@qduc/term2 0.7.2 → 0.8.0

package/dist/utils/conversation/conversation-event-handler.test.js

@@ -0,0 +1,1453 @@
+import { it, expect } from 'vitest';
+import { createConversationEventHandler } from './conversation-event-handler.js';
+import { createStreamingState } from './conversation-utils.js';
+function createMockDeps() {
+    const calls = {
+        botResponsePushes: [],
+        botResponseCancelled: false,
+        botResponseFlushed: false,
+        reasoningPushes: [],
+        reasoningFlushed: false,
+        reasoningCancelled: false,
+        appendedMessages: [],
+        setMessagesCalls: [],
+    };
+    return {
+        calls,
+        createMessageId: (() => {
+            let seq = 0;
+            return () => `msg-${seq++}`;
+        })(),
+        botResponseUpdater: {
+            push: (text) => calls.botResponsePushes.push(text),
+            cancel: () => {
+                calls.botResponseCancelled = true;
+            },
+            flush: () => {
+                calls.botResponseFlushed = true;
+            },
+        },
+        reasoningUpdater: {
+            push: (text) => calls.reasoningPushes.push(text),
+            cancel: () => {
+                calls.reasoningCancelled = true;
+            },
+            flush: () => {
+                calls.reasoningFlushed = true;
+            },
+        },
+        appendMessages: (messages) => calls.appendedMessages.push(messages),
+        setMessages: (updater) => calls.setMessagesCalls.push(updater),
+        trimMessages: (messages) => messages,
+        annotateCommandMessage: (msg) => ({ ...msg, annotated: true }),
+    };
+}
+// =============================================================================
+// text_delta tests
+// =============================================================================
+it('text_delta: avoids splitting inside a code block and splits after it closes', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'text_delta',
+        delta: 'Here is code:\n```javascript\nconst a = 1;\n\nconst b = 2;\n```\nTail',
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    const next = deps.calls.setMessagesCalls[0]([]);
+    expect(next[0].text).toBe('Here is code:\n```javascript\nconst a = 1;\n\nconst b = 2;\n```\n');
+    expect(next[1].text).toBe('Tail');
+    expect(state.accumulatedText).toBe('Here is code:\n```javascript\nconst a = 1;\n\nconst b = 2;\n```\nTail');
+    expect(state.flushedTextLength).toBe('Here is code:\n```javascript\nconst a = 1;\n\nconst b = 2;\n```\n'.length);
+});
+it('text_delta: accumulates text and pushes to live response', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'text_delta', delta: 'Hello ' });
+    handler({ type: 'text_delta', delta: 'world!' });
+    expect(state.accumulatedText).toBe('Hello world!');
+    expect(deps.calls.botResponsePushes).toEqual(['Hello ', 'Hello world!']);
+});
+it('text_delta: preserves newline between code fence language and first code line', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'text_delta', delta: '```typescript' });
+    handler({ type: 'text_delta', delta: '\n' });
+    handler({ type: 'text_delta', delta: 'if (enabled) {\n' });
+    expect(state.accumulatedText).toBe('```typescript\nif (enabled) {\n');
+    expect(deps.calls.botResponsePushes.includes('```typescript\nif (enabled) {\n')).toBe(true);
+});
+it('text_delta: finalizes stable paragraphs and streams only the unfinished tail', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    // Single delta that contains two complete paragraphs followed by an unfinished tail.
+    // The handler should flush the completed paragraphs as a finalized message and
+    // push only the tail to the live updater.
+    handler({
+        type: 'text_delta',
+        delta: 'First paragraph.\n\nSecond paragraph.\n\nCurrent tail',
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    expect(deps.calls.setMessagesCalls[0]([])).toEqual([
+        {
+            id: 'msg-0',
+            sender: 'bot',
+            status: 'finalized',
+            text: 'First paragraph.\n\nSecond paragraph.\n\n',
+        },
+        {
+            id: 'msg-1',
+            sender: 'bot',
+            status: 'streaming',
+            text: 'Current tail',
+        },
+    ]);
+    expect(state.flushedTextLength).toBe('First paragraph.\n\nSecond paragraph.\n\n'.length);
+    expect(deps.calls.botResponseCancelled).toBe(true);
+    expect(state.currentBotMessageId).toBe('msg-1');
+});
+it('text_delta: atomically commits a heading before its unfinished paragraph', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    const text = 'Earlier paragraph.\n\n---\n\n### The boundary\n\nThe dividing line is still streaming';
+    handler({ type: 'text_delta', delta: text });
+    expect(deps.calls.setMessagesCalls[0]([])).toEqual([
+        {
+            id: 'msg-0',
+            sender: 'bot',
+            status: 'finalized',
+            text: 'Earlier paragraph.\n\n---\n\n### The boundary\n\n',
+        },
+        {
+            id: 'msg-1',
+            sender: 'bot',
+            status: 'streaming',
+            text: 'The dividing line is still streaming',
+        },
+    ]);
+});
+it('text_delta: atomically replaces the live message with a finalized prefix and live suffix', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.currentBotMessageId = 'active-bot';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'text_delta',
+        delta: 'First paragraph.\n\nCurrent tail',
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    expect(deps.calls.setMessagesCalls[0]([
+        { id: 'active-bot', sender: 'bot', status: 'streaming', text: 'First paragraph.' },
+    ])).toEqual([
+        {
+            id: 'active-bot',
+            sender: 'bot',
+            status: 'finalized',
+            text: 'First paragraph.\n\n',
+        },
+        {
+            id: 'msg-0',
+            sender: 'bot',
+            status: 'streaming',
+            text: 'Current tail',
+        },
+    ]);
+    expect(state.currentBotMessageId).toBe('msg-0');
+});
+it('text_delta: does not finalize until a paragraph boundary exists', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'text_delta', delta: 'Single paragraph still growing' });
+    expect(deps.calls.appendedMessages).toEqual([]);
+    expect(state.flushedTextLength).toBe(0);
+    expect(state.accumulatedText).toBe('Single paragraph still growing');
+    expect(deps.calls.botResponsePushes).toEqual(['Single paragraph still growing']);
+});
+it('text_delta: finalizes an existing live bot message in place before streaming a new tail', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.currentBotMessageId = 'active-bot';
+    const handler = createConversationEventHandler(deps, state);
+    // Arrive with a delta that completes the first paragraph and starts a new tail.
+    // The handler should update the existing 'active-bot' message with the finalized
+    // paragraph text and push the new tail to the live updater.
+    handler({
+        type: 'text_delta',
+        delta: 'Old tail now complete.\n\nNew tail',
+    });
+    expect(deps.calls.appendedMessages).toEqual([]);
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'active-bot',
+            sender: 'bot',
+            text: 'Old tail',
+        },
+    ]);
+    expect(next).toEqual([
+        {
+            id: 'active-bot',
+            sender: 'bot',
+            status: 'finalized',
+            text: 'Old tail now complete.\n\n',
+        },
+        {
+            id: 'msg-0',
+            sender: 'bot',
+            status: 'streaming',
+            text: 'New tail',
+        },
+    ]);
+    expect(state.currentBotMessageId).toBe('msg-0');
+    expect(state.flushedTextLength).toBe('Old tail now complete.\n\n'.length);
+    expect(deps.calls.botResponseCancelled).toBe(true);
+});
+it('text_delta: keeps the final paragraph mutable when only trailing whitespace follows it', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.currentBotMessageId = 'active-bot';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'text_delta',
+        delta: 'Finished paragraph.\n\n',
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(0);
+    expect(deps.calls.botResponsePushes).toEqual(['Finished paragraph.\n\n']);
+    expect(deps.calls.botResponseCancelled).toBe(false);
+});
+// =============================================================================
+// reasoning_delta tests
+// =============================================================================
+it('reasoning_delta: accumulates reasoning after flushed position', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: 'ing',
+        fullText: 'Thinking',
+    });
+    expect(state.accumulatedReasoningText).toBe('Thinking');
+    expect(deps.calls.reasoningPushes).toEqual(['Thinking']);
+});
+it('reasoning_delta: skips already flushed reasoning', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.flushedReasoningLength = 5; // Already flushed "Think"
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: 'ing',
+        fullText: 'Thinking',
+    });
+    expect(state.accumulatedReasoningText).toBe('ing');
+    expect(deps.calls.reasoningPushes).toEqual(['ing']);
+});
+it('reasoning_delta: ignores empty reasoning', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: '',
+        fullText: '   ',
+    });
+    expect(state.accumulatedReasoningText).toBe('   ');
+    expect(deps.calls.reasoningPushes).toEqual([]);
+});
+it('reasoning_delta: finalizes stable paragraphs and streams only the unfinished tail', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: 'tail',
+        fullText: 'First paragraph.\n\nSecond paragraph.\n\nCurrent tail',
+    });
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    expect(deps.calls.appendedMessages[0]).toEqual([
+        {
+            id: 'msg-0',
+            sender: 'reasoning',
+            status: 'finalized',
+            text: 'First paragraph.\n\nSecond paragraph.\n\n',
+        },
+    ]);
+    expect(state.flushedReasoningLength).toBe('First paragraph.\n\nSecond paragraph.\n\n'.length);
+    expect(state.accumulatedReasoningText).toBe('Current tail');
+    expect(deps.calls.reasoningPushes).toEqual(['Current tail']);
+});
+it('reasoning_delta: does not finalize until a paragraph boundary exists', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: 'tail',
+        fullText: 'Single paragraph still growing',
+    });
+    expect(deps.calls.appendedMessages).toEqual([]);
+    expect(state.flushedReasoningLength).toBe(0);
+    expect(state.accumulatedReasoningText).toBe('Single paragraph still growing');
+    expect(deps.calls.reasoningPushes).toEqual(['Single paragraph still growing']);
+});
+it('reasoning_delta: finalizes an existing live reasoning message in place before streaming a new tail', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.currentReasoningMessageId = 'active-reasoning';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: 'tail',
+        fullText: 'Old tail now complete.\n\nNew tail',
+    });
+    expect(deps.calls.appendedMessages).toEqual([]);
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            text: 'Old tail',
+        },
+    ]);
+    expect(next).toEqual([
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            status: 'finalized',
+            text: 'Old tail now complete.\n\n',
+        },
+    ]);
+    expect(state.currentReasoningMessageId === null).toBe(true);
+    expect(state.flushedReasoningLength).toBe('Old tail now complete.\n\n'.length);
+    expect(state.accumulatedReasoningText).toBe('New tail');
+    expect(deps.calls.reasoningPushes).toEqual(['New tail']);
+    expect(deps.calls.reasoningCancelled).toBe(true);
+});
+it('reasoning_delta: keeps the final paragraph mutable when only trailing whitespace follows it', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.currentReasoningMessageId = 'active-reasoning';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: '\n\n',
+        fullText: 'Finished reasoning paragraph.\n\n',
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(0);
+    expect(deps.calls.reasoningCancelled).toBe(false);
+    expect(deps.calls.reasoningPushes).toEqual(['Finished reasoning paragraph.\n\n']);
+    expect(state.accumulatedReasoningText).toBe('Finished reasoning paragraph.\n\n');
+    expect(state.currentReasoningMessageId).toBe('active-reasoning');
+});
+// =============================================================================
+// tool_started tests
+// =============================================================================
+it('tool_started: flushes accumulated text before showing tool', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.accumulatedText = 'Some text before tool';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-1',
+        toolName: 'shell',
+        arguments: { command: 'ls' },
+    });
+    expect(state.accumulatedText).toBe('');
+    expect(state.textWasFlushed).toBe(true);
+    expect(deps.calls.botResponseCancelled).toBe(true);
+    // Should append text message and command message
+    expect(deps.calls.appendedMessages.length).toBe(2);
+    expect(deps.calls.appendedMessages[0][0].sender).toBe('bot');
+    expect(deps.calls.appendedMessages[0][0].status).toBe('finalized');
+    expect(deps.calls.appendedMessages[0][0].text).toBe('Some text before tool');
+});
+it('tool_started: flushes accumulated reasoning before showing tool', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.accumulatedReasoningText = 'Some reasoning';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-1',
+        toolName: 'shell',
+        arguments: { command: 'ls' },
+    });
+    expect(deps.calls.reasoningFlushed).toBe(true);
+    expect(state.accumulatedReasoningText).toBe('');
+    expect(state.flushedReasoningLength).toBe(14); // 'Some reasoning'.length
+    expect(state.currentReasoningMessageId === null).toBe(true);
+});
+it('tool_started: finalizes live reasoning text before clearing it', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.currentReasoningMessageId = 'active-reasoning';
+    state.accumulatedReasoningText = 'Reasoning before the tool';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-1',
+        toolName: 'shell',
+        arguments: { command: 'ls' },
+    });
+    expect(deps.calls.reasoningFlushed).toBe(true);
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            text: 'Reasoning before the tool',
+        },
+    ]);
+    expect(next).toEqual([
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            status: 'finalized',
+            text: 'Reasoning before the tool',
+        },
+    ]);
+    expect(state.accumulatedReasoningText).toBe('');
+    expect(state.flushedReasoningLength).toBe('Reasoning before the tool'.length);
+    expect(state.currentReasoningMessageId === null).toBe(true);
+});
+it('reasoning_delta: does not drop prefix when reasoning restarts after a tool', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: 'Before tool',
+        fullText: 'Before tool',
+    });
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-1',
+        toolName: 'shell',
+        arguments: { command: 'ls' },
+    });
+    handler({
+        type: 'reasoning_delta',
+        delta: 'After tool reasoning',
+        fullText: 'After tool reasoning',
+    });
+    expect(state.accumulatedReasoningText).toBe('After tool reasoning');
+    expect(deps.calls.reasoningPushes).toEqual(['Before tool', 'After tool reasoning']);
+});
+it('tool_started: creates pending command message with shell command', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-1',
+        toolName: 'shell',
+        arguments: { command: 'echo hello' },
+    });
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    const cmdMsg = deps.calls.appendedMessages[0][0];
+    expect(cmdMsg.sender).toBe('command');
+    expect(cmdMsg.status).toBe('running');
+    expect(cmdMsg.command).toBe('echo hello');
+    expect(cmdMsg.toolName).toBe('shell');
+    expect(cmdMsg.callId).toBe('call-1');
+});
+it('tool_started: parses JSON string arguments', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-1',
+        toolName: 'shell',
+        arguments: '{"command": "pwd"}',
+    });
+    const cmdMsg = deps.calls.appendedMessages[0][0];
+    expect(cmdMsg.command).toBe('pwd');
+    expect(cmdMsg.toolArgs).toEqual({ command: 'pwd' });
+});
+it('tool_started: formats grep command correctly', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-1',
+        toolName: 'grep',
+        arguments: { pattern: 'TODO', path: 'src/' },
+    });
+    const cmdMsg = deps.calls.appendedMessages[0][0];
+    expect(cmdMsg.command).toBe('grep "TODO" src/');
+});
+it('tool_started: skips pending message for run_subagent (SubagentActivityMessage handles display)', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-sa-1',
+        toolName: 'run_subagent',
+        arguments: { role: 'worker', task: 'fix the bug' },
+    });
+    expect(deps.calls.appendedMessages.length).toBe(0);
+});
+it('tool_started: does not append duplicate running message for the same callId', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-dup-1',
+        toolName: 'shell',
+        arguments: { command: 'ls -la' },
+    });
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-dup-1',
+        toolName: 'shell',
+        arguments: { command: 'ls -la' },
+    });
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    expect(deps.calls.appendedMessages[0][0].callId).toBe('call-dup-1');
+    expect(deps.calls.appendedMessages[0][0].status).toBe('running');
+});
+// =============================================================================
+// command_message tests
+// =============================================================================
+it('command_message: annotates and updates existing pending message', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'call-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'ls',
+            output: 'file.txt',
+            callId: 'call-1',
+            toolName: 'shell',
+        },
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    // The annotateCommandMessage should have been called
+    const updater = deps.calls.setMessagesCalls[0];
+    const existingMessages = [{ id: 'call-1', sender: 'command', status: 'running', callId: 'call-1' }];
+    const result = updater(existingMessages);
+    expect(result[0].annotated).toBe(true);
+    expect(result[0].status).toBe('completed');
+});
+it('command_message: adds new message if no pending exists', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'call-new',
+            sender: 'command',
+            status: 'completed',
+            command: 'ls',
+            output: 'file.txt',
+            callId: 'call-new',
+            toolName: 'shell',
+        },
+    });
+    const updater = deps.calls.setMessagesCalls[0];
+    const existingMessages = [{ id: 1, sender: 'user', text: 'hi' }];
+    const result = updater(existingMessages);
+    expect(result.length).toBe(2);
+    expect(result[1].annotated).toBe(true);
+});
+it('command_message: flushes accumulated text before adding', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.accumulatedText = 'Partial response';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'call-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'ls',
+            output: '',
+            callId: 'call-1',
+        },
+    });
+    expect(state.accumulatedText).toBe('');
+    expect(state.textWasFlushed).toBe(true);
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    expect(deps.calls.appendedMessages[0][0].status).toBe('finalized');
+    expect(deps.calls.appendedMessages[0][0].text).toBe('Partial response');
+});
+it('tool_recovery: marks dropped running commands failed and appends recovery note', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_recovery',
+        recoveredCallIds: ['call-read'],
+        droppedCallIds: ['call-write'],
+        message: 'Recovered 1 completed tool call/result pair(s) from a previously interrupted turn. Dropped 1 incomplete tool call(s); do not assume dropped calls completed.',
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'read',
+            sender: 'command',
+            status: 'completed',
+            command: 'read_file source/a.ts',
+            output: 'contents',
+            callId: 'call-read',
+        },
+        {
+            id: 'write',
+            sender: 'command',
+            status: 'running',
+            command: 'apply_patch',
+            output: '',
+            callId: 'call-write',
+        },
+    ]);
+    expect(next[0].status).toBe('completed');
+    expect(next[1].status).toBe('failed');
+    expect(next[1].failureReason).toBe('Dropped during recovery');
+    expect(next[1].output.includes('not sent to model history')).toBe(true);
+    expect(next[2].sender).toBe('system');
+    expect(next[2].text.startsWith('Recovered 1 completed')).toBe(true);
+});
+// =============================================================================
+// subagent activity tests
+// =============================================================================
+it('subagent events: maintains a live peek with the last three tools', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'inspect the command message rendering flow and report findings',
+    });
+    expect(deps.calls.appendedMessages[0]).toEqual([
+        {
+            id: 'subagent-agent-1',
+            sender: 'subagent',
+            status: 'running',
+            agentId: 'agent-1',
+            role: 'explorer',
+            task: 'inspect the command message rendering flow and report findings',
+            tools: [],
+        },
+    ]);
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: { toolName: 'find_files', command: 'find_files "*.ts"', success: true, output: '' },
+    });
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: { toolName: 'grep', command: 'grep "needle" "source"', success: true, output: 'line1\nline2' },
+    });
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: { toolName: 'read_file', command: 'read_file "source/app.tsx"', success: true, output: '' },
+    });
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: {
+            toolName: 'read_code_outline',
+            command: 'read_code_outline "source/app.tsx"',
+            success: true,
+            output: '',
+        },
+    });
+    let messages = deps.calls.appendedMessages[0];
+    for (const update of deps.calls.setMessagesCalls) {
+        messages = update(messages);
+    }
+    expect(messages).toEqual([
+        {
+            id: 'subagent-agent-1',
+            sender: 'subagent',
+            status: 'running',
+            agentId: 'agent-1',
+            role: 'explorer',
+            task: 'inspect the command message rendering flow and report findings',
+            tools: [
+                'grep "needle" "source" (2 matches)',
+                'read_file "source/app.tsx" (Success)',
+                'read_code_outline "source/app.tsx" (Success)',
+            ],
+        },
+    ]);
+});
+it('subagent_completed updates the status of the live peek', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_completed',
+        result: {
+            agentId: 'agent-1',
+            role: 'worker',
+            status: 'completed',
+            finalText: 'done',
+            filesChanged: [],
+            toolsUsed: [],
+        },
+    });
+    const result = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'subagent-agent-1',
+            sender: 'subagent',
+            status: 'running',
+            agentId: 'agent-1',
+            role: 'worker',
+            task: 'make the change',
+            tools: ['apply_patch'],
+        },
+    ]);
+    expect(result).toEqual([
+        {
+            id: 'subagent-agent-1',
+            sender: 'subagent',
+            status: 'completed',
+            agentId: 'agent-1',
+            role: 'worker',
+            task: 'make the change',
+            finalText: 'done',
+            tools: ['apply_patch'],
+        },
+    ]);
+});
+it('subagent_started links callId from tool_started and command_message replaces it', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    // 1. tool_started for run_subagent
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-sa-123',
+        toolName: 'run_subagent',
+        arguments: { role: 'worker', task: 'do task X' },
+    });
+    // 2. subagent_started
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-sa-123',
+        role: 'worker',
+        task: 'do task X',
+    });
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    const subagentMsg = deps.calls.appendedMessages[0][0];
+    expect(subagentMsg.sender).toBe('subagent');
+    expect(subagentMsg.callId).toBe('call-sa-123');
+    // 3. subagent_completed updates status
+    handler({
+        type: 'subagent_completed',
+        result: {
+            agentId: 'agent-sa-123',
+            role: 'worker',
+            status: 'completed',
+            finalText: 'done',
+            filesChanged: [],
+            toolsUsed: [],
+        },
+    });
+    // 4. command_message for run_subagent is now skipped (SubagentActivityMessage
+    //    handles display), so no additional setMessages call is made.
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'result-sa-123',
+            sender: 'command',
+            status: 'completed',
+            command: 'run_subagent [worker] do task X',
+            output: 'done',
+            callId: 'call-sa-123',
+            toolName: 'run_subagent',
+        },
+    });
+    // Only one setMessages call: from subagent_completed, not from command_message
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    // The subagent message remains intact (not replaced by command message)
+    const completedMsg = deps.calls.setMessagesCalls[0]([subagentMsg]);
+    expect(completedMsg.length).toBe(1);
+    expect(completedMsg[0].sender).toBe('subagent');
+    expect(completedMsg[0].status).toBe('completed');
+});
+// =============================================================================
+// retry tests
+// =============================================================================
+it('retry: adds system message about hallucination retry', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'retry',
+        toolName: 'shell',
+        attempt: 1,
+        maxRetries: 2,
+        errorMessage: 'Tool hallucination detected',
+        retryType: 'hallucination',
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    const updater = deps.calls.setMessagesCalls[0];
+    const result = updater([]);
+    expect(result.length).toBe(1);
+    expect(result[0].sender).toBe('system');
+    expect(result[0].text.includes('shell')).toBe(true);
+    expect(result[0].text.includes('1/2')).toBe(true);
+});
+it('retry: adds generic system message when retryType is undefined', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'retry',
+        toolName: 'shell',
+        attempt: 1,
+        maxRetries: 2,
+        errorMessage: 'Generic retry error',
+    });
+    const updater = deps.calls.setMessagesCalls[0];
+    const result = updater([]);
+    expect(result.length).toBe(1);
+    expect(result[0].sender).toBe('system');
+    expect(result[0].text).toBe('Retrying... (Attempt 1/2)');
+});
+it('retry: adds system message about flex service tier fallback', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'retry',
+        toolName: 'service_tier',
+        attempt: 1,
+        maxRetries: 1,
+        errorMessage: 'Flex service tier timed out',
+        retryType: 'flex_service_tier',
+    });
+    const updater = deps.calls.setMessagesCalls[0];
+    const result = updater([]);
+    expect(result.length).toBe(1);
+    expect(result[0].sender).toBe('system');
+    expect(result[0].text.includes('Flex service tier timed out')).toBe(true);
+    expect(result[0].text.includes('standard service tier')).toBe(true);
+});
+it('retry: adds system message about upstream retry', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'retry',
+        toolName: 'continuation',
+        attempt: 1,
+        maxRetries: 3,
+        errorMessage: 'Connection error',
+        retryType: 'upstream',
+    });
+    const updater = deps.calls.setMessagesCalls[0];
+    const result = updater([]);
+    expect(result.length).toBe(1);
+    expect(result[0].sender).toBe('system');
+    expect(result[0].text).toBe('Upstream error or rate limit encountered. Retrying... (Attempt 1/3)');
+});
+it('retry: adds system message about parsing error retry', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'retry',
+        toolName: 'model',
+        attempt: 1,
+        maxRetries: 2,
+        errorMessage: 'JSON parse error',
+        retryType: 'parsing_error',
+    });
+    const updater = deps.calls.setMessagesCalls[0];
+    const result = updater([]);
+    expect(result.length).toBe(1);
+    expect(result[0].sender).toBe('system');
+    expect(result[0].text).toBe('Model parsing error detected. Retrying... (Attempt 1/2)');
+});
+it('retry: adds system message about behavior error retry', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'retry',
+        toolName: 'model',
+        attempt: 2,
+        maxRetries: 2,
+        errorMessage: 'Did not produce final response',
+        retryType: 'behavior',
+    });
+    const updater = deps.calls.setMessagesCalls[0];
+    const result = updater([]);
+    expect(result.length).toBe(1);
+    expect(result[0].sender).toBe('system');
+    expect(result[0].text).toBe('Model behavior error detected. Retrying... (Attempt 2/2)');
+});
+// =============================================================================
+// final event tests
+// =============================================================================
+it('final: finalizes trailing reasoning message that was never followed by a tool call', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.currentReasoningMessageId = 'active-reasoning';
+    state.accumulatedReasoningText = 'Trailing reasoning with no tool call';
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'final', finalText: '' });
+    expect(deps.calls.reasoningFlushed).toBe(true);
+    expect(state.accumulatedReasoningText).toBe('');
+    expect(state.currentReasoningMessageId === null).toBe(true);
+    // markCurrentReasoningFinalized sets status via setMessages
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    const next = deps.calls.setMessagesCalls[0]([
+        { id: 'active-reasoning', sender: 'reasoning', text: 'Trailing reasoning with no tool call' },
+    ]);
+    expect(next).toEqual([
+        { id: 'active-reasoning', sender: 'reasoning', status: 'finalized', text: 'Trailing reasoning with no tool call' },
+    ]);
+});
+it('final: appends missing final text after already flushed streamed text', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'text_delta', delta: 'Intro\n\n' });
+    handler({ type: 'final', finalText: 'Intro\n\n## Missing Header\n\nBody' });
+    expect(state.accumulatedText).toBe('Intro\n\n## Missing Header\n\nBody');
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    expect(deps.calls.appendedMessages[0]).toEqual([
+        {
+            id: 'msg-0',
+            sender: 'bot',
+            status: 'finalized',
+            text: 'Intro\n\n## Missing Header\n\nBody',
+        },
+    ]);
+});
+it('final: is a no-op when there is no pending reasoning', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'final', finalText: '' });
+    expect(deps.calls.reasoningFlushed).toBe(false);
+    expect(deps.calls.setMessagesCalls.length).toBe(0);
+    expect(deps.calls.appendedMessages.length).toBe(0);
+});
+// =============================================================================
+// unknown event tests
+// =============================================================================
+it('unknown event: is ignored without error', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    // Should not throw
+    handler({ type: 'unknown_event' });
+    expect(deps.calls.appendedMessages.length).toBe(0);
+    expect(deps.calls.setMessagesCalls.length).toBe(0);
+});
+// =============================================================================
+// Bug: final event silently ignores corrections when finalText.length <= accumulatedText.length
+// =============================================================================
+it('final: ignores corrected finalText when it is the same length as accumulated streamed text', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    // Simulate streaming that produced a typo whose length matches the correct text
+    state.accumulatedText = 'Hello wrold';
+    state.flushedTextLength = 0;
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'final', finalText: 'Hello world' });
+    // The guard `finalText.length > accumulatedText.length` is false for equal-length strings.
+    // accumulatedText is never updated, so the typo is what gets flushed.
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    const flushedMsg = deps.calls.appendedMessages[0][0];
+    // Fails: actual is 'Hello wrold' (the typo) — correction from finalText is silently lost
+    expect(flushedMsg.text).toBe('Hello world');
+});
+it('final: flushes over-accumulated streamed content when finalText is shorter than accumulated', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    // Simulate streaming that over-shot the authoritative answer
+    state.accumulatedText = 'The answer is 42. Extra hallucinated sentence.';
+    state.flushedTextLength = 0;
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'final', finalText: 'The answer is 42.' });
+    // The guard `finalText.length > accumulatedText.length` is false when final is shorter.
+    // accumulatedText is not corrected, so the hallucinated tail is included in the flush.
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    const flushedMsg = deps.calls.appendedMessages[0][0];
+    // Fails: actual is the full over-accumulated string including ' Extra hallucinated sentence.'
+    expect(flushedMsg.text).toBe('The answer is 42.');
+});
+// =============================================================================
+// Whitespace preservation
+// =============================================================================
+it('text_delta: preserves whitespace before the first block', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    // Response begins with whitespace before the paragraph boundary
+    handler({ type: 'text_delta', delta: '   \n\nActual content' });
+    expect(state.flushedTextLength).toBe(0);
+    expect(deps.calls.appendedMessages.length).toBe(0);
+    expect(deps.calls.botResponsePushes).toEqual(['   \n\nActual content']);
+    handler({ type: 'final', finalText: '   \n\nActual content' });
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    expect(deps.calls.appendedMessages[0][0].text).toBe('   \n\nActual content');
+});
+// =============================================================================
+// Bug: command_message without callId leaves the running message stranded
+// =============================================================================
+it('command_message: leaves stale running message when no callId is present on either side', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    // tool_started with no callId appends a running message with no way to match it later
+    handler({
+        type: 'tool_started',
+        toolCallId: undefined,
+        toolName: 'shell',
+        arguments: { command: 'ls' },
+    });
+    const runningMsg = deps.calls.appendedMessages[0][0];
+    expect(runningMsg.status).toBe('running');
+    expect(runningMsg.callId).toBe(undefined);
+    // command_message also has no callId, so pendingIndex is immediately -1
+    // and the completed message is appended rather than replacing the running one
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'result-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'ls',
+            output: 'file.txt',
+            callId: undefined,
+            toolName: 'shell',
+        },
+    });
+    const updater = deps.calls.setMessagesCalls[0];
+    const result = updater([runningMsg]);
+    // Fails: result has 2 messages — the stale 'running' + the new 'completed'
+    // Expected: 1 message, the running entry replaced by the completed one
+    expect(result.length).toBe(1);
+    expect(result[0].status).toBe('completed');
+});
+it('command_message: preserves the id of the running message when replacing it', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'call-1-0', // different id from the running command
+            sender: 'command',
+            status: 'completed',
+            command: 'ls',
+            output: 'file.txt',
+            callId: 'call-1',
+            toolName: 'shell',
+        },
+    });
+    const updater = deps.calls.setMessagesCalls[0];
+    const existingMessages = [{ id: 'call-1', sender: 'command', status: 'running', callId: 'call-1' }];
+    const result = updater(existingMessages);
+    expect(result.length).toBe(1);
+    expect(result[0].id).toBe('call-1'); // preserves running message id
+    expect(result[0].status).toBe('completed');
+});
+it('command_message: preserves running ids for batch completions matched by callId', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'call-1-0',
+            sender: 'command',
+            status: 'completed',
+            command: 'read_file file1.ts',
+            output: 'content1',
+            callId: 'call-1',
+            toolName: 'read_file',
+        },
+    });
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'call-2-0',
+            sender: 'command',
+            status: 'completed',
+            command: 'read_file file2.ts',
+            output: 'content2',
+            callId: 'call-2',
+            toolName: 'read_file',
+        },
+    });
+    const firstUpdater = deps.calls.setMessagesCalls[0];
+    const secondUpdater = deps.calls.setMessagesCalls[1];
+    const afterFirst = firstUpdater([
+        { id: 'call-1', sender: 'command', status: 'running', callId: 'call-1' },
+        { id: 'call-2', sender: 'command', status: 'running', callId: 'call-2' },
+    ]);
+    const afterSecond = secondUpdater(afterFirst);
+    expect(afterSecond.map((message) => ({
+        id: message.id,
+        callId: message.callId,
+        status: message.status,
+    }))).toEqual([
+        { id: 'call-1', callId: 'call-1', status: 'completed' },
+        { id: 'call-2', callId: 'call-2', status: 'completed' },
+    ]);
+});
+it('subagent_started: ignores event if parentTool is ask_mentor', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'mentor',
+        task: 'peer review this plan',
+        parentTool: 'ask_mentor',
+    });
+    expect(deps.calls.appendedMessages.length).toBe(0);
+});
+it('subagent_command_message: replaces generic toolName or appends command to subagent tools', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    // 1. Subagent starts
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'investigate',
+    });
+    // 2. Subagent tool starts (generic name 'read_file')
+    handler({
+        type: 'subagent_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'read_file',
+    });
+    // 3. Subagent command message received
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: {
+            id: 'cmd-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'read_file "source/app.tsx"',
+            toolName: 'read_file',
+            success: true,
+        },
+    });
+    let messages = deps.calls.appendedMessages[0];
+    for (const update of deps.calls.setMessagesCalls) {
+        messages = update(messages);
+    }
+    expect(messages).toEqual([
+        {
+            id: 'subagent-agent-1',
+            sender: 'subagent',
+            status: 'running',
+            agentId: 'agent-1',
+            role: 'explorer',
+            task: 'investigate',
+            tools: ['read_file "source/app.tsx" (Success)'],
+        },
+    ]);
+});
+it('subagent_command_message: creates subagent message if not present', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: {
+            id: 'cmd-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'read_file "source/app.tsx"',
+            toolName: 'read_file',
+            success: true,
+        },
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+    const result = deps.calls.setMessagesCalls[0]([]);
+    expect(result.length).toBe(1);
+    expect(result[0].sender).toBe('subagent');
+    expect(result[0].agentId).toBe('agent-1');
+    expect(result[0].tools).toEqual(['read_file "source/app.tsx" (Success)']);
+});
+it('subagent_tool_started: formats shell command with args', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'investigate',
+    });
+    handler({
+        type: 'subagent_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'shell',
+        arguments: { command: 'npm test' },
+    });
+    let messages = deps.calls.appendedMessages[0];
+    for (const update of deps.calls.setMessagesCalls) {
+        messages = update(messages);
+    }
+    expect(messages[0].tools).toEqual([]);
+});
+it('subagent_command_message: replaces formatted shell command and appends outcome', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'investigate',
+    });
+    handler({
+        type: 'subagent_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'shell',
+        arguments: { command: 'npm test' },
+    });
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: {
+            id: 'cmd-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'npm test',
+            toolName: 'shell',
+            success: false,
+        },
+    });
+    let messages = deps.calls.appendedMessages[0];
+    for (const update of deps.calls.setMessagesCalls) {
+        messages = update(messages);
+    }
+    expect(messages[0].tools).toEqual(['shell npm test (Failed)']);
+});
+it('subagent_command_message: counts matches for grep tool and appends count', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'investigate',
+    });
+    handler({
+        type: 'subagent_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'grep',
+        arguments: { pattern: 'TODO', path: 'src/' },
+    });
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: {
+            id: 'cmd-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'grep "TODO" "src/"',
+            toolName: 'grep',
+            output: 'src/main.ts:1:TODO: first\nsrc/main.ts:5:TODO: second',
+        },
+    });
+    let messages = deps.calls.appendedMessages[0];
+    for (const update of deps.calls.setMessagesCalls) {
+        messages = update(messages);
+    }
+    expect(messages[0].tools).toEqual(['grep "TODO" "src/" (2 matches)']);
+});
+it('subagent_command_message: appends 0 matches for empty grep output', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'investigate',
+    });
+    handler({
+        type: 'subagent_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'grep',
+        arguments: { pattern: 'TODO', path: 'src/' },
+    });
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: {
+            id: 'cmd-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'grep "TODO" "src/"',
+            toolName: 'grep',
+            output: 'No matches found.',
+        },
+    });
+    let messages = deps.calls.appendedMessages[0];
+    for (const update of deps.calls.setMessagesCalls) {
+        messages = update(messages);
+    }
+    expect(messages[0].tools).toEqual(['grep "TODO" "src/" (0 matches)']);
+});
+it('subagent_command_message: stores CommandMessage object for write tools', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'investigate',
+    });
+    const writeMsg = {
+        id: 'cmd-w1',
+        sender: 'command',
+        status: 'completed',
+        command: 'create_file "src/test.txt"',
+        toolName: 'create_file',
+        toolArgs: { path: 'src/test.txt', content: 'hello' },
+        success: true,
+    };
+    handler({
+        type: 'subagent_command_message',
+        agentId: 'agent-1',
+        role: 'explorer',
+        message: writeMsg,
+    });
+    let messages = deps.calls.appendedMessages[0];
+    for (const update of deps.calls.setMessagesCalls) {
+        messages = update(messages);
+    }
+    expect(messages[0].tools.length).toBe(1);
+    expect(messages[0].tools[0]).toEqual(writeMsg);
+});
+it('tool_started: renders parent tool call when a subagent is active', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'find x',
+    });
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-shell-1',
+        toolName: 'shell',
+        arguments: { command: 'pwd' },
+    });
+    expect(deps.calls.appendedMessages.length).toBe(2);
+    expect(deps.calls.appendedMessages[1][0].callId).toBe('call-shell-1');
+});
+it('tool_started: renders parent tool call after local subagent activity', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'inspect',
+    });
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-shell-1',
+        toolName: 'shell',
+        arguments: { command: 'pwd' },
+    });
+    expect(deps.calls.appendedMessages.length).toBe(2);
+    expect(deps.calls.appendedMessages[0][0].sender).toBe('subagent');
+    expect(deps.calls.appendedMessages[1][0].callId).toBe('call-shell-1');
+});
+it('command_message: renders parent tool completion when subagent is active', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        task: 'find x',
+    });
+    handler({
+        type: 'command_message',
+        message: {
+            id: 'result-shell-1',
+            sender: 'command',
+            status: 'completed',
+            command: 'pwd',
+            output: '/home',
+            callId: 'call-shell-1',
+            toolName: 'shell',
+        },
+    });
+    expect(deps.calls.setMessagesCalls.length).toBe(1);
+});
+it('tool_started: links subagent delegation tools to subagent activity', () => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'tool_started',
+        toolCallId: 'call-sa-nested',
+        toolName: 'run_subagent_worker',
+        arguments: { role: 'worker', task: 'nested work' },
+    });
+    handler({
+        type: 'subagent_started',
+        agentId: 'agent-sa-nested',
+        role: 'worker',
+        task: 'nested work',
+    });
+    expect(deps.calls.appendedMessages.length).toBe(1);
+    expect(deps.calls.appendedMessages[0][0].id).toBe('subagent-agent-sa-nested');
+    expect(deps.calls.appendedMessages[0][0].callId).toBe('call-sa-nested');
+});
+//# sourceMappingURL=conversation-event-handler.test.js.map