feat(web-shell): run read-only info commands immediately mid-turn

packages/sdk-typescript/src/daemon/ui/transcript.ts

@@ -341,6 +341,10 @@ function applyDaemonTranscriptEvent(
       break;
     case 'status':
     case 'debug':
+      appendStatusBlock(next, event.type, event.text, event, {
+        clearActiveText: event.clearActiveText,
+      });
+      break;
     case 'error':
       appendStatusBlock(next, event.type, event.text, event);
       break;
@@ -1256,6 +1260,10 @@ function appendStatusBlock(
   };
   appendBlock(state, block);
   if (opts.clearActiveText !== false) clearActiveText(state);
+  // Opt-out only protects the streaming assistant/thought block; the user
+  // pointer must still reset, otherwise a later mergeable user.text.delta
+  // (e.g. a peer client's prompt echo) appends onto the command echo block.
+  else state.activeUserBlockId = undefined;
 }
 
 function appendPromptCancelledBlock(

packages/sdk-typescript/src/daemon/ui/types.ts

@@ -278,6 +278,13 @@ export interface DaemonUiStatusEvent extends DaemonUiEventBase {
   text: string;
   source?: string;
   data?: unknown;
+  /**
+   * Client-dispatch opt-out: `false` inserts the status block without
+   * finalizing the active assistant/thought block, so read-only command
+   * output dispatched mid-turn does not split a streaming answer or orphan
+   * its usage frames. Daemon-emitted events leave this unset.
+   */
+  clearActiveText?: boolean;
 }
 
 export interface DaemonUiErrorEvent extends DaemonUiEventBase {

packages/sdk-typescript/test/daemon-ui-transcript.test.ts

@@ -38,3 +38,115 @@ describe('daemon transcript rewind', () => {
     expect(state.activeAssistantBlockId).toBeUndefined();
   });
 });
+
+describe('status event while an assistant block is streaming', () => {
+  it('finalizes the active assistant block by default', () => {
+    const state = reduceDaemonTranscriptEvents(
+      createDaemonTranscriptState({ now: 1 }),
+      [
+        { type: 'user.text.delta', text: 'question' },
+        { type: 'assistant.text.delta', text: 'answering' },
+        { type: 'status', text: 'mid-stream status' },
+        { type: 'assistant.text.delta', text: ' more' },
+        { type: 'assistant.done' },
+      ],
+      { now: 1 },
+    );
+
+    expect(state.blocks.map((block) => block.kind)).toEqual([
+      'user',
+      'assistant',
+      'status',
+      'assistant',
+    ]);
+  });
+
+  it('keeps the assistant block active when clearActiveText is false', () => {
+    const state = reduceDaemonTranscriptEvents(
+      createDaemonTranscriptState({ now: 1 }),
+      [
+        { type: 'user.text.delta', text: 'question' },
+        { type: 'assistant.text.delta', text: 'answering' },
+        { type: 'status', text: 'mid-stream status', clearActiveText: false },
+        { type: 'assistant.text.delta', text: ' more' },
+        {
+          type: 'assistant.usage',
+          usage: { inputTokens: 3, outputTokens: 5 },
+        },
+        { type: 'assistant.done' },
+      ],
+      { now: 1 },
+    );
+
+    expect(state.blocks.map((block) => block.kind)).toEqual([
+      'user',
+      'assistant',
+      'status',
+    ]);
+    const assistant = state.blocks[1];
+    if (assistant.kind !== 'assistant') throw new Error('expected assistant');
+    expect(assistant.text).toBe('answering more');
+    expect(assistant.usage).toEqual({
+      inputTokens: 3,
+      outputTokens: 5,
+      cachedTokens: 0,
+    });
+  });
+
+  it('resets the active user block even when clearActiveText is false', () => {
+    let state = reduceDaemonTranscriptEvents(
+      createDaemonTranscriptState({ now: 1 }),
+      [{ type: 'user.text.delta', text: '/stats' }],
+      { now: 1 },
+    );
+    state = reduceDaemonTranscriptEvents(
+      state,
+      [{ type: 'status', text: 'stats output', clearActiveText: false }],
+      { now: 1 },
+    );
+
+    expect(state.activeUserBlockId).toBeUndefined();
+
+    // A peer client's prompt echo must open its own user block instead of
+    // merging into the local command echo.
+    state = reduceDaemonTranscriptEvents(
+      state,
+      [{ type: 'user.text.delta', text: 'fix the bug' }],
+      { now: 1 },
+    );
+
+    expect(state.blocks.map((block) => block.kind)).toEqual([
+      'user',
+      'status',
+      'user',
+    ]);
+    expect(
+      state.blocks.map((block) => ('text' in block ? block.text : '')),
+    ).toEqual(['/stats', 'stats output', 'fix the bug']);
+  });
+});
+
+describe('status event while a thought block is streaming', () => {
+  it('keeps the thought block active when clearActiveText is false', () => {
+    const state = reduceDaemonTranscriptEvents(
+      createDaemonTranscriptState({ now: 1 }),
+      [
+        { type: 'user.text.delta', text: 'question' },
+        { type: 'thought.text.delta', text: 'thinking' },
+        { type: 'status', text: 'mid-stream status', clearActiveText: false },
+        { type: 'thought.text.delta', text: ' more' },
+        { type: 'assistant.done' },
+      ],
+      { now: 1 },
+    );
+
+    expect(state.blocks.map((block) => block.kind)).toEqual([
+      'user',
+      'thought',
+      'status',
+    ]);
+    const thought = state.blocks[1];
+    if (thought.kind !== 'thought') throw new Error('expected thought');
+    expect(thought.text).toBe('thinking more');
+  });
+});