xo-harness 0.2.0 → 0.3.0

package/dist/internal/harness/message.js

@@ -1,10 +1,8 @@
-import { toolDenialError } from "./tool-policy.js";
+import { projectTranscriptFragments, } from "../protocol/index.js";
+import { ToolCallTracker } from "./tool-calls.js";
 /**
- * Projects the flat, sequence-ordered event log into the v2 `Message[]` part model —
- * the shape every agent harness renders and persists (opencode / Vercel AI SDK v5 /
- * agent-server / echo). Pure AND deterministic over the recorded events: ids derive
- * from the opening event, so the same log always projects to the same identities —
- * re-folds diff cleanly, upserts stay idempotent, and renderers can key on part ids.
+ * Projects the sequence-ordered source log into display messages. Identities derive
+ * from opening events, so replay produces the same message and part IDs.
  *
  * Folding rules:
  *  - `message.input` → a user message; its recorded `parts` project with full fidelity
@@ -12,27 +10,54 @@ import { toolDenialError } from "./tool-policy.js";
  *  - `transcript.delta` from either speaker → a `streaming` text part accumulating deltas,
  *    finalized in place by the matching `transcript` (streamId-correlated, so a
  *    barge-in interrupted stream still finalizes into its original part).
- *  - `audio.output` → an `audio` part on the current assistant message (deduped per
- *    streamId), linked to its transcript text part by that streamId.
+ *  - Response audio and its transcript share a stream's message owner, including
+ *    when the first caption arrives after another speaker's input.
+ *  - Confirmed interruption separates the next new assistant speech stream; late
+ *    updates still belong to their original stream. Timed fragments keep their
+ *    independent, revisable display grouping. Interrupted response streams retain
+ *    their generated text with playback evidence; a final caption does not erase it.
+ *  - `backend.output.*` → backend item-owned text/refusal/summary parts, separate
+ *    from speech. Final items replace their content; failed responses settle only
+ *    unfinished parts. Backend completion is never evidence of spoken delivery.
  *  - `tool.requested` → ONE `tool` part in `running` state; `tool.completed`/`tool.failed`
  *    settle it with the canonical outcome, and a task terminal upgrades an
  *    `accepted_task` outcome to the task's real result. This is why a tool result
  *    (e.g. a crisis card) replays from history: the outcome lives on the part.
  *
- * A tool part belongs to the assistant message open when it was requested; a new
- * assistant transcript or user turn opens the next message.
+ * A tool part retains an existing native item owner when one is known. Otherwise,
+ * continuous-output tools own a separate assistant message, independent of revisable
+ * captions; response-based tools belong to the assistant message open at invocation.
+ * Display messages are not provider turns or evidence of device playback.
  */
 export function projectMessages(events) {
+    return foldMessages(events).messages;
+}
+/** Internal shared fold: persistence and batch rendering use the same text evidence. */
+export function foldMessages(events) {
     const started = events.find((event) => event.type === "session.started");
     const sessionId = started?.sessionId ?? events[0]?.sessionId ?? "unknown";
+    const fragmentGroups = new Map(projectTranscriptFragments(events.filter((event) => event.type === "transcript.fragment")).map((group) => [group.id, group]));
+    const ended = events.some((event) => event.type === "session.ended");
     const messages = [];
+    const textCompletion = {};
     let current;
+    let interruptedMessage;
     // callId → the tool part being advanced, so settlement updates the same part.
     const toolParts = new Map();
-    // streamId → the assistant message + audio part, so repeated chunks fold into one.
+    const toolCalls = new ToolCallTracker();
+    // Source streams retain their owner even before the first text or audio part arrives.
+    const streamMessages = new Map();
+    // Content streams from one known native item keep its owner across interleaved ASR.
+    const itemMessages = new Map();
+    // streamId → audio part, so repeated chunks fold into one.
     const audioParts = new Map();
     // stream key → the streaming text part accumulating deltas, finalized by `transcript`.
     const textParts = new Map();
+    // Backend item/content ownership is independent of the current spoken display group.
+    const backendMessages = new Map();
+    const backendParts = new Map();
+    const backendItemStates = new Map();
+    const backendFailures = new Map();
     // Speakers can overlap even when a provider omits stream IDs.
     const streamlessTextKeys = new Map();
     // Identity is the opening event: message id = event id, part id = event id + ordinal.
@@ -51,11 +76,192 @@ export function projectMessages(events) {
             return current;
         return openMessage("assistant", event);
     };
+    const toolMessage = (event, source) => {
+        const owner = source?.itemId === undefined
+            ? undefined
+            : itemMessages.get(JSON.stringify(["assistant", source.scope, source.itemId]));
+        if (owner)
+            return owner;
+        if (started?.capabilities.outputLifecycle !== "continuous")
+            return assistantMessage(event);
+        const message = {
+            id: event.id,
+            sessionId,
+            role: "assistant",
+            createdAtMs: event.recordedAtMs,
+            parts: [],
+        };
+        // Tools have no native caption parent in continuous speech. Do not make this
+        // the current speech owner: a later caption must not join a tool-only message.
+        messages.push(message);
+        return message;
+    };
+    const speechMessage = (role, event, streamId, source) => {
+        const key = streamId === undefined ? undefined : `${role}:${streamId}`;
+        const itemKey = source?.itemId === undefined ? undefined : JSON.stringify([role, source.scope, source.itemId]);
+        const owner = (key === undefined ? undefined : streamMessages.get(key)) ??
+            (itemKey === undefined ? undefined : itemMessages.get(itemKey));
+        const resumed = key !== undefined && interruptedMessage !== undefined && interruptedMessage === current;
+        const message = owner ?? (role === "user" || resumed ? openMessage(role, event) : assistantMessage(event));
+        if (key !== undefined) {
+            streamMessages.set(key, message);
+            if (role === "assistant" && owner === undefined)
+                interruptedMessage = undefined;
+        }
+        if (itemKey !== undefined)
+            itemMessages.set(itemKey, message);
+        return message;
+    };
+    const backendItemKey = (source) => JSON.stringify([source.responseId, source.itemId]);
+    const backendPart = (event, source, kind, ordinal = 0) => {
+        const itemKey = backendItemKey(source);
+        let message = backendMessages.get(itemKey);
+        if (!message) {
+            message = { id: event.id, sessionId, role: "assistant", createdAtMs: event.recordedAtMs, parts: [] };
+            backendMessages.set(itemKey, message);
+            // Do not change `current`: backend activity cannot open or split a spoken caption.
+            messages.push(message);
+        }
+        else if (message.parts.length === 0 && !messages.includes(message)) {
+            messages.push(message);
+        }
+        const key = JSON.stringify([
+            itemKey,
+            kind === "reasoning_summary" ? "summary" : "content",
+            kind === "reasoning_summary" ? source.summaryIndex : source.contentIndex,
+        ]);
+        let part = backendParts.get(key);
+        if (!part) {
+            part =
+                kind === "reasoning_summary"
+                    ? {
+                        ...partBase(message, event, ordinal),
+                        type: "reasoning",
+                        summary: true,
+                        text: "",
+                        state: "streaming",
+                        source: { ...source },
+                    }
+                    : {
+                        ...partBase(message, event, ordinal),
+                        type: "text",
+                        ...(kind === "refusal" ? { refusal: true } : {}),
+                        text: "",
+                        state: "streaming",
+                        source: { ...source },
+                    };
+            backendParts.set(key, part);
+            message.parts.push(part);
+            message.parts.sort((a, b) => (a.source?.contentIndex ?? a.source?.summaryIndex ?? 0) -
+                (b.source?.contentIndex ?? b.source?.summaryIndex ?? 0));
+        }
+        part.source = { ...part.source, ...source };
+        const failure = source.responseId === undefined ? undefined : backendFailures.get(source.responseId);
+        if (failure && !backendItemStates.has(itemKey))
+            part.state = failure;
+        if (part.type === "text")
+            textCompletion[part.id] ??= "unconfirmed";
+        return part;
+    };
     for (const event of events) {
+        const toolCall = toolCalls.apply(event);
+        if (toolCall) {
+            const part = toolParts.get(toolCall.callId);
+            if (part)
+                part.state = toolCall.state;
+        }
         switch (event.type) {
+            case "backend.output.delta": {
+                const key = backendItemKey(event.source);
+                // No delta can extend an item after its authoritative final snapshot.
+                if (backendItemStates.has(key))
+                    break;
+                const part = backendPart(event, event.source, event.kind);
+                part.text += event.delta;
+                break;
+            }
+            case "backend.output": {
+                const key = backendItemKey(event.source);
+                backendItemStates.set(key, event.status);
+                const parts = event.content.map((content, ordinal) => {
+                    const source = {
+                        ...event.source,
+                        ...("contentIndex" in content
+                            ? { contentIndex: content.contentIndex }
+                            : { summaryIndex: content.summaryIndex }),
+                    };
+                    const part = backendPart(event, source, content.kind, ordinal);
+                    part.text = content.text;
+                    part.state =
+                        event.status === "incomplete" || event.status === "cancelled" || event.status === "failed"
+                            ? event.status
+                            : event.status === "completed"
+                                ? "done"
+                                : (backendFailures.get(event.source.responseId) ?? "done");
+                    if (part.type === "text") {
+                        if (content.kind === "refusal")
+                            part.refusal = true;
+                        else
+                            delete part.refusal;
+                        // Text has ended, but a status-less snapshot is not proof of item success.
+                        textCompletion[part.id] = event.status === "completed" ? "provider-final" : "unconfirmed";
+                    }
+                    return part;
+                });
+                const message = backendMessages.get(key);
+                if (message) {
+                    const retained = new Set(parts.map((part) => part.id));
+                    for (const part of message.parts)
+                        if (!retained.has(part.id))
+                            delete textCompletion[part.id];
+                    message.parts = parts;
+                    const index = messages.indexOf(message);
+                    if (parts.length === 0 && index >= 0)
+                        messages.splice(index, 1);
+                }
+                break;
+            }
+            case "backend.response": {
+                if (event.phase !== "completed" ||
+                    (event.status !== "incomplete" && event.status !== "cancelled" && event.status !== "failed"))
+                    break;
+                backendFailures.set(event.responseId, event.status);
+                for (const part of backendParts.values()) {
+                    if (part.source?.responseId !== event.responseId)
+                        continue;
+                    const state = backendItemStates.get(backendItemKey(part.source));
+                    if (state !== undefined && state !== "in_progress")
+                        continue;
+                    part.state = event.status;
+                }
+                break;
+            }
+            case "transcript.fragment": {
+                const group = fragmentGroups.get(event.fragmentId);
+                if (!group)
+                    break;
+                fragmentGroups.delete(event.fragmentId);
+                const message = openMessage(group.role, event);
+                textCompletion[`${event.id}/p0`] = "unconfirmed";
+                message.parts.push({
+                    ...partBase(message, event),
+                    type: "text",
+                    text: group.text,
+                    state: ended ? "done" : "streaming",
+                    transcript: {
+                        fragmentIds: group.fragmentIds,
+                        startMs: group.startMs,
+                        endMs: group.endMs,
+                        timebase: group.timebase,
+                    },
+                });
+                break;
+            }
             case "message.input": {
                 const message = openMessage("user", event);
                 for (const [ordinal, part] of (event.parts ?? [{ type: "text", text: event.text }]).entries()) {
+                    if (part.type === "text")
+                        textCompletion[`${event.id}/p${ordinal}`] = "input";
                     message.parts.push(part.type === "text"
                         ? { ...partBase(message, event, ordinal), type: "text", text: part.text, state: "done" }
                         : {
@@ -76,9 +282,14 @@ export function projectMessages(events) {
                 if (existing) {
                     if (existing.state === "streaming")
                         existing.text += event.delta;
+                    if (event.source !== undefined) {
+                        existing.source = { ...existing.source, ...event.source };
+                        if (event.streamId !== undefined)
+                            speechMessage(event.role, event, event.streamId, existing.source);
+                    }
                     break;
                 }
-                const message = event.role === "assistant" ? assistantMessage(event) : openMessage("user", event);
+                const message = speechMessage(event.role, event, event.streamId, event.source);
                 const key = `${event.role}:${event.streamId ?? message.id}`;
                 if (event.streamId === undefined)
                     streamlessTextKeys.set(event.role, key);
@@ -87,7 +298,10 @@ export function projectMessages(events) {
                     type: "text",
                     text: event.delta,
                     state: "streaming",
+                    ...(event.streamId === undefined ? {} : { streamId: event.streamId }),
+                    ...(event.source === undefined ? {} : { source: { ...event.source } }),
                 };
+                textCompletion[part.id] = "unconfirmed";
                 textParts.set(key, part);
                 message.parts.push(part);
                 break;
@@ -102,33 +316,47 @@ export function projectMessages(events) {
                 if (key !== undefined && streaming !== undefined) {
                     streaming.text = event.text;
                     streaming.state = "done";
+                    if (event.source !== undefined) {
+                        streaming.source = { ...streaming.source, ...event.source };
+                        if (event.streamId !== undefined)
+                            speechMessage(event.role, event, event.streamId, streaming.source);
+                    }
+                    textCompletion[streaming.id] = "provider-final";
                     if (event.streamId === undefined) {
                         textParts.delete(key);
                         streamlessTextKeys.delete(event.role);
                     }
                     break;
                 }
-                const message = event.role === "assistant" ? assistantMessage(event) : openMessage("user", event);
+                const message = speechMessage(event.role, event, event.streamId, event.source);
                 const part = {
                     ...partBase(message, event),
                     type: "text",
                     text: event.text,
                     state: "done",
+                    ...(event.streamId === undefined ? {} : { streamId: event.streamId }),
+                    ...(event.source === undefined ? {} : { source: { ...event.source } }),
                 };
+                textCompletion[part.id] = "provider-final";
                 if (event.streamId !== undefined)
                     textParts.set(`${event.role}:${event.streamId}`, part);
                 message.parts.push(part);
                 break;
             }
             case "audio.output": {
+                // A continuous stream spans many display groups. Keep it on the session
+                // timeline rather than attaching the whole recording to the first message.
+                if (started?.capabilities.outputLifecycle === "continuous")
+                    break;
                 const streamId = event.chunk.streamId;
                 if (audioParts.has(streamId))
                     break;
-                const message = assistantMessage(event);
+                const message = speechMessage("assistant", event, streamId, event.source);
                 const part = {
                     ...partBase(message, event),
                     type: "audio",
                     streamId,
+                    ...(event.source === undefined ? {} : { source: { ...event.source } }),
                     sampleRate: event.chunk.sampleRate,
                     state: "done",
                 };
@@ -136,83 +364,49 @@ export function projectMessages(events) {
                 message.parts.push(part);
                 break;
             }
+            case "audio.interrupted": {
+                const owner = streamMessages.get(`assistant:${event.streamId}`);
+                if (owner !== undefined && owner === current)
+                    interruptedMessage = owner;
+                break;
+            }
             case "tool.requested": {
-                if (toolParts.has(event.call.callId))
+                if (!toolCall)
                     break;
-                const message = assistantMessage(event);
+                const message = toolMessage(event, toolCall.source);
                 const part = {
                     ...partBase(message, event),
                     type: "tool",
                     toolCallId: event.call.callId,
                     toolName: event.call.name,
-                    state: { status: "running", input: event.call.arguments, startedAtMs: event.recordedAtMs },
+                    ...(toolCall.source === undefined ? {} : { source: { ...toolCall.source } }),
+                    state: toolCall.state,
                 };
                 toolParts.set(event.call.callId, part);
                 message.parts.push(part);
                 break;
             }
-            case "tool.completed": {
-                const part = toolParts.get(event.callId);
-                if (part?.state.status !== "running")
-                    break;
-                part.state = {
-                    status: "settled",
-                    input: part.state.input,
-                    outcome: event.outcome,
-                    startedAtMs: part.state.startedAtMs,
-                    endedAtMs: event.recordedAtMs,
-                };
-                break;
-            }
-            case "tool.failed": {
-                const part = toolParts.get(event.callId);
-                if (part?.state.status !== "running")
-                    break;
-                part.state = {
-                    status: "settled",
-                    input: part.state.input,
-                    outcome: { type: "failed", error: event.error },
-                    startedAtMs: part.state.startedAtMs,
-                    endedAtMs: event.recordedAtMs,
-                };
-                break;
-            }
-            case "tool.denied": {
-                // Admission refusal settles the part like a failure; the log keeps the distinction.
-                const part = toolParts.get(event.callId);
-                if (part?.state.status !== "running")
-                    break;
-                part.state = {
-                    status: "settled",
-                    input: part.state.input,
-                    outcome: { type: "failed", error: toolDenialError(event.reason) },
-                    startedAtMs: part.state.startedAtMs,
-                    endedAtMs: event.recordedAtMs,
-                };
-                break;
-            }
-            case "task.completed":
-            case "task.failed":
-            case "task.cancelled": {
-                // A background task settling upgrades its tool part's accepted_task handoff to
-                // the real result, so task-shaped tools replay from history like direct ones.
-                const part = toolParts.get(event.callId);
-                if (part?.state.status !== "settled" || part.state.outcome.type !== "accepted_task")
-                    break;
-                part.state = {
-                    ...part.state,
-                    outcome: event.type === "task.completed"
-                        ? { type: "completed", value: event.result }
-                        : event.type === "task.failed"
-                            ? { type: "failed", error: event.error }
-                            : { type: "failed", error: `Task cancelled: ${event.reason}` },
-                    endedAtMs: event.recordedAtMs,
-                };
-                break;
-            }
             default:
                 break;
         }
     }
-    return messages;
+    // Generation may finish before playback is interrupted, or its final caption may
+    // arrive afterward. Join by response stream after folding so both orders retain
+    // the same evidence without changing original text or guessing a heard prefix.
+    // A continuous session stream cannot identify an individual Live caption group.
+    if (started?.capabilities.outputLifecycle !== "continuous") {
+        const interrupted = new Set(events.filter((event) => event.type === "audio.interrupted").map((event) => event.streamId));
+        for (const message of messages) {
+            if (message.role !== "assistant")
+                continue;
+            for (const part of message.parts) {
+                if ((part.type === "text" || part.type === "audio") &&
+                    part.source?.scope !== "backend" &&
+                    part.streamId !== undefined &&
+                    interrupted.has(part.streamId))
+                    part.playback = "interrupted";
+            }
+        }
+    }
+    return { messages, textCompletion };
 }

package/dist/internal/harness/report-diff.d.ts

@@ -33,6 +33,9 @@ export interface SessionReportDiff {
     transcriptLines: MetricDelta;
     errorCount: MetricDelta;
     usage: Record<keyof UsageTotals, MetricDelta>;
+    /** Continuous voice duration and backend tokens are separate accounting units. */
+    voiceDurationSeconds?: MetricDelta;
+    backendUsage?: Record<keyof UsageTotals, MetricDelta>;
     /** Union of tool names from both reports, sorted, one row each. */
     toolCalls: ToolCallDiff[];
 }

package/dist/internal/harness/report-diff.js

@@ -11,6 +11,12 @@ export function diffSessionReports(baseline, candidate) {
         usage[key] = metric(baseline.usage[key], candidate.usage[key]);
     }
     const names = [...new Set([...baseline.toolCalls, ...candidate.toolCalls].map((call) => call.name))].sort();
+    const backendUsage = {};
+    if (baseline.backendUsage || candidate.backendUsage) {
+        for (const key of Object.keys(usage)) {
+            backendUsage[key] = metric(baseline.backendUsage?.[key], candidate.backendUsage?.[key]);
+        }
+    }
     return {
         baseline: identity(baseline),
         candidate: identity(candidate),
@@ -22,6 +28,10 @@ export function diffSessionReports(baseline, candidate) {
         transcriptLines: metric(baseline.transcripts.length, candidate.transcripts.length),
         errorCount: metric(baseline.errors.length, candidate.errors.length),
         usage,
+        ...(baseline.voiceDuration || candidate.voiceDuration
+            ? { voiceDurationSeconds: metric(baseline.voiceDuration?.seconds, candidate.voiceDuration?.seconds) }
+            : {}),
+        ...(baseline.backendUsage || candidate.backendUsage ? { backendUsage } : {}),
         toolCalls: names.map((name) => toolDiff(name, baseline.toolCalls, candidate.toolCalls)),
     };
 }

package/dist/internal/harness/report.d.ts

@@ -1,4 +1,6 @@
-import { type HarnessEvent, type ToolOutcome } from "../protocol/index.js";
+import { type HarnessRecord, type ToolOutcome } from "../protocol/index.js";
+import { type UsageTotals } from "./usage-tracker.js";
+export type { UsageTotals } from "./usage-tracker.js";
 export interface ToolCallReport {
     callId: string;
     name: string;
@@ -13,17 +15,11 @@ export interface TranscriptLine {
     role: "user" | "assistant";
     text: string;
     atMs: number;
-}
-/** Session token totals summed over provider usage reports; zeros when none arrived. */
-export interface UsageTotals {
-    responses: number;
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    cachedInputTokens: number;
-    audioInputTokens: number;
-    audioOutputTokens: number;
-    cachedAudioInputTokens: number;
+    nativeTiming?: {
+        startMs: number;
+        endMs: number;
+        timebase: "provider-session";
+    };
 }
 export interface SessionReport {
     sessionId: string;
@@ -33,7 +29,7 @@ export interface SessionReport {
     readyAtMs?: number;
     firstInputAtMs?: number;
     firstOutputAtMs?: number;
-    /** First model audio relative to first microphone audio. */
+    /** First model audio relative to first input audio; omitted for continuous output (which includes silence). */
     responseLatencyMs?: number;
     inputAudioMs: number;
     outputAudioMs: number;
@@ -45,9 +41,16 @@ export interface SessionReport {
         recoverable: boolean;
     }[];
     usage: UsageTotals;
+    /** Separate accounting domains: duration snapshots never become token deltas. */
+    voiceDuration?: {
+        seconds: number;
+        final: boolean;
+    };
+    backendUsage?: UsageTotals;
+    finalized?: boolean;
 }
 /**
  * Derives latency and outcome metrics from a session log. Pure over the recorded events,
  * so it works identically on live sessions, replays, and shadow runs.
  */
-export declare function summarizeSession(events: readonly HarnessEvent[]): SessionReport;
+export declare function summarizeSession(events: readonly HarnessRecord[]): SessionReport;

package/dist/internal/harness/report.js

@@ -1,5 +1,6 @@
-import { audioSampleCount } from "../protocol/index.js";
+import { audioSampleCount, projectTranscriptFragments, } from "../protocol/index.js";
 import { toolDenialError } from "./tool-policy.js";
+import { SessionUsageTracker } from "./usage-tracker.js";
 /**
  * Derives latency and outcome metrics from a session log. Pure over the recorded events,
  * so it works identically on live sessions, replays, and shadow runs.
@@ -16,33 +17,16 @@ export function summarizeSession(events) {
     let outputAudioMs = 0;
     const toolCalls = new Map();
     const transcripts = [];
+    const transcriptStreams = new Map();
     const taskIds = new Set();
     const errors = [];
-    const usage = {
-        responses: 0,
-        inputTokens: 0,
-        outputTokens: 0,
-        totalTokens: 0,
-        cachedInputTokens: 0,
-        audioInputTokens: 0,
-        audioOutputTokens: 0,
-        cachedAudioInputTokens: 0,
-    };
+    const accounting = new SessionUsageTracker({ sessionId: started.sessionId });
     for (const event of events) {
+        accounting.apply(event);
         switch (event.type) {
             case "provider.ready":
                 readyAtMs ??= event.sessionTimeMs;
                 break;
-            case "usage":
-                usage.responses += 1;
-                usage.inputTokens += event.inputTokens;
-                usage.outputTokens += event.outputTokens;
-                usage.totalTokens += event.totalTokens;
-                usage.cachedInputTokens += event.cachedInputTokens ?? 0;
-                usage.audioInputTokens += event.audioInputTokens ?? 0;
-                usage.audioOutputTokens += event.audioOutputTokens ?? 0;
-                usage.cachedAudioInputTokens += event.cachedAudioInputTokens ?? 0;
-                break;
             case "audio.input":
                 firstInputAtMs ??= event.sessionTimeMs;
                 inputAudioMs += (audioSampleCount(event.chunk) / event.chunk.sampleRate) * 1000;
@@ -51,9 +35,21 @@ export function summarizeSession(events) {
                 firstOutputAtMs ??= event.sessionTimeMs;
                 outputAudioMs += (audioSampleCount(event.chunk) / event.chunk.sampleRate) * 1000;
                 break;
-            case "transcript":
-                transcripts.push({ role: event.role, text: event.text, atMs: event.sessionTimeMs });
+            case "transcript": {
+                const key = event.streamId === undefined ? undefined : JSON.stringify([event.role, event.streamId]);
+                const previous = key === undefined ? undefined : transcriptStreams.get(key);
+                if (previous) {
+                    // Revised finals replace the same utterance, preserving its original order and timing.
+                    previous.text = event.text;
+                }
+                else {
+                    const line = { role: event.role, text: event.text, atMs: event.sessionTimeMs };
+                    transcripts.push(line);
+                    if (key !== undefined)
+                        transcriptStreams.set(key, line);
+                }
                 break;
+            }
             case "message.input":
                 transcripts.push({ role: "user", text: event.text, atMs: event.sessionTimeMs });
                 break;
@@ -103,6 +99,22 @@ export function summarizeSession(events) {
                 break;
         }
     }
+    const fragments = events.filter((event) => event.type === "transcript.fragment");
+    const fragmentEvents = new Map(fragments.map((event) => [event.fragmentId, event]));
+    for (const group of projectTranscriptFragments(fragments)) {
+        const opening = fragmentEvents.get(group.id);
+        if (!opening)
+            continue;
+        transcripts.push({
+            role: group.role,
+            text: group.text,
+            atMs: opening.sessionTimeMs,
+            nativeTiming: { startMs: group.startMs, endMs: group.endMs, timebase: group.timebase },
+        });
+    }
+    if (fragments.length)
+        transcripts.sort((a, b) => a.atMs - b.atMs);
+    const { usage, voiceDuration, backendUsage, finalized } = accounting.snapshot();
     return {
         sessionId: started.sessionId,
         providerId: started.providerId,
@@ -114,11 +126,16 @@ export function summarizeSession(events) {
         taskIds: [...taskIds],
         usage,
         errors,
+        ...(voiceDuration === undefined ? {} : { voiceDuration }),
+        ...(backendUsage === undefined ? {} : { backendUsage }),
+        ...(finalized === undefined ? {} : { finalized }),
         ...(endedReason === undefined ? {} : { endedReason }),
         ...(readyAtMs === undefined ? {} : { readyAtMs }),
         ...(firstInputAtMs === undefined ? {} : { firstInputAtMs }),
         ...(firstOutputAtMs === undefined ? {} : { firstOutputAtMs }),
-        ...(firstInputAtMs === undefined || firstOutputAtMs === undefined
+        ...(started.capabilities.outputLifecycle === "continuous" ||
+            firstInputAtMs === undefined ||
+            firstOutputAtMs === undefined
             ? {}
             : { responseLatencyMs: firstOutputAtMs - firstInputAtMs }),
     };