@mmerterden/multi-agent-pipeline 10.3.0 → 10.5.0

package/CHANGELOG.md

@@ -14,6 +14,60 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ---
 
+## [10.5.0] - 2026-07-02
+
+Stack skills move from the local `stack-swap` mechanic to versioned marketplace plugins.
+
+### Added
+
+- **`build-stack-plugins.mjs`** — rebuilds each stack plugin's `knowledge/`
+  layer in the `{owner}/multi-agent-plugins` marketplace from the pipeline's
+  authoring source (`pipeline/skills/shared/external/`), regenerates each
+  `plugin.json` `skills[]`, and **bumps the patch version of any plugin whose
+  skill set changed**. Idempotent (`--dry-run` supported); a no-op run bumps
+  nothing. Cross-stack skills (accessibility audit, humanizer, Firebase) route
+  to `ai-common-engineering-toolkit`; Apple/Xcode-only skills stay in the iOS
+  plugin. This is the version-based-management backbone: the pipeline is the
+  single authoring source, the marketplace is a derived, versioned artifact.
+- **`multi-agent:sync` Step 3c (PLUGINS)** — runs the generator, then commits +
+  pushes the plugins repo when a plugin version was bumped.
+
+### Changed
+
+- **`/multi-agent:stack`** — selecting a stack no longer moves skill directories
+  via `stack-swap.sh`. It now enables the matching marketplace plugin(s) (stack
+  toolkit + `ai-common-engineering-toolkit`) in the current repo's
+  `.claude/settings.json` `enabledPlugins`, disabling the stack toolkits that
+  don't apply. Declarative, per-repo, versioned. No SessionStart hook.
+- **`/multi-agent:update`** — added a step that refreshes the plugin marketplace
+  (`claude marketplace update multi-agent-plugins`) so the latest published
+  plugin versions are picked up alongside the pipeline update.
+
+### Deprecated
+
+- **`stack-swap.sh`** — no longer wired to any SessionStart hook. Retained for
+  manual/offline use only; stack selection is now plugin enablement.
+
+## [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.
@@ -527,7 +528,7 @@ Stack is auto-detected. Build commands, test runners, lint tools, and review foc
 | Fastest | `/multi-agent:dev-autopilot "task"` | `multi-agent-dev-autopilot "task"` | Zero interaction |
 | Test | `/multi-agent:test` | `multi-agent-test` | UI Bug Hunter - visual + accessibility |
 | Channels | `/multi-agent:channels <target>` | `multi-agent-channels <target>` | Post report to Jira / Confluence / Wiki / PR (multi-select, humanizer pass, reviewer-preserving) |
-| Stack | `/multi-agent:stack ios` | `multi-agent-stack ios` | Manually swap skill set per platform |
+| Stack | `/multi-agent:stack ios` | `multi-agent-stack ios` | Select stack by enabling the matching marketplace plugin(s) |
 | Language | `/multi-agent:language [prompt\|output] <en\|tr>` | `multi-agent-language [prompt\|output] <en\|tr>` | Toggle `promptLanguage` (interactive prompts) and/or `outputLanguage` (assistant explanations). External payloads stay English. |
 
 ## UI Bug Hunter + Audit Tools
@@ -562,22 +563,22 @@ All audits run via **direct Bash commands** - no MCP server dependency. Pipeline
 
 **No external dependencies** - only standard Xcode CLI tools (iOS) and Android SDK (Android). Platform guides include **compliance rules** that map 1:1 to audit checks - follow the guide, pass the audit.
 
-## Stack Swap
+## Stack Selection (marketplace plugins)
 
-Stack is auto-detected at session start by `pipeline/scripts/stack-swap.sh` (SessionStart hook) based on project markers (`.xcodeproj`, `build.gradle`, `package.json`, etc.). To override manually:
+Stack skills ship as versioned plugins in the `{owner}/multi-agent-plugins` marketplace. Selecting a stack **enables the matching plugin(s)** in the repo's `.claude/settings.json` `enabledPlugins` — the stack toolkit plus `ai-common-engineering-toolkit` (cross-stack skills). This replaced the old `stack-swap.sh` mechanic (which physically moved skill directories on a SessionStart hook); enablement is now declarative, per-repo, and versioned.
 
 ```bash
 # Claude Code                              # Copilot CLI
-/multi-agent:stack                          multi-agent-stack                # show current
-/multi-agent:stack ios                      multi-agent-stack ios            # SwiftUI + Xcode
-/multi-agent:stack android                  multi-agent-stack android        # Compose + Gradle
-/multi-agent:stack backend                  multi-agent-stack backend        # Python/Node/Go
-/multi-agent:stack frontend                 multi-agent-stack frontend       # React/Vue/Next
-/multi-agent:stack mobile                   multi-agent-stack mobile         # iOS + Android
-/multi-agent:stack all                      multi-agent-stack all            # load everything
+/multi-agent:stack                          multi-agent-stack                # show enabled plugins
+/multi-agent:stack ios                      multi-agent-stack ios            # SwiftUI toolkit + common
+/multi-agent:stack android                  multi-agent-stack android        # Compose toolkit + common
+/multi-agent:stack backend                  multi-agent-stack backend        # Python/Node toolkit + common
+/multi-agent:stack frontend                 multi-agent-stack frontend       # React/TSX toolkit + common
+/multi-agent:stack mobile                   multi-agent-stack mobile         # iOS + Android + common
+/multi-agent:stack all                      multi-agent-stack all            # all four toolkits + common
 ```
 
-Re-runs `stack-swap.sh` with a forced mode and loads the matching guide (`swiftui-guide.md`, `android-guide.md`, `backend-guide.md`, `frontend-guide.md`).
+Add the marketplace once with `claude marketplace add {owner}/multi-agent-plugins`. Newly published plugin versions are pulled by `/multi-agent:update`. The plugins are rebuilt from `pipeline/skills/shared/external/` via `pipeline/scripts/build-stack-plugins.mjs` (run by `multi-agent:sync` Step 3c), which bumps the patch version of any plugin whose skill set changed. `stack-swap.sh` is retained for manual/offline use but is no longer wired to any hook.
 
 ## Setup
 
@@ -637,7 +638,8 @@ Runs unit tests, smoke suites, eval fixtures, schema validation, and lint - the
 | Script                 | Purpose                                          |
 | ---------------------- | ------------------------------------------------ |
 | `pre-commit-check.sh`  | Secret detection before commits                  |
-| `stack-swap.sh`        | Auto-detect project stack on session start       |
+| `build-stack-plugins.mjs` | Rebuild stack plugins from `shared/external`, bump changed plugin versions |
+| `stack-swap.sh`        | Legacy stack skill-dir swap (manual/offline; no longer hooked) |
 | `keychain-save.sh`     | Save tokens/JSON to macOS Keychain (interactive) |
 | `keychain.py`          | Deterministic Python Keychain helper (get/set/delete/list/doctor); shell driver auto-delegates on macOS/Linux |
 | `github-ssh-setup.sh`  | GitHub SSH key generation + config               |
@@ -782,7 +784,8 @@ pipeline/
       01-10/                    10 adversarial eval fixtures
   scripts/
     pre-commit-check.sh         Secret detection hook
-    stack-swap.sh               Auto stack detection (SessionStart)
+    build-stack-plugins.mjs     Rebuild stack plugins + version bump
+    stack-swap.sh               Legacy stack swap (manual; no longer hooked)
     keychain-save.sh            Save tokens/JSON to macOS Keychain
     github-ssh-setup.sh         GitHub SSH key generation + setup
     ui-tree-dumper.swift        iOS accessibility tree dumper

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "10.3.0",
+  "version": "10.5.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)
 
 ------------------------------------------------------------
 
@@ -119,7 +120,7 @@ Setup & Maintenance:
 
   /multi-agent:setup          First-run wizard  -  Keychain tokens + Git identity + language
   /multi-agent:language [en|tr]   Show or set outputLanguage (promptLanguage stays English)
-  /multi-agent:stack <id>     Manually switch active skill set (ios / android / backend / frontend / fullstack / all)
+  /multi-agent:stack <id>     Select stack by enabling the matching marketplace plugin(s) (ios / android / backend / frontend / fullstack / all)
   /multi-agent:sync           Sync ecosystem (Claude Code + Copilot CLI + pipeline + website + remote-control)
   /multi-agent:update         Pull latest pipeline + reinstall + run migrations
   /multi-agent:delete         Uninstall pipeline from every CLI (Keychain tokens left intact, double confirm)
@@ -176,7 +177,7 @@ Key Features:
 
   Multi-Platform   iOS, Android, Backend, Frontend  -  auto-detected
   Build Queue      xcodebuild/Gradle serialized with lock file  -  parallel safe
-  Stack Aware      Auto-detects iOS/Android/Python/Node/Go/Docker, loads matching skill set
+  Stack Aware      Auto-detects iOS/Android/Python/Node/Go/Docker, uses the enabled stack plugin's skills
   Det. Gates       Build + lint + test + secret scan BEFORE AI review
   Multi-Repo       Per-repo worktrees, per-repo identity, integration build before commit
   Identity Routing Git identity auto-picked from repo origin URL (corporate vs personal)
@@ -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)
 
 ------------------------------------------------------------
 
@@ -325,7 +327,7 @@ Setup & Maintenance:
 
   /multi-agent:setup              İlk kurulum sihirbazı  -  Keychain token + Git kimliği + dil
   /multi-agent:language [en|tr]   outputLanguage'ı göster veya ayarla (promptLanguage İngilizce kalır)
-  /multi-agent:stack <id>         Aktif skill set'i manuel değiştir (ios / android / backend / frontend / fullstack / all)
+  /multi-agent:stack <id>         Stack'i eşleşen marketplace plugin'i etkinleştirerek seç (ios / android / backend / frontend / fullstack / all)
   /multi-agent:sync               Ekosistemi senkronize et (Claude Code + Copilot CLI + pipeline + website + remote-control)
   /multi-agent:update             En son pipeline'ı çek + reinstall + migration çalıştır
   /multi-agent:delete             Pipeline'ı tüm CLI'lerden kaldır (Keychain token dokunulmaz, çift onay)
@@ -382,7 +384,7 @@ Temel Özellikler:
 
   Multi-Platform   iOS, Android, Backend, Frontend  -  otomatik tespit
   Build Queue      xcodebuild/Gradle lock file ile seri  -  parallel güvenli
-  Stack Aware      iOS/Android/Python/Node/Go/Docker algılanır, eşleşen skill set yüklenir
+  Stack Aware      iOS/Android/Python/Node/Go/Docker algılanır, etkin stack plugin'inin skilleri kullanılır
   Det. Gates       AI review'dan ÖNCE build + lint + test + secret scan
   Multi-Repo       Repo başına worktree, repo başına identity, commit öncesi entegrasyon build'i
   Identity Routing Repo origin URL'sinden git kimliği seçimi (kurumsal vs kişisel)

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/stack.md

@@ -1,48 +1,94 @@
 ---
-description: "Manually switch the active skill set by platform (ios/android/mobile/backend/frontend/fullstack/all)."
-allowed-tools: Bash
+description: "Select the active stack for this repo by enabling the matching marketplace plugin(s) in .claude/settings.json (ios/android/mobile/backend/frontend/fullstack/all)."
+allowed-tools: Bash, Read, Edit, Write
 ---
 
-# multi-agent stack  -  Manual Stack Swap
+# multi-agent stack  -  Select Stack via Plugin Enablement
 
-The `pipeline/scripts/stack-swap.sh` SessionStart hook auto-detects the stack from the project. This command manually overrides that decision  -  it switches the active skill set in `~/.claude/skills/` and moves the non-matching skills to `~/.claude/skills-inactive/`.
+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`. The `ai-common-engineering-toolkit` (accessibility audit, humanizer, Firebase) is always enabled alongside the stack plugin.
+
+This replaces the old `stack-swap.sh` mechanic that physically moved skill directories in `~/.claude/skills/`. There is no SessionStart hook and no directory shuffling — enablement is declarative, per-repo, and versioned.
 
 ## Usage
 
 ```bash
-/multi-agent:stack                 # show current state
-/multi-agent:stack ios             # SwiftUI + Xcode
-/multi-agent:stack android         # Compose + Gradle
-/multi-agent:stack mobile          # iOS + Android together
-/multi-agent:stack backend         # Python / Node / Go
-/multi-agent:stack frontend        # React / Vue / Next
-/multi-agent:stack fullstack       # backend + frontend
-/multi-agent:stack all             # activate everything
+/multi-agent:stack                 # show which plugins are enabled here
+/multi-agent:stack ios             # SwiftUI toolkit + common
+/multi-agent:stack android         # Compose toolkit + common
+/multi-agent:stack mobile          # iOS + Android + common
+/multi-agent:stack backend         # Python / Node spec-driven toolkit + common
+/multi-agent:stack frontend        # React / TSX toolkit + common
+/multi-agent:stack fullstack       # frontend + backend + common
+/multi-agent:stack all             # all four stack toolkits + common
 ```
 
+## Stack → plugin map
+
+| Stack | Plugins enabled (all `@multi-agent-plugins`) |
+|---|---|
+| `ios` | `ai-common-engineering-toolkit`, `ai-ios-engineering-toolkit` |
+| `android` | `ai-common-engineering-toolkit`, `ai-android-engineering-toolkit` |
+| `frontend` | `ai-common-engineering-toolkit`, `ai-frontend-engineering-toolkit` |
+| `backend` | `ai-common-engineering-toolkit`, `ai-backend-toolkit` |
+| `mobile` | common + `ai-ios-engineering-toolkit` + `ai-android-engineering-toolkit` |
+| `fullstack` | common + `ai-frontend-engineering-toolkit` + `ai-backend-toolkit` |
+| `all` | common + all four stack toolkits |
+
 ## Behaviour
 
-1. No arg → status mode: print the active skill count, do **not** move any files.
-2. Arg present → run `$HOME/.claude/scripts/stack-swap.sh <arg>`.
-3. The script prints JSON on stdout (`{"systemMessage": "..."}`)  -  show the `systemMessage` value to the user.
-4. Unknown arg → the script returns `exit 1` with an error message; do not re-prompt, show the list to the user.
+1. **No arg → status mode.** Read `.claude/settings.json` (repo) + `~/.claude/settings.json` (global) and print which `@multi-agent-plugins` plugins are currently enabled. Do not modify anything.
+2. **Arg present → enable mode.** Ensure the marketplace is known, then write the matching `enabledPlugins` entries into the **current repo's** `.claude/settings.json`, disabling the stack toolkits that don't belong to the selected stack. `ai-common-engineering-toolkit` is always set to `true`.
+3. **Unknown arg** → show the list above; do not guess.
 
 ## Implementation
 
 ```bash
-SCRIPT="$HOME/.claude/scripts/stack-swap.sh"
+REPO_SETTINGS=".claude/settings.json"
+MP="multi-agent-plugins"
+ARG="${1:-status}"
 
-if [ ! -x "$SCRIPT" ]; then
-  echo "stack-swap.sh not found at $SCRIPT  -  run install.js --all to deploy pipeline scripts."
-  exit 1
+# --- ensure the marketplace is known (idempotent) -------------------------
+if ! claude marketplace list 2>/dev/null | grep -q "$MP"; then
+  claude marketplace add {owner}/multi-agent-plugins 2>/dev/null \
+    || echo "note: add the marketplace once with: claude marketplace add {owner}/multi-agent-plugins"
 fi
 
-ARG="${1:-status}"
-"$SCRIPT" "$ARG"
+COMMON="ai-common-engineering-toolkit@${MP}"
+IOS="ai-ios-engineering-toolkit@${MP}"
+ANDROID="ai-android-engineering-toolkit@${MP}"
+FRONTEND="ai-frontend-engineering-toolkit@${MP}"
+BACKEND="ai-backend-toolkit@${MP}"
+
+if [ "$ARG" = "status" ]; then
+  echo "Enabled multi-agent plugins (repo + global):"
+  { [ -f "$REPO_SETTINGS" ] && cat "$REPO_SETTINGS"; cat "$HOME/.claude/settings.json"; } 2>/dev/null \
+    | grep -oE "ai-[a-z-]+@${MP}\"[[:space:]]*:[[:space:]]*(true|false)" | sort -u
+  exit 0
+fi
+
+# resolve the desired ON set
+case "$ARG" in
+  ios)       ON="$COMMON $IOS" ;;
+  android)   ON="$COMMON $ANDROID" ;;
+  frontend)  ON="$COMMON $FRONTEND" ;;
+  backend)   ON="$COMMON $BACKEND" ;;
+  mobile)    ON="$COMMON $IOS $ANDROID" ;;
+  fullstack) ON="$COMMON $FRONTEND $BACKEND" ;;
+  all)       ON="$COMMON $IOS $ANDROID $FRONTEND $BACKEND" ;;
+  *) echo "Unknown stack '$ARG'. One of: ios android mobile backend frontend fullstack all"; exit 1 ;;
+esac
 ```
 
+After resolving `$ON`, edit `.claude/settings.json` (create `{ "enabledPlugins": {} }` if absent) so that:
+- every plugin in `$ON` is set to `true`,
+- every stack toolkit **not** in `$ON` is set to `false` (leave non-`@multi-agent-plugins` entries untouched),
+- `ai-common-engineering-toolkit@multi-agent-plugins` is always `true`.
+
+Use the Read + Edit/Write tools (JSON must stay valid). Then print the resulting `enabledPlugins` block.
+
 ## Notes
 
-- A manual swap takes effect immediately, but to refresh Claude Code's skill discovery completely, **restart the conversation**.
-- If you want auto-detect to take over again, the next SessionStart is enough  -  the hook re-evaluates `cwd`. Manual overrides are not persisted.
-- Pipeline Phase 1 stack detection is independent of this command (it reads project files). `stack` only affects which skill set is active.
+- Enablement is per-repo and declarative — commit `.claude/settings.json` so teammates get the same stack.
+- Restart the conversation (or reload the window) for Claude Code to pick up newly enabled plugins.
+- Pipeline Phase 1 stack detection is independent (it reads project files); `stack` only sets which plugin skill set is active.
+- Legacy: `~/.claude/scripts/stack-swap.sh` is retained for manual/offline use but is no longer wired to any hook. Prefer plugin enablement.

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

@@ -70,6 +70,8 @@ Step 2b: ADAPTERS   Cursor / Antigravity / Copilot Chat per-project rule files r
                      -  `--no-adapters` skips this step entirely
                      -  writes files + a LOCAL commit per project; push stays the user's call
 Step 3: REPO        Claude Code -> pipeline repo (genericized, personal data scrub, bash -n on all sh)
+Step 3c: PLUGINS    pipeline shared/external -> multi-agent-plugins marketplace (rebuild knowledge/,
+                     bump changed plugins' patch version, commit + push the plugins repo)
 Step 4: WEBSITE     Version + phase/model counts -> {website-host} (i18n + projects.ts)
 Step 5: REMOTE      Pipeline references -> remote-control README
 Step 6: Commit      Commit + push all changed repos
@@ -215,7 +217,7 @@ Adapter sync orchestration goes through `pipeline/scripts/sync-adapters.mjs`  -
 5. **Files NOT synced** (local-only, may contain personal data):
    - `~/.claude/multi-agent-preferences.json`
    - `~/.claude/CLAUDE.md`, `~/.claude/rules/`, `~/.claude/knowledge/`
-   - `~/.claude/scripts/`  -  EXCEPT `pre-commit-check.sh` and `stack-swap.sh` (generic, synced)
+   - `~/.claude/scripts/`  -  EXCEPT `pre-commit-check.sh`, `stack-swap.sh` (legacy, retained for manual use), and `build-stack-plugins.mjs` (generic, synced)
    - `~/.claude/settings.json`
 
 6. **Cross-platform smoke gate** (final step of the REPO sync, before push):
@@ -234,6 +236,48 @@ Adapter sync orchestration goes through `pipeline/scripts/sync-adapters.mjs`  -
 
 ---
 
+## Stack-Plugin Sync (Step 3c)
+
+Stack skills are distributed as versioned plugins in the `{owner}/multi-agent-plugins` marketplace. The pipeline's `pipeline/skills/shared/external/` is the **single authoring source**; the marketplace is a derived, versioned publish artifact. This step rebuilds it and publishes only when something changed.
+
+**Source of truth:** author/vendor knowledge skills in `pipeline/skills/shared/external/` (the pipeline's own phases also consume them). The plugins' authored lifecycle skills (`index` / `reference` / `workflow` / `tools`) live in the plugins repo and are never touched by sync.
+
+**Flow:**
+
+```bash
+PLUGINS_REPO="$HOME/multi-agent-plugins"
+[ ! -d "$PLUGINS_REPO/.git" ] && gh repo clone {owner}/multi-agent-plugins "$PLUGINS_REPO"
+cd "$PLUGINS_REPO" && git pull origin main
+
+# 1. Preview what would change (routing + version bumps), no writes:
+node "$HOME/multi-agent-pipeline/pipeline/scripts/build-stack-plugins.mjs" --dry-run
+
+# 2. Apply: rebuild each stack plugin's knowledge/ from shared/external,
+#    regenerate plugin.json skills[], bump the patch version of any plugin
+#    whose skill set changed. Cross-stack skills -> ai-common-engineering-toolkit;
+#    Apple/Xcode-only skills -> iOS plugin only.
+node "$HOME/multi-agent-pipeline/pipeline/scripts/build-stack-plugins.mjs"
+```
+
+**Version-based management:** the generator bumps a plugin's `version` (patch) only when its skill set actually changed. Idempotent — a no-op run bumps nothing. Consumers pick up new versions via `/multi-agent:update` (which runs `claude marketplace update multi-agent-plugins`).
+
+**Publish (only if the generator reported bumps):**
+
+```bash
+cd "$PLUGINS_REPO"
+if ! git diff --quiet; then
+  git config user.name "$(git config user.name)"; git config user.email "$(git config user.email)"
+  git add -A
+  git commit -m "chore: rebuild stack plugins from pipeline shared/external"
+  gh auth switch --user {owner} 2>/dev/null || true
+  git push origin main
+fi
+```
+
+Never author skills directly in the plugins repo's `knowledge/` — they will be overwritten on the next rebuild. Author in `shared/external`, then run this step.
+
+---
+
 ## Website Sync (Step 4)
 
 Propagate pipeline version, phase count, model count, and feature descriptions to the website.

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

@@ -17,7 +17,7 @@ Update the pipeline in one command. Existing preferences are preserved; only ski
    done
    if [ -z "$PIPE_DIR" ]; then
      echo "Pipeline repo not found. Clone it:"
-     echo "  git clone git@github.com:mmerterden/multi-agent-pipeline.git"
+     echo "  git clone git@github.com:{owner}/multi-agent-pipeline.git"
      exit 1
    fi
    ```
@@ -38,6 +38,19 @@ Update the pipeline in one command. Existing preferences are preserved; only ski
    node "$PIPE_DIR/install.js" --all
    ```
 
+4b. **Update the stack-plugin marketplace** (pulls the latest plugin versions):
+   ```bash
+   # Stack skills ship as versioned plugins in {owner}/multi-agent-plugins.
+   # Refresh the marketplace so newly published plugin versions are picked up.
+   if claude marketplace list 2>/dev/null | grep -q "multi-agent-plugins"; then
+     claude marketplace update multi-agent-plugins 2>/dev/null \
+       || claude marketplace add {owner}/multi-agent-plugins 2>/dev/null
+     echo "  -> marketplace multi-agent-plugins refreshed"
+   else
+     echo "  -> marketplace not added yet; add with: claude marketplace add {owner}/multi-agent-plugins"
+   fi
+   ```
+
 5. **Migrate preferences** (if there is an old schema):
    ```bash
    if [ -f "$HOME/.claude/scripts/migrate-prefs.mjs" ]; then

package/pipeline/scripts/build-stack-plugins.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * build-stack-plugins.mjs
+ *
+ * Rebuild the per-stack plugin `knowledge/` trees in the multi-agent-plugins
+ * marketplace from the pipeline's authoring source (pipeline/skills/shared/external),
+ * regenerate each plugin.json `skills[]`, and bump the patch version of any plugin
+ * whose skill set changed. This is the version-based management backbone: the
+ * pipeline is the single authoring source; the marketplace is a derived, versioned
+ * publish artifact.
+ *
+ * The authored lifecycle skills (index / reference / workflow / tools) live in the
+ * plugin repo and are NEVER touched here — only the `knowledge/` layer + plugin.json
+ * knowledge entries are regenerated.
+ *
+ * Routing mirrors pipeline/scripts/stack-swap.sh patterns. Genuinely cross-stack
+ * skills go to ai-common-engineering-toolkit (not into each stack plugin). Apple/
+ * Xcode-only vendored skills that match no stack pattern belong to iOS only.
+ *
+ * Usage:
+ *   node build-stack-plugins.mjs [--plugins-repo <path>] [--pipeline <path>] [--dry-run]
+ *
+ * Exit code 0 always (report-only); prints a JSON-ish summary + per-plugin diff.
+ */
+import {
+  readdirSync, existsSync, rmSync, cpSync, readFileSync, writeFileSync, mkdirSync, statSync,
+} from 'node:fs';
+import { join } from 'node:path';
+
+const args = process.argv.slice(2);
+const getArg = (k, d) => { const i = args.indexOf(k); return i >= 0 ? args[i + 1] : d; };
+const HOME = process.env.HOME;
+const PLUGINS_REPO = getArg('--plugins-repo', join(HOME, 'multi-agent-plugins'));
+const PIPE_ROOT = getArg('--pipeline', join(HOME, 'multi-agent-pipeline'));
+const EXTERNAL = join(PIPE_ROOT, 'pipeline/skills/shared/external');
+const DRY = args.includes('--dry-run');
+
+const COMMON_PLUGIN = 'ai-common-engineering-toolkit';
+const COMMON_SKILLS = ['accessibility-compliance-accessibility-audit', 'firebase', 'humanizer'];
+
+// Apple/Xcode-only skills that match no stack pattern → iOS plugin only.
+const APPLE_ONLY = [
+  'avkit', 'cryptokit', 'metrickit-diagnostics', 'pdfkit', 'spm-build-analysis',
+  'swiftlint', 'xcode-build-benchmark', 'xcode-build-fixer', 'xcode-build-orchestrator',
+  'xcode-compilation-analyzer', 'xcode-project-analyzer',
+];
+
+// stack → matching pattern (mirrors stack-swap.sh IOS/ANDROID/BACKEND/FRONTEND patterns)
+const STACK_PATTERNS = {
+  'ai-ios-engineering-toolkit': /(swiftui|swift-|ios-|hig-|apple-|storekit|widgetkit|healthkit|homekit|mapkit|musickit|passkit|pencilkit|realitykit|weatherkit|alarmkit|callkit|cloudkit|coreml|core-|eventkit|energykit|permissionkit|tipkit|shareplay|live-activities|background-processing|app-store|app-clips|app-intents|authentication|contacts-framework|device-integrity|macos-|natural-language|photos-camera|push-notifications|speech-recognition|swiftdata|vision-framework|debugging-instruments|help-skills)/i,
+  'ai-android-engineering-toolkit': /(android|compose-|kotlin-|room-database|retrofit-|gradle-|play-store)/i,
+  'ai-backend-toolkit': /(fastapi|nodejs|docker|api-pattern|api-security|github-actions|observability|architecture|monorepo|clean-code|debugging-strategies|agentflow|closed-loop|context-compression|python-patterns|database-patterns|rest-api-design|testing-backend|ci-cd-pipelines)/i,
+  'ai-frontend-engineering-toolkit': /(react-|nextjs-|typescript-|tailwind-|vue-|web-accessibility|web-performance|css-modern|web-testing|html-semantic)/i,
+};
+
+const isDir = (p) => { try { return statSync(p).isDirectory(); } catch { return false; } };
+const listDirs = (p) => (existsSync(p) ? readdirSync(p).filter((n) => isDir(join(p, n))) : []);
+
+// --- 1. enumerate authoring source ---------------------------------------
+if (!existsSync(EXTERNAL)) {
+  console.error(`source not found: ${EXTERNAL}`);
+  process.exit(0);
+}
+const allSkills = listDirs(EXTERNAL);
+
+// --- 2. compute desired knowledge set per plugin -------------------------
+const desired = { [COMMON_PLUGIN]: new Set() };
+for (const p of Object.keys(STACK_PATTERNS)) desired[p] = new Set();
+
+const unrouted = [];
+for (const skill of allSkills) {
+  if (COMMON_SKILLS.includes(skill)) { desired[COMMON_PLUGIN].add(skill); continue; }
+  if (APPLE_ONLY.includes(skill)) { desired['ai-ios-engineering-toolkit'].add(skill); continue; }
+  let matched = false;
+  for (const [plugin, re] of Object.entries(STACK_PATTERNS)) {
+    if (re.test(skill)) { desired[plugin].add(skill); matched = true; }
+  }
+  if (!matched) unrouted.push(skill);
+}
+
+// --- 3. sync each plugin's knowledge/ + regenerate plugin.json -----------
+const report = [];
+for (const [plugin, want] of Object.entries(desired)) {
+  const pdir = join(PLUGINS_REPO, 'plugins', plugin);
+  const kdir = join(pdir, 'skills', 'knowledge');
+  const pjPath = join(pdir, '.claude-plugin', 'plugin.json');
+  if (!existsSync(pjPath)) { report.push({ plugin, error: 'plugin.json missing' }); continue; }
+
+  const have = new Set(listDirs(kdir));
+  const toAdd = [...want].filter((s) => !have.has(s)).sort();
+  const toRemove = [...have].filter((s) => !want.has(s)).sort();
+  const changed = toAdd.length > 0 || toRemove.length > 0;
+
+  if (!DRY && changed) {
+    if (!existsSync(kdir)) mkdirSync(kdir, { recursive: true });
+    for (const s of toAdd) cpSync(join(EXTERNAL, s), join(kdir, s), { recursive: true });
+    for (const s of toRemove) rmSync(join(kdir, s), { recursive: true, force: true });
+  }
+
+  // regenerate plugin.json skills[]: keep non-knowledge entries, rebuild knowledge set
+  const pj = JSON.parse(readFileSync(pjPath, 'utf8'));
+  const nonKnowledge = (pj.skills || []).filter((s) => !s.startsWith('./skills/knowledge/'));
+  const finalKnowledge = (DRY ? [...want] : listDirs(kdir)).map((s) => `./skills/knowledge/${s}`);
+  const newSkills = [...new Set([...nonKnowledge, ...finalKnowledge])].sort();
+  const skillsChanged = JSON.stringify(pj.skills) !== JSON.stringify(newSkills);
+
+  const oldV = pj.version || '0.1.0';
+  let newV = oldV;
+  if (changed || skillsChanged) {
+    const [maj, min, patch] = oldV.split('.').map((n) => parseInt(n, 10) || 0);
+    newV = `${maj}.${min}.${patch + 1}`;
+  }
+  if (!DRY && (changed || skillsChanged)) {
+    pj.skills = newSkills;
+    pj.version = newV;
+    writeFileSync(pjPath, `${JSON.stringify(pj, null, 2)}\n`);
+  }
+  report.push({ plugin, added: toAdd, removed: toRemove, skillCount: newSkills.length, version: oldV === newV ? oldV : `${oldV} → ${newV}`, bumped: oldV !== newV });
+}
+
+// --- 4. report ------------------------------------------------------------
+console.log(`build-stack-plugins ${DRY ? '(dry-run)' : ''}`);
+console.log(`source: ${EXTERNAL} (${allSkills.length} skills)`);
+console.log(`target: ${PLUGINS_REPO}`);
+for (const r of report) {
+  if (r.error) { console.log(`  ✗ ${r.plugin}: ${r.error}`); continue; }
+  const flag = r.bumped ? 'BUMPED' : 'unchanged';
+  console.log(`  ${r.plugin}: skills=${r.skillCount} version=${r.version} [${flag}]`);
+  if (r.added.length) console.log(`      + ${r.added.join(', ')}`);
+  if (r.removed.length) console.log(`      - ${r.removed.join(', ')}`);
+}
+if (unrouted.length) {
+  console.log(`  ⚠ unrouted (matched no stack, not common/apple-only) — NOT copied anywhere:`);
+  console.log(`      ${unrouted.join(', ')}`);
+}
+const anyBump = report.some((r) => r.bumped);
+console.log(anyBump ? 'result: changes detected (versions bumped)' : 'result: all plugins up to date');

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.

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

@@ -1,55 +1,50 @@
 ---
 name: multi-agent-stack
 language: en
-description: "Manually switch the active skill set by platform (ios/android/mobile/backend/frontend/fullstack/all)."
+description: "Select the active stack for this repo by enabling the matching marketplace plugin(s) in .claude/settings.json (ios/android/mobile/backend/frontend/fullstack/all)."
 user-invocable: true
 ---
 
-# multi-agent stack  -  Manual Stack Swap
+# multi-agent stack  -  Select Stack via Plugin Enablement
 
-The `pipeline/scripts/stack-swap.sh` SessionStart hook auto-detects the stack from the project. This command manually overrides that decision  -  it changes the active skill set and moves non-matching skills to `skills-inactive/`.
+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`. The `ai-common-engineering-toolkit` (accessibility audit, humanizer, Firebase) is always enabled alongside the stack plugin.
+
+This replaces the old `stack-swap.sh` mechanic that physically moved skill directories. No SessionStart hook, no directory shuffling — enablement is declarative, per-repo, and versioned.
 
 ## Usage
 
 ```bash
-multi-agent-stack                  # show the current state
-multi-agent-stack ios              # SwiftUI + Xcode
-multi-agent-stack android          # Compose + Gradle
-multi-agent-stack mobile           # iOS + Android together
-multi-agent-stack backend          # Python / Node / Go
-multi-agent-stack frontend         # React / Vue / Next
-multi-agent-stack fullstack        # backend + frontend
-multi-agent-stack all              # activate everything
+multi-agent-stack                  # show which plugins are enabled here
+multi-agent-stack ios              # SwiftUI toolkit + common
+multi-agent-stack android          # Compose toolkit + common
+multi-agent-stack mobile           # iOS + Android + common
+multi-agent-stack backend          # Python / Node spec-driven toolkit + common
+multi-agent-stack frontend         # React / TSX toolkit + common
+multi-agent-stack fullstack        # frontend + backend + common
+multi-agent-stack all              # all four stack toolkits + common
 ```
 
-## Behaviour
+## Stack → plugin map
 
-1. No arg → status mode: show the active skill count, do **not** move any files.
-2. With an arg → run `stack-swap.sh <arg>`.
-3. The script's stdout is JSON (`{"systemMessage": "..."}`)  -  print the `systemMessage` value to the user.
-4. Unknown arg → the script returns `exit 1` + an error message; do not ask for the value again, show the user the list.
+| Stack | Plugins enabled (all `@multi-agent-plugins`) |
+|---|---|
+| `ios` | `ai-common-engineering-toolkit`, `ai-ios-engineering-toolkit` |
+| `android` | `ai-common-engineering-toolkit`, `ai-android-engineering-toolkit` |
+| `frontend` | `ai-common-engineering-toolkit`, `ai-frontend-engineering-toolkit` |
+| `backend` | `ai-common-engineering-toolkit`, `ai-backend-toolkit` |
+| `mobile` | common + `ai-ios-engineering-toolkit` + `ai-android-engineering-toolkit` |
+| `fullstack` | common + `ai-frontend-engineering-toolkit` + `ai-backend-toolkit` |
+| `all` | common + all four stack toolkits |
 
-## Implementation
+## Behaviour
 
-```bash
-# Both CLIs install pipeline scripts under their own home dir. Prefer Copilot's
-# own scripts if present; fall back to Claude Code's scripts when running under
-# --all install (shared machine, either CLI's copy is up-to-date).
-if [ -x "$HOME/.copilot/scripts/stack-swap.sh" ]; then
-  SCRIPT="$HOME/.copilot/scripts/stack-swap.sh"
-elif [ -x "$HOME/.claude/scripts/stack-swap.sh" ]; then
-  SCRIPT="$HOME/.claude/scripts/stack-swap.sh"
-else
-  echo "stack-swap.sh not found  -  run install.js --copilot (or --all) to deploy pipeline scripts."
-  exit 1
-fi
-
-ARG="${1:-status}"
-"$SCRIPT" "$ARG"
-```
+1. **No arg → status mode.** Read `.claude/settings.json` (repo) + the global settings and print which `@multi-agent-plugins` plugins are enabled. Modify nothing.
+2. **Arg present → enable mode.** Ensure the marketplace is known (`claude marketplace add {owner}/multi-agent-plugins`), then write the matching `enabledPlugins` entries into the current repo's `.claude/settings.json`, setting the stack toolkits that don't belong to `false`. `ai-common-engineering-toolkit` is always `true`.
+3. **Unknown arg** → show the list above; do not guess.
 
 ## Notes
 
-- A manual swap takes effect immediately, but to fully refresh Copilot CLI's skill discovery, **restart the conversation**.
-- If you want auto-detect to take over again, the next SessionStart is enough  -  the hook looks at `cwd` and decides again. The manual override is not permanent.
-- Pipeline Phase 1 stack detection is independent of this command (it looks at project files). `stack` only affects which skill set is active.
+- Enablement is per-repo and declarative — commit `.claude/settings.json` so teammates get the same stack.
+- Restart the conversation to pick up newly enabled plugins.
+- Pipeline Phase 1 stack detection is independent (it reads project files); `stack` only sets which plugin skill set is active.
+- Legacy: `stack-swap.sh` is retained for manual/offline use but is no longer wired to any hook.

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

@@ -90,7 +90,8 @@ If nothing is stale -> report "All targets up to date" and stop.
 5. **Files NOT synced** (local-only, may contain personal data):
    - `~/.claude/multi-agent-preferences.json`
    - `~/.claude/CLAUDE.md`, `~/.claude/rules/`, `~/.claude/knowledge/`
-   - `~/.claude/scripts/`  -  EXCEPT `pre-commit-check.sh` and `stack-swap.sh` (generic, synced)
+   - `~/.claude/scripts/`  -  EXCEPT `pre-commit-check.sh`, `stack-swap.sh` (legacy, retained), and `build-stack-plugins.mjs` (generic, synced)
+   - Step 3c (PLUGINS): rebuild the `{owner}/multi-agent-plugins` marketplace from `shared/external` via `build-stack-plugins.mjs` (bumps changed plugins' patch version), then commit + push the plugins repo
    - `~/.claude/settings.json`
 
 

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

@@ -16,6 +16,8 @@ Update the pipeline with a single command. Preferences are preserved; only skill
 2. Record the current version
 3. `git pull origin main`
 4. `node install.js --all` (Claude + Copilot)
+4b. Refresh the stack-plugin marketplace so the latest plugin versions are picked up:
+   `claude marketplace update multi-agent-plugins` (or `claude marketplace add {owner}/multi-agent-plugins` if not yet added)
 5. `node migrate-prefs.mjs` (if there is a schema upgrade)
 6. Show the new version + changelog
 7. Smoke test (schema + cross-cli)