@mmerterden/multi-agent-pipeline 10.3.0 → 10.4.0

package/CHANGELOG.md

@@ -14,6 +14,26 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ---
 
+## [10.4.0] - 2026-07-02
+
+New `finish` command: run the pipeline tail over work you already did locally.
+
+### Added
+
+- **`/multi-agent:finish`** (`multi-agent-finish` on Copilot CLI). Takes the
+  current branch's local work (diff vs base + working tree) and runs the
+  pipeline **tail** in one command — Phase 4 Review → Phase 5 Build+Test success
+  gate → Phase 6 Commit/push/PR → Phase 7 technical analysis + a Jira comment
+  with test scenarios — **without re-developing** (phases 1-3 skipped). Works
+  after `dev-local`/`local` (which skip Review + Test) or after hand-coding /
+  hand-testing. Interactive and `autopilot` modes. Reuses the existing
+  `phase-4-review` / `phase-5-test` / `phase-6-commit` / `phase-7-report` /
+  `channels` contracts; distinct from `resume` (tracked task) and `review`/
+  `channels` (single-step). If the repo has no tests it reports "no tests
+  present" — never fabricates results.
+- Command inventory 34 → 35 (`cross-cli-contract` §1, README counts, `help.md`
+  EN+TR, `sync.md` synced-command list); cross-refs added in `dev-local`/`resume`.
+
 ## [10.3.0] - 2026-07-02
 
 Android (Jetpack Compose) parity for the interaction skills shipped in 10.2.0,

package/README.md

@@ -11,8 +11,8 @@
 
 | Surface | Count |
 |---|---|
-| Slash commands (colon-form `/multi-agent:*`) | 34 |
-| Copilot skills (dash-form `multi-agent-*`) | 34 |
+| Slash commands (colon-form `/multi-agent:*`) | 35 |
+| Copilot skills (dash-form `multi-agent-*`) | 35 |
 | Platforms (native: Claude Code, Copilot CLI · adapter: Cursor, Antigravity, VS Code Copilot Chat, Codex CLI) | 6 |
 | Store-compliance skills (`apple-archive-compliance`, `google-play-compliance`) | 2 |
 | Figma skills (iOS + Android + Common) | 41 |
@@ -154,6 +154,7 @@ slows down the install.
 
 ## What's new
 
+- **v10.4.0** (2026-07-02) - New `/multi-agent:finish` command: continue already-done LOCAL work through the pipeline tail in one shot — parallel review → build+test success gate → commit/push/PR → technical analysis + a Jira comment with test scenarios, without re-developing (phases 1-3 skipped). Pairs with `dev-local`/`local` (which skip Review + Test) or with hand-coded/hand-tested changes. Command inventory 34 → 35.
 - **v10.3.0** (2026-07-02) - Android (Jetpack Compose) parity for the 10.2.0 interaction skills: `figma-navigation` / `figma-overlays` / `figma-bottom-sheets` now carry both a SwiftUI and a Compose section (Navigation Compose; Snackbar/AlertDialog/Dialog + state-driven loading; `ModalBottomSheet`), same emit-intent rules and `ui.*` config hooks on both platforms. Plus a review pass: corrected the `animated-gradient-border` snippet (animate `AngularGradient(angle:)` on a static shape, not `rotationEffect`) and genericized the sheet corner-radius example token.
 - **v10.2.0** (2026-07-02) - Generic SwiftUI interaction coverage for figma-to-swiftui: three new cross-cutting integration skills (`figma-navigation`, `figma-overlays`, `figma-bottom-sheets`) + a reconcile-and-extend workflow (`figma-evolve-component`), all native-SwiftUI-first with an optional per-project `ui.*` config hook (so the same capabilities work on any SwiftUI codebase, no app-specific coupling). Phase 3D dev detection (§1.5.4) and Phase 4 review both consume them; `figma-to-swiftui` accessibility reference enriched with the VoiceOver-minimalism decision tree; new `animated-gradient-border` UI pattern. Figma-common skills 27 → 31, total figma skills 37 → 41.
 - **v10.1.0** (2026-06-20) - Fable 5 retired (no longer available): the five heavy agent personas plus Phase 1 / Phase 2 / Phase 4 reviewer-1 + triage and `--dev` fast mode now route to Opus (top available tier); fallback ladder is `opus -> sonnet`. Per-task cost guard (`costBudget`) now defaults on in warn mode. Token economy: Phase 4 shared cache prefix + single-repo diff cap, Phase 1 light Explore tier for small bugfixes, triage prior-art injection capped.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "10.3.0",
+  "version": "10.4.0",
   "description": "8-phase AI development pipeline with full orchestration on Claude Code, Copilot CLI, Cursor, Antigravity, and VS Code Copilot Chat. Analysis, planning, TDD, CLI-aware parallel review with consensus surfacing + Opus triage, default-FAIL evidence gates, secret + intent guards, per-phase cost ledger, persistent learnings memory, wiki generation, commit automation. Token-preserving uninstall.",
   "type": "module",
   "main": "index.js",

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

@@ -20,6 +20,8 @@ Phase 7: Report     → Jira / Wiki + log + knowledge/memory
 
 `--dev local` skips Phase 1 (Analysis), Phase 2 (Planning + Approval Gate), Phase 4 (Review), and Phase 5 (User Test  -  local/autopilot variants skip the interactive test gate). It differs from `--dev` on two axes: no git worktree is created (development happens directly on the current branch in `$PROJECT_ROOT`), and the interactive User Test phase is skipped.
 
+> **Want the quality tail afterwards?** Since this mode skips Review + Test, run [`/multi-agent:finish`](./finish.md) on the same branch when you're done to add parallel review, a build+test success gate, PR, and a Jira technical-analysis + test-scenario comment  -  without re-developing.
+
 ## When to use it
 
 - Quick bug fix or small feature  -  review overhead is unnecessary

package/pipeline/commands/multi-agent/finish.md

@@ -0,0 +1,98 @@
+---
+description: "Continue already-done LOCAL work through the pipeline tail: Review → Build+Test → Commit/PR → Report (technical analysis + Jira test-scenario comment). No dev phase."
+allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, AskUserQuestion, WebFetch, WebSearch, Skill
+---
+
+# multi-agent finish  -  Ship Local Work Through the Pipeline Tail
+
+> **Language (read FIRST)**: Before any status output, read `prefs.global.outputLanguage` and render every conversational line in it. `AskUserQuestion` and external payloads stay English. Full contract: `refs/rules.md` "Language Application".
+
+You already did the work locally  -  wrote code on the current branch and maybe tested it by hand (or ran `/multi-agent:local` / `/multi-agent:dev-local`, which skip Review + Test). `/multi-agent:finish` 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 `dev-local` / `local` (which skip 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`, `/multi-agent:local`, or `/multi-agent:dev-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:finish                       # current branch vs its base; resolve Jira id from branch name
+/multi-agent:finish DIJITAL-12345          # bind to an explicit Jira id for the Phase 7 comment
+/multi-agent:finish --base develop         # override the base branch for the diff
+/multi-agent:finish 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 4: Review        → deterministic gates + parallel review (Opus + Sonnet) + Opus triage
+Phase 5: Build+Test    → stack-aware build gate + run existing tests; SUCCESS required (automated, not the interactive user-test)
+Phase 6: Commit        → commit remaining local changes + push + open PR if none exists
+Phase 7: Report        → technical analysis + Jira comment with test scenarios (channels: Jira / PR / Confluence / Wiki)
+```
+
+Phases 1-3 (Analysis / Planning / Dev) are skipped by design  -  `finish` treats the current branch's local changes as the Phase 3 output.
+
+## 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/DIJITAL-XXXX` / `feature/DIJITAL-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 `dev-local`/`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 4 Review** — run per `refs/phases/phase-4-review.md` against the resolved diff: deterministic gates (Step 1.x), stack-specific parallel reviewers (Opus + Sonnet on Claude Code; +GPT on Copilot CLI), Opus 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.finish.autoFix == true`): auto-fix accepted blocking/important findings, then re-review the fix, before advancing.
+- **Phase 5 Build+Test** — 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/frontend 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 6 Commit/PR** — per `refs/phases/phase-6-commit.md`: stage + commit any remaining local changes with a conventional message (`{type}(scope): desc [DIJITAL-{id}]`), push, and open a PR **only if one does not already exist** for the branch. PR body per `refs/pipeline-output-formatting` and `rules/git-conventions` — `Ref: #N` / `Related: #N`, never `Closes/Fixes/Resolves`; NO AI/bot attribution anywhere.
+- **Phase 7 Report** — per `refs/phases/phase-7-report.md` + `channels.md`: produce the **technical analysis** and **test scenarios**, then post to the configured channels. Default content for `finish`: 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: Phase Tracker Contract
+
+**The phase tracker is mandatory.** Full spec: [`refs/tracker-contract.md`](./refs/tracker-contract.md). `finish` registers only its active phase set  -  `0:Init 4:Review 5:Build+Test 6:Commit 7:Report` (phases 1-3 are not part of the finish set; do not register tiles for them).
+
+```bash
+# Phase 0, first shell call (every CLI):
+bash $HOME/.claude/scripts/phase-tracker.sh init "$TASK_ID"
+for p in "0:Init" "4:Review" "5:Build+Test" "6:Commit" "7: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>
+```
+
+### Visual channel  -  Claude Code (native TaskList widget, required)
+
+Register one tile per phase in **strict creation 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: `refs/tracker-contract.md` "TaskCreate ordering (strict)".
+
+### 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:dev-local "DIJITAL-12345"     # develop locally (Init→Dev→Commit→Report, no review/test)
+# … you inspect / hand-test the change …
+/multi-agent:finish                        # now: review + build/test + PR + Jira analysis & test scenarios
+```

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

@@ -90,6 +90,7 @@ Dedicated commands (same as flags above):
   /multi-agent:local-autopilot "task"           = multi-agent "task" --local autopilot
   /multi-agent:dev-local "task"                 = multi-agent "task" --dev --local
   /multi-agent:dev-local-autopilot "task"       = multi-agent "task" --dev --local autopilot
+  /multi-agent:finish [jira-id] [autopilot]     Continue already-done LOCAL work: Review → Build+Test → PR → Jira analysis + test scenarios (no dev)
 
 ------------------------------------------------------------
 
@@ -296,6 +297,7 @@ Dedicated komutlar (yukarıdaki flag'lerin eşdeğeri):
   /multi-agent:local-autopilot "task"           = multi-agent "task" --local autopilot
   /multi-agent:dev-local "task"                 = multi-agent "task" --dev --local
   /multi-agent:dev-local-autopilot "task"       = multi-agent "task" --dev --local autopilot
+  /multi-agent:finish [jira-id] [autopilot]     Lokalde biten işi sürdür: Review → Build+Test → PR → Jira teknik analiz + test senaryoları (dev yok)
 
 ------------------------------------------------------------
 

package/pipeline/commands/multi-agent/refs/cross-cli-contract.md

@@ -6,11 +6,11 @@
 
 ---
 
-## 1. Command Inventory (34 commands)
+## 1. Command Inventory (35 commands)
 
 ```
 analysis, analysis-resolve, autopilot, build-optimize, channels, delete, dev,
-dev-autopilot, dev-local, dev-local-autopilot, diff-explain, garbage-collect,
+dev-autopilot, dev-local, dev-local-autopilot, diff-explain, finish, garbage-collect,
 help, issue, jira, kill, language, local, local-autopilot, log, manual-test,
 prune-logs, purge, refactor, resume, review, scan, search, setup, stack, status,
 sync, test, update
@@ -21,6 +21,7 @@ Categories:
 - **Interactive pickers** (single-purpose, not modes): `jira`, `issue`
 - **Full 8-phase modes**: `autopilot`, `local`, `local-autopilot`
 - **Fast modes** (Init -> Dev(Opus) -> Commit -> Report): `dev`, `dev-autopilot`, `dev-local`, `dev-local-autopilot`
+- **Tail modes** (run the pipeline tail over already-done local work): `finish`
 - **Ops commands** (one-shot, no worktree): `status`, `log`, `kill`, `purge`, `delete`, `resume`, `review`, `analysis`, `analysis-resolve`, `build-optimize`, `channels`, `scan`, `search`, `diff-explain`, `garbage-collect`, `prune-logs`
 - **Meta-ops**: `setup`, `sync`, `update`, `help`, `refactor`, `test`, `stack`, `manual-test`, `language`
 
@@ -28,7 +29,7 @@ Categories:
 
 ### 1.1 Figma component subphase skills
 
-In addition to the 34 top-level multi-agent commands, the figma-to-component pipeline ships platform-specific skills that multi-agent dispatches from Phase 3 (see `refs/component-dispatch.md`). The structure is **platform-parallel iOS + Android with a shared common pool**:
+In addition to the 35 top-level multi-agent commands, the figma-to-component pipeline ships platform-specific skills that multi-agent dispatches from Phase 3 (see `refs/component-dispatch.md`). The structure is **platform-parallel iOS + Android with a shared common pool**:
 
 | Location | Skill count | Purpose |
 |---|---|---|
@@ -310,7 +311,7 @@ For clipboard ops, callers still gate with `if command -v pbpaste >/dev/null; th
 
 This contract is validated by:
 
-- `smoke-cross-cli-behavior.sh`  -  asserts all 34 commands behave identically, pulls from Section 2 (placeholder vocab), Section 5 (argument parsing), Section 6 (output formats); also regression-locks the 6-persona agent deployment
+- `smoke-cross-cli-behavior.sh`  -  asserts all 35 commands behave identically, pulls from Section 2 (placeholder vocab), Section 5 (argument parsing), Section 6 (output formats); also regression-locks the 6-persona agent deployment
 - `smoke-commands-skills-parity.sh` (50 assertions)  -  enforces colon-form command ↔ dash-form skill directory parity
 - `smoke-compliance-skills.sh` (45 assertions)  -  enforces store-compliance skill catalog + 4 consumer wiring
 - `smoke-personal-data.sh`  -  extended in 0.5.5 to treat deprecated placeholders (`{github-username}`, `{your-website}`, `{website-repo}`) as leaks; adds `mmerterden` to public-handle blocklist for generic docs

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

@@ -9,6 +9,8 @@ argument-hint: "[#id]  -  optional: task ID (e.g. #2). If omitted, the most rece
 
 Resume a paused or failed task from the last successful phase.
 
+> **Not the same as `/multi-agent:finish`.** `resume` continues a **tracked pipeline task** (needs its `agent-state.json`/worktree) from where it stopped. `/multi-agent:finish` 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.
+
 ## Steps
 
 1. **Find the task**  -  parse `#N` from the argument, or pick the most recent worktree with `status != "done"`.

package/pipeline/commands/multi-agent/sync.md

@@ -61,7 +61,7 @@ Run every step automatically:
 Step 0: FIGMA_SYNC  SKIP (deprecated  -  feedback_figma_source_deprecated)
 Step 1: PLATFORM    Detect macOS / Linux / Windows (Git Bash / WSL); export PLATFORM env
 Step 1.5: DETECT    Compare timestamps, find stale targets
-Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 34 sub-command skills)
+Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 35 sub-command skills)
 Step 2a: CODEX      Claude Code -> Codex CLI (global ~/.codex prompt + AGENTS.md + config.toml mcp)
                      -  runs via `node pipeline/scripts/sync-adapters.mjs`, which fires the
                         codex adapter ONCE (global) when `~/.codex` exists on this machine
@@ -302,11 +302,11 @@ This step runs only on the Claude <-> Copilot axis. Cursor / Copilot Chat do not
 |-------------|-------------|
 | `~/.claude/commands/multi-agent/{cmd}.md` | `~/.copilot/skills/multi-agent-{cmd}/SKILL.md` |
 
-**34 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
+**35 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
 
 ```
 analysis, analysis-resolve, autopilot, build-optimize, channels, delete, dev,
-dev-autopilot, dev-local, dev-local-autopilot, diff-explain, garbage-collect,
+dev-autopilot, dev-local, dev-local-autopilot, diff-explain, finish, garbage-collect,
 help, issue, jira, kill, language, local, local-autopilot, log, manual-test,
 prune-logs, purge, refactor, resume, review, scan, search, setup, stack, status,
 sync, test, update

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

@@ -0,0 +1,47 @@
+---
+name: multi-agent-finish
+language: en
+description: "Continue already-done LOCAL work through the pipeline tail: Review → Build+Test → Commit/PR → Report (technical analysis + Jira test-scenario comment). No dev phase."
+user-invocable: true
+---
+
+# multi-agent finish  -  Ship Local Work Through the Pipeline Tail
+
+You already wrote (and maybe hand-tested) the change on the current branch  -  or ran `dev-local` / `local`, which skip Review + Test. `finish` picks up from there and runs the **pipeline tail** over that existing local work in one command, without re-developing.
+
+## Pipeline
+
+```
+Phase 0: Init          → project/branch detect, resolve base + diff (work already done), Jira id, state (NO worktree)
+Phase 4: Review        → deterministic gates + parallel review + Opus triage
+Phase 5: Build+Test    → stack-aware build + run existing tests; SUCCESS required (automated gate, not the interactive user-test)
+Phase 6: Commit        → commit remaining changes + push + open PR if none exists
+Phase 7: Report        → technical analysis + Jira comment with test scenarios (channels: Jira / PR / Confluence / Wiki)
+```
+
+Phases 1-3 (Analysis / Planning / Dev) are skipped by design  -  the branch's local diff IS the input.
+
+## When to use it
+
+- After `dev-local` / `local` (which skip Review + Test) to run the full quality tail on the same branch.
+- After hand-coding / hand-testing a change, to get review + build/test + PR + Jira write-up without re-running dev.
+
+## When NOT to use it
+
+- Change not written yet → `multi-agent` / `multi-agent:local` / `multi-agent:dev-local`.
+- Only the review → `multi-agent:review`; only report/channels → `multi-agent:channels`; only device UI test → `multi-agent:test` / `multi-agent:manual-test`.
+
+## Input
+
+```bash
+multi-agent finish                 # current branch vs base; Jira id from branch name
+multi-agent finish DIJITAL-12345    # explicit Jira id for the Phase 7 comment
+multi-agent finish --base develop   # override base branch for the diff
+multi-agent finish autopilot        # no gate prompts: auto-fix, auto-PR, auto-comment
+```
+
+## Notes
+
+- Build+Test is the automated success gate (not the interactive device user-test  -  that is `multi-agent:manual-test`). If the repo has no tests, it reports "no tests present"  -  never fabricates results.
+- 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/finish.md`; this skill is the Copilot-CLI counterpart.