@mmerterden/multi-agent-pipeline 13.5.0 → 14.0.0

package/install/_plugin-skills.mjs

@@ -27,7 +27,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 
-import { copyDir, countFiles, ensureDir, ensureRealDir, isDryRun } from "./_common.mjs";
+import { copyDir, countFiles, ensureDir, ensureRealDir, isDryRun, wipeDir } from "./_common.mjs";
 
 /** Subtrees a plugin authors itself. `knowledge/` is generated, so it is excluded. */
 export const AUTHORED_GROUPS = Object.freeze(["index", "reference", "workflow", "tools"]);
@@ -148,16 +148,17 @@ export function pluginsToDeliver(home, platformFlag) {
  * @param {string} opts.dest - flat skills directory
  * @param {"ios"|"android"|"all"} opts.platformFlag
  * @param {string} opts.label - host label for log lines
- * @param {Set<string>} [opts.skipNames] - skill names the host already has
- * @returns {{copied: number, skipped: number, plugins: string[], missing: string[]}}
+ * @param {Set<string>} [opts.skipNames] - PIPELINE-owned skill names; a plugin skill matching one is delivered plugin-prefixed rather than dropped
+ * @returns {{copied: number, renamed: string[], collided: number, plugins: string[], missing: string[]}}
  */
 export function installAuthoredPluginSkills(opts) {
   const { home, dest, platformFlag, label, skipNames = new Set() } = opts;
   const { names: wanted, source: selectionSource } = pluginsToDeliver(home, platformFlag);
 
   let copied = 0;
-  let skipped = 0;
   let collided = 0;
+  /** `<original> -> <plugin-prefixed>` for each name a pipeline skill already owns. */
+  const renamed = [];
   const plugins = [];
   const missing = [];
   // Names delivered in THIS pass, so a later plugin cannot overwrite an earlier
@@ -186,17 +187,43 @@ export function installAuthoredPluginSkills(opts) {
               .map((e) => ({ name: e.name, from: join(groupDir, e.name) }));
 
       for (const { name, from } of entries) {
+        // A plugin skill whose name a PIPELINE skill already owns used to be dropped.
+        // That is not a duplicate: the pipeline's `architecture` is a generic ADR
+        // framework while the iOS plugin's is that stack's structural rules, and the
+        // same holds for `backlog`. Claude Code reaches both because its loader
+        // namespaces plugin skills (`ai-ios-engineering-toolkit:architecture`); the
+        // copy hosts had no namespace, so the stack-specific version was silently
+        // unreachable on exactly the repos that need it most.
+        //
+        // Deliver it under the plugin-prefixed name instead - the flat analogue of
+        // what the loader does. The pipeline keeps the bare name, so nothing that
+        // dispatches on it changes.
+        let deliveredName = name;
         if (skipNames.has(name)) {
-          skipped++;
-          continue;
+          deliveredName = `${pluginName}-${name}`;
+          renamed.push(`${name} -> ${deliveredName}`);
         }
-        if (delivered.has(name)) {
-          collided++;
-          continue;
+        // Two plugins can author the same skill name - `index` in every toolkit,
+        // `fix-bug` and `branch-and-pr` in four of them. Dropping the later one lost
+        // it entirely on the copy hosts: with the iOS and common toolkits both
+        // enabled, the common toolkit's `index` was simply gone. Prefix instead, so
+        // the first (stack) plugin keeps the bare name that dispatch expects and the
+        // later one is still reachable.
+        if (delivered.has(deliveredName)) {
+          const prefixed = `${pluginName}-${name}`;
+          if (delivered.has(prefixed)) {
+            collided++;
+            continue;
+          }
+          renamed.push(`${deliveredName} -> ${prefixed}`);
+          deliveredName = prefixed;
         }
-        delivered.add(name);
-        const to = join(dest, name);
+        delivered.add(deliveredName);
+        const to = join(dest, deliveredName);
         ensureDir(dest);
+        // Wipe before copy: `copyDir` only adds, so a file the plugin dropped upstream
+        // would linger in the installed skill and keep being read as current.
+        wipeDir(to);
         copyDir(from, to, {});
         copied += countFiles(from);
         perPlugin++;
@@ -215,8 +242,11 @@ export function installAuthoredPluginSkills(opts) {
       `    -> ${label}: ${collided} name collision(s) resolved in favour of the earlier plugin`,
     );
   }
-  if (skipped > 0) {
-    console.log(`    -> ${label}: skipped ${skipped} skill(s) the host already carries`);
+  if (renamed.length > 0) {
+    console.log(
+      `    -> ${label}: ${renamed.length} plugin skill(s) plugin-prefixed so a name clash loses ` +
+        `nothing (${renamed.join(", ")})`,
+    );
   }
   if (missing.length > 0) {
     console.log(
@@ -224,7 +254,7 @@ export function installAuthoredPluginSkills(opts) {
         `clone {owner}/multi-agent-plugins or enable them in Claude Code to deliver their skills`,
     );
   }
-  return { copied, skipped, collided, plugins, missing, selectionSource };
+  return { copied, collided, renamed, plugins, missing, selectionSource };
 }
 
 /**
@@ -243,4 +273,33 @@ export function existingSkillNames(dir) {
   );
 }
 
+/**
+ * Skill names the PIPELINE owns, derived from its source tree.
+ *
+ * This is what `skipNames` should be. Callers used to pass
+ * `existingSkillNames(dest)` - a snapshot of whatever was already installed - which
+ * did protect pipeline skills from being shadowed by a plugin, but also meant a
+ * plugin skill was copied exactly once and then frozen: on the second install its
+ * own name was "already there", so it was skipped, forever. A stale plugin skill
+ * then outlives every upstream fix in it, which is how a reference to a path the
+ * plugin no longer names survived in an installed tree.
+ *
+ * Deriving from the source keeps the shadowing protection (a plugin still cannot
+ * overwrite a pipeline skill) while letting plugin skills refresh on every install.
+ *
+ * @param {string} pipelineSrc - the repo's `pipeline/` directory
+ * @returns {Set<string>}
+ */
+export function pipelineOwnedSkillNames(pipelineSrc) {
+  const owned = new Set();
+  for (const group of ["core", "external"]) {
+    const dir = join(pipelineSrc, "skills", "shared", group);
+    if (!existsSync(dir)) continue;
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      if (e.isDirectory()) owned.add(e.name);
+    }
+  }
+  return owned;
+}
+
 export { ensureRealDir };

package/install/claude.mjs

@@ -23,18 +23,21 @@ import { localizeCommands } from "../pipeline/scripts/localize-commands.mjs";
 import {
   copyDir,
   copyFile,
+  copySkillsIndex,
   countFiles,
   ensureDir,
   ensureRealDir,
   isDryRun,
   pruneAbandonedTrees,
   pruneLegacyMultiAgentSkills,
+  pruneOrphanSkillFiles,
   removePipelineAgentFiles,
   wipeDir,
   writeFile,
 } from "./_common.mjs";
 import { copyExternalSkillsFiltered } from "./_platform-filter.mjs";
 import { DEV_ONLY_SCRIPTS, countDevOnlyFiles } from "./_dev-only-files.mjs";
+import { registerMcpServer } from "./_mcp-register.mjs";
 
 /**
  * Dead matcher written by pre-v11.4.1 installs. Hook matchers only ever see
@@ -86,6 +89,14 @@ export function installClaude(ctx) {
   ensurePreferences(PREFS_PATH, pipelineSrc);
   configureSettings(home);
 
+  // Claude Code was the last target still shipping skills without the tools those
+  // skills call. The dev-toolkit server backs design-check, every ios_* / android_*
+  // simulator call and the archive audits, and its absence is invisible until a run
+  // reaches for one of them. `--scope user` is not optional here: `claude mcp add`
+  // defaults to project scope, which would register the server only for whichever
+  // directory the installer ran in.
+  registerMcpServer("claude", "Claude Code");
+
   console.log("");
 }
 
@@ -325,10 +336,7 @@ function installSkills(opts) {
 
   if (indexOnly) {
     ensureDir(dest);
-    const indexJson = join(pipelineSrc, "skills", ".skills-index.json");
-    const indexMd = join(pipelineSrc, "skills", "skills-index.md");
-    if (existsSync(indexJson)) copyFile(indexJson, join(dest, ".skills-index.json"));
-    if (existsSync(indexMd)) copyFile(indexMd, join(dest, "skills-index.md"));
+    copySkillsIndex(pipelineSrc, dest);
     console.log(`    -> --index-only: wrote skills-index.{json,md} to ${dest}`);
     console.log(`    -> set prefs.global.dynamicSkillLoading=true to use (see docs)`);
     return;
@@ -386,6 +394,22 @@ function installSkills(opts) {
     }
   }
 
+  // The index ships on FULL installs too, not just --index-only. It is what
+  // `match-skills.mjs` reads when prefs.global.dynamicSkillLoading is on, and the
+  // schema has always claimed a full install provides it. It did not: only
+  // --index-only copied it, so flipping the pref on a normal install produced an
+  // exit-1 "cannot read index" on the first dispatch. Two small files, and the
+  // feature is either wired or it is not.
+  copySkillsIndex(pipelineSrc, dest);
+
+  // Same pre-directory-layout leftovers Copilot accumulated. Claude Code's tree is
+  // clean today, but the legacy shape predates both targets, so the prune runs here
+  // too rather than waiting for someone to find the first stale copy.
+  const orphans = pruneOrphanSkillFiles(dest);
+  if (orphans > 0) {
+    console.log(`    -> pruned ${orphans} stale flat skill file(s) from an older layout`);
+  }
+
   console.log(`    -> ${claudeSkillCount} skill files installed to ${dest}`);
 
   // Keep the shared skills index README in sync.

package/install/codex.mjs

@@ -23,6 +23,7 @@ import { join } from "path";
 import {
   copyDir,
   copyFile,
+  copySkillsIndex,
   countFiles,
   ensureDir,
   ensureRealDir,
@@ -33,7 +34,7 @@ import {
 import { DEV_ONLY_SCRIPTS, countDevOnlyFiles } from "./_dev-only-files.mjs";
 import { registerMcpServer } from "./_mcp-register.mjs";
 import { installCodexAgents } from "./_codex-agents.mjs";
-import { existingSkillNames, installAuthoredPluginSkills } from "./_plugin-skills.mjs";
+import { installAuthoredPluginSkills, pipelineOwnedSkillNames } from "./_plugin-skills.mjs";
 import { generateCodexInstructions } from "./_codex-instructions.mjs";
 import { mergeManagedBlock } from "./_managed-block.mjs";
 
@@ -86,6 +87,12 @@ export const CODEX_PATH_REWRITES = Object.freeze([
   // refs/commands dir, so these generic rules follow the multi-agent ones.
   { from: /\$HOME\/\.claude\/commands\b/g, to: "$HOME/.codex/multi-agent-refs/commands" },
   { from: /~\/\.claude\/commands\b/g, to: "~/.codex/multi-agent-refs/commands" },
+  // Skills live under the refs tree on this host, so a skill referenced by path
+  // (the compliance pair, humanizer, the xcode-build family) has to point there.
+  // MUST precede the bare `multi-agent-refs` rule below, which would otherwise
+  // leave the `/skills` segment pointing at the Claude tree.
+  { from: /\$HOME\/\.claude\/skills\b/g, to: "$HOME/.codex/multi-agent-refs/skills" },
+  { from: /~\/\.claude\/skills\b/g, to: "~/.codex/multi-agent-refs/skills" },
   { from: /\$HOME\/\.claude\/multi-agent-refs\b/g, to: "$HOME/.codex/multi-agent-refs" },
   { from: /~\/\.claude\/multi-agent-refs\b/g, to: "~/.codex/multi-agent-refs" },
   { from: /\$HOME\/\.claude\/agents\b/g, to: "$HOME/.codex/agents" },
@@ -375,6 +382,7 @@ function installPrompt(promptsDir) {
  */
 function installSkillRefs(pipelineSrc, dest, home, platformFlag) {
   const externalSrc = join(pipelineSrc, "skills", "shared", "external");
+  const coreSrc = join(pipelineSrc, "skills", "shared", "core");
 
   ensureRealDir(dest);
   ensureDir(dest);
@@ -383,14 +391,37 @@ function installSkillRefs(pipelineSrc, dest, home, platformFlag) {
   let count = 0;
   if (existsSync(externalSrc)) count += copyTreeRewritten(externalSrc, dest);
 
+  // `shared/core` also holds two skills that are NOT pipeline sub-commands:
+  // apple-archive-compliance and google-play-compliance. Copying only `external`
+  // left both unreachable on Codex while `smoke-compliance-skills.sh` asserted they
+  // were wired to four consumers - the gate passed, the host had nothing to load.
+  // The `multi-agent*` dirs stay out: those are sub-command specs, and they ship as
+  // refs under `commands/` precisely so they never enter the skills block.
+  if (existsSync(coreSrc)) {
+    count += copyTreeRewritten(
+      coreSrc,
+      dest,
+      (rel) => !rel.startsWith("multi-agent/") && !rel.startsWith("multi-agent-"),
+    );
+  }
+
+  // Pipeline-owned names come from the SOURCE tree. A destination snapshot also
+  // matched plugin skills from a previous install, so each was copied once and then
+  // skipped forever - frozen against every upstream fix in it.
   const res = installAuthoredPluginSkills({
     home,
     dest,
     platformFlag,
     label: "Codex CLI",
-    skipNames: existingSkillNames(dest),
+    skipNames: pipelineOwnedSkillNames(pipelineSrc),
   });
 
+  // The index lands beside the refs it indexes. Codex has no skills block to feed,
+  // but `match-skills.mjs` is installed here too and dynamic skill loading reads the
+  // same file on every host - and the router's `ls`/`grep` discovery gets a cheap
+  // catalogue out of it rather than heading four lines of each SKILL.md.
+  copySkillsIndex(pipelineSrc, dest);
+
   console.log(
     `    -> ${count + res.copied} skill file(s) copied to ${dest} as refs (0 skills-block cost)`,
   );

package/install/copilot.mjs

@@ -8,24 +8,27 @@
  * @module install/copilot
  */
 
-import { existsSync, mkdirSync, readdirSync, rmSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
 import { join } from "path";
 
 import {
   copyDir,
   copyFile,
+  copySkillsIndex,
   countFiles,
   ensureDir,
   ensureRealDir,
   isDryRun,
+  pruneOrphanSkillFiles,
   removePipelineAgentFiles,
   wipeDir,
+  writeFile,
 } from "./_common.mjs";
 import { copyExternalSkillsFiltered } from "./_platform-filter.mjs";
 import { DEV_ONLY_SCRIPTS, countDevOnlyFiles } from "./_dev-only-files.mjs";
 import { generateCopilotInstructions } from "./_copilot-instructions.mjs";
 import { legacyTrailingContent, mergeManagedBlock } from "./_managed-block.mjs";
-import { existingSkillNames, installAuthoredPluginSkills } from "./_plugin-skills.mjs";
+import { installAuthoredPluginSkills, pipelineOwnedSkillNames } from "./_plugin-skills.mjs";
 import { registerMcpServer } from "./_mcp-register.mjs";
 
 /**
@@ -47,6 +50,7 @@ export function installCopilot(ctx) {
   const COPILOT_SKILLS = join(COPILOT_DIR, "skills");
   const COPILOT_SCHEMAS = join(COPILOT_DIR, "schemas");
   const COPILOT_LIB = join(COPILOT_DIR, "lib");
+  const COPILOT_RULES = join(COPILOT_DIR, "rules");
 
   console.log("  [Copilot CLI] Installing pipeline instructions...");
   ensureDir(COPILOT_DIR);
@@ -56,6 +60,7 @@ export function installCopilot(ctx) {
   installAgents(pipelineSrc, COPILOT_AGENTS, useSymlinks);
   installSchemas(pipelineSrc, COPILOT_SCHEMAS, useSymlinks);
   installLib(pipelineSrc, COPILOT_LIB, useSymlinks);
+  installRules(pipelineSrc, COPILOT_RULES, useSymlinks);
   installSkills({ home, pipelineSrc, dest: COPILOT_SKILLS, indexOnly, useSymlinks, platformFlag });
 
   // Copilot never registered the companion MCP server, while Codex did from the day its
@@ -66,6 +71,91 @@ export function installCopilot(ctx) {
   registerMcpServer("copilot", "Copilot CLI");
 }
 
+/**
+ * `$HOME/.claude/...` rewrites applied to skill files copied into the Copilot tree.
+ *
+ * Copilot's skills used to be copied byte-for-byte, so a Copilot-only install
+ * shipped 15 references to `~/.claude/scripts` and `~/.claude/lib` - trees that
+ * install never creates. Every one of those was a dangling path: the skill told the
+ * agent to run a script at a location that does not exist on that machine. Codex has
+ * had this rewrite since its installer was written; Copilot simply never got it.
+ *
+ * Only the trees Copilot actually OWNS are rewritten:
+ *
+ * - `scripts`, `lib`, `schemas`, `agents`, `rules` and `skills` are installed under
+ *   `~/.copilot/`, so references must point there.
+ * - `multi-agent-refs` and `commands` are deliberately NOT rewritten: Copilot does
+ *   not install them, and the instructions block already routes those to GitHub or
+ *   to `~/.claude` when Claude Code is present on the same machine.
+ * - Shared state (`logs/`, `multi-agent-preferences.json`, `knowledge/`) is NOT
+ *   rewritten either. `~/.claude` is the cross-host state root - that is what lets
+ *   `:resume` / `:log` / `:status` see a task started from another CLI.
+ *
+ * @type {ReadonlyArray<{from: RegExp, to: string}>}
+ */
+export const COPILOT_PATH_REWRITES = Object.freeze([
+  // Skills first: a skill that names a sibling skill by path (the compliance pair,
+  // humanizer, the xcode-build family) has to land inside THIS host's skills tree.
+  { from: /\$HOME\/\.claude\/skills\b/g, to: "$HOME/.copilot/skills" },
+  { from: /~\/\.claude\/skills\b/g, to: "~/.copilot/skills" },
+  { from: /\$HOME\/\.claude\/scripts\b/g, to: "$HOME/.copilot/scripts" },
+  { from: /~\/\.claude\/scripts\b/g, to: "~/.copilot/scripts" },
+  { from: /\$HOME\/\.claude\/lib\b/g, to: "$HOME/.copilot/lib" },
+  { from: /~\/\.claude\/lib\b/g, to: "~/.copilot/lib" },
+  { from: /\$HOME\/\.claude\/schemas\b/g, to: "$HOME/.copilot/schemas" },
+  { from: /~\/\.claude\/schemas\b/g, to: "~/.copilot/schemas" },
+  { from: /\$HOME\/\.claude\/agents\b/g, to: "$HOME/.copilot/agents" },
+  { from: /~\/\.claude\/agents\b/g, to: "~/.copilot/agents" },
+  { from: /\$HOME\/\.claude\/rules\b/g, to: "$HOME/.copilot/rules" },
+  { from: /~\/\.claude\/rules\b/g, to: "~/.copilot/rules" },
+]);
+
+/**
+ * Apply the Copilot path map to a file's text.
+ * @param {string} text
+ * @returns {string}
+ */
+export function rewriteCopilotPaths(text) {
+  let out = text;
+  for (const { from, to } of COPILOT_PATH_REWRITES) out = out.replace(from, to);
+  return out;
+}
+
+/**
+ * Recursively copy a tree, applying the Copilot path map to text files.
+ *
+ * Not `copyDir`: that copies bytes, and every skill file here carries
+ * `$HOME/.claude/...` references that have to be retargeted.
+ *
+ * @param {string} src
+ * @param {string} dest
+ * @param {(relPath: string) => boolean} [filter] - receives the path relative to the
+ *   copy root (POSIX-separated). Return false to skip.
+ * @param {string} [relBase] - internal: accumulated relative path
+ * @returns {number} files written
+ */
+function copyTreeRewritten(src, dest, filter, relBase = "") {
+  const TEXT = /\.(md|json|sh|mjs|js|txt|ya?ml|toml)$/i;
+  let n = 0;
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const from = join(src, entry.name);
+    const to = join(dest, entry.name);
+    const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      n += copyTreeRewritten(from, to, filter, rel);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (filter && !filter(rel)) continue;
+    ensureDir(dest);
+    const isText = TEXT.test(entry.name);
+    const raw = readFileSync(from, isText ? "utf-8" : null);
+    writeFile(to, isText ? rewriteCopilotPaths(raw) : raw);
+    n++;
+  }
+  return n;
+}
+
 /** Start of the pipeline-managed span in copilot-instructions.md. */
 export const INSTRUCTIONS_START_MARKER = "# Multi-Agent Development Pipeline";
 
@@ -168,6 +258,26 @@ function installLib(pipelineSrc, dest, useSymlinks) {
   console.log(`    -> ${countFiles(libSrc)} files copied to ${dest}`);
 }
 
+/**
+ * The convention rules the analysis phase falls back to when a project ships no
+ * standards file of its own.
+ *
+ * Codex has installed these since its installer was written, with the reason stated
+ * there: a dangling `rules/` means that fallback silently yields nothing. Copilot never
+ * got the tree, so every `rules/figma-pipeline.md` and `rules/tdd.md` reference in its
+ * skills pointed at a directory that install never created - the same silent-nothing
+ * outcome, on the host that has no `~/.claude` to borrow from.
+ */
+function installRules(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Copilot CLI] Installing convention rules...");
+  const rulesSrc = join(pipelineSrc, "rules");
+  if (!existsSync(rulesSrc)) return;
+  if (!useSymlinks) ensureRealDir(dest);
+  wipeDir(dest);
+  copyDir(rulesSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(rulesSrc)} files copied to ${dest}`);
+}
+
 function installSkills(opts) {
   const { home, pipelineSrc, dest, indexOnly, useSymlinks, platformFlag } = opts;
   console.log("  [Copilot CLI] Installing skills...");
@@ -182,10 +292,7 @@ function installSkills(opts) {
     } catch {
       /* ok */
     }
-    const indexJson = join(pipelineSrc, "skills", ".skills-index.json");
-    const indexMd = join(pipelineSrc, "skills", "skills-index.md");
-    if (existsSync(indexJson)) copyFile(indexJson, join(dest, ".skills-index.json"));
-    if (existsSync(indexMd)) copyFile(indexMd, join(dest, "skills-index.md"));
+    copySkillsIndex(pipelineSrc, dest);
     console.log(`    -> --index-only: wrote skills-index.{json,md} to ${dest}`);
     console.log("");
     return;
@@ -229,8 +336,24 @@ function installSkills(opts) {
   }
 
   if (existsSync(sharedCoreSrc)) {
-    copyDir(sharedCoreSrc, dest, { useSymlinks });
-    copilotSkillCount += countFiles(sharedCoreSrc);
+    if (useSymlinks) {
+      // --link (dev) mode points at the repo, so there is nothing to rewrite -
+      // and rewriting would mean editing the checkout.
+      copyDir(sharedCoreSrc, dest, { useSymlinks });
+      copilotSkillCount += countFiles(sharedCoreSrc);
+    } else {
+      // Wipe each pipeline-owned skill dir before refilling it. Copying only ADDS,
+      // so a subtree from an older layout survives inside a directory the installer
+      // still manages - a real install carried `skills/multi-agent/refs/` for
+      // releases after Copilot stopped installing refs, and every file in it still
+      // pointed at `~/.claude/lib`.
+      for (const e of readdirSync(sharedCoreSrc, { withFileTypes: true })) {
+        if (e.isDirectory()) wipeDir(join(dest, e.name));
+      }
+      // The core skills are the ones that invoke scripts and lib helpers, so they
+      // are the ones whose `~/.claude/...` paths have to be retargeted.
+      copilotSkillCount += copyTreeRewritten(sharedCoreSrc, dest);
+    }
   }
 
   if (existsSync(sharedExternalSrc)) {
@@ -273,17 +396,30 @@ function installSkills(opts) {
   // `knowledge/` is skipped: it is generated from this pipeline's own
   // skills/shared/external, which the step above already installed. Copying it again
   // would duplicate ~5 MB the host already has.
+  // skipNames is the PIPELINE-owned set, derived from the source tree - not a
+  // snapshot of the destination. A dest snapshot also matched plugin skills from a
+  // previous install, so each was copied once and then skipped forever, freezing it
+  // against every upstream fix.
   const pluginResult = installAuthoredPluginSkills({
     home,
     dest,
     platformFlag,
     label: "Copilot CLI",
-    skipNames: existingSkillNames(dest),
+    skipNames: pipelineOwnedSkillNames(pipelineSrc),
   });
   if (pluginResult.copied > 0) {
     console.log(`    -> ${pluginResult.copied} plugin skill file(s) delivered to ${dest}`);
   }
 
+  // Full installs ship the index too - see copySkillsIndex for why.
+  copySkillsIndex(pipelineSrc, dest);
+
+  // Drop `<name>.md` duplicates the pre-directory layout left behind.
+  const orphans = pruneOrphanSkillFiles(dest);
+  if (orphans > 0) {
+    console.log(`    -> pruned ${orphans} stale flat skill file(s) from an older layout`);
+  }
+
   console.log(`    -> ${copilotSkillCount} skill files installed to ${dest}`);
 
   const sharedReadmeSrc = join(pipelineSrc, "skills", "shared", "README.md");

package/install/index.mjs

@@ -182,16 +182,20 @@ function printSummary(opts) {
     console.log("");
   }
 
-  console.log("  For UI testing, the mobile MCP server:");
-  if (forCodex) {
-    console.log("    Codex CLI:   registered automatically (codex mcp add dev-toolkit)");
+  // All three register automatically now. Claude Code was the last to gain it, and
+  // this summary kept telling users to do it by hand long enough that the
+  // hand-registered entry became the only reason it worked on any given machine.
+  console.log("  For UI testing, the dev-toolkit MCP server is registered automatically:");
+  if (forClaude) {
+    console.log("    Claude Code: claude mcp add --scope user dev-toolkit  (user scope, all projects)");
   }
   if (forCopilot) {
-    console.log("    Copilot CLI: registered automatically (copilot mcp add dev-toolkit)");
+    console.log("    Copilot CLI: copilot mcp add dev-toolkit");
   }
-  if (forClaude) {
-    console.log("    Claude Code: add it yourself - claude mcp add dev-toolkit -- npx -y @mmerterden/dev-toolkit-mcp");
+  if (forCodex) {
+    console.log("    Codex CLI:   codex mcp add dev-toolkit");
   }
+  console.log("    Skipped only when the host CLI is not on PATH - the command to run is printed above.");
   console.log("");
   console.log("  Uninstall everything: npx @mmerterden/multi-agent-pipeline uninstall");
   console.log("  (Personal access tokens in keychain are preserved.)");

package/install/templates/copilot-instructions.md

@@ -26,7 +26,7 @@
 ## Modes
 
 - **Normal**: Full 8 phases with code review + Plan Approval Gate
-- **Fast (multi-agent-dev)**: Init -> Dev(Opus) -> Commit -> Report
+- **Fast (multi-agent-dev)**: Init -> Dev(Opus) -> Review -> Test -> Commit -> Report
 - **Autopilot (multi-agent-autopilot)**: Skip confirmations, auto commit/PR
 - **Fastest (multi-agent-dev-autopilot)**: Combine dev + autopilot
 - **Local (multi-agent-local)**: Full 8 phases on current branch - no worktree

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "13.5.0",
+  "version": "14.0.0",
   "description": "8-phase AI development pipeline with full orchestration on Claude Code, Copilot CLI and Codex CLI. Analysis, planning, TDD, CLI-aware parallel review with consensus surfacing + Fable 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/code-reviewer.md

@@ -21,9 +21,17 @@ You are a code reviewer. Review the provided diff for:
 Return ONLY a JSON object:
 
 ```json
-{"findings": [{"severity": "blocking|important|suggestion", "file": "...", "line": N, "issue": "...", "fix": "..."}], "approved": true|false}
+{
+  "findings": [{"severity": "blocking|important|suggestion", "file": "...", "line": N, "issue": "...", "fix": "...", "ruleId": "SEC-01", "criteriaSource": "ios-coding-standard"}],
+  "conformance": [{"ruleId": "SEC-01", "verdict": "conformant|violated|not-applicable", "file": "Sources/X.swift", "line": 42, "reason": "..."}],
+  "approved": true|false
+}
 ```
 
+`ruleId` + `criteriaSource` are required on a finding that comes from a cited
+rule and omitted otherwise. `conformance` is required whenever a `${CRITERIA}`
+block was supplied  -  see below.
+
 ## Severity Classification
 
 - **blocking**: Must fix  -  bugs, security holes, data loss risk, architecture violations
@@ -32,6 +40,55 @@ Return ONLY a JSON object:
 
 Do NOT approve if any blocking findings exist.
 
+## Criteria (required when supplied)
+
+The orchestrator may pass a `${CRITERIA}` block: the rule IDs the changed code
+was supposed to honour, resolved deterministically before you were dispatched,
+plus the paths of the registry files that define them. Read the registry files
+you are pointed at. They are YAML, and a rule carries `title`, `severity` and
+`enforcement`; **many but not all** carry a `check` spelling out what counts as a
+violation (in the shipped iOS registry, 53 of 99 do). Where `check` is absent,
+judge against the rule's `title` and `rationale` rather than assuming the rule is
+unusable  -  and say so in the conformance row's evidence, so a thin rule reads as
+a thin rule and not as a pass.
+
+```
+${CRITERIA}
+registries:
+  <name> (<version>) -> <absolute path to rules.yml>
+rules in scope:
+  <RULE-ID> [<severity>/<enforcement>] -> <files it applies to>
+  ...
+module guides:
+  <repo-relative path>
+coverage gaps:
+  <language>: <why no rule applies  -  review these files on general criteria>
+```
+
+Return one `conformance` row **per rule ID in that list**, and no rows for IDs
+outside it. Rules:
+
+- `conformant` requires evidence: the `file` and `line` you checked. A verdict
+  with no evidence is an assertion, and the report would then certify
+  completeness you never established.
+- `violated` must have a matching entry in `findings` carrying the same
+  `ruleId`.
+- `not-applicable` requires a `reason` naming why the rule cannot bind here.
+- An ID that is neither checked nor explicitly waived fails the stage. This is
+  the whole point of the list: "I found nothing" and "I checked nothing"
+  produce identical `findings` arrays, so the checklist is what tells them
+  apart.
+- Never invent a rule ID. Cite only IDs from the block, and only for rules the
+  registry actually contains.
+
+Enforcement kinds tell you who owns a rule: `format` belongs to the formatter
+and `lint` to the linter, so do not hand-review those beyond noticing an
+obvious breach; `judgement` rules are yours, and each needs the measurement its
+`check` names (a count, a call-site list) rather than an impression.
+
+When no `${CRITERIA}` block is supplied, omit `conformance` entirely and review
+on the focus areas above.
+
 ## Priority Files (advisory)
 
 When the orchestrator passes a `${PRIORITY_FILES}` block, treat it as a heuristic