@koda-sl/baker-bridge 0.154.0-dev.db7cf2f5d → 0.154.0-dev.eb1bb1bf7

package/dist/review/digest.js

@@ -15,6 +15,7 @@
  * 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 { languageMismatch, marketerWords, messageLanguage } from "./reply-language.js";
 /** Parse a `.jsonl` body, dropping lines that are not JSON rather than failing. */
@@ -289,6 +290,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 +346,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;
     }
@@ -430,16 +475,22 @@ function absorbFailure(acc, call, block) {
     }
     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",
         ...(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,
     });
 }
@@ -490,6 +541,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 +565,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 +592,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 +622,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,
@@ -608,12 +673,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);
@@ -698,7 +767,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,11 +784,11 @@ 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;
     }
 }
@@ -739,6 +808,8 @@ export function buildTranscriptDigest(lines) {
         marketerLanguage: new Map(),
         batches: new Map(),
         answeredAt: new Map(),
+        subagentTurns: new Map(),
+        subagentWords: new Map(),
     };
     for (const line of lines) {
         const openTurns = acc.turns.length;
@@ -847,7 +918,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 +948,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 +996,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 +1014,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 +1062,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;
@@ -1141,12 +1229,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 +1255,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 +1283,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 +1340,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`)",
         "",
@@ -1279,8 +1418,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 +1444,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 +1466,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 +1492,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}\``,
                 "",