Squad

{
  "default_provider": "claude",
  "providers": {
    "claude": {
      "refiner": "opus",
      "planner": "opus",
      "critic": "sonnet",
      "builder": "opus",
      "shield": "sonnet",
      "inspector": "sonnet",
      "ranger": "sonnet"
    },
    "codex": {
      "refiner": "gpt-5.2",
      "planner": "gpt-5.4",
      "critic": "gpt-5.4",
      "builder": "gpt-5.3-codex",
      "shield": "gpt-5.3-codex",
      "inspector": "gpt-5.4",
      "ranger": "gpt-5.3-codex"
    }
  },
  "reasoning_effort": {
    "codex": {
      "refiner": "medium",
      "planner": "high",
      "critic": "medium",
      "builder": "high",
      "shield": "medium",
      "inspector": "medium",
      "ranger": "medium"
    }
  }
}


# Squad Safety-First Principles

**Speed is not the goal. Doing it right is the goal.** These apply to every Squad skill
and every pipeline agent — read them before planning or implementing a card.

---

## Codebase-First Exploration (before planning)

- Don't assume — read the relevant files and existing patterns before you plan. A wrong
  assumption early quietly contaminates everything downstream.
- Map the existing interfaces, file structure, and dependencies, then fix scope.
- Follow patterns already in the codebase rather than inventing new ones.
- "It's probably wired like this" is forbidden — plan only from facts confirmed in the code.

## Card-Split Criteria

Split a card (or send it back to `/squad-refine`) if **any** hold:

- Estimated implementation time exceeds ~1 hour
- The change spans two or more layers (DB / service / UI / …)
- Rollback on failure would be complex — prefer small, reversible changes
- One or more requirements are still uncertain

## Pre-Flight Check (before status → `impl`)

- Is the card's completion condition (`done_when`) clear and **verifiable**?
- Are in-scope and out-of-scope stated, so the work can't drift?
- If this card fails, are the other cards unaffected?

## Done Means Verified (not "looks done")

- "Looks done" is not done. A card is complete only when its `done_when` checks have
  actually **run and passed** — show the evidence (the command run and its output,
  test results, build exit).
- Run the gates before handing off: format, lint, typecheck, tests; fix what fails.
- Fix the **root cause, not the symptom** — never suppress an error to make a check pass.

## Forbidden

- Starting implementation without refining first
- "Just ship it and clean up later" progress
- Expanding a card's scope mid-implementation
- Planning from assumptions without reading the codebase
- **Weakening a safeguard to pass review** — deleting or skipping tests, suppressing
  errors, or lowering a check instead of fixing the code


# Squad DB Schema & Data Formats

## Table: tasks

```sql
CREATE TABLE IF NOT EXISTS tasks (
  id SERIAL PRIMARY KEY,
  project TEXT NOT NULL,
  title TEXT NOT NULL,
  status TEXT NOT NULL DEFAULT 'todo',
  priority TEXT NOT NULL DEFAULT 'medium',
  description TEXT,
  plan TEXT,
  implementation_notes TEXT,
  tags TEXT,
  review_comments TEXT,
  plan_review_comments TEXT,
  test_results TEXT,
  agent_log TEXT,
  current_agent TEXT,
  plan_review_count INTEGER NOT NULL DEFAULT 0,
  impl_review_count INTEGER NOT NULL DEFAULT 0,
  version INTEGER NOT NULL DEFAULT 1,
  level INTEGER NOT NULL DEFAULT 3,
  attachments TEXT,
  notes TEXT,
  decision_log TEXT,
  done_when TEXT,
  rank INTEGER NOT NULL DEFAULT 0,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  started_at TIMESTAMPTZ,
  planned_at TIMESTAMPTZ,
  reviewed_at TIMESTAMPTZ,
  tested_at TIMESTAMPTZ,
  completed_at TIMESTAMPTZ
);
```

| Column | Type | Description |
|--------|------|-------------|
| `project` | TEXT | Project identifier |
| `status` | TEXT | `todo` / `plan` / `plan_review` / `impl` / `impl_review` / `test` / `done` |
| `priority` | TEXT | `high` / `medium` / `low` |
| `description` | TEXT | Requirements in markdown |
| `plan` | TEXT | Implementation plan in markdown |
| `implementation_notes` | TEX