@mmerterden/multi-agent-pipeline 20.20.0 → 20.22.0

package/pipeline/scripts/_diff-impact.mjs

@@ -0,0 +1,312 @@
+/**
+ * @file _diff-impact.mjs  -  a diff, mapped onto the code graph.
+ *
+ * Three questions a reviewer or a planner asks of a change, answered from the
+ * graph without a model:
+ *
+ *   parseHunkRanges  which lines of each file the diff touched, on the side
+ *                    the graph was built from (graphSide)
+ *   changedSymbols   which declarations those lines fall in, innermost first,
+ *                    and which files the graph does not index at all
+ *   graphFreshness   how far the graph is behind the tree it describes
+ *
+ * The reverse walk itself is graph-affected.mjs; this module only produces its
+ * seeds. A graph built before definition spans existed (schema 1.0.0) has no
+ * `endLine`, so a hunk in such a file seeds the whole file and the file is
+ * listed in `fileLevel`: a coarser answer that says it is coarse.
+ *
+ * Zero runtime dependencies (ADR-0004).
+ *
+ * @module pipeline/scripts/_diff-impact
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { unquotePathIfNeeded } from "./git-path.mjs";
+
+const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+/** The path of a `---`/`+++` line: git-quoted or not, one-letter prefix removed. */
+function sidePath(raw, prefix) {
+  const text = raw.startsWith('"') ? raw : raw.replace(/\t.*$/, "");
+  const path = unquotePathIfNeeded(text);
+  if (path === "/dev/null") return null;
+  return path.startsWith(prefix) ? path.slice(prefix.length) : path;
+}
+
+function addLine(set, line) {
+  set.add(Math.max(1, line));
+}
+
+function toRanges(lines) {
+  const sorted = [...lines].sort((a, b) => a - b);
+  const out = [];
+  for (const l of sorted) {
+    const last = out[out.length - 1];
+    if (last && l === last.end + 1) last.end = l;
+    else if (!last || l > last.end) out.push({ start: l, end: l });
+  }
+  return out;
+}
+
+/**
+ * Every file of a unified diff with the lines it touched on each side.
+ *
+ * New side: an added line counts as itself, and a deletion as the line now
+ * standing where the removed lines were. Old side: a removed line counts as
+ * itself, and an insertion as the old line standing where it went in. Either way a hunk that
+ * only adds or only removes still lands inside the declaration it changed.
+ * Hunks are counted from their headers, so concatenated `diff -u` output with
+ * no `diff --git` lines parses too, CRLF included, at any context size.
+ *
+ * @param {string} diffText - unified diff
+ * @returns {Array<{oldPath: string|null, newPath: string|null, oldRanges: Array<{start: number, end: number}>, newRanges: Array<{start: number, end: number}>}>}
+ */
+export function parseDiffFiles(diffText) {
+  const files = [];
+  let cur = null;
+  let pendingOld;
+  let oldLine = 0;
+  let newLine = 0;
+  let oldLeft = 0;
+  let newLeft = 0;
+  for (const line of String(diffText).split("\n")) {
+    const raw = line.endsWith("\r") ? line.slice(0, -1) : line;
+    if (oldLeft > 0 || newLeft > 0) {
+      if (raw.startsWith("+")) {
+        addLine(cur.newLines, newLine);
+        addLine(cur.oldLines, oldLine);
+        newLine++;
+        newLeft--;
+        continue;
+      }
+      if (raw.startsWith("-")) {
+        addLine(cur.oldLines, oldLine);
+        addLine(cur.newLines, newLine);
+        oldLine++;
+        oldLeft--;
+        continue;
+      }
+      if (raw.startsWith(" ") || raw === "") {
+        oldLine++;
+        newLine++;
+        oldLeft--;
+        newLeft--;
+        continue;
+      }
+      if (raw.startsWith("\\")) continue;
+      oldLeft = 0;
+      newLeft = 0;
+    }
+    if (raw.startsWith("diff --git ")) {
+      pendingOld = undefined;
+      continue;
+    }
+    if (raw.startsWith("--- ")) {
+      pendingOld = sidePath(raw.slice(4), "a/");
+      continue;
+    }
+    if (raw.startsWith("+++ ")) {
+      cur = {
+        oldPath: pendingOld === undefined ? null : pendingOld,
+        newPath: sidePath(raw.slice(4), "b/"),
+        oldLines: new Set(),
+        newLines: new Set(),
+      };
+      files.push(cur);
+      pendingOld = undefined;
+      continue;
+    }
+    const hunk = HUNK_RE.exec(raw);
+    if (hunk && cur) {
+      const oldCount = hunk[2] === undefined ? 1 : Number(hunk[2]);
+      const newCount = hunk[4] === undefined ? 1 : Number(hunk[4]);
+      oldLine = Number(hunk[1]);
+      newLine = Number(hunk[3]);
+      oldLeft = oldCount;
+      newLeft = newCount;
+      if (newCount === 0) addLine(cur.newLines, newLine);
+      if (oldCount === 0) addLine(cur.oldLines, oldLine);
+    }
+  }
+  return files
+    .filter((f) => f.oldPath || f.newPath)
+    .map((f) => ({
+      oldPath: f.oldPath,
+      newPath: f.newPath,
+      oldRanges: toRanges(f.oldLines),
+      newRanges: toRanges(f.newLines),
+    }));
+}
+
+/**
+ * Line ranges per file on one side of the diff. `new` (default) keys by the
+ * new path; a deleted file falls back to its old path. `old` keys by the old
+ * path; an added file falls back to its new path. Pick the side the graph was
+ * built from (`graphSide`): its spans are line numbers in that tree.
+ *
+ * @param {string} diffText - unified diff
+ * @param {"new"|"old"} [side]
+ * @returns {Map<string, Array<{start: number, end: number}>>} in diff order
+ */
+export function parseHunkRanges(diffText, side = "new") {
+  const out = new Map();
+  for (const f of parseDiffFiles(diffText)) {
+    const path = side === "old" ? f.oldPath || f.newPath : f.newPath || f.oldPath;
+    const ranges = side === "old" ? f.oldRanges : f.newRanges;
+    if (ranges.length) out.set(path, ranges);
+  }
+  return out;
+}
+
+/**
+ * Declarations a set of ranges falls in.
+ *
+ * `changed` holds the innermost declaration per range - what a person would
+ * call "the function I edited". `seeds` adds every enclosing declaration, since
+ * references in the graph point at types, not at the methods inside them, and a
+ * walk seeded with the method alone would find no dependents. A range that hits
+ * no declaration (top-level code) seeds its file.
+ *
+ * @param {object} graph
+ * @param {Map<string, Array<{start: number, end: number}>>} ranges
+ * @returns {{changed: object[], seeds: object[], fileLevel: string[], notIndexed: string[]}}
+ */
+export function changedSymbols(graph, ranges) {
+  const files = new Map();
+  const symbolsByPath = new Map();
+  for (const n of graph.nodes) {
+    if (n.kind === "file") files.set(n.path, n);
+    else if (n.kind === "symbol" && n.path) {
+      if (!symbolsByPath.has(n.path)) symbolsByPath.set(n.path, []);
+      symbolsByPath.get(n.path).push(n);
+    }
+  }
+
+  const changed = new Map();
+  const seeds = new Map();
+  const fileLevel = [];
+  const notIndexed = [];
+
+  for (const [path, list] of ranges) {
+    const fileNode = files.get(path);
+    if (!fileNode) {
+      notIndexed.push(path);
+      continue;
+    }
+    const symbols = symbolsByPath.get(path) || [];
+    const spanned = symbols.filter((s) => Number.isInteger(s.endLine));
+    if (symbols.length && !spanned.length) {
+      fileLevel.push(path);
+      seeds.set(fileNode.id, fileNode);
+      continue;
+    }
+    for (const r of list) {
+      const containing = spanned
+        .filter((s) => (s.startLine ?? s.line) <= r.end && s.endLine >= r.start)
+        .sort((a, b) => b.line - a.line);
+      if (!containing.length) {
+        seeds.set(fileNode.id, fileNode);
+        continue;
+      }
+      const inner = containing[0];
+      changed.set(inner.id, inner);
+      for (const s of containing) seeds.set(s.id, s);
+    }
+  }
+
+  return { changed: [...changed.values()], seeds: [...seeds.values()], fileLevel, notIndexed };
+}
+
+function gitOut(root, args) {
+  try {
+    return execFileSync("git", ["-C", root, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * How far the graph is behind the tree. `changedFiles` compares each indexed
+ * file's size and mtime with the manifest written at build time, so an edit
+ * that was never committed counts; `commitMoved` compares the build commit with
+ * HEAD. Either makes the graph stale - an answer from it is about the tree as
+ * it was, and callers say so instead of presenting it as current.
+ *
+ * @param {object} graph
+ * @param {{root?: string}} [opts] - defaults to the root recorded in the graph
+ * @returns {{stale: boolean, commitMoved: boolean|null, baseCommit: string|null, head: string|null, changedFiles: string[], removedFiles: string[]}}
+ */
+export function graphFreshness(graph, { root = graph.root } = {}) {
+  const manifest = graph.manifest || {};
+  const changedFiles = [];
+  const removedFiles = [];
+  for (const [path, prev] of Object.entries(manifest)) {
+    const abs = join(root, path);
+    if (!existsSync(abs)) {
+      removedFiles.push(path);
+      continue;
+    }
+    const st = statSync(abs);
+    if (st.size !== prev.size || Math.floor(st.mtimeMs) !== prev.mtimeMs) changedFiles.push(path);
+  }
+  const head = root ? gitOut(root, ["rev-parse", "HEAD"]) : null;
+  const baseCommit = graph.baseCommit || null;
+  const commitMoved = head && baseCommit ? head !== baseCommit : null;
+  return {
+    stale: Boolean(commitMoved) || changedFiles.length > 0 || removedFiles.length > 0,
+    commitMoved,
+    baseCommit,
+    head,
+    changedFiles: changedFiles.sort(),
+    removedFiles: removedFiles.sort(),
+  };
+}
+
+/**
+ * Which side of a diff the graph's line numbers describe. A graph that matches
+ * the tree at `root` (same HEAD, no file edited since the build) describes the
+ * new side; any other graph was built before the change - on the base checkout,
+ * or before the edit - and its spans are old-side line numbers.
+ *
+ * @param {object} graph
+ * @param {{root?: string}} [opts]
+ * @returns {"new"|"old"}
+ */
+export function graphSide(graph, opts = {}) {
+  return graphFreshness(graph, opts).stale ? "old" : "new";
+}
+
+const REF_RE = /^(?!-)[A-Za-z0-9._/~^@{}-]{1,200}$/;
+
+/**
+ * The unified diff for `<base>` (working tree against base, uncommitted work
+ * included) or `<base>..<head>` (two commits), with no context lines.
+ *
+ * @param {string} root
+ * @param {string} spec
+ * @returns {string}
+ */
+export function diffFor(root, spec) {
+  const parts = String(spec).split("..");
+  if (parts.length > 2 || parts.some((p) => !REF_RE.test(p))) {
+    throw new Error(`not a ref or ref range: ${JSON.stringify(String(spec).slice(0, 80))}`);
+  }
+  const args = [
+    "-C",
+    root,
+    "diff",
+    "-U0",
+    "--no-color",
+    "--no-ext-diff",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    "--end-of-options",
+    ...parts,
+  ];
+  return execFileSync("git", args, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+}

package/pipeline/scripts/bulk-read.sh

@@ -91,11 +91,12 @@ if command -v jq >/dev/null 2>&1; then
 fi
 [ -n "$MODEL" ] || MODEL="${PREF_MODEL:-haiku}"
 
-# Routing picks the rung INSIDE the Anthropic ladder. The worker below is the
-# `claude` CLI, which speaks that ladder and nothing else, so a rung on another
-# provider is refused at dispatch rather than returned and failed. Sending this
-# read to a third-party provider would put the file's full text outside the
-# account that owns it, and that is a decision a user makes, not a default.
+# Routing picks the rung. An Anthropic rung goes to the `claude` CLI below. The
+# `free` rung (route-on --free) goes to the multi-agent-toolkit's verified
+# free-model chain first, and the Anthropic default answers whenever that chain
+# escalates or is unreachable. Sending this read to a free provider puts the
+# file's text outside the account that owns it, which is why it happens only
+# after a user turned it on, and only to providers the data policy allows.
 # An explicit --model still wins: a caller that named a rung asked for that rung.
 if [ -z "${MODEL_EXPLICIT:-}" ] && [ -x "$HERE/../lib/model-dispatch.sh" ]; then
   MODEL=$("$HERE/../lib/model-dispatch.sh" bulk-read \
@@ -104,7 +105,9 @@ fi
 case "$TIMEOUT" in "" ) TIMEOUT="$PREF_TIMEOUT" ;; esac
 case "$TIMEOUT" in ""|*[!0-9]*|0) TIMEOUT=60 ;; esac
 
-command -v claude >/dev/null 2>&1 || degrade "the claude CLI is not on PATH"
+FALLBACK_MODEL="${PREF_MODEL:-haiku}"
+[ "$FALLBACK_MODEL" = "free" ] && FALLBACK_MODEL="haiku"
+[ "$MODEL" = "free" ] || command -v claude >/dev/null 2>&1 || degrade "the claude CLI is not on PATH"
 
 LINES=$(wc -l < "$FILE" | tr -d ' ')
 BYTES=$(wc -c < "$FILE" | tr -d ' ')
@@ -163,7 +166,8 @@ fi
 
 PROMPT_FILE="$(mktemp -t bulk-read.XXXXXX)"
 OUT_FILE="$(mktemp -t bulk-read-out.XXXXXX)"
-trap 'rm -f "$PROMPT_FILE" "$OUT_FILE"' EXIT
+FREE_DIR="$(mktemp -d -t bulk-read-free.XXXXXX)"
+trap 'rm -rf "$PROMPT_FILE" "$OUT_FILE" "$FREE_DIR"' EXIT
 
 # The worker gets numbered lines because every claim it makes has to be
 # addressable afterwards. `nl -ba` numbers blank lines too, so the numbers match
@@ -191,6 +195,90 @@ done
 } > "$PROMPT_FILE"
 
 START=$(date +%s)
+TIMEOUT_BIN=""
+for candidate in timeout gtimeout; do
+  command -v "$candidate" >/dev/null 2>&1 && { TIMEOUT_BIN="$candidate"; break; }
+done
+
+# The free chain gets the same persona, question and numbered lines, and the
+# bulk-reader output schema. The toolkit verifies the answer
+# against the numbered text before it returns it; the range check below adds
+# what only this script knows, the file's line count. Anything short of a
+# verified, in-range answer hands the read to the Anthropic default.
+FREE_DONE=0
+if [ "$MODEL" = "free" ]; then
+  FREE_REASON=""
+  _MA_TL="$(dirname "${BASH_SOURCE[0]}")/../lib/toolkit-llm.sh"
+  [ -f "$_MA_TL" ] || _MA_TL="$HOME/.claude/lib/toolkit-llm.sh"
+  FREE_SCHEMA="$HERE/../schemas/bulk-read-output.schema.json"
+  if [ -f "$_MA_TL" ] && [ -f "$FREE_SCHEMA" ]; then
+    . "$_MA_TL"
+    # The sandbox of an unattended run denies writes under ~/.claude, where the
+    # toolkit keeps its quota and usage files by default.
+    if [ "${MULTI_AGENT_UNATTENDED:-}" = "1" ] && [ -z "${MCP_TOOLKIT_INDEX_DIR:-}" ]; then
+      export MCP_TOOLKIT_INDEX_DIR="$HOME/.multi-agent-unattended/toolkit-index"
+    fi
+    nl -ba "$FILE" > "$FREE_DIR/numbered.txt"
+    FREE_PROMPT="$(awk 'BEGIN{fm=0} /^---$/{fm++; next} fm>=2{print}' "$PERSONA")
+<question>
+$QUESTION
+</question>
+The SOURCE is the file $FILE with its $LINES lines numbered."
+    ALLOW_FLAG=""
+    for prefs in "${MULTI_AGENT_PREFS:-}" "$HOME/.claude/multi-agent-preferences.json" "$HOME/.config/multi-agent-pipeline/multi-agent-preferences.json"; do
+      [ -n "$prefs" ] && [ -f "$prefs" ] || continue
+      [ "$(jq -r '.global.modelRouting.free.allowTraining // false' "$prefs" 2>/dev/null)" = "true" ] && ALLOW_FLAG="--allow-training"
+      break
+    done
+    if [ -n "$TIMEOUT_BIN" ]; then
+      "$TIMEOUT_BIN" "$TIMEOUT" bash -c '. "$1"; shift; ma_toolkit_llm "$@"' _ "$_MA_TL" delegate --task summarize \
+        --prompt "$FREE_PROMPT" --path "$FREE_DIR/numbered.txt" --schema "$FREE_SCHEMA" \
+        --max-tokens 2048 $ALLOW_FLAG > "$FREE_DIR/result.json" 2>/dev/null
+    else
+      ma_toolkit_llm delegate --task summarize --prompt "$FREE_PROMPT" --path "$FREE_DIR/numbered.txt" \
+        --schema "$FREE_SCHEMA" --max-tokens 2048 $ALLOW_FLAG > "$FREE_DIR/result.json" 2>/dev/null
+    fi
+    FREE_STATUS=$?
+    case "$FREE_STATUS" in
+      0)
+        if LINES="$LINES" python3 - "$FREE_DIR/result.json" "$OUT_FILE" <<'PYEOF'
+import json, os, sys
+r = json.load(open(sys.argv[1]))
+v = r.get("value")
+n = int(os.environ["LINES"])
+ok = isinstance(v, dict)
+for reg in (v or {}).get("regions") or []:
+    ok = ok and 1 <= reg.get("start", 0) <= reg.get("end", 0) <= n
+for sym in (v or {}).get("symbols") or []:
+    ok = ok and 1 <= sym.get("line", 0) <= n
+if not ok:
+    sys.exit(1)
+json.dump(v, open(sys.argv[2], "w"))
+open(sys.argv[2] + ".via", "w").write("free:%s/%s" % (r.get("provider"), r.get("model")))
+PYEOF
+        then
+          FREE_DONE=1
+          MODEL=$(cat "$OUT_FILE.via"); rm -f "$OUT_FILE.via"
+        else
+          FREE_REASON="the free answer cited lines outside 1-$LINES"
+        fi ;;
+      3) FREE_REASON="no free provider produced a verified answer" ;;
+      124) FREE_REASON="the free chain did not answer within ${TIMEOUT}s" ;;
+      *) FREE_REASON="the free chain is unavailable (exit $FREE_STATUS)" ;;
+    esac
+  else
+    FREE_REASON="toolkit-llm.sh or the bulk-read output schema is not installed"
+  fi
+  [ -x "$HERE/log-metric.sh" ] && \
+    "$HERE/log-metric.sh" "${MULTI_AGENT_TASK_ID:-unknown}" "$PHASE" bulk_read.free \
+      outcome="$([ "$FREE_DONE" = 1 ] && echo verified || echo escalated)" reason="${FREE_REASON:-ok}" >/dev/null 2>&1
+  if [ "$FREE_DONE" != 1 ]; then
+    echo "bulk-read: free chain not used ($FREE_REASON); reading on $FALLBACK_MODEL" >&2
+    MODEL="$FALLBACK_MODEL"
+    command -v claude >/dev/null 2>&1 || degrade "the claude CLI is not on PATH"
+  fi
+fi
+
 # `claude -p` reads the prompt from stdin; the model flag names the rung. A
 # non-zero exit, an empty answer and a non-JSON answer are all degradations, and
 # each one names itself rather than falling through to a generic failure.
@@ -198,11 +286,9 @@ START=$(date +%s)
 # GNU spelling would leave the budget silently unenforced on the platform most of
 # these runs happen on - a pref that does nothing, which is the class
 # smoke-prefs-consumed exists to catch.
-TIMEOUT_BIN=""
-for candidate in timeout gtimeout; do
-  command -v "$candidate" >/dev/null 2>&1 && { TIMEOUT_BIN="$candidate"; break; }
-done
-if [ -n "$TIMEOUT_BIN" ]; then
+if [ "$FREE_DONE" = 1 ]; then
+  STATUS=0
+elif [ -n "$TIMEOUT_BIN" ]; then
   "$TIMEOUT_BIN" "$TIMEOUT" claude -p --model "$MODEL" < "$PROMPT_FILE" > "$OUT_FILE" 2>/dev/null
   STATUS=$?
 else

package/pipeline/scripts/capture-flush.sh

@@ -110,8 +110,37 @@ fi
 # Phase 4 removes the worktree once the PR is open, so the salvaged copy under
 # artifactsPath is tried FIRST. Reading the worktree path first would degrade
 # silently for exactly the runs this script exists to rescue.
+#
+# After those, each worktree's newest `.pipeline/triage-round-<N>.json`: Phase 3
+# writes every round there itself, and the copy to triage-output.json is a
+# separate step a run can die before. A multi-repo run names its worktrees only
+# under projects[], so those are read too, and the state directory last.
+newest_round() {
+  [ -d "$1/.pipeline" ] || return 0
+  ls -t "$1"/.pipeline/triage-round-*.json 2>/dev/null | head -1
+}
+WORKTREES=$( { [ -n "$WORKTREE" ] && printf '%s\n' "$WORKTREE"; jq -r '.projects[]?.worktreePath // empty' "$STATE" 2>/dev/null; } | awk 'NF && !seen[$0]++')
 TRIAGE=""
-for cand in "${ARTIFACTS:+$ARTIFACTS/triage-output.json}" "${WORKTREE:+$WORKTREE/triage-output.json}"; do
+CANDIDATES=("${ARTIFACTS:+$ARTIFACTS/triage-output.json}")
+# Within one worktree the newer of the copy and the newest round wins: a run
+# that died before the copy step leaves the previous round in the copy.
+newest_in_worktree() {
+  local copy="$1/triage-output.json" round
+  round=$(newest_round "$1")
+  if [ -f "$copy" ] && [ -n "$round" ]; then
+    ls -t "$copy" "$round" 2>/dev/null | head -1
+  elif [ -f "$copy" ]; then
+    printf '%s\n' "$copy"
+  else
+    printf '%s\n' "$round"
+  fi
+}
+while IFS= read -r wt; do
+  [ -n "$wt" ] || continue
+  CANDIDATES+=("$(newest_in_worktree "$wt")")
+done <<< "$WORKTREES"
+CANDIDATES+=("$(dirname "$STATE")/triage-output.json")
+for cand in "${CANDIDATES[@]}"; do
   [ -n "$cand" ] && [ -f "$cand" ] && { TRIAGE="$cand"; break; }
 done
 
@@ -136,12 +165,38 @@ run_store() {
   esac
 }
 
+# The store is named after the run's repository, never after the directory this
+# script happens to run in: a SessionEnd hook fires wherever the session was.
+# A live worktree resolves to its main checkout's folder, the same name the
+# readers derive; otherwise the project recorded in the state.
+slug_of_worktree() {
+  [ -d "$1" ] || return 0
+  local main
+  main=$(git -C "$1" worktree list --porcelain 2>/dev/null | sed -n '1s/^worktree //p')
+  [ -n "$main" ] || return 0
+  basename "$main" .git
+}
+SLUG=""
+while IFS= read -r wt; do
+  [ -n "$wt" ] && [ -z "$SLUG" ] && SLUG=$(slug_of_worktree "$wt")
+done <<< "$WORKTREES"
+plain_slug() {
+  case "$1" in
+    "" | .* | *[!A-Za-z0-9._-]*) return 0 ;;
+  esac
+  printf '%s' "$1"
+}
+SLUG=$(plain_slug "$SLUG")
+[ -n "$SLUG" ] || SLUG=$(plain_slug "$(jq -r '.project // .projects[0].name // empty' "$STATE" 2>/dev/null)")
+SLUG_ARGS=()
+[ -n "$SLUG" ] && SLUG_ARGS=(--repo-slug "$SLUG")
+
 if [ -n "$TRIAGE" ]; then
   INGESTED=$(run_store ingest \
-    node "$SCRIPTS/triage-memory.mjs" ingest --triage "$TRIAGE" --state "$STATE")
+    node "$SCRIPTS/triage-memory.mjs" ingest --triage "$TRIAGE" --state "$STATE" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
   if [ -n "$TASK_ID" ]; then
     DISTILLED=$(run_store distill \
-      node "$SCRIPTS/learnings-ledger.mjs" from-triage --triage "$TRIAGE" --task "$TASK_ID")
+      node "$SCRIPTS/learnings-ledger.mjs" from-triage --triage "$TRIAGE" --task "$TASK_ID" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
   fi
 fi
 

package/pipeline/scripts/cost-table.json

@@ -1,5 +1,5 @@
 {
-  "_readme": "Per-model unit prices in USD per million tokens. Source: Anthropic public pricing (Claude-family rows verified 2026-07-28 against the current model table; the gpt-* rows remain approximate). Update when Anthropic publishes new tiers. Rung names (fable / opus / sonnet / haiku) are the pipeline's stable identifiers and `modelId` is the wire value they currently resolve to - dispatch reads the rung, so a generation move is a `modelId` edit here plus the phase specs, never a rename of the rungs. `provider` says which layer a rung belongs to: an `anthropic` rung is reachable from every call site, a non-anthropic one only from the call sites the pipeline makes itself (bulk-read, research), which is what model-dispatch.sh enforces. Unknown models render USD as ' - ' and emit a footnote  -  never block PR-body generation. cacheReadPerMtok is the discounted rate for prompt-cache hits (~10% of inPerMtok); the renderer prices a phase's tokens_cached at this rate when the tracker records it, so resume/cache reuse is visible in the ledger.",
+  "_readme": "Per-model unit prices in USD per million tokens. Source: Anthropic public pricing (Claude-family rows verified 2026-07-28 against the current model table; the gpt-* rows remain approximate). Update when Anthropic publishes new tiers. Rung names (fable / opus / sonnet / haiku) are the pipeline's stable identifiers and `modelId` is the wire value they currently resolve to - dispatch reads the rung, so a generation move is a `modelId` edit here plus the phase specs, never a rename of the rungs. `provider` says which layer a rung belongs to: an `anthropic` rung is reachable from every call site; `free-chain` (the `free` rung) only from bulk-read and delegate, where the multi-agent-toolkit's verified free-model chain answers and the caller's default takes over when it escalates; any other provider from no call site. model-dispatch.sh enforces this. Unknown models render USD as ' - ' and emit a footnote  -  never block PR-body generation. cacheReadPerMtok is the discounted rate for prompt-cache hits (~10% of inPerMtok); the renderer prices a phase's tokens_cached at this rate when the tracker records it, so resume/cache reuse is visible in the ledger.",
   "schemaVersion": "1.1.0",
   "prices": {
     "fable": {
@@ -57,6 +57,14 @@
       "modelId": "gpt-5.6-terra",
       "provider": "openai",
       "note": "Codex CLI floor tier  -  speed-optimised, maps the haiku rung of the Codex persona tier map (task-clarifier). Approximate; verify against OpenAI pricing before relying on totals."
+    },
+    "free": {
+      "inPerMtok": 0.0,
+      "outPerMtok": 0.0,
+      "cacheReadPerMtok": 0.0,
+      "modelId": "free-chain",
+      "provider": "free-chain",
+      "note": "Layer 2: the multi-agent-toolkit's verified free-model chain (llm_delegate / multi-agent-toolkit-llm) over free tiers - Groq, Mistral, Gemini, OpenRouter free models, Z.AI GLM Flash, local Ollama. Priced at zero because the provider bills nothing on a free tier; what it saves is reported by route-status from the toolkit's usage log at the rate of the rung it replaced."
     }
   }
 }