> **TLDR**  -  four entry commands, two axes, and depth is no longer one of them:
>
> - **Depth** is a picker, not a flag. Phase 0 Step 7.5 asks Full or Short and sets `state.onlyDevelop`. Short strips to Init → Dev(Opus self-contained) → Review → Test → Commit → Report. Review is never stripped.
> - **`autopilot`** skips confirmations (Plan, Test, Commit, PR prompts) and therefore skips the depth question too, always running Full. Still fails safe on review blockers and build retries.
> - **`--local`** means no worktree: work happens in `$PROJECT_ROOT` on a local branch.
>
> Fastest path is `/multi-agent:local` then Short. There is no fast-and-unattended combination any more, and that is deliberate  -  see "Pipeline depth".

## Autopilot Mode

Autopilot mode skips interactive confirmations and runs the pipeline end-to-end autonomously.

**Activation**: Add `autopilot` flag to any pipeline command:

```
/multi-agent "PROJ-12345" autopilot
/multi-agent "https://{JIRA_HOST}/browse/PROJ-12345" autopilot
/multi-agent "https://github.com/.../issues/316" autopilot
/multi-agent "#316" autopilot
/multi-agent "LoginView dark mode fix" autopilot
```

**What changes in autopilot (Tablo 1  -  Full pipeline modes):**

| Phase               | Normal (full)                                           | autopilot (full)                            | local (full)                                | local autopilot (full)                      |
| ------------------- | ------------------------------------------------------- | ------------------------------------------- | ------------------------------------------- | ------------------------------------------- |
| Phase 2 (Plan Approval Gate) | Clarification (max 2 rounds) + approval loop  -  user: approve/abort/free-text edit | **Gate skip**  -  log the plan, proceed directly to Phase 3 (autopilot contract: zero interaction) | Same as Normal | Same as autopilot |
| Phase 5 (User Test) | Interactive prompt ("Want to test?" -> wait)            | Skip (autopilot suppresses interactive prompts) -> proceed directly to Phase 6 | **Not in the phase set** (the gate checks the change out of a worktree; local has none) | Not in the phase set |
| Phase 6 (Commit)    | "Want to commit?" -> wait                               | Auto commit + push                          | "Want to commit?" -> wait                   | Auto commit + push                          |
| Phase 6 (PR)        | "Want to open a PR?" -> wait                            | Auto create PR                              | "Want to open a PR?" -> wait                | Auto create PR                              |
| **Phase 7 (Channels)**  | Multi-select channel + content menu                 | **STILL PAUSES**  -  see "Phase 7 autopilot exception" below | Multi-select (same as Normal) | **STILL PAUSES** (same as autopilot) |

**What NEVER skips (even in autopilot):**

- Phase 4 Review -> if blocking finding, returns to Phase 3, auto fix + rebuild (safety)
- Kill/Purge confirmations -> destructive operations always ask
- Build fail -> auto fix + rebuild (max 3 retries). After 3 retries still failing -> pause, ask user
- **Circuit-breaker** -> autopilot halts (records reason, waits for `resume`) on a no-progress stall, an identical repeated failure, a rework storm, cost drift past the `costBudget` ceiling, or a merge/rebase conflict. Full wiring: `$HOME/.claude/multi-agent-refs/features/autopilot-circuit-breaker.md`. This is the sanctioned autopilot pause  -  continuing unattended off the happy path is the less safe choice.
- **Phase 7 channels dispatch** -> always pauses for multi-select. Rationale: Jira/Confluence are externally visible; silently posting wrong-tone content leaks team-visible artifacts. See below.

**State tracking**: `agent-state.json` gets `"autopilot": true`. Autopilot continues on resume as well.

### Phase 7 autopilot exception

The generic "zero-interaction" contract covers Phases 0-6 only. Phase 7 channels dispatch is the **single exception**:

- ALL modes (`autopilot`, `--local autopilot`, and a Short run reaching Phase 7) pause at the channels multi-select menu.
- Menu pre-ticks from `prefs.global.reportChannels` + `prefs.global.reportContent`  -  user can accept with one keypress if prefs are stable.
- **30-minute timeout**  -  if user does not respond, session ends cleanly:
  - External delivery aborted (no silent apply  -  prevents accidental Jira comments / Confluence pages).
  - Internal capture (`agent-log.md`, telemetry, knowledge base) STILL runs.
  - State persisted as `{phase: 7, waitingFor: "user-channels-choice", channelsTimeout: true}`.
  - Resume: `/multi-agent:resume <task-id>` re-opens menu with same inputs.
- Post-hoc `/multi-agent:channels <task>` never times out  -  user invoked it explicitly.

Full contract: `$HOME/.claude/multi-agent-refs/phases/phase-7-report.md` (Autopilot pause contract) + `commands/multi-agent/channels/SKILL.md`.

---

## Pipeline depth (Full / Short)

Short strips the pipeline to what an already-scoped task needs: no deep analysis, no planning phase. The **Opus** dev agent reads the task scope and implements, and Phase 4 then reviews what it produced. Review is deliberately NOT part of the strip: analysis and planning shape work that has not happened yet, so a task the user has already scoped can skip them, while review judges work that now exists and has no substitute.

**How it is chosen.** Phase 0 Step 7.5, after `taskType` is known:

```
Bu is icin hangi pipeline? / Which pipeline for this task?
  1. Tam / Full    Analysis -> Plan -> Dev -> Review -> Test -> Commit -> Report
  2. Kisa / Short  Dev (self-contained, Opus) -> Review -> Test -> Commit -> Report
```

`bugfix` and `chore` recommend Short; `feature`, `refactor` and `component` recommend Full. The recommendation is presented first and passed as `ASK_CHOICE_DEFAULT` on hosts without a native picker, because `ask-choice.sh` picks the first option on a non-TTY and option order is not a contract.

**Who is asked.** `/multi-agent` and `/multi-agent:local`. Both autopilot entries always run Full without asking.

**Why there is no fast-and-unattended combination.** It existed until v16.0.0 as `--dev autopilot`, and removing it is a real behaviour change, not a rename. Autopilot may not ask, so something has to choose, and unattended is the worst place to drop analysis and planning: nobody is watching to notice what the shortcut lost. A cron job or script that called `dev-autopilot` now has to pick - stay unattended and pay for the full pipeline, or stay fast and have a person present.

**Pipeline in a Short run:**

```
Phase 0: Init -> Phase 3: Dev (self-contained) -> Phase 4: Review -> Phase 5: Test -> Phase 6: Commit -> Phase 7: Report
```

**What changes (Tablo 2  -  Short runs):**

| Phase               | Full                                            | Short                                                                              | Short + `--local`                             |
| ------------------- | ----------------------------------------------- | ---------------------------------------------------------------------------------- | --------------------------------------------- |
| Phase 0 (Init)      | Full setup                                      | Same  -  worktree, branch, state, and the depth question itself                      | Same  -  no worktree, branch on `$PROJECT_ROOT` |
| Phase 1 (Analysis)  | Parallel Explore agents + analysis document     | **SKIP**  -  tile flips to `skipped` at Step 7.5                                     | **SKIP**                                      |
| Phase 2 (Planning)  | TaskCreate + architecture review + **Plan Approval Gate** | **SKIP** (no plan means no plan gate)                                    | **SKIP**                                      |
| Phase 3 (Dev)       | Follows the Phase 2 plan, TDD cycle (Sonnet)    | **Self-contained** (Opus): agent scans relevant files, implements with TDD, builds | Same, on the local branch                     |
| Phase 4 (Review)    | Parallel review + Fable triage (Claude: 2-model / Copilot: 3-model) | **Same**  -  gates, parallel review, triage; blocking findings return to Phase 3 (cap 3) | **Same**, on the local branch diff |
| Phase 5 (User Test) | Interactive prompt                              | **Interactive prompt**                                                             | Not in the set  -  no worktree to check out    |
| Phase 6 (Commit)    | Commit + PR                                     | Same  -  still asks                                                                  | Same                                          |
| Phase 7 (Report)    | Full report + channels multi-select             | Simplified  -  no analysis section, review section IS present, channels menu still pauses | Same                              |

**Phase 3 in a Short run (self-contained):**

The **Opus** agent receives the task description (from Jira, GitHub issue, or free-text) and:

1. Quickly scans relevant files in the codebase (lightweight, not full Explore)
2. Implements the change following TDD cycle (test -> code -> build)
3. Runs build verification (max 3 retries on failure)

No separate task breakdown  -  the agent handles scope autonomously.

**State tracking**: `agent-state.json` gets `"onlyDevelop": true`. Because the tracker boots at Step -1 and the answer arrives at Step 7.5, Phases 1 and 2 are registered `pending` with everything else and flipped to `skipped` when the answer lands; pre-marking is forbidden and would scramble the tile order. Full contract: `$HOME/.claude/multi-agent-refs/tracker-contract.md` section "Late skip".

### Intake warnings for a Short run

**An analysis document was supplied.** Because Phase 1 and Phase 2 are skipped, no phase turns that document into a task breakdown. The doc becomes raw context for one Dev pass, and work comes out ordered by whatever the model read first: the bottom of the dependency chain lands, the screen wiring does not.

The depth picker is where this is caught. When the intake carried an analysis document or a Figma reference, say so in the question itself rather than after the choice:

```
This task carries an analysis document. Short skips Analysis and Planning, so
the document will not be turned into a task breakdown.
  1. Tam / Full    (recommended here)
  2. Kisa / Short  (doc as context only)
```

Autopilot never sees this: it runs Full.

**The branch already carries the work.** When the change was developed outside the pipeline, or by hand, Short is still the wrong entry point: it will try to develop again. `/multi-agent:resume-local` puts the existing diff through the same review, adds a build+test success gate, opens the PR, and posts the Jira technical-analysis + test-scenario comment  -  without re-developing. Offer it when the working tree or branch is already ahead of the base with the task's changes.

---

## Analysis Mode (`/multi-agent:analysis`)

Not a depth permutation - a different **output kind**. It produces the analysis document and stops; no code, no branch, no PR. The 8-phase contract holds, with four phases reinterpreted the same way a Short run reinterprets Phase 3.

```
Phase 0: Init -> Phase 1: Analysis -> Phase 2: Planning -> Phase 4: Review -> Phase 6: Publish -> Phase 7: Report
```

| Phase | Analysis mode |
|---|---|
| 0 Init | Same intake, but **no worktree**: nothing is isolated because nothing is built, so `state.run.repoPath` is the repo itself |
| 1 Analysis | The engine (`multi-agent-refs/analysis/*`): evidence, synthesis, render, humanizer, `validate-analysis-doc.mjs` |
| 2 Planning | Synthesis and render finish here; **no task decomposition** - there is no code to plan |
| 3 Dev | **SKIP** |
| 4 Review | Document review plus the open questions still marked `Acik / Open` |
| 5 Test | **SKIP** |
| 6 Commit | **Publish** instead: Local file / Confluence / Jira. Locked 6 still forbids `git add` and `git commit` |
| 7 Report | Channels, same as every mode |

**No `local` or `autopilot` variant.** Worktree isolation buys nothing when no code is written, and the intake, the Pass B convention preview and the open-question resolution are interactive by nature; a zero-interaction analysis would be a document nobody agreed to.

**Where the document lands.** Drafts go to `/tmp/analysis-<slug>-<ts>/` first, then the Phase 6 picker decides: Local writes `<repo>/analysis/<feature>-<platform>.md` uncommitted, Confluence posts the page, Jira updates the description. In the full pipeline the same engine writes into the worktree instead and `prefs.global.analysisPhase.commitDoc` decides whether it rides along with the commit.

---

## Local Mode (`--local`)

Local mode skips worktree creation  -  works directly on a local branch in the project root. Useful for single-task workflows or when worktrees cause issues.

**Activation**: the `:local` entries, or `--local` on the base command:

```
/multi-agent:local "PROJ-12345"
/multi-agent:local "#316"
/multi-agent:local "LoginView dark mode fix"
/multi-agent:local-autopilot "PROJ-12345"
/multi-agent "PROJ-12345" --local
```

**What changes in local mode:**

| Phase          | Normal (worktree)                                | Local                                                          |
| -------------- | ------------------------------------------------ | -------------------------------------------------------------- |
| Phase 0 Step 8 | Creates worktree at `.worktrees/{id}/`           | `git checkout -b {branch}` directly in `$PROJECT_ROOT`         |
| Phase 3        | Works in worktree path                           | Works in `$PROJECT_ROOT`                                       |
| Phase 5        | WIP commit -> remove worktree -> checkout branch | **Not in the phase set**  -  nothing to check out, nothing to remove |
| Phase 6        | Commit in worktree, push                         | Commit in project root, push                                   |
| All paths      | `{worktreePath}` references                      | All paths use `$PROJECT_ROOT` directly                         |

**Phase 0 Step 8 in local mode:**

```bash
# Instead of creating worktree:
git -C $PROJECT_ROOT fetch origin
git -C $PROJECT_ROOT checkout -b {branch} origin/{baseBranch}
git -C $PROJECT_ROOT config user.name "{identity.name}"
git -C $PROJECT_ROOT config user.email "{identity.email}"
```

**Phase 5 in local mode:** it is not in the phase set. The gate exists to hand the user a change checked out of a worktree, and in local mode the code is already on the branch in `$PROJECT_ROOT` with nothing to check out or remove. `gen-mode-dispatch.mjs --mode=local` is the enforced statement of this; the row above mirrors it.

**State tracking**: `agent-state.json` gets `"localMode": true`, `"worktreePath": null`. All path references resolve to `$PROJECT_ROOT`.

**Limitations:**

- Cannot run parallel tasks on same project (no worktree isolation)
- Uncommitted changes in PROJECT_ROOT may conflict  -  pipeline warns if dirty
- Build queue lock still applies for xcodebuild

**Combinable**: `/multi-agent:local-autopilot` is the no-worktree unattended path; `/multi-agent:local` then Short is the no-worktree fast path.