@mmerterden/multi-agent-pipeline 16.11.0 → 16.13.0

package/pipeline/scripts/graph-build.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+/**
+ * @file graph-build.mjs  -  build the code graph for one repo.
+ *
+ * Full rebuild every time, by measurement rather than by principle: on the
+ * corporate iOS app (4,311 Swift sources, 14.3 MB) the whole pass takes under
+ * three seconds, so an incremental extraction path would add a cache file, a
+ * staleness bug surface and a second code path to test in exchange for nothing.
+ * The manifest is still written - Phase 1 uses it to report how far behind a
+ * graph is, not to rebuild a subset.
+ *
+ * Inputs:
+ *   --root <path>    Repo root. Default: cwd
+ *   --stack <id>     ios | android | node | python. Required.
+ *   --out <path>     Graph output. Default: ~/.claude/knowledge/<project>/code-graph.json
+ *   --max-nodes N    Refuse to write a graph larger than this. Default: 200000.
+ *                    Callers pass prefs.global.codeGraph.maxNodes. A tree that
+ *                    blows past it is vendored or generated source, and writing
+ *                    a several-hundred-megabyte file for it helps nobody, so
+ *                    the build fails loudly instead of succeeding quietly.
+ *   --json           Emit the summary as JSON instead of a line
+ *
+ * Output:
+ *   Writes the graph, prints a one-line summary.
+ *
+ * Exit codes:
+ *   0  -  built
+ *   1  -  rule load, walk, write error, or graph past --max-nodes
+ *   64 -  usage error
+ *
+ * @module pipeline/scripts/graph-build
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join, dirname, resolve, basename } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import {
+  loadRules,
+  listSourceFiles,
+  extractFile,
+  buildGraph,
+  diffManifest,
+} from "./_code-graph.mjs";
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_MAX_NODES = 200000;
+
+export function parseFlags(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const k = a.slice(2);
+      const v = argv[i + 1];
+      if (v !== undefined && !v.startsWith("--")) {
+        flags[k] = v;
+        i++;
+      } else {
+        flags[k] = true;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { flags, positional };
+}
+
+export function defaultGraphPath(root) {
+  return join(homedir(), ".claude", "knowledge", basename(root), "code-graph.json");
+}
+
+function headCommit(root) {
+  try {
+    return execFileSync("git", ["-C", root, "rev-parse", "HEAD"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  const { flags } = parseFlags(process.argv.slice(2));
+  const stack = flags.stack;
+  if (!stack || stack === true) {
+    process.stderr.write("graph-build: --stack <ios|android|node|python> required\n");
+    process.exit(64);
+  }
+
+  const root = resolve(flags.root || process.cwd());
+  if (!existsSync(root)) {
+    process.stderr.write(`graph-build: root not found: ${root}\n`);
+    process.exit(1);
+  }
+  const out = flags.out && flags.out !== true ? resolve(flags.out) : defaultGraphPath(root);
+
+  let rules;
+  try {
+    rules = loadRules(stack, SCRIPT_DIR);
+  } catch (e) {
+    process.stderr.write(`graph-build: ${e.message}\n`);
+    process.exit(1);
+  }
+
+  const startedAt = Date.now();
+  const files = listSourceFiles(root, rules);
+  const extracted = new Map();
+  for (const path of files) {
+    try {
+      extracted.set(path, extractFile(readFileSync(join(root, path), "utf8"), rules));
+    } catch {
+      /* unreadable file: skip, it simply does not reach the graph */
+    }
+  }
+
+  const { manifest } = diffManifest(root, [...extracted.keys()], {});
+  const graph = buildGraph({
+    root,
+    stack,
+    extracted,
+    rules,
+    manifest,
+    baseCommit: headCommit(root),
+    generatedAt: new Date().toISOString(),
+  });
+
+  const maxNodes = Number(flags["max-nodes"]) > 0 ? Number(flags["max-nodes"]) : DEFAULT_MAX_NODES;
+  if (graph.stats.nodes > maxNodes) {
+    process.stderr.write(
+      `graph-build: ${graph.stats.nodes} nodes exceeds --max-nodes ${maxNodes}; ` +
+        `nothing written. Narrow the tree with the stack rules' excludePathGlobs, ` +
+        `or raise prefs.global.codeGraph.maxNodes if this repo really is that large.\n`,
+    );
+    process.exit(1);
+  }
+
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, JSON.stringify(graph), "utf8");
+
+  const elapsedMs = Date.now() - startedAt;
+  const summary = { out, elapsedMs, ...graph.stats };
+  if (flags.json === true) {
+    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+  } else {
+    process.stdout.write(
+      `graph-build: ${graph.stats.files} files, ${graph.stats.nodes} nodes, ` +
+        `${graph.stats.edges} edges in ${elapsedMs}ms -> ${out}\n`,
+    );
+  }
+}
+
+if (process.argv[1] && process.argv[1].endsWith("graph-build.mjs")) main();

package/pipeline/scripts/graph-query.mjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+/**
+ * @file graph-query.mjs  -  token-budgeted traversal of the code graph.
+ *
+ * Phase 1's read surface. Ranks graph nodes against the task text with the
+ * pipeline's own BM25 (`_retrieval.mjs`, already gated by eval-recall.mjs),
+ * takes the best seeds, then walks their edges breadth-first until the token
+ * budget is spent. The budget is the point: an unbounded neighbourhood dump is
+ * the context-stuffing anti-pattern this is supposed to replace, so the walk
+ * stops on budget rather than on depth alone.
+ *
+ * Inputs:
+ *   "<question>"     Free text. Required.
+ *   --graph <path>   Graph file. Default: ~/.claude/knowledge/<cwd name>/code-graph.json
+ *   --budget N       Output token cap. Default: 2000
+ *   --depth N        Max BFS depth from a seed. Default: 2
+ *   --seeds N        How many ranked seeds to expand. Default: 8
+ *   --json           Emit JSON instead of text
+ *
+ * Exit codes:
+ *   0  -  answered (possibly empty)
+ *   1  -  graph missing or unreadable
+ *   64 -  usage error
+ *
+ * @module pipeline/scripts/graph-query
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { join, resolve, basename } from "node:path";
+import { homedir } from "node:os";
+import { bm25 } from "./_retrieval.mjs";
+import { parseFlags } from "./graph-build.mjs";
+
+const CHARS_PER_TOKEN = 4;
+
+export function defaultGraphPath(cwd = process.cwd()) {
+  return join(homedir(), ".claude", "knowledge", basename(resolve(cwd)), "code-graph.json");
+}
+
+export function loadGraph(path) {
+  if (!existsSync(path)) throw new Error(`graph not found: ${path}`);
+  const graph = JSON.parse(readFileSync(path, "utf8"));
+  if (!Array.isArray(graph.nodes) || !Array.isArray(graph.edges)) {
+    throw new Error(`graph is malformed: ${path}`);
+  }
+  return graph;
+}
+
+/**
+ * Adjacency in both directions.
+ *
+ * Traversal has to cross an edge either way: a task naming a base class must
+ * reach its subclasses (incoming) as readily as its own file (outgoing).
+ *
+ * @param {object} graph
+ * @returns {Map<string, Array<{id: string, kind: string, dir: string}>>}
+ */
+export function adjacency(graph) {
+  const adj = new Map();
+  const push = (from, to, kind, dir) => {
+    if (!adj.has(from)) adj.set(from, []);
+    adj.get(from).push({ id: to, kind, dir });
+  };
+  for (const e of graph.edges) {
+    push(e.from, e.to, e.kind, "out");
+    push(e.to, e.from, e.kind, "in");
+  }
+  return adj;
+}
+
+/**
+ * Rank nodes against the question.
+ *
+ * `name` outweighs `path` because a task names symbols far more often than
+ * directories, and `symbolKind` carries a little signal ("the FlightList view
+ * model") without letting the kind word alone win a match.
+ *
+ * @param {object} graph
+ * @param {string} question
+ * @returns {Array<{node: object, score: number}>} descending, zero scores dropped
+ */
+export function rankNodes(graph, question) {
+  const docs = graph.nodes.map((n) => ({
+    name: n.name || "",
+    path: n.path || "",
+    symbolKind: n.symbolKind || "",
+  }));
+  const scored = bm25(question, docs, { fieldWeights: { name: 3, path: 1, symbolKind: 1 } });
+  return scored
+    .filter((s) => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map((s) => ({ node: graph.nodes[s.index], score: s.score }));
+}
+
+function renderNode(node) {
+  const where = node.path ? `${node.path}${node.line ? `:${node.line}` : ""}` : "-";
+  const kind = node.symbolKind || node.kind;
+  return `${node.name} (${kind}) ${where}`;
+}
+
+/**
+ * Seed, then breadth-first expand until the budget is spent.
+ *
+ * @param {object} params
+ * @returns {{seeds: object[], hits: object[], truncated: boolean, tokens: number}}
+ */
+export function traverse({ graph, question, budget, depth, seedCount }) {
+  const ranked = rankNodes(graph, question);
+  const seeds = ranked.slice(0, seedCount).map((r) => r.node);
+  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+  const adj = adjacency(graph);
+
+  const seen = new Set(seeds.map((n) => n.id));
+  const hits = [];
+  let tokens = 0;
+  let truncated = false;
+
+  const queue = seeds.map((n) => ({ node: n, dist: 0, via: null }));
+  while (queue.length) {
+    const { node, dist, via } = queue.shift();
+    const cost = Math.ceil(renderNode(node).length / CHARS_PER_TOKEN);
+    if (tokens + cost > budget) {
+      truncated = true;
+      break;
+    }
+    tokens += cost;
+    hits.push({ id: node.id, dist, via, line: renderNode(node), degree: node.degree });
+
+    if (dist >= depth) continue;
+    const neighbours = (adj.get(node.id) || [])
+      .slice()
+      .sort((a, b) => (byId.get(b.id)?.degree || 0) - (byId.get(a.id)?.degree || 0));
+    for (const n of neighbours) {
+      if (seen.has(n.id)) continue;
+      const target = byId.get(n.id);
+      if (!target) continue;
+      seen.add(n.id);
+      queue.push({ node: target, dist: dist + 1, via: `${n.kind}/${n.dir}` });
+    }
+  }
+
+  return { seeds, hits, truncated, tokens };
+}
+
+function main() {
+  const { flags, positional } = parseFlags(process.argv.slice(2));
+  const question = positional.join(" ").trim();
+  if (!question) {
+    process.stderr.write('graph-query: a question is required, e.g. graph-query "flight search"\n');
+    process.exit(64);
+  }
+
+  const path = flags.graph && flags.graph !== true ? resolve(flags.graph) : defaultGraphPath();
+  let graph;
+  try {
+    graph = loadGraph(path);
+  } catch (e) {
+    process.stderr.write(`graph-query: ${e.message}\n`);
+    process.exit(1);
+  }
+
+  const budget = Number(flags.budget) > 0 ? Number(flags.budget) : 2000;
+  const depth = Number(flags.depth) > 0 ? Number(flags.depth) : 2;
+  const seedCount = Number(flags.seeds) > 0 ? Number(flags.seeds) : 8;
+
+  const result = traverse({ graph, question, budget, depth, seedCount });
+
+  if (flags.json === true) {
+    process.stdout.write(JSON.stringify({ question, budget, ...result }, null, 2) + "\n");
+    return;
+  }
+
+  process.stdout.write(`# ${question}\n\n`);
+  if (result.hits.length === 0) {
+    process.stdout.write("no matching nodes\n");
+    return;
+  }
+  for (const hit of result.hits) {
+    const prefix = hit.dist === 0 ? "*" : " ".repeat(hit.dist) + "-";
+    const via = hit.via ? ` [${hit.via}]` : "";
+    process.stdout.write(`${prefix} ${hit.line}${via}\n`);
+  }
+  process.stdout.write(
+    `\n${result.hits.length} nodes, ~${result.tokens} tokens` +
+      (result.truncated ? " (budget reached)" : "") +
+      "\n",
+  );
+}
+
+if (process.argv[1] && process.argv[1].endsWith("graph-query.mjs")) main();

package/pipeline/scripts/graph-report.mjs

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+/**
+ * @file graph-report.mjs  -  GRAPH_REPORT.md, the human-and-model readable summary.
+ *
+ * Phase 1 reads this before deciding how wide to explore, and Phase 7 ships it
+ * next to the knowledge base. Sections are ordered by how much they narrow a
+ * search: hubs first (the types everything touches), then the module map, then
+ * the long tail that is usually safe to ignore.
+ *
+ * God-nodes exclude test files. A test base class is a hub of the test target,
+ * not of the architecture, and letting it rank pushes the real hubs off a list
+ * whose whole value is its first ten rows.
+ *
+ * Inputs:
+ *   --graph <path>   Graph file. Default: ~/.claude/knowledge/<cwd name>/code-graph.json
+ *   --out <path>     Report path. Default: GRAPH_REPORT.md beside the graph
+ *   --top N          Rows per ranked section. Default: 15
+ *   --stdout         Print instead of writing
+ *   --status         Print one header line and exit, writing nothing. This is
+ *                    what `/multi-agent:graph status` runs: the graph is a
+ *                    22MB JSON on a large repo, so "read the header yourself"
+ *                    would mean pulling the whole file into a model's context.
+ *
+ * Exit codes:
+ *   0  -  written
+ *   1  -  graph missing or unreadable
+ *
+ * @module pipeline/scripts/graph-report
+ */
+
+import { writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join, dirname, resolve } from "node:path";
+import { parseFlags } from "./graph-build.mjs";
+import { loadGraph, defaultGraphPath } from "./graph-query.mjs";
+
+/**
+ * Top-level source directory of a path, used as the module bucket.
+ *
+ * @param {string} path
+ * @returns {string}
+ */
+export function moduleOf(path) {
+  if (!path) return "-";
+  const parts = path.split("/");
+  return parts.length > 1 ? parts[0] : ".";
+}
+
+/**
+ * Section inputs, derived once so the renderer stays declarative.
+ *
+ * @param {object} graph
+ * @param {number} top
+ * @returns {object}
+ */
+export function summarize(graph, top) {
+  const symbols = graph.nodes.filter((n) => n.kind === "symbol");
+  const files = graph.nodes.filter((n) => n.kind === "file");
+
+  const hubs = symbols
+    .filter((n) => !n.isTest)
+    .sort((a, b) => b.degree - a.degree)
+    .slice(0, top);
+
+  const modules = new Map();
+  for (const f of files) {
+    const key = moduleOf(f.path);
+    if (!modules.has(key)) modules.set(key, { files: 0, symbols: 0, tests: 0 });
+    const bucket = modules.get(key);
+    bucket.files++;
+    if (f.isTest) bucket.tests++;
+  }
+  for (const s of symbols) {
+    const key = moduleOf(s.path);
+    if (modules.has(key)) modules.get(key).symbols++;
+  }
+
+  const externals = graph.nodes
+    .filter((n) => n.kind === "module")
+    .sort((a, b) => b.degree - a.degree)
+    .slice(0, top);
+
+  const orphans = files.filter((f) => f.degree === 0);
+
+  const kinds = {};
+  for (const s of symbols) kinds[s.symbolKind] = (kinds[s.symbolKind] || 0) + 1;
+
+  return { hubs, modules, externals, orphans, kinds, fileCount: files.length };
+}
+
+/**
+ * @param {object} graph
+ * @param {number} top
+ * @returns {string} markdown
+ */
+export function render(graph, top) {
+  const s = summarize(graph, top);
+  const L = [];
+
+  L.push(`# Code graph report`);
+  L.push("");
+  L.push(`- Root: \`${graph.root}\``);
+  L.push(`- Stack: ${graph.stack}`);
+  L.push(`- Built: ${graph.generatedAt}`);
+  if (graph.baseCommit) L.push(`- Commit: \`${graph.baseCommit.slice(0, 12)}\``);
+  L.push(
+    `- Scale: ${graph.stats.files} files, ${graph.stats.nodes} nodes, ${graph.stats.edges} edges`,
+  );
+  L.push("");
+
+  L.push(`## Architectural hubs`);
+  L.push("");
+  L.push(`The most connected non-test symbols. A change here reaches the widest surface.`);
+  L.push("");
+  L.push(`| Degree | Symbol | Kind | Path |`);
+  L.push(`|---|---|---|---|`);
+  for (const h of s.hubs) {
+    L.push(`| ${h.degree} | \`${h.name}\` | ${h.symbolKind} | \`${h.path}:${h.line || 1}\` |`);
+  }
+  L.push("");
+
+  L.push(`## Modules`);
+  L.push("");
+  L.push(`| Module | Files | Symbols | Test files |`);
+  L.push(`|---|---|---|---|`);
+  const sortedModules = [...s.modules.entries()].sort((a, b) => b[1].files - a[1].files);
+  for (const [name, m] of sortedModules) {
+    L.push(`| \`${name}\` | ${m.files} | ${m.symbols} | ${m.tests} |`);
+  }
+  L.push("");
+
+  L.push(`## External dependencies`);
+  L.push("");
+  L.push(`Imported names with no declaring file in this repo.`);
+  L.push("");
+  L.push(`| Imports | Module |`);
+  L.push(`|---|---|`);
+  for (const e of s.externals) L.push(`| ${e.degree} | \`${e.name}\` |`);
+  L.push("");
+
+  L.push(`## Symbol kinds`);
+  L.push("");
+  const kindRows = Object.entries(s.kinds).sort((a, b) => b[1] - a[1]);
+  L.push(kindRows.map(([k, n]) => `${k}: ${n}`).join(" · "));
+  L.push("");
+
+  L.push(`## Unconnected files`);
+  L.push("");
+  if (s.orphans.length === 0) {
+    L.push(`None: every file has at least one edge.`);
+  } else {
+    L.push(
+      `${s.orphans.length} of ${s.fileCount} files have no edge at all. ` +
+        `Either they declare nothing this stack's rules recognise, or nothing references them.`,
+    );
+    L.push("");
+    for (const o of s.orphans.slice(0, top)) L.push(`- \`${o.path}\``);
+    if (s.orphans.length > top) L.push(`- ... ${s.orphans.length - top} more`);
+  }
+  L.push("");
+
+  return L.join("\n");
+}
+
+/**
+ * HEAD of a repo, or null when it is not a git checkout.
+ *
+ * @param {string} root
+ * @returns {string|null}
+ */
+function headCommit(root) {
+  try {
+    return execFileSync("git", ["-C", root, "rev-parse", "HEAD"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * One line: what the graph covers and whether it still matches the tree.
+ *
+ * @param {object} graph
+ * @param {string} path
+ * @returns {string}
+ */
+export function statusLine(graph, path) {
+  const head = headCommit(graph.root);
+  let freshness = "freshness unknown (no git HEAD)";
+  if (graph.baseCommit && head) {
+    freshness =
+      graph.baseCommit === head
+        ? `current (${head.slice(0, 12)})`
+        : `STALE: built at ${graph.baseCommit.slice(0, 12)}, HEAD is ${head.slice(0, 12)}`;
+  } else if (!graph.baseCommit) {
+    freshness = "freshness unknown (graph carries no baseCommit)";
+  }
+  return (
+    `graph-status: ${graph.stack} | ${graph.stats.files} files, ${graph.stats.nodes} nodes, ` +
+    `${graph.stats.edges} edges | built ${graph.generatedAt} | ${freshness} | ${path}`
+  );
+}
+
+function main() {
+  const { flags } = parseFlags(process.argv.slice(2));
+  const path = flags.graph && flags.graph !== true ? resolve(flags.graph) : defaultGraphPath();
+
+  let graph;
+  try {
+    graph = loadGraph(path);
+  } catch (e) {
+    process.stderr.write(`graph-report: ${e.message}\n`);
+    process.exit(1);
+  }
+
+  if (flags.status === true) {
+    process.stdout.write(statusLine(graph, path) + "\n");
+    return;
+  }
+
+  const top = Number(flags.top) > 0 ? Number(flags.top) : 15;
+  const markdown = render(graph, top);
+
+  if (flags.stdout === true) {
+    process.stdout.write(markdown);
+    return;
+  }
+  const out =
+    flags.out && flags.out !== true ? resolve(flags.out) : join(dirname(path), "GRAPH_REPORT.md");
+  writeFileSync(out, markdown, "utf8");
+  process.stdout.write(`graph-report: ${out}\n`);
+}
+
+if (process.argv[1] && process.argv[1].endsWith("graph-report.mjs")) main();

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

@@ -185,12 +185,12 @@ else
 fi
 
 # ──────────────────────────────────────────────────────────────────────────
-# CLI-aware reviewer-count contract: Claude Code = 2 (Fable + Sonnet), Copilot CLI
+# CLI-aware reviewer-count contract: Claude Code = 3 (Fable + Opus + Sonnet), Copilot CLI
 # = 3 (Opus + GPT-5.4 + Sonnet), Codex CLI = 3 (gpt-5.6 xhigh + gpt-5.4 + gpt-5.6
 # medium). Nothing in code enforces the count (the orchestrator dispatches per the
 # doc), so lock the CONTRACT here against drift across the phase doc, the schema,
 # and the consensus block.
-echo "→ reviewer-count contract (Claude=2, Copilot=3, Codex=3)"
+echo "→ reviewer-count contract (Claude=3, Copilot=3, Codex=3)"
 # `/multi-agent:update` runs this smoke on the user's machine, where the tree is
 # ~/.claude/{schemas,multi-agent-refs} and NOT <root>/pipeline/*. Resolving the
 # root by hand here reported three phantom failures in an install, which reads as
@@ -203,10 +203,13 @@ TRSCHEMA="${MA_SCHEMAS:+$MA_SCHEMAS/triage-output.schema.json}"
 
 if [ -z "$P4" ] || [ ! -f "$P4" ]; then
   echo "  ↷ SKIP: phase-4-review.md not present in this $MA_LAYOUT layout"
-elif grep -qiE "Claude Code (dispatches|=|:) ?2|2-model" "$P4" \
-  && grep -qiE "Copilot CLI (dispatches|=|:) ?3|3-model" "$P4" \
-  && grep -qiE "Codex CLI (dispatches|=|:) ?3|Claude Code 2, Copilot CLI 3, Codex CLI 3" "$P4"; then
-  pass "phase-4-review declares Claude=2 / Copilot=3 / Codex=3 reviewers"
+# Two independent statements, because they can drift apart: the count sentence is
+# the contract, and the matrix is what a reader dispatches from. Three regexes over
+# overlapping prose used to stand in for this and let the count sentence 300 lines
+# further down go stale for a whole release without failing.
+elif grep -qF "Claude Code 3, Copilot CLI 3, Codex CLI 3" "$P4" \
+  && grep -qE '^\| Reviewer 3 .*\|.*\|.*\|.*\|' "$P4"; then
+  pass "phase-4-review declares Claude=3 / Copilot=3 / Codex=3 reviewers, and the matrix has all three host columns"
 else
   fail "phase-4-review does not declare the CLI-aware reviewer count for all three hosts"
 fi
@@ -231,13 +234,13 @@ else
   fail "reviewer-output schema missing the CLI-aware note"
 fi
 
-# consensus.reviewerCount must accommodate both 2 and 3 (min 1, no max < 3)
+# consensus.reviewerCount must accommodate 3 on every host (min 1, no max < 3)
 if [ -z "$TRSCHEMA" ] || [ ! -f "$TRSCHEMA" ]; then
   echo "  ↷ SKIP: triage-output.schema.json not present in this $MA_LAYOUT layout"
-elif grep -q '"reviewerCount"' "$TRSCHEMA" && grep -qi "Claude Code = 2, Copilot CLI = 3" "$TRSCHEMA"; then
-  pass "triage consensus.reviewerCount documents 2 (Claude) and 3 (Copilot)"
+elif grep -q '"reviewerCount"' "$TRSCHEMA" && grep -qi "Claude Code = 3, Copilot CLI = 3" "$TRSCHEMA"; then
+  pass "triage consensus.reviewerCount documents 3 reviewers on every host"
 else
-  fail "triage consensus.reviewerCount does not document the 2/3 split"
+  fail "triage consensus.reviewerCount does not document the 3-reviewer set"
 fi
 
 echo ""

package/pipeline/scripts/test-gap-rules/ios.json

@@ -13,20 +13,48 @@
     "Generated/",
     "Sourcery/",
     "_Generated.swift",
-    "Tests/Fixtures/"
+    "Tests/Fixtures/",
+    ".xctemplate/"
   ],
   "publicApiPatterns": [
-    { "id": "public_func", "regex": "\\bpublic\\s+func\\s+([A-Za-z_][A-Za-z0-9_]*)" },
-    { "id": "public_class", "regex": "\\bpublic\\s+(?:final\\s+)?class\\s+([A-Z][A-Za-z0-9_]*)" },
-    { "id": "public_struct", "regex": "\\bpublic\\s+struct\\s+([A-Z][A-Za-z0-9_]*)" },
-    { "id": "public_enum", "regex": "\\bpublic\\s+enum\\s+([A-Z][A-Za-z0-9_]*)" },
-    { "id": "public_proto", "regex": "\\bpublic\\s+protocol\\s+([A-Z][A-Za-z0-9_]*)" },
-    { "id": "public_init", "regex": "\\bpublic\\s+init\\b" },
-    { "id": "objc_export", "regex": "@objc(?:Members)?\\s+(?:public\\s+)?(?:func|class|var)" }
+    {
+      "id": "public_func",
+      "regex": "\\bpublic\\s+func\\s+([A-Za-z_][A-Za-z0-9_]*)"
+    },
+    {
+      "id": "public_class",
+      "regex": "\\bpublic\\s+(?:final\\s+)?class\\s+([A-Z][A-Za-z0-9_]*)"
+    },
+    {
+      "id": "public_struct",
+      "regex": "\\bpublic\\s+struct\\s+([A-Z][A-Za-z0-9_]*)"
+    },
+    {
+      "id": "public_enum",
+      "regex": "\\bpublic\\s+enum\\s+([A-Z][A-Za-z0-9_]*)"
+    },
+    {
+      "id": "public_proto",
+      "regex": "\\bpublic\\s+protocol\\s+([A-Z][A-Za-z0-9_]*)"
+    },
+    {
+      "id": "public_init",
+      "regex": "\\bpublic\\s+init\\b"
+    },
+    {
+      "id": "objc_export",
+      "regex": "@objc(?:Members)?\\s+(?:public\\s+)?(?:func|class|var)"
+    }
   ],
   "swiftUiViewPatterns": [
-    { "id": "view_struct", "regex": "struct\\s+([A-Z][A-Za-z0-9_]*)\\s*:\\s*View\\b" },
-    { "id": "config_struct", "regex": "struct\\s+([A-Z][A-Za-z0-9_]*Configuration)\\b" }
+    {
+      "id": "view_struct",
+      "regex": "struct\\s+([A-Z][A-Za-z0-9_]*)\\s*:\\s*View\\b"
+    },
+    {
+      "id": "config_struct",
+      "regex": "struct\\s+([A-Z][A-Za-z0-9_]*Configuration)\\b"
+    }
   ],
   "expectedTestKindsForView": ["snapshot", "viewinspector", "unit"],
   "snapshotPathHints": ["SnapshotTests", "__Snapshots__"],