@mmerterden/multi-agent-pipeline 10.4.0 → 10.6.0

package/CHANGELOG.md

@@ -14,6 +14,72 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ---
 
+## [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.
+
+### 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.

package/README.md

@@ -528,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
@@ -563,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. The old `stack-swap.sh` mechanic has been removed.
 
 ## Setup
 
@@ -638,7 +638,7 @@ 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 |
 | `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               |
@@ -783,7 +783,7 @@ 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
     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.4.0",
+  "version": "10.6.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/help.md

@@ -120,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)
@@ -177,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)
@@ -327,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)
@@ -384,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/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/setup.md

@@ -800,3 +800,21 @@ Offer to make the secret scan a HARD pre-commit gate (a non-zero exit blocks the
 - 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

@@ -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.
+- The old `stack-swap.sh` skill-dir swap has been removed; stack selection is entirely plugin enablement.

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

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

package/pipeline/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/README.md

@@ -52,7 +52,6 @@ Validate contracts. Each emits `══ <name> smoke: N passed, M failed ══`
 - `smoke-prefs-language.sh`  -  `prefs.global.promptLanguage` contract
 - `smoke-progress-contract.sh`  -  progress-line quiet/normal/verbose
 - `smoke-search.sh`  -  `/multi-agent:search` log search + smart ranking
-- `smoke-stack-swap.sh`  -  `/multi-agent:stack` auto-detect + manual override
 - `smoke-subagent-validators.sh`  -  Phase 1/2 validator schemas
 - `smoke-telemetry.sh`  -  opt-in telemetry contract
 - `smoke-validator-contradiction.sh`  -  Phase 4 approved/blocking contradiction detection

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 uses the per-stack skill patterns (formerly carried by stack-swap.sh). 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 (per-stack routing patterns (formerly in stack-swap.sh))
+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/scripts/smoke-model-fallback.sh

@@ -62,19 +62,20 @@ echo "→ 3. Phase wiring references the contract"
 grep -q "model-fallback.md" "$P0" && ok "phase-0-init wires the date gate" || fail "phase-0-init missing fallback wiring"
 grep -q "model-fallback.md" "$P4" && ok "phase-4-review wires the per-dispatch triggers" || fail "phase-4-review missing fallback wiring"
 
-echo "→ 4. Personas declare opus as preferred (fallback is dispatch-time, not file-time)"
-OPUS_COUNT=$(grep -l "^preferredModel: opus" "$REPO_ROOT"/pipeline/agents/*.md 2>/dev/null | wc -l | tr -d ' ')
-if [ "$OPUS_COUNT" -ge 5 ]; then
-  ok "opus personas intact ($OPUS_COUNT files)"
+echo "→ 4. Top-tier personas declare their preferred model (fallback is dispatch-time, not file-time)"
+# Fable 5 is the top tier again: architect + Reviewer-1 (+ triage) personas pin it.
+FABLE_COUNT=$(grep -l "^preferredModel: fable" "$REPO_ROOT"/pipeline/agents/*.md 2>/dev/null | wc -l | tr -d ' ')
+if [ "$FABLE_COUNT" -ge 4 ]; then
+  ok "fable top-tier personas present ($FABLE_COUNT files)"
 else
-  fail "expected >=5 opus personas, found $OPUS_COUNT"
+  fail "expected >=4 fable personas (architects + Reviewer-1), found $FABLE_COUNT"
 fi
-# Fable 5 is retired - no persona should still pin it.
-FABLE_LEFT=$(grep -l "^preferredModel: fable" "$REPO_ROOT"/pipeline/agents/*.md 2>/dev/null | wc -l | tr -d ' ')
-if [ "$FABLE_LEFT" -eq 0 ]; then
-  ok "no persona still pins retired fable tier"
+# Opus stays a valid tier — the first fallback below fable, and the top tier for security personas.
+OPUS_COUNT=$(grep -l "^preferredModel: opus" "$REPO_ROOT"/pipeline/agents/*.md 2>/dev/null | wc -l | tr -d ' ')
+if [ "$OPUS_COUNT" -ge 1 ]; then
+  ok "opus personas intact ($OPUS_COUNT files)"
 else
-  fail "expected 0 fable personas (fable retired), found $FABLE_LEFT"
+  fail "expected >=1 opus persona (fallback tier / security), found $OPUS_COUNT"
 fi
 
 echo ""

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

@@ -35,7 +35,7 @@ Phases 1-3 (Analysis / Planning / Dev) are skipped by design  -  the branch's lo
 
 ```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 PROJ-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
 ```

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.
+- The old `stack-swap.sh` skill-dir swap has been removed; stack selection is entirely plugin enablement.

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` 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)

package/pipeline/scripts/smoke-stack-swap.sh

@@ -1,132 +0,0 @@
-#!/usr/bin/env bash
-# smoke-stack-swap.sh  -  verify stack-swap.sh argument dispatch and skill movement.
-# Bootstraps a temp HOME with fixture skills, runs the script in forced mode for
-# each supported stack, asserts skills move between active and inactive
-# directories, and validates the JSON systemMessage output contract.
-#
-# Covers v5.3.4+ /multi-agent:stack command backend: ios, android, mobile,
-# backend, frontend, fullstack, all, status, and unknown-arg rejection.
-
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-STACK_SWAP="$SCRIPT_DIR/stack-swap.sh"
-
-if [ ! -x "$STACK_SWAP" ]; then
-  echo "FAIL: stack-swap.sh not found or not executable at $STACK_SWAP" >&2
-  exit 1
-fi
-
-PASS=0
-FAIL=0
-pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
-
-TMPHOME=$(mktemp -d) || { echo "FAIL: mktemp" >&2; exit 1; }
-trap 'rm -rf "$TMPHOME"' EXIT
-
-export HOME="$TMPHOME"
-SKILLS="$TMPHOME/.claude/skills"
-INACTIVE="$TMPHOME/.claude/skills-inactive"
-mkdir -p "$SKILLS" "$INACTIVE"
-
-# Fixture skill dirs  -  one matching each stack's pattern catalog.
-bootstrap_fixtures() {
-  rm -rf "$SKILLS" "$INACTIVE"
-  mkdir -p "$SKILLS" "$INACTIVE"
-  # iOS pattern hits
-  mkdir -p "$SKILLS/swiftui-patterns" "$SKILLS/ios-networking" "$SKILLS/hig-foundations"
-  # Android pattern hits
-  mkdir -p "$SKILLS/android-security" "$SKILLS/compose-navigation" "$SKILLS/kotlin-coroutines-expert"
-  # Backend pattern hits
-  mkdir -p "$SKILLS/fastapi-patterns" "$SKILLS/nodejs-tips"
-  # Frontend pattern hits
-  mkdir -p "$SKILLS/react-best-practices" "$SKILLS/nextjs-app-router"
-  # Unrelated skill that should never move
-  mkdir -p "$SKILLS/general-writing"
-}
-
-echo "→ 1. status mode prints JSON with active+inactive counts, no file movement"
-bootstrap_fixtures
-COUNT_BEFORE=$(ls "$SKILLS" | wc -l | tr -d ' ')
-OUT=$("$STACK_SWAP" status 2>&1)
-if echo "$OUT" | grep -q '"systemMessage"'; then
-  pass "status emits {\"systemMessage\": ...} JSON"
-else
-  fail "status output missing systemMessage field: $OUT"
-fi
-COUNT_AFTER=$(ls "$SKILLS" | wc -l | tr -d ' ')
-if [ "$COUNT_BEFORE" = "$COUNT_AFTER" ]; then
-  pass "status does not move files (before=$COUNT_BEFORE after=$COUNT_AFTER)"
-else
-  fail "status moved files (before=$COUNT_BEFORE after=$COUNT_AFTER)"
-fi
-
-echo ""
-echo "→ 2. ios mode keeps iOS skills active, deactivates Android/backend/frontend"
-bootstrap_fixtures
-"$STACK_SWAP" ios >/dev/null 2>&1
-[ -d "$SKILLS/swiftui-patterns" ] && pass "iOS skill stays active: swiftui-patterns" || fail "swiftui-patterns missing from active"
-[ -d "$SKILLS/ios-networking" ] && pass "iOS skill stays active: ios-networking" || fail "ios-networking missing from active"
-[ -d "$INACTIVE/android-security" ] && pass "Android skill moved to inactive: android-security" || fail "android-security not in inactive"
-[ -d "$INACTIVE/react-best-practices" ] && pass "Frontend skill moved to inactive: react-best-practices" || fail "react-best-practices not in inactive"
-[ -d "$SKILLS/general-writing" ] && pass "Unrelated skill untouched: general-writing" || fail "general-writing was moved"
-
-echo ""
-echo "→ 3. android mode keeps Android skills active, deactivates iOS"
-bootstrap_fixtures
-"$STACK_SWAP" android >/dev/null 2>&1
-[ -d "$SKILLS/android-security" ] && pass "Android skill stays active" || fail "android-security missing from active"
-[ -d "$SKILLS/compose-navigation" ] && pass "Compose skill stays active" || fail "compose-navigation missing from active"
-[ -d "$INACTIVE/swiftui-patterns" ] && pass "iOS skill moved to inactive" || fail "swiftui-patterns not in inactive"
-
-echo ""
-echo "→ 4. mobile mode keeps iOS AND Android active, deactivates backend"
-bootstrap_fixtures
-"$STACK_SWAP" mobile >/dev/null 2>&1
-[ -d "$SKILLS/swiftui-patterns" ] && pass "mobile keeps iOS active" || fail "iOS deactivated by mobile"
-[ -d "$SKILLS/android-security" ] && pass "mobile keeps Android active" || fail "Android deactivated by mobile"
-[ -d "$INACTIVE/fastapi-patterns" ] && pass "backend moved to inactive under mobile" || fail "backend stayed active under mobile"
-
-echo ""
-echo "→ 5. all mode keeps every stack active"
-bootstrap_fixtures
-# Pre-deactivate something so "all" has work to do
-mv "$SKILLS/fastapi-patterns" "$INACTIVE/fastapi-patterns"
-"$STACK_SWAP" all >/dev/null 2>&1
-[ -d "$SKILLS/swiftui-patterns" ] && pass "all keeps iOS" || fail "all dropped iOS"
-[ -d "$SKILLS/android-security" ] && pass "all keeps Android" || fail "all dropped Android"
-[ -d "$SKILLS/fastapi-patterns" ] && pass "all re-activates backend" || fail "all did not re-activate backend"
-
-echo ""
-echo "→ 6. unknown arg returns exit 1 with error message"
-bootstrap_fixtures
-OUT=$("$STACK_SWAP" badstack 2>&1)
-RC=$?
-if [ "$RC" -eq 1 ]; then
-  pass "unknown arg exits 1"
-else
-  fail "unknown arg exit code was $RC, expected 1"
-fi
-if echo "$OUT" | grep -qi "unknown"; then
-  pass "unknown arg error message mentions 'unknown'"
-else
-  fail "unknown arg message lacks expected text: $OUT"
-fi
-
-echo ""
-echo "→ 7. exit code 0 on every valid mode"
-bootstrap_fixtures
-for arg in status ios android mobile backend frontend all; do
-  "$STACK_SWAP" "$arg" >/dev/null 2>&1
-  RC=$?
-  if [ "$RC" -eq 0 ]; then
-    pass "$arg exits 0"
-  else
-    fail "$arg exit code was $RC"
-  fi
-done
-
-echo ""
-echo "══ stack-swap smoke: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -eq 0 ] || exit 1

package/pipeline/scripts/stack-swap.sh

@@ -1,182 +0,0 @@
-#!/bin/bash
-# stack-swap.sh  -  Auto-detect project stack and swap skills
-# Called by SessionStart hook
-# Default: iOS. Swaps Android/backend in only when detected.
-
-set -uo pipefail
-
-SKILLS="$HOME/.claude/skills"
-INACTIVE="$HOME/.claude/skills-inactive"
-mkdir -p "$INACTIVE"
-
-# Skill group definitions (folder name prefixes/patterns)
-IOS_PATTERNS="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"
-ANDROID_PATTERNS="android|compose-|kotlin-|room-database|retrofit-|gradle-|play-store"
-BACKEND_PATTERNS="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"
-FRONTEND_PATTERNS="react-|nextjs-|typescript-|tailwind-|vue-|web-accessibility|web-performance|css-modern|web-testing|html-semantic"
-
-activate_stack() {
-  local patterns="$1"
-  # Move matching skills from inactive to active
-  for dir in "$INACTIVE"/*/; do
-    [ -d "$dir" ] || continue
-    name=$(basename "$dir")
-    if echo "$name" | grep -qiE "$patterns"; then
-      mv "$dir" "$SKILLS/$name" 2>/dev/null
-    fi
-  done
-}
-
-deactivate_stack() {
-  local patterns="$1"
-  # Move matching skills from active to inactive
-  for dir in "$SKILLS"/*/; do
-    [ -d "$dir" ] || continue
-    name=$(basename "$dir")
-    if echo "$name" | grep -qiE "$patterns"; then
-      mv "$dir" "$INACTIVE/$name" 2>/dev/null
-    fi
-  done
-}
-
-# Manual mode: if argument provided, force that stack
-FORCE_STACK="${1:-}"
-
-if [ -n "$FORCE_STACK" ]; then
-  case "$FORCE_STACK" in
-    ios)
-      activate_stack "$IOS_PATTERNS"
-      deactivate_stack "$ANDROID_PATTERNS"
-      deactivate_stack "$BACKEND_PATTERNS"
-      deactivate_stack "$FRONTEND_PATTERNS"
-      ;;
-    android)
-      deactivate_stack "$IOS_PATTERNS"
-      activate_stack "$ANDROID_PATTERNS"
-      deactivate_stack "$BACKEND_PATTERNS"
-      deactivate_stack "$FRONTEND_PATTERNS"
-      ;;
-    mobile)
-      activate_stack "$IOS_PATTERNS"
-      activate_stack "$ANDROID_PATTERNS"
-      deactivate_stack "$BACKEND_PATTERNS"
-      deactivate_stack "$FRONTEND_PATTERNS"
-      ;;
-    backend)
-      deactivate_stack "$IOS_PATTERNS"
-      deactivate_stack "$ANDROID_PATTERNS"
-      activate_stack "$BACKEND_PATTERNS"
-      deactivate_stack "$FRONTEND_PATTERNS"
-      ;;
-    frontend)
-      deactivate_stack "$IOS_PATTERNS"
-      deactivate_stack "$ANDROID_PATTERNS"
-      deactivate_stack "$BACKEND_PATTERNS"
-      activate_stack "$FRONTEND_PATTERNS"
-      ;;
-    fullstack)
-      deactivate_stack "$IOS_PATTERNS"
-      deactivate_stack "$ANDROID_PATTERNS"
-      activate_stack "$BACKEND_PATTERNS"
-      activate_stack "$FRONTEND_PATTERNS"
-      ;;
-    all)
-      activate_stack "$IOS_PATTERNS"
-      activate_stack "$ANDROID_PATTERNS"
-      activate_stack "$BACKEND_PATTERNS"
-      activate_stack "$FRONTEND_PATTERNS"
-      ;;
-    status)
-      ACTIVE=$(ls "$SKILLS" 2>/dev/null | wc -l | tr -d ' ')
-      INACTIVE_COUNT=$(ls "$INACTIVE" 2>/dev/null | wc -l | tr -d ' ')
-      echo "{\"systemMessage\": \"Active: $ACTIVE | Inactive: $INACTIVE_COUNT\"}"
-      exit 0
-      ;;
-    *)
-      echo "{\"systemMessage\": \"Unknown stack: $FORCE_STACK. Use: ios, android, mobile, backend, frontend, fullstack, all, status\"}"
-      exit 1
-      ;;
-  esac
-  ACTIVE=$(ls "$SKILLS" 2>/dev/null | wc -l | tr -d ' ')
-  echo "{\"systemMessage\": \"Stack switched to $FORCE_STACK ($ACTIVE skills active). Restart conversation for full effect.\"}"
-  exit 0
-fi
-
-# Auto-detect mode (SessionStart hook)
-CWD=$(pwd)
-
-# If cwd is $HOME, skip detection  -  keep default (iOS)
-if [ "$CWD" = "$HOME" ]; then
-  activate_stack "$IOS_PATTERNS"
-  ACTIVE=$(ls "$SKILLS" 2>/dev/null | wc -l | tr -d ' ')
-  echo "{\"systemMessage\": \"Stack: iOS  -  default ($ACTIVE skills active)\"}"
-  exit 0
-fi
-
-HAS_IOS=$(find "$CWD" -maxdepth 2 \( -name "*.xcodeproj" -o -name "Package.swift" \) -not -path "*/.claude/*" -not -path "*/node_modules/*" 2>/dev/null | head -1)
-HAS_ANDROID=$(find "$CWD" -maxdepth 2 \( -name "build.gradle" -o -name "build.gradle.kts" \) -not -path "*/.claude/*" 2>/dev/null | head -1)
-HAS_FRONTEND=$(find "$CWD" -maxdepth 2 \( -name "next.config.*" -o -name "vite.config.*" -o -name "nuxt.config.*" -o -name "tailwind.config.*" -o -name "tsconfig.json" \) -not -path "*/.claude/*" -not -path "*/node_modules/*" 2>/dev/null | head -1)
-HAS_BACKEND=$(find "$CWD" -maxdepth 2 \( -name "requirements.txt" -o -name "pyproject.toml" -o -name "Pipfile" -o -name "Dockerfile" \) -not -path "*/.claude/*" -not -path "*/node_modules/*" 2>/dev/null | head -1)
-
-# Determine stack
-if [ -n "$HAS_IOS" ] && [ -n "$HAS_ANDROID" ]; then
-  STACK="mobile"
-elif [ -n "$HAS_ANDROID" ]; then
-  STACK="android"
-elif [ -n "$HAS_IOS" ]; then
-  STACK="ios"
-elif [ -n "$HAS_FRONTEND" ] && [ -n "$HAS_BACKEND" ]; then
-  STACK="fullstack"
-elif [ -n "$HAS_FRONTEND" ]; then
-  STACK="frontend"
-elif [ -n "$HAS_BACKEND" ]; then
-  STACK="backend"
-else
-  STACK="ios"  # default
-fi
-
-# Apply swap
-case "$STACK" in
-  ios)
-    activate_stack "$IOS_PATTERNS"
-    deactivate_stack "$ANDROID_PATTERNS"
-    deactivate_stack "$BACKEND_PATTERNS"
-    MSG="iOS"
-    ;;
-  android)
-    deactivate_stack "$IOS_PATTERNS"
-    activate_stack "$ANDROID_PATTERNS"
-    deactivate_stack "$BACKEND_PATTERNS"
-    MSG="Android"
-    ;;
-  mobile)
-    activate_stack "$IOS_PATTERNS"
-    activate_stack "$ANDROID_PATTERNS"
-    deactivate_stack "$BACKEND_PATTERNS"
-    MSG="Mobile (iOS + Android)"
-    ;;
-  frontend)
-    deactivate_stack "$IOS_PATTERNS"
-    deactivate_stack "$ANDROID_PATTERNS"
-    deactivate_stack "$BACKEND_PATTERNS"
-    activate_stack "$FRONTEND_PATTERNS"
-    MSG="Frontend"
-    ;;
-  fullstack)
-    deactivate_stack "$IOS_PATTERNS"
-    deactivate_stack "$ANDROID_PATTERNS"
-    activate_stack "$BACKEND_PATTERNS"
-    activate_stack "$FRONTEND_PATTERNS"
-    MSG="Fullstack (Frontend + Backend)"
-    ;;
-  backend)
-    deactivate_stack "$IOS_PATTERNS"
-    deactivate_stack "$ANDROID_PATTERNS"
-    activate_stack "$BACKEND_PATTERNS"
-    deactivate_stack "$FRONTEND_PATTERNS"
-    MSG="Backend"
-    ;;
-esac
-
-ACTIVE=$(ls "$SKILLS" 2>/dev/null | wc -l | tr -d ' ')
-echo "{\"systemMessage\": \"Stack: $MSG ($ACTIVE skills active)\"}"