@mmerterden/multi-agent-pipeline 20.33.0 → 20.34.0

package/pipeline/scripts/_graph-analysis.mjs

@@ -0,0 +1,270 @@
+/**
+ * @file _graph-analysis.mjs  -  whole-graph views over the code graph.
+ *
+ * File-level structure the per-symbol queries cannot show:
+ *
+ *   importCycles     files that import each other, directly or around a loop
+ *                    (strongly connected components of the file import graph)
+ *   clusters         groups of files more connected to each other than to the
+ *                    rest, by label propagation over imports and references,
+ *                    with a cohesion score (internal / all edges touching it)
+ *   graphDiff        what changed between two builds of the same repository
+ *   questions        a short list of questions worth asking before a change,
+ *                    built from hubs, cycles and the edges between clusters
+ *
+ * Deterministic: same graph in, same answer out, so a report diff means the
+ * code changed. Zero dependencies; the algorithms are small enough to own.
+ *
+ * @module pipeline/scripts/_graph-analysis
+ */
+
+const LP_ROUNDS = 20;
+
+function fileOfSymbolMap(graph) {
+  const fileOf = new Map();
+  for (const e of graph.edges) {
+    if (e.kind === "defines" && e.from.startsWith("file:")) fileOf.set(e.to, e.from);
+  }
+  return fileOf;
+}
+
+/**
+ * Directed file -> file edges: an import of a file, or a reference to a symbol
+ * another file defines. External modules are left out.
+ *
+ * @returns {Map<string, Map<string, {imports: number, references: number}>>}
+ */
+export function fileEdges(graph) {
+  const files = new Set(graph.nodes.filter((n) => n.kind === "file").map((n) => n.id));
+  const fileOf = fileOfSymbolMap(graph);
+  const out = new Map([...files].map((f) => [f, new Map()]));
+  const add = (from, to, kind) => {
+    if (!from || !to || from === to || !files.has(from) || !files.has(to)) return;
+    const row = out.get(from).get(to) ?? { imports: 0, references: 0 };
+    row[kind]++;
+    out.get(from).set(to, row);
+  };
+  for (const e of graph.edges) {
+    const from = files.has(e.from) ? e.from : fileOf.get(e.from);
+    if (e.kind === "imports") add(from, e.to, "imports");
+    else if (e.kind === "references" || e.kind === "inherits") {
+      add(from, files.has(e.to) ? e.to : fileOf.get(e.to), "references");
+    }
+  }
+  return out;
+}
+
+/**
+ * Import cycles: strongly connected components of size two or more of the
+ * file import graph, largest first. Iterative Tarjan, so a deep repository
+ * cannot overflow the stack.
+ *
+ * @returns {string[][]}
+ */
+export function importCycles(graph) {
+  const edges = fileEdges(graph);
+  const succ = (f) => [...edges.get(f)].filter(([, w]) => w.imports > 0).map(([t]) => t);
+  const index = new Map();
+  const low = new Map();
+  const onStack = new Set();
+  const stack = [];
+  const found = [];
+  let next = 0;
+  for (const root of [...edges.keys()].sort()) {
+    if (index.has(root)) continue;
+    const work = [{ id: root, it: 0, nbrs: null }];
+    while (work.length) {
+      const top = work[work.length - 1];
+      if (top.nbrs === null) {
+        index.set(top.id, next);
+        low.set(top.id, next);
+        next++;
+        stack.push(top.id);
+        onStack.add(top.id);
+        top.nbrs = succ(top.id).sort();
+      }
+      if (top.it < top.nbrs.length) {
+        const w = top.nbrs[top.it++];
+        if (!index.has(w)) work.push({ id: w, it: 0, nbrs: null });
+        else if (onStack.has(w)) low.set(top.id, Math.min(low.get(top.id), index.get(w)));
+        continue;
+      }
+      work.pop();
+      if (work.length) {
+        const parent = work[work.length - 1].id;
+        low.set(parent, Math.min(low.get(parent), low.get(top.id)));
+      }
+      if (low.get(top.id) === index.get(top.id)) {
+        const members = [];
+        let m;
+        do {
+          m = stack.pop();
+          onStack.delete(m);
+          members.push(m);
+        } while (m !== top.id);
+        if (members.length > 1) found.push(members.sort());
+      }
+    }
+  }
+  return found.sort((a, b) => b.length - a.length || a[0].localeCompare(b[0]));
+}
+
+/**
+ * Clusters by label propagation on the undirected, weighted file graph. Each
+ * round every file takes the label its neighbours carry the most weight for;
+ * among equal labels the smallest wins, a file keeps its own label on a tie,
+ * and files are visited in id order, so the result does not depend on chance.
+ *
+ * The cluster's id is its most connected file; `dirs` names where its files sit.
+ *
+ * @returns {Array<{id: string, dirs: string, files: string[], cohesion: number, internal: number, external: number}>}
+ */
+export function clusters(graph, { rounds = LP_ROUNDS, minSize = 2 } = {}) {
+  const directed = fileEdges(graph);
+  const nbrs = new Map([...directed.keys()].map((f) => [f, new Map()]));
+  for (const [from, row] of directed) {
+    for (const [to, w] of row) {
+      const weight = w.imports + w.references;
+      nbrs.get(from).set(to, (nbrs.get(from).get(to) ?? 0) + weight);
+      nbrs.get(to).set(from, (nbrs.get(to).get(from) ?? 0) + weight);
+    }
+  }
+  const order = [...nbrs.keys()].sort();
+  const label = new Map(order.map((f) => [f, f]));
+  for (let r = 0; r < rounds; r++) {
+    let changed = false;
+    for (const f of order) {
+      const tally = new Map();
+      for (const [n, w] of nbrs.get(f)) tally.set(label.get(n), (tally.get(label.get(n)) ?? 0) + w);
+      if (!tally.size) continue;
+      let best = null;
+      let bestW = -1;
+      for (const [l, w] of [...tally].sort((a, b) => a[0].localeCompare(b[0]))) {
+        if (w > bestW) {
+          best = l;
+          bestW = w;
+        }
+      }
+      // A file keeps its label on a tie, so one bridge edge cannot pull a
+      // whole group across.
+      if (best !== label.get(f) && bestW > (tally.get(label.get(f)) ?? 0)) {
+        label.set(f, best);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  const groups = new Map();
+  for (const f of order) {
+    const l = label.get(f);
+    if (!groups.has(l)) groups.set(l, []);
+    groups.get(l).push(f);
+  }
+  const result = [];
+  for (const files of groups.values()) {
+    if (files.length < minSize) continue;
+    const set = new Set(files);
+    let internal = 0;
+    let external = 0;
+    for (const f of files) {
+      for (const [n, w] of nbrs.get(f)) {
+        if (set.has(n)) internal += w;
+        else external += w;
+      }
+    }
+    internal /= 2;
+    const total = internal + external;
+    const hub = files
+      .map((f) => [f, [...nbrs.get(f)].reduce((sum, [n, w]) => sum + (set.has(n) ? w : 0), 0)])
+      .sort((x, y) => y[1] - x[1] || x[0].localeCompare(y[0]))[0][0];
+    result.push({
+      id: hub.replace(/^file:/, ""),
+      dirs: commonPrefix(files),
+      files,
+      internal,
+      external,
+      cohesion: total ? Math.round((internal / total) * 100) / 100 : 1,
+    });
+  }
+  return result.sort((a, b) => b.files.length - a.files.length || a.id.localeCompare(b.id));
+}
+
+/** A cluster's name: the directory most of its files sit in, and how many others. */
+function commonPrefix(files) {
+  const dirs = new Map();
+  for (const f of files) {
+    const path = f.replace(/^file:/, "");
+    const dir = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : ".";
+    dirs.set(dir, (dirs.get(dir) ?? 0) + 1);
+  }
+  const ranked = [...dirs].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  return ranked.length > 1 ? `${ranked[0][0]} (+${ranked.length - 1} dirs)` : ranked[0][0];
+}
+
+/** Nodes and edges added and removed between two builds. */
+export function graphDiff(before, after) {
+  const ids = (g, kind) => new Set(g.nodes.filter((n) => n.kind === kind).map((n) => n.id));
+  const edgeKey = (e) => `${e.from}|${e.kind}|${e.to}`;
+  const delta = (a, b) => ({
+    added: [...b].filter((x) => !a.has(x)).sort(),
+    removed: [...a].filter((x) => !b.has(x)).sort(),
+  });
+  const edgesA = new Set(before.edges.map(edgeKey));
+  const edgesB = new Set(after.edges.map(edgeKey));
+  const e = delta(edgesA, edgesB);
+  return {
+    files: delta(ids(before, "file"), ids(after, "file")),
+    symbols: delta(ids(before, "symbol"), ids(after, "symbol")),
+    edges: { added: e.added.length, removed: e.removed.length },
+    cycles: {
+      before: importCycles(before).length,
+      after: importCycles(after).length,
+    },
+  };
+}
+
+/**
+ * Questions worth asking before a change, from what the graph can show:
+ * the widest hubs, each import cycle, and the strongest link between two
+ * clusters. Templates only; no model call.
+ */
+export function questions(graph, { hubs = [], cycles = null, groups = null, max = 8 } = {}) {
+  const out = [];
+  const shortPath = (id) => id.replace(/^file:/, "");
+  for (const h of hubs.slice(0, 3)) {
+    out.push(`What depends on \`${h.name}\` (${h.degree} edges), and which of it has tests?`);
+  }
+  for (const c of (cycles ?? importCycles(graph)).slice(0, 2)) {
+    const shown = c.slice(0, 3).map(shortPath).join("`, `");
+    out.push(
+      `Why do \`${shown}\`${c.length > 3 ? ` and ${c.length - 3} more` : ""} import each other?`,
+    );
+  }
+  const list = groups ?? clusters(graph);
+  const clusterOf = new Map();
+  list.forEach((g, i) => g.files.forEach((f) => clusterOf.set(f, i)));
+  const cross = new Map();
+  for (const [from, row] of fileEdges(graph)) {
+    for (const [to, w] of row) {
+      const a = clusterOf.get(from);
+      const b = clusterOf.get(to);
+      if (a === undefined || b === undefined || a === b) continue;
+      const key = `${a}>${b}`;
+      const cur = cross.get(key) ?? { a, b, weight: 0, via: from };
+      cur.weight += w.imports + w.references;
+      cross.set(key, cur);
+    }
+  }
+  const strongest = [...cross.values()].sort((x, y) => y.weight - x.weight).slice(0, 2);
+  for (const l of strongest) {
+    out.push(
+      `Should the cluster around \`${list[l.a].id}\` reach into the one around \`${list[l.b].id}\` directly (${l.weight} edges, e.g. from \`${shortPath(l.via)}\`)?`,
+    );
+  }
+  for (const g of list.filter((x) => x.files.length >= 3 && x.cohesion < 0.3).slice(0, 2)) {
+    out.push(
+      `The cluster around \`${g.id}\` (${g.dirs}) has cohesion ${g.cohesion}: one module, or several sharing a folder?`,
+    );
+  }
+  return out.slice(0, max);
+}

package/pipeline/scripts/_memory-policy.mjs

@@ -0,0 +1,165 @@
+/**
+ * @file _memory-policy.mjs  -  what the per-repo memory stores may keep, and
+ * how much weight an entry has earned.
+ *
+ *   ledgerRowId(row)       the stable id of a learnings-ledger row, the one
+ *                          feedback is recorded against
+ *   checkedSlug(slug)      the slug as one folder name; a separator, NUL, `.`
+ *                          or `..`, anything that could leave
+ *                          ~/.claude/memory/multi-agent/, throws
+ *   memoryExcluded(slug)   prefs.global.memory.excludeProjects lists repo slugs
+ *                          whose memory is never written; every store asks
+ *                          before it writes
+ *   standing(feedback)     what the outcomes recorded against one ledger entry
+ *                          say about it: suppressed (marked corrected, or
+ *                          judged a dead end more often than useful, twice or
+ *                          more), corroborated (useful at least twice) and a
+ *                          strength that decays with age (ACT-R base level,
+ *                          ln of the sum of age^-0.5 over the useful dates)
+ *   nearDuplicate(a, b)    two statements that say the same thing in other
+ *                          words: TF-IDF cosine at or above the threshold, the
+ *                          same numbers, the same negations and mostly the
+ *                          same word order ("A over B" is not "B over A")
+ *
+ * Zero dependencies.
+ *
+ * @module pipeline/scripts/_memory-policy
+ */
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { shortId, tokens } from "./_retrieval.mjs";
+
+const CORROBORATION = 2;
+const NEAR_DUP = 0.9;
+const ORDER_OVERLAP = 0.5;
+const NEGATIONS = /\b(not|never|no|none|without|except|only|avoid|don't|do not)\b/gi;
+
+function prefs(env) {
+  const p =
+    env.MULTI_AGENT_PREFS || join(env.HOME || homedir(), ".claude", "multi-agent-preferences.json");
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+/** Stable id of a ledger row: its kind and its whitespace-folded statement. */
+export function ledgerRowId(row) {
+  const statement = String(row?.statement || "")
+    .toLowerCase()
+    .replace(/\s+/g, " ")
+    .trim();
+  return shortId("L", row?.kind, statement);
+}
+
+/**
+ * The slug, when it names one folder; throws on anything that could leave the
+ * memory folder (a separator, NUL, `.` or `..`). Spaces and non-ASCII letters
+ * are fine: a repository folder may carry them.
+ */
+export function checkedSlug(slug) {
+  const s = String(slug ?? "");
+  if (!s || s.length > 255 || /[/\\\0]/.test(s) || s === "." || s === "..") {
+    throw new Error(`not a repository slug: ${JSON.stringify(s.slice(0, 80))}`);
+  }
+  return s.normalize("NFC");
+}
+
+/** True when the repo's memory must not be written. */
+export function memoryExcluded(slug, env = process.env) {
+  const list = prefs(env)?.global?.memory?.excludeProjects;
+  const want = String(slug ?? "").normalize("NFC");
+  return Array.isArray(list) && list.some((p) => String(p).normalize("NFC") === want);
+}
+
+/**
+ * @param {Array<{ts: string, outcome: string}>} feedback  rows for one entry
+ * @returns {{useful: number, deadEnd: number, corrected: number, suppressed: boolean, corroborated: boolean, strength: number}}
+ */
+export function standing(feedback, now = Date.now()) {
+  const useful = feedback.filter((f) => f.outcome === "useful");
+  const deadEnd = feedback.filter((f) => f.outcome === "dead_end").length;
+  const corrected = feedback.filter((f) => f.outcome === "corrected").length;
+  const sum = useful.reduce((s, f) => {
+    const t = Date.parse(f.ts);
+    const days = Number.isNaN(t) ? 365 : Math.max(0, (now - t) / 86400000);
+    return s + Math.pow(days + 1, -0.5);
+  }, 0);
+  return {
+    useful: useful.length,
+    deadEnd,
+    corrected,
+    suppressed: corrected > 0 || (deadEnd >= CORROBORATION && deadEnd > useful.length),
+    corroborated: useful.length >= CORROBORATION,
+    strength: sum > 0 ? Math.log(sum) + 10 : 0,
+  };
+}
+
+const numbersIn = (s) => (String(s).match(/\d+(?:\.\d+)?/g) || []).sort().join(",");
+const negationsIn = (s) =>
+  (String(s).toLowerCase().match(NEGATIONS) || [])
+    .map((w) => w.replace(/\s+/g, " "))
+    .sort()
+    .join(",");
+
+/** Inverse document frequencies over a corpus of token lists. */
+function idf(corpus) {
+  const df = new Map();
+  for (const doc of corpus) for (const t of new Set(doc)) df.set(t, (df.get(t) || 0) + 1);
+  const n = corpus.length;
+  return (t) => Math.log(1 + n / (df.get(t) || 1));
+}
+
+function tfidf(doc, weight) {
+  const tf = new Map();
+  for (const t of doc) tf.set(t, (tf.get(t) || 0) + 1);
+  const v = new Map();
+  for (const [t, c] of tf) v.set(t, c * weight(t));
+  return v;
+}
+
+function cosine(va, vb) {
+  let dot = 0;
+  for (const [t, w] of va) dot += w * (vb.get(t) || 0);
+  const norm = (v) => Math.sqrt([...v.values()].reduce((s, w) => s + w * w, 0));
+  const d = norm(va) * norm(vb);
+  return d ? dot / d : 0;
+}
+
+/** Jaccard overlap of adjacent token pairs: low when the same words come in another order. */
+function orderOverlap(a, b) {
+  const pairs = (doc) => new Set(doc.slice(1).map((t, i) => `${doc[i]} ${t}`));
+  const pa = pairs(a);
+  const pb = pairs(b);
+  if (!pa.size || !pb.size) return 0;
+  let shared = 0;
+  for (const p of pa) if (pb.has(p)) shared++;
+  return shared / (pa.size + pb.size - shared);
+}
+
+/**
+ * The existing statement `candidate` repeats in other words, or null.
+ *
+ * @param {string} candidate
+ * @param {string[]} existing  statements of the same kind
+ */
+export function nearDuplicate(candidate, existing) {
+  const c = tokens(candidate);
+  if (c.length < 3) return null;
+  const docs = existing.map((s) => tokens(s));
+  const weight = idf([...docs, c]);
+  const vc = tfidf(c, weight);
+  const nums = numbersIn(candidate);
+  const negs = negationsIn(candidate);
+  for (let i = 0; i < existing.length; i++) {
+    if (numbersIn(existing[i]) !== nums) continue;
+    if (negationsIn(existing[i]) !== negs) continue;
+    if (orderOverlap(c, docs[i]) < ORDER_OVERLAP) continue;
+    if (cosine(vc, tfidf(docs[i], weight)) >= NEAR_DUP) return existing[i];
+  }
+  return null;
+}

package/pipeline/scripts/_secret-scan.mjs

@@ -0,0 +1,105 @@
+/**
+ * @file _secret-scan.mjs  -  the check every memory store runs before it writes.
+ *
+ * Text goes to a 0600 temp file and through `pre-commit-check.sh --scan-file`,
+ * which owns the secret patterns; a hit is refused, never written. A store
+ * that cannot find the scanner refuses as well, because "unchecked" and
+ * "clean" are different answers and only one of them may reach a file that
+ * later rides into a prompt.
+ *
+ * `<private>...</private>` spans are removed before the scan, so a caller can
+ * mark text that must not be remembered; an unclosed tag drops everything
+ * after it.
+ *
+ * Control bytes are removed from the scanned copy: the scanner skips a file
+ * `file --mime` calls binary, and one NUL is enough for that verdict. Removing
+ * them also rejoins a token split by one. A run that starts with a known token
+ * prefix is scanned a second time with its inner whitespace removed, so a token
+ * hard-wrapped by a space or a line break is still caught; prose without such
+ * a prefix is scanned once, as written.
+ *
+ * @module pipeline/scripts/_secret-scan
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+// eslint-disable-next-line no-control-regex
+const CONTROL = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+const WRAPPED_TOKEN =
+  /(?:gh[pousr]_|github_pat_|glpat-|xox[baprs]-|sk-|sk_live_|rk_live_|npm_|hf_|gsk_|pplx-|fig[a-z]_|eyJ|AIza|AKIA|ASIA)[A-Za-z0-9_.-]{0,256}(?:\s+[A-Za-z0-9_.-]{1,256}){1,16}/g;
+
+/** The text with whitespace removed inside every run that starts like a token. */
+function rejoined(text) {
+  return text.replace(WRAPPED_TOKEN, (m) => m.replace(/\s+/g, ""));
+}
+
+/** Remove `<private>` spans; an unclosed opening tag drops the rest. */
+export function stripPrivate(text) {
+  return String(text ?? "")
+    .replace(/<private>[\s\S]*?<\/private>/gi, " ")
+    .replace(/<private>[\s\S]*$/i, " ")
+    .replace(/<\/private>/gi, " ");
+}
+
+function scannerPath() {
+  const local = join(HERE, "pre-commit-check.sh");
+  if (existsSync(local)) return local;
+  const installed = join(homedir(), ".claude", "scripts", "pre-commit-check.sh");
+  return existsSync(installed) ? installed : null;
+}
+
+/**
+ * A scanner bound to one temp directory. `isClean(text)` is true only when
+ * the scanner ran and found nothing; call `close()` when done.
+ */
+export function openScanner() {
+  const scanner = scannerPath();
+  if (!scanner) return { scanned: false, isClean: () => false, close() {} };
+  const dir = mkdtempSync(join(tmpdir(), "secret-scan-"));
+  const file = join(dir, "candidate.txt");
+  return {
+    scanned: true,
+    isClean(text) {
+      const plain = String(text ?? "").replace(CONTROL, "");
+      const copies = [plain];
+      const joined = rejoined(plain);
+      if (joined !== plain) copies.push(joined);
+      return copies.every((copy) => {
+        writeFileSync(file, `${copy}\n`, { mode: 0o600 });
+        try {
+          execFileSync("bash", [scanner, "--scan-file", file], {
+            stdio: "ignore",
+            timeout: 15_000,
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      });
+    },
+    close() {
+      rmSync(dir, { recursive: true, force: true });
+    },
+  };
+}
+
+/** Split items into kept and dropped by the text `textOf(item)` returns. */
+export function dropSecrets(items, textOf) {
+  const scan = openScanner();
+  const kept = [];
+  let dropped = 0;
+  try {
+    for (const it of items) {
+      if (scan.isClean(textOf(it))) kept.push(it);
+      else dropped++;
+    }
+  } finally {
+    scan.close();
+  }
+  return { kept, dropped, scanned: scan.scanned };
+}

package/pipeline/scripts/_unified-diff.mjs

@@ -10,7 +10,7 @@
 
 /**
  * @typedef {{line: number, text: string}} DiffLine
- * @typedef {{removed: DiffLine[], added: DiffLine[]}} Hunk
+ * @typedef {{header: string, removed: DiffLine[], added: DiffLine[]}} Hunk
  * @typedef {{added: string[], addedAt: DiffLine[], removed: string[], removedAt: DiffLine[],
  *            hunks: Hunk[], isNew: boolean, isDeleted: boolean, binary: boolean}} DiffFile
  */
@@ -73,7 +73,7 @@ export function parseUnifiedDiff(text) {
     let newLeft = h[4] === undefined ? 1 : Number(h[4]);
     let oldNo = Number(h[1]);
     let newNo = Number(h[3]);
-    const hunk = { removed: [], added: [] };
+    const hunk = { header: h[0], removed: [], added: [] };
     cur.hunks.push(hunk);
     while ((oldLeft > 0 || newLeft > 0) && i + 1 < lines.length) {
       const body = lines[++i];

package/pipeline/scripts/capture-flush.sh

@@ -200,12 +200,22 @@ if [ -n "$TRIAGE" ]; then
   if [ -n "$TASK_ID" ]; then
     DISTILLED=$(run_store distill \
       node "$SCRIPTS/learnings-ledger.mjs" from-triage --triage "$TRIAGE" --task "$TASK_ID" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
+    DEBT=$(run_store debt \
+      node "$SCRIPTS/debt-ledger.mjs" from-run --triage "$TRIAGE" --state "$STATE" --task "$TASK_ID" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
   fi
 fi
 
+# Shortcut markers come from the diff, so they are read while a worktree is
+# still there; after Phase 4 removes it the flush has no diff and skips them.
+BASE=$(jq -r '.baseBranch // empty' "$STATE" 2>/dev/null)
+if [ -n "$TASK_ID" ] && [ -n "$BASE" ] && [ -n "$WORKTREE" ] && [ -d "$WORKTREE" ]; then
+  MARKERS=$(run_store markers bash -c 'set -o pipefail; git -C "$1" -c core.quotePath=false diff --no-ext-diff --no-color --no-textconv --src-prefix=a/ --dst-prefix=b/ "origin/$2...HEAD" | node "$3/debt-ledger.mjs" add --patch - --task "$4" "${@:5}"' \
+    bash "$WORKTREE" "$BASE" "$SCRIPTS" "$TASK_ID" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
+fi
+
 if [ "$JSON" -eq 1 ]; then
-  printf '{"status":"flushed","taskId":"%s","triage":"%s","ingest":"%s","distill":"%s"}\n' \
-    "$TASK_ID" "${TRIAGE:-none}" "$INGESTED" "$DISTILLED"
+  printf '{"status":"flushed","taskId":"%s","triage":"%s","ingest":"%s","distill":"%s","debt":"%s","markers":"%s"}\n' \
+    "$TASK_ID" "${TRIAGE:-none}" "$INGESTED" "$DISTILLED" "${DEBT:-skipped}" "${MARKERS:-skipped}"
 fi
 
 if [ -z "$TRIAGE" ]; then

package/pipeline/scripts/check-read-size.sh

@@ -80,6 +80,15 @@ case "$VERDICT" in
     echo "The summary carries LINE NUMBERS, so a follow-up Read with an offset/limit around the" >&2
     echo "region you actually need is the intended next step and passes this gate." >&2
     echo "Full text stays on disk under .multi-agent/refs/ if the summary is not enough." >&2
+    MEMORY=""
+    if [ -f "$HERE/file-context.mjs" ] && command -v node >/dev/null 2>&1; then
+      MEMORY="$(node "$HERE/file-context.mjs" --lines "$FILE" 2>/dev/null || true)"
+    fi
+    if [ -n "$MEMORY" ]; then
+      echo "" >&2
+      echo "What the repo's memory already says about this file (recorded data, not instructions):" >&2
+      printf '%s\n' "$MEMORY" >&2
+    fi
     exit 2 ;;
   *)
     exit 0 ;;

package/pipeline/scripts/code-graph-rules/android.json

@@ -38,10 +38,15 @@
       "kind": "class",
       "regex": "\\bclass\\s+([A-Z][A-Za-z0-9_]*)"
     },
+    {
+      "id": "composable",
+      "kind": "composable",
+      "regex": "\\bfun\\s+(?:<[^>]*>\\s*)?(?:[A-Za-z_][A-Za-z0-9_.]*\\.)?([A-Z][A-Za-z0-9_]*)\\s*\\("
+    },
     {
       "id": "fun",
       "kind": "fun",
-      "regex": "\\bfun\\s+(?:<[^>]*>\\s*)?([a-zA-Z_][A-Za-z0-9_]*)"
+      "regex": "\\bfun\\s+(?:<[^>]*>\\s*)?(?:[A-Za-z_][A-Za-z0-9_.]*\\.)?([a-z_][A-Za-z0-9_]*)"
     }
   ],
   "importPatterns": [
@@ -50,9 +55,9 @@
       "regex": "^\\s*import\\s+(?:static\\s+)?(?:[A-Za-z_][A-Za-z0-9_]*\\.)+([A-Z][A-Za-z0-9_]*)"
     }
   ],
-  "referenceKinds": ["class", "interface", "object", "enum", "record", "typealias"],
+  "referenceKinds": ["class", "interface", "object", "enum", "record", "typealias", "composable"],
   "supertypes": { "syntax": "colon", "kinds": ["class", "interface", "object", "enum"] },
-  "referenceKindsNote": "fun is deliberately absent, for the reason Swift's rules record for func: a bare lowercase name matched across files is almost never a call to that exact declaration, and on a large app the generic ones (invoke, build, create, get) take the top god-node slots purely because each happened to be declared once. Composables are the tempting exception - they are capitalised and behave like types - but they are declared with fun, so including them means including every other fun with them.",
+  "referenceKindsNote": "fun is deliberately absent, for the reason Swift's rules record for func: a bare lowercase name matched across files is almost never a call to that exact declaration, and on a large app the generic ones (invoke, build, create, get) take the top god-node slots purely because each happened to be declared once. A capitalised fun is the exception and gets its own kind, composable: Kotlin names ordinary functions in lowerCamelCase, so a capitalised fun is in practice a Compose UI function (or a factory named after the type it builds), and it is called by that exact name the way a type is.",
   "ignoredIdentifiers": [
     "this",
     "super",