@tangle-network/agent-eval 0.124.0 → 0.126.0

package/dist/{chunk-4Y7AAATF.js → chunk-LKKT3IVV.js}

@@ -1,8 +1,10 @@
 import {
   DEFAULT_OPENCODE_DB,
   findOpencodeSessionsByDirectory,
-  openOpencodeDb
-} from "./chunk-R7ZRE2KV.js";
+  openOpencodeDb,
+  parseClaudeEntries,
+  transcriptFromEntries
+} from "./chunk-VBQ3CRKH.js";
 import {
   ROLLOUT_SCHEMA,
   isRolloutLine
@@ -20,6 +22,11 @@ function showMeasured(v) {
   if (v === null) return "null";
   return String(v);
 }
+var NO_SOURCE_LIMITS = {
+  spendUsd: null,
+  workerVerdicts: null,
+  deliverables: null
+};
 var SUPERVISOR_RUN_SCHEMA = "tangle.supervisor-run@1";
 var SUPERVISOR_RUN_ROLLUP_SCHEMA = "tangle.supervisor-run-rollup@1";
 
@@ -33,13 +40,25 @@ function num(v) {
 function readSpend(v) {
   const rec = asRecord(v);
   const tok = asRecord(rec.tokens);
-  return { tokens: { input: num(tok.input), output: num(tok.output) }, usd: num(rec.usd) };
+  const cacheRead = tok.cacheRead ?? tok.cache_read;
+  const cacheWrite = tok.cacheWrite ?? tok.cache_write;
+  return {
+    tokens: {
+      input: num(tok.input),
+      output: num(tok.output),
+      cacheRead: num(cacheRead),
+      cacheWrite: num(cacheWrite),
+      hasCache: cacheRead !== void 0 || cacheWrite !== void 0
+    },
+    usd: num(rec.usd)
+  };
 }
+var NO_CACHE_COUNTERS = "the journal carries no cache-token counters for this role";
 function parseJsonl(text) {
   if (text === null) return [];
   const out = [];
-  for (const line of text.split("\n")) {
-    const trimmed = line.trim();
+  for (const line2 of text.split("\n")) {
+    const trimmed = line2.trim();
     if (!trimmed) continue;
     try {
       const parsed = JSON.parse(trimmed);
@@ -70,6 +89,9 @@ function parseSupervisorTree(src) {
   const closes = [];
   let brainIn = 0;
   let brainOut = 0;
+  let brainCacheRead = 0;
+  let brainCacheWrite = 0;
+  let brainHasCache = false;
   let brainUsd = 0;
   let meteredCount = 0;
   let rootId = null;
@@ -88,7 +110,8 @@ function parseSupervisorTree(src) {
         status: typeof ev.status === "string" ? ev.status : null,
         verdict: typeof ev.verdict === "string" ? ev.verdict : null,
         at: ms(ev.at),
-        spend: readSpend(ev.spent)
+        spend: readSpend(ev.spent),
+        hasSpend: asRecord(ev.spent).tokens !== void 0
       });
     } else if (kind === "cancelled") {
       closes.push({
@@ -97,12 +120,19 @@ function parseSupervisorTree(src) {
         status: "cancelled",
         verdict: typeof ev.reason === "string" ? ev.reason : null,
         at: ms(ev.at),
-        spend: { tokens: { input: 0, output: 0 }, usd: 0 }
+        spend: {
+          tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, hasCache: false },
+          usd: 0
+        },
+        hasSpend: false
       });
     } else if (kind === "metered") {
       const s = readSpend(ev.spend);
       brainIn += s.tokens.input;
       brainOut += s.tokens.output;
+      brainCacheRead += s.tokens.cacheRead;
+      brainCacheWrite += s.tokens.cacheWrite;
+      brainHasCache = brainHasCache || s.tokens.hasCache;
       brainUsd += s.usd;
       meteredCount += 1;
     }
@@ -158,7 +188,15 @@ function parseSupervisorTree(src) {
     closes,
     workerSpawns,
     workerCloses,
-    brain: { tokensIn: brainIn, tokensOut: brainOut, usd: brainUsd, meteredCount },
+    brain: {
+      tokensIn: brainIn,
+      tokensOut: brainOut,
+      cacheRead: brainCacheRead,
+      cacheWrite: brainCacheWrite,
+      hasCache: brainHasCache,
+      usd: brainUsd,
+      meteredCount
+    },
     workerLogs,
     startedAt,
     completedAt
@@ -292,6 +330,7 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
     settledByStatus[key] = (settledByStatus[key] ?? 0) + 1;
     if (c.verdict !== null) settledVerdicts[c.verdict] = (settledVerdicts[c.verdict] ?? 0) + 1;
   }
+  const verdictLimit = src.limits.workerVerdicts;
   let accepted = 0;
   let rejected = 0;
   let emptyPass = 0;
@@ -320,10 +359,10 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
   }
   const decision = {
     settledByStatus: haveJournal ? settledByStatus : gap("settledByStatus", journalMissing),
-    settledVerdicts: haveJournal ? settledVerdicts : unavailable(journalMissing),
-    accepted: src.workers === null ? unavailable(workersGapReason) : accepted,
-    rejected: src.workers === null ? unavailable(workersGapReason) : rejected,
-    emptyPass: src.workers === null ? unavailable(workersGapReason) : emptyPass,
+    settledVerdicts: verdictLimit !== null ? unavailable(verdictLimit) : haveJournal ? settledVerdicts : unavailable(journalMissing),
+    accepted: verdictLimit !== null ? gap("accepted", verdictLimit) : src.workers === null ? unavailable(workersGapReason) : accepted,
+    rejected: verdictLimit !== null ? unavailable(verdictLimit) : src.workers === null ? unavailable(workersGapReason) : rejected,
+    emptyPass: verdictLimit !== null || src.limits.deliverables !== null ? unavailable(verdictLimit ?? src.limits.deliverables) : src.workers === null ? unavailable(workersGapReason) : emptyPass,
     observeThenRespawn: haveJournal ? observeThenRespawn : unavailable(journalMissing),
     respawnWithoutEvidence: haveJournal ? respawnWithoutEvidence : unavailable(journalMissing),
     reviewActions: src.workers === null ? unavailable(workersGapReason) : steerQueuedTotal + upLegMessages,
@@ -332,21 +371,29 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
   const journalWorkerIn = workerCloses.reduce((a, c) => a + c.spend.tokens.input, 0);
   const journalWorkerOut = workerCloses.reduce((a, c) => a + c.spend.tokens.output, 0);
   const journalWorkerUsd = workerCloses.reduce((a, c) => a + c.spend.usd, 0);
+  const labelById = new Map(tree.workerSpawns.map((s) => [s.id, s.label]));
+  const workerUsdByLabel = /* @__PURE__ */ new Map();
+  for (const c of workerCloses) {
+    const label = labelById.get(c.id);
+    if (label === void 0) continue;
+    workerUsdByLabel.set(label, (workerUsdByLabel.get(label) ?? 0) + c.spend.usd);
+  }
   const sq = src.harnessWorkerTokens;
   const harnessGapReason = src.harnessMissingReason ?? "harness session store unavailable and journal settled spend is 0";
   const workerIn = sq !== null ? journalWorkerIn + sq.input : journalWorkerIn > 0 ? journalWorkerIn : gap("workers.tokensIn", harnessGapReason);
   const workerOut = sq !== null ? journalWorkerOut + sq.output : journalWorkerOut > 0 ? journalWorkerOut : unavailable(harnessGapReason);
   const stateResult = asRecord(state?.result);
   const stateUsd = typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : null;
-  const totalUsd = stateUsd !== null ? round(stateUsd, 6) : haveJournal ? round(tree.brain.usd + journalWorkerUsd, 6) : gap("totalUsd", journalMissing);
+  const usdLimit = src.limits.spendUsd;
+  const totalUsd = usdLimit !== null ? gap("totalUsd", usdLimit) : stateUsd !== null ? round(stateUsd, 6) : haveJournal ? round(tree.brain.usd + journalWorkerUsd, 6) : gap("totalUsd", journalMissing);
   const perWorker = (src.workers ?? []).map((w) => {
     const f = tree.workerLogs.get(w.label);
     return {
       worker: w.label,
       wallMs: f?.started != null && f.finishedAt != null ? f.finishedAt - f.started : null,
-      tokensIn: 0,
-      tokensOut: 0,
-      usd: 0,
+      tokensIn: w.tokensIn ?? null,
+      tokensOut: w.tokensOut ?? null,
+      usd: usdLimit !== null ? null : workerUsdByLabel.get(w.label) ?? null,
       patchBytes: w.patchBytes ?? f?.finishedPatchBytes ?? null,
       passed: f?.passed ?? null
     };
@@ -357,7 +404,9 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
     brain: {
       tokensIn: haveJournal ? tree.brain.tokensIn : gap("brain.tokensIn", journalMissing),
       tokensOut: haveJournal ? tree.brain.tokensOut : unavailable(journalMissing),
-      usd: haveJournal ? round(tree.brain.usd, 6) : unavailable(journalMissing),
+      usd: usdLimit !== null ? unavailable(usdLimit) : haveJournal ? round(tree.brain.usd, 6) : unavailable(journalMissing),
+      cacheRead: !haveJournal ? unavailable(journalMissing) : tree.brain.hasCache ? tree.brain.cacheRead : unavailable(NO_CACHE_COUNTERS),
+      cacheWrite: !haveJournal ? unavailable(journalMissing) : tree.brain.hasCache ? tree.brain.cacheWrite : unavailable(NO_CACHE_COUNTERS),
       source: haveJournal ? `journal metered events (n=${tree.brain.meteredCount})` : journalMissing
     },
     brainTruncations: src.brainLog === null ? gap(
@@ -367,11 +416,13 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
     workers: {
       tokensIn: workerIn,
       tokensOut: workerOut,
-      usd: haveJournal ? round(journalWorkerUsd, 6) : unavailable(journalMissing),
+      cacheRead: sq?.cacheRead !== void 0 ? sq.cacheRead : unavailable(NO_CACHE_COUNTERS),
+      cacheWrite: sq?.cacheWrite !== void 0 ? sq.cacheWrite : unavailable(NO_CACHE_COUNTERS),
+      usd: usdLimit !== null ? unavailable(usdLimit) : haveJournal ? round(journalWorkerUsd, 6) : unavailable(journalMissing),
       source: sq !== null ? `journal settled spend + ${sq.store} sessions (n=${sq.sessions})` : `journal settled spend only \u2014 ${src.harnessMissingReason ?? "harness session store unavailable"}`
     },
     totalUsd,
-    totalUsdSource: stateUsd !== null ? `state.json result.spentUsd${journalWorkerUsd === 0 ? " \u2014 brain-priced only; worker CLI inference is unpriced (see worker token counts)" : ""}` : haveJournal ? "journal metered + settled usd" : journalMissing,
+    totalUsdSource: usdLimit !== null ? usdLimit : stateUsd !== null ? `state.json result.spentUsd${journalWorkerUsd === 0 ? " \u2014 brain-priced only; worker CLI inference is unpriced (see worker token counts)" : ""}` : haveJournal ? "journal metered + settled usd" : journalMissing,
     costPerAcceptedPatchUsd: isUnavailable(totalUsd) ? unavailable(totalUsd.unavailable) : isUnavailable(decision.accepted) ? unavailable(decision.accepted.unavailable) : decision.accepted === 0 ? unavailable("no accepted worker patch (cost has no denominator)") : round(totalUsd / decision.accepted, 6),
     workerWallMsDistribution: walls.length === 0 ? unavailable(
       src.workers === null ? workersGapReason : "no worker start/finish pairs captured"
@@ -385,7 +436,7 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
     },
     perWorker: src.workers === null ? unavailable(workersGapReason) : perWorker
   };
-  const patchStats = src.patch === null ? gap("patch", "delivered patch file absent") : parsePatch(src.patch);
+  const patchStats = src.patch === null ? gap("patch", src.limits.deliverables ?? "delivered patch file absent") : parsePatch(src.patch);
   const outcome = {
     supStatus: pickString(state, "status") ?? pickString(result, "sup_status") ?? gap("supStatus", "no state.json / result.json status"),
     supVerdict: pickString(state, "verdict") ?? pickString(result, "sup_verdict") ?? unavailable("no state.json / result.json verdict"),
@@ -411,13 +462,13 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
     economics,
     outcome,
     gaps,
-    traceCommand: "npx --yes @tangle-network/traces@latest analyze --harness opencode --cwd <worker-clone-cwd>"
+    traceCommand: src.traceCommand ?? "npx --yes @tangle-network/traces@latest analyze --harness opencode --cwd <worker-clone-cwd>"
   };
 }
 function registrationMentions(driverLog) {
   let n = 0;
-  for (const line of driverLog.split("\n")) {
-    if (line.includes("registered tools:") && line.includes("supervisor_steer")) n += 1;
+  for (const line2 of driverLog.split("\n")) {
+    if (line2.includes("registered tools:") && line2.includes("supervisor_steer")) n += 1;
   }
   return n;
 }
@@ -439,20 +490,20 @@ function parsePatch(text) {
   const testFiles = /* @__PURE__ */ new Set();
   let added = 0;
   let removed = 0;
-  for (const line of text.split("\n")) {
-    if (line.startsWith("+++ ")) {
-      const p = line.slice(4).trim().replace(/^b\//, "");
+  for (const line2 of text.split("\n")) {
+    if (line2.startsWith("+++ ")) {
+      const p = line2.slice(4).trim().replace(/^b\//, "");
       if (p !== "/dev/null") {
         files.add(p);
         if (isTestPath(p)) testFiles.add(p);
       }
       continue;
     }
-    if (line.startsWith("--- ") || line.startsWith("diff --git") || line.startsWith("index ")) {
+    if (line2.startsWith("--- ") || line2.startsWith("diff --git") || line2.startsWith("index ")) {
       continue;
     }
-    if (line.startsWith("+")) added += 1;
-    else if (line.startsWith("-")) removed += 1;
+    if (line2.startsWith("+")) added += 1;
+    else if (line2.startsWith("-")) removed += 1;
   }
   return {
     files: files.size,
@@ -506,9 +557,426 @@ function rollupSupervisorRuns(reports) {
   };
 }
 
+// src/supervisor-run/claude-code-reader.ts
+import { readdir, readFile } from "fs/promises";
+import { basename, dirname, join } from "path";
+var DEFAULT_SPAWN_TOOLS = ["Agent", "Task"];
+var DEFAULT_STEER_TOOLS = ["SendMessage"];
+var DEFAULT_CANCEL_TOOLS = ["TaskStop", "KillAgent"];
+var SPEND_UNPRICED = "Claude Code transcripts record token usage but never a price \u2014 usd is not in the store";
+var NO_VERDICTS = "Claude Code runs no per-worker verify step \u2014 a subagent reports prose, not pass/fail";
+var NO_DELIVERABLES = "Claude Code retains no per-worker patch \u2014 subagents commit to git, they do not hand back a diff";
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str = (v) => typeof v === "string" ? v : null;
+function blockText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const b of content) {
+    if (isRecord(b) && b.type === "text" && typeof b.text === "string") parts.push(b.text);
+  }
+  return parts.join("\n");
+}
+var tag = (xml, name) => {
+  const m = xml.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`));
+  return m === null ? null : m[1];
+};
+function parseNotifications(text, at) {
+  const out = [];
+  for (const m of text.matchAll(/<task-notification>[\s\S]*?<\/task-notification>/g)) {
+    const xml = m[0];
+    const taskId = tag(xml, "task-id");
+    if (taskId === null) continue;
+    out.push({
+      taskId: taskId.trim(),
+      toolUseId: tag(xml, "tool-use-id")?.trim() ?? null,
+      status: tag(xml, "status")?.trim() ?? "unknown",
+      summary: tag(xml, "summary")?.trim() ?? null,
+      at
+    });
+  }
+  return out;
+}
+function threadCalls(entries) {
+  const uses = [];
+  const results = /* @__PURE__ */ new Map();
+  const notifications = [];
+  let firstAt = null;
+  let lastAt = null;
+  for (const entry of entries) {
+    if (entry.timestamp !== null) {
+      if (firstAt === null) firstAt = entry.timestamp;
+      lastAt = entry.timestamp;
+    }
+    const content = entry.message.content;
+    if (entry.type === "assistant") {
+      if (!Array.isArray(content)) continue;
+      for (const block of content) {
+        if (!isRecord(block) || block.type !== "tool_use") continue;
+        const id = str(block.id);
+        const name = str(block.name);
+        if (id === null || name === null) continue;
+        uses.push({
+          id,
+          name,
+          input: isRecord(block.input) ? block.input : {},
+          at: entry.timestamp
+        });
+      }
+      continue;
+    }
+    if (typeof content === "string") {
+      notifications.push(...parseNotifications(content, entry.timestamp));
+      continue;
+    }
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!isRecord(block)) continue;
+      if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+        results.set(block.tool_use_id, {
+          id: block.tool_use_id,
+          at: entry.timestamp,
+          structured: entry.toolUseResult,
+          text: blockText(block.content)
+        });
+      } else if (block.type === "text" && typeof block.text === "string") {
+        notifications.push(...parseNotifications(block.text, entry.timestamp));
+      }
+    }
+  }
+  return { uses, results, notifications, firstAt, lastAt };
+}
+function spawnedAgentId(result) {
+  if (result === void 0) return null;
+  if (isRecord(result.structured)) {
+    const id = str(result.structured.agentId);
+    if (id !== null) return id;
+  }
+  return result.text.match(/agentId:\s*([A-Za-z0-9_-]+)/)?.[1] ?? null;
+}
+async function readChildren(dir) {
+  const names = await readdir(dir).catch(() => null);
+  if (names === null) return [];
+  const out = [];
+  for (const name of names.filter((n) => n.endsWith(".jsonl")).sort()) {
+    const path = join(dir, name);
+    const raw = await readFile(path, "utf8").catch(() => null);
+    if (raw === null) continue;
+    const entries = parseClaudeEntries(raw);
+    const projected = transcriptFromEntries(entries, { includeSidechain: true });
+    const metaRaw = await readFile(path.replace(/\.jsonl$/, ".meta.json"), "utf8").catch(() => null);
+    let meta = {};
+    if (metaRaw !== null) {
+      try {
+        const parsed = JSON.parse(metaRaw);
+        if (isRecord(parsed)) meta = parsed;
+      } catch {
+        meta = {};
+      }
+    }
+    const agentId = entries.find((e) => e.agentId !== null)?.agentId ?? name.replace(/^agent-/, "").replace(/\.jsonl$/, "");
+    out.push({
+      agentId,
+      path,
+      description: str(meta.description),
+      spawnToolUseId: str(meta.toolUseId),
+      spawnDepth: typeof meta.spawnDepth === "number" ? meta.spawnDepth : null,
+      entries,
+      tokensIn: projected.usage.tokensIn,
+      tokensOut: projected.usage.tokensOut,
+      cacheRead: projected.usage.cacheRead,
+      cacheWrite: projected.usage.cacheWrite,
+      firstAt: projected.startedAt,
+      lastAt: projected.endedAt,
+      model: projected.model,
+      finalReport: [...projected.messages].reverse().find((m) => m.role === "assistant" && typeof m.content === "string")?.content ?? null
+    });
+  }
+  return out;
+}
+var line = (obj) => JSON.stringify(obj);
+async function readClaudeCodeSupervisorRun(opts) {
+  const spawnTools = new Set(opts.spawnTools ?? DEFAULT_SPAWN_TOOLS);
+  const steerTools = new Set(opts.steerTools ?? DEFAULT_STEER_TOOLS);
+  const cancelTools = new Set(opts.cancelTools ?? DEFAULT_CANCEL_TOOLS);
+  const raw = await readFile(opts.transcriptPath, "utf8").catch(() => null);
+  const sessionId = basename(opts.transcriptPath).replace(/\.jsonl$/, "");
+  const runRef = opts.runRef ?? opts.transcriptPath;
+  const limits = { spendUsd: SPEND_UNPRICED, workerVerdicts: NO_VERDICTS, deliverables: null };
+  const traceCommand = `npx --yes @tangle-network/traces@latest analyze --harness claude-code --session ${sessionId}`;
+  if (raw === null) {
+    return {
+      runRef,
+      instanceId: opts.instanceId ?? sessionId,
+      arm: opts.arm ?? null,
+      supRunDir: null,
+      journal: null,
+      brainLog: null,
+      state: null,
+      progress: null,
+      workers: null,
+      workersMissingReason: `session transcript unreadable at ${opts.transcriptPath}`,
+      result: null,
+      judge: null,
+      judgeSource: null,
+      patch: null,
+      driverLog: null,
+      harnessWorkerTokens: null,
+      harnessMissingReason: `session transcript unreadable at ${opts.transcriptPath}`,
+      limits: { ...limits, deliverables: NO_DELIVERABLES },
+      traceCommand
+    };
+  }
+  const allEntries = parseClaudeEntries(raw);
+  const main = threadCalls(allEntries.filter((e) => !e.isSidechain));
+  const mainTranscript = transcriptFromEntries(allEntries);
+  const subagentsDir = opts.subagentsDir === void 0 ? join(dirname(opts.transcriptPath), sessionId, "subagents") : opts.subagentsDir;
+  const children = subagentsDir === null ? [] : await readChildren(subagentsDir);
+  const childByAgentId = new Map(children.map((c) => [c.agentId, c]));
+  const childBySpawnToolUseId = new Map(
+    children.filter((c) => c.spawnToolUseId !== null).map((c) => [c.spawnToolUseId, c])
+  );
+  const threads = [{ id: sessionId, calls: main }];
+  for (const child of children) {
+    threads.push({ id: child.agentId, calls: threadCalls(child.entries) });
+  }
+  const spawns = [];
+  const steersByTarget = /* @__PURE__ */ new Map();
+  const cancels = [];
+  const settles = [];
+  for (const thread of threads) {
+    for (const use of thread.calls.uses) {
+      if (spawnTools.has(use.name)) {
+        const result = thread.calls.results.get(use.id);
+        const agentId = spawnedAgentId(result) ?? childBySpawnToolUseId.get(use.id)?.agentId ?? null;
+        if (agentId === null) continue;
+        const label = str(use.input.description) ?? childByAgentId.get(agentId)?.description ?? agentId;
+        spawns.push({
+          agentId,
+          parentId: thread.id,
+          label,
+          // The spawn is complete when the launch call is answered; the tool_use
+          // instant is the fallback for a call that never got a result line.
+          at: result?.at ?? use.at,
+          model: isRecord(result?.structured) ? str(result.structured.resolvedModel) : null
+        });
+        continue;
+      }
+      if (steerTools.has(use.name)) {
+        const target = str(use.input.to) ?? str(use.input.recipient);
+        if (target === null) continue;
+        const result = thread.calls.results.get(use.id);
+        const structured = isRecord(result?.structured) ? result.structured : null;
+        const delivered = structured?.success === true || str(structured?.resumedAgentId) === target;
+        const rows = steersByTarget.get(target) ?? [];
+        rows.push({ at: use.at, delivered });
+        steersByTarget.set(target, rows);
+        continue;
+      }
+      if (cancelTools.has(use.name)) {
+        const target = str(use.input.agentId) ?? str(use.input.to) ?? str(use.input.taskId);
+        if (target !== null) cancels.push({ agentId: target, at: use.at });
+      }
+    }
+    settles.push(...thread.calls.notifications);
+  }
+  const spawnedIds = new Set(spawns.map((s) => s.agentId));
+  const cancelledIds = new Set(
+    cancels.filter((c) => spawnedIds.has(c.agentId)).map((c) => c.agentId)
+  );
+  const startedAt = main.firstAt;
+  const completedAt = main.lastAt;
+  const journalLines = [
+    line({
+      kind: "spawned",
+      id: sessionId,
+      parent: null,
+      label: `session:${sessionId}`,
+      at: startedAt
+    })
+  ];
+  for (const s of spawns) {
+    journalLines.push(
+      line({ kind: "spawned", id: s.agentId, parent: s.parentId, label: s.label, at: s.at })
+    );
+  }
+  const lastNotification = /* @__PURE__ */ new Map();
+  for (const n of settles) {
+    if (!spawnedIds.has(n.taskId)) continue;
+    lastNotification.set(n.taskId, n);
+  }
+  for (const [agentId, n] of lastNotification) {
+    if (cancelledIds.has(agentId)) continue;
+    journalLines.push(
+      line({
+        kind: "settled",
+        id: agentId,
+        status: n.status,
+        verdict: n.summary,
+        at: n.at
+        // No `spent` key: Claude Code prices nothing, and a zeroed spend object
+        // would read as a $0 worker. `limits.spendUsd` carries the reason.
+      })
+    );
+  }
+  const lastCancel = /* @__PURE__ */ new Map();
+  for (const c of cancels) {
+    if (!spawnedIds.has(c.agentId)) continue;
+    lastCancel.set(c.agentId, c);
+  }
+  for (const c of lastCancel.values()) {
+    journalLines.push(
+      line({ kind: "cancelled", id: c.agentId, reason: "stopped by supervisor", at: c.at })
+    );
+  }
+  journalLines.push(
+    line({
+      kind: "metered",
+      id: sessionId,
+      spend: {
+        tokens: {
+          input: mainTranscript.usage.tokensIn,
+          output: mainTranscript.usage.tokensOut,
+          cacheRead: mainTranscript.usage.cacheRead,
+          cacheWrite: mainTranscript.usage.cacheWrite
+        }
+      },
+      at: completedAt
+    })
+  );
+  const settleAtByAgent = new Map(
+    [...lastNotification.entries()].map(([id, n]) => [id, n.at])
+  );
+  const spawnAtByAgent = new Map(spawns.map((s) => [s.agentId, s.at]));
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const s of spawns) {
+    const ids = byLabel.get(s.label) ?? [];
+    ids.push(s.agentId);
+    byLabel.set(s.label, ids);
+  }
+  const workers = [];
+  for (const [label, agentIds] of byLabel) {
+    const events = [];
+    const inbox = [];
+    let tokensIn = null;
+    let tokensOut = null;
+    let cacheRead = null;
+    let cacheWrite = null;
+    let transcriptRef = null;
+    for (const agentId of agentIds) {
+      const child = childByAgentId.get(agentId) ?? null;
+      const startAt = child?.firstAt ?? spawnAtByAgent.get(agentId) ?? null;
+      const endAt = settleAtByAgent.get(agentId) ?? child?.lastAt ?? null;
+      if (startAt !== null) events.push(line({ kind: "started", label, at: startAt, agentId }));
+      for (const steer of steersByTarget.get(agentId) ?? []) {
+        inbox.push(
+          line({ id: `${agentId}:${steer.at}`, at: steer.at, worker: label, message: "steer" })
+        );
+        events.push(
+          line({
+            kind: "message",
+            label,
+            direction: "down",
+            at: steer.at,
+            requestId: `${agentId}:${steer.at}`,
+            delivered: steer.delivered
+          })
+        );
+      }
+      if (endAt !== null) {
+        events.push(
+          line({
+            kind: "finished",
+            label,
+            at: endAt,
+            agentId,
+            // No `passed` / `patchBytes`: this harness has neither. Emitting
+            // `passed: false` here would invent a failed worker.
+            // `evidence` is the child's closing message — what it handed back.
+            ...child?.finalReport === null || child?.finalReport === void 0 ? {} : { evidence: child.finalReport }
+          })
+        );
+      }
+      if (child !== null) {
+        tokensIn = (tokensIn ?? 0) + child.tokensIn;
+        tokensOut = (tokensOut ?? 0) + child.tokensOut;
+        cacheRead = (cacheRead ?? 0) + child.cacheRead;
+        cacheWrite = (cacheWrite ?? 0) + child.cacheWrite;
+        transcriptRef = child.path;
+      }
+    }
+    workers.push({
+      label,
+      events: events.length === 0 ? null : `${events.join("\n")}
+`,
+      inbox: inbox.length === 0 ? null : `${inbox.join("\n")}
+`,
+      patchBytes: null,
+      transcriptRef,
+      patchPath: null,
+      tokensIn,
+      tokensOut,
+      cacheRead,
+      cacheWrite
+    });
+  }
+  const joined = children.length;
+  const harnessWorkerTokens = joined === 0 ? null : {
+    store: "claude-code subagent transcripts",
+    sessions: joined,
+    input: children.reduce((a, c) => a + c.tokensIn, 0),
+    output: children.reduce((a, c) => a + c.tokensOut, 0),
+    cacheRead: children.reduce((a, c) => a + c.cacheRead, 0),
+    cacheWrite: children.reduce((a, c) => a + c.cacheWrite, 0)
+  };
+  const missingChildren = spawns.filter((s) => !childByAgentId.has(s.agentId)).length;
+  const harnessMissingReason = subagentsDir === null ? "subagent transcript join disabled" : joined === 0 ? `no subagent transcripts under ${subagentsDir}` : missingChildren === 0 ? null : `${missingChildren}/${spawns.length} spawned agents have no retained transcript under ${subagentsDir} (Claude Code prunes them; their tokens are unrecoverable)`;
+  const liveWorkers = spawns.filter(
+    (s) => !lastNotification.has(s.agentId) && !cancelledIds.has(s.agentId)
+  ).length;
+  const state = JSON.stringify({
+    id: sessionId,
+    // Derived, not asserted: a spawned agent with no notification and no stop
+    // is still running, which is exactly what a live transcript looks like.
+    status: liveWorkers > 0 ? "running" : "idle",
+    startedAt,
+    completedAt,
+    result: { delivered: null }
+  });
+  return {
+    runRef,
+    instanceId: opts.instanceId ?? sessionId,
+    arm: opts.arm ?? null,
+    supRunDir: subagentsDir,
+    journal: `${journalLines.join("\n")}
+`,
+    brainLog: null,
+    state,
+    progress: null,
+    workers,
+    workersMissingReason: null,
+    result: null,
+    judge: null,
+    judgeSource: null,
+    patch: null,
+    driverLog: null,
+    harnessWorkerTokens,
+    harnessMissingReason,
+    limits: { ...limits, deliverables: NO_DELIVERABLES },
+    rootTranscriptRef: opts.transcriptPath,
+    traceCommand
+  };
+}
+function claudeCodeSupervisorRunReader(opts) {
+  return {
+    runRef: opts.runRef ?? opts.transcriptPath,
+    read: () => readClaudeCodeSupervisorRun(opts)
+  };
+}
+
 // src/supervisor-run/loops-reader.ts
-import { appendFile, mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { basename, join } from "path";
+import { appendFile, mkdir, readdir as readdir2, readFile as readFile2, writeFile } from "fs/promises";
+import { basename as basename2, join as join2 } from "path";
 
 // src/supervisor-run/render.ts
 function renderSupervisorRunHeadline(r) {
@@ -607,13 +1075,13 @@ unavailable \u2014 ${o.steersByWorker.unavailable}
   out.push("");
   out.push("## Economics");
   out.push("");
-  out.push("| Role | Tokens in | Tokens out | USD | Source |");
-  out.push("|---|---:|---:|---:|---|");
+  out.push("| Role | Tokens in | Tokens out | Cache read | Cache write | USD | Source |");
+  out.push("|---|---:|---:|---:|---:|---:|---|");
   out.push(
-    `| brain | ${showMeasured(e.brain.tokensIn)} | ${showMeasured(e.brain.tokensOut)} | ${showMeasured(e.brain.usd)} | ${e.brain.source} |`
+    `| brain | ${showMeasured(e.brain.tokensIn)} | ${showMeasured(e.brain.tokensOut)} | ${showMeasured(e.brain.cacheRead)} | ${showMeasured(e.brain.cacheWrite)} | ${showMeasured(e.brain.usd)} | ${e.brain.source} |`
   );
   out.push(
-    `| workers | ${showMeasured(e.workers.tokensIn)} | ${showMeasured(e.workers.tokensOut)} | ${showMeasured(e.workers.usd)} | ${e.workers.source} |`
+    `| workers | ${showMeasured(e.workers.tokensIn)} | ${showMeasured(e.workers.tokensOut)} | ${showMeasured(e.workers.cacheRead)} | ${showMeasured(e.workers.cacheWrite)} | ${showMeasured(e.workers.usd)} | ${e.workers.source} |`
   );
   out.push("");
   if (!isUnavailable(e.brainTruncations) && e.brainTruncations > 0) {
@@ -637,11 +1105,11 @@ unavailable \u2014 ${o.steersByWorker.unavailable}
   }
   out.push("");
   if (!isUnavailable(e.perWorker) && e.perWorker.length > 0) {
-    out.push("| Worker | Wall | Patch bytes | Verify passed |");
-    out.push("|---|---:|---:|---|");
+    out.push("| Worker | Wall | Tokens in | Tokens out | Patch bytes | Verify passed |");
+    out.push("|---|---:|---:|---:|---:|---|");
     for (const w of e.perWorker) {
       out.push(
-        `| \`${w.worker}\` | ${w.wallMs === null ? "unavailable \u2014 no start/finish pair" : fmtMs(w.wallMs)} | ${w.patchBytes ?? "unavailable \u2014 no worker patch file"} | ${w.passed === null ? "unavailable \u2014 no finished event" : String(w.passed)} |`
+        `| \`${w.worker}\` | ${w.wallMs === null ? "unavailable \u2014 no start/finish pair" : fmtMs(w.wallMs)} | ${w.tokensIn ?? "unavailable \u2014 store does not attribute tokens per worker"} | ${w.tokensOut ?? "unavailable \u2014 store does not attribute tokens per worker"} | ${w.patchBytes ?? "unavailable \u2014 no worker patch file"} | ${w.passed === null ? "unavailable \u2014 no finished event" : String(w.passed)} |`
       );
     }
     out.push("");
@@ -721,27 +1189,27 @@ function renderSupervisorRollupMarkdown(rollup, title = "Round rollup") {
 
 // src/supervisor-run/loops-reader.ts
 async function readMaybe(path) {
-  return readFile(path, "utf8").catch(() => null);
+  return readFile2(path, "utf8").catch(() => null);
 }
 async function findSupervisorRunDirIn(ws) {
-  const root = join(ws, ".loops", "supervisor");
-  const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
-  const dirs = entries.filter((e) => e.isDirectory()).map((e) => join(root, e.name));
+  const root = join2(ws, ".loops", "supervisor");
+  const entries = await readdir2(root, { withFileTypes: true }).catch(() => []);
+  const dirs = entries.filter((e) => e.isDirectory()).map((e) => join2(root, e.name));
   return dirs[0] ?? null;
 }
 async function readLoopsSupervisorRun(runDir, opts = {}) {
-  const ws = opts.ws ?? join(runDir, "ws");
+  const ws = opts.ws ?? join2(runDir, "ws");
   const supRunDir = await findSupervisorRunDirIn(ws);
-  const result = await readMaybe(join(runDir, "result.json"));
+  const result = await readMaybe(join2(runDir, "result.json"));
   const resultObj = parseJson(result);
   let workers = null;
   let workersMissingReason = null;
   const workerCwds = [];
   if (supRunDir === null) {
-    workersMissingReason = `no supervisor run dir under ${join(ws, ".loops", "supervisor")}`;
+    workersMissingReason = `no supervisor run dir under ${join2(ws, ".loops", "supervisor")}`;
   } else {
-    const workersDir = join(supRunDir, "workers");
-    const entries = await readdir(workersDir).catch(() => null);
+    const workersDir = join2(supRunDir, "workers");
+    const entries = await readdir2(workersDir).catch(() => null);
     if (entries === null) {
       workersMissingReason = `workers/ directory absent under ${supRunDir}`;
     } else {
@@ -752,9 +1220,9 @@ async function readLoopsSupervisorRun(runDir, opts = {}) {
       ].sort();
       workers = [];
       for (const label of labels) {
-        const events = await readMaybe(join(workersDir, `${label}.ndjson`));
-        const inbox = await readMaybe(join(workersDir, `${label}.inbox.ndjson`));
-        const patch = await readMaybe(join(workersDir, `${label}.patch`));
+        const events = await readMaybe(join2(workersDir, `${label}.ndjson`));
+        const inbox = await readMaybe(join2(workersDir, `${label}.inbox.ndjson`));
+        const patch = await readMaybe(join2(workersDir, `${label}.patch`));
         workers.push({
           label,
           events,
@@ -799,8 +1267,8 @@ async function readLoopsSupervisorRun(runDir, opts = {}) {
     }
   }
   const patchPath = opts.patchPath ?? (typeof resultObj?.patchPath === "string" ? resultObj.patchPath : null);
-  let judge = await readMaybe(join(runDir, "judge.json"));
-  let judgeSource = judge === null ? null : join(runDir, "judge.json");
+  let judge = await readMaybe(join2(runDir, "judge.json"));
+  let judgeSource = judge === null ? null : join2(runDir, "judge.json");
   if (judge === null && opts.ledgerPath !== void 0) {
     const row = await findLedgerRow(opts.ledgerPath, runDir);
     if (row !== null) {
@@ -811,21 +1279,25 @@ async function readLoopsSupervisorRun(runDir, opts = {}) {
   return {
     runRef: runDir,
     instanceId: typeof resultObj?.iid === "string" ? resultObj.iid : instanceIdFromPath(runDir),
-    arm: typeof resultObj?.arm === "string" ? resultObj.arm : basename(runDir),
+    arm: typeof resultObj?.arm === "string" ? resultObj.arm : basename2(runDir),
     supRunDir,
-    journal: supRunDir === null ? null : await readMaybe(join(supRunDir, "journal.jsonl")),
-    brainLog: supRunDir === null ? null : await readMaybe(join(supRunDir, "brain.jsonl")),
-    state: supRunDir === null ? null : await readMaybe(join(supRunDir, "state.json")),
-    progress: supRunDir === null ? null : await readMaybe(join(supRunDir, "progress.ndjson")),
+    journal: supRunDir === null ? null : await readMaybe(join2(supRunDir, "journal.jsonl")),
+    brainLog: supRunDir === null ? null : await readMaybe(join2(supRunDir, "brain.jsonl")),
+    state: supRunDir === null ? null : await readMaybe(join2(supRunDir, "state.json")),
+    progress: supRunDir === null ? null : await readMaybe(join2(supRunDir, "progress.ndjson")),
     workers,
     workersMissingReason,
     result,
     judge,
     judgeSource,
     patch: patchPath === null ? null : await readMaybe(patchPath),
-    driverLog: await readMaybe(join(runDir, "driver.log")),
+    driverLog: await readMaybe(join2(runDir, "driver.log")),
     harnessWorkerTokens,
-    harnessMissingReason
+    harnessMissingReason,
+    // loops prices its own inference, runs a verify per worker, and keeps each
+    // worker's patch — every fact the analyzer can use is expressible here.
+    limits: NO_SOURCE_LIMITS,
+    traceCommand: null
   };
 }
 function loopsSupervisorRunReader(runDir, opts = {}) {
@@ -836,7 +1308,7 @@ async function findLedgerRow(ledgerPath, runDir) {
   const exact = rows.find((r) => r.runDir === runDir);
   if (exact !== void 0) return exact;
   const iid = instanceIdFromPath(runDir);
-  const arm = basename(runDir);
+  const arm = basename2(runDir);
   return rows.find((r) => r.iid === iid && r.arm === arm) ?? null;
 }
 function instanceIdFromPath(runDir) {
@@ -863,9 +1335,9 @@ async function writeSupervisorRunReport(runDir, opts = {}) {
   const stem = opts.reportDir === void 0 ? "run-report" : supervisorReportStem(runDir);
   if (opts.reportDir !== void 0) await mkdir(opts.reportDir, { recursive: true }).catch(() => {
   });
-  await writeFile(join(dest, `${stem}.json`), JSON.stringify(report, null, 1)).catch(() => {
+  await writeFile(join2(dest, `${stem}.json`), JSON.stringify(report, null, 1)).catch(() => {
   });
-  await writeFile(join(dest, `${stem}.md`), md).catch(() => {
+  await writeFile(join2(dest, `${stem}.md`), md).catch(() => {
   });
   const headline = renderSupervisorRunHeadline(report);
   if (opts.appendHeadlineTo !== void 0) {
@@ -882,8 +1354,8 @@ function supervisorReportStem(runDir) {
   const iid = parts[parts.length - 2] ?? "instance";
   const rep = parts.find((p) => /^rep-\d+$/.test(p));
   const armRunsIdx = parts.indexOf("arm-runs");
-  const tag = armRunsIdx >= 0 ? parts[armRunsIdx + 1] : void 0;
-  return [tag, rep, iid, arm].filter((s) => s !== void 0 && s !== "runs").join(".").replace(/[^A-Za-z0-9._-]/g, "_");
+  const tag2 = armRunsIdx >= 0 ? parts[armRunsIdx + 1] : void 0;
+  return [tag2, rep, iid, arm].filter((s) => s !== void 0 && s !== "runs").join(".").replace(/[^A-Za-z0-9._-]/g, "_");
 }
 async function writeSupervisorRunReportSafe(runDir, opts = {}) {
   try {
@@ -905,16 +1377,16 @@ async function reportSupervisorRound(outDir, opts = {}) {
   const rollup = rollupSupervisorRuns(reports);
   const md = renderSupervisorRollupMarkdown(
     rollup,
-    opts.title ?? `Round rollup \u2014 ${basename(outDir)}`
+    opts.title ?? `Round rollup \u2014 ${basename2(outDir)}`
   );
   const dest = opts.reportDir ?? outDir;
   if (opts.reportDir !== void 0) await mkdir(opts.reportDir, { recursive: true }).catch(() => {
   });
-  await writeFile(join(dest, "run-report-round.json"), JSON.stringify(rollup, null, 1)).catch(
+  await writeFile(join2(dest, "run-report-round.json"), JSON.stringify(rollup, null, 1)).catch(
     () => {
     }
   );
-  await writeFile(join(dest, "run-report-round.md"), md).catch(() => {
+  await writeFile(join2(dest, "run-report-round.md"), md).catch(() => {
   });
   if (opts.appendHeadlineTo !== void 0) {
     await appendFile(opts.appendHeadlineTo, `${md}
@@ -928,17 +1400,17 @@ async function findSupervisorRunDirs(root) {
   const found = [];
   const walk = async (dir, depth) => {
     if (depth > 8) return;
-    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       if (e.name === "node_modules" || e.name === ".git") continue;
-      const full = join(dir, e.name);
+      const full = join2(dir, e.name);
       if (e.name === "runs") {
-        const iids = await readdir(full, { withFileTypes: true }).catch(() => []);
+        const iids = await readdir2(full, { withFileTypes: true }).catch(() => []);
         for (const iid of iids) {
           if (!iid.isDirectory()) continue;
-          const arms = await readdir(join(full, iid.name), { withFileTypes: true }).catch(() => []);
-          for (const arm of arms) if (arm.isDirectory()) found.push(join(full, iid.name, arm.name));
+          const arms = await readdir2(join2(full, iid.name), { withFileTypes: true }).catch(() => []);
+          for (const arm of arms) if (arm.isDirectory()) found.push(join2(full, iid.name, arm.name));
         }
         continue;
       }
@@ -1036,15 +1508,17 @@ function supervisorRunRolloutLines(src, opts = {}) {
       },
       cost: {
         ...EMPTY_COST,
-        usd: typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : tree.brain.usd,
+        usd: src.limits.spendUsd !== null ? null : typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : tree.brain.usd,
         tokens_in: tree.brain.tokensIn,
         tokens_out: tree.brain.tokensOut,
+        cache_read: tree.brain.hasCache ? tree.brain.cacheRead : null,
+        cache_write: tree.brain.hasCache ? tree.brain.cacheWrite : null,
         wall_s: wallMs === null ? null : wallMs / 1e3
       },
       artifacts: {
         patch_path: typeof result?.patchPath === "string" ? result.patchPath : null,
         run_dir: src.supRunDir,
-        transcript_ref: src.supRunDir === null ? null : `${src.supRunDir}/journal.jsonl`
+        transcript_ref: src.rootTranscriptRef !== void 0 ? src.rootTranscriptRef : src.supRunDir === null ? null : `${src.supRunDir}/journal.jsonl`
       },
       provenance: {
         captured_at: capturedAt,
@@ -1056,9 +1530,11 @@ function supervisorRunRolloutLines(src, opts = {}) {
     gaps.push("tree.root: no parentless `spawned` event in the journal");
   }
   const closeById = new Map(tree.closes.map((c) => [c.id, c]));
+  const sourceByLabel = new Map((src.workers ?? []).map((w) => [w.label, w]));
   for (const spawn of tree.workerSpawns) {
     const close = closeById.get(spawn.id) ?? null;
     const facts = tree.workerLogs.get(spawn.label) ?? null;
+    const workerSource = sourceByLabel.get(spawn.label) ?? null;
     const wallMs = facts?.started != null && facts.finishedAt != null ? facts.finishedAt - facts.started : null;
     const reward = facts?.passed === null || facts === null ? null : facts.passed ? 1 : 0;
     if (reward === null) {
@@ -1098,22 +1574,33 @@ function supervisorRunRolloutLines(src, opts = {}) {
         is_truncated: close?.kind === "cancelled",
         error: close?.kind === "cancelled" ? close.verdict ?? "cancelled" : null
       },
+      // `close.spend` is only a measurement when the close event carried one;
+      // a store that never priced this worker must leave null, not 0.
       cost: {
         ...EMPTY_COST,
-        usd: close?.spend.usd ?? null,
-        tokens_in: close?.spend.tokens.input ?? null,
-        tokens_out: close?.spend.tokens.output ?? null,
+        usd: src.limits.spendUsd !== null || !close?.hasSpend ? null : close.spend.usd,
+        tokens_in: workerSource?.tokensIn ?? (close?.hasSpend ? close.spend.tokens.input : null),
+        tokens_out: workerSource?.tokensOut ?? (close?.hasSpend ? close.spend.tokens.output : null),
+        // Mirror the tokens_in/out journal fallback so a loops-shaped store whose
+        // `settled` spend carries cache counters is not reported as null cache
+        // beside real tokens. Gate on `hasCache` — a spend object without cache
+        // counters must stay null, not a fabricated 0.
+        cache_read: workerSource?.cacheRead ?? (close?.hasSpend && close.spend.tokens.hasCache ? close.spend.tokens.cacheRead : null),
+        cache_write: workerSource?.cacheWrite ?? (close?.hasSpend && close.spend.tokens.hasCache ? close.spend.tokens.cacheWrite : null),
         wall_s: wallMs === null ? null : wallMs / 1e3
       },
+      // A reader that knows where its worker artifacts live says so; only the
+      // loops layout is derivable from `supRunDir`, so guessing it for another
+      // store would mint rows pointing at paths that never existed.
       artifacts: {
-        patch_path: src.supRunDir === null ? null : `${src.supRunDir}/workers/${spawn.label}.patch`,
+        patch_path: workerSource?.patchPath !== void 0 ? workerSource.patchPath : src.supRunDir === null ? null : `${src.supRunDir}/workers/${spawn.label}.patch`,
         run_dir: src.supRunDir,
-        transcript_ref: src.supRunDir === null ? null : `${src.supRunDir}/workers/${spawn.label}.ndjson`
+        transcript_ref: workerSource?.transcriptRef !== void 0 ? workerSource.transcriptRef : src.supRunDir === null ? null : `${src.supRunDir}/workers/${spawn.label}.ndjson`
       },
       provenance: {
         captured_at: capturedAt,
         capture: "backfill",
-        gap: "worker transcript lives in the harness session store \u2014 hydrate via src/rollout/readers"
+        gap: workerSource?.transcriptRef == null ? "worker transcript lives in the harness session store \u2014 hydrate via src/rollout/readers" : "worker transcript recorded by the harness; messages not inlined into this row"
       }
     });
   }
@@ -1128,12 +1615,18 @@ export {
   unavailable,
   isUnavailable,
   showMeasured,
+  NO_SOURCE_LIMITS,
   SUPERVISOR_RUN_SCHEMA,
   SUPERVISOR_RUN_ROLLUP_SCHEMA,
   parseSupervisorTree,
   analyzeSupervisorRunSources,
   parsePatch,
   rollupSupervisorRuns,
+  DEFAULT_SPAWN_TOOLS,
+  DEFAULT_STEER_TOOLS,
+  DEFAULT_CANCEL_TOOLS,
+  readClaudeCodeSupervisorRun,
+  claudeCodeSupervisorRunReader,
   renderSupervisorRunHeadline,
   renderSupervisorRunMarkdown,
   renderSupervisorRollupMarkdown,
@@ -1148,4 +1641,4 @@ export {
   findSupervisorRunDirs,
   supervisorRunRolloutLines
 };
-//# sourceMappingURL=chunk-4Y7AAATF.js.map
+//# sourceMappingURL=chunk-LKKT3IVV.js.map