@mmerterden/multi-agent-pipeline 12.5.0 → 12.7.0

package/pipeline/scripts/run-smokes.mjs

@@ -22,7 +22,43 @@ import { fileURLToPath } from "node:url";
 const scriptsDir = dirname(fileURLToPath(import.meta.url));
 const timeoutSec = Number(process.env.SMOKE_TIMEOUT_SECONDS || 180);
 const bail = process.env.SMOKE_NO_BAIL !== "1";
-const filters = process.argv.slice(2);
+const argv = process.argv.slice(2);
+const reportCounts = argv.includes("--counts");
+const filters = argv.filter((a) => !a.startsWith("--"));
+
+// How many assertions did a suite actually make?
+//
+// Exit code alone cannot answer that, and the difference matters: three smokes
+// were exiting 0 having checked nothing. smoke-workflow-audit skipped both its
+// linters because neither was installed anywhere, so the GitHub Actions
+// security audit had never run while showing green - it was hiding a
+// high-severity finding. smoke-plugin-validate had no manifest to validate in
+// this repo at all. A gate that cannot fail is worse than no gate, because the
+// green tick is read as coverage.
+//
+// The four output shapes actually in use here, surveyed across all suites
+// rather than assumed. Anything a suite prints that matches none of them
+// counts as zero, which is the intended answer: an unrecognisable result is
+// not evidence that something was checked.
+//
+//   1. "══ name: 22 passed, 0 failed ══"   most suites
+//   2. "check-md-links: 212 files OK"      counted sweeps
+//   3. per-line "✓" / "ok " / "PASS:"      suites with no summary line
+//   4. "smoke-language-axis: ok"           terse single-verdict suites
+function countAssertions(stdout) {
+  const passed = [...stdout.matchAll(/(\d+) passed/g)];
+  if (passed.length > 0) return Number(passed[passed.length - 1][1]);
+
+  const swept = [...stdout.matchAll(/(\d+) (?:files|patterns|checks|entries) (?:OK|clean)/gi)];
+  if (swept.length > 0) return Number(swept[swept.length - 1][1]);
+
+  const marks = stdout.match(/^[ \t]*(✓|ok |PASS[: ])/gm);
+  if (marks) return marks.length;
+
+  if (/^\S+: ok\s*$/m.test(stdout)) return 1;
+
+  return 0;
+}
 
 const suites = readdirSync(scriptsDir)
   .filter((f) => f.startsWith("smoke-") && f.endsWith(".sh"))
@@ -49,10 +85,28 @@ for (const suite of suites) {
   const secs = ((Date.now() - t0) / 1000).toFixed(1);
 
   const timedOut = res.error && res.error.code === "ETIMEDOUT";
-  const ok = !timedOut && res.status === 0;
+  const asserted = countAssertions(res.stdout || "");
+  const ok = !timedOut && res.status === 0 && (reportCounts || asserted > 0);
+
+  if (reportCounts) {
+    console.log(`${String(asserted).padStart(4)}  ${suite}`);
+    continue;
+  }
 
   if (ok) {
-    console.log(`ok   ${suite} (${secs}s)`);
+    console.log(`ok   ${suite} (${secs}s, ${asserted} checks)`);
+    continue;
+  }
+
+  if (!timedOut && res.status === 0 && asserted === 0) {
+    console.error(
+      `FAIL ${suite} (exited 0 having asserted nothing, ${secs}s)\n` +
+        "     A suite that checks nothing reports coverage it does not have.\n" +
+        "     Give it something to assert, or delete it.",
+    );
+    if (res.stdout) console.error(res.stdout.split("\n").slice(-15).join("\n"));
+    failures.push(suite);
+    if (bail) break;
     continue;
   }
 

package/pipeline/scripts/scorecard.mjs

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+// scorecard.mjs - the measurable part of the review score, as a gate.
+//
+// A refactor review scores ten categories out of ten. Six of those numbers can
+// be measured; four cannot, and writing a number for those is how a scorecard
+// turns into self-congratulation. So this reports exactly two things:
+//
+//   MEASURED    a metric with a threshold, pass or fail
+//   UNMEASURED  a category no script can score, named as such
+//
+// Nothing here re-implements a check. Each metric either reads a committed
+// threshold file or shells out to the gate that already owns the question, so
+// there is one source of truth per question and the scorecard cannot drift from
+// the gates it summarises.
+//
+// Thresholds are locked at the values measured when the gate was written. They
+// are a ratchet: lowering one is a deliberate, reviewable edit, and a metric
+// that improves should have its floor raised.
+//
+// Runs on a clean clone: no $HOME lookups, no credentials, no network. The one
+// metric that needs local configuration (derived-skill drift) reports
+// NOT CONFIGURED rather than passing by default.
+//
+// Usage:  node pipeline/scripts/scorecard.mjs [--json]
+// Exit:   0 every measured metric within threshold, 1 otherwise
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const asJson = process.argv.includes("--json");
+
+// Locked floors. Raise when a metric improves; lowering one is the reviewable act.
+const FLOORS = {
+  coverageLines: 72,
+  coverageBranches: 68,
+  coverageFunctions: 85,
+  contextBytes: 60000,
+};
+
+const results = [];
+
+function measured(category, metric, ok, detail) {
+  results.push({ kind: "MEASURED", category, metric, ok, detail });
+}
+function unmeasured(category, why) {
+  results.push({ kind: "UNMEASURED", category, why });
+}
+
+// Run a gate and report whether it passed. The gate owns the assertion; this
+// only records the verdict, so the two can never disagree.
+function gate(category, metric, argv) {
+  try {
+    execFileSync(argv[0], argv.slice(1), { cwd: ROOT, stdio: "pipe" });
+    return measured(category, metric, true, "gate passed");
+  } catch (e) {
+    const out = `${e.stdout || ""}${e.stderr || ""}`.trim().split("\n").slice(-3).join(" | ");
+    return measured(category, metric, false, out || `exit ${e.status}`);
+  }
+}
+
+// --- Tests: the coverage floors must not be lowered ------------------------
+// c8 enforces the numbers on every run; what nothing enforced was the numbers
+// themselves. .c8rc.json reported 83% while the real figure over its own include
+// set was 33%, because `all` was missing - so the floors are worth pinning.
+{
+  const c8 = JSON.parse(readFileSync(join(ROOT, ".c8rc.json"), "utf-8"));
+  const checks = [
+    ["lines", c8.lines, FLOORS.coverageLines],
+    ["branches", c8.branches, FLOORS.coverageBranches],
+    ["functions", c8.functions, FLOORS.coverageFunctions],
+  ];
+  const low = checks.filter(([, actual, floor]) => !(actual >= floor));
+  measured(
+    "Tests",
+    "coverage floors held",
+    c8.all === true && low.length === 0,
+    c8.all !== true
+      ? "`all` is not set, so the floors only cover files the tests already load"
+      : low.length
+        ? low.map(([k, a, f]) => `${k} ${a} below the locked ${f}`).join(", ")
+        : checks.map(([k, a]) => `${k} ${a}`).join(", "),
+  );
+}
+
+// --- Dependency management: no high or critical advisories ------------------
+{
+  let vulns;
+  try {
+    const raw = execFileSync("npm", ["audit", "--json"], { cwd: ROOT, encoding: "utf-8" });
+    vulns = JSON.parse(raw).metadata.vulnerabilities;
+  } catch (e) {
+    // npm audit exits non-zero when it finds something; the JSON is still on stdout.
+    try {
+      vulns = JSON.parse(e.stdout).metadata.vulnerabilities;
+    } catch {
+      vulns = null;
+    }
+  }
+  if (!vulns) {
+    measured(
+      "Dependency management",
+      "no high or critical advisories",
+      false,
+      "npm audit produced no parseable report",
+    );
+  } else {
+    const bad = vulns.high + vulns.critical;
+    measured(
+      "Dependency management",
+      "no high or critical advisories",
+      bad === 0,
+      `critical ${vulns.critical}, high ${vulns.high}, moderate ${vulns.moderate}`,
+    );
+  }
+}
+
+// --- Performance: the bytes every run pays before it starts ----------------
+gate("Performance", "fixed per-run context within budget", [
+  "bash",
+  "pipeline/scripts/smoke-context-budget.sh",
+]);
+
+// --- CI/CD: the workflow audit runs, and finds nothing ---------------------
+// Strict by default, so a runner without the linters fails here rather than
+// reporting a clean audit it never performed.
+gate("CI/CD", "workflow audit clean (zizmor + actionlint)", [
+  "bash",
+  "pipeline/scripts/smoke-workflow-audit.sh",
+]);
+
+// --- Code quality: our own punctuation rule, both encodings ---------------
+gate("Code quality", "no banned punctuation in shipped files", [
+  "bash",
+  "pipeline/scripts/smoke-own-punctuation.sh",
+]);
+
+// --- Documentation: every skill description routes ------------------------
+gate("Documentation", "every skill description has a routing clause", [
+  "node",
+  "pipeline/scripts/lint-skills.mjs",
+]);
+
+// --- Documentation: the licence and changelog a consumer expects ----------
+{
+  const missing = ["LICENSE", "CHANGELOG.md", "README.md", "SECURITY.md"].filter(
+    (f) => !existsSync(join(ROOT, f)),
+  );
+  measured(
+    "Documentation",
+    "licence, changelog, readme, security present",
+    missing.length === 0,
+    missing.length ? `missing: ${missing.join(", ")}` : "all four present",
+  );
+}
+
+// --- Tests: no suite reports success without asserting anything ------------
+// The runner owns this check; asking it for the counts would re-run 120 suites,
+// so the scorecard asserts the capability is wired rather than re-measuring it.
+{
+  const runner = readFileSync(join(ROOT, "pipeline", "scripts", "run-smokes.mjs"), "utf-8");
+  const wired = runner.includes("countAssertions") && /asserted nothing/.test(runner);
+  measured(
+    "Tests",
+    "runner rejects a suite that asserted nothing",
+    wired,
+    wired
+      ? "zero-assertion check present in run-smokes.mjs"
+      : "run-smokes.mjs no longer counts assertions",
+  );
+}
+
+// --- Drift: needs local configuration, so it reports honestly -------------
+{
+  // The exit code alone cannot answer this. check-derived-drift exits 0 both
+  // when every derivation is current AND when nothing is configured at all, and
+  // those are different facts: one is a pass, the other is an absence of
+  // evidence. Reading `configured` off the JSON is what tells them apart. The
+  // first version of this block trusted exit 0 and reported an unconfigured
+  // machine as a passing metric, which is the exact failure this whole gate set
+  // exists to prevent.
+  let state;
+  let ok = false;
+  let parsed;
+  try {
+    parsed = JSON.parse(
+      execFileSync("node", ["pipeline/scripts/check-derived-drift.mjs", "--json"], {
+        cwd: ROOT,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }),
+    );
+  } catch (e) {
+    // Non-zero exit still writes the report to stdout; an unparseable one means
+    // the check itself could not run.
+    try {
+      parsed = JSON.parse(e.stdout);
+    } catch {
+      parsed = undefined;
+    }
+  }
+  if (parsed && parsed.configured > 0) {
+    const bad = parsed.drifted + parsed.unverified + parsed.unreachable;
+    ok = bad === 0;
+    state = ok
+      ? `${parsed.configured} derivation(s) current with upstream`
+      : `${parsed.drifted} drifted, ${parsed.unverified} unverified, ${parsed.unreachable} unreachable`;
+  } else if (parsed) {
+    state = "NOT CONFIGURED - prefs carry no derivedSkillSources on this machine";
+  } else {
+    state = "NOT CONFIGURED - the drift check produced no parseable report";
+  }
+  if (state.startsWith("NOT CONFIGURED")) {
+    unmeasured("Derived-skill drift", state);
+  } else {
+    measured("Architecture", "derived skills current with upstream", ok, state);
+  }
+}
+
+// --- What no script can score --------------------------------------------
+unmeasured("Architecture", "layer separation and dependency direction are judgement, not a number");
+unmeasured("DevEx", "onboarding time and error-message quality need a person");
+unmeasured(
+  "Accessibility",
+  "nothing in this repo renders UI; the audits it ships are scored per target app",
+);
+unmeasured(
+  "Code quality",
+  "naming, cohesion and altitude are judgement; only the mechanical rules above are gated",
+);
+
+const failed = results.filter((r) => r.kind === "MEASURED" && !r.ok);
+const passed = results.filter((r) => r.kind === "MEASURED" && r.ok);
+
+if (asJson) {
+  console.log(JSON.stringify({ passed: passed.length, failed: failed.length, results }, null, 2));
+} else {
+  console.log("MEASURED");
+  for (const r of results.filter((x) => x.kind === "MEASURED")) {
+    console.log(`  ${r.ok ? "✓" : "✗"} ${r.category}: ${r.metric}`);
+    console.log(`      ${r.detail}`);
+  }
+  console.log("");
+  console.log("UNMEASURED (reported, never scored)");
+  for (const r of results.filter((x) => x.kind === "UNMEASURED")) {
+    console.log(`  - ${r.category}: ${r.why}`);
+  }
+  console.log("");
+  console.log(`══ scorecard: ${passed.length} measured metrics passed, ${failed.length} failed ══`);
+  if (failed.length === 0) {
+    console.log("Every mechanically checkable claim holds. The four unmeasured");
+    console.log("categories above are not covered by that statement.");
+  }
+}
+
+process.exit(failed.length === 0 ? 0 : 1);

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-context-budget.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+#
+# smoke-context-budget.sh  -  the bytes every pipeline run pays before it starts.
+#
+# core/multi-agent/SKILL.md plus multi-agent-refs/rules.md load on every run of
+# every mode, whatever the task. They were 67150 bytes together, roughly 17k
+# tokens spent before the first phase, because the orchestrator skill had grown
+# its own inline copies of things that already existed as loadable references -
+# the log-file template (whose copy had gone stale and named a path the code no
+# longer uses), the help text the multi-agent-help skill owns, and a component
+# generation guide that only applies to design tasks.
+#
+# A budget nobody measures only moves one way, so this pins it. The ceiling is
+# the measured value plus a small margin: enough to add a paragraph, not enough
+# to move a chapter back in. Lowering it is always fine.
+#
+# Exit codes: 0=within budget, 1=over, 2=a tracked file is missing
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+
+# The files loaded unconditionally at run start.
+TRACKED="
+pipeline/skills/shared/core/multi-agent/SKILL.md
+pipeline/multi-agent-refs/rules.md
+"
+
+# Measured 57289 after the split. 60000 leaves ~2.7 kB of headroom.
+CEILING=${CONTEXT_BUDGET_CEILING:-60000}
+
+PASS=0
+FAIL=0
+pass() { PASS=$((PASS + 1)); echo "  ✓ $1"; }
+fail() { FAIL=$((FAIL + 1)); echo "  ✗ $1"; }
+
+echo "→ 1. every tracked file exists"
+TOTAL=0
+for rel in $TRACKED; do
+  f="$REPO_ROOT/$rel"
+  if [ ! -f "$f" ]; then
+    echo "  ✗ missing: $rel"
+    echo "    a tracked file that vanished makes the budget meaningless"
+    exit 2
+  fi
+  n=$(wc -c < "$f" | tr -d ' ')
+  TOTAL=$((TOTAL + n))
+  pass "$rel ($n bytes)"
+done
+
+echo "→ 2. fixed per-run load is within budget"
+if [ "$TOTAL" -le "$CEILING" ]; then
+  pass "fixed load $TOTAL bytes, ceiling $CEILING"
+else
+  fail "fixed load $TOTAL bytes exceeds the $CEILING ceiling by $((TOTAL - CEILING))"
+  echo "    Move detail into multi-agent-refs/ and point at it, rather than"
+  echo "    raising the ceiling. Every byte here is paid by every run."
+fi
+
+echo "→ 3. the orchestrator points at the references instead of copying them"
+SKILL="$REPO_ROOT/pipeline/skills/shared/core/multi-agent/SKILL.md"
+REFS=$(grep -c "multi-agent-refs" "$SKILL" || true)
+if [ "$REFS" -ge 3 ]; then
+  pass "orchestrator cites multi-agent-refs $REFS times"
+else
+  fail "orchestrator cites multi-agent-refs only $REFS time(s)"
+  echo "    It carried zero citations while duplicating three of those files."
+fi
+
+echo ""
+echo "══ smoke-context-budget: $PASS passed, $FAIL failed ══"
+[ "$FAIL" -gt 0 ] && exit 1 || exit 0

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-model-fallback.sh

@@ -70,7 +70,7 @@ if [ "$FABLE_COUNT" -ge 4 ]; then
 else
   fail "expected >=4 fable personas (architects + Reviewer-1), found $FABLE_COUNT"
 fi
-# Opus stays a valid tier — the first fallback below fable, and the top tier for security personas.
+# Opus stays a valid tier - the first fallback below fable, and the top tier for security personas.
 OPUS_COUNT=$(grep -l "^preferredModel: opus" "$REPO_ROOT"/pipeline/agents/*.md 2>/dev/null | wc -l | tr -d ' ')
 if [ "$OPUS_COUNT" -ge 1 ]; then
   ok "opus personas intact ($OPUS_COUNT files)"