@mmerterden/multi-agent-pipeline 12.5.0 → 12.7.0

package/pipeline/scripts/test-gap-scan.mjs

@@ -90,11 +90,20 @@ function git(args) {
 
 function resolveBase() {
   if (BASE) return BASE;
-  for (const ref of ["origin/main", "main", "origin/master", "master", "develop", "origin/develop"]) {
+  for (const ref of [
+    "origin/main",
+    "main",
+    "origin/master",
+    "master",
+    "develop",
+    "origin/develop",
+  ]) {
     try {
       execFileSync("git", ["-C", ROOT, "rev-parse", "--verify", ref], { stdio: "ignore" });
       return ref;
-    } catch { /* continue */ }
+    } catch {
+      /* continue */
+    }
   }
   throw new Error("no base ref found");
 }
@@ -133,9 +142,15 @@ function isExcluded(path) {
 }
 
 function isTestPath(path) {
-  if (Array.isArray(rules.testPathSuffixes) && rules.testPathSuffixes.some((s) => path.endsWith(s))) return true;
-  if (Array.isArray(rules.testPathPrefixes) && rules.testPathPrefixes.some((p) => basename(path).startsWith(p))) return true;
-  if (Array.isArray(rules.testPathContains) && rules.testPathContains.some((c) => path.includes(c))) return true;
+  if (Array.isArray(rules.testPathSuffixes) && rules.testPathSuffixes.some((s) => path.endsWith(s)))
+    return true;
+  if (
+    Array.isArray(rules.testPathPrefixes) &&
+    rules.testPathPrefixes.some((p) => basename(path).startsWith(p))
+  )
+    return true;
+  if (Array.isArray(rules.testPathContains) && rules.testPathContains.some((c) => path.includes(c)))
+    return true;
   return false;
 }
 
@@ -227,8 +242,11 @@ function scanTreeForTests() {
   if (!SCAN_TREE) return hits;
   const visit = (dir) => {
     let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); }
-    catch { return; }
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
     for (const ent of entries) {
       const full = join(dir, ent.name);
       const rel = full.replace(ROOT + "/", "");
@@ -238,7 +256,11 @@ function scanTreeForTests() {
         visit(full);
       } else if (ent.isFile() && isTestPath(rel)) {
         let body;
-        try { body = readFileSync(full, "utf8"); } catch { continue; }
+        try {
+          body = readFileSync(full, "utf8");
+        } catch {
+          continue;
+        }
         // crude symbol mention: any Identifier-ish token. Cap body size.
         const slice = body.slice(0, 400_000);
         const tokens = slice.match(/[A-Za-z_][A-Za-z0-9_]{2,}/g) || [];
@@ -258,7 +280,14 @@ function severityFor(symbol, kind) {
   // Public API additions without tests are important; pure boolean exports
   // (e.g. const FLAG = true) tend to be suggestion-tier.
   if (kind === "objc_export" || kind === "interface" || kind === "public_proto") return "important";
-  if (kind.startsWith("public_") || kind === "open_class" || kind === "open_fun" || kind === "named_export" || kind === "default_export") return "suggestion";
+  if (
+    kind.startsWith("public_") ||
+    kind === "open_class" ||
+    kind === "open_fun" ||
+    kind === "named_export" ||
+    kind === "default_export"
+  )
+    return "suggestion";
   if (kind === "view_struct" || kind === "config_struct") return "important";
   if (kind === "composable_fun") return "important";
   if (kind === "top_def" || kind === "top_class" || kind === "async_def") return "suggestion";
@@ -272,7 +301,10 @@ function symbolMentionedInTest(diffText, symbol) {
   let inTestFile = false;
   for (const line of lines) {
     const fm = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
-    if (fm) { inTestFile = isTestPath(fm[2]); continue; }
+    if (fm) {
+      inTestFile = isTestPath(fm[2]);
+      continue;
+    }
     if (!inTestFile) continue;
     if (!line.startsWith("+")) continue;
     if (re.test(line)) return true;
@@ -327,8 +359,8 @@ function main() {
     testsScanned: tests.length,
     gapCount: gaps.length,
     gapBySeverity: {
-      blocking:   gaps.filter((g) => g.severity === "blocking").length,
-      important:  gaps.filter((g) => g.severity === "important").length,
+      blocking: gaps.filter((g) => g.severity === "blocking").length,
+      important: gaps.filter((g) => g.severity === "important").length,
       suggestion: gaps.filter((g) => g.severity === "suggestion").length,
     },
   };

package/pipeline/scripts/test-integrity-gate.mjs

@@ -76,7 +76,11 @@ function main() {
   }
 
   process.stdout.write(
-    JSON.stringify({ schemaVersion: "1.0.0", count: findings.length, findings }, null, PRETTY ? 2 : 0),
+    JSON.stringify(
+      { schemaVersion: "1.0.0", count: findings.length, findings },
+      null,
+      PRETTY ? 2 : 0,
+    ),
   );
 }
 

package/pipeline/scripts/token-budget-report.mjs

@@ -23,10 +23,10 @@ import os from "node:os";
 import path from "node:path";
 
 const args = parseArgs(process.argv.slice(2));
-const METRICS = process.env.METRICS_FILE
-  || path.join(os.homedir(), ".claude/logs/multi-agent/metrics.jsonl");
-const BUDGET = process.env.BUDGET_FILE
-  || path.join(os.homedir(), ".claude/configs/token-budget.json");
+const METRICS =
+  process.env.METRICS_FILE || path.join(os.homedir(), ".claude/logs/multi-agent/metrics.jsonl");
+const BUDGET =
+  process.env.BUDGET_FILE || path.join(os.homedir(), ".claude/configs/token-budget.json");
 const SUMMARY = path.join(os.homedir(), ".claude/logs/multi-agent/metrics-summary.md");
 
 const PERIOD_DAYS = { daily: 1, weekly: 7, monthly: 30 };
@@ -41,17 +41,28 @@ if (!fs.existsSync(METRICS)) {
 
 const lines = fs.readFileSync(METRICS, "utf8").split("\n").filter(Boolean);
 const events = lines
-  .map(l => { try { return JSON.parse(l); } catch { return null; } })
-  .filter(e => e && e.ts)
-  .filter(e => Date.parse(e.ts) >= cutoffMs)
-  .filter(e => !args.task || e.task_id === args.task);
+  .map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  })
+  .filter((e) => e && e.ts)
+  .filter((e) => Date.parse(e.ts) >= cutoffMs)
+  .filter((e) => !args.task || e.task_id === args.task);
 
 // Per-task aggregation
 const byTask = new Map();
 for (const e of events) {
-  if (!byTask.has(e.task_id)) byTask.set(e.task_id, {
-    tokens_in: 0, tokens_out: 0, premium_calls: 0, phases: new Set(), models: new Set()
-  });
+  if (!byTask.has(e.task_id))
+    byTask.set(e.task_id, {
+      tokens_in: 0,
+      tokens_out: 0,
+      premium_calls: 0,
+      phases: new Set(),
+      models: new Set(),
+    });
   const t = byTask.get(e.task_id);
   t.phases.add(e.phase);
   const d = e.details || {};
@@ -64,21 +75,26 @@ for (const e of events) {
 // Budget (best-effort)
 let budget = {};
 if (fs.existsSync(BUDGET)) {
-  try { budget = JSON.parse(fs.readFileSync(BUDGET, "utf8")); }
-  catch { /* tolerate malformed */ }
+  try {
+    budget = JSON.parse(fs.readFileSync(BUDGET, "utf8"));
+  } catch {
+    /* tolerate malformed */
+  }
 }
 const limits = {
   perTaskTokens: budget.perTaskTokens || 250000,
   perTaskTokensMultiRepo: budget.perTaskTokensMultiRepo || 500000,
-  perTaskUsd: budget.perTaskUsd || 2.50,
-  perTaskUsdMultiRepo: budget.perTaskUsdMultiRepo || 5.00,
+  perTaskUsd: budget.perTaskUsd || 2.5,
+  perTaskUsdMultiRepo: budget.perTaskUsdMultiRepo || 5.0,
 };
 // Crude USD estimate: opus ~$15/M in, $75/M out; sonnet ~$3/M, $15/M out.
 function estimateUsd(t) {
   const inK = t.tokens_in / 1e6;
   const outK = t.tokens_out / 1e6;
   const opusShare = t.models.has("opus") ? 0.5 : 0; // rough
-  return (inK * (15 * opusShare + 3 * (1 - opusShare))) + (outK * (75 * opusShare + 15 * (1 - opusShare)));
+  return (
+    inK * (15 * opusShare + 3 * (1 - opusShare)) + outK * (75 * opusShare + 15 * (1 - opusShare))
+  );
 }
 
 const summary = {
@@ -100,14 +116,18 @@ for (const [taskId, t] of byTask) {
   const isMulti = t.phases.has("4") && t.premium_calls > 5; // heuristic
   const tokenLimit = isMulti ? limits.perTaskTokensMultiRepo : limits.perTaskTokens;
   const usdLimit = isMulti ? limits.perTaskUsdMultiRepo : limits.perTaskUsd;
-  if (total > tokenLimit) summary.breaches.push({ taskId, kind: "tokens", actual: total, limit: tokenLimit });
-  if (usd > usdLimit)    summary.breaches.push({ taskId, kind: "usd",    actual: usd.toFixed(2), limit: usdLimit });
+  if (total > tokenLimit)
+    summary.breaches.push({ taskId, kind: "tokens", actual: total, limit: tokenLimit });
+  if (usd > usdLimit)
+    summary.breaches.push({ taskId, kind: "usd", actual: usd.toFixed(2), limit: usdLimit });
 }
 
 if (args.json) {
   console.log(JSON.stringify(summary, null, 2));
 } else {
-  console.log(`Token & cost report  -  ${summary.period} (${summary.windowStart} → ${summary.windowEnd})`);
+  console.log(
+    `Token & cost report  -  ${summary.period} (${summary.windowStart} → ${summary.windowEnd})`,
+  );
   console.log(`  tasks:        ${summary.taskCount}`);
   console.log(`  tokens in:    ${summary.totalTokensIn.toLocaleString()}`);
   console.log(`  tokens out:   ${summary.totalTokensOut.toLocaleString()}`);
@@ -123,10 +143,13 @@ if (args.json) {
 }
 
 if (args.append) {
-  const row = `| ${summary.windowEnd.slice(0,10)} | ${summary.period} | ${summary.taskCount} | ${summary.totalTokensIn} | ${summary.totalTokensOut} | $${summary.totalUsd.toFixed(2)} | ${summary.breaches.length} |`;
+  const row = `| ${summary.windowEnd.slice(0, 10)} | ${summary.period} | ${summary.taskCount} | ${summary.totalTokensIn} | ${summary.totalTokensOut} | $${summary.totalUsd.toFixed(2)} | ${summary.breaches.length} |`;
   if (!fs.existsSync(SUMMARY)) {
     fs.mkdirSync(path.dirname(SUMMARY), { recursive: true });
-    fs.writeFileSync(SUMMARY, "# Multi-Agent Pipeline Metrics Summary\n\n| date | period | tasks | tokens_in | tokens_out | est_usd | breaches |\n|---|---|---|---|---|---|---|\n");
+    fs.writeFileSync(
+      SUMMARY,
+      "# Multi-Agent Pipeline Metrics Summary\n\n| date | period | tasks | tokens_in | tokens_out | est_usd | breaches |\n|---|---|---|---|---|---|---|\n",
+    );
   }
   fs.appendFileSync(SUMMARY, row + "\n");
 }

package/pipeline/scripts/triage-memory.mjs

@@ -53,8 +53,10 @@ for (let i = 1; i < argv.length; 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;
+    if (v !== undefined && !v.startsWith("--")) {
+      flags[k] = v;
+      i++;
+    } else flags[k] = true;
   }
 }
 
@@ -63,21 +65,50 @@ function die(msg, code = 1) {
   process.exit(code);
 }
 
+// Resolves to the MAIN repository name even when called from inside a pipeline
+// worktree. `--show-toplevel` returns the worktree root, whose basename is the
+// task id, which would shard the per-repo store one directory per task and make
+// prior-art recall always miss. `--git-common-dir` points at the main
+// repository's .git for every linked worktree.
 function repoSlug() {
   if (flags["repo-slug"]) return String(flags["repo-slug"]);
   if (process.env.MULTI_AGENT_REPO_SLUG) return process.env.MULTI_AGENT_REPO_SLUG;
+  try {
+    const commonDir = execFileSync(
+      "git",
+      ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] },
+    ).trim();
+    if (commonDir) {
+      const base = basename(commonDir);
+      const root = base === ".git" ? dirname(commonDir) : commonDir.replace(/\.git$/, "");
+      const slug = basename(root);
+      if (slug) return slug;
+    }
+  } catch {
+    /* not a git repo, or git too old for --path-format */
+  }
   try {
     const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
     }).trim();
     if (top) return basename(top);
-  } catch { /* not a git repo */ }
+  } catch {
+    /* not a git repo */
+  }
   return "default";
 }
 
 function corpusPath(slug) {
-  return join(homedir(), ".claude", "memory", "multi-agent", slug || repoSlug(), "triage-corpus.jsonl");
+  return join(
+    homedir(),
+    ".claude",
+    "memory",
+    "multi-agent",
+    slug || repoSlug(),
+    "triage-corpus.jsonl",
+  );
 }
 
 function ensureDir(p) {
@@ -89,10 +120,12 @@ function ensureDir(p) {
 // flagged stale so a reused finding is verified, not trusted blindly.
 function repoTop() {
   try {
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim() || null;
+    return (
+      execFileSync("git", ["rev-parse", "--show-toplevel"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim() || null
+    );
   } catch {
     return null;
   }
@@ -101,27 +134,84 @@ function repoTop() {
 function fileSha(file, top) {
   if (!file || !top) return null;
   try {
-    return execFileSync("git", ["hash-object", "--", file], {
-      cwd: top,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim() || null;
+    return (
+      execFileSync("git", ["hash-object", "--", file], {
+        cwd: top,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim() || null
+    );
   } catch {
     return null;
   }
 }
 
 const STOP = new Set([
-  "the","a","an","and","or","but","of","in","on","at","to","for","with","by","is","are",
-  "be","been","being","this","that","these","those","it","its","as","not","no","do","does",
-  "did","done","have","has","had","will","would","should","could","may","might","can","cant",
-  "don","wont","you","your","i","we","they","them","he","she","his","her","our","their"
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "of",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "with",
+  "by",
+  "is",
+  "are",
+  "be",
+  "been",
+  "being",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "as",
+  "not",
+  "no",
+  "do",
+  "does",
+  "did",
+  "done",
+  "have",
+  "has",
+  "had",
+  "will",
+  "would",
+  "should",
+  "could",
+  "may",
+  "might",
+  "can",
+  "cant",
+  "don",
+  "wont",
+  "you",
+  "your",
+  "i",
+  "we",
+  "they",
+  "them",
+  "he",
+  "she",
+  "his",
+  "her",
+  "our",
+  "their",
 ]);
 
 function tokenize(text) {
   if (!text) return new Set();
   const out = new Set();
-  for (const m of String(text).toLowerCase().matchAll(/[a-z][a-z0-9_]{2,}/g)) {
+  for (const m of String(text)
+    .toLowerCase()
+    .matchAll(/[a-z][a-z0-9_]{2,}/g)) {
     if (!STOP.has(m[0])) out.add(m[0]);
   }
   return out;
@@ -157,8 +247,11 @@ function readCorpus(slug) {
   const rows = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
-    try { rows.push(JSON.parse(line)); }
-    catch { /* skip corrupted line */ }
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+      /* skip corrupted line */
+    }
   }
   return rows;
 }
@@ -180,18 +273,23 @@ function ingest() {
   const slug = repoSlug();
 
   let triage;
-  try { triage = JSON.parse(readFileSync(triagePath, "utf8")); }
-  catch (e) { die(`cannot parse triage JSON: ${e.message}`, 1); }
+  try {
+    triage = JSON.parse(readFileSync(triagePath, "utf8"));
+  } catch (e) {
+    die(`cannot parse triage JSON: ${e.message}`, 1);
+  }
 
   const ts = new Date().toISOString();
   const top = repoTop();
   const corpus = readCorpus(slug);
-  const seen = new Set(corpus.map((r) => `${r.task_id}::${r.classification}::${r.file}::${r.issue}`));
+  const seen = new Set(
+    corpus.map((r) => `${r.task_id}::${r.classification}::${r.file}::${r.issue}`),
+  );
 
   const buckets = [
-    ["accepted",  triage.accepted  || []],
-    ["deferred",  (triage.deferred || []).map((d) => ({ ...d.finding, _reason: d.reason }))],
-    ["rejected",  (triage.rejected || []).map((d) => ({ ...d.finding, _reason: d.reason }))],
+    ["accepted", triage.accepted || []],
+    ["deferred", (triage.deferred || []).map((d) => ({ ...d.finding, _reason: d.reason }))],
+    ["rejected", (triage.rejected || []).map((d) => ({ ...d.finding, _reason: d.reason }))],
   ];
 
   let written = 0;
@@ -265,12 +363,16 @@ function query() {
         score: Math.round(score * 1000) / 1000,
       };
     });
-  process.stdout.write(JSON.stringify({ ok: true, slug, total: filtered.length, hits: ranked }) + "\n");
+  process.stdout.write(
+    JSON.stringify({ ok: true, slug, total: filtered.length, hits: ranked }) + "\n",
+  );
   process.exit(0);
 }
 
 function pathCmd() {
-  process.stdout.write(corpusPath(flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug()) + "\n");
+  process.stdout.write(
+    corpusPath(flags["repo-slug"] ? String(flags["repo-slug"]) : repoSlug()) + "\n",
+  );
   process.exit(0);
 }
 
@@ -295,10 +397,18 @@ function statsCmd() {
 }
 
 switch (SUB) {
-  case "ingest": ingest(); break;
-  case "query":  query();  break;
-  case "path":   pathCmd(); break;
-  case "stats":  statsCmd(); break;
+  case "ingest":
+    ingest();
+    break;
+  case "query":
+    query();
+    break;
+  case "path":
+    pathCmd();
+    break;
+  case "stats":
+    statsCmd();
+    break;
   default:
     process.stderr.write("usage: triage-memory.mjs <ingest|query|path|stats> [flags]\n");
     process.exit(64);