@koda-sl/baker-bridge 0.155.0-dev.25961ab20 → 0.155.0-dev.d0f8a7fd4

package/dist/review/digest.js

@@ -15,7 +15,9 @@
  * it could NOT find, so missing evidence is a fact before the model starts
  * rather than a silence it fills in.
  */
+import { createHash } from "node:crypto";
 import { imageSize } from "image-size";
+import { parse } from "unbash";
 import { languageMismatch, marketerWords, messageLanguage } from "./reply-language.js";
 /** Parse a `.jsonl` body, dropping lines that are not JSON rather than failing. */
 export function parseTranscript(body) {
@@ -289,6 +291,49 @@ function clip(text, max = TRUNCATE) {
 function currentTurn(acc) {
     return acc.turns[acc.turns.length - 1];
 }
+/** One conversation inside a thread: the main agent, or one subagent. */
+function conversationKey(threadId, agentId) {
+    return `${threadId ?? ""}\u0000${agentId ?? ""}`;
+}
+function isSubagentLine(line) {
+    return line.isSidechain === true || line.isSubagent === true;
+}
+/**
+ * The turn a line belongs to.
+ *
+ * A subagent's own file is read after the whole session file it was spawned
+ * in, so the turn open by then is that session's last one. Charged to it, a
+ * fan-out in turn 1 was listed under the re-render turn 2 — its refusals, its
+ * denials and its parent's closing recap as their intent. A subagent belongs to
+ * the last turn of its thread that began before the prompt that started it, or
+ * before the later prompt that continued it.
+ */
+function turnIndexOf(acc, line) {
+    const current = currentTurn(acc)?.index;
+    if (!isSubagentLine(line)) {
+        return current;
+    }
+    const key = line.agentId === undefined ? undefined : conversationKey(line.threadId, line.agentId);
+    const known = key === undefined ? undefined : acc.subagentTurns.get(key);
+    if (known !== undefined) {
+        return known;
+    }
+    const at = stampOf(line.timestamp);
+    if (at === undefined) {
+        return current;
+    }
+    let spawned;
+    for (const turn of acc.turns) {
+        const began = stampOf(turn.timestamp);
+        if (turn.threadId === line.threadId && began !== undefined && began <= at) {
+            spawned = turn.index;
+        }
+    }
+    if (key !== undefined && spawned !== undefined) {
+        acc.subagentTurns.set(key, spawned);
+    }
+    return spawned ?? current;
+}
 /**
  * Close the open turn at the latest line that still belongs to it.
  *
@@ -302,7 +347,8 @@ function currentTurn(acc) {
  */
 function noteTurnEnd(acc, line) {
     const at = stampOf(line.timestamp);
-    const turn = currentTurn(acc);
+    const index = turnIndexOf(acc, line);
+    const turn = index === undefined ? undefined : acc.turns[index];
     if (at === undefined || turn === undefined) {
         return;
     }
@@ -420,26 +466,38 @@ export function namedGuard(message) {
     }
     return undefined;
 }
-/** Ledger a failed call: its class, the guard row, and the turn's denial count when a guard refused it. */
-function absorbFailure(acc, call, block) {
+/**
+ * Ledger a failure: its class, the guard row, and the turn's denial count when a
+ * guard refused it. A call can fail more than once — each `baker` call one
+ * command line ran — and its own class and message are its first failure's.
+ */
+function absorbFailure(acc, call, message, failureClass = classifyFailure(message)) {
     const turn = acc.turns[call.turn];
-    const message = typeof block.content === "string" ? block.content : String(block.content ?? "");
-    call.failureClass = classifyFailure(message);
-    if (turn && call.failureClass === "refused") {
+    call.isError = true;
+    call.failureClass ??= failureClass;
+    if (turn && failureClass === "refused") {
         turn.denials += 1;
     }
-    acc.failureMessages.set(call.toolUseId, clip(message, 400));
+    if (!acc.failureMessages.has(call.toolUseId)) {
+        acc.failureMessages.set(call.toolUseId, clip(message, 400));
+    }
     const guard = namedGuard(message);
+    // A subagent's words, never the turn's: the turn's are its parent's.
+    const intent = call.isSidechain
+        ? acc.subagentWords.get(conversationKey(call.threadId, call.agentId))
+        : turn?.assistantText || undefined;
     acc.guards.push({
         turn: call.turn,
         ...(call.threadId === undefined ? {} : { threadId: call.threadId }),
         toolUseId: call.toolUseId,
         tool: call.tool,
         attempted: call.summary,
+        inputKey: call.inputKey,
         message: clip(message, 400),
-        refusal: call.failureClass === "refused",
+        refusal: failureClass === "refused",
         ...(guard === undefined ? {} : { guard }),
-        ...(turn?.assistantText ? { intent: clip(turn.assistantText, 300) } : {}),
+        ...(intent ? { intent: clip(intent, 300) } : {}),
+        ...(call.isSidechain && call.agentId !== undefined ? { agentId: call.agentId } : {}),
         repeats: 1,
     });
 }
@@ -457,12 +515,11 @@ function absorbToolResults(acc, line) {
         const seen = measureToolResult(block.content);
         call.resultBytes = seen.bytes;
         call.resultTokens = seen.tokens;
-        call.isError = block.is_error === true;
         if (line.timestamp !== undefined) {
             acc.answeredAt.set(call.toolUseId, line.timestamp);
         }
-        if (call.isError) {
-            absorbFailure(acc, call, block);
+        if (block.is_error === true) {
+            absorbFailure(acc, call, typeof block.content === "string" ? block.content : String(block.content ?? ""));
         }
     }
 }
@@ -490,6 +547,11 @@ function absorbUserLine(acc, line) {
     absorbToolResults(acc, line);
     const spoken = raw.replace(SYSTEM_REMINDER, "").trim();
     const isToolResult = blocks(line).some((block) => block.type === "tool_result");
+    if (isSubagentLine(line) && !isToolResult && spoken.length > 0) {
+        // A prompt to a subagent: its spawn, or a later turn continuing it (`SendMessage`
+        // keeps the id), so the turn it belongs to is read again from this line.
+        acc.subagentTurns.delete(conversationKey(line.threadId, line.agentId));
+    }
     if (line.isSidechain || line.isSubagent || isToolResult || spoken.length === 0) {
         return;
     }
@@ -509,6 +571,7 @@ function absorbUserLine(acc, line) {
         outputTokens: 0,
         cacheReadTokens: 0,
         cacheWriteTokens: 0,
+        subagent: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 },
         denials: 0,
         compacted: false,
     });
@@ -535,21 +598,25 @@ function absorbRequestUsage(acc, line, turnAt) {
         acc.countedRequests.add(requestId);
     }
     const usage = line.message?.usage ?? {};
+    const subagent = isSubagentLine(line);
     const request = {
         turn: turnAt,
         ...(line.message?.model === undefined ? {} : { model: line.message.model }),
+        subagent,
+        ...(subagent && line.agentId !== undefined ? { agentId: line.agentId } : {}),
         inputTokens: usage.input_tokens ?? 0,
         outputTokens: usage.output_tokens ?? 0,
         cacheReadTokens: usage.cache_read_input_tokens ?? 0,
         cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
     };
     acc.requests.push(request);
-    const turn = currentTurn(acc);
+    const turn = acc.turns[turnAt];
     if (turn) {
-        turn.inputTokens += request.inputTokens;
-        turn.outputTokens += request.outputTokens;
-        turn.cacheReadTokens += request.cacheReadTokens;
-        turn.cacheWriteTokens += request.cacheWriteTokens;
+        const usage = subagent ? turn.subagent : turn;
+        usage.inputTokens += request.inputTokens;
+        usage.outputTokens += request.outputTokens;
+        usage.cacheReadTokens += request.cacheReadTokens;
+        usage.cacheWriteTokens += request.cacheWriteTokens;
     }
 }
 function buildToolCall(input) {
@@ -561,6 +628,10 @@ function buildToolCall(input) {
         toolUseId: input.block.id ?? `${input.turnAt}:${input.index}`,
         tool,
         summary: clip(summarizeInput(tool, input.block.input), 400),
+        inputKey: createHash("sha256")
+            .update(JSON.stringify(input.block.input ?? {}))
+            .digest("hex")
+            .slice(0, 16),
         ...(bakerVerb ? { bakerVerb } : {}),
         resultBytes: 0,
         resultTokens: 0,
@@ -581,6 +652,12 @@ function userFacingMessage(turn, text, marketerLanguage) {
         ...(mismatch === undefined ? {} : { languageMismatch: mismatch }),
     };
 }
+/** A Bash call's whole command, which placing a failed `baker` call on it reads. */
+function rememberCommand(acc, call, use) {
+    if (call.tool === "Bash" && typeof use.input?.command === "string") {
+        acc.commands.set(call.toolUseId, use.input.command);
+    }
+}
 /** Ledger each tool call a response asked for, under the response it came in. */
 function absorbToolUses(acc, line, turnAt, isSidechain) {
     const uses = blocks(line).filter((block) => block.type === "tool_use");
@@ -597,6 +674,7 @@ function absorbToolUses(acc, line, turnAt, isSidechain) {
         });
         acc.toolCalls.push(call);
         acc.pending.set(call.toolUseId, call);
+        rememberCommand(acc, call, use);
         if (requestId !== undefined) {
             acc.batches.set(requestId, [...(acc.batches.get(requestId) ?? []), call]);
         }
@@ -608,12 +686,16 @@ function absorbToolUses(acc, line, turnAt, isSidechain) {
     return uses.length;
 }
 function absorbAssistantLine(acc, line) {
-    const turnAt = currentTurn(acc)?.index ?? 0;
+    const turnAt = turnIndexOf(acc, line) ?? 0;
     absorbRequestUsage(acc, line, turnAt);
-    const isSidechain = line.isSidechain === true || line.isSubagent === true;
+    const isSidechain = isSubagentLine(line);
     const uses = absorbToolUses(acc, line, turnAt, isSidechain);
     const text = textOf(line);
-    if (text.trim().length === 0 || isSidechain) {
+    if (text.trim().length === 0) {
+        return;
+    }
+    if (isSidechain) {
+        acc.subagentWords.set(conversationKey(line.threadId, line.agentId), text);
         return;
     }
     const turn = currentTurn(acc);
@@ -667,6 +749,122 @@ function timeCalls(acc) {
             call.durationMs = took;
         }
     }
+    return startOf;
+}
+/** Whether the CLI says an invocation failed: a non-zero exit, or an `ok: false` envelope it printed. */
+function cliFailed(invocation) {
+    return (invocation.exitCode !== undefined && invocation.exitCode !== 0) || invocation.error !== undefined;
+}
+/**
+ * What the CLI said about a failed invocation, and nothing the agent typed: the
+ * class is read from this, so `--title "Fix checkout timeout"` is not a timeout.
+ */
+function cliErrorOf(invocation) {
+    const exit = invocation.exitCode === undefined ? "failed" : `exited ${invocation.exitCode}`;
+    return invocation.error === undefined ? exit : `${invocation.error.code}: ${invocation.error.message} — ${exit}`;
+}
+/** The error first, so clipping a long command never takes the code with it. */
+function describeCliFailure(invocation) {
+    return invocation.error === undefined
+        ? `\`baker ${invocation.argv.join(" ")}\` ${cliErrorOf(invocation)}`
+        : `${cliErrorOf(invocation)} — \`baker ${invocation.argv.join(" ")}\``;
+}
+/**
+ * The arguments of every `baker` command a shell command line runs, read the way
+ * the shell reads it: dequoted, inside pipes, lists, loops and substitutions,
+ * never inside a heredoc body or a quoted string.
+ */
+function bakerArgvsOf(command) {
+    const script = parse(command);
+    if (script.errors && script.errors.length > 0) {
+        return [];
+    }
+    const argvs = [];
+    // Serialised because unbash materialises a word's parts only in `toJSON`.
+    JSON.stringify(script, (_key, value) => {
+        const node = value;
+        if (node?.type === "Command" && typeof node.name?.value === "string" && /(?:^|\/)baker$/.test(node.name.value)) {
+            argvs.push((node.suffix ?? []).map((word) => String(word.value ?? "")));
+        }
+        return value;
+    });
+    return argvs;
+}
+/** A word the shell expands before `baker` sees it, and so matches whatever argument it became. */
+const EXPANDED_WORD = /[$*?[`]/;
+/** Whether a command's own `baker` words are the ones an invocation received. */
+function ranInvocation(words, argv) {
+    return words.length === argv.length && words.every((word, index) => word === argv[index] || EXPANDED_WORD.test(word));
+}
+/**
+ * The Bash call a `baker` invocation ran inside: the one running when it
+ * started whose command runs exactly that `baker` call.
+ *
+ * Nothing else places it. Subagents run side by side, so two running calls can
+ * share a platform (`baker ads meta campaigns`, `baker ads meta ads pause`), and
+ * a watcher or a hook calls `baker` while an unrelated command runs; a failure
+ * pinned on whichever call was running reports a success as failed and the
+ * failed call as a success. When no running call ran it, or more than one did,
+ * it is left unplaced.
+ */
+function callRunning(invocation, acc, startOf, argvsOf) {
+    const at = stampOf(invocation.startedAt);
+    if (at === undefined) {
+        return undefined;
+    }
+    const ran = acc.toolCalls.filter((call) => {
+        const from = stampOf(startOf.get(call.toolUseId));
+        const to = stampOf(acc.answeredAt.get(call.toolUseId));
+        return (call.tool === "Bash" &&
+            from !== undefined &&
+            to !== undefined &&
+            from <= at &&
+            at <= to &&
+            argvsOf(call).some((words) => ranInvocation(words, invocation.argv)));
+    });
+    return ran.length === 1 ? ran[0] : undefined;
+}
+/**
+ * Count a `baker` call that failed as a failure, whatever its shell returned.
+ *
+ * A Bash result is an error only when the whole command line exited non-zero,
+ * and `| head`, `> file` or a later `; echo` make that zero. Read from the tool
+ * result alone, a Session whose every refused or timed-out `baker` call was
+ * piped reported "none of them failed" — while the CLI's own record said why
+ * each one did. A failure no call can be placed on is returned, never dropped.
+ */
+function absorbCliFailures(acc, cli, startOf) {
+    const unplaced = [];
+    const failedIn = new Map();
+    const argvs = new Map();
+    const argvsOf = (call) => {
+        const known = argvs.get(call.toolUseId) ?? bakerArgvsOf(acc.commands.get(call.toolUseId) ?? "");
+        argvs.set(call.toolUseId, known);
+        return known;
+    };
+    for (const invocation of cli.filter(cliFailed)) {
+        const call = callRunning(invocation, acc, startOf, argvsOf);
+        if (call === undefined) {
+            unplaced.push(invocation);
+        }
+        else if (!call.isError) {
+            failedIn.set(call, [...(failedIn.get(call) ?? []), invocation]);
+        }
+    }
+    for (const [call, invocations] of failedIn) {
+        const failures = invocations.map((invocation) => ({
+            failureClass: classifyFailure(cliErrorOf(invocation)),
+            message: clip(describeCliFailure(invocation), 400),
+            durationMs: invocation.durationMs ?? 0,
+        }));
+        for (const failure of failures) {
+            absorbFailure(acc, call, failure.message, failure.failureClass);
+        }
+        acc.cliFailures.set(call.toolUseId, failures);
+    }
+    const order = new Map(acc.toolCalls.map((call, index) => [call.toolUseId, index]));
+    acc.guards.sort((a, b) => (order.get(a.toolUseId) ?? 0) - (order.get(b.toolUseId) ?? 0));
+    return unplaced;
 }
 /** The latest of some ISO timestamps, or nothing when none is given. */
 function latest(stamps) {
@@ -698,7 +896,7 @@ function attributeGuardFollowUps(guards, calls) {
             .find((call) => call.threadId === refused.threadId &&
             call.isSidechain === refused.isSidechain &&
             call.agentId === refused.agentId &&
-            call.summary !== guard.attempted);
+            call.inputKey !== refused.inputKey);
         if (after) {
             guard.nextAction = `${after.tool}: ${clip(after.summary, 160)}`;
         }
@@ -715,15 +913,15 @@ function attributeGuardFollowUps(guards, calls) {
 function countGuardRepeats(guards) {
     const counts = new Map();
     for (const guard of guards) {
-        const key = `${guard.tool}\u0000${guard.attempted}\u0000${guard.guard ?? guard.message}`;
+        const key = `${guard.tool}\u0000${guard.inputKey}\u0000${guard.guard ?? guard.message}`;
         counts.set(key, (counts.get(key) ?? 0) + 1);
     }
     for (const guard of guards) {
-        const key = `${guard.tool}\u0000${guard.attempted}\u0000${guard.guard ?? guard.message}`;
+        const key = `${guard.tool}\u0000${guard.inputKey}\u0000${guard.guard ?? guard.message}`;
         guard.repeats = counts.get(key) ?? 1;
     }
 }
-export function buildTranscriptDigest(lines) {
+export function buildTranscriptDigest(lines, cli = []) {
     const acc = {
         turns: [],
         toolCalls: [],
@@ -739,6 +937,10 @@ export function buildTranscriptDigest(lines) {
         marketerLanguage: new Map(),
         batches: new Map(),
         answeredAt: new Map(),
+        subagentTurns: new Map(),
+        subagentWords: new Map(),
+        commands: new Map(),
+        cliFailures: new Map(),
     };
     for (const line of lines) {
         const openTurns = acc.turns.length;
@@ -770,7 +972,8 @@ export function buildTranscriptDigest(lines) {
         call.failureClass = "timeout";
         acc.failureMessages.set(call.toolUseId, "No result was ever recorded for this call.");
     }
-    timeCalls(acc);
+    const startOf = timeCalls(acc);
+    const unplacedCliFailures = absorbCliFailures(acc, cli, startOf);
     attributeGuardFollowUps(acc.guards, acc.toolCalls);
     countGuardRepeats(acc.guards);
     const threadStamps = stampsByThread(lines);
@@ -789,7 +992,8 @@ export function buildTranscriptDigest(lines) {
             .filter((call) => call.durationMs !== undefined)
             .sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0))
             .slice(0, 15),
-        failures: aggregateFailures(acc.toolCalls, acc.failureMessages),
+        failures: aggregateFailures(acc.toolCalls, acc.failureMessages, acc.cliFailures),
+        unplacedCliFailures: unplacedCliFailures.map(describeCliFailure),
         flaky: findFlakyCalls(acc.toolCalls),
         introspectionCalls: acc.toolCalls.filter((call) => call.bakerVerb?.startsWith("baker schema") || /--help\b/.test(call.summary)),
         hooks: [...acc.hooks.values()].sort((a, b) => b.fired - a.fired),
@@ -809,30 +1013,37 @@ export function buildTranscriptDigest(lines) {
  * a bad moment, eleven of them at the same bound is a default set for a network
  * this sandbox does not have.
  */
-function aggregateFailures(calls, messages) {
+function ownFailure(call, failureClass, messages) {
+    return { failureClass, message: messages.get(call.toolUseId) ?? "", durationMs: call.durationMs ?? 0 };
+}
+function aggregateFailures(calls, messages, cliFailures) {
     const map = new Map();
     for (const call of calls) {
         if (!call.isError || call.failureClass === undefined) {
             continue;
         }
-        const key = `${call.failureClass}::${call.tool}`;
-        const entry = map.get(key) ?? {
-            failureClass: call.failureClass,
-            tool: call.tool,
-            calls: 0,
-            totalMs: 0,
-            example: messages.get(call.toolUseId) ?? "",
-            turns: [],
-        };
-        entry.calls += 1;
-        entry.totalMs += call.durationMs ?? 0;
-        if (entry.example.length === 0) {
-            entry.example = messages.get(call.toolUseId) ?? "";
-        }
-        if (!entry.turns.includes(call.turn)) {
-            entry.turns.push(call.turn);
+        // A command line that ran several failed `baker` calls counts each of them.
+        const failures = cliFailures.get(call.toolUseId) ?? [ownFailure(call, call.failureClass, messages)];
+        for (const failure of failures) {
+            const key = `${failure.failureClass}::${call.tool}`;
+            const entry = map.get(key) ?? {
+                failureClass: failure.failureClass,
+                tool: call.tool,
+                calls: 0,
+                totalMs: 0,
+                example: failure.message,
+                turns: [],
+            };
+            entry.calls += 1;
+            entry.totalMs += failure.durationMs;
+            if (entry.example.length === 0) {
+                entry.example = failure.message;
+            }
+            if (!entry.turns.includes(call.turn)) {
+                entry.turns.push(call.turn);
+            }
+            map.set(key, entry);
         }
-        map.set(key, entry);
     }
     return [...map.values()].sort((a, b) => b.calls - a.calls);
 }
@@ -847,7 +1058,7 @@ function aggregateFailures(calls, messages) {
 function findFlakyCalls(calls) {
     const groups = new Map();
     for (const call of calls) {
-        const key = `${call.tool}\u0000${call.summary}`;
+        const key = `${call.tool}\u0000${call.inputKey}`;
         groups.set(key, [...(groups.get(key) ?? []), call]);
     }
     const out = [];
@@ -877,7 +1088,18 @@ function findFlakyCalls(calls) {
  * and this is what says where in the Session to look.
  */
 function emptyThread(threadId) {
-    return { threadId, turns: 0, toolCalls: 0, resultBytes: 0, resultTokens: 0, errors: 0, denials: 0, workingMs: 0 };
+    return {
+        threadId,
+        turns: 0,
+        toolCalls: 0,
+        resultBytes: 0,
+        resultTokens: 0,
+        subagentToolCalls: 0,
+        subagentResultTokens: 0,
+        errors: 0,
+        denials: 0,
+        workingMs: 0,
+    };
 }
 /** Milliseconds parsed off an ISO timestamp, or nothing. */
 function stampOf(value) {
@@ -914,6 +1136,8 @@ function aggregateByThread(turns, calls, stamps) {
         entry.toolCalls += 1;
         entry.resultBytes += call.resultBytes;
         entry.resultTokens += call.resultTokens;
+        entry.subagentToolCalls += call.isSidechain ? 1 : 0;
+        entry.subagentResultTokens += call.isSidechain ? call.resultTokens : 0;
         entry.errors += call.isError ? 1 : 0;
     }
     for (const [threadId, values] of stamps) {
@@ -930,14 +1154,18 @@ function aggregateByTool(calls) {
         const entry = map.get(call.tool) ?? {
             tool: call.tool,
             calls: 0,
+            subagentCalls: 0,
             totalBytes: 0,
             totalTokens: 0,
+            subagentTokens: 0,
             maxBytes: 0,
             errors: 0,
         };
         entry.calls += 1;
+        entry.subagentCalls += call.isSidechain ? 1 : 0;
         entry.totalBytes += call.resultBytes;
         entry.totalTokens += call.resultTokens;
+        entry.subagentTokens += call.isSidechain ? call.resultTokens : 0;
         entry.maxBytes = Math.max(entry.maxBytes, call.resultBytes);
         entry.errors += call.isError ? 1 : 0;
         map.set(call.tool, entry);
@@ -974,7 +1202,7 @@ function aggregateByVerb(calls) {
 function findRepeats(calls) {
     const seen = new Map();
     for (const call of calls) {
-        const key = `${call.tool}\u0000${call.summary}`;
+        const key = `${call.tool}\u0000${call.inputKey}`;
         const entry = seen.get(key);
         if (entry) {
             entry.extra += 1;
@@ -1029,6 +1257,9 @@ function absorbInvocation(entry, line) {
         return;
     }
     entry.argv = line.argv;
+    if (line.ts !== undefined) {
+        entry.startedAt = line.ts;
+    }
     const verb = bakerVerbOf(`baker ${line.argv.join(" ")}`);
     if (verb) {
         entry.verb = verb;
@@ -1053,14 +1284,38 @@ function absorbExit(entry, line) {
         entry.durationMs = line.durationMs;
     }
 }
+/** What it printed, and the error it reported when the text is an `ok: false` envelope. */
+function absorbOutput(entry, line) {
+    if (typeof line.text !== "string") {
+        return;
+    }
+    entry.printedBytes += Buffer.byteLength(line.text);
+    const error = printedError(line.text);
+    if (error !== undefined && entry.error === undefined) {
+        entry.error = error;
+    }
+}
+function printedError(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null || parsed.ok !== false) {
+        return undefined;
+    }
+    const error = parsed.error;
+    return {
+        code: typeof error?.code === "string" ? error.code : "ERROR",
+        message: typeof error?.message === "string" ? error.message : "",
+    };
+}
 const DEBUG_LINE_HANDLERS = {
     invocation: absorbInvocation,
     http: absorbHttpCall,
-    output: (entry, line) => {
-        if (typeof line.text === "string") {
-            entry.printedBytes += Buffer.byteLength(line.text);
-        }
-    },
+    output: absorbOutput,
     exit: absorbExit,
 };
 /**
@@ -1141,12 +1396,25 @@ export function renderTurns(digest) {
         "",
         digest.threads.length === 0
             ? "No thread could be attributed — the transcripts carried no thread id."
-            : table(["thread", "turns", "tool calls", "result bytes", "~result tokens", "errors", "denials", "running"], digest.threads.map((thread) => [
+            : table([
+                "thread",
+                "turns",
+                "tool calls",
+                "subagent calls",
+                "result bytes",
+                "~main result tokens",
+                "~subagent result tokens",
+                "errors",
+                "denials",
+                "running",
+            ], digest.threads.map((thread) => [
                 thread.threadId,
                 thread.turns,
                 thread.toolCalls,
+                thread.subagentToolCalls,
                 thread.resultBytes,
-                thread.resultTokens,
+                thread.resultTokens - thread.subagentResultTokens,
+                thread.subagentResultTokens,
                 thread.errors,
                 thread.denials,
                 `${Math.round(thread.workingMs / 1000)}s`,
@@ -1154,7 +1422,25 @@ export function renderTurns(digest) {
         "",
         "## Every turn",
         "",
-        table(["#", "thread", "at", "user", "assistant", "tools", "in", "out", "cache read", "denials", "compacted"], digest.turns.map((turn) => [
+        "`in`, `out` and `cache read` are the main agent's context; `subagent` columns",
+        "are what that turn's subagents spent, which never reached it.",
+        "",
+        table([
+            "#",
+            "thread",
+            "at",
+            "user",
+            "assistant",
+            "tools",
+            "in",
+            "out",
+            "cache read",
+            "subagent in",
+            "subagent out",
+            "subagent cache read",
+            "denials",
+            "compacted",
+        ], digest.turns.map((turn) => [
             turn.index,
             turn.threadId ?? "",
             turn.timestamp ?? "",
@@ -1164,23 +1450,36 @@ export function renderTurns(digest) {
             turn.inputTokens,
             turn.outputTokens,
             turn.cacheReadTokens,
+            turn.subagent.inputTokens,
+            turn.subagent.outputTokens,
+            turn.subagent.cacheReadTokens,
             turn.denials,
             turn.compacted ? "yes" : "",
         ])),
         "",
     ].join("\n");
 }
+/** Who made a call: the main agent, or the subagent by its id. */
+function agentOf(call) {
+    return call.isSidechain ? `subagent ${call.agentId ?? "(unnamed)"}` : "main";
+}
 export function renderTools(digest) {
     const sections = [
         "# Tool calls",
         "",
         "## Per tool",
         "",
-        table(["tool", "calls", "total bytes", "~total tokens", "max bytes", "errors"], digest.byTool.map((entry) => [
+        "`main` is what the agent the marketer talks to called; `subagent` ran in a",
+        "subagent, and its results never reached the main agent's context.",
+        "",
+        table(["tool", "calls", "main", "subagent", "total bytes", "~main tokens", "~subagent tokens", "max bytes", "errors"], digest.byTool.map((entry) => [
             entry.tool,
             entry.calls,
+            entry.calls - entry.subagentCalls,
+            entry.subagentCalls,
             entry.totalBytes,
-            entry.totalTokens,
+            entry.totalTokens - entry.subagentTokens,
+            entry.subagentTokens,
             entry.maxBytes,
             entry.errors,
         ])),
@@ -1208,7 +1507,14 @@ export function renderTools(digest) {
         "",
         "## Ten largest single results (by what the model received)",
         "",
-        table(["turn", "tool", "input", "bytes", "~tokens"], digest.largestResults.map((call) => [call.turn, call.tool, call.summary, call.resultBytes, call.resultTokens])),
+        table(["turn", "agent", "tool", "input", "bytes", "~tokens"], digest.largestResults.map((call) => [
+            call.turn,
+            agentOf(call),
+            call.tool,
+            call.summary,
+            call.resultBytes,
+            call.resultTokens,
+        ])),
         "",
         "## Introspection calls (`baker schema`, `--help`)",
         "",
@@ -1258,6 +1564,17 @@ export function renderFailures(digest) {
                 clip(entry.example, 160),
             ])),
         "",
+        ...(digest.unplacedCliFailures.length === 0
+            ? []
+            : [
+                "## Failed `baker` calls no tool call can be placed on",
+                "",
+                "The CLI recorded these as failed, and when each started no loaded transcript",
+                "had exactly one running Bash call whose command ran that `baker` call.",
+                "",
+                ...digest.unplacedCliFailures.map((failure) => `- ${clip(failure, 300)}`),
+                "",
+            ]),
         "## The same call, two answers",
         "",
         "Identical tool and input, one attempt failing and another succeeding, with",
@@ -1279,8 +1596,9 @@ export function renderFailures(digest) {
         "",
         digest.slowest.length === 0
             ? "No call carried both a request and a result timestamp, so nothing here can be timed."
-            : table(["turn", "tool", "took", "failed", "input"], digest.slowest.map((call) => [
+            : table(["turn", "agent", "tool", "took", "failed", "input"], digest.slowest.map((call) => [
                 call.turn,
+                agentOf(call),
                 call.tool,
                 secs(call.durationMs ?? 0),
                 call.isError ? (call.failureClass ?? "yes") : "",
@@ -1304,6 +1622,9 @@ export function renderHooks(digest) {
         "",
     ].join("\n");
 }
+function guardAgent(guard) {
+    return guard.agentId === undefined ? "" : ` · subagent ${guard.agentId}`;
+}
 export function renderGuards(digest) {
     const refusals = digest.guards.filter((guard) => guard.refusal);
     const errors = digest.guards.filter((guard) => !guard.refusal);
@@ -1323,13 +1644,14 @@ export function renderGuards(digest) {
             : [
                 `${refusals.length} refusals.`,
                 "",
-                "`Intent` is the agent's own words in that turn — what it thought it",
-                "was doing. It is the transcript's only answer to why it went there;",
+                "`Intent` is the refused agent's own words — the main agent's in that",
+                "turn, or the subagent's own when a subagent was refused: what it thought",
+                "it was doing. It is the transcript's only answer to why it went there;",
                 "the rest of the answer is in whatever doc, skill, hint or example",
                 "pointed it that way, which is yours to go and open.",
                 "",
                 ...refusals.map((guard) => [
-                    `### Turn ${guard.turn} · ${guard.tool}${guard.guard ? ` · ${guard.guard}` : ""}${guard.repeats > 1 ? ` · refused ${guard.repeats}× this Session` : ""}`,
+                    `### Turn ${guard.turn}${guardAgent(guard)} · ${guard.tool}${guard.guard ? ` · ${guard.guard}` : ""}${guard.repeats > 1 ? ` · refused ${guard.repeats}× this Session` : ""}`,
                     "",
                     `Attempted: \`${guard.attempted}\``,
                     "",
@@ -1348,7 +1670,7 @@ export function renderGuards(digest) {
             ? "No tool returned an error."
             : errors
                 .map((guard) => [
-                `### Turn ${guard.turn} · ${guard.tool}${guard.repeats > 1 ? ` · ${guard.repeats}×` : ""}`,
+                `### Turn ${guard.turn}${guardAgent(guard)} · ${guard.tool}${guard.repeats > 1 ? ` · ${guard.repeats}×` : ""}`,
                 "",
                 `Attempted: \`${guard.attempted}\``,
                 "",