@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.11

package/dist/worker/console/chat/context-insights.js

@@ -0,0 +1,723 @@
+/**
+ * Operator Chat — context insights projection (dsh-context parity).
+ *
+ * Folds the durable Chat event ring into a context-insight dashboard view:
+ *  - current composition (what the window is made of, provider-anchored)
+ *  - per-request trend with step briefs, turn grouping, delta mode support
+ *  - context browser elements (category → items with token estimates and
+ *    bounded content previews, diffable between steps)
+ *  - context lifecycle events (injections / compactions / prunes) with chips
+ *  - per-file activity (reads/writes/searches, line deltas, op log)
+ *  - usage totals (cache hit, cost when reported) and timing stats
+ *
+ * Estimates use the same conservative fixed-density heuristic as the
+ * compaction policy (conservativeTokenEstimate), so figures never disagree
+ * with the harness's own pressure decisions. The projection is derived
+ * EXCLUSIVELY from persisted events + bounded previews the server already
+ * stores — it invents no payload text and never re-reads the live Pi session,
+ * so it works for idle and restored sessions alike.
+ */
+import { conservativeTokenEstimate } from "../../../shared/pi-context-pressure/compaction-policy.js";
+/** Fixed-density token estimate for preview text (chars → tokens). */
+export function estimateTokensFromText(text) {
+    if (!text)
+        return 0;
+    return conservativeTokenEstimate(text);
+}
+/** Hard cap on a single element's preview content (chars). */
+const ELEMENT_PREVIEW_MAX = 8_000;
+/** Max elements retained per browser category. */
+const ELEMENT_LIST_CAP = 200;
+const COMPOSITION_CATEGORY_ORDER = [
+    "system",
+    "tools",
+    "user",
+    "injected",
+    "assistant",
+    "toolResults",
+];
+const BROWSER_CATEGORY_ORDER = [
+    "system",
+    "tools",
+    "messages",
+    "injected",
+    "toolResults",
+    "skills",
+];
+function emptyComposition() {
+    return {
+        totalTokens: 0,
+        contextWindow: null,
+        occupancy: null,
+        headroom: null,
+        slices: COMPOSITION_CATEGORY_ORDER.map((category) => ({
+            category,
+            tokens: 0,
+            items: 0,
+        })),
+        providerTotal: null,
+    };
+}
+function sliceOf(composition, category) {
+    const slice = composition.slices.find((item) => item.category === category);
+    if (!slice) {
+        throw new Error(`composition slice missing: ${category}`);
+    }
+    return slice;
+}
+function addSlice(composition, category, tokens, items = 1) {
+    const slice = sliceOf(composition, category);
+    slice.tokens += tokens;
+    slice.items += items;
+}
+function eventTimeMs(event) {
+    const parsed = Date.parse(event.at);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function asRecord(value) {
+    return value && typeof value === "object"
+        ? value
+        : undefined;
+}
+function boundedText(value, max = 4_000) {
+    if (typeof value !== "string" || !value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+function elementPreview(value) {
+    return boundedText(value, ELEMENT_PREVIEW_MAX);
+}
+/** First string field on a tool-args record among candidates. */
+function argString(args, keys) {
+    for (const key of keys) {
+        const value = args[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+    }
+    return undefined;
+}
+function classifyToolOperation(toolName) {
+    const normalized = toolName.toLowerCase().replace(/[-_]/g, "");
+    if (normalized === "read" || normalized === "ls")
+        return "read";
+    if (normalized === "write" || normalized === "multiedit")
+        return "write";
+    if (normalized === "edit" ||
+        normalized === "strreplaceeditor" ||
+        normalized === "strreplacebasededittool" ||
+        normalized === "applypatch") {
+        return "edit";
+    }
+    if (normalized === "grep" ||
+        normalized === "rg" ||
+        normalized === "find" ||
+        normalized === "fd" ||
+        normalized === "glob") {
+        return "search";
+    }
+    if (normalized === "bash" ||
+        normalized === "powershell" ||
+        normalized === "pwsh") {
+        return "bash";
+    }
+    return "other";
+}
+const READ_PATH_KEYS = ["file_path", "path", "filePath", "filename", "name"];
+const SEARCH_PATH_KEYS = ["path", "dir", "directory", "include", "glob"];
+/** Extract touched file paths from a tool call's arguments preview. */
+export function filePathsFromToolArgs(toolName, args) {
+    const kind = classifyToolOperation(toolName);
+    const paths = [];
+    if (kind === "search") {
+        const query = argString(args, SEARCH_PATH_KEYS);
+        if (query)
+            paths.push(query);
+        return paths;
+    }
+    if (kind === "bash")
+        return paths;
+    const target = argString(args, READ_PATH_KEYS);
+    if (target)
+        paths.push(target);
+    return paths;
+}
+function lineDelta(oldText, newText) {
+    if (!newText)
+        return { added: 0, removed: 0 };
+    const newLines = newText.split("\n").length;
+    if (!oldText)
+        return { added: newLines, removed: 0 };
+    const oldLines = oldText.split("\n").length;
+    return {
+        added: Math.max(0, newLines - oldLines),
+        removed: Math.max(0, oldLines - newLines),
+    };
+}
+/** Parse a JSON args preview back into a record (best-effort, bounded). */
+function parseArgsPreview(preview) {
+    if (!preview)
+        return {};
+    try {
+        const parsed = JSON.parse(preview);
+        const record = asRecord(parsed);
+        return record ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function deltaFor(kind, args) {
+    if (kind !== "write" && kind !== "edit")
+        return undefined;
+    const delta = lineDelta(argString(args, ["oldText", "old_string", "oldStr"]), argString(args, ["content", "newText", "new_string", "newStr"]));
+    return {
+        ...(delta.added > 0 ? { linesAdded: delta.added } : {}),
+        ...(delta.removed > 0 ? { linesRemoved: delta.removed } : {}),
+    };
+}
+function num(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        return undefined;
+    }
+    return value;
+}
+function toolSourceChip(toolName) {
+    const normalized = toolName.toLowerCase();
+    if (normalized.startsWith("task") ||
+        normalized.startsWith("dag") ||
+        normalized.startsWith("worker") ||
+        normalized.startsWith("contract") ||
+        normalized.startsWith("observe") ||
+        normalized.startsWith("prepare") ||
+        normalized.startsWith("confirm")) {
+        return "operator";
+    }
+    if (normalized.startsWith("sql_"))
+        return "builtin:sql";
+    if (normalized.startsWith("mcp"))
+        return "mcp";
+    if (normalized.startsWith("agent") || normalized === "explore") {
+        return "builtin:subagent";
+    }
+    if (["read", "write", "edit", "bash", "grep", "find", "ls"].includes(normalized)) {
+        return "pi";
+    }
+    return "extension";
+}
+function contentBlocksThinking(blocks) {
+    if (!Array.isArray(blocks))
+        return false;
+    return blocks.some((block) => asRecord(block)?.type === "thinking" ||
+        asRecord(block)?.type === "reasoning");
+}
+function capElements(elements) {
+    return elements.slice(-ELEMENT_LIST_CAP);
+}
+/** Fold the event ring into the context insights view. */
+export function deriveContextInsights(events, options = {}) {
+    const ordered = [...events].sort((a, b) => a.seq - b.seq);
+    const composition = emptyComposition();
+    const trend = [];
+    const contextEvents = [];
+    const files = new Map();
+    const usage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        cost: null,
+        cacheHitPercent: null,
+        turns: 0,
+        steps: 0,
+        humanInputs: 0,
+    };
+    const timing = {
+        llmMs: 0,
+        toolMs: 0,
+        busyMs: 0,
+        wallMs: null,
+        overheadMs: null,
+        ttftMs: null,
+        decodeTokensPerSecond: null,
+        steps: 0,
+    };
+    const turnIds = [];
+    const turnStartMs = new Map();
+    const turnUserBrief = new Map();
+    const stepToolsCalled = new Map();
+    const toolStarts = new Map();
+    const ttftSamples = [];
+    const decodeSamples = [];
+    let contextWindow = null;
+    let providerTotal = null;
+    let lastSeq = 0;
+    let firstAt = null;
+    let lastAt = null;
+    // --- Live browser fold (the "next request" makeup) ---
+    const browserMessages = [];
+    const browserInjected = [];
+    const browserToolResults = [];
+    if (options.systemPromptPreview) {
+        addSlice(composition, "system", estimateTokensFromText(options.systemPromptPreview));
+    }
+    else if (typeof options.systemPromptChars === "number" &&
+        options.systemPromptChars > 0) {
+        addSlice(composition, "system", conservativeTokenEstimate("x".repeat(Math.min(options.systemPromptChars, 2_000_000))));
+    }
+    const browserTools = (options.tools ?? []).map((tool, index) => {
+        const tokens = estimateTokensFromText(`${tool.id}${tool.description ? `: ${tool.description}` : ""}`);
+        return {
+            id: `tool:${tool.id}:${index}`,
+            label: tool.id,
+            tokens,
+            preview: elementPreview(tool.description),
+            toolSource: toolSourceChip(tool.id),
+            seq: 0,
+            at: "",
+        };
+    });
+    for (const tool of browserTools) {
+        addSlice(composition, "tools", tool.tokens);
+    }
+    const browserSkills = (options.skillInjections ?? []).map((skill, index) => ({
+        id: `skill:${skill.name}:${index}`,
+        label: skill.name,
+        tokens: skill.tokens,
+        seq: 0,
+        at: "",
+    }));
+    for (const event of ordered) {
+        lastSeq = event.seq;
+        const atMs = eventTimeMs(event);
+        if (atMs > 0) {
+            if (firstAt === null)
+                firstAt = atMs;
+            lastAt = atMs;
+        }
+        const data = asRecord(event.data) ?? {};
+        switch (event.kind) {
+            case "user_message": {
+                const message = asRecord(data.message);
+                const text = boundedText(message?.text, ELEMENT_PREVIEW_MAX);
+                if (text) {
+                    const tokens = estimateTokensFromText(text);
+                    addSlice(composition, "user", tokens);
+                    browserMessages.push({
+                        id: `user:${event.seq}`,
+                        label: "用户",
+                        tokens,
+                        preview: text,
+                        seq: event.seq,
+                        at: event.at,
+                    });
+                    if (!turnUserBrief.has(event.turnId)) {
+                        turnUserBrief.set(event.turnId, text.slice(0, 200));
+                    }
+                }
+                usage.humanInputs += 1;
+                if (!turnIds.includes(event.turnId))
+                    turnIds.push(event.turnId);
+                if (!turnStartMs.has(event.turnId) && atMs > 0) {
+                    turnStartMs.set(event.turnId, atMs);
+                }
+                break;
+            }
+            case "message_update":
+            case "message_end": {
+                const text = boundedText(data.text, ELEMENT_PREVIEW_MAX);
+                const thinking = contentBlocksThinking(data.content);
+                if (event.kind === "message_end") {
+                    usage.steps += 1;
+                    timing.steps += 1;
+                    if (!turnIds.includes(event.turnId))
+                        turnIds.push(event.turnId);
+                    if (text) {
+                        const tokens = estimateTokensFromText(text);
+                        addSlice(composition, "assistant", tokens);
+                        browserMessages.push({
+                            id: `assistant:${event.seq}`,
+                            label: thinking ? "助手（含思考）" : "助手",
+                            tokens,
+                            preview: text,
+                            seq: event.seq,
+                            at: event.at,
+                        });
+                    }
+                    const toolsCalled = stepToolsCalled.get(event.turnId) ?? [];
+                    const recorded = asRecord(data.timing);
+                    const llmMs = num(recorded?.llmMs) ?? null;
+                    if (llmMs !== null)
+                        timing.llmMs += llmMs;
+                    const ttft = num(recorded?.ttftMs);
+                    if (ttft !== undefined)
+                        ttftSamples.push(ttft);
+                    const decodeMs = num(recorded?.decodeMs);
+                    const outputTokens = num(recorded?.outputTokens);
+                    if (decodeMs !== undefined &&
+                        decodeMs > 0 &&
+                        outputTokens !== undefined) {
+                        decodeSamples.push({ ms: decodeMs, tokens: outputTokens });
+                    }
+                    const start = turnStartMs.get(event.turnId);
+                    const turnElapsedMs = start !== undefined && atMs >= start ? atMs - start : null;
+                    const stepComposition = emptyComposition();
+                    for (const slice of composition.slices) {
+                        const target = sliceOf(stepComposition, slice.category);
+                        target.tokens = slice.tokens;
+                        target.items = slice.items;
+                    }
+                    stepComposition.totalTokens = composition.slices.reduce((sum, slice) => sum + slice.tokens, 0);
+                    trend.push({
+                        index: trend.length + 1,
+                        turnId: event.turnId,
+                        turnIndex: turnIds.indexOf(event.turnId) + 1,
+                        at: event.at,
+                        seq: event.seq,
+                        composition: stepComposition.slices,
+                        totalTokens: stepComposition.totalTokens,
+                        actualPromptTokens: null,
+                        actualOutputTokens: null,
+                        actualCacheReadTokens: null,
+                        userBrief: turnUserBrief.get(event.turnId),
+                        responseBrief: text ? text.slice(0, 200) : undefined,
+                        toolsCalled,
+                        thinking,
+                        turnElapsedMs,
+                        llmMs,
+                    });
+                    stepToolsCalled.set(event.turnId, []);
+                }
+                break;
+            }
+            case "tool_call": {
+                const toolName = typeof data.toolName === "string" ? data.toolName : "";
+                const argsPreview = typeof data.argsPreview === "string" ? data.argsPreview : undefined;
+                const args = parseArgsPreview(argsPreview);
+                const atTime = eventTimeMs(event);
+                if (toolName) {
+                    const list = stepToolsCalled.get(event.turnId) ?? [];
+                    list.push(toolName);
+                    stepToolsCalled.set(event.turnId, list);
+                }
+                if (argsPreview) {
+                    const tokens = estimateTokensFromText(argsPreview);
+                    addSlice(composition, "injected", tokens);
+                    browserInjected.push({
+                        id: `args:${event.seq}`,
+                        label: toolName || "工具调用",
+                        tokens,
+                        preview: argsPreview,
+                        toolSource: toolName ? toolSourceChip(toolName) : undefined,
+                        seq: event.seq,
+                        at: event.at,
+                    });
+                }
+                if (toolName && atTime > 0) {
+                    const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : "";
+                    toolStarts.set(`${event.turnId}\u0000${toolCallId}`, atTime);
+                }
+                const kind = classifyToolOperation(toolName);
+                if (kind !== "other") {
+                    const paths = filePathsFromToolArgs(toolName, args);
+                    for (const path of paths) {
+                        const entry = files.get(path) ??
+                            {
+                                path,
+                                reads: 0,
+                                writes: 0,
+                                searches: 0,
+                                otherOps: 0,
+                                linesAdded: 0,
+                                linesRemoved: 0,
+                                operations: [],
+                            };
+                        if (kind === "read")
+                            entry.reads += 1;
+                        else if (kind === "write" || kind === "edit")
+                            entry.writes += 1;
+                        else if (kind === "search")
+                            entry.searches += 1;
+                        else
+                            entry.otherOps += 1;
+                        const opDelta = deltaFor(kind, args);
+                        if (opDelta) {
+                            entry.linesAdded += opDelta.linesAdded ?? 0;
+                            entry.linesRemoved += opDelta.linesRemoved ?? 0;
+                        }
+                        entry.operations.push({
+                            seq: event.seq,
+                            at: event.at,
+                            toolName: toolName || "unknown",
+                            kind,
+                            ...opDelta,
+                        });
+                        files.set(path, entry);
+                    }
+                }
+                break;
+            }
+            case "tool_result": {
+                const resultPreview = typeof data.resultPreview === "string"
+                    ? data.resultPreview
+                    : undefined;
+                const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : "";
+                const key = `${event.turnId}\u0000${toolCallId}`;
+                const startedAt = toolStarts.get(key);
+                if (startedAt !== undefined && atMs >= startedAt) {
+                    timing.toolMs += atMs - startedAt;
+                }
+                toolStarts.delete(key);
+                if (resultPreview) {
+                    const tokens = estimateTokensFromText(resultPreview);
+                    addSlice(composition, "toolResults", tokens);
+                    browserToolResults.push({
+                        id: `result:${event.seq}`,
+                        label: typeof data.toolName === "string" && data.toolName
+                            ? data.toolName
+                            : "工具结果",
+                        tokens,
+                        preview: elementPreview(resultPreview),
+                        status: data.isError === true ? "error" : "ok",
+                        seq: event.seq,
+                        at: event.at,
+                    });
+                }
+                break;
+            }
+            case "usage": {
+                const input = num(data.inputTokens);
+                const output = num(data.outputTokens);
+                const cacheRead = num(data.cacheReadTokens);
+                const cacheWrite = num(data.cacheWriteTokens);
+                if (input !== undefined)
+                    usage.inputTokens += input;
+                if (output !== undefined)
+                    usage.outputTokens += output;
+                if (cacheRead !== undefined)
+                    usage.cacheReadTokens += cacheRead;
+                if (cacheWrite !== undefined)
+                    usage.cacheWriteTokens += cacheWrite;
+                const total = num(data.totalTokens);
+                if (total !== undefined)
+                    usage.totalTokens += total;
+                const cost = num(data.cost);
+                if (cost !== undefined) {
+                    usage.cost = (usage.cost ?? 0) + cost;
+                }
+                const contextUsage = asRecord(data.contextUsage);
+                const window = num(contextUsage?.contextWindow);
+                const tokens = num(contextUsage?.tokens);
+                if (window !== undefined && window > 0)
+                    contextWindow = window;
+                if (tokens !== undefined)
+                    providerTotal = tokens;
+                const lastStep = trend.at(-1);
+                if (lastStep && input !== undefined) {
+                    lastStep.actualPromptTokens =
+                        input + (cacheRead ?? 0) + (cacheWrite ?? 0);
+                    lastStep.actualOutputTokens = output ?? null;
+                    lastStep.actualCacheReadTokens = cacheRead ?? null;
+                }
+                break;
+            }
+            case "compaction_start":
+            case "compaction_end":
+            case "compact": {
+                const before = num(data.tokensBefore);
+                const after = num(data.estimatedTokensAfter);
+                const reclaimed = before !== undefined && after !== undefined ? before - after : null;
+                const pruned = data.pruned === true || data.kind === "prune";
+                contextEvents.push({
+                    seq: event.seq,
+                    at: event.at,
+                    turnId: event.turnId,
+                    turnIndex: turnIds.indexOf(event.turnId) + 1,
+                    kind: pruned ? "prune" :
+                        event.kind === "compaction_start"
+                            ? "compact-start"
+                            : event.kind === "compaction_end"
+                                ? "compact-end"
+                                : "compact",
+                    tokenDelta: reclaimed,
+                    ...(before !== undefined ? { tokensBefore: before } : {}),
+                    ...(after !== undefined ? { tokensAfter: after } : {}),
+                    ...(Array.isArray(data.shadowedSeqs) ? { shadowedItems: data.shadowedSeqs.length } : {}),
+                    ...(typeof data.reason === "string" ? { reason: data.reason } : {}),
+                    ...(pruned ? { pruned: true } : {}),
+                    detail: boundedText(asRecord(data.details)?.text, 300),
+                });
+                const lastStep = trend.at(-1);
+                if (lastStep && event.kind !== "compaction_start") {
+                    lastStep.eventMark = pruned ? "prune" : "compact";
+                }
+                if (reclaimed !== null && reclaimed > 0) {
+                    const userSlice = sliceOf(composition, "user");
+                    const assistantSlice = sliceOf(composition, "assistant");
+                    const toolSlice = sliceOf(composition, "toolResults");
+                    let remaining = reclaimed;
+                    for (const slice of [userSlice, assistantSlice, toolSlice]) {
+                        const take = Math.min(slice.tokens, remaining);
+                        slice.tokens -= take;
+                        remaining -= take;
+                        if (remaining <= 0)
+                            break;
+                    }
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    composition.totalTokens = composition.slices.reduce((sum, slice) => sum + slice.tokens, 0);
+    composition.contextWindow = contextWindow;
+    composition.providerTotal = providerTotal;
+    if (providerTotal !== null &&
+        providerTotal > 0 &&
+        composition.totalTokens > 0) {
+        const scale = providerTotal / composition.totalTokens;
+        for (const slice of composition.slices) {
+            slice.tokens = Math.round(slice.tokens * scale);
+        }
+        composition.totalTokens = providerTotal;
+    }
+    if (contextWindow !== null && contextWindow > 0) {
+        composition.occupancy =
+            Math.round((composition.totalTokens / contextWindow) * 1000) / 10;
+        composition.headroom = Math.max(0, contextWindow - composition.totalTokens);
+    }
+    const billed = usage.inputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+    usage.cacheHitPercent =
+        billed > 0
+            ? Math.round((usage.cacheReadTokens / billed) * 1000) / 10
+            : null;
+    usage.turns = turnIds.length;
+    if (usage.totalTokens === 0 && billed + usage.outputTokens > 0) {
+        usage.totalTokens = billed + usage.outputTokens;
+    }
+    timing.busyMs = timing.llmMs + timing.toolMs;
+    if (firstAt !== null && lastAt !== null && lastAt >= firstAt) {
+        timing.wallMs = lastAt - firstAt;
+        timing.overheadMs = Math.max(0, timing.wallMs - timing.busyMs);
+    }
+    if (ttftSamples.length > 0) {
+        timing.ttftMs = Math.round(ttftSamples.reduce((sum, v) => sum + v, 0) / ttftSamples.length);
+    }
+    if (decodeSamples.length > 0) {
+        const ms = decodeSamples.reduce((sum, s) => sum + s.ms, 0);
+        const tokens = decodeSamples.reduce((sum, s) => sum + s.tokens, 0);
+        if (ms > 0 && tokens > 0) {
+            timing.decodeTokensPerSecond = Math.round((tokens / ms) * 1000);
+        }
+    }
+    // --- Browser snapshots: live + one per trend step (rolling elements) ---
+    const browserSteps = [];
+    const liveMessages = capElements(browserMessages);
+    const liveInjected = capElements(browserInjected);
+    const liveToolResults = capElements(browserToolResults);
+    const liveCategories = [];
+    const pushCategory = (category, elements) => {
+        if (elements.length === 0)
+            return;
+        liveCategories.push({
+            category,
+            elements,
+            totalTokens: elements.reduce((sum, e) => sum + e.tokens, 0),
+        });
+    };
+    pushCategory("system", options.systemPromptPreview
+        ? [{
+                id: "system:prompt",
+                label: "System prompt",
+                tokens: estimateTokensFromText(options.systemPromptPreview),
+                preview: elementPreview(options.systemPromptPreview),
+                seq: 0,
+                at: "",
+            }]
+        : []);
+    pushCategory("tools", browserTools);
+    pushCategory("messages", liveMessages);
+    pushCategory("injected", liveInjected);
+    pushCategory("toolResults", liveToolResults);
+    pushCategory("skills", browserSkills);
+    browserSteps.push({
+        stepId: "live",
+        categories: liveCategories,
+        totalTokens: liveCategories.reduce((sum, c) => sum + c.totalTokens, 0),
+    });
+    // Retained steps: rebuild each step's makeup from cumulative snapshots at
+    // that point in the ring (bounded to the most recent steps).
+    const RETAINED_BROWSER_STEPS = 30;
+    const recentTrend = trend.slice(-RETAINED_BROWSER_STEPS);
+    for (let i = 0; i < recentTrend.length; i++) {
+        const step = recentTrend[i];
+        const cutoffSeq = step.seq;
+        const upto = (list) => capElements(list.filter((e) => e.seq <= cutoffSeq));
+        const messagesAt = upto(browserMessages);
+        const injectedAt = upto(browserInjected);
+        const resultsAt = upto(browserToolResults);
+        const categories = [];
+        const push = (category, elements) => {
+            if (elements.length === 0)
+                return;
+            categories.push({
+                category,
+                elements,
+                totalTokens: elements.reduce((sum, e) => sum + e.tokens, 0),
+            });
+        };
+        push("system", options.systemPromptPreview
+            ? [{
+                    id: "system:prompt",
+                    label: "System prompt",
+                    tokens: estimateTokensFromText(options.systemPromptPreview),
+                    preview: elementPreview(options.systemPromptPreview),
+                    seq: 0,
+                    at: "",
+                }]
+            : []);
+        push("tools", browserTools);
+        push("messages", messagesAt);
+        push("injected", injectedAt);
+        push("toolResults", resultsAt);
+        push("skills", browserSkills);
+        browserSteps.push({
+            stepId: String(step.index),
+            turnId: step.turnId,
+            at: step.at,
+            categories,
+            totalTokens: categories.reduce((sum, c) => sum + c.totalTokens, 0),
+        });
+    }
+    return {
+        schemaVersion: 1,
+        ...(options.sessionId ? { sessionId: options.sessionId } : {}),
+        generatedAt: new Date().toISOString(),
+        lastEventSeq: lastSeq,
+        composition,
+        trend,
+        events: contextEvents,
+        files: [...files.values()].sort((a, b) => {
+            const opsA = a.reads + a.writes + a.searches + a.otherOps;
+            const opsB = b.reads + b.writes + b.searches + b.otherOps;
+            if (opsB !== opsA)
+                return opsB - opsA;
+            return a.path.localeCompare(b.path);
+        }),
+        browser: browserSteps,
+        usage,
+        timing,
+        systemPromptChars: options.systemPromptChars ?? null,
+        systemPromptPreview: options.systemPromptPreview ?? null,
+        tools: browserTools.map((t) => ({
+            id: t.label,
+            description: "",
+            tokens: t.tokens,
+        })),
+        skillInjections: options.skillInjections ?? [],
+    };
+}