@mmerterden/multi-agent-pipeline 14.2.1 → 15.0.0

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

@@ -24,23 +24,32 @@ while [ $# -gt 0 ]; do
   esac
 done
 
-ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
-COST_TABLE="$ROOT/pipeline/scripts/cost-table.json"
-COST_LIB="$ROOT/pipeline/scripts/cost-lib.sh"
+# cost-table.json/cost-lib.sh ship as siblings of this script both in the
+# repo (pipeline/scripts/) and once installed (~/.claude/scripts/) - a
+# repo-root-relative path (../../pipeline/scripts/...) only resolves in the
+# repo checkout and silently misses in the installed layout. Match
+# phase-tracker.sh's own resolution instead of re-deriving a repo root.
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+COST_TABLE="$SCRIPT_DIR/cost-table.json"
+COST_LIB="$SCRIPT_DIR/cost-lib.sh"
 if [ -f "$COST_LIB" ]; then . "$COST_LIB"; else COST_JQ_DEFS=""; fi
 
 command -v jq >/dev/null 2>&1 || { echo "render-cost-summary: jq required" >&2; exit 2; }
 
-# Tracker JSON location convention: .worktrees/<TASK>/phase-tracker.json
-# Accept both the full key (e.g. "{JIRA_KEY}-1234") and the numeric-only
-# variant  -  the Jira-prefix is project-specific, so strip anything before
-# the first dash when trying the fallback.
+# Tracker JSON candidates, worktree convention first, then the location
+# phase-tracker.sh actually writes ($HOME/.claude/logs/multi-agent/<task>/
+# tracker-state.json). The list must stay in lockstep with
+# render-agent-log-cost.sh - before the logs/ candidates were added here,
+# every standard run exited 2 and the channels Cost Summary silently never
+# rendered, because only the worktree paths were tried.
 tracker_file=""
 task_id_bare="${TASK_ID##*-}"
 for candidate in \
   "$PWD/.worktrees/$TASK_ID/phase-tracker.json" \
   "$PWD/.worktrees/$task_id_bare/phase-tracker.json" \
-  "$PWD/.worktrees/task-$task_id_bare/phase-tracker.json"
+  "$PWD/.worktrees/task-$task_id_bare/phase-tracker.json" \
+  "$HOME/.claude/logs/multi-agent/$TASK_ID/tracker-state.json" \
+  "$HOME/.claude/logs/multi-agent/$task_id_bare/tracker-state.json"
 do
   [ -f "$candidate" ] && { tracker_file="$candidate"; break; }
 done
@@ -52,17 +61,27 @@ fi
 # Build rows  -  prefer tracker JSON, fall back to spans aggregation
 rows_json="[]"
 if [ -n "$tracker_file" ]; then
-  rows_json=$(jq '[
-    (.phases // {} | to_entries[]) |
-    select(.value.tokens_in // 0 > 0 or .value.tokens_out // 0 > 0) |
-    {
-      phase: .key,
-      phase_name: (.value.name // .key),
-      model: (.value.model // "opus"),
-      tokens_in: (.value.tokens_in // 0),
-      tokens_out: (.value.tokens_out // 0)
-    }
-  ]' "$tracker_file")
+  # Tracker JSON ships in two shapes (same contract as render-agent-log-cost.sh):
+  #   array shape   -  phase-tracker.sh writes phases:[{id, name, model, tokens_in, ...}]
+  #   object shape  -  older fixture / hand-built variant phases:{ "1": {...}, ... }
+  rows_json=$(jq '
+    (if (.phases | type) == "array" then
+      [.phases[] | {key: (.id | tostring), value: .}]
+    else
+      (.phases // {} | to_entries)
+    end)
+    | [ .[] |
+        select(.value.tokens_in // 0 > 0 or .value.tokens_out // 0 > 0) |
+        {
+          phase: .key,
+          phase_name: (.value.name // .key),
+          model: (.value.model // " - "),
+          tokens_in: (.value.tokens_in // 0),
+          tokens_out: (.value.tokens_out // 0),
+          tokens_cached: (.value.tokens_cached // 0)
+        }
+      ]
+    | sort_by(.phase | tonumber? // 999)' "$tracker_file")
 fi
 
 if [ "$rows_json" = "[]" ] && [ -n "$SPANS_FILE" ] && [ -f "$SPANS_FILE" ]; then
@@ -72,9 +91,10 @@ if [ "$rows_json" = "[]" ] && [ -n "$SPANS_FILE" ] && [ -f "$SPANS_FILE" ]; then
     map({
       phase: (.[0].attributes.phase_id // .[0].attributes.phase // "?"),
       phase_name: (.[0].attributes.phase_name // (.[0].attributes.phase_id // "?")),
-      model: (.[0].attributes.model // "opus"),
+      model: (.[0].attributes.model // " - "),
       tokens_in: ([.[].attributes.tokens_in_delta // 0] | add),
-      tokens_out: ([.[].attributes.tokens_out_delta // 0] | add)
+      tokens_out: ([.[].attributes.tokens_out_delta // 0] | add),
+      tokens_cached: ([.[].attributes.tokens_cached_delta // 0] | add)
     })
   ' "$SPANS_FILE")
 fi
@@ -85,7 +105,7 @@ joined=$(jq -n --argjson rows "$rows_json" --slurpfile prices "$COST_TABLE" "$CO
     . as $r |
     ($prices[0].prices[$r.model] // null) as $p |
     . + {
-      usd: cost_usd_of($p; $r.tokens_in; $r.tokens_out; 0)
+      usd: cost_usd_of($p; $r.tokens_in; $r.tokens_out; ($r.tokens_cached // 0))
     }
   )
 ')

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

@@ -69,9 +69,11 @@ fi
 
 STATE_FILE=""
 TRACKER_FILE=""
+TRIAGE_FILE=""
 if [ -n "$WORKTREE" ]; then
-  [ -f "$WORKTREE/agent-state.json" ]   && STATE_FILE="$WORKTREE/agent-state.json"
-  [ -f "$WORKTREE/phase-tracker.json" ] && TRACKER_FILE="$WORKTREE/phase-tracker.json"
+  [ -f "$WORKTREE/agent-state.json" ]    && STATE_FILE="$WORKTREE/agent-state.json"
+  [ -f "$WORKTREE/phase-tracker.json" ]  && TRACKER_FILE="$WORKTREE/phase-tracker.json"
+  [ -f "$WORKTREE/triage-output.json" ]  && TRIAGE_FILE="$WORKTREE/triage-output.json"
 fi
 
 # Fall back to the salvaged artefacts when the worktree is gone. Phase 6 removes it
@@ -88,8 +90,22 @@ if [ -z "$STATE_FILE" ] || [ -z "$TRACKER_FILE" ]; then
     "$HOME"/.claude/logs/multi-agent/*/"$task_bare"/artifacts
   do
     [ -d "$base" ] || continue
-    [ -z "$STATE_FILE" ]   && [ -f "$base/agent-state.json" ]   && STATE_FILE="$base/agent-state.json"
-    [ -z "$TRACKER_FILE" ] && [ -f "$base/phase-tracker.json" ] && TRACKER_FILE="$base/phase-tracker.json"
+    [ -z "$STATE_FILE" ]   && [ -f "$base/agent-state.json" ]    && STATE_FILE="$base/agent-state.json"
+    [ -z "$TRACKER_FILE" ] && [ -f "$base/phase-tracker.json" ]  && TRACKER_FILE="$base/phase-tracker.json"
+    [ -z "$TRIAGE_FILE" ]  && [ -f "$base/triage-output.json" ]  && TRIAGE_FILE="$base/triage-output.json"
+  done
+fi
+
+# Last resort for the tracker: the file phase-tracker.sh actually writes on
+# every run. The worktree/artifacts copies above exist only when something
+# mirrored them there; the logs/ state file always exists for a tracked task.
+if [ -z "$TRACKER_FILE" ]; then
+  task_bare="${TASK_ID##*-}"
+  for f in \
+    "$HOME/.claude/logs/multi-agent/$TASK_ID/tracker-state.json" \
+    "$HOME/.claude/logs/multi-agent/$task_bare/tracker-state.json"
+  do
+    [ -f "$f" ] && { TRACKER_FILE="$f"; break; }
   done
 fi
 
@@ -126,9 +142,15 @@ if [ -n "$STATE_FILE" ]; then
   state_jira=$(jq -r '.taskId // ""' "$STATE_FILE")
   state_branch=$(jq -r '.branch // (.projects // [] | .[0].branch // "")' "$STATE_FILE")
   state_base=$(jq -r '.baseBranch // (.projects // [] | .[0].baseBranch // "")' "$STATE_FILE")
-  state_pr=$(jq -r '.prNumber // .prUrl // ""' "$STATE_FILE")
-  state_tasks=$(jq -c '(.planTodos // []) + (.phases["2"].tasks // [])' "$STATE_FILE" 2>/dev/null || echo "[]")
-  state_triage=$(jq -c '.reviewConsensus // .phases["4"].triage // {}' "$STATE_FILE" 2>/dev/null || echo "{}")
+  # agent-state.schema.json has no .prNumber/.prUrl/.planTodos/.reviewConsensus/
+  # .phases["2"].tasks/.phases["4"].triage - PR data lives at .pr.{number,url},
+  # the plan at .plan.todos[], and review triage in the separate
+  # triage-output.json (read via TRIAGE_FILE below, not out of agent-state).
+  state_pr=$(jq -r '.pr.number // .pr.url // ""' "$STATE_FILE")
+  state_tasks=$(jq -c '.plan.todos // []' "$STATE_FILE" 2>/dev/null || echo "[]")
+fi
+if [ -n "$TRIAGE_FILE" ]; then
+  state_triage=$(jq -c '.' "$TRIAGE_FILE" 2>/dev/null || echo "{}")
 fi
 
 # Flag overrides
@@ -141,13 +163,19 @@ fi
 phase_ticks=""
 if [ -n "$TRACKER_FILE" ]; then
   phase_ticks=$(jq -r '
-    . as $root |
+    # Normalize both tracker shapes: phase-tracker.sh writes phases as an
+    # array of {id,...}; older fixtures keyed an object by phase id. The
+    # string-index below errors on an array and 2>/dev/null would swallow
+    # it, silently dropping the whole tick strip.
+    (if (.phases | type) == "array"
+     then (.phases | map({key: (.id | tostring), value: .}) | from_entries)
+     else (.phases // {}) end) as $ph |
     ["0 Init","1 Analysis","2 Planning","3 Dev","4 Review","5 Test","6 Commit","7 Report"] as $labels |
     [range(0;8) | tostring] as $ids |
     $ids
     | map(. as $i |
         ($labels[$i | tonumber]) as $label |
-        (($root.phases // {})[$i] // {}) as $p |
+        ($ph[$i] // {}) as $p |
         (if   $p.status == "completed"   then "✅"
          elif $p.status == "in_progress" then "▶"
          elif $p.status == "failed"      then "❌"
@@ -195,16 +223,19 @@ if [ -n "$DIFF_IN" ]; then
   fi
 fi
 
-# Task list with ✅ / ⏳ marks  -  derived from triage if available
+# Task list with ✅ / ⏳ marks. plan-todos.schema.json's todo items carry
+# `.task` (not `.title`/`.subject`) and a status enum of
+# pending|in_progress|completed|skipped|failed (not "done"/"deferred") -
+# the old check here never matched real data, so every todo rendered ⏳.
 tasks_block=""
 if [ "$(jq 'length' <<< "$state_tasks")" != "0" ]; then
   tasks_block=$(jq -r '
     .[] |
     "- " +
-    (if (.status // "done") == "done" then "✅ " else "⏳ " end) +
+    (if (.status // "pending") == "completed" then "✅ " else "⏳ " end) +
     (.id // "") +
     (if (.id // "") != "" then " " else "" end) +
-    (.title // .subject // "(untitled)")
+    (.task // "(untitled)")
   ' <<< "$state_tasks")
 fi
 
@@ -221,7 +252,10 @@ header="**Task**: \`$state_jira\`"
 [ -n "$state_branch" ] && header="$header  |  **Branch**: \`$state_branch\`"
 [ -n "$state_base" ]   && header="$header  |  **Base**: \`$state_base\`"
 if [ -n "$state_pr" ] && [ "$state_pr" != "null" ]; then
-  header="$header  |  **PR**: $state_pr"
+  case "$state_pr" in
+    *[!0-9]*) header="$header  |  **PR**: $state_pr" ;;
+    *)        header="$header  |  **PR**: #$state_pr" ;;
+  esac
 fi
 printf '%s\n\n' "$header"
 

package/pipeline/scripts/review-scope.mjs

@@ -81,7 +81,7 @@ function main() {
   const blockers = [];
   for (const f of files) {
     for (const s of f.signals || []) {
-      if (HIGH_STAKES.has(s.name)) blockers.push({ file: f.file, signal: s.name });
+      if (HIGH_STAKES.has(s.name)) blockers.push({ file: f.path, signal: s.name });
     }
   }
 

package/pipeline/scripts/run-aggregator.mjs

@@ -82,14 +82,29 @@ function die(msg) {
   process.exit(1);
 }
 
-function resolveTaskDir() {
-  if (flags["task-dir"]) return flags["task-dir"];
-  if (flags["task-id"] && flags.project) {
+// phase-tracker.sh writes tracker-state.json (never phase-tracker.json) at
+// $HOME/.claude/logs/multi-agent/<task-id>/ (no <project> segment) - the
+// same drift render-cost-summary.sh/render-agent-log-cost.sh already guard
+// against with a candidate list. Mirror that list here instead of assuming
+// one fixed filename/path.
+function resolveTrackerCandidates() {
+  const candidates = [];
+  if (flags["task-dir"]) {
+    candidates.push(join(flags["task-dir"], "tracker-state.json"));
+  }
+  if (flags["task-id"]) {
     const HOME = process.env.HOME || process.env.USERPROFILE;
     if (!HOME) die("neither HOME nor USERPROFILE is set  -  pass --task-dir");
-    return join(HOME, ".claude", "logs", "multi-agent", flags.project, String(flags["task-id"]));
+    const taskId = String(flags["task-id"]);
+    if (flags.project) {
+      candidates.push(
+        join(HOME, ".claude", "logs", "multi-agent", flags.project, taskId, "tracker-state.json"),
+      );
+    }
+    candidates.push(join(HOME, ".claude", "logs", "multi-agent", taskId, "tracker-state.json"));
   }
-  die("either --task-dir or --task-id with --project is required");
+  if (!candidates.length) die("either --task-dir or --task-id is required");
+  return candidates;
 }
 
 function loadJson(path) {
@@ -161,11 +176,14 @@ function tsCompare(a, b) {
 }
 
 // ─────────────────────────────────────────────────────────────────────────
-const taskDir = resolveTaskDir();
-if (!existsSync(taskDir)) die(`task dir not found: ${taskDir}`);
-
-const tracker = loadJson(join(taskDir, "phase-tracker.json"));
-if (!tracker) die(`phase-tracker.json not found in ${taskDir}`);
+const trackerCandidates = resolveTrackerCandidates();
+const trackerPath = trackerCandidates.find((p) => existsSync(p));
+if (!trackerPath) {
+  die(`tracker state not found, tried:\n${trackerCandidates.map((p) => `  ${p}`).join("\n")}`);
+}
+const taskDir = dirname(trackerPath);
+const tracker = loadJson(trackerPath);
+if (!tracker) die(`failed to parse tracker state at ${trackerPath}`);
 
 const otelSpans = loadJsonl(join(taskDir, "otel-spans.jsonl"));
 const costTable = loadCostTable();
@@ -187,7 +205,18 @@ let totalOut = 0;
 let totalCost = 0;
 let unknownModelHits = 0;
 
-for (const phase of tracker.phases || []) {
+// tracker.phases ships in two shapes (same contract render-cost-summary.sh
+// normalizes): an array (phase-tracker.sh's real output) or an object keyed
+// by phase id (older fixtures / hand-built variants). Normalize once so the
+// rest of this file can treat it as a plain array.
+const phaseList = Array.isArray(tracker.phases)
+  ? tracker.phases
+  : Object.entries(tracker.phases || {}).map(([key, value]) => ({
+      ...value,
+      id: value?.id ?? key,
+    }));
+
+for (const phase of phaseList) {
   const tIn = phase.tokens_in || 0;
   const tOut = phase.tokens_out || 0;
   const model = phase.model || inferModelForPhase(phase.id);
@@ -279,9 +308,9 @@ const summary = {
   kind: "summary",
   ts: lastTs,
   task_id: taskId,
-  phases_total: tracker.phases?.length ?? 0,
-  phases_completed: (tracker.phases || []).filter((p) => p.status === "completed").length,
-  phases_failed: (tracker.phases || []).filter((p) => p.status === "failed").length,
+  phases_total: phaseList.length,
+  phases_completed: phaseList.filter((p) => p.status === "completed").length,
+  phases_failed: phaseList.filter((p) => p.status === "failed").length,
   tokens_in: totalIn,
   tokens_out: totalOut,
   total_cost_usd: Number(totalCost.toFixed(6)),

package/pipeline/scripts/scan-agent-config.sh

@@ -31,7 +31,7 @@ add "$ROOT/install/templates/claude-hooks.json"
 add "$ROOT/install/templates/copilot-instructions.md"
 add "$ROOT/pipeline/preferences-template.json"
 for f in "$ROOT"/pipeline/agents/*.md; do add "$f"; done
-# (figma component skills + their scripts now live in the ai-*-engineering-toolkit
+# (figma component skills + their scripts now live in the ai-*-toolkit
 #  marketplace plugin, not in this repo, so there is nothing figma to scan here.)
 add "$ROOT/pipeline/scripts/agent-guard.sh"
 add "$ROOT/pipeline/scripts/pre-commit-check.sh"

package/pipeline/scripts/skill-conformance.mjs

@@ -43,6 +43,7 @@
 import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from "node:fs";
 import { dirname, join, resolve, relative, basename, extname, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 
 const here = dirname(fileURLToPath(import.meta.url));
 
@@ -64,10 +65,74 @@ function skillsRootCandidates() {
   return [
     join(installRoot, "skills"), // ~/.claude/skills, ~/.copilot/skills
     join(installRoot, "multi-agent-refs", "skills"), // ~/.codex/multi-agent-refs/skills
+    ...pluginSkillRoots(), // marketplace stack plugins (Claude Code's only stack-skill source)
     join(repoRoot, "pipeline", "skills"), // checkout
   ];
 }
 
+// ---------------------------------------------------------------------------
+// Marketplace plugin roots.
+//
+// On Claude Code the stack skills no longer land in ~/.claude/skills - they are
+// loaded from the multi-agent-plugins marketplace. The registries this gate
+// depends on (`ios-coding-standard`, `ios-module-structure`) live in the iOS
+// plugin's knowledge/ tree, so without these roots the registry set silently
+// collapses to the two local compliance catalogs and Phase 4 reads green over
+// criteria that were never loaded. Local checkout is preferred over the plugin
+// cache for the same reason install/_plugin-skills.mjs prefers it: the checkout
+// is what /multi-agent:sync rebuilds, the cache only advances on marketplace
+// refresh. Cache dirs are version-named; newest wins.
+// ---------------------------------------------------------------------------
+const PLUGIN_MARKETPLACE = "multi-agent-plugins";
+const STACK_PLUGIN_NAMES = [
+  "ai-ios-toolkit",
+  "ai-android-toolkit",
+  "ai-frontend-toolkit",
+  "ai-backend-toolkit",
+  "ai-common-toolkit",
+];
+
+function semverCompare(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d !== 0) return d;
+  }
+  return a.localeCompare(b);
+}
+
+function pluginSkillRoots() {
+  const home = homedir();
+  const roots = [];
+  for (const name of STACK_PLUGIN_NAMES) {
+    const checkout = join(home, PLUGIN_MARKETPLACE, "plugins", name, "skills");
+    if (existsSync(checkout)) {
+      roots.push(checkout);
+      continue;
+    }
+    const cacheRoot = join(home, ".claude", "plugins", "cache", PLUGIN_MARKETPLACE, name);
+    if (!existsSync(cacheRoot)) continue;
+    const versions = readdirSafe(cacheRoot)
+      .filter((v) => {
+        try {
+          return statSync(join(cacheRoot, v)).isDirectory();
+        } catch {
+          return false;
+        }
+      })
+      .sort(semverCompare);
+    for (const v of versions.reverse()) {
+      const p = join(cacheRoot, v, "skills");
+      if (existsSync(p)) {
+        roots.push(p);
+        break;
+      }
+    }
+  }
+  return roots;
+}
+
 /**
  * Resolve the roots to search, and report every candidate that was PROBED  -  not
  * only the ones that existed.
@@ -496,28 +561,64 @@ function auditExceptions(addedByFile, knownIds, today, markerToken) {
       const reason = rest.replace(/(\d{4}-\d{2}-\d{2})/, "").trim();
 
       if (!id) {
-        findings.push(f(file, line, "blocking", null, "Exception marker names no rule ID.",
-          "Name the rule the exception applies to: standard:exception(<RULE-ID>) <reason> <expiry>."));
+        findings.push(
+          f(
+            file,
+            line,
+            "blocking",
+            null,
+            "Exception marker names no rule ID.",
+            "Name the rule the exception applies to: standard:exception(<RULE-ID>) <reason> <expiry>.",
+          ),
+        );
         continue;
       }
       if (knownIds.size > 0 && !knownIds.has(id)) {
-        findings.push(f(file, line, "blocking", id,
-          `Exception cites '${id}', which is not in any registry in scope for this diff.`,
-          "Use a real rule ID, or drop the marker. An exception against an unknown rule suppresses nothing and hides intent."));
+        findings.push(
+          f(
+            file,
+            line,
+            "blocking",
+            id,
+            `Exception cites '${id}', which is not in any registry in scope for this diff.`,
+            "Use a real rule ID, or drop the marker. An exception against an unknown rule suppresses nothing and hides intent.",
+          ),
+        );
       }
       if (!dateMatch) {
-        findings.push(f(file, line, "important", id,
-          `Exception for '${id}' has no expiry date.`,
-          "Add an expiry: standard:exception(<RULE-ID>) <reason> YYYY-MM-DD. An exception with no expiry is a permanent silent carve-out."));
+        findings.push(
+          f(
+            file,
+            line,
+            "important",
+            id,
+            `Exception for '${id}' has no expiry date.`,
+            "Add an expiry: standard:exception(<RULE-ID>) <reason> YYYY-MM-DD. An exception with no expiry is a permanent silent carve-out.",
+          ),
+        );
       } else if (dateMatch[1] < today) {
-        findings.push(f(file, line, "blocking", id,
-          `Exception for '${id}' expired on ${dateMatch[1]}.`,
-          "Fix the underlying violation, or renew the exception with a new expiry and a current reason."));
+        findings.push(
+          f(
+            file,
+            line,
+            "blocking",
+            id,
+            `Exception for '${id}' expired on ${dateMatch[1]}.`,
+            "Fix the underlying violation, or renew the exception with a new expiry and a current reason.",
+          ),
+        );
       }
       if (!reason) {
-        findings.push(f(file, line, "important", id,
-          `Exception for '${id}' gives no reason.`,
-          "State why the rule does not apply here. An unexplained exception cannot be reviewed, only trusted."));
+        findings.push(
+          f(
+            file,
+            line,
+            "important",
+            id,
+            `Exception for '${id}' gives no reason.`,
+            "State why the rule does not apply here. An unexplained exception cannot be reviewed, only trusted.",
+          ),
+        );
       }
     }
   }
@@ -614,7 +715,8 @@ function parseArgs(argv) {
     else if (a === "--repo") o.repo = argv[++i];
     else if (a === "--out") o.out = argv[++i];
     else if (a === "--skills-root") o.skillsRoot = argv[++i];
-    else if (a === "--today") o.today = argv[++i]; // tests pin the clock
+    else if (a === "--today")
+      o.today = argv[++i]; // tests pin the clock
     else {
       console.error(`unknown argument: ${a}`);
       process.exit(1);
@@ -692,7 +794,11 @@ const unparseable = [...escapedDeclarations];
 
 for (const d of discovered) {
   if (!existsSync(d.rulesPath)) {
-    unparseable.push({ name: d.name, path: d.rulesPath, reason: "declared standards-registry file does not exist" });
+    unparseable.push({
+      name: d.name,
+      path: d.rulesPath,
+      reason: "declared standards-registry file does not exist",
+    });
     continue;
   }
   let loaded;
@@ -703,7 +809,11 @@ for (const d of discovered) {
     continue;
   }
   if (loaded.rules.length === 0) {
-    unparseable.push({ name: d.name, path: d.rulesPath, reason: "no rules extracted  -  rules: block missing or unexpected indentation" });
+    unparseable.push({
+      name: d.name,
+      path: d.rulesPath,
+      reason: "no rules extracted  -  rules: block missing or unexpected indentation",
+    });
     continue;
   }
   registries.push({ ...d, ...loaded });
@@ -716,9 +826,10 @@ const perRegistry = [];
 for (const reg of registries) {
   const scope = reg.meta.scope;
   const regLanguages = scope?.languages ?? [];
-  const langHit = regLanguages.length === 0
-    ? Object.keys(languages)
-    : regLanguages.filter((l) => Object.prototype.hasOwnProperty.call(languages, l));
+  const langHit =
+    regLanguages.length === 0
+      ? Object.keys(languages)
+      : regLanguages.filter((l) => Object.prototype.hasOwnProperty.call(languages, l));
 
   // Files this registry may speak about at all.
   const inScopeFiles = changedFiles.filter((file) => {
@@ -747,7 +858,9 @@ for (const reg of registries) {
         ? inScopeFiles.filter((f2) => matchesAnyGlob(f2, rule.scope.paths))
         : inScopeFiles;
       if (files.length === 0) {
-        const why = rule.scopeReason ? `out-of-scope: ${rule.scopeReason}` : "out-of-scope: no changed file matches the rule's paths";
+        const why = rule.scopeReason
+          ? `out-of-scope: ${rule.scopeReason}`
+          : "out-of-scope: no changed file matches the rule's paths";
         droppedReasons[why] = (droppedReasons[why] ?? 0) + 1;
         continue;
       }
@@ -776,9 +889,16 @@ for (const reg of registries) {
     languagesMatched: langHit,
     inScopeFileCount: inScopeFiles.length,
     notCovered: reg.meta.notCovered,
-    loadedAs: unscoped ? "reference-only" : inScopeFiles.length ? "rule-checklist" : "not-applicable",
+    loadedAs: unscoped
+      ? "reference-only"
+      : inScopeFiles.length
+        ? "rule-checklist"
+        : "not-applicable",
     ...(unscoped
-      ? { referenceOnlyReason: "registry declares no scope; applying its rules to unknown languages would manufacture findings" }
+      ? {
+          referenceOnlyReason:
+            "registry declares no scope; applying its rules to unknown languages would manufacture findings",
+        }
       : {}),
     toolchains: detectToolchains(repoRoot, reg.rules),
     exceptionMarker: reg.meta.exceptionMarker,
@@ -794,7 +914,9 @@ for (const [lang, files] of Object.entries(languages)) {
   const covered = files.filter((f2) => coveredFiles.has(f2));
   if (covered.length === 0) {
     const claims = perRegistry
-      .flatMap((r) => Object.entries(r.notCovered ?? {}).map(([k, v]) => ({ registry: r.name, key: k, note: v })))
+      .flatMap((r) =>
+        Object.entries(r.notCovered ?? {}).map(([k, v]) => ({ registry: r.name, key: k, note: v })),
+      )
       .filter((c) => c.key === lang || lang.startsWith(c.key));
     gaps.push({
       language: lang,
@@ -803,7 +925,8 @@ for (const [lang, files] of Object.entries(languages)) {
       reason: claims.length
         ? `no registry in scope covers ${lang}: ${claims.map((c) => `${c.registry} declares '${c.key}' not covered`).join("; ")}`
         : `no registry in scope declares ${lang}`,
-      consequence: "these files are reviewed on general criteria only  -  no rule IDs apply to them",
+      consequence:
+        "these files are reviewed on general criteria only  -  no rule IDs apply to them",
     });
   }
 }
@@ -815,7 +938,7 @@ const { guides, dropped: guidesDropped } = collectModuleGuides(repoRoot, changed
 // knownIds spans EVERY discovered registry, not just the in-scope ones. Narrowing
 // it to the selected set would report a valid rule as unknown whenever the
 // exception sits in a file that rule does not cover, which is a false accusation
-// in the one place the author is trying to be explicit. The narrower question  - 
+// in the one place the author is trying to be explicit. The narrower question  -
 // "is this exception citing a rule that applies here?"  -  is answered separately
 // below, so a mis-scoped exception is still reported, just not as a typo.
 const knownIds = new Set(registries.flatMap((r) => r.rules.map((x) => x.id)));
@@ -872,7 +995,9 @@ for (const reg of perRegistry) {
 const resolvedNames = new Set(perRegistry.map((r) => r.name));
 const declaredNames = ledger.entries.map((e) => e?.skill).filter(Boolean);
 const declaredNotResolved = [...new Set(declaredNames)].filter((n) => !resolvedNames.has(n));
-const ledgerMissingTargets = ledger.entries.filter((e) => !Array.isArray(e?.targetFiles) || e.targetFiles.length === 0).length;
+const ledgerMissingTargets = ledger.entries.filter(
+  (e) => !Array.isArray(e?.targetFiles) || e.targetFiles.length === 0,
+).length;
 
 // Entries a stack toolkit's own index chose (Phase 3 step 9 stamps `routedBy`).
 // Surfaced separately because "the project's toolkit says this skill governs this
@@ -940,10 +1065,20 @@ if (opts.json) {
   process.stdout.write(JSON.stringify(manifest, null, 2) + "\n");
 } else {
   console.log(`criteria-manifest: ${outPath}`);
-  console.log(`  languages:      ${Object.entries(manifest.languages).map(([k, v]) => `${k}:${v}`).join(" ") || "(none)"}`);
-  console.log(`  registries:     ${perRegistry.length} discovered, ${perRegistry.filter((r) => r.loadedAs === "rule-checklist").length} as rule-checklist`);
+  console.log(
+    `  languages:      ${
+      Object.entries(manifest.languages)
+        .map(([k, v]) => `${k}:${v}`)
+        .join(" ") || "(none)"
+    }`,
+  );
+  console.log(
+    `  registries:     ${perRegistry.length} discovered, ${perRegistry.filter((r) => r.loadedAs === "rule-checklist").length} as rule-checklist`,
+  );
   console.log(`  selected rules: ${selected.length}`);
-  console.log(`  coverage:       ${coveredFiles.size}/${changedFiles.length} changed files carry rule criteria`);
+  console.log(
+    `  coverage:       ${coveredFiles.size}/${changedFiles.length} changed files carry rule criteria`,
+  );
   for (const g of gaps) console.log(`  GAP  ${g.language} (${g.fileCount} file(s)): ${g.reason}`);
   console.log(`  ledger:         ${manifest.ledger.source} (self-report: ${ledger.status})`);
   console.log(`  findings:       ${findings.length}`);

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

@@ -152,7 +152,7 @@ fi
 # ──────────────────────────────────────────────────────────────────────────
 echo ""
 # Figma/component skill trees no longer ship in the pipeline (v11.2.0+): they
-# live in the marketplace component plugins (ai-ios-engineering-toolkit /
+# live in the marketplace component plugins (ai-ios-toolkit /
 # multi-agent-plugins), which each CLI loads through its own plugin channel.
 # The pipeline therefore has no figma tree to deploy or parity-check here.
 echo "→ 7. Agent personas deployed to both CLIs"

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

@@ -91,10 +91,14 @@ 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.
+# process.stdout.write of a String, not console.log of a Number: console.log
+# inspects non-string arguments, so with FORCE_COLOR set in the environment the
+# count comes back wrapped in ANSI codes and the -ge comparison below silently
+# fails on a value that is actually in range.
 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);
+  process.stdout.write(String(Object.keys(km).length));
 " 2>/dev/null)
 if [ "${KM_COUNT:-0}" -ge 12 ] 2>/dev/null; then
   pass "keychainMapping declares $KM_COUNT services (≥12 expected)"