@mmerterden/multi-agent-pipeline 16.25.0 → 16.27.0

package/pipeline/scripts/learn-from-transcripts.mjs

@@ -0,0 +1,625 @@
+#!/usr/bin/env node
+/**
+ * @file learn-from-transcripts.mjs  -  lessons the model never noticed.
+ *
+ * WHY THIS EXISTS
+ *
+ * Phase 7 asks a subagent to read the run log and propose a few memory entries.
+ * That works for what the model noticed, and it is structurally blind to what it
+ * did not: the same wrong path tried in three sessions, the command that fails
+ * every time until its `--flag` variant is used, the directory that never has
+ * the answer. Those are the repetitions worth capturing, and a model that missed
+ * them once misses them again on the read-back.
+ *
+ * So this correlates instead of interpreting. It reads the raw transcripts, pairs
+ * each failure with whatever succeeded next in the same shape, and writes the
+ * difference. No model runs. The output is deterministic - the same transcripts
+ * produce the same lessons, which is also what makes it testable.
+ *
+ * FIVE CORRELATIONS
+ *
+ *   path-correction   a read of X failed, a read of a same-named file elsewhere
+ *                     then succeeded    -> fact
+ *   environment       a command failed repeatedly and a variant of it worked
+ *                     -> convention
+ *   search-scope      a search returned nothing, a wider one then returned hits
+ *                     -> fact
+ *   refused-pattern   a tool call the user denied, repeatedly
+ *                     -> rejected-preference
+ *   large-file        a read that tripped the read-size threshold  -> fact
+ *
+ * PRIVACY
+ *
+ * Two independent defenses, because a transcript holds whatever the session read.
+ *
+ *   1. Structural. A statement is assembled from tokens this script chose - a
+ *      path, a command's head word, a count. It never concatenates free text out
+ *      of the transcript, so there is no route by which a value becomes a
+ *      statement.
+ *   2. Belt and braces. Every candidate is written to a temp file and run
+ *      through `pre-commit-check.sh --scan-file` before it can reach the ledger.
+ *      A hit is dropped, counted and reported - never written. The patterns live
+ *      in that script alone; copying them here would produce the copy that stops
+ *      matching whatever it later gains.
+ *
+ * A turn whose user message contains a <private> block is skipped whole.
+ *
+ * Usage:
+ *   ./learn-from-transcripts.mjs [--dir <transcripts>] [--repo-slug <slug>]
+ *                                [--since-days N] [--json] [--apply]
+ *
+ * Default is DRY RUN: nothing is written without --apply.
+ *
+ * Exit: 0 ok (including "nothing found") | 1 usage
+ */
+
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { execFileSync } from "node:child_process";
+import { basename, dirname, join } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const argv = process.argv.slice(2);
+const flags = {};
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i];
+  if (!a.startsWith("--")) continue;
+  const k = a.slice(2);
+  flags[k] = argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[++i] : true;
+}
+const APPLY = flags.apply === true;
+const JSON_OUT = flags.json === true;
+
+function repoSlug() {
+  if (typeof flags["repo-slug"] === "string") return flags["repo-slug"];
+  try {
+    const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (top) return basename(top);
+  } catch {
+    /* not a repo; fall through */
+  }
+  return basename(process.cwd());
+}
+
+function transcriptDir() {
+  if (typeof flags.dir === "string") return flags.dir;
+  const slug = process.cwd().replace(/[^A-Za-z0-9]/g, "-");
+  return join(homedir(), ".claude", "projects", slug);
+}
+
+/* ------------------------------------------------------------------ reading */
+
+/** One flat, ordered list of events. Everything downstream is a walk over it. */
+function readEvents(file) {
+  const events = [];
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return events;
+  }
+  const pending = new Map();
+  let skipTurn = false;
+
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let d;
+    try {
+      d = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const content = (d.message || {}).content;
+
+    // A <private> block in a user message takes the whole turn out of scope.
+    // The user marked it; nothing from it is mined, not even the shape.
+    if (d.type === "user") {
+      const raw =
+        typeof content === "string"
+          ? content
+          : Array.isArray(content)
+            ? content.map((b) => (b && b.text) || "").join(" ")
+            : "";
+      if (raw.includes("<private>")) skipTurn = true;
+      else if (raw.trim()) skipTurn = false;
+    }
+    if (skipTurn || !Array.isArray(content)) continue;
+
+    for (const b of content) {
+      if (!b || typeof b !== "object") continue;
+      if (b.type === "tool_use") {
+        pending.set(b.id, { name: b.name || "?", input: b.input || {} });
+      } else if (b.type === "tool_result") {
+        const call = pending.get(b.tool_use_id);
+        pending.delete(b.tool_use_id);
+        if (!call) continue;
+        const c = b.content;
+        const out = Array.isArray(c)
+          ? c.map((x) => (x && x.text) || "").join(" ")
+          : typeof c === "string"
+            ? c
+            : "";
+        events.push({
+          tool: call.name,
+          input: call.input,
+          isError: Boolean(b.is_error),
+          denied: out.includes("has been denied"),
+          empty: out.trim().length === 0,
+          outLen: out.length,
+        });
+      }
+    }
+  }
+  return events;
+}
+
+/* --------------------------------------------------------------- extraction */
+
+/** The path a call reads, whichever tool did the reading. */
+function readPath(e) {
+  if (e.tool === "Read") return typeof e.input.file_path === "string" ? e.input.file_path : null;
+  if (e.tool !== "Bash") return null;
+  const cmd = typeof e.input.command === "string" ? e.input.command : "";
+  // Single-line invocations only, and the captured token has to look like a
+  // path. Reading the first word after `cat` out of a multi-line script yielded
+  // things like `SKILL.md;` - a shell fragment presented as a file.
+  const first = cmd.trim().split("\n")[0];
+  if (/[;&|]/.test(first)) return null;
+  const m = /^\s*(?:cat|head|tail|sed -n \S+)\s+(?:-\S+\s+)*("[^"]+"|'[^']+'|\S+)\s*$/.exec(first);
+  if (!m) return null;
+  const p = m[1].replace(/^["']|["']$/g, "");
+  if (p.startsWith("-") || /[;&|<>*?$`]/.test(p)) return null;
+  return p;
+}
+
+// Shell syntax is not a program. An early version mined `export`, `set`, `for`
+// and `echo` as environment facts, which is what happens when the first token of
+// a multi-line script is treated as a command name.
+const SHELL_WORDS = new Set([
+  "export",
+  "set",
+  "for",
+  "while",
+  "do",
+  "done",
+  "if",
+  "then",
+  "else",
+  "fi",
+  "case",
+  "esac",
+  "echo",
+  "printf",
+  "local",
+  "return",
+  "source",
+  "unset",
+  "read",
+  "shift",
+  "trap",
+  "eval",
+  "true",
+  "false",
+  "wait",
+  "sleep",
+  "cd",
+]);
+
+function headWord(cmd) {
+  if (typeof cmd !== "string") return null;
+  // Only the FIRST line is a candidate. A heredoc or a multi-line script has no
+  // single command name, and pretending otherwise is where the path fragments
+  // came from.
+  const first = cmd.trim().split("\n")[0];
+  const toks = first.trim().split(/\s+/);
+  for (let i = 0; i < toks.length; i++) {
+    const t = toks[i];
+    if (["sudo", "env", "time", "command", "exec"].includes(t)) continue;
+    if (t === "cd" || t === "pushd") {
+      i++;
+      continue;
+    }
+    if (["&&", ";", "|", "\\"].includes(t)) continue;
+    if (/^[-/$({"'!]/.test(t)) return null;
+    if (t.includes("=")) return null; // VAR=value, an assignment
+    const base = t.split("/").pop();
+    if (!/^[a-z][a-z0-9_.-]{0,31}$/.test(base)) return null;
+    return SHELL_WORDS.has(base) ? null : base;
+  }
+  return null;
+}
+
+function searchPath(e) {
+  if (e.tool === "Grep" || e.tool === "Glob") {
+    return typeof e.input.path === "string" ? e.input.path : null;
+  }
+  return null;
+}
+
+function mine(events) {
+  const found = [];
+  const seen = new Set();
+  const push = (kind, statement, scope, diagnosis) => {
+    const key = `${kind}::${statement}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    found.push({ kind, statement, scope: scope || "global", diagnosis: diagnosis || null });
+  };
+
+  // 1. path correction: a failed read, then a successful read of the same
+  //    basename somewhere else. The basename is the join key - a rename would
+  //    not be a correction, a relocation is.
+  const failedReads = [];
+  for (const e of events) {
+    const p = readPath(e);
+    if (!p) continue;
+    if (e.isError) {
+      failedReads.push(p);
+      continue;
+    }
+    const hit = failedReads.find((f) => basename(f) === basename(p) && f !== p);
+    if (hit) {
+      push(
+        "fact",
+        `${basename(p)} lives at ${p}, not ${hit}`,
+        p,
+        `a read of ${hit} failed and the same file resolved at ${p}`,
+      );
+      failedReads.splice(failedReads.indexOf(hit), 1);
+    }
+  }
+
+  // 2. environment: the SAME command, character for character, failing again and
+  //    again - and then a different invocation of the same program working.
+  //
+  //    An earlier version grouped by program name and fired at two failures. It
+  //    mined "`ls` failed twice", "`cat` failed twice", "`chmod` failed twice" -
+  //    ordinary exploration hitting files that were not there, presented as
+  //    durable environment facts. Grouping by the exact text is what separates
+  //    "I looked for something that did not exist" from "this invocation does
+  //    not work here", and the threshold is 3 because two is still a coincidence.
+  const REPEAT_THRESHOLD = 3;
+  const sameCmdFail = new Map();
+  const progOk = new Set();
+  for (const e of events) {
+    if (e.tool !== "Bash") continue;
+    const raw = typeof e.input.command === "string" ? e.input.command : "";
+    const norm = raw.trim().split("\n")[0].replace(/\s+/g, " ");
+    const h = headWord(raw);
+    if (!h || !norm) continue;
+    if (e.isError) {
+      const cur = sameCmdFail.get(norm) || { n: 0, head: h };
+      cur.n += 1;
+      sameCmdFail.set(norm, cur);
+    } else {
+      progOk.add(h);
+    }
+  }
+  // The command text is intentionally not read here: it is the one part of
+  // this correlation that could carry an argument, so it stays out of the
+  // statement entirely.
+  for (const [_norm, { n, head }] of sameCmdFail) {
+    if (n < REPEAT_THRESHOLD || !progOk.has(head)) continue;
+    // The statement names the program and the count, never the command text:
+    // the text is the one part of this that could carry an argument.
+    push(
+      "convention",
+      `the same \`${head}\` invocation failed ${n} times here before a different one worked - check the form against this repo first`,
+      "global",
+      "an identical command repeated and kept failing",
+    );
+  }
+
+  // 3. search scope: an empty search, then a hit from a wider path. Only counted
+  //    when the later path is a prefix of the earlier one, which is what makes
+  //    "wider" mechanical rather than a guess.
+  const emptySearch = [];
+  for (const e of events) {
+    if (e.tool !== "Grep" && e.tool !== "Glob") continue;
+    const p = searchPath(e);
+    if (!p) continue;
+    if (e.empty || e.isError) {
+      emptySearch.push(p);
+      continue;
+    }
+    const narrower = emptySearch.find((q) => q !== p && q.startsWith(p));
+    if (narrower) {
+      push("fact", `searching ${narrower} alone misses matches that ${p} finds`, p);
+      emptySearch.splice(emptySearch.indexOf(narrower), 1);
+    }
+  }
+
+  // 4. refused pattern: the user said no, more than once, to the same tool.
+  //    A single refusal is a moment; a repeat is a preference.
+  const denied = new Map();
+  for (const e of events) {
+    if (!e.denied) continue;
+    // A refusal whose program cannot be named is not a lesson: "Bash:? was
+    // refused" tells a future run nothing it can act on.
+    let key = e.tool;
+    if (e.tool === "Bash") {
+      const h = headWord(e.input.command);
+      if (!h) continue;
+      key = `Bash:${h}`;
+    }
+    denied.set(key, (denied.get(key) || 0) + 1);
+  }
+  for (const [key, n] of denied) {
+    if (n >= 2) {
+      push(
+        "rejected-preference",
+        `${key} was refused ${n} times - propose it before running it`,
+        "global",
+        "the user declined the same call repeatedly",
+      );
+    }
+  }
+
+  // 5. large file: a read whose output is big enough that the next one should be
+  //    ranged. The threshold matches check-read-size.sh's own default.
+  const BIG = 100000;
+  const bigSeen = new Set();
+  for (const e of events) {
+    const p = readPath(e);
+    if (!p || e.isError || e.outLen < BIG || bigSeen.has(p)) continue;
+    bigSeen.add(p);
+    push("fact", `${p} is large - read it with an offset and limit, not whole`, p);
+  }
+
+  return found;
+}
+
+/* ----------------------------------------------------------------- privacy */
+
+/**
+ * The single-source secret check. Candidates go to a temp file and through
+ * pre-commit-check.sh, which owns the patterns; a hit is dropped, never written.
+ */
+function dropSecrets(items) {
+  const scanner = existsSync(join(HERE, "pre-commit-check.sh"))
+    ? join(HERE, "pre-commit-check.sh")
+    : join(homedir(), ".claude", "scripts", "pre-commit-check.sh");
+  if (!existsSync(scanner)) {
+    return { kept: items, dropped: 0, scanned: false };
+  }
+  const dir = mkdtempSync(join(tmpdir(), "lft-"));
+  const kept = [];
+  let dropped = 0;
+  try {
+    for (const it of items) {
+      const f = join(dir, "candidate.txt");
+      writeFileSync(f, `${it.statement}\n${it.diagnosis || ""}\n${it.scope}\n`);
+      let clean = true;
+      try {
+        execFileSync("bash", [scanner, "--scan-file", f], { stdio: "ignore" });
+      } catch {
+        clean = false;
+      }
+      if (clean) kept.push(it);
+      else dropped++;
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  return { kept, dropped, scanned: true };
+}
+
+/* -------------------------------------------------------------------- main */
+
+function main() {
+  const dir = transcriptDir();
+  if (!existsSync(dir)) {
+    const out = { status: "noop", reason: "no-transcripts", dir };
+    process.stdout.write(JSON_OUT ? JSON.stringify(out) + "\n" : `no transcripts under ${dir}\n`);
+    return;
+  }
+
+  const sinceDays = Number(flags["since-days"] || 30);
+  const cutoff = Date.now() - sinceDays * 86400000;
+  const files = readdirSync(dir)
+    .filter((f) => f.endsWith(".jsonl"))
+    .map((f) => join(dir, f))
+    .filter((f) => {
+      try {
+        return statSync(f).mtimeMs >= cutoff;
+      } catch {
+        return false;
+      }
+    });
+
+  // Count what was examined, not just what was found. Zero lessons from zero
+  // events and zero lessons from fifty thousand are different facts, and a miner
+  // that reports only the second number cannot tell you which one it is looking
+  // at - the same ambiguity the observation store's SCAN BROKEN guard exists for.
+  let all = [];
+  let examined = 0;
+  for (const f of files) {
+    const events = readEvents(f);
+    examined += events.length;
+    all = all.concat(mine(events));
+  }
+
+  // Same lesson from two transcripts is one lesson.
+  const uniq = [];
+  const seenKey = new Set();
+  for (const it of all) {
+    const k = `${it.kind}::${it.statement}`;
+    if (seenKey.has(k)) continue;
+    seenKey.add(k);
+    uniq.push(it);
+  }
+
+  const { kept, dropped, scanned } = dropSecrets(uniq);
+  const slug = repoSlug();
+
+  let written = 0;
+  let deduped = 0;
+  if (APPLY && kept.length) {
+    const ledger = existsSync(join(HERE, "learnings-ledger.mjs"))
+      ? join(HERE, "learnings-ledger.mjs")
+      : join(homedir(), ".claude", "scripts", "learnings-ledger.mjs");
+    for (const it of kept) {
+      const args = [
+        ledger,
+        "add",
+        "--kind",
+        it.kind,
+        "--statement",
+        it.statement,
+        "--scope",
+        it.scope,
+        "--source",
+        "transcript-mining",
+        "--confidence",
+        "low",
+        "--repo-slug",
+        slug,
+      ];
+      if (it.diagnosis) args.push("--diagnosis", it.diagnosis);
+      try {
+        execFileSync("node", args, { stdio: "ignore" });
+        written++;
+      } catch (e) {
+        // exit 2 is the ledger's "already known", which is a success here.
+        if (e && e.status === 2) deduped++;
+      }
+    }
+  }
+
+  /**
+   * Render the lessons into a marked block in CLAUDE.local.md.
+   *
+   * The ledger is where a phase reads them; this file is where a PERSON does. The
+   * markers make the write idempotent: a re-run replaces what is between them and
+   * touches nothing else, so a hand-written note above the block survives every
+   * future run. Without them the choice is append (a file that grows forever) or
+   * overwrite (a file nobody dares edit).
+   *
+   * `.local.md` because these are facts about THIS checkout on THIS machine - a
+   * path that resolved here, a command that failed here. The gitignore guard is
+   * the same one memory-save.sh applies, for the same reason.
+   */
+  function writeLocalBlock(items) {
+    const START = "<!-- multi-agent:learn:start -->";
+    const END = "<!-- multi-agent:learn:end -->";
+    let root;
+    try {
+      root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim();
+    } catch {
+      return null;
+    }
+    if (!root) return null;
+
+    const file = join(root, "CLAUDE.local.md");
+    const body = [
+      START,
+      "## Learned from past sessions",
+      "",
+      "Mined mechanically by `learn-from-transcripts.mjs` - each line is a correlation",
+      "between something that failed and whatever worked next, never a model's opinion.",
+      "Delete a line that has stopped being true; the next run will not put it back",
+      "unless the transcripts still say it.",
+      "",
+      ...items.map((it) => `- **${it.kind}**: ${it.statement}`),
+      END,
+    ].join("\n");
+
+    let text = existsSync(file) ? readFileSync(file, "utf8") : "";
+    if (text.includes(START) && text.includes(END)) {
+      const head = text.slice(0, text.indexOf(START));
+      const tail = text.slice(text.indexOf(END) + END.length);
+      text = head + body + tail;
+    } else {
+      text = (text.trimEnd() + "\n\n" + body + "\n").trimStart();
+    }
+    writeFileSync(file, text.endsWith("\n") ? text : text + "\n");
+
+    // Never commit machine-local facts. Same guard memory-save.sh applies.
+    const gi = join(root, ".gitignore");
+    const line = "CLAUDE.local.md";
+    let ignored = false;
+    try {
+      ignored = readFileSync(gi, "utf8")
+        .split("\n")
+        .some((l) => l.trim() === line);
+    } catch {
+      /* no .gitignore yet */
+    }
+    if (!ignored) {
+      const prev = existsSync(gi) ? readFileSync(gi, "utf8") : "";
+      writeFileSync(
+        gi,
+        `${prev.trimEnd()}\n\n# Machine-local learned facts - never commit.\n${line}\n`.trimStart(),
+      );
+    }
+    return file;
+  }
+
+  let localFile = null;
+  if (APPLY && kept.length) localFile = writeLocalBlock(kept);
+
+  // Record how many lessons the machine found, kept apart from the ones a model
+  // proposed. Pooling them lets a "lessons learned" number climb while the half
+  // that actually prevents a repeat stays flat.
+  if (APPLY && written > 0) {
+    const logger = existsSync(join(HERE, "log-metric.sh"))
+      ? join(HERE, "log-metric.sh")
+      : join(homedir(), ".claude", "scripts", "log-metric.sh");
+    if (existsSync(logger)) {
+      try {
+        execFileSync("bash", [logger, "unknown", "7", "learning.mined", `rows=${written}`], {
+          stdio: "ignore",
+        });
+      } catch {
+        /* a metric that cannot be written is never a reason to fail the mine */
+      }
+    }
+  }
+
+  const result = {
+    status: "ok",
+    repo: slug,
+    transcripts: files.length,
+    toolResultsExamined: examined,
+    candidates: uniq.length,
+    droppedBySecretScan: dropped,
+    secretScanRan: scanned,
+    applied: APPLY,
+    written,
+    deduped,
+    localFile,
+    learnings: kept,
+  };
+
+  if (JSON_OUT) {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  } else if (kept.length === 0) {
+    process.stdout.write(
+      `${files.length} transcript(s), ${examined} tool result(s) examined, nothing new to learn\n`,
+    );
+  } else {
+    process.stdout.write(
+      `${files.length} transcript(s) read, ${kept.length} candidate lesson(s)` +
+        `${dropped ? `, ${dropped} dropped by the secret scan` : ""}` +
+        `${APPLY ? ` - ${written} written, ${deduped} already known` : " (dry run; pass --apply to write)"}\n`,
+    );
+    for (const it of kept) process.stdout.write(`  [${it.kind}] ${it.statement}\n`);
+  }
+}
+
+main();

package/pipeline/scripts/learning-curve.mjs

@@ -8,7 +8,9 @@
 //
 // Buckets tasks by the timestamp of their first event, then per bucket reports:
 //   tasks, first-pass-clean rate, avg review cycles, rework/task,
-//   tokens/task, cache-reuse ratio, memory-recall precision. Prints a
+//   tokens/task, cache-reuse ratio, memory-recall precision, mined lessons per
+//   task (learn-from-transcripts.mjs) and bytes saved by structural offload
+//   (crush-json.mjs). Prints a
 //   first->last trend for the headline KPIs. Read-only, zero deps, no API/model calls.
 //
 // Usage:
@@ -75,6 +77,8 @@ for (const e of events) {
       tokensCached: 0,
       memInjected: 0,
       memUsed: 0,
+      minedLessons: 0,
+      offloadSaved: 0,
     };
     tasks.set(id, t);
   }
@@ -98,6 +102,13 @@ for (const e of events) {
   // the case the instruction invites. An ABSENT rows field still means one hit
   // (the event happened); a present zero means zero.
   if (e.event === "memory.hit") t.memUsed += d.rows === undefined ? 1 : num(d.rows);
+  // Two things the loop learned to count once the pipeline started producing
+  // them. They are kept apart from the model-written lessons on purpose: a
+  // machine-mined path correction and a model's architectural claim are
+  // different evidence, and a single "lessons learned" number can climb while
+  // the half that actually helps stays flat.
+  if (e.event === "learning.mined") t.minedLessons += d.rows === undefined ? 1 : num(d.rows);
+  if (e.event === "offload.crushed") t.offloadSaved += num(d.saved_bytes);
   t.tokensIn += num(d.tokens_in);
   t.tokensOut += num(d.tokens_out);
   t.tokensCached += num(d.tokens_cached);
@@ -132,6 +143,8 @@ const buckets = [...byBucket.keys()].sort().map((start) => {
   const totCached = list.reduce((s, t) => s + t.tokensCached, 0);
   const totInjected = list.reduce((s, t) => s + t.memInjected, 0);
   const totUsed = list.reduce((s, t) => s + t.memUsed, 0);
+  const totMined = list.reduce((s, t) => s + t.minedLessons, 0);
+  const totSaved = list.reduce((s, t) => s + t.offloadSaved, 0);
   return {
     bucketStart: start,
     tasks: n,
@@ -143,6 +156,11 @@ const buckets = [...byBucket.keys()].sort().map((start) => {
     tokensPerTask: Math.round((totIn + totOut) / n),
     cacheRatio: totIn + totCached ? round(totCached / (totIn + totCached)) : null,
     memoryPrecision: totInjected ? round(totUsed / totInjected) : null,
+    // null, not 0, when nothing was recorded: "no data" and "measured zero" are
+    // different answers, and a chart that draws them the same way invites the
+    // wrong conclusion about a feature that was simply never switched on.
+    minedLessonsPerTask: totMined ? round(totMined / n) : null,
+    offloadBytesSavedPerTask: totSaved ? Math.round(totSaved / n) : null,
   };
 });
 
@@ -179,12 +197,12 @@ const arrow = (v, goodIsUp) => {
 };
 console.log(`# Learning curve (${opts.bucketDays}-day buckets)\n`);
 console.log(
-  "| Bucket | Tasks | First-pass clean | Avg review cycles | Rework/task | Tokens/task | Cache ratio | Memory precision |",
+  "| Bucket | Tasks | First-pass clean | Avg review cycles | Rework/task | Tokens/task | Cache ratio | Memory precision | Mined lessons/task | Offload bytes saved/task |",
 );
-console.log("|---|---|---|---|---|---|---|---|");
+console.log("|---|---|---|---|---|---|---|---|---|---|");
 for (const b of buckets) {
   console.log(
-    `| ${b.bucketStart} | ${b.tasks} | ${b.firstPassCleanRate ?? "-"} | ${b.avgReviewCycles ?? "-"} | ${b.reworkPerTask} | ${b.tokensPerTask} | ${b.cacheRatio ?? "-"} | ${b.memoryPrecision ?? "-"} |`,
+    `| ${b.bucketStart} | ${b.tasks} | ${b.firstPassCleanRate ?? "-"} | ${b.avgReviewCycles ?? "-"} | ${b.reworkPerTask} | ${b.tokensPerTask} | ${b.cacheRatio ?? "-"} | ${b.memoryPrecision ?? "-"} | ${b.minedLessonsPerTask ?? "-"} | ${b.offloadBytesSavedPerTask ?? "-"} |`,
   );
 }
 if (trend) {