@qduc/term2 0.3.1 → 0.5.0

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

@@ -1,16 +1,16 @@
 import test from 'ava';
-import { createConversationEventHandler } from './conversation-event-handler.js';
+import { createConversationEventHandler, findLastSafeBoundary, } from './conversation-event-handler.js';
 import { createStreamingState } from './conversation-utils.js';
 function createMockDeps() {
     const calls = {
-        liveResponsePushes: [],
-        liveResponseCancelled: false,
-        liveResponseFlushed: false,
+        botResponsePushes: [],
+        botResponseCancelled: false,
+        botResponseFlushed: false,
         reasoningPushes: [],
         reasoningFlushed: false,
+        reasoningCancelled: false,
         appendedMessages: [],
         setMessagesCalls: [],
-        liveResponses: [],
     };
     return {
         calls,
@@ -18,32 +18,73 @@ function createMockDeps() {
             let seq = 0;
             return () => `msg-${seq++}`;
         })(),
-        liveResponseUpdater: {
-            push: (text) => calls.liveResponsePushes.push(text),
+        botResponseUpdater: {
+            push: (text) => calls.botResponsePushes.push(text),
             cancel: () => {
-                calls.liveResponseCancelled = true;
+                calls.botResponseCancelled = true;
             },
             flush: () => {
-                calls.liveResponseFlushed = true;
+                calls.botResponseFlushed = true;
             },
         },
         reasoningUpdater: {
             push: (text) => calls.reasoningPushes.push(text),
-            cancel: () => { },
+            cancel: () => {
+                calls.reasoningCancelled = true;
+            },
             flush: () => {
                 calls.reasoningFlushed = true;
             },
         },
         appendMessages: (messages) => calls.appendedMessages.push(messages),
         setMessages: (updater) => calls.setMessagesCalls.push(updater),
-        setLiveResponse: (response) => calls.liveResponses.push(response),
         trimMessages: (messages) => messages,
         annotateCommandMessage: (msg) => ({ ...msg, annotated: true }),
     };
 }
 // =============================================================================
+// findLastSafeBoundary tests
+// =============================================================================
+test('findLastSafeBoundary: splits on paragraph boundary', (t) => {
+    const text = 'Paragraph 1\n\nParagraph 2';
+    t.is(findLastSafeBoundary(text, 0), 13);
+});
+test('findLastSafeBoundary: ignores paragraph boundaries inside code blocks', (t) => {
+    const text = '```javascript\nconst a = 1;\n\nconst b = 2;\n```\nMore text';
+    const expectedBoundary = text.indexOf('```\nMore text') + 4; // after \n```\n
+    t.is(findLastSafeBoundary(text, 0), expectedBoundary);
+});
+test('findLastSafeBoundary: splits at closing code blocks', (t) => {
+    const text = 'Here is code:\n```javascript\ncode\n```\nTail';
+    const expectedBoundary = text.indexOf('```\nTail') + 4;
+    t.is(findLastSafeBoundary(text, 0), expectedBoundary);
+});
+test('findLastSafeBoundary: splits before headings', (t) => {
+    const text = 'Paragraph 1\n# Heading 1';
+    const expectedBoundary = text.indexOf('#'); // Split right before #
+    t.is(findLastSafeBoundary(text, 0), expectedBoundary);
+});
+test('findLastSafeBoundary: splits on thematic breaks', (t) => {
+    const text = 'Paragraph 1\n---\nParagraph 2';
+    const expectedBoundary = text.indexOf('Paragraph 2'); // after \n---\n
+    t.is(findLastSafeBoundary(text, 0), expectedBoundary);
+});
+// =============================================================================
 // text_delta tests
 // =============================================================================
+test('text_delta: avoids splitting inside a code block and splits after it closes', (t) => {
+    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',
+    });
+    t.is(deps.calls.appendedMessages.length, 1);
+    t.is(deps.calls.appendedMessages[0][0].text, 'Here is code:\n```javascript\nconst a = 1;\n\nconst b = 2;\n```\n');
+    t.is(state.accumulatedText, 'Here is code:\n```javascript\nconst a = 1;\n\nconst b = 2;\n```\nTail');
+    t.is(state.flushedTextLength, 'Here is code:\n```javascript\nconst a = 1;\n\nconst b = 2;\n```\n'.length);
+});
 test('text_delta: accumulates text and pushes to live response', (t) => {
     const deps = createMockDeps();
     const state = createStreamingState();
@@ -51,7 +92,104 @@ test('text_delta: accumulates text and pushes to live response', (t) => {
     handler({ type: 'text_delta', delta: 'Hello ' });
     handler({ type: 'text_delta', delta: 'world!' });
     t.is(state.accumulatedText, 'Hello world!');
-    t.deepEqual(deps.calls.liveResponsePushes, ['Hello ', 'Hello world!']);
+    t.deepEqual(deps.calls.botResponsePushes, ['Hello ', 'Hello world!']);
+});
+test('text_delta: finalizes stable paragraphs and streams only the unfinished tail', (t) => {
+    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',
+    });
+    t.is(deps.calls.appendedMessages.length, 1);
+    t.deepEqual(deps.calls.appendedMessages[0], [
+        {
+            id: 'msg-0',
+            sender: 'bot',
+            status: 'finalized',
+            text: 'First paragraph.\n\nSecond paragraph.\n\n',
+        },
+    ]);
+    t.is(state.flushedTextLength, 'First paragraph.\n\nSecond paragraph.\n\n'.length);
+    t.deepEqual(deps.calls.botResponsePushes, ['Current tail']);
+    t.true(deps.calls.botResponseCancelled);
+});
+test('text_delta: does not finalize until a paragraph boundary exists', (t) => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'text_delta', delta: 'Single paragraph still growing' });
+    t.deepEqual(deps.calls.appendedMessages, []);
+    t.is(state.flushedTextLength, 0);
+    t.is(state.accumulatedText, 'Single paragraph still growing');
+    t.deepEqual(deps.calls.botResponsePushes, ['Single paragraph still growing']);
+});
+test('text_delta: finalizes an existing live bot message in place before streaming a new tail', (t) => {
+    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',
+    });
+    t.deepEqual(deps.calls.appendedMessages, []);
+    t.is(deps.calls.setMessagesCalls.length, 1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'active-bot',
+            sender: 'bot',
+            text: 'Old tail',
+        },
+    ]);
+    t.deepEqual(next, [
+        {
+            id: 'active-bot',
+            sender: 'bot',
+            status: 'finalized',
+            text: 'Old tail now complete.\n\n',
+        },
+    ]);
+    t.true(state.currentBotMessageId === null);
+    t.is(state.flushedTextLength, 'Old tail now complete.\n\n'.length);
+    t.deepEqual(deps.calls.botResponsePushes, ['New tail']);
+    t.true(deps.calls.botResponseCancelled);
+});
+test('text_delta: cancels pending live bot update when paragraph boundary leaves no tail', (t) => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    state.currentBotMessageId = 'active-bot';
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'text_delta',
+        delta: 'Finished paragraph.\n\n',
+    });
+    t.is(deps.calls.setMessagesCalls.length, 1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'active-bot',
+            sender: 'bot',
+            status: 'streaming',
+            text: 'Finished paragraph.',
+        },
+    ]);
+    t.deepEqual(next, [
+        {
+            id: 'active-bot',
+            sender: 'bot',
+            status: 'finalized',
+            text: 'Finished paragraph.\n\n',
+        },
+    ]);
+    t.deepEqual(deps.calls.botResponsePushes, []);
+    t.true(deps.calls.botResponseCancelled);
 });
 // =============================================================================
 // reasoning_delta tests
@@ -93,6 +231,106 @@ test('reasoning_delta: ignores empty reasoning', (t) => {
     t.is(state.accumulatedReasoningText, '   ');
     t.deepEqual(deps.calls.reasoningPushes, []);
 });
+test('reasoning_delta: finalizes stable paragraphs and streams only the unfinished tail', (t) => {
+    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',
+    });
+    t.is(deps.calls.appendedMessages.length, 1);
+    t.deepEqual(deps.calls.appendedMessages[0], [
+        {
+            id: 'msg-0',
+            sender: 'reasoning',
+            status: 'finalized',
+            text: 'First paragraph.\n\nSecond paragraph.\n\n',
+        },
+    ]);
+    t.is(state.flushedReasoningLength, 'First paragraph.\n\nSecond paragraph.\n\n'.length);
+    t.is(state.accumulatedReasoningText, 'Current tail');
+    t.deepEqual(deps.calls.reasoningPushes, ['Current tail']);
+});
+test('reasoning_delta: does not finalize until a paragraph boundary exists', (t) => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({
+        type: 'reasoning_delta',
+        delta: 'tail',
+        fullText: 'Single paragraph still growing',
+    });
+    t.deepEqual(deps.calls.appendedMessages, []);
+    t.is(state.flushedReasoningLength, 0);
+    t.is(state.accumulatedReasoningText, 'Single paragraph still growing');
+    t.deepEqual(deps.calls.reasoningPushes, ['Single paragraph still growing']);
+});
+test('reasoning_delta: finalizes an existing live reasoning message in place before streaming a new tail', (t) => {
+    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',
+    });
+    t.deepEqual(deps.calls.appendedMessages, []);
+    t.is(deps.calls.setMessagesCalls.length, 1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            text: 'Old tail',
+        },
+    ]);
+    t.deepEqual(next, [
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            status: 'finalized',
+            text: 'Old tail now complete.\n\n',
+        },
+    ]);
+    t.true(state.currentReasoningMessageId === null);
+    t.is(state.flushedReasoningLength, 'Old tail now complete.\n\n'.length);
+    t.is(state.accumulatedReasoningText, 'New tail');
+    t.deepEqual(deps.calls.reasoningPushes, ['New tail']);
+    t.true(deps.calls.reasoningCancelled);
+});
+test('reasoning_delta: cancels pending live reasoning update when paragraph boundary leaves no tail', (t) => {
+    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',
+    });
+    t.is(deps.calls.setMessagesCalls.length, 1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            text: 'Finished reasoning paragraph.',
+        },
+    ]);
+    t.deepEqual(next, [
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            status: 'finalized',
+            text: 'Finished reasoning paragraph.\n\n',
+        },
+    ]);
+    t.true(deps.calls.reasoningCancelled);
+    t.deepEqual(deps.calls.reasoningPushes, []);
+    t.is(state.accumulatedReasoningText, '');
+    t.true(state.currentReasoningMessageId === null);
+});
 // =============================================================================
 // tool_started tests
 // =============================================================================
@@ -109,10 +347,11 @@ test('tool_started: flushes accumulated text before showing tool', (t) => {
     });
     t.is(state.accumulatedText, '');
     t.is(state.textWasFlushed, true);
-    t.true(deps.calls.liveResponseCancelled);
+    t.true(deps.calls.botResponseCancelled);
     // Should append text message and command message
     t.is(deps.calls.appendedMessages.length, 2);
     t.is(deps.calls.appendedMessages[0][0].sender, 'bot');
+    t.is(deps.calls.appendedMessages[0][0].status, 'finalized');
     t.is(deps.calls.appendedMessages[0][0].text, 'Some text before tool');
 });
 test('tool_started: flushes accumulated reasoning before showing tool', (t) => {
@@ -129,7 +368,63 @@ test('tool_started: flushes accumulated reasoning before showing tool', (t) => {
     t.true(deps.calls.reasoningFlushed);
     t.is(state.accumulatedReasoningText, '');
     t.is(state.flushedReasoningLength, 14); // 'Some reasoning'.length
-    t.is(state.currentReasoningMessageId, null);
+    t.true(state.currentReasoningMessageId === null);
+});
+test('tool_started: finalizes live reasoning text before clearing it', (t) => {
+    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' },
+    });
+    t.true(deps.calls.reasoningFlushed);
+    t.is(deps.calls.setMessagesCalls.length, 1);
+    const next = deps.calls.setMessagesCalls[0]([
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            text: 'Reasoning before the tool',
+        },
+    ]);
+    t.deepEqual(next, [
+        {
+            id: 'active-reasoning',
+            sender: 'reasoning',
+            status: 'finalized',
+            text: 'Reasoning before the tool',
+        },
+    ]);
+    t.is(state.accumulatedReasoningText, '');
+    t.is(state.flushedReasoningLength, 'Reasoning before the tool'.length);
+    t.true(state.currentReasoningMessageId === null);
+});
+test('reasoning_delta: does not drop prefix when reasoning restarts after a tool', (t) => {
+    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',
+    });
+    t.is(state.accumulatedReasoningText, 'After tool reasoning');
+    t.deepEqual(deps.calls.reasoningPushes, ['Before tool', 'After tool reasoning']);
 });
 test('tool_started: creates pending command message with shell command', (t) => {
     const deps = createMockDeps();
@@ -264,9 +559,118 @@ test('command_message: flushes accumulated text before adding', (t) => {
     t.is(state.accumulatedText, '');
     t.is(state.textWasFlushed, true);
     t.is(deps.calls.appendedMessages.length, 1);
+    t.is(deps.calls.appendedMessages[0][0].status, 'finalized');
     t.is(deps.calls.appendedMessages[0][0].text, 'Partial response');
 });
 // =============================================================================
+// subagent activity tests
+// =============================================================================
+test('subagent events: maintains a live peek with the last three tools', (t) => {
+    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',
+    });
+    t.deepEqual(deps.calls.appendedMessages[0], [
+        {
+            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_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'find_files',
+        commandMessages: [{ id: 'find', sender: 'command', status: 'running', command: 'find_files "*.ts"', output: '' }],
+    });
+    handler({
+        type: 'subagent_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'grep',
+        commandMessages: [
+            { id: 'grep', sender: 'command', status: 'running', command: 'grep "needle" "source"', output: '' },
+        ],
+    });
+    handler({
+        type: 'subagent_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'read_file',
+        commandMessages: [
+            { id: 'read', sender: 'command', status: 'running', command: 'read_file "source/app.tsx"', output: '' },
+        ],
+    });
+    handler({
+        type: 'subagent_tool_started',
+        agentId: 'agent-1',
+        role: 'explorer',
+        toolName: 'read_code_outline',
+        commandMessages: [
+            {
+                id: 'outline',
+                sender: 'command',
+                status: 'running',
+                command: 'read_code_outline "source/app.tsx"',
+                output: '',
+            },
+        ],
+    });
+    let messages = deps.calls.appendedMessages[0];
+    for (const update of deps.calls.setMessagesCalls) {
+        messages = update(messages);
+    }
+    t.deepEqual(messages, [
+        {
+            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"', 'read_file "source/app.tsx"', 'read_code_outline "source/app.tsx"'],
+        },
+    ]);
+});
+test('subagent_completed removes the live peek', (t) => {
+    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'],
+        },
+    ]);
+    t.deepEqual(result, []);
+});
+// =============================================================================
 // retry tests
 // =============================================================================
 test('retry: adds system message about hallucination retry', (t) => {
@@ -288,6 +692,73 @@ test('retry: adds system message about hallucination retry', (t) => {
     t.true(result[0].text.includes('shell'));
     t.true(result[0].text.includes('1/2'));
 });
+test('retry: adds system message about flex service tier fallback', (t) => {
+    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([]);
+    t.is(result.length, 1);
+    t.is(result[0].sender, 'system');
+    t.true(result[0].text.includes('Flex service tier timed out'));
+    t.true(result[0].text.includes('standard service tier'));
+});
+// =============================================================================
+// final event tests
+// =============================================================================
+test('final: finalizes trailing reasoning message that was never followed by a tool call', (t) => {
+    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: '' });
+    t.true(deps.calls.reasoningFlushed);
+    t.is(state.accumulatedReasoningText, '');
+    t.true(state.currentReasoningMessageId === null);
+    // markCurrentReasoningFinalized sets status via setMessages
+    t.is(deps.calls.setMessagesCalls.length, 1);
+    const next = deps.calls.setMessagesCalls[0]([
+        { id: 'active-reasoning', sender: 'reasoning', text: 'Trailing reasoning with no tool call' },
+    ]);
+    t.deepEqual(next, [
+        { id: 'active-reasoning', sender: 'reasoning', status: 'finalized', text: 'Trailing reasoning with no tool call' },
+    ]);
+});
+test('final: appends missing final text after already flushed streamed text', (t) => {
+    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' });
+    t.is(state.accumulatedText, 'Intro\n\n## Missing Header\n\nBody');
+    t.is(deps.calls.appendedMessages.length, 2);
+    t.deepEqual(deps.calls.appendedMessages[1], [
+        {
+            id: 'msg-1',
+            sender: 'bot',
+            status: 'finalized',
+            text: '## Missing Header\n\nBody',
+        },
+    ]);
+});
+test('final: is a no-op when there is no pending reasoning', (t) => {
+    const deps = createMockDeps();
+    const state = createStreamingState();
+    const handler = createConversationEventHandler(deps, state);
+    handler({ type: 'final', finalText: '' });
+    t.false(deps.calls.reasoningFlushed);
+    t.is(deps.calls.setMessagesCalls.length, 0);
+    t.is(deps.calls.appendedMessages.length, 0);
+});
 // =============================================================================
 // unknown event tests
 // =============================================================================
@@ -300,4 +771,95 @@ test('unknown event: is ignored without error', (t) => {
     t.is(deps.calls.appendedMessages.length, 0);
     t.is(deps.calls.setMessagesCalls.length, 0);
 });
+// =============================================================================
+// Bug: final event silently ignores corrections when finalText.length <= accumulatedText.length
+// =============================================================================
+test('final: ignores corrected finalText when it is the same length as accumulated streamed text', (t) => {
+    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.
+    t.is(deps.calls.appendedMessages.length, 1);
+    const flushedMsg = deps.calls.appendedMessages[0][0];
+    // Fails: actual is 'Hello wrold' (the typo) — correction from finalText is silently lost
+    t.is(flushedMsg.text, 'Hello world');
+});
+test('final: flushes over-accumulated streamed content when finalText is shorter than accumulated', (t) => {
+    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.
+    t.is(deps.calls.appendedMessages.length, 1);
+    const flushedMsg = deps.calls.appendedMessages[0][0];
+    // Fails: actual is the full over-accumulated string including ' Extra hallucinated sentence.'
+    t.is(flushedMsg.text, 'The answer is 42.');
+});
+// =============================================================================
+// Bug: whitespace-only content before a paragraph boundary is permanently dropped
+// =============================================================================
+test('text_delta: whitespace-only content before first paragraph boundary is silently dropped', (t) => {
+    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' });
+    // flushedTextLength is NOT advanced — whitespace content is kept in the unflushed window
+    t.is(state.flushedTextLength, 0);
+    t.is(deps.calls.appendedMessages.length, 0);
+    // The live updater only received 'Actual content' — the leading spaces are gone
+    t.deepEqual(deps.calls.botResponsePushes, ['Actual content']);
+    // After final, only 'Actual content' is written; the three leading spaces are permanently lost
+    handler({ type: 'final', finalText: '   \n\nActual content' });
+    t.is(deps.calls.appendedMessages.length, 1);
+    // Fails: actual is 'Actual content' — '   ' is not recoverable
+    t.is(deps.calls.appendedMessages[0][0].text, '   \n\nActual content');
+});
+// =============================================================================
+// Bug: command_message without callId leaves the running message stranded
+// =============================================================================
+test('command_message: leaves stale running message when no callId is present on either side', (t) => {
+    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];
+    t.is(runningMsg.status, 'running');
+    t.is(runningMsg.callId, 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
+    t.is(result.length, 1);
+    t.is(result[0].status, 'completed');
+});
 //# sourceMappingURL=conversation-event-handler.test.js.map