fix(chat): unqueue mid-turn messages when claude picks them up

Mid-turn interjections kept their dashed "queued" bubble until the
whole turn ended, even though claude ingests them at the next
agent-loop step — often minutes earlier, and visibly so when the reply
already referenced the queued message.

Claude drains its pending-input queue immediately before building the
next API request and emits {system, subtype: status, status:
requesting} at that moment. Verified against a session transcript:
the `queue-operation: remove` record lands ~1ms before that event. So
unqueue there instead of waiting for `result`, which stays as the
backstop for messages that land after the final request.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: frenchie4111

src/main/json-claude-manager.test.ts

@@ -304,6 +304,93 @@ describe('JsonClaudeManager', () => {
     expect(cmd).not.toContain('--name')
   })
 
+  // Mid-turn messages used to stay dashed/"queued" until the whole turn
+  // ended, even though claude picks them up at the next agent-loop step.
+  // Claude drains its input queue right before building the next API
+  // request and emits {system, status: 'requesting'} at that moment — so
+  // that event, not `result`, is when the bubble should go solid.
+  describe('mid-turn queued messages', () => {
+    function startBusySession(store: Store, sessionId: string) {
+      const mgr = makeManager(store)
+      const cwd = '/tmp/wt'
+      store.dispatch({
+        type: 'jsonClaude/sessionStarted',
+        payload: { sessionId, worktreePath: cwd }
+      })
+      mgr.create(sessionId, cwd)
+      mgr.send(sessionId, 'first turn')
+      return { mgr, proc: sessionProcs()[0] }
+    }
+
+    const queuedCount = (store: Store, sessionId: string) =>
+      (store.getSnapshot().state.jsonClaude.sessions[sessionId]?.entries ?? []).filter(
+        (e) => e.isQueued
+      ).length
+
+    it("clears isQueued on the next 'requesting' status, before the turn ends", () => {
+      const store = new Store()
+      const sessionId = 'sess-queued-requesting'
+      const { mgr, proc } = startBusySession(store, sessionId)
+
+      mgr.send(sessionId, 'interjection')
+      expect(queuedCount(store, sessionId)).toBe(1)
+
+      // A tool result mid-turn doesn't mean the message was picked up.
+      proc.stdout.emit(
+        'data',
+        Buffer.from(
+          JSON.stringify({
+            type: 'user',
+            message: {
+              role: 'user',
+              content: [
+                { type: 'tool_result', tool_use_id: 'toolu_1', content: 'ok' }
+              ]
+            }
+          }) + '\n'
+        )
+      )
+      expect(queuedCount(store, sessionId)).toBe(1)
+
+      proc.stdout.emit(
+        'data',
+        Buffer.from(
+          JSON.stringify({ type: 'system', subtype: 'status', status: 'requesting' }) +
+            '\n'
+        )
+      )
+      expect(queuedCount(store, sessionId)).toBe(0)
+      // Still mid-turn: busy stays true, the bubble just isn't queued.
+      expect(store.getSnapshot().state.jsonClaude.sessions[sessionId]?.busy).toBe(true)
+    })
+
+    it('leaves a message queued while a non-requesting status streams by', () => {
+      const store = new Store()
+      const sessionId = 'sess-queued-other-status'
+      const { mgr, proc } = startBusySession(store, sessionId)
+      mgr.send(sessionId, 'interjection')
+
+      proc.stdout.emit(
+        'data',
+        Buffer.from(
+          JSON.stringify({ type: 'system', subtype: 'status', status: 'compacting' }) +
+            '\n'
+        )
+      )
+      expect(queuedCount(store, sessionId)).toBe(1)
+    })
+
+    it('still unqueues on result for messages that land after the last request', () => {
+      const store = new Store()
+      const sessionId = 'sess-queued-result'
+      const { mgr, proc } = startBusySession(store, sessionId)
+      mgr.send(sessionId, 'interjection')
+
+      proc.stdout.emit('data', Buffer.from(JSON.stringify({ type: 'result' }) + '\n'))
+      expect(queuedCount(store, sessionId)).toBe(0)
+    })
+  })
+
   it('rate_limit_event over threshold emits one warning card; back-to-back duplicates dedup', () => {
     const store = new Store()
     const mgr = makeManager(store)

src/main/json-claude-manager.ts

@@ -839,8 +839,11 @@ export class JsonClaudeManager {
     // stream-json input buffers between agent-loop steps, so the
     // message gets injected at the next safe boundary (typically
     // post-tool_result) within the current turn — matching the TUI's
-    // interject-while-busy behavior. On `result` we clear the
-    // isQueued flag so the bubble loses its dashed/queued styling.
+    // interject-while-busy behavior. The isQueued flag clears when
+    // claude drains its input queue into the next request (see the
+    // `system/status: requesting` branch in handleLine), so the bubble
+    // stops looking dashed the moment the message is really in the
+    // conversation rather than at the end of the turn.
     const session =
       this.store.getSnapshot().state.jsonClaude.sessions[sessionId]
     if (session?.busy) {
@@ -959,6 +962,20 @@ export class JsonClaudeManager {
     }
   }
 
+  /** Clear the dashed/queued styling on every in-flight queued entry of
+   *  a session. Guarded on there actually being one: the reducer no-ops
+   *  when nothing is queued, but the dispatch would still fan out an
+   *  IPC broadcast to every renderer, and the caller on the hot path
+   *  (`system/status: requesting`) fires on every API request. */
+  private unqueueUserEntries(sessionId: string): void {
+    const session = this.store.getSnapshot().state.jsonClaude.sessions[sessionId]
+    if (!session?.entries.some((e) => e.isQueued)) return
+    this.store.dispatch({
+      type: 'jsonClaude/userEntriesUnqueued',
+      payload: { sessionId }
+    })
+  }
+
   /** Remove a queued user entry from the renderer view. NOTE: the
    *  message text is already in claude's stdin buffer by the time the
    *  user clicks cancel, so this is UI-only — claude will still
@@ -1006,10 +1023,7 @@ export class JsonClaudeManager {
     // so claude will still process them on the next agent-loop pass
     // unless the interrupt itself drains the buffer (TBD — observe
     // behavior in test).
-    this.store.dispatch({
-      type: 'jsonClaude/userEntriesUnqueued',
-      payload: { sessionId }
-    })
+    this.unqueueUserEntries(sessionId)
     // Flip busy off optimistically; the result event (when the abort
     // resolves into a turn boundary) will also clear it.
     this.dispatchBusy(sessionId, false)
@@ -1555,6 +1569,20 @@ export class JsonClaudeManager {
       }
       return
     }
+    if (type === 'system' && subtype === 'status' && parsed['status'] === 'requesting') {
+      // Claude drains its pending-input queue immediately before it
+      // builds the next API request, then emits this status. So this is
+      // the earliest point at which a mid-turn message we injected is
+      // genuinely part of the conversation — verified against the
+      // session transcript, where the `queue-operation: remove` record
+      // lands ~1ms before this event. Unqueue here rather than waiting
+      // for `result`, which only fires at the end of the whole turn and
+      // left the bubble dashed for minutes while claude was already
+      // acting on it. The `result` handler keeps its own unqueue as the
+      // backstop for messages that land after the last request.
+      this.unqueueUserEntries(instance.sessionId)
+      return
+    }
     if (type === 'system' && subtype === 'init') {
       // Session id is already known (we pinned it via --session-id), but
       // the init payload includes the canonical slash_commands list — keep
@@ -1665,10 +1693,7 @@ export class JsonClaudeManager {
     }
     if (type === 'result') {
       this.dispatchBusy(instance.sessionId, false)
-      this.store.dispatch({
-        type: 'jsonClaude/userEntriesUnqueued',
-        payload: { sessionId: instance.sessionId }
-      })
+      this.unqueueUserEntries(instance.sessionId)
       const authMessage = detectAuthFailureFromResult(parsed)
       if (
         parsed['is_error'] === true ||

src/shared/state/json-claude.ts

@@ -209,10 +209,12 @@ export interface JsonClaudeChatEntry {
    *  blinking cursor at the end of the text. */
   isPartial?: boolean
   /** True for a user entry that was typed while busy=true and has
-   *  been written to stdin but not yet resolved by claude (i.e.,
-   *  no `result` boundary has fired since it was queued). The
+   *  been written to stdin but claude hasn't picked it up yet. The
    *  renderer styles these as dashed/muted "queued" bubbles with
-   *  a cancel affordance. Cleared on the next `result`. */
+   *  a cancel affordance. Cleared as soon as claude drains its
+   *  input queue into the next API request (the `system/status:
+   *  requesting` boundary), which is when the message genuinely
+   *  enters the conversation — not at the end of the whole turn. */
   isQueued?: boolean
   /** For kind === 'user'. Set when Ness injected the turn itself rather
    *  than the human typing it, so the renderer can style the bubble as an