@qduc/term2 0.9.3 → 0.10.0

package/dist/services/conversation/conversation-replay.test.js

@@ -1,1221 +0,0 @@
-import { it, expect, beforeEach } from 'vitest';
-import { LOG_ENVELOPE_VERSION } from '../logging/conversation-log-events.js';
-import { replayEvents } from './conversation-replay.js';
-let seq = 0;
-function env(event) {
-    return { v: LOG_ENVELOPE_VERSION, seq: ++seq, ts: new Date().toISOString(), event };
-}
-beforeEach(() => {
-    seq = 0;
-});
-it('replayEvents: empty log produces empty state with no warnings', () => {
-    const restored = replayEvents([]);
-    expect(restored.id).toBe('');
-    expect(restored.history.length).toBe(0);
-    expect(restored.messages.length).toBe(0);
-    expect(restored.replayWarnings).toEqual([]);
-});
-it('replayEvents: session_init populates session metadata', () => {
-    const envelopes = [
-        env({
-            type: 'session_init',
-            id: 'sess-1',
-            createdAt: '2026-01-01T00:00:00Z',
-            projectPath: '/p',
-            sshHost: 'h',
-            model: 'gpt-5',
-            provider: 'openai',
-            reasoningEffort: 'high',
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.id).toBe('sess-1');
-    expect(restored.projectPath).toBe('/p');
-    expect(restored.sshHost).toBe('h');
-    expect(restored.model).toBe('gpt-5');
-    expect(restored.provider).toBe('openai');
-    expect(restored.reasoningEffort).toBe('high');
-});
-it('replayEvents: unsupported assistant_final is ignored', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        {
-            v: 1,
-            seq: 2,
-            ts: new Date().toISOString(),
-            event: {
-                type: 'assistant_final',
-                message: { id: 'b1', sender: 'bot', status: 'finalized', text: 'ok' },
-                finalText: 'ok',
-                snapshot: {
-                    history: [{ role: 'user', type: 'message', content: 'hi' }],
-                    previousResponseId: 'r1',
-                    toolLedger: [],
-                },
-            },
-        },
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.history.length).toBe(0);
-    expect(restored.previousResponseId).toBe(null);
-    expect(restored.messages.length).toBe(0);
-});
-it('replayEvents: cross-model invalidation nulls previousResponseId', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z', model: 'gpt-4o' }),
-        env({
-            type: 'assistant_turn',
-            turn: { items: [{ type: 'assistant_text', text: 'ok' }] },
-            state: { previousResponseId: 'r1', model: 'gpt-5' },
-        }),
-        env({ type: 'settings_changed', key: 'agent.model', value: 'gpt-4o' }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.previousResponseId).toBe(null);
-});
-it('replayEvents: v3 assistant_turn restores state without cumulative snapshot', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z', model: 'gpt-5', provider: 'openai' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run pwd' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: '{"command":"pwd"}' },
-                    { type: 'tool_result', callId: 'call-1', toolName: 'shell', status: 'completed', output: '/repo' },
-                    { type: 'assistant_text', text: 'The current directory is /repo.' },
-                ],
-            },
-            usage: { prompt_tokens: 7, completion_tokens: 8, total_tokens: 15 },
-            state: {
-                previousResponseId: 'resp-v3',
-                model: 'gpt-5',
-                provider: 'openai',
-            },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.previousResponseId).toBe('resp-v3');
-    expect(restored.model).toBe('gpt-5');
-    expect(restored.provider).toBe('openai');
-    expect(restored.usage).toEqual({ prompt_tokens: 7, completion_tokens: 8, total_tokens: 15 });
-    expect(restored.history).toEqual([
-        { role: 'user', type: 'message', content: 'run pwd' },
-        { type: 'function_call', callId: 'call-1', name: 'shell', arguments: '{"command":"pwd"}' },
-        { type: 'function_call_result', callId: 'call-1', name: 'shell', output: '/repo' },
-        {
-            role: 'assistant',
-            type: 'message',
-            status: 'completed',
-            content: [{ type: 'output_text', text: 'The current directory is /repo.' }],
-        },
-    ]);
-    expect(restored.toolLedger.length).toBe(1);
-    expect(restored.toolLedger[0]).toMatchObject({
-        callId: 'call-1',
-        toolName: 'shell',
-        arguments: '{"command":"pwd"}',
-        status: 'completed',
-        output: '/repo',
-    });
-    expect(restored.messages.length).toBe(3);
-    expect(restored.messages[1].sender).toBe('command');
-    expect(restored.messages[1].status).toBe('completed');
-    expect(restored.messages[2].text).toBe('The current directory is /repo.');
-    expect(restored.messages[2].usage).toBe(undefined);
-});
-it('replayEvents: timed-out partial assistant turn preserves tool history for the next message', () => {
-    const restored = replayEvents([
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'continue the task' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: { command: 'pwd' } },
-                    { type: 'tool_result', callId: 'call-1', toolName: 'shell', status: 'completed', output: '/repo' },
-                ],
-            },
-            state: { previousResponseId: null },
-        }),
-        env({ type: 'error', message: 'network timed out', kind: 'network' }),
-    ]);
-    expect(restored.history).toEqual([
-        { role: 'user', type: 'message', content: 'continue the task' },
-        { type: 'function_call', callId: 'call-1', name: 'shell', arguments: { command: 'pwd' } },
-        { type: 'function_call_result', callId: 'call-1', name: 'shell', output: '/repo' },
-    ]);
-    expect(restored.previousResponseId).toBe(null);
-    expect(restored.replayWarnings.some((warning) => warning.includes('interrupted'))).toBe(false);
-    expect(restored.messages.some((message) => message.sender === 'bot' && message.text === 'Error: network timed out')).toBe(true);
-});
-it('replayEvents: v3 assistant_turn preserves coarse tool_result ledger and avoids duplicates', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run pwd' } }),
-        env({ type: 'tool_started', toolCallId: 'call-1', toolName: 'shell', arguments: '{"command":"pwd"}' }),
-        env({ type: 'tool_result', callId: 'call-1', toolName: 'shell', status: 'completed', output: '/repo' }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: '{"command":"pwd"}' },
-                    { type: 'tool_result', callId: 'call-1', toolName: 'shell', status: 'completed', output: '/repo' },
-                    { type: 'assistant_text', text: 'Done.' },
-                ],
-            },
-            state: { previousResponseId: 'resp-v3' },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.toolLedger.length).toBe(1);
-    expect(restored.toolLedger[0].callId).toBe('call-1');
-    expect(restored.toolLedger[0].output).toBe('/repo');
-    expect(restored.history.filter((item) => item.callId === 'call-1').length).toBe(2);
-    expect(restored.replayWarnings.some((warning) => warning.includes('duplicated'))).toBe(false);
-});
-it('replayEvents: v3 assistant_turn compact state participates in cross-model invalidation', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z', model: 'gpt-5' }),
-        env({
-            type: 'assistant_turn',
-            turn: { items: [{ type: 'assistant_text', text: 'ok' }] },
-            state: { previousResponseId: 'resp-v3', model: 'gpt-5' },
-        }),
-        env({ type: 'settings_changed', key: 'agent.model', value: 'gpt-4o' }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.previousResponseId).toBe(null);
-});
-it('replayEvents: trailing user_message inserts interrupted system message', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.messages.some((m) => m.sender === 'system' && String(m.text).includes('interrupted'))).toBe(true);
-    expect(restored.replayWarnings.length > 0).toBe(true);
-    expect(restored.previousResponseId).toBe(null);
-});
-it('replayEvents: interrupted turn nulls previousResponseId even when a prior turn completed', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z', provider: 'openai' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'first' } }),
-        env({
-            type: 'assistant_turn',
-            turn: { items: [{ type: 'assistant_text', text: 'done' }] },
-            state: { previousResponseId: 'resp-1', provider: 'openai' },
-        }),
-        env({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'second' } }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.replayWarnings.some((warning) => warning.includes('interrupted'))).toBe(true);
-    expect(restored.previousResponseId).toBe(null);
-});
-it('replayEvents: tool_started followed by tool_result clears in-flight (no warning)', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } }),
-        env({ type: 'tool_started', toolCallId: 'c1', toolName: 'shell', arguments: {} }),
-        env({ type: 'tool_result', callId: 'c1', toolName: 'shell', status: 'completed', output: 'ok' }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'c1', toolName: 'shell', arguments: {} },
-                    { type: 'tool_result', callId: 'c1', toolName: 'shell', status: 'completed', output: 'ok' },
-                    { type: 'assistant_text', text: 'done' },
-                ],
-            },
-            state: { previousResponseId: 'r1' },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.replayWarnings.length).toBe(0);
-});
-it('replayEvents: subagent_started + subagent_completed cleans up activity message and accumulates usage', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'subagent_started', agentId: 'a1', role: 'explorer', task: 'find x' }),
-        env({
-            type: 'subagent_completed',
-            result: {
-                agentId: 'a1',
-                role: 'explorer',
-                status: 'completed',
-                finalText: 'done',
-                filesChanged: [],
-                toolsUsed: [],
-                usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
-            },
-        }),
-        env({
-            type: 'assistant_turn',
-            turn: { items: [{ type: 'assistant_text', text: 'all done' }] },
-            state: { previousResponseId: 'r1' },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.messages.some((m) => m.sender === 'subagent')).toBe(false);
-    expect(restored.subagentUsage).toBeTruthy();
-});
-it('replayEvents: subagent_tool_started restores scoped activity without a parent in-flight tool', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'subagent_started', agentId: 'a1', role: 'worker', task: 'inspect' }),
-        env({
-            type: 'subagent_tool_started',
-            agentId: 'a1',
-            role: 'worker',
-            toolCallId: 'nested-call-1',
-            toolName: 'shell',
-            arguments: { command: 'pwd' },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.toolLedger.length).toBe(0);
-    expect(restored.messages.some((message) => message.sender === 'subagent' && message.agentId === 'a1')).toBe(true);
-});
-it('replayEvents: unknown event type is ignored gracefully', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        { v: LOG_ENVELOPE_VERSION, seq: 99, ts: '', event: { type: 'made_up_event' } },
-        env({
-            type: 'assistant_turn',
-            turn: { items: [{ type: 'assistant_text', text: 'ok' }] },
-            state: { previousResponseId: 'r1' },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.previousResponseId).toBe('r1');
-});
-it('replayEvents: truncated event is skipped and adds warning', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({
-            type: 'assistant_turn',
-            truncated: true,
-            originalSize: 500000,
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.replayWarnings.length).toBe(1);
-    expect(restored.replayWarnings[0].includes('truncated')).toBe(true);
-    expect(restored.history.length).toBe(0);
-});
-it('replayEvents: reconstructs history and ledger on mid-turn interruption', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run tool' } }),
-        env({ type: 'tool_started', toolCallId: 'call-1', toolName: 'shell', arguments: { command: 'echo 1' } }),
-        env({
-            type: 'tool_result',
-            callId: 'call-1',
-            toolName: 'shell',
-            status: 'completed',
-            output: '1\n',
-            historyItems: [
-                {
-                    role: 'assistant',
-                    type: 'message',
-                    content: '',
-                    tool_calls: [
-                        {
-                            type: 'function',
-                            id: 'call-1',
-                            function: { name: 'shell', arguments: '{"command":"echo 1"}' },
-                        },
-                    ],
-                },
-                {
-                    role: 'tool',
-                    type: 'function_call_result',
-                    callId: 'call-1',
-                    name: 'shell',
-                    output: '1\n',
-                },
-            ],
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    // Replayed state should have:
-    // 1. Reconstructed history containing user message and tool call/result items.
-    // 2. Completed tool in the toolLedger.
-    expect(restored.history.length).toBe(3); // user message, tool call, tool result
-    expect(restored.history[0].role).toBe('user');
-    expect(restored.history[0].content).toBe('run tool');
-    expect(restored.history[1].tool_calls[0].id).toBe('call-1');
-    expect(restored.history[2].callId).toBe('call-1');
-    expect(restored.toolLedger.length).toBe(1);
-    expect(restored.toolLedger[0].callId).toBe('call-1');
-    expect(restored.toolLedger[0].status).toBe('completed');
-    expect(restored.toolLedger[0].arguments).toEqual({ command: 'echo 1' });
-});
-it('replayEvents: handles incomplete in-flight tool call on interruption', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run tool' } }),
-        env({ type: 'tool_started', toolCallId: 'call-1', toolName: 'shell', arguments: { command: 'echo 1' } }),
-    ];
-    const restored = replayEvents(envelopes);
-    // The in-flight tool should be marked as aborted in the toolLedger.
-    expect(restored.toolLedger.length).toBe(1);
-    expect(restored.toolLedger[0].callId).toBe('call-1');
-    expect(restored.toolLedger[0].status).toBe('aborted');
-    expect(restored.toolLedger[0].failureReason).toBe('Session ended unexpectedly');
-    // History should have the user message.
-    expect(restored.history.length).toBe(1);
-    expect(restored.history[0].role).toBe('user');
-    expect(restored.history[0].content).toBe('run tool');
-});
-it('replayEvents: assistant_turn maps items to SavedMessage[] in correct order with stable call IDs', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'reasoning', text: 'thinking' },
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: 'ls' },
-                    { type: 'tool_result', callId: 'call-1', toolName: 'shell', status: 'completed', output: 'files' },
-                    { type: 'assistant_text', text: 'here is files' },
-                ],
-            },
-            usage: { prompt_tokens: 5, completion_tokens: 10, total_tokens: 15 },
-            snapshot: {
-                history: [],
-                previousResponseId: 'r1',
-                toolLedger: [],
-            },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.messages.length).toBe(4); // 1 user + 3 assistant_turn items (tool_result updates tool_call in-place)
-    expect(restored.messages[0].sender).toBe('user');
-    expect(restored.messages[1].sender).toBe('reasoning');
-    expect(restored.messages[1].text).toBe('thinking');
-    expect(restored.messages[1].status).toBe('finalized');
-    expect(restored.messages[2].sender).toBe('command');
-    expect(restored.messages[2].callId).toBe('call-1');
-    expect(restored.messages[2].status).toBe('completed');
-    expect(restored.messages[2].success).toBe(true);
-    expect(restored.messages[2].output).toBe('files');
-    expect(restored.messages[3].sender).toBe('bot');
-    expect(restored.messages[3].text).toBe('here is files');
-    expect(restored.messages[3].usage).toBe(undefined);
-    expect(restored.usage).toEqual({ prompt_tokens: 5, completion_tokens: 10, total_tokens: 15 });
-});
-it('replayEvents: assistant_turn renders apply_patch success output from parsed message field', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'patch it' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'apply_patch', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'apply_patch',
-                        status: 'completed',
-                        output: JSON.stringify({
-                            output: [{ success: true, operation: 'update_file', path: 'src/foo.ts', message: 'Updated src/foo.ts' }],
-                        }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command).toBeTruthy();
-    expect(command?.output).toBe('Updated src/foo.ts');
-});
-it('replayEvents: assistant_turn renders apply_patch failure output from parsed error field', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'patch it' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'apply_patch', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'apply_patch',
-                        status: 'failed',
-                        output: JSON.stringify({
-                            output: [{ success: false, error: 'Invalid patch: context mismatch' }],
-                        }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command).toBeTruthy();
-    expect(command?.output).toBe('Invalid patch: context mismatch');
-    expect(command?.status).toBe('failed');
-    expect(command?.success).toBe(false);
-});
-it('replayEvents: assistant_turn joins multi-item apply_patch results with newlines preserving order', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'patch both' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'apply_patch', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'apply_patch',
-                        status: 'completed',
-                        output: JSON.stringify({
-                            output: [
-                                { success: true, operation: 'update_file', path: 'a.ts', message: 'Updated a.ts' },
-                                { success: false, error: 'Invalid patch: bad context' },
-                            ],
-                        }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command?.output).toBe('Updated a.ts\nInvalid patch: bad context');
-});
-it('replayEvents: assistant_turn falls back to path when apply_patch item has no message and no error', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'patch it' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'apply_patch', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'apply_patch',
-                        status: 'completed',
-                        output: JSON.stringify({ output: [{ success: true, path: 'legacy.ts' }] }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command?.output).toBe('legacy.ts');
-});
-it('replayEvents: assistant_turn renders create_file success output from parsed message field', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'make file' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'create_file', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'create_file',
-                        status: 'completed',
-                        output: JSON.stringify({ success: true, path: 'new.ts', message: 'Created new.ts' }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command?.output).toBe('Created new.ts');
-});
-it('replayEvents: assistant_turn renders create_file failure output from parsed error field', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'make file' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'create_file', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'create_file',
-                        status: 'failed',
-                        output: JSON.stringify({ success: false, error: 'Error: File already exists at new.ts' }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command?.output).toBe('Error: File already exists at new.ts');
-    expect(command?.status).toBe('failed');
-});
-it('replayEvents: assistant_turn falls through to JSON pretty-print for unknown tool output shape', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'weird tool' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'shell',
-                        status: 'completed',
-                        output: JSON.stringify({ unexpected: { nested: 1 } }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    // No error/message/path/summary keys; pretty-printed JSON is the contract.
-    expect(command?.output).toMatch(/^\{\n  "unexpected": \{/);
-});
-it('replayEvents: assistant_turn unwraps AI-SDK style { type: text, text } wrapper from JSON string', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run something' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'shell',
-                        status: 'completed',
-                        output: JSON.stringify({ type: 'text', text: 'hello world' }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command?.output).toBe('hello world');
-});
-it('replayEvents: assistant_turn unwraps OpenAI Responses { type: output_text, text } wrapper from JSON string', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run something' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'shell',
-                        status: 'completed',
-                        output: JSON.stringify({ type: 'output_text', text: 'Tue May 12 18:40:41 +07 2026' }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command?.output).toBe('Tue May 12 18:40:41 +07 2026');
-});
-it('replayEvents: assistant_turn unwraps { content: [...] } content-parts array from JSON string', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run something' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'shell',
-                        status: 'completed',
-                        output: JSON.stringify({
-                            content: [
-                                { type: 'text', text: 'first' },
-                                { type: 'text', text: 'second' },
-                            ],
-                        }),
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command?.output).toBe('first\nsecond');
-});
-it('replayEvents: assistant_turn unwraps { type: text, text } wrapper when tool_result.output is already an object', () => {
-    // Some tool results are persisted as raw objects (not JSON strings).
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run something' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: '{}' },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'shell',
-                        status: 'completed',
-                        output: { type: 'text', text: 'plain output' },
-                    },
-                ],
-            },
-            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const command = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(command?.output).toBe('plain output');
-});
-it('replayEvents: assistant_turn prefers persisted displayUsage for resumed footer usage', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run ls' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: 'ls' },
-                    { type: 'tool_result', callId: 'call-1', toolName: 'shell', status: 'completed', output: 'files' },
-                    { type: 'assistant_text', text: 'done' },
-                ],
-            },
-            usage: { prompt_tokens: 6000, completion_tokens: 280, total_tokens: 6280 },
-            displayUsage: { prompt_tokens: 3000, completion_tokens: 120, total_tokens: 3120 },
-            snapshot: {
-                history: [],
-                previousResponseId: 'r1',
-                toolLedger: [],
-            },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.messages[2].sender).toBe('bot');
-    expect(restored.messages[2].usage).toEqual({ prompt_tokens: 3000, completion_tokens: 120, total_tokens: 3120 });
-    expect(restored.usage).toEqual({ prompt_tokens: 6000, completion_tokens: 280, total_tokens: 6280 });
-});
-it('replayEvents: assistant_turn does not infer resumed footer usage from cumulative usage for tool turns', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run ls' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: 'ls' },
-                    { type: 'tool_result', callId: 'call-1', toolName: 'shell', status: 'completed', output: 'files' },
-                    { type: 'assistant_text', text: 'done' },
-                ],
-            },
-            usage: { prompt_tokens: 6000, completion_tokens: 280, total_tokens: 6280 },
-            snapshot: {
-                history: [],
-                previousResponseId: 'r1',
-                toolLedger: [],
-            },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.messages[2].sender).toBe('bot');
-    expect(restored.messages[2].usage).toBe(undefined);
-    expect(restored.usage).toEqual({ prompt_tokens: 6000, completion_tokens: 280, total_tokens: 6280 });
-});
-it('replayEvents: assistant_turn deduplicates earlier coarse command_message events from same turn', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } }),
-        // Coarse events emitted during execution
-        env({
-            type: 'command_message',
-            message: { id: 'cmd-coarse', sender: 'command', status: 'running', command: 'ls', output: '' },
-        }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    { type: 'tool_call', callId: 'call-1', toolName: 'shell', arguments: 'ls' },
-                    { type: 'tool_result', callId: 'call-1', toolName: 'shell', status: 'completed', output: 'files' },
-                    { type: 'assistant_text', text: 'done' },
-                ],
-            },
-            snapshot: {
-                history: [],
-                previousResponseId: 'r1',
-                toolLedger: [],
-            },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    // Coarse 'cmd-coarse' should be removed, replaced with replayed assistant turn messages.
-    expect(restored.messages.length).toBe(3); // 1 user + 1 command + 1 bot
-    expect(restored.messages[0].sender).toBe('user');
-    expect(restored.messages[1].sender).toBe('command');
-    expect(restored.messages[1].callId).toBe('call-1');
-    expect(restored.messages[1].status).toBe('completed');
-    expect(restored.messages[2].sender).toBe('bot');
-    expect(restored.messages[2].text).toBe('done');
-});
-it('replayEvents: assistant_turn rebuilds structured assistant history for resume', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run date' } }),
-        env({
-            type: 'assistant_turn',
-            turn: {
-                items: [
-                    {
-                        type: 'reasoning',
-                        text: 'I should run date.',
-                        providerMetadata: {
-                            reasoning_content: 'I should run date.',
-                            reasoning_details: [{ type: 'summary_text', text: 'I should run date.' }],
-                        },
-                    },
-                    {
-                        type: 'tool_call',
-                        callId: 'call-1',
-                        toolName: 'shell',
-                        arguments: '{"command":"date"}',
-                        providerItem: {
-                            type: 'function_call',
-                            id: 'fc_1',
-                            callId: 'call-1',
-                            name: 'shell',
-                            arguments: '{"command":"date"}',
-                        },
-                    },
-                    {
-                        type: 'tool_result',
-                        callId: 'call-1',
-                        toolName: 'shell',
-                        status: 'completed',
-                        output: 'Mon Jan 01 00:00:00 UTC 2024',
-                        providerItem: {
-                            type: 'function_call_result',
-                            id: 'fr_1',
-                            callId: 'call-1',
-                            name: 'shell',
-                            output: 'Mon Jan 01 00:00:00 UTC 2024',
-                        },
-                    },
-                    {
-                        type: 'reasoning',
-                        text: 'Now answer.',
-                        providerMetadata: {
-                            reasoning_content: 'Now answer.',
-                        },
-                    },
-                    {
-                        type: 'assistant_text',
-                        text: 'Done.',
-                        providerMetadata: {
-                            reasoning_content: 'Now answer.',
-                        },
-                        providerItemId: 'msg_1',
-                    },
-                ],
-            },
-            snapshot: {
-                history: [],
-                previousResponseId: 'r1',
-                toolLedger: [],
-            },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    // Reasoning is reconstructed as standalone history items (matching live SDK output)
-    // rather than folded into the adjacent tool_call / assistant message providerData.
-    // The reasoning text lives in the item's `content`; signature-bearing fields like
-    // `reasoning_details` are preserved on the standalone item's providerData.
-    expect(restored.history.length).toBe(6);
-    expect(restored.history[0]).toEqual({ role: 'user', type: 'message', content: 'run date' });
-    expect(restored.history[1]).toEqual({
-        type: 'reasoning',
-        content: [{ type: 'reasoning_text', text: 'I should run date.' }],
-        rawContent: [{ type: 'reasoning_text', text: 'I should run date.' }],
-        providerData: {
-            reasoning_details: [{ type: 'summary_text', text: 'I should run date.' }],
-        },
-    });
-    expect(restored.history[2]).toEqual({
-        type: 'function_call',
-        id: 'fc_1',
-        callId: 'call-1',
-        name: 'shell',
-        arguments: '{"command":"date"}',
-    });
-    expect(restored.history[3]).toEqual({
-        type: 'function_call_result',
-        id: 'fr_1',
-        callId: 'call-1',
-        name: 'shell',
-        output: 'Mon Jan 01 00:00:00 UTC 2024',
-    });
-    expect(restored.history[4]).toEqual({
-        type: 'reasoning',
-        content: [{ type: 'reasoning_text', text: 'Now answer.' }],
-        rawContent: [{ type: 'reasoning_text', text: 'Now answer.' }],
-    });
-    expect(restored.history[5]).toEqual({
-        role: 'assistant',
-        type: 'message',
-        id: 'msg_1',
-        status: 'completed',
-        content: [{ type: 'output_text', text: 'Done.' }],
-    });
-});
-it('replayEvents: assistant_journal_delta restores partial assistant text on crash before final', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'tell me a story' } }),
-        env({
-            type: 'assistant_journal_delta',
-            turnId: 'turn-1',
-            seq: 1,
-            kind: 'reasoning',
-            delta: 'Let me think',
-        }),
-        env({
-            type: 'assistant_journal_delta',
-            turnId: 'turn-1',
-            seq: 2,
-            kind: 'text',
-            delta: 'Once upon a time',
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    // Reasoning and assistant text fragments surface as visible messages.
-    expect(restored.messages.some((m) => m.sender === 'reasoning' && m.text === 'Let me think')).toBe(true);
-    expect(restored.messages.some((m) => m.sender === 'bot' && m.text === 'Once upon a time')).toBe(true);
-    // History was reconstructed from the fragments so the next resumed request can see them.
-    expect(restored.history.some((h) => h.type === 'reasoning' && h.content?.[0]?.text === 'Let me think')).toBe(true);
-    expect(restored.history.some((h) => h.role === 'assistant' && h.content?.[0]?.text === 'Once upon a time')).toBe(true);
-});
-it('replayEvents: assistant_journal_item restores history and ledger on interrupted turn', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run pwd' } }),
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 1,
-            item: {
-                type: 'reasoning',
-                text: 'I should check the current directory.',
-                providerMetadata: {
-                    reasoning_content: 'I should check the current directory.',
-                },
-            },
-        }),
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 2,
-            item: {
-                type: 'tool_call',
-                callId: 'call-1',
-                toolName: 'shell',
-                arguments: '{"command":"pwd"}',
-                providerItem: {
-                    type: 'function_call',
-                    callId: 'call-1',
-                    name: 'shell',
-                    arguments: '{"command":"pwd"}',
-                },
-            },
-        }),
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 3,
-            item: {
-                type: 'tool_result',
-                callId: 'call-1',
-                toolName: 'shell',
-                status: 'completed',
-                output: '/repo',
-                providerItem: {
-                    type: 'function_call_result',
-                    callId: 'call-1',
-                    name: 'shell',
-                    output: '/repo',
-                },
-            },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    // Reasoning, tool call, and result were pushed into history for the next resumed request.
-    const reasoningIndex = restored.history.findIndex((h) => h.type === 'reasoning');
-    const callIndex = restored.history.findIndex((h) => h.type === 'function_call' && h.callId === 'call-1');
-    const resultIndex = restored.history.findIndex((h) => h.type === 'function_call_result' && h.callId === 'call-1');
-    expect(reasoningIndex > -1).toBe(true);
-    expect(callIndex > reasoningIndex).toBe(true);
-    expect(resultIndex > callIndex).toBe(true);
-    expect(restored.history[reasoningIndex].content[0].text).toBe('I should check the current directory.');
-    expect(restored.history[callIndex].name).toBe('shell');
-    expect(restored.history[resultIndex].output).toBe('/repo');
-    expect((restored.toolLedger[0].historyItems?.[0]).type).toBe('reasoning');
-    expect((restored.toolLedger[0].historyItems?.[1]).type).toBe('function_call');
-    expect((restored.toolLedger[0].historyItems?.[2]).type).toBe('function_call_result');
-    // The corresponding command message in the UI shows the completed output.
-    const commandMsg = restored.messages.find((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(commandMsg).toBeTruthy();
-    expect(commandMsg?.status).toBe('completed');
-    expect(commandMsg?.output).toBe('/repo');
-});
-it('replayEvents: journal reasoning is preserved when tool_result already populated ledger history', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run pwd' } }),
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 1,
-            item: {
-                type: 'reasoning',
-                text: 'I should check pwd.',
-                providerMetadata: { reasoning_content: 'I should check pwd.' },
-            },
-        }),
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 2,
-            item: {
-                type: 'tool_call',
-                callId: 'call-1',
-                toolName: 'shell',
-                arguments: '{"command":"pwd"}',
-                providerItem: {
-                    type: 'function_call',
-                    callId: 'call-1',
-                    name: 'shell',
-                    arguments: '{"command":"pwd"}',
-                },
-            },
-        }),
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 3,
-            item: {
-                type: 'tool_result',
-                callId: 'call-1',
-                toolName: 'shell',
-                status: 'completed',
-                output: '/repo',
-                providerItem: {
-                    type: 'function_call_result',
-                    callId: 'call-1',
-                    name: 'shell',
-                    output: '/repo',
-                },
-            },
-        }),
-        env({
-            type: 'tool_result',
-            turnId: 'turn-1',
-            callId: 'call-1',
-            toolName: 'shell',
-            status: 'completed',
-            output: '/repo',
-            historyItems: [
-                { type: 'function_call', callId: 'call-1', name: 'shell', arguments: '{"command":"pwd"}' },
-                { type: 'function_call_result', callId: 'call-1', name: 'shell', output: '/repo' },
-            ],
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    const historyItems = restored.toolLedger[0].historyItems;
-    expect(historyItems.map((item) => item.type)).toEqual(['reasoning', 'function_call', 'function_call_result']);
-    expect(historyItems[0].content[0].text).toBe('I should check pwd.');
-});
-it('replayEvents: mixed journal items and fragments preserve partial assistant output', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run pwd' } }),
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 1,
-            item: {
-                type: 'tool_call',
-                callId: 'call-1',
-                toolName: 'shell',
-                arguments: '{"command":"pwd"}',
-                providerItem: {
-                    type: 'function_call',
-                    callId: 'call-1',
-                    name: 'shell',
-                    arguments: '{"command":"pwd"}',
-                },
-            },
-        }),
-        env({
-            type: 'assistant_journal_delta',
-            turnId: 'turn-1',
-            seq: 2,
-            kind: 'reasoning',
-            delta: 'checking the workspace',
-        }),
-        env({
-            type: 'assistant_journal_delta',
-            turnId: 'turn-1',
-            seq: 3,
-            kind: 'text',
-            delta: 'I found the file',
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    expect(restored.messages.some((m) => m.sender === 'command' && m.callId === 'call-1')).toBe(true);
-    expect(restored.messages.some((m) => m.sender === 'reasoning' && m.text === 'checking the workspace')).toBe(true);
-    expect(restored.messages.some((m) => m.sender === 'bot' && m.text === 'I found the file')).toBe(true);
-    expect(restored.history.some((h) => h.type === 'reasoning' && h.content?.[0]?.text === 'checking the workspace')).toBe(true);
-    expect(restored.history.some((h) => h.role === 'assistant' && h.content?.[0]?.text === 'I found the file')).toBe(true);
-});
-it('replayEvents: approval_required without final turn restores open tool state', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'rm -rf /' } }),
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 1,
-            item: {
-                type: 'tool_call',
-                callId: 'call-1',
-                toolName: 'shell',
-                arguments: '{"command":"rm -rf /"}',
-                providerItem: {
-                    type: 'function_call',
-                    callId: 'call-1',
-                    name: 'shell',
-                    arguments: '{"command":"rm -rf /"}',
-                },
-            },
-        }),
-        env({
-            type: 'approval_required',
-            approval: { callId: 'call-1', toolName: 'shell', argumentsText: 'rm -rf /', agentName: 'assistant' },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    // Approval is still pending -> the in-flight tool call must remain
-    // visible in the recovery state (toolLedger carries the started entry)
-    // instead of being marked aborted.
-    expect(restored.toolLedger.length > 0).toBe(true);
-    expect(restored.history.some((h) => h.type === 'function_call' && h.callId === 'call-1')).toBe(true);
-    expect(restored.previousResponseId).toBe(null);
-});
-it('replayEvents: completed turn prefers assistant_turn over earlier journal fragments', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'do it' } }),
-        // Coarse journal fragments: an older draft the model streamed and replaced.
-        env({
-            type: 'assistant_journal_delta',
-            turnId: 'turn-1',
-            seq: 1,
-            kind: 'text',
-            delta: 'draft ',
-        }),
-        env({
-            type: 'assistant_journal_delta',
-            turnId: 'turn-1',
-            seq: 2,
-            kind: 'text',
-            delta: 'text',
-        }),
-        // Final assistant_turn supersedes the journal transcript.
-        env({
-            type: 'assistant_turn',
-            turn: { items: [{ type: 'assistant_text', text: 'final' }] },
-            state: { previousResponseId: 'r1' },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    // The draft "draft text" must NOT appear in messages or history; only "final" should.
-    expect(restored.messages.some((m) => m.sender === 'bot' && m.text === 'draft text')).toBe(false);
-    expect(restored.messages.some((m) => m.sender === 'bot' && m.text === 'final')).toBe(true);
-    expect(restored.history.some((h) => h.role === 'assistant' && h.content?.[0]?.text === 'draft text')).toBe(false);
-});
-it('replayEvents: command_message tool output is deduped when a richer tool result exists', () => {
-    const envelopes = [
-        env({ type: 'session_init', id: 'sess', createdAt: '2026-01-01T00:00:00Z' }),
-        env({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run pwd' } }),
-        // Coarse command_message emitted during streaming: "running" placeholder.
-        env({
-            type: 'command_message',
-            message: {
-                id: 'cmd-1',
-                sender: 'command',
-                status: 'running',
-                command: 'pwd',
-                output: '',
-                callId: 'call-1',
-                toolName: 'shell',
-            },
-        }),
-        // Journal tool_result with the real, richer output.
-        env({
-            type: 'assistant_journal_item',
-            turnId: 'turn-1',
-            seq: 1,
-            item: {
-                type: 'tool_result',
-                callId: 'call-1',
-                toolName: 'shell',
-                status: 'completed',
-                output: '/repo',
-                providerItem: {
-                    type: 'function_call_result',
-                    callId: 'call-1',
-                    name: 'shell',
-                    output: '/repo',
-                },
-            },
-        }),
-    ];
-    const restored = replayEvents(envelopes);
-    // The journal's richer tool result wins; the running placeholder is gone.
-    const commandMsgs = restored.messages.filter((m) => m.sender === 'command' && m.callId === 'call-1');
-    expect(commandMsgs.length).toBe(1);
-    expect(commandMsgs[0].status).toBe('completed');
-    expect(commandMsgs[0].output).toBe('/repo');
-});
-//# sourceMappingURL=conversation-replay.test.js.map