@mmerterden/multi-agent-pipeline 10.5.0 → 10.7.0

package/CHANGELOG.md

@@ -14,6 +14,61 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ---
 
+## [10.7.0] - 2026-07-02
+
+The pipeline targets **Claude Code + Copilot CLI only**. The Cursor / Antigravity / VS Code Copilot Chat / OpenAI Codex CLI adapters are removed.
+
+### Removed
+
+- **All non-native adapters deleted.** `pipeline/adapters/` (Cursor, Antigravity,
+  Copilot Chat, Codex + orchestration variants), `pipeline/scripts/sync-adapters.mjs`,
+  `install/_adapters.mjs`, and the `smoke-adapters.sh` / `smoke-sync-adapters.sh` /
+  `smoke-shared-runtime.sh` smokes are gone.
+- Installer flags `--cursor` / `--copilot-chat` / `--antigravity` / `--codex` /
+  `--all-tools` removed; `install` now dispatches only Claude Code + Copilot CLI.
+- `multi-agent:sync` drops the Codex (Step 2a) and per-project adapter (Step 2b)
+  steps; the `--no-adapters` flag is retired. README, `phase-4-review`, and
+  `setup` adapter documentation removed.
+
+### Changed
+
+- **`multi-agent:update` prunes the retired global Codex adapter prompt**
+  (`~/.codex/prompts/multi-agent.md`). Per-project adapter files (`.cursor/`,
+  `.agent/`, `.github/copilot-instructions.md`) are left untouched — they live in
+  user repos; the `uninstall` command can still remove them selectively.
+
+## [10.6.0] - 2026-07-02
+
+Fable 5 restored as the top model tier; `stack-swap` fully removed; setup gains a default stack step.
+
+### Added
+
+- **`multi-agent:setup` Step 9 — default stack plugin enablement.** First-run
+  setup detects the project stack from markers (`.xcodeproj`/`Package.swift` → iOS,
+  `build.gradle` → Android, `package.json`+react → Frontend, `requirements.txt`/
+  `pyproject.toml` → Backend) and enables the matching marketplace plugin plus the
+  always-on `ai-common-engineering-toolkit`. **No clear marker → default iOS.** So a
+  fresh install works out of the box and a repo at any org gets its correct stack.
+
+### Changed
+
+- **Fable 5 is the top model tier again.** Architect (`ios/android/backend-architect`)
+  and Reviewer-1 (`code-reviewer`) personas declare `preferredModel: fable`. The tier
+  ladder is now `fable → opus → sonnet → haiku`: **if Fable 5 is unavailable, the first
+  fallback is Opus 4.8**, applied per-dispatch with no file edits. Security personas keep
+  opus. Reverses the 2026-06 "fable retired" state now that `claude-fable-5` is available.
+
+### Removed
+
+- **`stack-swap.sh` + `smoke-stack-swap.sh` deleted.** The SessionStart skill-dir-swap
+  mechanic is gone entirely; stack selection is marketplace-plugin enablement
+  (`/multi-agent:stack`). No dead code or legacy hook remains.
+
+### Fixed
+
+- Genericized a leaked corporate Jira key (`DIJITAL` → `PROJ`/`{JIRA_KEY}`) in the
+  `finish` command + skill so the personal-data gate passes.
+
 ## [10.5.0] - 2026-07-02
 
 Stack skills move from the local `stack-swap` mechanic to versioned marketplace plugins.

package/README.md

@@ -13,7 +13,7 @@
 |---|---|
 | 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 |
+| Platforms (Claude Code, Copilot CLI) | 2 |
 | Store-compliance skills (`apple-archive-compliance`, `google-play-compliance`) | 2 |
 | Figma skills (iOS + Android + Common) | 41 |
 | External skill catalog (`shared/external/`) | 143 |
@@ -25,7 +25,7 @@
 | Agent personas | 8 |
 | Pipeline phases | 8 |
 
-> Platform tiers, stated honestly: **Claude Code** and **Copilot CLI** run the full pipeline natively - the gate scripts + live tracker are installed to `~/.claude` / `~/.copilot`, and on Claude Code a `PreToolUse` hook hard-blocks on the secret scan. **Cursor, Antigravity, and VS Code Copilot Chat** (v9.4.0+) receive the orchestration workflow + subagents/agents + the dev-toolkit MCP server, AND the gate scripts are installed to a shared `~/.multi-agent/` runtime that the emitted agents invoke by absolute path - so the deterministic gates (evidence, secret, intent, consensus, cost) DO run there. The remaining gap vs Claude Code is enforcement strength: those three platforms have no `PreToolUse` hook, so the gates are workflow-enforced (the agent runs them as steps) rather than OS-blocked. See `refs/picker-contract.md`.
+> **Claude Code** and **Copilot CLI** run the full pipeline natively - the gate scripts + live tracker are installed to `~/.claude` / `~/.copilot`, and on Claude Code a `PreToolUse` hook hard-blocks on the secret scan.
 
 > Security issue? See [SECURITY.md](./SECURITY.md). Please do not open public issues for vulnerabilities.
 
@@ -72,14 +72,6 @@ node install.js                         # Claude Code (default)
 node install.js --copilot               # Copilot CLI
 node install.js --all                   # Both Claude + Copilot
 
-# Third-party AI tool adapters (knowledge layer only)
-node install.js --cursor                # Cursor (.cursor/rules/*.mdc + .cursorrules)
-node install.js --copilot-chat          # GitHub Copilot Chat (.github/copilot-instructions.md)
-node install.js --antigravity           # Antigravity (.agent/ + AGENTS.md)
-node install.js --codex                 # OpenAI Codex CLI (global: ~/.codex/prompts + config.toml)
-node install.js --all-tools             # Everything: 2 native (Claude + Copilot CLI) + 4 adapter targets
-node install.js --cursor --target=/path/to/repo   # Adapter target override (default: cwd)
-
 node install.js --link                  # Symlink mode (dev, saves ~10K tokens)
 node install.js --all --dry-run         # Preview every operation, write nothing
 
@@ -87,7 +79,6 @@ node install.js --all --dry-run         # Preview every operation, write nothing
 node install.js                         # ...later...
 node pipeline/scripts/uninstall.mjs --dry-run     # preview what would be removed
 node pipeline/scripts/uninstall.mjs --yes         # remove from every installed target
-node pipeline/scripts/uninstall.mjs --cursor      # selective uninstall
 
 # Optional: expose the CLI globally as 'multi-agent-pipeline'
 npm link
@@ -109,11 +100,6 @@ Update later with `git pull && npm install` inside the clone. Pin to a specific
 npx @mmerterden/multi-agent-pipeline install            # Claude Code only (default)
 npx @mmerterden/multi-agent-pipeline install --copilot  # Copilot CLI only
 npx @mmerterden/multi-agent-pipeline install --all      # Both native CLIs (Claude + Copilot)
-npx @mmerterden/multi-agent-pipeline install --cursor       # Cursor adapter (per-project, cwd)
-npx @mmerterden/multi-agent-pipeline install --copilot-chat # GitHub Copilot Chat adapter (per-project)
-npx @mmerterden/multi-agent-pipeline install --antigravity  # Antigravity adapter (per-project)
-npx @mmerterden/multi-agent-pipeline install --codex        # OpenAI Codex CLI (global ~/.codex)
-npx @mmerterden/multi-agent-pipeline install --all-tools    # Everything: 2 native + 4 adapter targets
 npx @mmerterden/multi-agent-pipeline install --link     # Symlink mode
 npx @mmerterden/multi-agent-pipeline install --all --dry-run  # Preview, write nothing
 
@@ -194,42 +180,27 @@ Earlier README revisions referenced GitHub Packages with a Classic PAT and `~/.n
 
 ## Tool support
 
-> **TL;DR** - Full pipeline orchestration runs on **Claude Code, Copilot CLI, Cursor, Antigravity, VS Code Copilot Chat, and OpenAI Codex CLI**. Claude Code and Copilot CLI run it natively; Cursor (`.cursor/agents` + `/multi-agent` command), Antigravity (`.agent/workflows` + rules), and VS Code Copilot Chat (`.github/agents` + `/multi-agent` prompt) run it via per-platform orchestration adapters, with the dev-toolkit MCP server registered automatically. Codex CLI runs it via a global adapter (`~/.codex/prompts/multi-agent.md` + `~/.codex/config.toml` MCP); since Codex has no subagent fan-out, its parallel review degrades to a sequential adversarial two-pass. Interactive pickers and hard gates degrade per `refs/picker-contract.md` (native dialog where available, else the `ask_user_choice` MCP tool or `pipeline/lib/ask-choice.sh`). Note: Gemini CLI is being folded into Antigravity (consumer support ends 2026-06-18), so Antigravity is the forward target.
-
-### Tier 1 - Full pipeline (orchestration + knowledge)
+The pipeline runs natively on **Claude Code** and **Copilot CLI** — the two CLIs it targets. Both install from the same `pipeline/skills/` source and get identical skill coverage.
 
 | Tool | Install Flag | How It Works |
 | --- | --- | --- |
 | **Claude Code** | `--claude` (default) | Native: slash commands + shared + figma skills + agents + rules + scripts |
 | **Copilot CLI** | `--copilot` | Native: instructions + shared + figma skills + scripts |
-| **Cursor** | `--cursor` | Adapter: `.cursor/agents/ma-*.md` subagents + `.cursor/commands/multi-agent.md` + rules + `.cursor/mcp.json` |
-| **Antigravity** | `--antigravity` | Adapter: `.agent/workflows/multi-agent.md` + `.agent/rules/` + `AGENTS.md` + `.agent/mcp_config.json` |
-| **VS Code Copilot Chat** | `--copilot-chat` | Adapter: `.github/agents/ma-*.agent.md` + `.github/prompts/multi-agent.prompt.md` + `.vscode/mcp.json` |
-| **OpenAI Codex CLI** | `--codex` | Global adapter: `~/.codex/prompts/multi-agent.md` + `~/.codex/AGENTS.md` + `~/.codex/config.toml` ([mcp_servers.dev-toolkit]) |
-
-Claude Code and Copilot CLI run the pipeline natively. Cursor, Antigravity, and VS Code Copilot Chat run it through per-platform orchestration adapters that transform the pipeline personas (`pipeline/agents/*.md`) into that platform's subagent/agent format and emit a `/multi-agent` command/workflow, registering the dev-toolkit MCP server automatically. Codex CLI is a global-config tool (its prompts + MCP live under `~/.codex`, with no per-project prompt directory), so its adapter installs globally and runs the `/multi-agent` slash command sequentially - Codex has no subagent fan-out, so the parallel review degrades to a sequential adversarial two-pass. Where a platform lacks a native picker, confirmations degrade per `refs/picker-contract.md` (the `ask_user_choice` MCP tool or `pipeline/lib/ask-choice.sh`); hard blocking gates degrade to advisory rules plus a CI smoke step.
-
-All install from the same `pipeline/skills/` source. Tree organization:
-
-- `pipeline/skills/shared/core/` - **orchestration skills** (`multi-agent-*` dash-form mirrors of colon-form slash commands + compliance skills + orchestrator)
-- `pipeline/skills/shared/external/` - **127 third-party / curated iOS, Android, and generic guidance skills** (SwiftUI, Jetpack Compose, testing, performance, security, etc.)
-- `pipeline/skills/figma-ios/` + `pipeline/skills/figma-android/` - **5 + 5 platform-specific Phase 3 sub-skills** (SwiftUI and Jetpack Compose code generation)
-- `pipeline/skills/figma-common/` - **27 platform-agnostic Figma helpers** (iterate, commit, wiki setup, MCP auth, performance harness)
-
-You get identical skill coverage regardless of which CLI you use. Both CLIs also receive the same `pipeline/scripts/` tree so multi-CLI-only installs stay self-contained.
 
-All orchestration adapters default to `process.cwd()`; override with `--target=<path>`. Install every supported tool at once with `--all-tools`. Filter the skill set by stack with `--platform=ios|android|all`. Each adapter also writes the knowledge layer (rules + per-skill instructions) so single-tool installs are self-contained.
+Skill tree:
 
-### Tier 2 - Manual port
+- `pipeline/skills/shared/core/` - **orchestration skills** (`multi-agent-*` dash-form mirrors of the colon-form slash commands + compliance skills + orchestrator)
+- `pipeline/skills/shared/external/` - **curated iOS / Android / generic guidance skills** (SwiftUI, Jetpack Compose, testing, performance, security, etc.) — also distributed as versioned marketplace plugins in `mmerterden/multi-agent-plugins`
+- `pipeline/skills/figma-ios/` + `pipeline/skills/figma-android/` - **platform-specific Phase 3 sub-skills** (SwiftUI and Jetpack Compose code generation)
+- `pipeline/skills/figma-common/` - **platform-agnostic Figma helpers** (iterate, commit, wiki setup, MCP auth, performance harness)
 
-**JetBrains AI**, **Codeium**, **Tabnine**, **Amazon Q Developer** - closed/proprietary config or a different paradigm with no agent/command file format we can target. Skill content can be copy-pasted into native rule formats; no automated installer ships today. PRs welcome.
+Filter the skill set by stack with `--platform=ios|android|all`. Both CLIs also receive the same `pipeline/scripts/` tree so single-CLI installs stay self-contained.
 
-### Uninstall (token-preserving, all tiers)
+### Uninstall (token-preserving)
 
 ```bash
 npx @mmerterden/multi-agent-pipeline uninstall            # interactive, all installed targets
 npx @mmerterden/multi-agent-pipeline uninstall --dry-run  # preview, zero side effects
-npx @mmerterden/multi-agent-pipeline uninstall --cursor   # selective: only this tool
 ```
 
 Personal access tokens stored in macOS Keychain / Windows Credential Manager / Linux libsecret are **never touched** by the uninstaller. Smoke tests enforce this with a static check that fails the build if the script ever references a credential-store deletion API.
@@ -578,7 +549,7 @@ Stack skills ship as versioned plugins in the `{owner}/multi-agent-plugins` mark
 /multi-agent:stack all                      multi-agent-stack all            # all four toolkits + common
 ```
 
-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.
+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. The old `stack-swap.sh` mechanic has been removed.
 
 ## Setup
 
@@ -639,7 +610,6 @@ Runs unit tests, smoke suites, eval fixtures, schema validation, and lint - the
 | ---------------------- | ------------------------------------------------ |
 | `pre-commit-check.sh`  | Secret detection before commits                  |
 | `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               |
@@ -785,7 +755,6 @@ pipeline/
   scripts/
     pre-commit-check.sh         Secret detection hook
     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/install/index.mjs

@@ -1,12 +1,9 @@
 /**
  * multi-agent-pipeline installer entry point.
  *
- * Parses flags, dispatches to per-target installers (Claude / Copilot /
- * adapter modules), prints summary, and fires opt-in telemetry.
- *
- * Behaviour MUST stay byte-equivalent to the pre-v8.0.0 monolithic install.js.
- * The smoke `smoke-install-layout.sh` test compares the produced filesystem
- * tree against a fixture before/after refactor.
+ * Parses flags, dispatches to the per-target installers (Claude Code / Copilot
+ * CLI), prints a summary, and fires opt-in telemetry. The pipeline runs natively
+ * on these two CLIs only.
  *
  * @module install/index
  */
@@ -16,7 +13,6 @@ import { fileURLToPath } from "url";
 
 import { installClaude } from "./claude.mjs";
 import { installCopilot } from "./copilot.mjs";
-import { anyAdapterRequested, installAdapters } from "./_adapters.mjs";
 import { setDryRun } from "./_common.mjs";
 import { sendInstallTelemetry } from "./_telemetry.mjs";
 
@@ -26,14 +22,7 @@ const PIPELINE_ROOT = dirname(__dirname);
 const PIPELINE_SRC = `${PIPELINE_ROOT}/pipeline`;
 
 /** Tool flags surfaced in CLI help. */
-const TOOL_FLAGS = [
-  "--claude",
-  "--copilot",
-  "--cursor",
-  "--copilot-chat",
-  "--antigravity",
-  "--codex",
-];
+const TOOL_FLAGS = ["--claude", "--copilot"];
 
 /**
  * @param {string[]} argv
@@ -55,7 +44,6 @@ export async function runInstall(argv) {
   const KNOWN_FLAGS = [
     ...TOOL_FLAGS,
     "--all",
-    "--all-tools",
     "--link",
     "--index-only",
     "--dry-run",
@@ -79,32 +67,12 @@ export async function runInstall(argv) {
   setDryRun(dryRun);
 
   const isExplicitlyTargeted =
-    flags.some((f) => TOOL_FLAGS.includes(f)) ||
-    flags.includes("--all") ||
-    flags.includes("--all-tools");
+    flags.some((f) => TOOL_FLAGS.includes(f)) || flags.includes("--all");
 
   const forClaude =
-    flags.includes("--claude") ||
-    flags.includes("--all") ||
-    flags.includes("--all-tools") ||
-    !isExplicitlyTargeted;
-
-  const forCopilot =
-    flags.includes("--copilot") ||
-    flags.includes("--all") ||
-    flags.includes("--all-tools");
-
-  const adapterFlags = {
-    cursor: flags.includes("--cursor") || flags.includes("--all-tools"),
-    copilotChat: flags.includes("--copilot-chat") || flags.includes("--all-tools"),
-    antigravity: flags.includes("--antigravity") || flags.includes("--all-tools"),
-    codex: flags.includes("--codex") || flags.includes("--all-tools"),
-  };
+    flags.includes("--claude") || flags.includes("--all") || !isExplicitlyTargeted;
 
-  const adapterTarget = (() => {
-    const raw = flags.find((f) => f.startsWith("--target="));
-    return raw ? raw.slice("--target=".length) : process.cwd();
-  })();
+  const forCopilot = flags.includes("--copilot") || flags.includes("--all");
 
   const useSymlinks = flags.includes("--link");
   const indexOnly = flags.includes("--index-only");
@@ -127,26 +95,6 @@ export async function runInstall(argv) {
   if (forClaude) installClaude(installerCtx);
   if (forCopilot) installCopilot(installerCtx);
 
-  if (anyAdapterRequested(adapterFlags)) {
-    if (dryRun) {
-      // Adapter installs merge marker-wrapped blocks into user-owned files;
-      // the preview lists the touched paths instead of threading dry-run
-      // through every adapter write site.
-      const planned = Object.entries(adapterFlags)
-        .filter(([, on]) => on)
-        .map(([name]) => name);
-      console.log(`  [dry-run] would install adapter(s) ${planned.join(", ")} into ${adapterTarget}`);
-    } else {
-      await installAdapters({
-        pipelineRoot: PIPELINE_ROOT,
-        pipelineSrc: PIPELINE_SRC,
-        target: adapterTarget,
-        platformFilter: platformFlag,
-        flags: adapterFlags,
-      });
-    }
-  }
-
   if (dryRun) {
     console.log("");
     console.log("  Dry-run complete — nothing was written. Re-run without --dry-run to install.");
@@ -154,12 +102,7 @@ export async function runInstall(argv) {
     return;
   }
 
-  printSummary({
-    forClaude,
-    forCopilot,
-    adapterFlags,
-    adapterTarget,
-  });
+  printSummary({ forClaude, forCopilot });
 
   // Fire-and-forget; install is already done.
   sendInstallTelemetry({ packageRoot: PIPELINE_ROOT, flags });
@@ -182,7 +125,7 @@ function parsePlatformFlag(flags) {
 }
 
 function printSummary(opts) {
-  const { forClaude, forCopilot, adapterFlags, adapterTarget } = opts;
+  const { forClaude, forCopilot } = opts;
 
   console.log("  Installation complete!");
   console.log("");
@@ -200,41 +143,6 @@ function printSummary(opts) {
     console.log("    Just describe your task — Copilot will follow the pipeline");
     console.log("");
   }
-  if (adapterFlags.cursor) {
-    console.log("  Cursor (full orchestration):");
-    console.log(`    Rules:    ${adapterTarget}/.cursor/rules/multi-agent-*.mdc`);
-    console.log(`    Subagents: ${adapterTarget}/.cursor/agents/ma-*.md (parallel review / explorer / triage)`);
-    console.log(`    Command:  ${adapterTarget}/.cursor/commands/multi-agent.md  (run /multi-agent)`);
-    console.log(`    MCP:      ${adapterTarget}/.cursor/mcp.json (dev-toolkit)`);
-    console.log("    Pickers degrade per refs/picker-contract.md; hard gates -> advisory rules + CI.");
-    console.log("");
-  }
-  if (adapterFlags.copilotChat) {
-    console.log("  GitHub Copilot Chat (VS Code, full orchestration):");
-    console.log(`    Instructions: ${adapterTarget}/.github/copilot-instructions.md + .github/instructions/multi-agent-*`);
-    console.log(`    Agents:   ${adapterTarget}/.github/agents/ma-*.agent.md (parallel review / explorer / triage)`);
-    console.log(`    Command:  ${adapterTarget}/.github/prompts/multi-agent.prompt.md  (run /multi-agent)`);
-    console.log(`    MCP:      ${adapterTarget}/.vscode/mcp.json (dev-toolkit)`);
-    console.log("    Confirmations use VS Code native approval dialogs (refs/picker-contract.md).");
-    console.log("");
-  }
-  if (adapterFlags.antigravity) {
-    console.log("  Antigravity (full orchestration):");
-    console.log(`    Rules:    ${adapterTarget}/.agent/rules/multi-agent-*.md`);
-    console.log(`    Workflow: ${adapterTarget}/.agent/workflows/multi-agent.md  (run /multi-agent)`);
-    console.log(`    Context:  ${adapterTarget}/AGENTS.md (skill index, marker-wrapped)`);
-    console.log(`    MCP:      ${adapterTarget}/.agent/mcp_config.json (dev-toolkit)`);
-    console.log("    Note: .agent/ paths community-documented; confirm against current Antigravity docs.");
-    console.log("");
-  }
-  if (adapterFlags.codex) {
-    console.log("  OpenAI Codex CLI (global, sequential orchestration):");
-    console.log("    Command:  ~/.codex/prompts/multi-agent.md  (run /multi-agent)");
-    console.log("    Context:  ~/.codex/AGENTS.md (skill index, marker-wrapped)");
-    console.log("    MCP:      ~/.codex/config.toml ([mcp_servers.dev-toolkit])");
-    console.log("    Note: prompts + MCP are global; Codex has no subagent fan-out (review runs sequential).");
-    console.log("");
-  }
 
   console.log("  For UI testing, also install the mobile MCP server:");
   console.log("    Add to your MCP config: npx @mmerterden/dev-toolkit-mcp");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "10.5.0",
+  "version": "10.7.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/agents/android-architect.md

@@ -1,8 +1,8 @@
 ---
 description: Android architect  -  evaluates design decisions, patterns, and module structure
-model: opus
-preferredModel: opus
-modelRationale: "Architecture decisions across Gradle modules, Compose stability, Hilt graphs, and migration paths run on opus (top available tier). No downgrade recommended."
+model: fable
+preferredModel: fable
+modelRationale: "Architecture decisions across Gradle modules, Compose stability, Hilt graphs, and migration paths run on fable, the top tier (opus is the first fallback). No downgrade recommended."
 ---
 
 You are a senior Android architect with deep expertise in large-scale modular Android applications.

package/pipeline/agents/backend-architect.md

@@ -1,8 +1,8 @@
 ---
 description: Backend architect  -  evaluates API design, data modeling, and system architecture
-model: opus
-preferredModel: opus
-modelRationale: "API design + migration safety + scaling analysis are top-tier concerns; opus is the top available tier and handles concurrent-write / rollback edge cases in database migration reviews."
+model: fable
+preferredModel: fable
+modelRationale: "API design + migration safety + scaling analysis are top-tier concerns; fable is the top tier (opus is the first fallback) and handles concurrent-write / rollback edge cases in database migration reviews."
 ---
 
 You are a senior backend architect with expertise in API design, distributed systems, and data modeling.

package/pipeline/agents/code-reviewer.md

@@ -1,7 +1,7 @@
 ---
-description: "Code reviewer for multi-agent Phase 4  -  security, architecture, quality, performance. Default model is opus; Phase 4 orchestrator overrides to sonnet for Reviewer 3."
-model: opus
-preferredModel: opus
+description: "Code reviewer for multi-agent Phase 4  -  security, architecture, quality, performance. Default model is fable (opus is the first fallback); Phase 4 orchestrator overrides to sonnet for Reviewer 3."
+model: fable
+preferredModel: fable
 modelRationale: "Reviewer 1 tier  -  deep security + architecture review runs on opus (top available intelligence tier). Phase 4 orchestrator overrides to sonnet for Reviewer 3 (quality/correctness focus) via CLAUDE_CODE_SUBAGENT_MODEL before dispatch. Copilot CLI adds Reviewer 2 on gpt-5.4 for cross-model diversity."
 ---
 

package/pipeline/agents/ios-architect.md

@@ -1,8 +1,8 @@
 ---
 description: iOS architect  -  evaluates design decisions, patterns, and module structure
-model: opus
-preferredModel: opus
-modelRationale: "Architecture decisions require deep reasoning across modules, protocols, and migration paths  -  opus is the top available intelligence tier. No downgrade recommended; if cost is a concern, skip the architect consultation entirely."
+model: fable
+preferredModel: fable
+modelRationale: "Architecture decisions require deep reasoning across modules, protocols, and migration paths  -  fable is the top tier (opus is the first fallback). No downgrade recommended; if cost is a concern, skip the architect consultation entirely."
 ---
 
 You are a senior iOS architect with deep expertise in large-scale modular iOS applications.

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

@@ -24,7 +24,7 @@ You already did the work locally  -  wrote code on the current branch and maybe
 
 ```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 PROJ-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
 ```
@@ -45,7 +45,7 @@ Phases 1-3 (Analysis / Planning / Dev) are skipped by design  -  `finish` treats
 
 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.
+3. **Task binding:** Jira id from the `--`/positional arg, else parse the branch name (`bugfix/PROJ-XXXX` / `feature/PROJ-XXXX`); `taskType` inferred from the diff (bugfix/feature/refactor/chore) for the report wording. GitHub issue `#N` from branch/arg when present.
 4. **Prior state (optional):** if an `agent-state.json` / tracker-state exists for this branch (left by a prior `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`).
 
@@ -55,7 +55,7 @@ Phases 1-3 (Analysis / Planning / Dev) are skipped by design  -  `finish` treats
   - 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 6 Commit/PR** — per `refs/phases/phase-6-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 `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
@@ -92,7 +92,7 @@ No TaskList widget. After every state change call `bash $HOME/.claude/scripts/ph
 ## Examples
 
 ```bash
-/multi-agent:dev-local "DIJITAL-12345"     # develop locally (Init→Dev→Commit→Report, no review/test)
+/multi-agent:dev-local "PROJ-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/refs/features/model-fallback.md

@@ -1,22 +1,30 @@
 # Model Fallback Contract (v10.1.0)
 
-Personas that declare `preferredModel: opus` route to the top available
-intelligence tier (`claude-opus-4-8`). Opus access can be quota-limited or
-temporarily unavailable. This contract defines when and how the orchestrator
-falls back, deterministically, without ever editing persona files at runtime.
+Personas route to the top available intelligence tier they declare in
+`preferredModel`. That tier can be quota-limited or temporarily unavailable.
+This contract defines when and how the orchestrator falls back, deterministically,
+without ever editing persona files at runtime.
 
-> **Fable retired (2026-06).** Earlier versions routed architect / Reviewer-1 /
-> triage personas to `claude-fable-5` as the top tier. Fable 5 is no longer
-> available, so opus is now the top tier and the persona frontmatter declares
-> `preferredModel: opus`. The `premiumTierUntil` date gate stays in the contract
-> as a generic mechanism for any future plan-window-limited premium tier.
+> **Fable 5 available again (2026-07).** `claude-fable-5` is the top tier once
+> more. Architect (`ios/android/backend-architect`), Reviewer-1 (`code-reviewer`),
+> and triage personas declare `preferredModel: fable` — the deepest-reasoning
+> roles. **If Fable 5 is unavailable, the first fallback is opus (`claude-opus-4-8`).**
+> Security and other `preferredModel: opus` personas keep opus as their top tier.
+> The `premiumTierUntil` date gate stays in the contract as a generic mechanism
+> for any plan-window-limited premium tier.
 
 ## Tier ladder
 
 ```
-opus -> sonnet -> haiku
+fable -> opus -> sonnet -> haiku
 ```
 
+The orchestrator walks **one step down per trigger** from whichever tier a
+persona prefers: a `fable` persona degrades `fable -> opus` first, then
+`opus -> sonnet`, then `sonnet -> haiku`; an `opus` persona starts at
+`opus -> sonnet`. So a Fable 5 outage transparently promotes Opus 4.8 into the
+architect/reviewer roles with no file edits.
+
 One step down per trigger, walking the ladder until a tier dispatches or the
 floor (`haiku`) is reached. `haiku` is the last-resort floor: a run that reaches
 it is heavily degraded but still makes progress instead of hard-halting because

package/pipeline/commands/multi-agent/refs/phases/phase-4-review.md

@@ -187,17 +187,7 @@ Launch Agent instances **in parallel** using the shared `code-reviewer` subagent
 
 Each reviewer inherits the `code-reviewer` agent's focus areas (Security, Architecture, Quality, Performance) and output contract. The orchestrator overrides only the model and the stack-specific skill per-reviewer  -  no prompt duplication.
 
-**Model override wiring:** `code-reviewer.md` declares `preferredModel: opus`, so Reviewer 1 uses the persona default. Reviewer 2 (Copilot-only, `gpt-5.4`) and Reviewer 3 (`claude-sonnet-4.6`) set `PHASE_MODEL_OVERRIDE=<model>` before dispatch  -  the orchestrator exports `CLAUDE_CODE_SUBAGENT_MODEL` on Claude Code, or passes `--model` on Copilot CLI. Full precedence rule: `skills/shared/core/multi-agent/SKILL.md#agent-dispatch--per-persona-model-routing-v610`. Opus dispatches are additionally subject to the fallback contract (`refs/features/model-fallback.md`): dispatch-error retry on `fallbackModel` (sonnet) and budget-ceiling downgrade.
-
-**Adapter platforms (Cursor / Antigravity / VS Code Copilot Chat) - reviewer set.** The native trio above is a Claude-Code / Copilot-CLI capability. On the adapter platforms the pipeline configures a 2-model cross-vendor review using the models each platform actually exposes (lineup in `pipeline/adapters/_base.mjs#REVIEWER_MODELS`; update as the platforms ship new versions):
-
-| Platform | Reviewer agents emitted | Models |
-|---|---|---|
-| Cursor | `ma-code-reviewer` + `ma-code-reviewer-x` (per-agent `model:` pinning is supported) | primary `inherit` (your selected model, usually Claude) + `gpt-5.5` |
-| VS Code Copilot Chat | `ma-code-reviewer` + `ma-code-reviewer-x` (frontmatter `model:` takes the picker label) | `Claude Opus 4.8` + `GPT-5.5` |
-| Antigravity | two parallel review agents (model chosen in the UI, not a file) | recommended `Gemini 3 Pro` + `Claude Opus 4.6`, set via the side-panel dropdown |
-
-So cross-vendor review IS restored on the adapter platforms (two different models on the code review), with the stack architect + `ma-security-auditor` as before. Two honest caveats remain vs the native hosts: (1) the exact model availability depends on the user's subscription (a pinned model the user lacks must be swapped in `REVIEWER_MODELS` / the dropdown), and (2) there is no `PreToolUse` hook, so gates are workflow-enforced not OS-blocked. Antigravity's models are dropdown-selected, so its pair is documented in the workflow rather than file-pinned.
+**Model override wiring:** `code-reviewer.md` declares `preferredModel: fable`, so Reviewer 1 uses the persona default (Fable 5). Reviewer 2 (Copilot-only, `gpt-5.4`) and Reviewer 3 (`claude-sonnet-4.6`) set `PHASE_MODEL_OVERRIDE=<model>` before dispatch  -  the orchestrator exports `CLAUDE_CODE_SUBAGENT_MODEL` on Claude Code, or passes `--model` on Copilot CLI. Full precedence rule: `skills/shared/core/multi-agent/SKILL.md#agent-dispatch--per-persona-model-routing-v610`. Fable dispatches are subject to the fallback contract (`refs/features/model-fallback.md`): dispatch-error retry walks `fable -> opus -> sonnet` and budget-ceiling downgrade.
 
 **Stack-specific skills loaded per reviewer** (from Phase 1 `detectedStack`). On Claude Code, Reviewer 2 (GPT-5.4) is not dispatched  -  its skill column is ignored. On Copilot CLI all three columns are used.
 

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

@@ -799,4 +799,21 @@ Offer to make the secret scan a HARD pre-commit gate (a non-zero exit blocks the
 - Ask (picker): "Install the pre-commit secret-scan hook into `~/.claude/settings.json`?" Default Yes.
 - On Yes, deep-merge the template's `hooks.PreToolUse` into the user's `settings.json` (preserve any existing hooks; do not duplicate a matcher that already calls `pre-commit-check.sh`).
 - Honest note to show: this is the only deterministic gate that is OS-enforceable as a hook (it needs no run-specific arguments). The evidence / consensus / intent / learnings gates are invoked by the pipeline phases with per-run arguments, so they are enforced by the phase contract + the installed gate scripts, not by a hook.
-- On the adapter platforms (Cursor / Antigravity / VS Code Copilot Chat) there is no PreToolUse equivalent; the gate scripts live in `~/.multi-agent/` and are run as workflow steps. See `refs/picker-contract.md`.
+### Step 9  -  Default stack plugin enablement
+
+Stack skills ship as versioned plugins in the `{owner}/multi-agent-plugins` marketplace. On first setup, wire the stack so the pipeline works out of the box.
+
+1. Ensure the marketplace is known (idempotent):
+   ```bash
+   claude marketplace add {owner}/multi-agent-plugins 2>/dev/null || true
+   ```
+2. Detect the project stack from markers and enable the matching plugin(s) plus the always-on common plugin in the project's `.claude/settings.json` `enabledPlugins`:
+   - `.xcodeproj` / `Package.swift` / `*.xcworkspace` → `ai-ios-engineering-toolkit`
+   - `build.gradle` / `settings.gradle` → `ai-android-engineering-toolkit`
+   - `package.json` with `react`/`next` → `ai-frontend-engineering-toolkit`
+   - `requirements.txt` / `pyproject.toml` / server `package.json` → `ai-backend-toolkit`
+   - **no clear marker → default `ai-ios-engineering-toolkit`**
+   `ai-common-engineering-toolkit@multi-agent-plugins` is always set `true` alongside the stack plugin.
+3. Report the enabled set. To change later, run `/multi-agent:stack <ios|android|frontend|backend|...>` in the repo. Pipeline Phase 1 auto-detects the stack for its own routing regardless of enablement.
+
+The marketplace repo name (`multi-agent-plugins`) is generic; a different org points `{owner}` at its own fork — nothing in the pipeline is coupled to a specific account.

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

@@ -91,4 +91,4 @@ Use the Read + Edit/Write tools (JSON must stay valid). Then print the resulting
 - 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.
+- The old `stack-swap.sh` skill-dir swap has been removed; stack selection is entirely plugin enablement.