@mmerterden/multi-agent-pipeline 12.5.0 → 12.6.0

package/pipeline/scripts/classify-plan-safety.mjs

@@ -34,8 +34,10 @@
 //   - infrastructure        20    -  touches Dockerfile, CI yaml, Gradle wrapper,
 //                                    package.json resolutions / engines, install.js
 //
-// recommendPause = true when score >= 50 (tuned: any two medium signals or
-// any one heavy signal flips it).
+// recommendPause = true when any one heavy signal (weight >= 30) fires, OR two
+// or more medium-and-above signals (weight >= 20) fire, OR the accumulated
+// score reaches 50. A score threshold alone cannot express the first two
+// clauses: the heaviest single rule is 35 and two medium signals can total 45.
 //
 // Exit codes: 0 = verdict produced, 1 = malformed input, 2 = usage error.
 
@@ -168,7 +170,10 @@ if (infraHits.length > 0) {
 
 // --- aggregate ---
 const score = reasons.reduce((s, r) => s + r.weight, 0);
-const recommendPause = score >= 50;
+const heavyHits = reasons.filter((r) => r.weight >= 30);
+const mediumOrAboveHits = reasons.filter((r) => r.weight >= 20);
+const recommendPause =
+  heavyHits.length >= 1 || mediumOrAboveHits.length >= 2 || score >= 50;
 
 let summary;
 if (recommendPause) {

package/pipeline/scripts/cost-budget-check.mjs

@@ -33,6 +33,7 @@
 
 import { readFileSync, existsSync } from "fs";
 import { dirname, join } from "path";
+import { homedir } from "os";
 import { fileURLToPath } from "url";
 import { costUsd } from "./_cost.mjs";
 
@@ -103,10 +104,11 @@ function resolveTracker() {
   const id = flags["task-id"];
   if (!id) die("either --tracker or --task-id is required");
   const bare = String(id).replace(/^#/, "");
+  const logRoot = join(homedir(), ".claude", "logs", "multi-agent");
   for (const c of [
-    join(process.cwd(), ".worktrees", String(id), "phase-tracker.json"),
-    join(process.cwd(), ".worktrees", bare, "phase-tracker.json"),
-    join(process.cwd(), ".worktrees", `task-${bare}`, "phase-tracker.json"),
+    join(logRoot, String(id), "tracker-state.json"),
+    join(logRoot, bare, "tracker-state.json"),
+    join(logRoot, `task-${bare}`, "tracker-state.json"),
   ]) {
     if (existsSync(c)) return c;
   }
@@ -134,15 +136,17 @@ if (!rate) die(`no price for model "${cfg.pricingModel}" in cost-table.json`);
 
 let tokensIn = 0;
 let tokensOut = 0;
+let tokensCached = 0;
 for (const p of Object.values(tracker.phases || {})) {
   tokensIn += Number(p?.tokens_in || 0);
   tokensOut += Number(p?.tokens_out || 0);
+  tokensCached += Number(p?.tokens_cached || 0);
 }
 
-const usd = costUsd(rate, tokensIn, tokensOut);
+const usd = costUsd(rate, tokensIn, tokensOut, tokensCached);
 const pctOfMax = (usd / cfg.maxUsd) * 100;
 const usdStr = `$${usd.toFixed(2)}`;
-const totalTok = tokensIn + tokensOut;
+const totalTok = tokensIn + tokensOut + tokensCached;
 
 const base =
   `cost-budget: ${usdStr} of $${cfg.maxUsd.toFixed(2)} ` +

package/pipeline/scripts/fixtures/install-layout.tsv

@@ -1,19 +1,19 @@
 .claude/.pipeline-version	1
 .claude/CLAUDE.md	1
 .claude/agents	8
-.claude/commands	47
+.claude/commands	48
 .claude/lib	27
 .claude/multi-agent-preferences.json	1
 .claude/multi-agent-refs	52
 .claude/rules	12
-.claude/schemas	24
-.claude/scripts	199
+.claude/schemas	25
+.claude/scripts	201
 .claude/settings.json	1
 .claude/skills	428
 .copilot/.pipeline-version	1
 .copilot/agents	8
 .copilot/copilot-instructions.md	1
 .copilot/lib	27
-.copilot/schemas	24
-.copilot/scripts	199
-.copilot/skills	470
+.copilot/schemas	25
+.copilot/scripts	201
+.copilot/skills	471

package/pipeline/scripts/learnings-ledger.mjs

@@ -74,9 +74,27 @@ function die(msg, code = 1) {
   process.exit(code);
 }
 
+// Resolves to the MAIN repository name even when called from inside a pipeline
+// worktree. `--show-toplevel` returns the worktree root, whose basename is the
+// task id, which would shard the per-repo ledger one directory per task and make
+// the learning replay always miss. `--git-common-dir` points at the main
+// repository's .git for every linked worktree.
 function repoSlug() {
   if (flags["repo-slug"]) return String(flags["repo-slug"]);
   if (process.env.MULTI_AGENT_REPO_SLUG) return process.env.MULTI_AGENT_REPO_SLUG;
+  try {
+    const commonDir = execFileSync(
+      "git",
+      ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    if (commonDir) {
+      const base = basename(commonDir);
+      const root = base === ".git" ? dirname(commonDir) : commonDir.replace(/\.git$/, "");
+      const slug = basename(root);
+      if (slug) return slug;
+    }
+  } catch { /* not a git repo, or git too old for --path-format */ }
   try {
     const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf8",

package/pipeline/scripts/lint-mcp-refs.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+// lint-mcp-refs.mjs  -  every mcp__<server>__<tool> reference must be callable.
+//
+// A host composes an MCP tool name as mcp__<registered-server-name>__<tool>.
+// The pipeline had 100 references to `mcp__dev_toolkit__*` while the server is
+// registered as `dev-toolkit`, so the real names are `mcp__dev-toolkit__*`.
+// Nothing caught it: prose is not executed, and a wrong name inside an
+// `allowed-tools:` allowlist silently denies the tool instead of erroring.
+//
+// Checks (errors - fail the gate):
+//   1. the server segment must be a known registered server name
+//   2. the known-bad snake_case spellings are called out with their fix
+//
+// Optional deep check (advisory - never fails):
+//   3. when the companion dev-toolkit repo resolves locally (via
+//      prefs.global.devToolkit.localPath, or the mcpServers registration in
+//      ~/.claude.json / ~/.claude/settings.json), handshake it over stdio and
+//      confirm every referenced dev-toolkit tool actually exists in tools/list.
+//      CI has no local checkout, so an unresolvable repo is a skip, not a fail.
+//
+// Zero-dependency. Runs inside `npm test` and ci-lite.
+//
+// Usage: node pipeline/scripts/lint-mcp-refs.mjs [--strict-tools]
+// Exit: 0 clean, 1 unknown server segment (or a missing tool with --strict-tools).
+
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const strictTools = process.argv.includes("--strict-tools");
+
+// Servers the pipeline is allowed to reference. The key is the registered
+// server name as it appears in an mcpServers config, which is what the host
+// interpolates into the tool name.
+const KNOWN_SERVERS = {
+  "dev-toolkit": "companion device/browser toolkit (@mmerterden/dev-toolkit-mcp)",
+  claude_ai_Figma: "Figma MCP (analysis phase only)",
+  XcodeBuildMCP: "optional third-party Xcode build server",
+};
+// Spellings that look right but cannot resolve to a registered server.
+const KNOWN_BAD = { dev_toolkit: "dev-toolkit", "claude-ai-Figma": "claude_ai_Figma" };
+
+const SCAN_DIRS = ["pipeline/commands", "pipeline/skills", "pipeline/multi-agent-refs"];
+const SCAN_EXT = /\.(md|sh|mjs|json)$/;
+const PRUNE = new Set(["node_modules", ".git", ".worktrees", "Pods", ".build", "DerivedData", ".next"]);
+
+function walk(dir, out = []) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    if (PRUNE.has(e.name)) continue;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) walk(p, out);
+    else if (SCAN_EXT.test(e.name)) out.push(p);
+  }
+  return out;
+}
+
+const files = SCAN_DIRS.flatMap((d) => walk(join(repoRoot, d)));
+const REF = /mcp__([A-Za-z0-9_-]+?)__([a-z0-9_]+)/g;
+
+const errors = [];
+const refs = new Map(); // server -> Map(tool -> Set(file:line))
+
+for (const file of files) {
+  const rel = file.slice(repoRoot.length + 1);
+  const lines = readFileSync(file, "utf8").split("\n");
+  lines.forEach((line, i) => {
+    for (const m of line.matchAll(REF)) {
+      const [, server, tool] = m;
+      // Prose writes families as mcp__dev-toolkit__ios_* - a wildcard, not a tool.
+      const next = line[m.index + m[0].length];
+      if (next === "*" || tool.endsWith("_")) continue;
+      const where = `${rel}:${i + 1}`;
+      if (!refs.has(server)) refs.set(server, new Map());
+      const tools = refs.get(server);
+      if (!tools.has(tool)) tools.set(tool, new Set());
+      tools.get(tool).add(where);
+    }
+  });
+}
+
+for (const [server, tools] of refs) {
+  if (server in KNOWN_SERVERS) continue;
+  const fix = KNOWN_BAD[server];
+  const sample = [...tools.values()][0].values().next().value;
+  errors.push(
+    fix
+      ? `unknown MCP server segment "${server}" (${tools.size} tool refs, e.g. ${sample}) - the registered server is "${fix}", so the prefix must be mcp__${fix}__`
+      : `unknown MCP server segment "${server}" (${tools.size} tool refs, e.g. ${sample}) - add it to KNOWN_SERVERS in lint-mcp-refs.mjs if this server is expected, or fix the prefix to match the registered server name`,
+  );
+}
+
+// ---- optional deep check: do the referenced dev-toolkit tools exist? --------
+
+function resolveToolkitRepo() {
+  const prefsPath = join(homedir(), ".claude", "multi-agent-preferences.json");
+  if (existsSync(prefsPath)) {
+    try {
+      const dt = JSON.parse(readFileSync(prefsPath, "utf8"))?.global?.devToolkit;
+      if (dt && dt.enabled === false) return null;
+      if (dt?.localPath) {
+        const p = dt.localPath.replace(/^~|\$HOME/, homedir());
+        if (existsSync(join(p, "package.json"))) return p;
+      }
+    } catch {
+      /* fall through to registration lookup */
+    }
+  }
+  const candidates = [];
+  const collect = (obj) => {
+    for (const [name, cfg] of Object.entries(obj || {})) {
+      const arg = Array.isArray(cfg?.args) ? cfg.args.find((a) => /\.(mjs|js)$/.test(a)) : null;
+      if (name.includes("dev") && arg) candidates.push(dirname(resolve(arg)));
+    }
+  };
+  for (const cfgPath of [join(homedir(), ".claude.json"), join(homedir(), ".claude", "settings.json")]) {
+    if (!existsSync(cfgPath)) continue;
+    try {
+      const json = JSON.parse(readFileSync(cfgPath, "utf8"));
+      collect(json.mcpServers);
+      for (const proj of Object.values(json.projects || {})) collect(proj.mcpServers);
+    } catch {
+      /* ignore unreadable config */
+    }
+  }
+  for (const c of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(c, "package.json"), "utf8"));
+      if (pkg.dependencies?.["@modelcontextprotocol/sdk"] && statSync(join(c, ".git"))) return c;
+    } catch {
+      /* not the toolkit */
+    }
+  }
+  return null;
+}
+
+function listTools(repo) {
+  const frames =
+    [
+      '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"lint-mcp-refs","version":"1"}}}',
+      '{"jsonrpc":"2.0","method":"notifications/initialized"}',
+      '{"jsonrpc":"2.0","id":2,"method":"tools/list"}',
+    ].join("\n") + "\n";
+  const r = spawnSync(process.execPath, ["index.js"], {
+    cwd: repo,
+    input: frames,
+    encoding: "utf8",
+    timeout: 20000,
+    maxBuffer: 32 * 1024 * 1024,
+  });
+  if (r.error || !r.stdout) return null;
+  for (const line of r.stdout.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+      if (msg.id === 2 && msg.result?.tools) return msg.result.tools.map((t) => t.name);
+    } catch {
+      /* not a frame */
+    }
+  }
+  return null;
+}
+
+const referencedToolkitTools = refs.get("dev-toolkit");
+let deep = "skipped (no local dev-toolkit checkout)";
+if (referencedToolkitTools) {
+  const repo = resolveToolkitRepo();
+  const served = repo ? listTools(repo) : null;
+  if (!served) {
+    deep = repo ? `skipped (${repo} did not answer tools/list)` : deep;
+  } else {
+    const missing = [...referencedToolkitTools.keys()].filter((t) => !served.includes(t));
+    if (missing.length === 0) {
+      deep = `all ${referencedToolkitTools.size} referenced tools exist in the live server (${served.length} served)`;
+    } else {
+      const msg = `dev-toolkit tools referenced but not served (${served.length} served): ${missing
+        .map((t) => `${t} [${[...referencedToolkitTools.get(t)][0]}]`)
+        .join(", ")}`;
+      deep = `${missing.length} referenced tool(s) not served`;
+      if (strictTools) errors.push(msg);
+      else console.warn(`  WARNING - ${msg}`);
+    }
+  }
+}
+
+const totalRefs = [...refs.values()].reduce((n, tools) => n + tools.size, 0);
+console.log(
+  `lint-mcp-refs: ${totalRefs} distinct tool references across ${refs.size} server(s) in ${files.length} files`,
+);
+for (const [server, tools] of refs) {
+  console.log(`  ${server in KNOWN_SERVERS ? "✓" : "✗"} mcp__${server}__* : ${tools.size} tools`);
+}
+console.log(`  tool-existence check: ${deep}`);
+
+if (errors.length > 0) {
+  console.error(`lint-mcp-refs: ${errors.length} error(s)`);
+  for (const e of errors) console.error("  " + e);
+  process.exit(1);
+}

package/pipeline/scripts/memory-load.sh

@@ -16,9 +16,13 @@ PROJECT_ROOT="${1:?usage: memory-load.sh <project-root>}"
 MEM_DIR="$PROJECT_ROOT/.multi-agent/memory"
 MEM_INDEX="$MEM_DIR/MEMORY.md"
 
-# Pref-gate: locate prefs.json (home-dir first, then project-specific).
+# Pref-gate: locate the preferences file (home-dir first, then XDG config).
+# The canonical name written by the installer is multi-agent-preferences.json;
+# the bare preferences.json names are kept only as legacy fallbacks.
 prefs_file=""
 for candidate in \
+  "$HOME/.claude/multi-agent-preferences.json" \
+  "$HOME/.config/multi-agent-pipeline/multi-agent-preferences.json" \
   "$HOME/.claude/preferences.json" \
   "$HOME/.config/multi-agent-pipeline/preferences.json"
 do

package/pipeline/scripts/render-work-summary.sh

@@ -126,7 +126,10 @@ fi
 changed_block=""
 files_count=0
 total_add=0; total_del=0
-if [ -n "$WORKTREE" ] && [ -d "$WORKTREE/.git" -o -d "$WORKTREE" ]; then
+# Only the directory needs to exist here; `git rev-parse HEAD` below is the real
+# repository check. Testing -d "$WORKTREE/.git" would be wrong regardless: in a
+# linked worktree .git is a file, not a directory.
+if [ -n "$WORKTREE" ] && [ -d "$WORKTREE" ]; then
   if git -C "$WORKTREE" rev-parse HEAD >/dev/null 2>&1; then
     diffstat=$(git -C "$WORKTREE" diff --numstat "$state_base"...HEAD 2>/dev/null || true)
     if [ -n "$diffstat" ]; then

package/pipeline/scripts/smoke-command-inventory.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# smoke-command-inventory.sh  -  the command inventory is DERIVED, never asserted.
+#
+# Every count that describes "how many multi-agent commands exist" used to be a
+# literal in prose (contract header, sync skill, dispatcher). Adding a command
+# left those literals stale while every gate stayed green, because the gates
+# asserted the literal instead of the tree. This gate computes the count from
+# pipeline/commands/multi-agent/*/ and requires the prose to agree.
+#
+# Verifies:
+#   1. contract header count == number of command directories
+#   2. every command directory appears in the contract inventory block
+#   3. both sync surfaces (command + Copilot skill) carry the same count twice
+#      ("N commands are synced" + "instructions + N sub-command skills")
+#   4. every command directory appears in both sync inventory blocks
+#   5. every command directory has its shared/core skill counterpart
+#
+# Exit: 0 all green, 1 any failure.
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$HERE/../.." && pwd)"
+CMD_DIR="$ROOT/pipeline/commands/multi-agent"
+CONTRACT="$ROOT/pipeline/multi-agent-refs/cross-cli-contract.md"
+SYNC="$ROOT/pipeline/commands/multi-agent/sync/SKILL.md"
+SYNC_SKILL="$ROOT/pipeline/skills/shared/core/multi-agent-sync/SKILL.md"
+SKILLS_DIR="$ROOT/pipeline/skills/shared/core"
+
+PASS=0
+FAIL=0
+pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
+fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
+
+echo "══ smoke-command-inventory ══"
+
+for f in "$CONTRACT" "$SYNC" "$SYNC_SKILL"; do
+  [ -f "$f" ] || { echo "  ✗ missing file: ${f#$ROOT/}"; exit 1; }
+done
+
+COMMANDS=$(find "$CMD_DIR" -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | sort)
+N=$(printf '%s\n' "$COMMANDS" | grep -c . || true)
+
+echo "→ 1. derived count from the command tree: $N commands"
+[ "$N" -gt 0 ] && pass "found $N command directories" || fail "no command directories under ${CMD_DIR#$ROOT/}"
+
+echo "→ 2. contract header agrees"
+if grep -Fq "## 1. Command Inventory ($N commands)" "$CONTRACT"; then
+  pass "contract header = $N"
+else
+  fail "contract header does not say ($N commands): $(grep -o '## 1\. Command Inventory ([0-9]* commands)' "$CONTRACT" || echo 'header not found')"
+fi
+
+echo "→ 3. sync surfaces agree (2 counts x 2 files)"
+for f in "$SYNC" "$SYNC_SKILL"; do
+  rel="${f#$ROOT/}"
+  grep -Fq "**$N commands are synced**" "$f" && pass "$rel: synced count = $N" || fail "$rel: 'N commands are synced' != $N"
+  grep -Fq "instructions + $N sub-command skills" "$f" && pass "$rel: step-2 count = $N" || fail "$rel: 'instructions + N sub-command skills' != $N"
+done
+
+echo "→ 4. every command is listed in the contract + both sync inventories"
+MISSING_LIST=0
+while IFS= read -r cmd; do
+  [ -n "$cmd" ] || continue
+  for f in "$CONTRACT" "$SYNC" "$SYNC_SKILL"; do
+    grep -Eq "(^|[ ,])$cmd([ ,]|$)" "$f" || { fail "${f#$ROOT/}: inventory missing '$cmd'"; MISSING_LIST=1; }
+  done
+done <<< "$COMMANDS"
+[ "$MISSING_LIST" -eq 0 ] && pass "all $N commands listed on all 3 surfaces"
+
+echo "→ 5. shared/core skill counterpart exists for every command"
+MISSING_SKILL=0
+while IFS= read -r cmd; do
+  [ -n "$cmd" ] || continue
+  [ -f "$SKILLS_DIR/multi-agent-$cmd/SKILL.md" ] || { fail "no shared/core skill for '$cmd'"; MISSING_SKILL=1; }
+done <<< "$COMMANDS"
+[ "$MISSING_SKILL" -eq 0 ] && pass "all $N commands have a shared/core skill"
+
+echo ""
+echo "══ command-inventory smoke: $PASS passed, $FAIL failed ══"
+[ "$FAIL" -eq 0 ] || exit 1

package/pipeline/scripts/smoke-commands-skills-parity.sh

@@ -36,7 +36,7 @@ fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
 # Underscore-prefixed files (e.g. _account-picker.md) are internal fragments
 # loaded by other commands via Read; they're not invocable slash commands and
 # intentionally have no matching skill.
-CMDS=$(find "$CMDS_DIR" -mindepth 2 -maxdepth 2 -name "SKILL.md" -exec dirname {} \; | xargs -n1 basename | sort)
+CMDS=$(find "$CMDS_DIR" -mindepth 2 -maxdepth 2 -name "SKILL.md" -exec sh -c 'for f do basename "$(dirname "$f")"; done' sh {} + | sort)
 
 # help.md in commands maps to multi-agent-help skill; the main "multi-agent"
 # skill covers the behavior documented across multiple command files, so we

package/pipeline/scripts/smoke-compliance-skills.sh

@@ -5,7 +5,7 @@
 # that the 4 claimed consumer surfaces actually reference them (not just promise).
 #
 # Covers:
-#   1. apple-archive-compliance/SKILL.md exists, has frontmatter, 17-rule catalog,
+#   1. apple-archive-compliance/SKILL.md exists, has frontmatter, 18-rule catalog,
 #      EN + TR humanizer blocks, severity table, prerequisite detection.
 #   2. google-play-compliance/SKILL.md exists, has frontmatter, 21-rule catalog
 #      across 4 categories, EN + TR humanizer blocks, severity table, prereq detection.
@@ -43,8 +43,8 @@ grep -q "^name: apple-archive-compliance$" "$APPLE_SKILL" && pass "apple frontma
 grep -q "^user-invocable: true$" "$APPLE_SKILL" && pass "apple user-invocable" || fail "apple user-invocable"
 grep -q "argument-hint:" "$APPLE_SKILL" && pass "apple argument-hint" || fail "apple argument-hint"
 # Count rule rows in the catalog table (excluding header + separator)
-APPLE_RULES=$(awk '/^## 17-Rule Catalog/,/^## Severity mapping/' "$APPLE_SKILL" | grep -cE '^\| *[0-9]+ *\|' || true)
-[ "$APPLE_RULES" -eq 17 ] && pass "apple catalog has 17 rule rows" || fail "apple catalog has $APPLE_RULES rule rows (want 17)"
+APPLE_RULES=$(awk '/^## 18-Rule Catalog/,/^## Severity mapping/' "$APPLE_SKILL" | grep -cE '^\| *[0-9]+ *\|' || true)
+[ "$APPLE_RULES" -eq 18 ] && pass "apple catalog has 18 rule rows" || fail "apple catalog has $APPLE_RULES rule rows (want 18)"
 
 echo "→ 2. apple skill humanizer blocks EN + TR + severity table"
 # v8.2 split humanizer language from picker language: gating moved from
@@ -59,7 +59,7 @@ echo "→ 3. apple skill prerequisite detection + archive resolution (v8.4.0+ us
 grep -q 'ios_app_store_audit' "$APPLE_SKILL" && pass "apple references ios_app_store_audit MCP tool" || fail "apple ios_app_store_audit reference missing"
 grep -q '.xcarchive' "$APPLE_SKILL" && pass "apple references .xcarchive" || fail "apple .xcarchive missing"
 grep -q '@mmerterden/dev-toolkit-mcp' "$APPLE_SKILL" && pass "apple references @mmerterden/dev-toolkit-mcp package" || fail "apple dev-toolkit-mcp reference missing"
-grep -q 'mcp__dev_toolkit__ios_app_store_audit' "$APPLE_SKILL" && pass "apple shows MCP-call invocation form" || fail "apple MCP-call invocation form missing"
+grep -q 'mcp__dev-toolkit__ios_app_store_audit' "$APPLE_SKILL" && pass "apple shows MCP-call invocation form" || fail "apple MCP-call invocation form missing"
 
 echo "→ 4. google-play-compliance SKILL.md frontmatter + catalog shape"
 grep -q "^name: google-play-compliance$" "$GOOGLE_SKILL" && pass "google frontmatter name" || fail "google frontmatter name"

package/pipeline/scripts/smoke-cross-cli-behavior.sh

@@ -61,6 +61,16 @@ fi
 # ──────────────────────────────────────────────────────────────────────────
 echo ""
 echo "→ 2. No deprecated placeholders in Claude source"
+# Corpus guard: the scans below can only be trusted if there is something to
+# scan. Without this, an empty or missing command tree reports every pattern
+# clean instead of reporting that it found nothing to check.
+SKILL_COUNT=$(find "$CLAUDE_CMDS" -name SKILL.md 2>/dev/null | wc -l | tr -d ' ')
+if [ "$SKILL_COUNT" -gt 0 ]; then
+  pass "command corpus non-empty ($SKILL_COUNT SKILL.md)"
+else
+  fail "no SKILL.md under $CLAUDE_CMDS  -  placeholder and hardcode scans below are vacuous"
+fi
+
 # Per refs/cross-cli-contract.md Section 2.5
 DEPRECATED=(
   "{github-username}"
@@ -72,7 +82,7 @@ DEPRECATED=(
 )
 for p in "${DEPRECATED[@]}"; do
   # grep -l returns filenames; empty = no matches
-  FOUND=$(grep -l -F -- "$p" $(find "$CLAUDE_CMDS" -name SKILL.md 2>/dev/null) 2>/dev/null || true)
+  FOUND=$(find "$CLAUDE_CMDS" -name SKILL.md -exec grep -l -F -- "$p" {} + 2>/dev/null || true)
   if [ -z "$FOUND" ]; then
     pass "no '$p' in Claude commands"
   else
@@ -88,7 +98,7 @@ PERSONAL_HARDCODES=(
   "${USER}_tkgithub"
 )
 for p in "${PERSONAL_HARDCODES[@]}"; do
-  FOUND=$(grep -l -F -- "$p" $(find "$CLAUDE_CMDS" -name SKILL.md 2>/dev/null) 2>/dev/null || true)
+  FOUND=$(find "$CLAUDE_CMDS" -name SKILL.md -exec grep -l -F -- "$p" {} + 2>/dev/null || true)
   if [ -z "$FOUND" ]; then
     pass "no '$p' leaked into Claude commands"
   else

package/pipeline/scripts/smoke-generate-issue.sh

@@ -9,7 +9,7 @@
 #   5. Convention mining + createmeta + Agile sprint endpoints present.
 #   6. UTF-8 verbatim POST path (--rawfile + --data-binary) present.
 #   7. Standard template vocab: Task/Story (Scope/Acceptance/Test Scenarios), Bug (Steps/Expected/Actual/Environment), Swagger.
-#   8. Registration: dispatcher rows, inventory lists, count consistency (36).
+#   8. Registration: dispatcher rows, inventory lists, count derived from the command tree.
 #   9. Forbidden strings absent (em-dash, section sign, the M-word, unicode_escape).
 
 set -euo pipefail
@@ -21,6 +21,7 @@ REF="$ROOT/pipeline/multi-agent-refs/generate-issue.md"
 SKILL="$ROOT/pipeline/skills/shared/core/multi-agent-create-jira/SKILL.md"
 DISPATCHER="$ROOT/pipeline/commands/multi-agent/SKILL.md"
 CONTRACT="$ROOT/pipeline/multi-agent-refs/cross-cli-contract.md"
+CMD_COUNT=$(find "$ROOT/pipeline/commands/multi-agent" -mindepth 1 -maxdepth 1 -type d | wc -l | tr -d ' ')
 SYNC="$ROOT/pipeline/commands/multi-agent/sync/SKILL.md"
 HELP="$ROOT/pipeline/commands/multi-agent/help/SKILL.md"
 
@@ -88,14 +89,14 @@ grep -Fqi "auto-sizing" "$REF" && pass "auto-sizing rule present" || fail "auto-
 grep -Fqi "swagger" "$REF" && pass "swagger context present" || fail "swagger context missing"
 
 echo ""
-echo "→ 8. registration + count consistency (36)"
+echo "→ 8. registration + count consistency (derived)"
 grep -Fq '| `create-jira ' "$DISPATCHER" && pass "dispatcher routing: create-jira" || fail "dispatcher routing missing: generate"
 grep -Fq "create-jira/SKILL.md" "$DISPATCHER" && pass "dispatcher loading row" || fail "dispatcher loading row missing"
-grep -Fq "## 1. Command Inventory (41 commands)" "$CONTRACT" && pass "contract count = 41" || fail "contract count wrong"
+grep -Fq "## 1. Command Inventory ($CMD_COUNT commands)" "$CONTRACT" && pass "contract count = $CMD_COUNT (derived)" || fail "contract count wrong"
 grep -Eq '(^|[ ,])create-jira([ ,]|$)' "$CONTRACT" && pass "contract list has create-jira" || fail "contract list missing generate"
-grep -Fq "**41 commands are synced**" "$SYNC" && pass "sync count = 41" || fail "sync count wrong"
+grep -Fq "**$CMD_COUNT commands are synced**" "$SYNC" && pass "sync count = $CMD_COUNT (derived)" || fail "sync count wrong"
 SYNC_SKILL="$ROOT/pipeline/skills/shared/core/multi-agent-sync/SKILL.md"
-grep -Fq "**41 commands are synced**" "$SYNC_SKILL" && pass "sync SKILL count = 41" || fail "sync SKILL count wrong (Copilot parity)"
+grep -Fq "**$CMD_COUNT commands are synced**" "$SYNC_SKILL" && pass "sync SKILL count = $CMD_COUNT (derived)" || fail "sync SKILL count wrong (Copilot parity)"
 grep -Fq "create-jira" "$ROOT/pipeline/skills/shared/core/multi-agent-help/SKILL.md" && pass "help SKILL lists create-jira" || fail "help SKILL missing create-jira (Copilot parity)"
 grep -c "multi-agent:create-jira" "$HELP" | awk '{exit !($1>=2)}' && pass "help.md has EN + TR entries" || fail "help.md entries incomplete"
 # no stale split-command references anywhere in the synced surfaces

package/pipeline/scripts/smoke-per-repo-memory.sh

@@ -35,7 +35,7 @@ repo="$sandbox/repo"
 mkdir -p "$repo"
 
 # --- 1: pref off → silent exit 0 ---
-printf '{"global":{"perRepoMemory":false}}' > "$HOME/.claude/preferences.json"
+printf '{"global":{"perRepoMemory":false}}' > "$HOME/.claude/multi-agent-preferences.json"
 out=$(bash "$LOAD" "$repo" 2>&1 || true)
 if [ -z "$out" ]; then
   record_pass "load exits silent when pref off"
@@ -44,7 +44,7 @@ else
 fi
 
 # --- 2: pref on + no memory → silent exit 0 ---
-printf '{"global":{"perRepoMemory":true}}' > "$HOME/.claude/preferences.json"
+printf '{"global":{"perRepoMemory":true}}' > "$HOME/.claude/multi-agent-preferences.json"
 out=$(bash "$LOAD" "$repo" 2>&1 || true)
 if [ -z "$out" ]; then
   record_pass "load exits silent when pref on but no memory present"

package/pipeline/scripts/smoke-review-readiness.sh

@@ -21,6 +21,7 @@ SK_J="$ROOT/pipeline/skills/shared/core/multi-agent-review-jira/SKILL.md"
 SK_I="$ROOT/pipeline/skills/shared/core/multi-agent-review-issue/SKILL.md"
 DISPATCHER="$ROOT/pipeline/commands/multi-agent/SKILL.md"
 CONTRACT="$ROOT/pipeline/multi-agent-refs/cross-cli-contract.md"
+CMD_COUNT=$(find "$ROOT/pipeline/commands/multi-agent" -mindepth 1 -maxdepth 1 -type d | wc -l | tr -d ' ')
 HELP="$ROOT/pipeline/commands/multi-agent/help/SKILL.md"
 
 PASS=0; FAIL=0
@@ -61,12 +62,12 @@ grep -Fqi "confirm" "$REF" && pass "ref has confirm-before-post gate" || fail "r
 grep -Fqi "rubric" "$REF" && pass "ref has readiness rubric" || fail "ref missing rubric"
 
 echo ""
-echo "→ 5. registration + count (38)"
+echo "→ 5. registration + count (derived)"
 grep -Fq '| `review-jira ' "$DISPATCHER" && pass "dispatcher desc: review-jira" || fail "dispatcher desc missing review-jira"
 grep -Fq '| `review-issue ' "$DISPATCHER" && pass "dispatcher desc: review-issue" || fail "dispatcher desc missing review-issue"
 grep -Fq "review-jira/SKILL.md" "$DISPATCHER" && pass "dispatcher routing: review-jira" || fail "dispatcher routing missing review-jira"
 grep -Fq "review-issue/SKILL.md" "$DISPATCHER" && pass "dispatcher routing: review-issue" || fail "dispatcher routing missing review-issue"
-grep -Fq "## 1. Command Inventory (41 commands)" "$CONTRACT" && pass "contract count = 41" || fail "contract count wrong"
+grep -Fq "## 1. Command Inventory ($CMD_COUNT commands)" "$CONTRACT" && pass "contract count = $CMD_COUNT (derived)" || fail "contract count wrong"
 grep -Eq '(^|[ ,])review-jira([ ,]|$)' "$CONTRACT" && pass "contract inventory has review-jira" || fail "contract missing review-jira"
 grep -Eq '(^|[ ,])review-issue([ ,]|$)' "$CONTRACT" && pass "contract inventory has review-issue" || fail "contract missing review-issue"
 grep -Fq "multi-agent:review-jira" "$HELP" && pass "help lists review-jira" || fail "help missing review-jira"

package/pipeline/scripts/smoke-schema-validation.sh

@@ -87,17 +87,31 @@ done
 
 # ──────────────────────────────────────────────────────────────────────────
 echo ""
-echo "→ 4. prefs.schema.json  -  keychainMapping has 12 services"
+echo "→ 4. prefs.schema.json  -  keychainMapping covers every resolved service"
+# A floor, not a pin: new credentials get added over time, and pinning the count
+# made every addition a false failure. What matters is that the keys shipped
+# flows resolve are all declared.
 KM_COUNT=$(node -e "
   const s = JSON.parse(require('fs').readFileSync('$PREFS_SCHEMA', 'utf8'));
   const km = s.properties.global.properties.keychainMapping.properties;
   console.log(Object.keys(km).length);
 " 2>/dev/null)
-EXPECTED_SERVICES=13  # 12 + legacy "bitbucket" alias
-if [ "$KM_COUNT" = "$EXPECTED_SERVICES" ] || [ "$KM_COUNT" = "12" ]; then
-  pass "keychainMapping has $KM_COUNT services (≥12 expected)"
+if [ "${KM_COUNT:-0}" -ge 12 ] 2>/dev/null; then
+  pass "keychainMapping declares $KM_COUNT services (≥12 expected)"
 else
-  fail "keychainMapping has $KM_COUNT services, expected ≥12"
+  fail "keychainMapping declares ${KM_COUNT:-0} services, expected ≥12"
+fi
+
+MISSING_KEYS=$(node -e "
+  const s = JSON.parse(require('fs').readFileSync('$PREFS_SCHEMA', 'utf8'));
+  const km = Object.keys(s.properties.global.properties.keychainMapping.properties);
+  const required = ['jira','bitbucket_token','bitbucket_user','github','confluence','figma','figma_pat','figma_mcp','firebase','npm'];
+  console.log(required.filter((k) => !km.includes(k)).join(','));
+" 2>/dev/null)
+if [ -z "$MISSING_KEYS" ]; then
+  pass "every credential the pipeline resolves is declared"
+else
+  fail "keychainMapping missing declared-and-used key(s): $MISSING_KEYS"
 fi
 
 # ──────────────────────────────────────────────────────────────────────────