@mmerterden/multi-agent-pipeline 19.1.4 → 20.1.0

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

@@ -46,7 +46,7 @@ How It Works (Phase 0  -  Interactive Flow):
   5. BRANCH NAME bugfix/{jiraId} or feature/{jiraId} -> confirm
   6. GIT ID      Select identity from preferences (multiple supported)
   7. INSTRUCTION Auto-detect if .instructions/ exists (figma etc.)
-  8. WORKSPACE   Create worktree (default) or local branch (--local)
+  8. WORKSPACE   Ask where the branch lives: worktree (default) or project root
 
 ------------------------------
 
@@ -55,7 +55,7 @@ Pipeline (after Phase 0)  -  shown as visual cards in terminal:
   Phase 0:   Init       -> The 8 steps above
   Phase 1:   Plan       -> Stack detection + codebase scan, task breakdown, architecture
                           review, Plan Approval Gate (Opus; max 2 clarification rounds,
-                          Full + interactive only  -  a Short run has no plan)
+                          interactive only  -  autopilot has nobody to ask)
   Phase 2:   Dev        -> TDD: test -> code -> build (Sonnet) + build queue, then the
                           Verify exit gate: build, lint, tests, secrets. The build runs
                           ONCE per run and its log carries into Review
@@ -68,11 +68,10 @@ Pipeline (after Phase 0)  -  shown as visual cards in terminal:
 
   Autopilot always pauses at the Phase 5 channels menu (30-min timeout → session ends cleanly).
 
-  Pipeline depth is asked at Phase 0 Step 7.5, not passed as a flag:
-    Full    Plan -> Dev(Sonnet) -> Review -> Commit -> Report
-    Short   Dev(Opus, self-contained) -> Review -> Commit -> Report
-  Short skips Phase 1 only; Review is NEVER skipped. Recommended from taskType:
-  bugfix/chore -> Short, feature/refactor/component -> Full. Autopilot always runs Full.
+  One pipeline. Every mode runs its whole phase set:
+    Plan -> Dev(Sonnet) -> Review -> Commit -> Report
+  What a run costs follows the evidence the task carries, not an answer taken
+  before the evidence exists.
 
   Every step is logged. Error in any phase -> pause -> resume to continue.
 
@@ -82,17 +81,15 @@ Modes:
 
 Four pipeline entries:
 
-  /multi-agent "task"                  Worktree, asks Full or Short
-  /multi-agent:local "task"            No worktree, asks Full or Short
+  /multi-agent "task"                  Worktree
   /multi-agent:autopilot "task"        Worktree, no questions, always Full
-  /multi-agent:local-autopilot "task"  No worktree, no questions, always Full
 
-  --local on the base command is the same as the :local entry.
-  autopilot skips every confirmation INCLUDING the plan gate and the depth
+  Phase 0 Step 5b asks where the branch lives; there is no flag for it.
+  autopilot skips every confirmation INCLUDING the plan gate and the workspace
   question, and auto commit/PR  -  EXCEPT the Phase 5 channels menu, which
   always pauses.
 
-  /multi-agent:resume-local [jira-id] [autopilot]     Continue already-done LOCAL work: Review (build gate) → Commit/PR → Report (no dev)
+  /multi-agent:resume [#id|jira-id] [autopilot]       Pick up unfinished work: a stopped run, or a branch with no run behind it (Review → Commit/PR → Report)
 
 ------------------------------
 
@@ -129,13 +126,14 @@ Post-Hoc & Side-Channel:
   /multi-agent:graph         Build and query the repo code graph (symbols, imports, references), LLM-free
   /multi-agent:search         Cross-task log search with smart ranking; --semantic queries triage corpus
   /multi-agent:scan           Skill security scan against tiered pattern catalog
+  /multi-agent:security-review  Standalone defensive static security review: threat model, OWASP + CWE + CVSS findings, dep inventory. No live target.
   /multi-agent:doctor         Would a run work here? Layout, prefs, credentials, hooks; exit code is the verdict
   /multi-agent:refactor       Best practices + bug hunt + upstream drift + toolkit MCP research -> one plan, approval, dev + sync
   /multi-agent:refactor backlog  Decide the friction already recorded about the pipeline itself, nothing re-derived
   /multi-agent:store-ready [repo] [flags]  Pre-submission store readiness, iOS + Android, local-only: three symmetric gates per platform plus the running-app sweep. A skipped gate is never a pass. Validates only, never uploads.
   /multi-agent:testflight-validation [repo] [--ipa=|--archive=]  iOS-pinned alias of :store-ready. Same three gates, one implementation.
   /multi-agent:ios-coding-standard [module]  Audit an iOS module against the 99-rule coding-standard registry -> remediation
-                              plan + one-page onboarding summary -> hand off to /multi-agent or :local. Read-only, never edits source.
+                              plan + one-page onboarding summary -> hand off to /multi-agent. Read-only, never edits source.
 
 Setup & Maintenance:
 
@@ -182,9 +180,8 @@ Interactive Launchers:
 
   Both follow the same flow after selection:
     1. Branch selection (develop/release/main)
-    2. Depth: Full or Short
-    3. Autopilot: yes/no
-    4. Pipeline starts with the selected issue
+    2. Autopilot: yes/no
+    3. Pipeline starts with the selected issue
 
 ------------------------------
 
@@ -274,7 +271,6 @@ Examples:
   /multi-agent "MOBILE-12345"
 
   # GitHub issue, fast mode, local
-  /multi-agent:local "#42"                                       # then choose Short
 
   # Interactive launchers  -  browse and pick
   /multi-agent:jira                    # Pick from my Jira issues
@@ -284,7 +280,7 @@ Examples:
   /multi-agent:autopilot "LoginView dark mode fix"               # iOS
   /multi-agent "Add pagination to /api/users endpoint"           # Backend
   /multi-agent "Fix bottom nav recomposition in HomeScreen"      # Android
-  /multi-agent "Responsive layout broken on tablet"              # Web, choose Short
+  /multi-agent "Responsive layout broken on tablet"              # Web
 
   # Review current diff only
   /multi-agent:review
@@ -326,7 +322,7 @@ Nasıl Çalışır (Phase 0  -  İnteraktif Akış):
   5. BRANCH NAME bugfix/{jiraId} veya feature/{jiraId} -> onayla
   6. GIT ID      Kimlik seç (prefs'ten; birden fazla desteklenir)
   7. INSTRUCTION .instructions/ varsa otomatik algıla (figma vs.)
-  8. WORKSPACE   Worktree yarat (default) ya da local branch (--local)
+  8. WORKSPACE   Branch nerede yaşayacak: worktree (default) ya da proje kökü
 
 ------------------------------
 
@@ -362,16 +358,14 @@ Modlar:
 
 Dört pipeline girişi:
 
-  /multi-agent "task"                  Worktree var, Tam mı Kısa mı diye sorar
-  /multi-agent:local "task"            Worktree yok, Tam mı Kısa mı diye sorar
+  /multi-agent "task"                  Worktree var
   /multi-agent:autopilot "task"        Worktree var, soru yok, her zaman Tam
-  /multi-agent:local-autopilot "task"  Worktree yok, soru yok, her zaman Tam
 
-  Ana komuta --local eklemek :local girişiyle aynıdır.
+  Faz 0 Adım 5b branch'in nerede yaşayacağını sorar; bayrağı yok.
   autopilot plan kapısı ve derinlik sorusu dahil her onayı atlar, otomatik
   commit/PR açar  -  İSTİSNA: Faz 5 channels menüsü, o her zaman durur.
 
-  /multi-agent:resume-local [jira-id] [autopilot]     Lokalde biten işi sürdür: Review (build kapısı) → Commit/PR → Report (dev yok)
+  /multi-agent:resume [#id|jira-id] [autopilot]       Yarım kalan işi sürdür: duran koşu ya da arkasında koşu olmayan branch (Review → Commit/PR → Report)
 
 ------------------------------
 
@@ -400,6 +394,7 @@ Post-Hoc & Side-Channel:
   /multi-agent:analysis ["analysis-name"]  Feature-spec analizi (Figma + Swagger + Confluence + repolar). Önce standardı sorar: global (23 bölümlük geliştirme dokümanı) veya kurumsal (IG→UC→FG gereksinim dokümanı). Stack opsiyonel; Referanslar kanıt kaydından üretilir
   /multi-agent:analysis-resolve [doc]      Analiz dokümanının Bölüm 20 açık sorularını kaynak etiketli adaylarla teker teker çözer
   /multi-agent:review-analysis [doc]  Yazılmış analizi review eder; bulgular ihlal edilen kuralı gösterir
+  /multi-agent:analysis-jira [doc]    Nihai analiz -> Jira story ağacı; kapsam iki yönlü kontrol edilir, var olan düğümler atlanır
   /multi-agent:complaint-analysis ["run-adı"]  Müşteri şikayeti triyajı: trx/conv id ile Graylog kanıtı + salt-okunur repo eşleştirme → client/bff kök neden + fix planı + dev prompt'u, veya core'a yönlendirme önerisi
   /multi-agent:build-optimize iOS-only Xcode build performance wrapper → benchmark + analiz + recommend-first .build-benchmark/optimization-plan.md
   /multi-agent:create-jira ["açıklama"] [figma-url] [swagger-url]  Takım standartlarına uygun Jira Task/Bug/Story oluştur (tip sorar + convention mining + aktif sprint + auto-sizing bölümler + önizleme & onay)
@@ -407,12 +402,14 @@ Post-Hoc & Side-Channel:
   /multi-agent:graph         Repo kod grafiğini kur ve sorgula (semboller, import'lar, referanslar), LLM'siz
   /multi-agent:search         Task log'larında akıllı arama; --semantic triage corpus'unu sorgular
   /multi-agent:scan           Skill güvenlik taraması (tiered pattern catalog)
+  /multi-agent:security-review  Bağımsız savunma amaçlı statik güvenlik incelemesi: tehdit modeli, OWASP + CWE + CVSS bulguları, bağımlılık envanteri. Canlı hedef yok.
+  /multi-agent:doctor         Burada bir koşu çalışır mı? Yerleşim, prefs, kimlik bilgileri, hook'lar; çıkış kodu kararı verir
   /multi-agent:refactor       Uyarlanmış best-practice + bug avı + upstream-drift + multi-agent-toolkit MCP araştırması -> tek plan, onay, dev + sync
   /multi-agent:refactor backlog  Pipeline'ın kendisi hakkında kaydedilmiş sürtünmeyi karara bağlar, sıfırdan türetmez
   /multi-agent:store-ready [repo] [flags]  Yükleme öncesi store hazırlığı, iOS + Android, yalnızca lokal: platform başına 3 simetrik kapı artı çalışan-app sweep'i. Atlanan kapı asla pass sayılmaz. Sadece doğrular, asla yüklemez.
   /multi-agent:testflight-validation [repo] [--ipa=|--archive=]  :store-ready'nin iOS alias'ı. Aynı 3 kapı, tek implementasyon.
   /multi-agent:ios-coding-standard [modül]  Bir iOS modülünü 99 kurallık kodlama-standardı registry'sine göre denetler -> düzeltme
-                              planı + tek sayfalık onboarding özeti -> /multi-agent veya :local'e devreder. Read-only, kaynağı hiç düzenlemez.
+                              planı + tek sayfalık onboarding özeti -> /multi-agent'a devreder. Read-only, kaynağı hiç düzenlemez.
 
 Setup & Maintenance:
 
@@ -550,7 +547,6 @@ Quality & Telemetry (advisory, default açık  -  prefs.global.* ile kapatılabi
   /multi-agent "MOBILE-12345"
 
   # GitHub issue, hızlı mode, local
-  /multi-agent:local "#42"                                       # sonra Kısa seç
 
   # İnteraktif launcher'lar  -  göz at ve seç
   /multi-agent:jira                    # Jira issue'larımdan seç

package/pipeline/commands/multi-agent/ios-coding-standard/SKILL.md

@@ -1,12 +1,14 @@
 ---
-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-tr: "Bir iOS modulunu paylasilan kodlama-standardi registry'sine (99 sabit-ID kural) gore denetler, duzeltme plani cikarir, sonra /multi-agent veya :local'e devreder. Bir modulde standart gecisi icin, ya da bir review'un gorus yerine kural ID'si istedigi durumda kullan."
+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."
+description-tr: "Bir iOS modulunu paylasilan kodlama-standardi registry'sine (99 sabit-ID kural) gore denetler, duzeltme plani cikarir, sonra /multi-agent'e devreder. Bir modulde standart gecisi icin, ya da bir review'un gorus yerine kural ID'si istedigi durumda kullan."
 argument-hint: "[module name or path]"
 allowed-tools: Skill, Bash, Read, Edit, Write, AskUserQuestion
 ---
 
 # multi-agent ios-coding-standard  -  Module audit → plan → dev handoff
 
+> **Pickers follow** `$HOME/.claude/multi-agent-refs/picker-contract.md`: never a one-option call, and branch on the option selected, not on its text.
+
 **Input**: $ARGUMENTS  -  optionally a module name or path. When absent, Phase 1 discovers and asks.
 
 This routine is the **procedure**. The rules live in the `ai-ios-toolkit:ios-coding-standard` skill, whose registry is
@@ -236,10 +238,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/commands/multi-agent/issue/SKILL.md

@@ -7,6 +7,8 @@ not-for: jira
 
 # multi-agent issue  -  4-Step Picker (Account → Repos → Issue → Dev Context)
 
+> **Pickers follow** `$HOME/.claude/multi-agent-refs/picker-contract.md`: never a one-option call, and branch on the option selected, not on its text.
+
 **Input**: $ARGUMENTS
 
 Fully interactive. Only one optional flag: `autopilot`.

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

@@ -6,6 +6,8 @@ argument-hint: "[autopilot]  -  optional: run the pipeline without confirmations
 
 # multi-agent jira  -  4-Step Picker (Account → Project → Issue → Dev Context)
 
+> **Pickers follow** `$HOME/.claude/multi-agent-refs/picker-contract.md`: never a one-option call, and branch on the option selected, not on its text.
+
 **Input**: $ARGUMENTS
 
 Fully interactive. Only one optional flag: `autopilot`.

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

@@ -6,6 +6,8 @@ argument-hint: "[en|tr]  -  sets outputLanguage; omit for interactive picker; us
 
 # multi-agent language  -  Language Preference Toggle
 
+> **Pickers follow** `$HOME/.claude/multi-agent-refs/picker-contract.md`: never a one-option call, and branch on the option selected, not on its text.
+
 **Input**: $ARGUMENTS
 
 Two-axis language preference for the pipeline:

package/pipeline/commands/multi-agent/prune-logs/SKILL.md

@@ -6,6 +6,8 @@ argument-hint: "[--older-than=<days>] [--project=<name>] [--task=<id>] [--yes]"
 
 # multi-agent prune-logs  -  Clear Per-Task Project Logs
 
+> **Pickers follow** `$HOME/.claude/multi-agent-refs/picker-contract.md`: never a one-option call, and branch on the option selected, not on its text.
+
 Every run persists a task log dir at
 `~/.claude/logs/multi-agent/<project>/<task>/` (agent-state.json, agent-log.md,
 tracker-state.json, otel-spans.jsonl). These accumulate forever. This prunes

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

@@ -6,6 +6,8 @@ description-tr: "⚠️ Tüm worktree, branch, log ve state dosyalarını siler.
 
 # multi-agent purge  -  Full Reset
 
+> **Pickers follow** `$HOME/.claude/multi-agent-refs/picker-contract.md`: never a one-option call, and branch on the option selected, not on its text.
+
 Reset every multi-agent worktree, its local branch, and the project task
 counter. Nuclear option  -  requires double confirmation. Backed by
 `$HOME/.claude/scripts/purge.sh`, which is safe by default (dry-run, deletes

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

@@ -1,58 +1,187 @@
 ---
-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-tr: "Durmuş veya hata almış bir görevi kaldığı fazdan devam ettirir."
-argument-hint: "[#id]  -  optional: task ID (e.g. #2). If omitted, the most recent paused task is used."
+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."
+description-tr: "Yarım kalan işi sürdürür: ortada duran bir pipeline koşusu ya da mevcut branch'te elle yazılmış, pipeline'dan hiç geçmemiş iş."
+argument-hint: "[#id | PROJ-12345] [--base <branch>] [autopilot]  -  no argument: pick from the list"
+allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, AskUserQuestion, WebFetch, WebSearch, Skill
 ---
 
-# 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.
+> **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".
 
-> **Not the same as `/multi-agent:resume-local`.** `resume` continues a **tracked pipeline task** (needs its `agent-state.json`/worktree) from where it stopped. `/multi-agent:resume-local` takes **ad-hoc local work** on the current branch (no prior task required) and runs the pipeline tail - Review → Build+Test → PR → Jira report - over it.
+Unfinished work reaches this command from two directions, and which one you are in is a property of the repository, not of how you typed the command:
+
+- **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.** You wrote it by hand, or a run outside the pipeline produced it. There is nothing to resume, so the **pipeline tail** runs over the diff: Review (with its build gate) → Commit/PR → Report. Plan and Dev never run; the diff already on the branch is the Dev output.
+
+Step 1 finds both and asks. A single command means you do not have to know which case you are in before you can ask 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
+```
+
+## When NOT to use it
+
+- The change is not written yet  -  use `/multi-agent`.
+- Only the review is wanted  -  `/multi-agent:review`. Only the report  -  `/multi-agent:channels`. Only device UI testing  -  `/multi-agent:test` / `/multi-agent:manual-test`.
+- The run is abandoned rather than paused  -  `/multi-agent:kill #N`, or `/multi-agent:garbage-collect --abandoned` for the Phase 0 leftovers.
 
 ## Steps
 
-1. **Find the task**  -  parse `#N` from the argument, or pick the most recent worktree with `status != "done"`.
-
-2. **Read + validate state**  -  parse `agent-state.json`:
-   - Validate first: `node $HOME/.claude/scripts/validate-state.mjs <state-file>` (resume-safety check, tolerant of legacy shapes). On non-zero exit, do NOT guess a phase  -  surface the errors and stop with `ERR: agent-state.json is unsafe to resume; inspect it or 'kill #N' and restart.`
-   - Confirm the worktree (`worktreePath` / `projects[].worktreePath`) exists and is usable; if missing or locked, run the Phase 0 "Worktree stale-lock heal" before continuing.
-- **Unless `state.worktreeRemovedAt` is set.** Then the worktree was removed on purpose by Phase 4 once the PR opened, the branch is still local, and the artefacts live under `state.artifactsPath`. Do NOT heal or recreate it: read state from `artifactsPath`, and if the remaining work needs a checkout (a Phase 5 pause needs none), ask before moving the user's HEAD  -  they may be mid-work on another branch, which is exactly why the removal did not check the branch out.
-   - `currentPhase`  -  last completed phase
-   - `status`  -  `paused` | `failed` | `in_progress`
-   - `haltReason`  -  if set, show it so the user knows why the run stopped; clear it on successful re-entry
-   - `circuitBreaker`  -  if `tripped`, show `trigger` + `detail`, then set `tripped: false` and keep `counters`; if the same trigger fires again at the next checkpoint the breaker re-trips (no silent bypass)
-   - `autopilot`  -  preserve the mode
-
-3. **Load context**  -  rebuild working context from durable artifacts, never from conversation memory:
-   - **Handoff first (v10.8.0)**: read the LATEST `## Handoff` block in `agent-log.md`  -  it carries done/remaining/decisions/open-findings and the exact re-entry point (phase + subStep). When present, it is the primary context source; cross-check its `Next:` line against `state.currentPhase` and trust state on mismatch (state is the machine truth, handoff is the narrative).
-   - Fall back to per-phase findings for logs written before v10.8 (no handoff blocks):
-     - Phase 1 analysis → use it from Phase 2+
-     - Phase 1 plan → use it from Phase 2+
-     - Phase 3 code → already in the worktree
-   - Recent `git log --oneline -10` in the worktree grounds what was actually committed vs. claimed.
-
-4. **Rebuild the phase tiles**  -  load `tracker-state.json` for the task (never re-init it; `$HOME/.claude/multi-agent-refs/tracker-contract.md` "Resume behaviour" + "Continuation runs"):
-   - Claude Code: `TaskCreate` every phase from the state file in phase order, then `TaskUpdate` each to its stored status, and replace every `tasklist_id` meta with the new IDs.
-   - Other CLIs: a single `bash $HOME/.claude/scripts/phase-tracker.sh render`.
-
-5. **Continue the pipeline.** Read `state.waitingFor` FIRST: when it names a step, the
-   run re-enters THAT step rather than the next phase. `currentPhase + 1` is the fallback,
-   not the rule - a run that stopped mid-phase to ask a human has `currentPhase` pointing at
-   the phase it is still inside, so resuming past it skips the question permanently. That
-   was already true of Phase 5's channels pause, which documented itself as resumable
-   through this field while this file never mentioned it.
-
-   | `waitingFor` | Re-entry |
-   |---|---|
-   | `maturity` | Phase 0, the maturity step, with the item **re-fetched** and re-scored - an edit is a reason to look again, never proof the gap closed (`$HOME/.claude/multi-agent-refs/features/maturity-followup.md`) |
-   | `user-channels-choice` | Phase 5, the channels multi-select, with the stored `channelsInput` |
-   | absent | `currentPhase + 1`, as before (same pipeline as the main multi-agent command) |
-
-   Clear `waitingFor` in the same write that records the answer, the moment the step is
-   re-entered. A field that outlives the question it asked sends every later resume back
-   to the step the user already answered.
-
-6. **Log**: `🔄 Resumed {JIRA-KEY}-{id} from Phase {N}`
+### Step 1  -  Build the resumable list, then ask
+
+Collect both sources before rendering anything. An argument that names a run (`#N`, a Jira id, a GitHub issue number) selects it directly and skips the question; an argument that names nothing resumable is an error, never a silent fall-through to the tail.
+
+**Source A  -  tracked runs.** Every `agent-state.json` under `$HOME/.claude/logs/multi-agent/{project}/` whose `status != "done"`. Each row carries what the choice actually turns on: task id, the phase it stopped inside, its workspace (the worktree path, or `local` when `worktreePath` is the project root), how long it has been sitting, and `haltReason` when set.
+
+**Source B  -  untracked work on the current branch.** Resolve the base branch in order: `--base <arg>` → `figma-config.project.baseBranch` → `develop` → the branch's upstream/merge-base. The work is `git diff <base>...HEAD` plus uncommitted working-tree changes. The row appears only when that diff is non-empty **and** no Source A run already owns this branch  -  otherwise the same work would be offered twice under two different contracts.
+
+**Ask.** Full rules: `$HOME/.claude/multi-agent-refs/picker-contract.md`. This is a one-step chain, so the breadcrumb is `Step 1/1: which unfinished work to pick up`, rendered in `outputLanguage` above the picker. `question`, every `label` and every `description` render in `outputLanguage`; `header` stays English (`Resume what`). Source A rows first (newest first), Source B last. Labels carry proper nouns verbatim - task id, branch name - and the run branches on which row was selected, never on the label text.
+
+**One candidate is still a question.** A single row is asked with a genuine escape as its second option, because `AskUserQuestion` refuses a call with fewer than two declared options and discards every question batched with it:
+
+| Only row | Second option |
+|---|---|
+| one stopped run | **Show every run** - re-opens with the `status != "done"` filter dropped, so a run that recorded itself finished but left work behind is still reachable |
+| only the branch diff | **Pick a stopped run instead** - re-opens listing Source A unfiltered, and says so when it is empty |
+
+Zero rows in both sources: do not ask. Stop with `ERR: nothing to resume  -  no stopped run for this project and no local changes on {branch} vs {base}`.
+
+**The answer routes.** A Source A row runs Steps 2-5 and nothing else; a Source B row runs Steps 6-7 and nothing else. The two halves never both run in one invocation.
+
+### Step 2  -  Tracked run: read and validate state
+
+- Validate first: `node $HOME/.claude/scripts/validate-state.mjs <state-file>` (resume-safety check, tolerant of legacy shapes). On non-zero exit, do NOT guess a phase  -  surface the errors and stop with `ERR: agent-state.json is unsafe to resume; inspect it or 'kill #N' and restart.`
+- Confirm the worktree (`worktreePath` / `projects[].worktreePath`) exists and is usable; if missing or locked, run the Phase 0 "Worktree stale-lock heal" before continuing.
+  - **Unless `state.worktreeRemovedAt` is set.** Then the worktree was removed on purpose by Phase 4 once the PR opened, the branch is still local, and the artefacts live under `state.artifactsPath`. Do NOT heal or recreate it: read state from `artifactsPath`, and if the remaining work needs a checkout (a Phase 5 pause needs none), ask before moving the user's HEAD  -  they may be mid-work on another branch, which is exactly why the removal did not check the branch out.
+- `currentPhase`  -  last completed phase
+- `status`  -  `paused` | `failed` | `in_progress`
+- `haltReason`  -  if set, show it so the user knows why the run stopped; clear it on successful re-entry
+- `circuitBreaker`  -  if `tripped`, show `trigger` + `detail`, then set `tripped: false` and keep `counters`; if the same trigger fires again at the next checkpoint the breaker re-trips (no silent bypass)
+- `autopilot`  -  preserve the mode
+
+### Step 3  -  Tracked run: load context
+
+Rebuild working context from durable artifacts, never from conversation memory:
+
+- **Handoff first**: read the LATEST `## Handoff` block in `agent-log.md`  -  it carries done/remaining/decisions/open-findings and the exact re-entry point (phase + subStep). When present, it is the primary context source; cross-check its `Next:` line against `state.currentPhase` and trust state on mismatch (state is the machine truth, handoff is the narrative).
+- Fall back to per-phase findings for logs written before handoff blocks existed:
+  - Phase 1 analysis and plan → use them from Phase 2 on
+  - Phase 2 code → already in the worktree
+- Recent `git log --oneline -10` in the worktree grounds what was actually committed vs. claimed.
+
+### Step 4  -  Tracked run: rebuild the phase tiles
+
+Load `tracker-state.json` for the task (never re-init it; `$HOME/.claude/multi-agent-refs/tracker-contract.md` "Resume behaviour" + "Continuation runs"):
+
+- Claude Code: `TaskCreate` every phase from the state file in phase order, then `TaskUpdate` each to its stored status, and replace every `tasklist_id` meta with the new IDs.
+- Other CLIs: a single `bash $HOME/.claude/scripts/phase-tracker.sh render`.
+
+### Step 5  -  Tracked run: continue the pipeline
+
+Read `state.waitingFor` FIRST: when it names a step, the run re-enters THAT step rather than the next phase. `currentPhase + 1` is the fallback, not the rule - a run that stopped mid-phase to ask a human has `currentPhase` pointing at the phase it is still inside, so resuming past it skips the question permanently.
+
+| `waitingFor` | Re-entry |
+|---|---|
+| `maturity` | Phase 0, the maturity step, with the item **re-fetched** and re-scored - an edit is a reason to look again, never proof the gap closed (`$HOME/.claude/multi-agent-refs/features/maturity-followup.md`) |
+| `user-channels-choice` | Phase 5, the channels multi-select, with the stored `channelsInput` |
+| `local-test` | Phase 3, the user-test gate, with the checkout the gate was waiting on |
+| absent | `currentPhase + 1`, as before (same pipeline as the main multi-agent command) |
+
+Clear `waitingFor` in the same write that records the answer, the moment the step is re-entered. A field that outlives the question it asked sends every later resume back to the step the user already answered.
+
+Log: `🔄 Resumed {JIRA-KEY}-{id} from Phase {N}`
+
+### Step 6  -  Untracked branch work: context resolution
+
+1. **Project + branch:** detect project (cwd), current branch (`git branch --show-current`). No worktree is created; the work is already in this checkout.
+2. **Base + diff:** as resolved in Step 1. Abort with `ERR: no local work to resume on <branch> vs <base>` if the diff went empty between the question and the answer.
+3. **Task binding:** Jira id from the argument, else parsed from 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 or argument when present.
+4. **Prior state (optional):** if a tracker state exists for this branch from an earlier run, load its analysis summary and Jira/issue binding to enrich the report. Never require a prior pipeline run.
+5. Persist state under `$HOME/.claude/logs/multi-agent/{project}/{taskId}/`, the same location every run uses.
+
+### Step 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 (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 and 2 (Plan / Dev) do not run: the branch's diff is the Dev output, so the **Plan Approval Gate** has no plan to approve here. That is the only path where it is absent for a reason other than `autopilot` having nobody to ask.
+
+**Why Review runs the build gate here.** Verify is Phase 2 Dev's exit gate, and this path has no Dev: the work arrived already written. The gate still has to run, so Review runs it before dispatching reviewers. Reviewing a branch whose build was never checked is the failure this ordering prevents.
+
+- **Phase 3 Review** - 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-2-style TDD fix) or proceed;
+  - `autopilot` (or `prefs.global.resume.autoFix == true`): auto-fix accepted blocking/important findings, then re-review the fix, before advancing.
+- **Phase 3 Verify gate** - the **automated success gate** (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: 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.
+
+## 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 a run that starts in the middle.
+
+## 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).
+
+A tracked run rebuilds its tiles from `tracker-state.json` (Step 4) and never re-declares a phase set. The untracked-branch path registers its own active set  -  `0:Init 3:Review 4:Commit 5:Report`  -  but NEVER resets a tracker 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 this run's own work (it re-opens Phase 3 with `update 3 in_progress` when the 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 → 3 → 4 → 5`) 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 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 "PROJ-12345"                 # a run that stops at the user-test gate
+/multi-agent:resume                        # ... pick it back up from that gate
+
+# ... or, with no run behind it at all:
+# you write the change by hand on bugfix/PROJ-12345-flight-filter
+/multi-agent:resume                        # review + build/test + PR + Jira analysis & test scenarios
+```

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

@@ -7,6 +7,8 @@ allowed-tools: Bash, Read, AskUserQuestion
 
 # multi-agent save  -  Save a Routine
 
+> **Pickers follow** `$HOME/.claude/multi-agent-refs/picker-contract.md`: never a one-option call, and branch on the option selected, not on its text.
+
 **Input**: $ARGUMENTS (optional routine name)
 
 Turn a recurring, project-specific procedure into a first-class `/multi-agent:<name>` command. The saved routine is a **local-only** command (`local-only: true`) plus a registry entry in `prefs.global.routines`; it is never synced to the public repo (the `/multi-agent:sync` backstops enforce this).

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

@@ -66,10 +66,10 @@ Known legitimate domains are embedded in the scanner (github, anthropic, figma,
 
 ## Smoke  -  self-verification
 
-`pipeline/scripts/smoke-skill-scan.sh` confirms the scanner triggers on positive fixtures for every severity and produces no false positives on the real tree. This is a maintainer-repo gate (smoke scripts are excluded from the npm package): it runs from a pipeline checkout and in CI, where it must be 13/13 green before a team rollout.
+`pipeline/scripts/smoke-skill-scan.sh` confirms the scanner triggers on positive fixtures for every severity and produces no false positives on the real tree. This is a maintainer-repo gate (smoke scripts are excluded from the npm package): it runs from a pipeline checkout and in CI, where it must be green before a team rollout.
 
 ## Integration points
 
 - **install.js pre-deploy hook**  -  every `install.js --all` runs an automatic high-threshold warn-only scan
-- **CI**  -  `.github/workflows/smoke.yml` step (strict mode, critical findings block the PR)
+- **Smoke suite**  -  `smoke-skill-scan.sh` runs the scanner in strict mode under `npm test`, so a critical pattern fails the suite
 - **Standalone**  -  `/multi-agent:scan` (this command)

package/pipeline/commands/multi-agent/security-review/SKILL.md

@@ -0,0 +1,52 @@
+---
+description: "Run a standalone defensive, static security review of a diff, a branch or a repo: build a run-scoped threat model, emit reviewer-shaped findings joined to OWASP + CWE with CVSS scoring, evidence and before/after fixes, and inventory dependencies offline. No live target, no payloads. Use when reviewing code for security outside a full pipeline run, auditing a dependency set, or preparing a branch for a security sign-off."
+description-tr: "Bir diff, branch veya repo üzerinde bağımsız, savunma amaçlı statik güvenlik incelemesi koşar: çalışmaya özel tehdit modeli kurar, OWASP + CWE'ye bağlı, CVSS puanlı, kanıtlı ve önce/sonra düzeltmeli reviewer biçiminde bulgular üretir, bağımlılıkları çevrimdışı envanterler. Canlı hedef yok, payload yok."
+argument-hint: "[#N | repo#N | PR-URL | branch | path]  -  optional: a PR, a local branch, or a path to scope the review. If omitted (interactive), reviews the current branch diff against its base."
+---
+
+# multi-agent security-review  -  standalone defensive static review
+
+**Input**: $ARGUMENTS
+
+The same security audit Phase 3 runs at Step 2.7, invoked on its own. Defensive and static: it reads code, configuration and dependency manifests and reports vulnerabilities. It never runs the target, fires a payload, or reaches a live host.
+
+## Scope resolution
+
+Resolve what to review from `$ARGUMENTS`, same input shapes as `/multi-agent:review`:
+
+- `#N` / `repo#N` / a PR URL (GitHub or Bitbucket Server) → that PR's diff.
+- a local branch name → its diff against the base branch.
+- a path → the files under it.
+- omitted (interactive) → the current branch diff against its base; autopilot uses the current branch.
+
+Compute the diff once and cap it the way Phase 3 Step 1.9 does; write the capped diff to `.pipeline/security-diff.txt` when it exceeds the budget.
+
+## Steps
+
+### 1. Threat model
+
+Produce `.pipeline/threat-model.md` if absent (four sections: attacker, trust boundaries, attack surface, severity calibration), or read the existing one. Contract: `$HOME/.claude/multi-agent-refs/threat-model.md`. Mirror to `state.threatModel`.
+
+### 2. Method (the plugin skill)
+
+Load the always-on `ai-common-toolkit:security-review` skill for the method: walk the OWASP checklist (Web/API Top 10 2021 for services and sites, Mobile Top 10 2024 for apps) against the changed surface, join each finding to a CWE, and score it. This command orchestrates; it does not re-derive the method.
+
+### 3. Findings (the security-auditor)
+
+Dispatch `Agent(subagent_type: "security-auditor")` on the capped diff plus the threat model. It returns one `reviewer-output.schema.json` object whose `findings[]` each carry the `security` envelope of `security-finding.schema.json`. Compute every `security.cvss.baseScore` + `band` with the toolkit `security_cvss_score` tool, so a score cannot drift from its vector. Validate the object with `$HOME/.claude/scripts/validate-reviewer.mjs`; on failure, one self-correction rework then halt.
+
+### 4. Dependencies (offline)
+
+Run the toolkit `security_dep_inventory` tool on the lockfiles in scope to get a normalized `{ecosystem, name, version}` inventory. When the analyst toolkit is registered, hand that inventory to `ai-analyst-toolkit:evidence-registry` for a known-CVE lookup; a vulnerable dependency becomes an `A06:2021` finding with the advisory's CWE and CVE. This command contacts nothing itself.
+
+### 5. Report
+
+Write the findings to `.pipeline/security-findings.json` (the reviewer-output object) and render a human summary: count by severity, each blocking and important finding with its OWASP id, CWE, CVSS band, evidence, and before/after fix. An empty findings list with `approved: true` is the correct result for a clean review; do not invent findings.
+
+## Relationship to the pipeline
+
+- Inside a run, the same audit is Phase 3 Step 2.7 (`$HOME/.claude/multi-agent-refs/features/security-audit.md`), triggered by the `security_path` diff-risk signal. This command is the standalone entry point; both share the persona, the schemas and the toolkit tools.
+- This is not the `store-ready` device pass under `/multi-agent:test`, and it is not a secret scanner: the pipeline's `pre-commit-check.sh` already covers secrets.
+- No writes to Jira, GitHub or Confluence: routing findings to a ticket is a separate, approval-gated step.
+
+**Autopilot**: reviews the current branch, writes the report, and never opens a PR or comments.

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

@@ -7,6 +7,8 @@ allowed-tools: Bash, Read, Edit, Write, AskUserQuestion
 
 # multi-agent stack  -  Select Stack(s) via Plugin Enablement
 
+> **Pickers follow** `$HOME/.claude/multi-agent-refs/picker-contract.md`: never a one-option call, and branch on the option selected, not on its text.
+
 Stack skills ship as plugins in the `{owner}/multi-agent-plugins` marketplace. Selecting a stack = **enabling the matching plugin(s)** in the current repo's `.claude/settings.json` `enabledPlugins`. Two toolkits are stack-independent and always enabled alongside the stack plugin(s): `ai-common-toolkit` (accessibility audit, humanizer, Firebase) and `ai-analyst-toolkit` (GitHub and package-registry evidence, community signal for analysis work).
 
 On Claude Code the marketplace plugins are the ONLY source of stack skills - nothing is copied into `~/.claude/skills` anymore. A stack that is not enabled here is simply absent from the session. Copilot CLI and Codex CLI have no plugin loader; they receive a local copy filtered to the enabled stacks at install time, which is why step 5 below offers to refresh those copies after a change.