@mmerterden/multi-agent-pipeline 19.1.4 → 20.0.0

package/pipeline/skills/shared/core/multi-agent-ios-coding-standard/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: multi-agent-ios-coding-standard
 language: en
-description: "Audit an iOS module against the shared coding-standard registry (99 stable-ID rules), produce a remediation plan, then hand off to /multi-agent or :local. Use for a standards pass on a module, or when a review needs rule IDs rather than opinions."
+description: "Audit an iOS module against the shared coding-standard registry (99 stable-ID rules), produce a remediation plan, then hand off to /multi-agent. Use for a standards pass on a module, or when a review needs rule IDs rather than opinions."
 user-invocable: true
 argument-hint: "[module name or path]"
 ---
@@ -237,10 +237,9 @@ Show a concise version of the plan to the user too.
 
 | Option | What it does |
 |---|---|
-| `/multi-agent:local` | No worktree; branches from the main development branch, fixes on the current checkout |
 | `/multi-agent` | Opens a worktree; fixes on a fresh branch + PR |
 
-Both ask Full or Short at Phase 0 Step 7.5; a standards sweep is usually already scoped, so Short is the common answer.
+Both run the whole pipeline; a standards sweep is usually already scoped, so Phase 1 has little to say and its document is short.
 
 Invoke the chosen command with the plan file as the task input, branching off the repo's main
 development branch (e.g. `chore/<module>-coding-standard`). The dev pipeline applies the fixes,

package/pipeline/skills/shared/core/multi-agent-resume/SKILL.md

@@ -1,31 +1,67 @@
 ---
 name: multi-agent-resume
 language: en
-description: "Resume a stopped or failed task from the phase where it left off. Use when a task stopped or failed and should carry on from where it left off."
+description: "Pick up unfinished work: a pipeline run that stopped mid-phase, or work already written on the current branch that never went through the pipeline. Use when a task stopped or failed, or when hand-written local work needs review, build, PR and reporting."
 user-invocable: true
-argument-hint: "[#id]  -  optional: task ID (e.g. #2). If omitted, the most recent paused task is used."
+argument-hint: "[#id | PROJ-12345] [--base <branch>] [autopilot]  -  no argument: pick from the list"
 ---
 
-# multi-agent resume  -  Resume Paused Task
+# multi-agent resume  -  Continue Unfinished Work
 
 **Input**: $ARGUMENTS
 
-Resume a paused or failed task from the last successful phase.
+Unfinished work arrives from two directions, and which one applies is a property of the repository, not of how the command was typed:
+
+- **A tracked run stopped.** It has an `agent-state.json`, a phase it was inside, and possibly a worktree. It resumes from where it stopped.
+- **Work exists on the current branch with no run behind it.** Nothing to resume, so the **pipeline tail** runs over the diff. Plan and Dev never run; the diff is the Dev output.
+
+Step 1 finds both and asks, so the user does not have to know which case they are in before asking the question.
+
+## Input
+
+```bash
+multi-agent resume                    # list everything resumable, pick one
+multi-agent resume #2                 # a tracked run by task number
+multi-agent resume PROJ-12345         # a tracked run by Jira id, or bind the tail to that id
+multi-agent resume --base develop     # tail path: override the base branch for the diff
+multi-agent resume autopilot          # no gate prompts: auto-fix, auto-PR, auto-comment
+```
 
 ## Steps
 
-1. **Find task**  -  Parse `#N` from the argument, or find the most recent worktree with `status != "done"`
+1. **Build the resumable list, then ask.** Source A: every `agent-state.json` under `$HOME/.claude/logs/multi-agent/{project}/` with `status != "done"`, each row showing task id, the phase it stopped inside, its workspace (worktree path, or `local`), age, and `haltReason` when set. Source B: the current branch, when `git diff <base>...HEAD` plus working-tree changes is non-empty **and** no Source A run owns that branch. An argument naming a run selects it directly; an argument naming nothing resumable is an error, never a silent fall-through to the tail. Nothing in either source: `ERR: nothing to resume` - do not ask.
+
+   Ask per `$HOME/.claude/multi-agent-refs/picker-contract.md` (Copilot CLI: `$HOME/.claude/lib/ask-choice.sh`). Breadcrumb `Step 1/1: which unfinished work to pick up` above the picker, in `outputLanguage`; labels carry the task id and branch name verbatim, and the run branches on which row was selected rather than on the label text. A single row is still a question and needs a genuine second option: **Show every run** (drops the `status != "done"` filter) when the only row is a stopped run, **Pick a stopped run instead** when the only row is the branch diff.
+
+2. **Tracked run  -  read and validate state.** `validate-state.mjs` first; on non-zero exit do NOT guess a phase. Read `currentPhase`, `status`, `haltReason`, `circuitBreaker`, `autopilot`. Heal a stale worktree lock before continuing  -  unless `worktreeRemovedAt` is set, in which case the artefacts live under `artifactsPath` and the worktree must not be recreated.
+
+3. **Tracked run  -  load context** from durable artifacts, never from conversation memory: the latest `## Handoff` block in `agent-log.md` first, per-phase findings as the fallback, `git log --oneline -10` to ground what was actually committed.
+
+4. **Tracked run  -  rebuild the phase tiles** from `tracker-state.json`, never re-initialized. Copilot CLI: a single `phase-tracker.sh render`.
+
+5. **Tracked run  -  continue.** Read `state.waitingFor` FIRST: when it names a step (`maturity`, `user-channels-choice`, `local-test`), the run re-enters THAT step. `currentPhase + 1` is the fallback, not the rule. Clear `waitingFor` in the same write that records the answer.
+
+6. **Untracked branch work  -  resolve context.** Base branch: `--base` → `figma-config.project.baseBranch` → `develop` → upstream/merge-base. Jira id from the argument or the branch name. State under `$HOME/.claude/logs/multi-agent/{project}/{taskId}/`. No worktree is created.
+
+7. **Untracked branch work  -  run the tail.**
+
+```
+Phase 0: Init          → project/branch detect, base + diff, Jira id, state (NO worktree)
+Phase 3: Review        → the Verify gate first (stack-aware build + existing tests; SUCCESS required), then
+                         parallel review (GPT + Opus + Sonnet) + triage
+Phase 4: Commit        → commit remaining changes + push + open PR if none exists
+Phase 5: Report        → technical analysis + Jira comment with test scenarios (channels: Jira / PR / Confluence / Wiki)
+```
+
+The build that Dev's exit gate would have run happens inside Review instead, because there is no Dev run to inherit a log from.
 
-2. **Read state**  -  Parse `agent-state.json`:
-   - `currentPhase`  -  last completed phase
-   - `status`  -  `paused` | `failed` | `in_progress`
-   - `autopilot`  -  preserve the mode
+## Notes
 
-3. **Load context**  -  Read the findings of previous phases from `agent-log.md`:
-   - Phase 1 analysis → use in Phase 2+
-   - Phase 1 plan → use in Phase 2+
-   - Phase 3 code → already present in the worktree
+- Build+Test is the automated success gate (the interactive device user-test is `multi-agent:manual-test`). If the repo has no tests, it reports "no tests present"  -  never fabricates results.
+- `autopilot` (or `prefs.global.resume.autoFix == true`) auto-fixes triage-accepted blocking/important findings and re-reviews the fix before advancing.
+- Commit/PR follows house rules: conventional message, `Ref: #N` (never Closes/Fixes), NO AI/bot attribution. PR opened only if one does not already exist.
+- Full phase contract lives in the Claude Code command `commands/multi-agent/resume/SKILL.md`; this skill is the Copilot-CLI counterpart.
 
-4. **Continue the pipeline**  -  Start from where it left off (same pipeline as the main multi-agent command)
+## Required: outward-facing payload contracts
 
-5. **Log**: `🔄 Resumed PROJ-{id} from Phase {N}`
+Before writing anything outward-facing  -  PR body, Jira comment, Confluence page, closing report  -  load `$HOME/.claude/multi-agent-refs/payload-contracts.md`. It names the canonical section set for each payload, the markup dialect per surface (PR body is Markdown, Jira is wiki markup  -  mixing them is a defect), and the token/duration numbers the closing report must carry. Improvising a payload shape from memory is the most common failure of a run that starts in the middle.

package/pipeline/skills/shared/core/multi-agent-sync/SKILL.md

@@ -32,8 +32,8 @@ Run all steps automatically:
 ```
 Step 0: DOCTOR      node $HOME/.claude/scripts/doctor.mjs  -  exit 2 or 4 STOPS the sync
 Step 1: DETECT      Compare timestamps, find stale targets
-Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 60 sub-command skills)
-Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 60 specs as refs + 8 agent TOML)
+Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 57 sub-command skills)
+Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 57 specs as refs + 8 agent TOML)
 Step 3: REPO        Claude Code -> pipeline repo (genericized, personal data scrub)
 Step 3d: DEV-TOOLKIT Companion MCP server -> detect movement, ship gates, commit + publish
 Step 4: WEBSITE     Version + phase/model counts -> {website-host} (i18n + projects.ts)
@@ -63,7 +63,7 @@ If nothing is stale -> report "All targets up to date" and stop.
    - `copilot-instructions.md`: general development instructions + pipeline summary section
    - `multi-agent-pipeline/pipeline/`: generic open-source version (NO personal data)
 3. **Sync shared sections** (Claude <-> Copilot):
-   - Pipeline entries table (base / :local / :autopilot / :local-autopilot) + the Full-or-Short depth question
+   - Pipeline entries table (base / :autopilot)
    - Project detection (URL-based + cwd-based)
    - Figma pipeline flow
    - Git conventions (author, branch, commit format)
@@ -228,15 +228,15 @@ When invoked with the `release` argument:
 |-------------|-------------|
 | `~/.claude/commands/multi-agent/{cmd}/SKILL.md` | `~/.copilot/skills/multi-agent-{cmd}/SKILL.md` |
 
-**60 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
+**57 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
 
 ```
 analysis, analysis-jira, analysis-resolve, autopilot, autopilot-off,
 autopilot-on, autopilot-status, build-optimize, channels, complaint-analysis,
 create-jira, design-check, diff-explain, doctor, feedback, forget,
 garbage-collect, graph, help, ios-coding-standard, issue, jira, kill,
-language, local, local-autopilot, log, manual-test, model, prune-logs,
-prune-prompts, purge, refactor, resume, resume-local, review,
+language, log, manual-test, model, prune-logs,
+prune-prompts, purge, refactor, resume, review,
 review-analysis, review-issue, review-jira, route-off, route-on,
 route-status, routines, save, scan, search,
 setup, stack, status, steer, store-ready, sync, test, test-accessibility,

package/pipeline/skills/skills-index.md

@@ -3,7 +3,7 @@
 > Auto-generated by `pipeline/scripts/build-skills-index.mjs`  -  do not hand-edit.
 > Regenerate with `node pipeline/scripts/build-skills-index.mjs`.
 
-**216 skills** across 2 groups.
+**213 skills** across 2 groups.
 
 | Group | Name | Platform | Description |
 |-------|------|----------|-------------|
@@ -117,17 +117,14 @@
 | core | `multi-agent-jira` |  -  | List open Jira issues, pick one, and launch the multi-agent pipeline. Use when a Jira issue should be picked up and started without knowing  |
 | core | `multi-agent-kill` |  -  | Stop the given task, then remove its worktree and branch. Asks for confirmation. Use when a running or stuck task should be stopped and its  |
 | core | `multi-agent-language` |  -  | Toggle outputLanguage (assistant explanations, picker questions, PR/Jira/Confluence bodies). promptLanguage is fixed to English; commit mess |
-| core | `multi-agent-local` |  -  | Full pipeline in local mode  -  no worktree, runs directly on the current branch. Use when the full pipeline should run on the current branc |
-| core | `multi-agent-local-autopilot` |  -  | Full pipeline + local + autopilot  -  no worktree, no confirmations, all 6 phases run end-to-end on the current branch. Use when the full pi |
 | core | `multi-agent-log` |  -  | Show the agent-log.md for the given task. With no ID, shows the most recent task. Use when asked what a task did, or to read its log. |
-| core | `multi-agent-manual-test` |  -  | Switch to the active task's branch and prepare it for manual testing in Xcode. Phase 5 standalone (the UI Bug Hunter lives at multi-agent-te |
+| core | `multi-agent-manual-test` |  -  | Switch to the active task's branch and prepare it for manual testing in Xcode. Phase 3 user-test step, standalone (the UI Bug Hunter lives a |
 | core | `multi-agent-model` |  -  | Turn the top model rung on or off and keep the cost ledger's pricing in step with it. Use when asked to enable or disable Fable, or which mo |
 | core | `multi-agent-prune-logs` |  -  | Delete per-task project logs under ~/.claude/logs/multi-agent (filter by age/project/task). Audit trail + metrics are preserved. Dry-run fir |
 | core | `multi-agent-prune-prompts` |  -  | Zero-base prompt review: measure the always-on instruction footprint, classify every rule block, propose keep/trial-removal/delete; applies  |
 | core | `multi-agent-purge` |  -  | ⚠️ Wipes every worktree, branch, log, and state file. Irreversible; asks for double confirmation. Use when every worktree, branch, log and s |
 | core | `multi-agent-refactor` |  -  | Analyse the project: extract adapted best-practices, hunt real bugs + improvement areas, check upstream drift of derived skills, research th |
-| core | `multi-agent-resume` |  -  | Resume a stopped or failed task from the phase where it left off. Use when a task stopped or failed and should carry on from where it left o |
-| core | `multi-agent-resume-local` |  -  | Continue already-done LOCAL work through the pipeline tail: Review (with its build gate) → Commit/PR → Report (technical analysis + Jira tes |
+| core | `multi-agent-resume` |  -  | Pick up unfinished work: a pipeline run that stopped mid-phase, or work already written on the current branch that never went through the pi |
 | core | `multi-agent-review` |  -  | Run parallel review on a branch diff or a Pull Request: 3 models on Claude Code (Fable + Opus + Sonnet), 3 models on Copilot CLI (GPT + Opus |
 | core | `multi-agent-review-analysis` |  -  | Review a written analysis document instead of a diff: resolve it from a path, a Confluence page or a Jira issue, run the deterministic gates |
 | core | `multi-agent-review-issue` |  -  | Assess whether a GitHub issue is ready for multi-agent development: fetch it, grade scope / acceptance criteria / repro / design / API / sta |

package/pipeline/commands/multi-agent/local/SKILL.md

@@ -1,132 +0,0 @@
----
-description: "Full pipeline in local mode  -  no worktree, runs directly on the current branch. Use when the full pipeline should run on the current branch without creating a worktree."
-description-tr: "Tam pipeline lokal modda - worktree yok, doğrudan mevcut branch üzerinde çalışır."
-allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, AskUserQuestion, WebFetch, WebSearch, Skill
----
-
-# multi-agent local  -  Full Pipeline, Local Branch
-
-> **Language (read FIRST)**: Before any status output, read `prefs.global.outputLanguage` and render every conversational line in it. `AskUserQuestion` renders its `question`, option `label`s and option `description`s in `outputLanguage`; only `header` stays English (<=12-char chip); external payload bodies follow `outputLanguage` too (identifiers, commit messages, branch names stay English). Full contract: `$HOME/.claude/multi-agent-refs/rules.md` "Language Application".
-
-The full pipeline in normal mode (Plan Approval Gate + parallel review + triage included), running on the **current branch with no worktree**. Dedicated alias for the `multi-agent "task" --local` flag form. Phase 5 (User Test) is skipped because there is no worktree to check the change out from; the other seven phases all run.
-
-## When to use it
-
-- You don't want a separate worktree open  -  keeps the editor / IDE in one folder
-- You're already on the right branch and just want pipeline discipline
-- Small project or prototype  -  the worktree overhead is unnecessary
-
-## When NOT to use it
-
-- Multiple parallel tasks at the same time  -  you lose worktree isolation
-- Long-iteration changes on a production repo  -  branch-switch friction shows up
-- Multi-repo tasks  -  `--local` is locked to a single repo
-
-## Pipeline
-
-Same phase count and order as the normal pipeline:
-
-```
-Phase 0: Init       → project detection, branch check, state (NO worktree)
-Phase 1: Plan (analysis)   → codebase scan (parallel explore agents, Opus)
-Phase 1: Plan   → task breakdown, Plan Approval Gate (approval loop)
-Phase 2: Dev        → TDD (Sonnet), build queue
-Phase 3: Review     → deterministic gates + parallel review + Fable triage
-Phase 4: Commit     → pre-commit checkout prompt, commit + push + PR
-Phase 5: Report     → Jira / Wiki / Confluence + log + knowledge/memory
-```
-
-## Delegation
-
-This command routes to the orchestrator with the `--local` flag set. The Phase 0-7 contract from `$HOME/.claude/multi-agent-refs/phases/phase-0-init.md` and the later phase docs applies as-is  -  only the worktree step is skipped, and `state.projects[*].worktreePath` stays `null`.
-
-Read the routing table in `$HOME/.claude/commands/multi-agent/SKILL.md` and apply Phase 0 Step 8 in local mode (no worktree: continue on the current branch, state file under `.claude/logs/multi-agent/{project}/{taskId}/`).
-
-## Examples
-
-```bash
-/multi-agent:local "PROJ-12345"                                # Jira
-/multi-agent:local "#42"                                        # GitHub issue
-/multi-agent:local "LoginView dark mode fix"                    # Free-text
-```
-## Required: outward-facing payload contracts
-
-Before writing anything outward-facing  -  PR body, Jira comment, Confluence page, closing report  -  load `$HOME/.claude/multi-agent-refs/payload-contracts.md`. It names the canonical section set for each payload, the markup dialect per surface (PR body is Markdown, Jira is wiki markup  -  mixing them is a defect), and the token/duration numbers the closing report must carry. Improvising a payload shape from memory is the most common failure of the short modes.
-
-## Required: Phase Tracker Contract
-
-**The phase tracker is mandatory**  -  the agent cannot skip it. Full spec: [`$HOME/.claude/multi-agent-refs/tracker-contract.md`]($HOME/.claude/multi-agent-refs/tracker-contract.md).
-
-> **Local mode:** no worktree is created, work happens on the current branch. Phase 0 Init still calls `init`  -  the `--local` flag is stored in tracker-state.json, and `:resume` restores the correct CWD.
-
-Two channels run in parallel at every phase boundary:
-
-1. **State channel** (every CLI, identical): `phase-tracker.sh` writes to `tracker-state.json`. Drives `:resume`, `:log`, `:status`.
-2. **Visual channel** (CLI-specific): native widget on Claude Code, ANSI render on every other CLI. Without it the user sees no phase progress.
-
-```bash
-# Phase 0, very first shell call (every CLI):
-bash $HOME/.claude/scripts/phase-tracker.sh init "$TASK_ID"
-bash $HOME/.claude/scripts/phase-tracker.sh add 0 "Init"
-bash $HOME/.claude/scripts/phase-tracker.sh tiles
-bash $HOME/.claude/scripts/phase-tracker.sh update 0 in_progress
-
-# Phase 0 Step 7.5, immediately after the depth answer - the first moment this
-# mode knows its phase set. Full:
-for p in "1:Plan" "2:Dev" "3:Review" "4:Commit" "5:Report"; do
-  bash $HOME/.claude/scripts/phase-tracker.sh add "${p%%:*}" "${p#*:}"
-done
-# Short (Analysis and Planning are not run, so they get no tile at all):
-for p in "2:Dev" "3:Review" "4:Commit" "5:Report"; do
-  bash $HOME/.claude/scripts/phase-tracker.sh add "${p%%:*}" "${p#*:}"
-done
-# Then the widget, narrowed to the phases that do not have a tile yet:
-bash $HOME/.claude/scripts/phase-tracker.sh tiles --new
-
-# Every phase boundary (every CLI):
-bash $HOME/.claude/scripts/phase-tracker.sh update <N> in_progress|completed|failed|skipped
-
-# After every LLM call (every CLI):
-bash $HOME/.claude/scripts/phase-tracker.sh tokens <N> <in> <out> [cached]
-```
-
-### Visual channel  -  Claude Code (native TaskList widget, required)
-
-In Claude Code the agent MUST also drive the native TaskList widget so the user sees a sticky phase tile stack  -  this is the only progress signal Claude Code surfaces. Skipping these calls is the #1 source of "I don't see any phases" complaints.
-
-**TaskCreate ordering (strict)**: All TaskCreate calls in a registration batch fire in strict phase-number order BEFORE any TaskUpdate in that batch, and a later batch only ever appends phases numbered above everything already registered. This mode registers in two batches (Step -1, then Step 7.5), so `tiles --new` narrows the second one and the Phase 0 tile is never created twice. The native widget renders by creation order, not by phase number  -  out-of-order calls produce visually scrambled tile stacks (e.g. `1 ✓ · 2 ✓ · 4 ✓ · 0 ▶ · 3 ☐`) even when the underlying state is correct. Pre-marking phases as completed/skipped before Phase 0 starts is FORBIDDEN  -  register the tile in order, then flip status via TaskUpdate when the phase actually short-circuits. Full contract in `$HOME/.claude/multi-agent-refs/tracker-contract.md` section "TaskCreate ordering (strict)".
-
-```text
-# Register one tile per phase, capture the taskId, persist it:
-for each phase in 0:Init at Step -1, then 1:Plan, 2:Dev, 3:Review, 4:Commit, 5:Report (Full) or 2:Dev, 3:Review, 4:Commit, 5:Report (Short) at Step 7.5:
-  TaskCreate({ subject: "Phase <N>: <Name>", activeForm: "<doing-form>" })
-    -> returns taskId
-  bash $HOME/.claude/scripts/phase-tracker.sh meta <N> tasklist_id "<taskId>"
-
-# Phase entry  -  flip the tile to in_progress alongside the state update:
-TaskUpdate({ taskId: <saved>, status: "in_progress" })
-bash $HOME/.claude/scripts/phase-tracker.sh update <N> in_progress
-
-# Active sub-step inside a phase  -  update activeForm so the spinner header reflects what's happening now:
-TaskUpdate({ taskId: <saved>, activeForm: "Editing TopBarView.swift" })
-
-# Phase exit  -  flip to completed/failed/skipped on both channels:
-TaskUpdate({ taskId: <saved>, status: "completed" })
-bash $HOME/.claude/scripts/phase-tracker.sh update <N> completed
-```
-
-`--local` mode TaskCreates all 6 phases (no phase is skipped).
-
-#### TaskCreate ordering (strict)
-
-**All TaskCreate calls in a batch fire in strict phase-number order BEFORE any TaskUpdate is applied.** For `--local` that means: Phase 0 at Step -1, then the rest in ascending order at Step 7.5 (Phase 0 → Phase 1 → Phase 2 → Phase 3 → Phase 4 → Phase 5 minus whatever the depth answer drops). The native widget renders by creation order, not by phase number  -  out-of-order calls produce visually scrambled tile stacks. Full ordering contract in `$HOME/.claude/multi-agent-refs/tracker-contract.md` section "TaskCreate ordering (strict)".
-
-### Visual channel  -  Copilot CLI / plain shell
-
-These CLIs have no TaskList widget. After every state change the agent calls render, which prints a bordered ANSI card as the last tool result so the user sees an updated phase table:
-
-```bash
-bash $HOME/.claude/scripts/phase-tracker.sh render
-```
-
-Do NOT call TaskCreate on these CLIs  -  the tool does not exist and the call fails.

package/pipeline/commands/multi-agent/local-autopilot/SKILL.md

@@ -1,142 +0,0 @@
----
-description: "Full pipeline + local + autopilot  -  no worktree, no confirmations; runs all 6 phases end-to-end on the current branch. Use when the full pipeline should run on the current branch with no worktree and no prompts."
-description-tr: "Tam pipeline + lokal + autopilot - worktree yok, onay yok; 6 fazı mevcut branch üzerinde uçtan uca koşar (kullanıcı testi Review'ın içinde, autopilot'ta atlanır)."
-argument-hint: '"task"  -  issue URL, Jira ID, free-text, or #id (for resume)'
-allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, AskUserQuestion, WebFetch, WebSearch, Skill
----
-
-# multi-agent local-autopilot  -  Full Pipeline, Local Branch, Autonomous
-
-**Input**: $ARGUMENTS
-
-> **Language (read FIRST)**: Before any status output, read `prefs.global.outputLanguage` and render every conversational line in it. `AskUserQuestion` renders its `question`, option `label`s and option `description`s in `outputLanguage`; only `header` stays English (<=12-char chip); external payload bodies follow `outputLanguage` too (identifiers, commit messages, branch names stay English). Full contract: `$HOME/.claude/multi-agent-refs/rules.md` "Language Application".
-
-Run the full pipeline **without a worktree** and **with every confirmation skipped**. All six phases execute. The user test inside Phase 3 Review is skipped  -  there is no worktree to check out from and no interaction to have  -  but it stopped being a phase of its own in v19.0.0, so nothing is dropped from the set. The `autopilot + local` combination  -  vs `/multi-agent:autopilot` the only difference is no worktree (work stays on the current branch); vs `/multi-agent:local` the only difference is zero interaction.
-
-## Matrix (which one should I use?)
-
-| Command | Pipeline | Worktree | Confirmations |
-|---|---|---|---|
-| `/multi-agent "task"` | 6 phases, user test offered | ✅ | ✅ (interactive) |
-| `/multi-agent:autopilot "task"` | 6 phases, user test skipped | ✅ | ❌ (autopilot) |
-| `/multi-agent:local "task"` | 6 phases, user test offered | ❌ | ✅ (interactive) |
-| **`/multi-agent:local-autopilot "task"`** | **6 phases, user test skipped** | **❌** | **❌ (autopilot)** |
-
-Depth is a separate axis, asked at Phase 0 Step 7.5 rather than encoded in the command name: Full runs every phase above, Short runs Dev → Review → Test → Commit → Report. The two autopilot rows never ask and always run Full.
-
-## What changes
-
-**vs `/multi-agent:autopilot`**: no worktree is created; work stays on the current branch. The task runs in the same editor / IDE session  -  no second folder.
-
-**vs `/multi-agent:local`**: Phase 2 Plan Approval Gate is skipped (the safety classifier still runs) and Phase 4 commit / PR runs without confirmation. Both modes already skip Phase 5 (User Test) because neither has a worktree, so the same seven phases execute  -  review / triage / build discipline are preserved.
-
-## When to use it
-
-- You want full-pipeline discipline (parallel review + triage) on a small task but want to step away from the keyboard
-- Single repo + simple branch  -  the worktree overhead is unnecessary; autopilot + local = clean flow
-- Repro-to-fix loop: try things quickly in the local folder, then fire the pipeline forget-and-go on the same branch
-
-## When NOT to use it
-
-- Multiple parallel tasks  -  you lose worktree isolation; branch collisions
-- Security-path or schema-migration changes  -  the Phase 2 safety classifier auto-pauses (`autopilotSafetyGate`, default on)
-- Multi-repo  -  `--local` is locked to a single repo
-
-## Never skipped (even with autopilot + local)
-
-- 🔴 **Review-blocking finding** → auto fix + rebuild (max 3 retries)
-- 💥 **Build failure** → auto fix + rebuild (max 3 retries, then pause)
-- 🛡️ **Safety classifier pause**  -  for high-risk plans, asks once for manual confirmation even in autopilot
-- ⚠️ **Kill / Purge** → always asks for confirmation (destructive)
-
-## Usage
-
-```bash
-/multi-agent:local-autopilot "{JIRA-KEY}-12345"
-/multi-agent:local-autopilot https://github.com/org/repo/issues/316
-/multi-agent:local-autopilot "LoginView dark mode fix"
-/multi-agent:local-autopilot "#3"          # resume a stopped task in local-autopilot mode
-```
-
-## Steps
-
-1. **Parse input**  -  standard multi-agent input formats.
-2. **Set both flags**  -  write `"autopilot": true` and `"local": true` into `agent-state.json`.
-3. **Launch the multi-agent pipeline**  -  Phase 0 worktree step is skipped (local contract), Phase 2/5/6 confirmations are skipped (autopilot contract), Phase 4 safety classifier runs.
-4. **On error**  -  after 3 failed retries, pause and ask the user.
-
-## Delegation
-
-Orchestrator routing: the routing table in `$HOME/.claude/commands/multi-agent/SKILL.md` resolves `local-autopilot` as the union of the `local` + `autopilot` mode mixins. Contract details: `$HOME/.claude/multi-agent-refs/phases/phase-0-init.md` Step 6 (local branch) + `$HOME/.claude/multi-agent-refs/phases/phase-1-plan.md` Step 5 (autopilot gate skip + safety classifier).
-## Required: outward-facing payload contracts
-
-Before writing anything outward-facing  -  PR body, Jira comment, Confluence page, closing report  -  load `$HOME/.claude/multi-agent-refs/payload-contracts.md`. It names the canonical section set for each payload, the markup dialect per surface (PR body is Markdown, Jira is wiki markup  -  mixing them is a defect), and the token/duration numbers the closing report must carry. Improvising a payload shape from memory is the most common failure of the short modes.
-
-## Required: Phase Tracker Contract
-
-**The phase tracker is mandatory**  -  the agent cannot skip it. Full spec: [`$HOME/.claude/multi-agent-refs/tracker-contract.md`]($HOME/.claude/multi-agent-refs/tracker-contract.md).
-
-> **Autopilot mode:** user confirmations are skipped. The tracker is still mandatory  -  autopilot agent calls cannot skip it; skipping breaks `smoke-tracker-contract.sh`.
-
-> **Local mode:** no worktree is created, work happens on the current branch. Phase 0 Init still calls `init`  -  the `--local` flag is stored in tracker-state.json, and `:resume` restores the correct CWD.
-
-Two channels run in parallel at every phase boundary:
-
-1. **State channel** (every CLI, identical): `phase-tracker.sh` writes to `tracker-state.json`. Drives `:resume`, `:log`, `:status`.
-2. **Visual channel** (CLI-specific): native widget on Claude Code, ANSI render on every other CLI. Without it the user sees no phase progress.
-
-```bash
-# Phase 0, very first shell call (every CLI):
-bash $HOME/.claude/scripts/phase-tracker.sh init "$TASK_ID"
-for p in "0:Init" "1:Plan" "2:Dev" "3:Review" "4:Commit" "5:Report"; do
-  bash $HOME/.claude/scripts/phase-tracker.sh add "${p%%:*}" "${p#*:}"
-done
-bash $HOME/.claude/scripts/phase-tracker.sh update 0 in_progress
-
-# Every phase boundary (every CLI):
-bash $HOME/.claude/scripts/phase-tracker.sh update <N> in_progress|completed|failed|skipped
-
-# After every LLM call (every CLI):
-bash $HOME/.claude/scripts/phase-tracker.sh tokens <N> <in> <out> [cached]
-```
-
-### Visual channel  -  Claude Code (native TaskList widget, required)
-
-In Claude Code the agent MUST also drive the native TaskList widget so the user sees a sticky phase tile stack  -  this is the only progress signal Claude Code surfaces. Skipping these calls is the #1 source of "I don't see any phases" complaints.
-
-**TaskCreate ordering (strict)**: All TaskCreate calls in a registration batch fire in strict phase-number order BEFORE any TaskUpdate in that batch, and a later batch only ever appends phases numbered above everything already registered. The native widget renders by creation order, not by phase number  -  out-of-order calls produce visually scrambled tile stacks (e.g. `1 ✓ · 2 ✓ · 4 ✓ · 0 ▶ · 3 ☐`) even when the underlying state is correct. Pre-marking phases as completed/skipped before Phase 0 starts is FORBIDDEN  -  register the tile in order, then flip status via TaskUpdate when the phase actually short-circuits. Full contract in `$HOME/.claude/multi-agent-refs/tracker-contract.md` section "TaskCreate ordering (strict)".
-
-```text
-# Register one tile per phase, capture the taskId, persist it:
-for each phase in 0:Init, 1:Plan, 2:Dev, 3:Review, 4:Commit, 5:Report:
-  TaskCreate({ subject: "Phase <N>: <Name>", activeForm: "<doing-form>" })
-    -> returns taskId
-  bash $HOME/.claude/scripts/phase-tracker.sh meta <N> tasklist_id "<taskId>"
-
-# Phase entry  -  flip the tile to in_progress alongside the state update:
-TaskUpdate({ taskId: <saved>, status: "in_progress" })
-bash $HOME/.claude/scripts/phase-tracker.sh update <N> in_progress
-
-# Active sub-step inside a phase  -  update activeForm so the spinner header reflects what's happening now:
-TaskUpdate({ taskId: <saved>, activeForm: "Editing TopBarView.swift" })
-
-# Phase exit  -  flip to completed/failed/skipped on both channels:
-TaskUpdate({ taskId: <saved>, status: "completed" })
-bash $HOME/.claude/scripts/phase-tracker.sh update <N> completed
-```
-
-`--local autopilot` mode TaskCreates all 6 phases (no phase is skipped).
-
-#### TaskCreate ordering (strict)
-
-**All TaskCreate calls in a batch fire in strict phase-number order BEFORE any TaskUpdate is applied.** For `--local autopilot` that means: Phase 0 → Phase 1 → Phase 2 → Phase 3 → Phase 4 → Phase 5. The native widget renders by creation order, not by phase number  -  out-of-order calls produce visually scrambled tile stacks. Full ordering contract in `$HOME/.claude/multi-agent-refs/tracker-contract.md` section "TaskCreate ordering (strict)".
-
-### Visual channel  -  Copilot CLI / plain shell
-
-These CLIs have no TaskList widget. After every state change the agent calls render, which prints a bordered ANSI card as the last tool result so the user sees an updated phase table:
-
-```bash
-bash $HOME/.claude/scripts/phase-tracker.sh render
-```
-
-Do NOT call TaskCreate on these CLIs  -  the tool does not exist and the call fails.

package/pipeline/commands/multi-agent/resume-local/SKILL.md

@@ -1,114 +0,0 @@
----
-description: "Continue already-done LOCAL work through the pipeline tail: Review (with its build gate) → Commit/PR → Report (technical analysis + Jira test-scenario comment). No dev phase. Use when local work is already done and only review, build, commit and reporting remain."
-description-tr: "Halihazırda bitmiş LOKAL işi pipeline kuyruğundan geçirir: Review (build kapısıyla) → Commit/PR → Report (teknik analiz + Jira test-senaryosu yorumu). Dev fazı yok."
-allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, AskUserQuestion, WebFetch, WebSearch, Skill
----
-
-# multi-agent resume-local  -  Take Existing Branch Work Through the Pipeline Tail
-
-> **Language (read FIRST)**: Before any status output, read `prefs.global.outputLanguage` and render every conversational line in it. `AskUserQuestion` renders its `question`, option `label`s and option `description`s in `outputLanguage`; only `header` stays English (<=12-char chip); external payload bodies follow `outputLanguage` too (identifiers, commit messages, branch names stay English). Full contract: `$HOME/.claude/multi-agent-refs/rules.md` "Language Application".
-
-You already did the work locally  -  wrote code on the current branch and maybe tested it by hand, or committed it outside the pipeline entirely. (As of v14.0.0 a Short run reviews its own output, so this command is for work that had no pipeline run behind it, not a patch for a mode that skipped review.) `/multi-agent:resume-local` picks up from there and runs the **pipeline tail** over that existing local work in one command: parallel review, a build + test success gate, commit/push + PR, then the technical analysis and a **Jira comment with test scenarios**. It does NOT re-develop  -  Analysis / Planning / Dev (phases 1-3) are intentionally skipped; the diff already on the branch IS the input.
-
-## When to use it
-
-- You ran `:local` and answered Short (which skips Review + Test) and now want the full quality tail on the same branch.
-- You hand-coded or hand-tested a change and want review + build/test + PR + Jira write-up without re-running dev.
-- You want the "reviewed, built, tested, PR'd, documented on Jira" finish with a single command.
-
-## When NOT to use it
-
-- You haven't written the change yet  -  use `/multi-agent` or `/multi-agent:local`.
-- You only want the review, nothing else  -  use `/multi-agent:review`. Only the report/channels  -  `/multi-agent:channels`. Only device UI testing  -  `/multi-agent:test` / `/multi-agent:manual-test`.
-
-## Input
-
-```bash
-/multi-agent:resume-local                       # current branch vs its base; resolve Jira id from branch name
-/multi-agent:resume-local PROJ-12345          # bind to an explicit Jira id for the Phase 5 comment
-/multi-agent:resume-local --base develop         # override the base branch for the diff
-/multi-agent:resume-local autopilot              # no gate prompts: auto-fix blocking findings, auto-PR, auto-comment
-```
-
-## Pipeline
-
-```
-Phase 0: Init          → project/branch detect, resolve base + diff (work-already-done), Jira id, state (NO worktree)
-Phase 3: Review        → the Verify gate first (stack-aware build + existing tests; SUCCESS required), then
-                         parallel review (Fable + Opus + Sonnet) + Fable triage
-Phase 4: Commit        → commit remaining local changes + push + open PR if none exists
-Phase 5: Report        → technical analysis + Jira comment with test scenarios (channels: Jira / PR / Confluence / Wiki)
-```
-
-Phases 1-2 (Plan / Dev) are skipped by design  -  `ship` treats the current branch's local changes as the Phase 2 output.
-
-**Why Review runs the build gate here.** Verify is Phase 2 Dev's exit gate since v19.0.0, and this mode has no Dev: the work arrived already written. The gate still has to run, so Review runs it before dispatching reviewers, which is what Review Stage 1 did before the consolidation. Reviewing a branch whose build was never checked is the failure this ordering prevents.
-
-## Phase 0  -  Context resolution (finish-specific)
-
-1. **Project + branch:** detect project (cwd), current branch (`git branch --show-current`). No worktree; work stays on the current branch.
-2. **Base + diff:** resolve base branch in order: `--base <arg>` → `figma-config.project.baseBranch` → `develop` → the branch's upstream/merge-base. The **work under review** is `git diff <base>...HEAD` PLUS uncommitted working-tree changes (`git status`). Abort with a clear message if the diff is empty (`ERR: no local work to finish on <branch> vs <base>`).
-3. **Task binding:** Jira id from the `--`/positional arg, else parse the branch name (`bugfix/PROJ-XXXX` / `feature/PROJ-XXXX`); `taskType` inferred from the diff (bugfix/feature/refactor/chore) for the report wording. GitHub issue `#N` from branch/arg when present.
-4. **Prior state (optional):** if an `agent-state.json` / tracker-state exists for this branch (left by a prior `:local` run), load its analysis summary + Jira/issue binding to enrich the report; otherwise synthesize a minimal state over the diff. Never require a prior full-pipeline run.
-5. Persist state under `.claude/logs/multi-agent/{project}/{taskId}/` (same as `--local`).
-
-## Phase execution (reuse the existing phase contracts)
-
-- **Phase 3 Review** - run per `$HOME/.claude/multi-agent-refs/phases/phase-3-review.md` against the resolved diff: deterministic gates (Step 1.x), stack-specific parallel reviewers (Fable + Opus + Sonnet on Claude Code; GPT + Opus + Sonnet on Copilot CLI), Fable triage → `triage.accepted`. Blocking/important accepted findings:
-  - interactive: present them and ask (`AskUserQuestion`) whether to fix now (loop back through a minimal Phase-3-style TDD fix) or proceed;
-  - `autopilot` (or `prefs.global.resumeLocal.autoFix == true`): auto-fix accepted blocking/important findings, then re-review the fix, before advancing.
-- **Phase 3 Verify gate** - the **automated success gate** (this is what "build+test success" means here; the interactive device user-test is `/multi-agent:manual-test`). Stack-aware: build via `figma-config.build` (iOS scheme / Android gradle / detected backend/web build) and run the existing test suite if present (`swift test` / `xcodebuild test` / `./gradlew test` / `pytest` / `npm test` / `vitest`). Require success to advance; on failure, surface logs and (interactive) stop or (autopilot) attempt a bounded fix loop. **If the repo has no tests, report "no tests present" - never fabricate test results.**
-- **Phase 4 Commit/PR** - per `$HOME/.claude/multi-agent-refs/phases/phase-4-commit.md`: stage + commit any remaining local changes with a conventional message (`{type}(scope): desc [{JIRA_KEY}-{id}]`), push, and open a PR **only if one does not already exist** for the branch. PR body per `$HOME/.claude/multi-agent-refs/rules.md "External System Outputs"` and `$HOME/.claude/rules/git-conventions.md` - `Ref: #N` / `Related: #N`, never `Closes/Fixes/Resolves`; NO AI/bot attribution anywhere.
-- **Phase 5 Report** - per `$HOME/.claude/multi-agent-refs/phases/phase-5-report.md` + `channels.md`: produce the **technical analysis** and **test scenarios**, then post to the configured channels. Default content for `ship`: a Jira **comment** carrying the technical analysis + the test scenarios (and, when the PR was opened, the PR description). Every body runs through the humanizer; bot/tool/AI signatures are FORBIDDEN in comments.
-
-## Modes
-
-- **interactive** (default): stops at the Phase 4 gate when there are blocking/important findings; asks before committing/PR when appropriate.
-- **`autopilot`**: no prompts  -  auto-fix accepted blocking/important findings, auto-commit/push/PR, auto-post the Jira comment. Mirrors `local-autopilot`.
-
-## Required: outward-facing payload contracts
-
-Before writing anything outward-facing  -  PR body, Jira comment, Confluence page, closing report  -  load `$HOME/.claude/multi-agent-refs/payload-contracts.md`. It names the canonical section set for each payload, the markup dialect per surface (PR body is Markdown, Jira is wiki markup  -  mixing them is a defect), and the token/duration numbers the closing report must carry. Improvising a payload shape from memory is the most common failure of the short modes.
-
-## Required: Phase Tracker Contract
-
-**The phase tracker is required.** Full spec: [`$HOME/.claude/multi-agent-refs/tracker-contract.md`]($HOME/.claude/multi-agent-refs/tracker-contract.md). `ship` registers its active phase set  -  `0:Init 3:Review 4:Commit 5:Report`  -  but NEVER resets a tracker that an earlier run already built (load-or-continue; contract section "Continuation runs"):
-
-```bash
-# Phase 0, first shell call (every CLI). init ONLY when no prior state exists -
-# a task handed off from the user test inside Phase 3 ("awaiting local test")
-# keeps its full phase 0-2 history (elapsed, tokens, USD).
-STATE="$HOME/.claude/logs/multi-agent/${TASK_ID}/tracker-state.json"
-if [ ! -f "$STATE" ]; then
-  bash $HOME/.claude/scripts/phase-tracker.sh init "$TASK_ID"
-fi
-for p in "0:Init" "3:Review" "4:Commit" "5:Report"; do
-  bash $HOME/.claude/scripts/phase-tracker.sh add "${p%%:*}" "${p#*:}"   # idempotent: existing phases keep their history
-done
-bash $HOME/.claude/scripts/phase-tracker.sh update 0 in_progress
-
-# Every phase boundary (every CLI):
-bash $HOME/.claude/scripts/phase-tracker.sh update <N> in_progress|completed|failed|skipped
-# After every LLM call (every CLI):
-bash $HOME/.claude/scripts/phase-tracker.sh tokens <N> <in> <out> [cached]
-```
-
-**Continuation path (prior state existed):** (1) if Phase 3 was left `in_progress` with `Now: awaiting local test (user)`, mark it `update 3 completed` + `meta 3 Result "local test done (user)"` before finish's own work (finish re-opens it with `update 3 in_progress` when its Verify gate runs; elapsed keeps the original `started_at`, which is expected); (2) print ONE line in `outputLanguage` summarizing the inherited history, e.g. `Continuing PROJ-12345: phases 0-3 finished earlier (12m, 38.4k tok, ~$0.74)` (USD via `phase-tracker.sh cost total`); (3) `render`.
-
-### Visual channel  -  Claude Code (native TaskList widget, required)
-
-Fresh state: register one tile per phase in strict phase-number order (`0 → 4 → 5 → 6 → 7`) BEFORE any TaskUpdate, capture each `taskId`, persist via `phase-tracker.sh meta <N> tasklist_id "<taskId>"`, then flip status with `TaskUpdate` at each boundary. Out-of-order TaskCreate scrambles the tile stack. Full contract: `$HOME/.claude/multi-agent-refs/tracker-contract.md` "TaskCreate ordering (strict)".
-
-Continuation: rebuild the FULL TaskList from the state file (completed 0-3 tiles included) in phase order before any `TaskUpdate`, refreshing every `tasklist_id` meta  -  same as the contract's "Resume behaviour".
-
-### Visual channel  -  Copilot CLI / plain shell
-
-No TaskList widget. After every state change call `bash $HOME/.claude/scripts/phase-tracker.sh render` (prints the bordered ANSI phase table as the last tool result). Do NOT call TaskCreate on these CLIs.
-
-## Examples
-
-```bash
-/multi-agent:local "PROJ-12345"         # develop locally, then answer Short at the depth question
-# ... you inspect / hand-test the change ...
-/multi-agent:resume-local                        # now: review + build/test + PR + Jira analysis & test scenarios
-```

package/pipeline/skills/shared/core/multi-agent-local/SKILL.md

@@ -1,41 +0,0 @@
----
-name: multi-agent-local
-language: en
-description: "Full pipeline in local mode  -  no worktree, runs directly on the current branch. Use when the full pipeline should run on the current branch without creating a worktree."
-user-invocable: true
----
-
-# multi-agent local  -  Full Pipeline, Local Branch
-
-Runs the full 6-phase pipeline (normal mode  -  including the Plan Approval Gate + parallel review + triage) on the current branch **without creating a worktree**. The dedicated equivalent of the `multi-agent "task" --local` flag form.
-
-## When to use it
-
-- You do not want an extra open worktree  -  if an editor/IDE is open in the same folder, it is not disrupted
-- You are already on the correct branch and just want to apply the pipeline discipline
-- Small project / prototype  -  worktree overhead is unnecessary
-
-## When NOT to use it
-
-- Multiple tasks in parallel at the same time  -  worktree isolation is lost
-- Multi-repo task  -  `--local` locks to a single repo
-
-## Pipeline
-
-The same 6 phases as the normal pipeline: Init → Analysis → Planning → Dev → Review → Test → Commit → Report. Only Phase 0 Step 8 (workspace creation) continues on the current branch instead of a worktree; the `state.projects[*].worktreePath` field stays `null`.
-
-## Delegation
-
-Delegates to the orchestrator skill (`multi-agent/SKILL.md`) with the `--local` flag. The Phase 0 Step 6 worktree step is skipped; all other phase contracts apply as is (Plan Approval Gate, three-reviewer review, triage, secret scan, PR creation).
-
-## Examples
-
-```bash
-multi-agent-local "PROJ-12345"                                 # Jira
-multi-agent-local "#42"                                        # GitHub issue
-multi-agent-local "LoginView dark mode fix"                    # Free-text
-```
-
-## Required: outward-facing payload contracts
-
-Before writing anything outward-facing  -  PR body, Jira comment, Confluence page, closing report  -  load `$HOME/.claude/multi-agent-refs/payload-contracts.md`. It names the canonical section set for each payload, the markup dialect per surface (PR body is Markdown, Jira is wiki markup  -  mixing them is a defect), and the token/duration numbers the closing report must carry. Improvising a payload shape from memory is the most common failure of the short modes.