@mmerterden/multi-agent-pipeline 14.2.2 → 15.1.0

package/pipeline/scripts/phase-tracker.sh

@@ -115,6 +115,23 @@ need_jq() {
   }
 }
 
+# Live usage ping (best-effort). Emits one per-phase update to the private
+# dashboard via usage-report.mjs, always status=running so per-phase updates
+# never fold the run into rollup counters - the terminal fold comes only from
+# the Phase 7 / halt emit that reads the real run status. The emitter no-ops
+# unless prefs.global.usageLog.enabled; detached so it never blocks a boundary.
+usage_live_ping() {
+  local task="$1" phase="$2"
+  local script="$HOME/.claude/scripts/usage-report.mjs"
+  local prefs="$HOME/.claude/multi-agent-preferences.json"
+  [ -n "$task" ] && [ -f "$script" ] || return 0
+  # Cheap gate: only spawn the emitter when usage logging is actually on, so a
+  # user who never enabled it pays nothing per phase boundary. jq is already a
+  # hard dependency of this script.
+  jq -e '.global.usageLog.enabled == true' "$prefs" >/dev/null 2>&1 || return 0
+  ( node "$script" --task-id "$task" --phase "$phase" --status running >/dev/null 2>&1 & ) 2>/dev/null || true
+}
+
 # Decode HTML entities in a tile title.
 #
 # `rules.md` forbids entities in "titles, commit messages, task subjects, or body
@@ -382,6 +399,9 @@ load_state() {
   fi
 }
 save_state() {
+  # Refuse to persist an empty document: every caller pipes jq output in, and
+  # a failed jq yields "" - writing that would destroy the whole tracker state.
+  [ -n "$1" ] || { echo "save_state: refusing to write empty state" >&2; return 65; }
   mkdir -p "$TRACKER_DIR" 2>/dev/null
   printf '%s\n' "$1" > "${TRACKER_FILE}.tmp"
   mv "${TRACKER_FILE}.tmp" "$TRACKER_FILE"
@@ -678,6 +698,7 @@ case "$ACTION" in
     # subsequent tracker call (the pointer flips on the most recent init).
     echo "$TRACKER_FILE" > "$HOME/.claude/logs/multi-agent/.tracker-current"
     render
+    usage_live_ping "$TASK_ID" 0
     if [ "${MULTI_AGENT_QUIET:-0}" != "1" ]; then
       echo "phase-tracker: tracker initialized for task=$TASK_ID" >&2
       echo "phase-tracker: TIP  -  for concurrent-safe resolution, set:" >&2
@@ -693,7 +714,7 @@ case "$ACTION" in
     state=$(load_state)
     # Idempotent: a phase id that already exists is a no-op (name, status, and
     # token history are preserved). This is what lets continuation commands
-    # (/multi-agent:ship, resume) re-declare their phase set against a
+    # (/multi-agent:resume-local, resume) re-declare their phase set against a
     # pre-existing tracker without duplicating or resetting tiles.
     new=$(echo "$state" | jq --arg id "$PID" --arg name "$PNAME" '
       if any(.phases[]?; .id == $id) then .
@@ -730,6 +751,7 @@ case "$ACTION" in
     release_state_lock
     emit_otel_span "phase.update" "$PID" "$STATUS" "{\"status\": \"$STATUS\"}"
     render
+    usage_live_ping "$(basename "$TRACKER_DIR")" "$PID"
     ;;
 
   sub)
@@ -766,9 +788,13 @@ case "$ACTION" in
     [ "$#" -ge 3 ] || { echo "tokens needs <phase_id> <in> <out> [cached]" >&2; exit 64; }
     PID="$1"; T_IN="$2"; T_OUT="$3"; T_CACHED="${4:-0}"
     # Validate integers (cached is optional, defaults to 0 for back-compat).
-    case "$T_IN$T_OUT$T_CACHED" in
-      *[!0-9]*) echo "tokens: in/out/cached must be non-negative integers" >&2; exit 64 ;;
-    esac
+    # Each field checked separately: concatenation would let an empty field
+    # pass and feed jq --argjson an empty string, nuking the state file.
+    for v in "$T_IN" "$T_OUT" "$T_CACHED"; do
+      case "$v" in
+        ''|*[!0-9]*) echo "tokens: in/out/cached must be non-negative integers" >&2; exit 64 ;;
+      esac
+    done
     acquire_state_lock
     state=$(load_state)
     # Additive: add to existing totals so multiple LLM calls accumulate.
@@ -819,7 +845,8 @@ case "$ACTION" in
       )')
     save_state "$new"
     release_state_lock
-    emit_otel_span "phase.meta" "$PID" "$KEY" "{\"meta_key\": \"$KEY\", \"meta_value\": \"$VALUE\"}"
+    META_EXTRA=$(jq -nc --arg k "$KEY" --arg v "$VALUE" '{meta_key: $k, meta_value: $v}')
+    emit_otel_span "phase.meta" "$PID" "$KEY" "$META_EXTRA"
     if [ "${TRACKER_QUIET:-0}" != "1" ]; then
       render
     fi

package/pipeline/scripts/phase0-exit-gate.mjs

@@ -76,7 +76,8 @@ export function inputTextOf(state) {
   // evidence[].url / figmaFrames[] are where the analysis phase parks references.
   for (const key of ["figmaFrames", "designRefs"]) {
     const v = state[key];
-    if (Array.isArray(v)) parts.push(v.map((x) => (typeof x === "string" ? x : JSON.stringify(x))).join(" "));
+    if (Array.isArray(v))
+      parts.push(v.map((x) => (typeof x === "string" ? x : JSON.stringify(x))).join(" "));
   }
   return parts.join("\n");
 }
@@ -198,7 +199,7 @@ function main(argv) {
   const args = argv.slice(2);
   const taskId = args.find((a) => !a.startsWith("--"));
   if (!taskId) {
-    console.error("usage: phase0-exit-gate.mjs <task_id> [--input \"<text>\"] [--json]");
+    console.error('usage: phase0-exit-gate.mjs <task_id> [--input "<text>"] [--json]');
     return 2;
   }
   const inputIdx = args.indexOf("--input");

package/pipeline/scripts/run-aggregator.mjs

@@ -97,7 +97,9 @@ function resolveTrackerCandidates() {
     if (!HOME) die("neither HOME nor USERPROFILE is set  -  pass --task-dir");
     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", flags.project, taskId, "tracker-state.json"),
+      );
     }
     candidates.push(join(HOME, ".claude", "logs", "multi-agent", taskId, "tracker-state.json"));
   }
@@ -209,7 +211,10 @@ let unknownModelHits = 0;
 // 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 }));
+  : Object.entries(tracker.phases || {}).map(([key, value]) => ({
+      ...value,
+      id: value?.id ?? key,
+    }));
 
 for (const phase of phaseList) {
   const tIn = phase.tokens_in || 0;

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/test-gap-rules/android.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "stack": "android",
+  "description": "Android / Jetpack Compose / Kotlin test gap rules. Sources in *.kt; tests under app/src/test/ or app/src/androidTest/.",
+  "sourceExtensions": [".kt", ".java"],
+  "testPathSuffixes": ["Test.kt", "Tests.kt", "Test.java"],
+  "testPathContains": ["/src/test/", "/src/androidTest/", "/test/", "/tests/"],
+  "excludePathGlobs": ["build/", ".gradle/", "generated/", "**/BuildConfig.java", "**/R.java"],
+  "publicApiPatterns": [
+    { "id": "open_class", "regex": "\\bopen\\s+class\\s+([A-Z][A-Za-z0-9_]*)" },
+    { "id": "open_fun", "regex": "\\bopen\\s+fun\\s+([a-z_][A-Za-z0-9_]*)" },
+    { "id": "public_fun", "regex": "^\\s*(?:public\\s+)?fun\\s+([a-z_][A-Za-z0-9_]*)" },
+    { "id": "public_class", "regex": "^\\s*(?:public\\s+)?class\\s+([A-Z][A-Za-z0-9_]*)" },
+    { "id": "jvmstatic", "regex": "@JvmStatic\\b" },
+    { "id": "interface", "regex": "^\\s*(?:public\\s+)?interface\\s+([A-Z][A-Za-z0-9_]*)" }
+  ],
+  "composablePatterns": [
+    {
+      "id": "composable_fun",
+      "regex": "@Composable\\s+(?:public\\s+|internal\\s+)?fun\\s+([A-Z][A-Za-z0-9_]*)"
+    }
+  ],
+  "expectedTestKindsForComposable": ["compose-ui-test"],
+  "hint": "Cover @Composable functions with createComposeRule() + onNodeWithText/Tag/ContentDescription assertions; ViewModels with runTest + Turbine."
+}

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

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "stack": "ios",
+  "description": "iOS / SwiftUI / UIKit test gap rules. Source files in *.swift; tests in *Tests.swift. Snapshot/ViewInspector tests are also recognised when the source is a SwiftUI View.",
+  "sourceExtensions": [".swift"],
+  "testPathSuffixes": ["Tests.swift", "Test.swift"],
+  "testPathContains": ["/Tests/", "/UnitTests/", "/SnapshotTests/"],
+  "excludePathGlobs": [
+    "Pods/",
+    "Carthage/",
+    ".build/",
+    "DerivedData/",
+    "Generated/",
+    "Sourcery/",
+    "_Generated.swift",
+    "Tests/Fixtures/"
+  ],
+  "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)" }
+  ],
+  "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" }
+  ],
+  "expectedTestKindsForView": ["snapshot", "viewinspector", "unit"],
+  "snapshotPathHints": ["SnapshotTests", "__Snapshots__"],
+  "hint": "Cover with a 3-layer test (structural ViewInspector + snapshot + unit) per swiftui-qa.md."
+}

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

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "stack": "node",
+  "description": "Node.js / TypeScript test gap rules. Sources in *.ts/*.tsx/*.js/*.mjs; tests in *.test.* / *.spec.* / __tests__/.",
+  "sourceExtensions": [".ts", ".tsx", ".js", ".mjs", ".cjs"],
+  "testPathSuffixes": [
+    ".test.ts",
+    ".test.tsx",
+    ".test.js",
+    ".test.mjs",
+    ".spec.ts",
+    ".spec.tsx",
+    ".spec.js",
+    ".spec.mjs"
+  ],
+  "testPathContains": ["/__tests__/", "/test/", "/tests/"],
+  "excludePathGlobs": ["node_modules/", "dist/", "build/", ".next/", "coverage/", "*.d.ts"],
+  "publicApiPatterns": [
+    {
+      "id": "named_export",
+      "regex": "^export\\s+(?:async\\s+)?(?:function|class|const|let|interface|type|enum)\\s+([A-Za-z_$][A-Za-z0-9_$]*)"
+    },
+    {
+      "id": "default_export",
+      "regex": "^export\\s+default\\s+(?:async\\s+)?(?:function|class)\\s+([A-Za-z_$][A-Za-z0-9_$]*)"
+    }
+  ],
+  "hint": "Cover named exports with vitest/jest test('<name>', ...). React components: React Testing Library (render + screen + userEvent)."
+}

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

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "stack": "python",
+  "description": "Python test gap rules. Sources in *.py; tests in test_*.py / *_test.py / tests/.",
+  "sourceExtensions": [".py"],
+  "testPathSuffixes": ["_test.py"],
+  "testPathPrefixes": ["test_"],
+  "testPathContains": ["/tests/", "/test/"],
+  "excludePathGlobs": [
+    "__pycache__/",
+    ".venv/",
+    "venv/",
+    ".tox/",
+    "build/",
+    "dist/",
+    "*.egg-info/",
+    "**/migrations/**"
+  ],
+  "publicApiPatterns": [
+    { "id": "top_def", "regex": "^def\\s+([a-z_][a-z0-9_]*)" },
+    { "id": "top_class", "regex": "^class\\s+([A-Z][A-Za-z0-9_]*)" },
+    { "id": "async_def", "regex": "^async\\s+def\\s+([a-z_][a-z0-9_]*)" }
+  ],
+  "hint": "Cover with pytest test_<symbol> style. Async with pytest-asyncio. Avoid name collision with private helpers (prefix _)."
+}