fix(chat): place mid-turn messages where claude read them

A queued bubble was appended where the user hit enter — mid-stream of
whatever claude was already saying — and stayed there, so the
conversation read as if the interjection came before content it was
actually sent after.

Two halves:

* Live: the requesting boundary now moves formerly-queued entries to
  the tail as it clears isQueued. Relative order among several queued
  entries is kept, and when they're already last the array comes out
  identical, so nothing visibly moves in the common case.

* Reload: claude records a mid-turn interjection as a queued_command
  attachment rather than a user record, positioned at the drain
  boundary. parseTranscriptEntries skipped all attachments, so every
  message sent while the agent was working vanished from the
  scrollback on reload. Seed those as user entries; other attachment
  subtypes stay ignored.

Verified against a live session: the seeded record lands between the
tool_result it interrupted and the reply that answers it, matching the
live ordering.

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

Author: frenchie4111

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

@@ -260,3 +260,109 @@ describe('JsonClaudeManager.forkAt', () => {
     expect(result.reason).toMatch(/assistant/)
   })
 })
+
+// Claude records a mid-turn interjection as a 'queued_command'
+// attachment rather than a `user` record, positioned at the agent-loop
+// boundary where it drained the input queue. Skipping attachments (as
+// the parser did) meant every message the user sent while the agent was
+// working vanished from the scrollback on reload.
+describe('JsonClaudeManager.seedFromTranscript — mid-turn messages', () => {
+  beforeEach(() => {
+    tmpHome = mkdtempSync(join(tmpdir(), 'harness-seed-'))
+  })
+
+  afterEach(() => {
+    rmSync(tmpHome, { recursive: true, force: true })
+    vi.clearAllMocks()
+  })
+
+  function writeTranscript(sessionId: string, worktree: string, lines: object[]): void {
+    const dir = transcriptDir(worktree)
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(
+      join(dir, `${sessionId}.jsonl`),
+      lines.map((l) => JSON.stringify(l)).join('\n') + '\n',
+      'utf8'
+    )
+  }
+
+  it('seeds a queued_command attachment as a user entry at its transcript position', () => {
+    const store = new Store()
+    const mgr = makeManager(store)
+    const sessionId = '55555555-5555-5555-5555-555555555555'
+    const worktree = '/tmp/wt-seed-queued'
+
+    writeTranscript(sessionId, worktree, [
+      { type: 'user', sessionId, message: { content: 'first turn' } },
+      {
+        type: 'assistant',
+        sessionId,
+        message: { id: 'msg_a', content: [{ type: 'tool_use', id: 'tu1', name: 'Bash' }] }
+      },
+      // The interjection lands here — after the tool call it interrupted,
+      // before the reply that took it into account.
+      {
+        type: 'attachment',
+        sessionId,
+        attachment: {
+          type: 'queued_command',
+          prompt: 'actually, also check the logs',
+          commandMode: 'prompt'
+        }
+      },
+      {
+        type: 'assistant',
+        sessionId,
+        message: { id: 'msg_b', content: [{ type: 'text', text: 'on it' }] }
+      }
+    ])
+    store.dispatch({
+      type: 'jsonClaude/sessionStarted',
+      payload: { sessionId, worktreePath: worktree }
+    })
+
+    mgr.seedFromTranscript(sessionId, worktree)
+
+    const entries = store.getSnapshot().state.jsonClaude.sessions[sessionId].entries
+    expect(entries.map((e) => e.kind)).toEqual([
+      'user',
+      'assistant',
+      'user',
+      'assistant'
+    ])
+    expect(entries[2].text).toBe('actually, also check the logs')
+    expect(entries[2].isQueued).toBeUndefined()
+  })
+
+  it('ignores bookkeeping attachments and prompt-less queued_commands', () => {
+    const store = new Store()
+    const mgr = makeManager(store)
+    const sessionId = '66666666-6666-6666-6666-666666666666'
+    const worktree = '/tmp/wt-seed-attachments'
+
+    writeTranscript(sessionId, worktree, [
+      { type: 'user', sessionId, message: { content: 'hello' } },
+      {
+        type: 'attachment',
+        sessionId,
+        attachment: { type: 'total_tokens_reminder', text: '<total_tokens>1</total_tokens>' }
+      },
+      {
+        type: 'attachment',
+        sessionId,
+        attachment: { type: 'deferred_tools_delta', addedNames: ['WebFetch'] }
+      },
+      { type: 'attachment', sessionId, attachment: { type: 'queued_command', prompt: '' } }
+    ])
+    store.dispatch({
+      type: 'jsonClaude/sessionStarted',
+      payload: { sessionId, worktreePath: worktree }
+    })
+
+    mgr.seedFromTranscript(sessionId, worktree)
+
+    const entries = store.getSnapshot().state.jsonClaude.sessions[sessionId].entries
+    expect(entries).toHaveLength(1)
+    expect(entries[0].text).toBe('hello')
+  })
+})

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

@@ -364,6 +364,44 @@ describe('JsonClaudeManager', () => {
       expect(store.getSnapshot().state.jsonClaude.sessions[sessionId]?.busy).toBe(true)
     })
 
+    it('repositions the message after the content it interrupted', () => {
+      const store = new Store()
+      const sessionId = 'sess-queued-reorder'
+      const { mgr, proc } = startBusySession(store, sessionId)
+
+      // The user interjects while claude is mid-stream, so the bubble is
+      // appended ahead of the assistant message that was already in
+      // flight — then claude finishes it.
+      mgr.send(sessionId, 'interjection')
+      proc.stdout.emit(
+        'data',
+        Buffer.from(
+          JSON.stringify({
+            type: 'assistant',
+            message: { id: 'msg_a', content: [{ type: 'text', text: 'still talking' }] }
+          }) + '\n'
+        )
+      )
+      // Assistant entries carry `blocks`, user entries carry `text`.
+      const order = (): Array<string | undefined> =>
+        (store.getSnapshot().state.jsonClaude.sessions[sessionId]?.entries ?? []).map(
+          (e) =>
+            e.kind === 'user'
+              ? e.text
+              : e.blocks?.map((b) => ('text' in b ? b.text : '')).join('')
+        )
+      expect(order()).toEqual(['first turn', 'interjection', 'still talking'])
+
+      proc.stdout.emit(
+        'data',
+        Buffer.from(
+          JSON.stringify({ type: 'system', subtype: 'status', status: 'requesting' }) +
+            '\n'
+        )
+      )
+      expect(order()).toEqual(['first turn', 'still talking', 'interjection'])
+    })
+
     it('leaves a message queued while a non-requesting status streams by', () => {
       const store = new Store()
       const sessionId = 'sess-queued-other-status'

src/main/json-claude-manager.ts

@@ -504,6 +504,32 @@ export class JsonClaudeManager {
           ...(apiMessageId ? { apiMessageId } : {}),
           ...(parentToolUseId ? { parentToolUseId } : {})
         })
+      } else if (type === 'attachment') {
+        // Mid-turn interjections are the one kind of user input claude
+        // does NOT write as a `user` record: they land as an attachment
+        // of type 'queued_command', positioned at the agent-loop
+        // boundary where claude drained them (its `timestamp` field is
+        // still the moment the user hit enter). Without this branch a
+        // reload silently dropped every message the user sent while the
+        // agent was working. Every other attachment subtype is internal
+        // bookkeeping (token reminders, tool/agent listing deltas) and
+        // stays ignored.
+        const attachment = parsed['attachment'] as
+          | { type?: unknown; prompt?: unknown }
+          | undefined
+        if (attachment?.type !== 'queued_command') continue
+        const prompt = attachment.prompt
+        if (typeof prompt !== 'string' || prompt.length === 0) continue
+        const automated = parseAutomatedMessage(prompt)
+        seededEntries.push({
+          kind: 'user',
+          text: automated ? automated.body : prompt,
+          timestamp: Date.now(),
+          entryId: `${sessionId}-seed-u-${counter++}`,
+          ...(automated ? { automation: automated.source } : {}),
+          ...(automated?.from ? { automationFrom: automated.from } : {}),
+          ...(transcriptUuid ? { transcriptUuid } : {})
+        })
       } else if (type === 'system' && parsed['subtype'] === 'compact_boundary') {
         const meta = parsed['compactMetadata'] as
           | { trigger?: unknown; preTokens?: unknown; postTokens?: unknown }
@@ -833,17 +859,19 @@ export class JsonClaudeManager {
     const inst = this.instances.get(sessionId)
     if (!inst) return
     // Mid-turn injection: if a turn is already in flight, append the
-    // user entry inline (so it lands in conversation order between
-    // whatever assistant content was streaming and whatever comes
-    // next) tagged isQueued, and write to stdin immediately. Claude's
-    // stream-json input buffers between agent-loop steps, so the
-    // message gets injected at the next safe boundary (typically
+    // user entry tagged isQueued (so the user sees their message land,
+    // with a cancel affordance) and write to stdin immediately.
+    // Claude's 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. 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.
+    // interject-while-busy behavior.
+    //
+    // The entry starts out wherever the user hit enter, which is
+    // mid-stream of whatever claude was already saying. When claude
+    // drains its input queue into the next request (the `system/status:
+    // requesting` branch in handleLine) the entry both loses isQueued
+    // and moves to the tail — its real position in the conversation,
+    // just before the response that considers it.
     const session =
       this.store.getSnapshot().state.jsonClaude.sessions[sessionId]
     if (session?.busy) {
@@ -980,9 +1008,10 @@ export class JsonClaudeManager {
    *  message text is already in claude's stdin buffer by the time the
    *  user clicks cancel, so this is UI-only — claude will still
    *  process the message on the next agent-loop step. The promoted
-   *  entry never gets re-added because we only clear isQueued (we
-   *  don't re-create an entry). On reload, however, claude's
-   *  session.jsonl will reseed the message. */
+   *  entry never gets re-added because unqueuing only touches entries
+   *  still in the list. On reload, however, the message comes back:
+   *  claude logged it to session.jsonl as a queued_command attachment,
+   *  which parseTranscriptEntries seeds. */
   cancelQueued(sessionId: string, entryId: string): void {
     this.store.dispatch({
       type: 'jsonClaude/entryRemoved',

src/shared/state/json-claude.test.ts

@@ -754,6 +754,73 @@ describe('jsonClaudeReducer', () => {
     expect(after[1].isQueued).toBeUndefined()
   })
 
+  it('userEntriesUnqueued moves queued entries to the tail, in order', () => {
+    let state = seedSession(initialJsonClaude)
+    state = jsonClaudeReducer(state, {
+      type: 'jsonClaude/entriesSeeded',
+      payload: {
+        sessionId: SID,
+        entries: [
+          { entryId: 'u0', kind: 'user', text: 'first turn', timestamp: 1 },
+          // Two interjections typed mid-stream, so they landed in the
+          // array before the assistant content claude was already
+          // producing when the user hit enter.
+          {
+            entryId: 'q1',
+            kind: 'user',
+            text: 'queued one',
+            timestamp: 2,
+            isQueued: true
+          },
+          {
+            entryId: 'q2',
+            kind: 'user',
+            text: 'queued two',
+            timestamp: 3,
+            isQueued: true
+          },
+          { entryId: 'a1', kind: 'assistant', text: 'streamed', timestamp: 4 }
+        ]
+      }
+    })
+    state = jsonClaudeReducer(state, {
+      type: 'jsonClaude/userEntriesUnqueued',
+      payload: { sessionId: SID }
+    })
+    expect(state.sessions[SID].entries.map((e) => e.entryId)).toEqual([
+      'u0',
+      'a1',
+      'q1',
+      'q2'
+    ])
+    expect(state.sessions[SID].entries.every((e) => !e.isQueued)).toBe(true)
+  })
+
+  it('userEntriesUnqueued leaves order alone when queued entries are already last', () => {
+    let state = seedSession(initialJsonClaude)
+    state = jsonClaudeReducer(state, {
+      type: 'jsonClaude/entriesSeeded',
+      payload: {
+        sessionId: SID,
+        entries: [
+          { entryId: 'a1', kind: 'assistant', text: 'done', timestamp: 1 },
+          {
+            entryId: 'q1',
+            kind: 'user',
+            text: 'queued',
+            timestamp: 2,
+            isQueued: true
+          }
+        ]
+      }
+    })
+    state = jsonClaudeReducer(state, {
+      type: 'jsonClaude/userEntriesUnqueued',
+      payload: { sessionId: SID }
+    })
+    expect(state.sessions[SID].entries.map((e) => e.entryId)).toEqual(['a1', 'q1'])
+  })
+
   it('entryRemoved drops the matching entry by id', () => {
     let state = seedSession(initialJsonClaude)
     state = jsonClaudeReducer(state, {

src/shared/state/json-claude.ts

@@ -214,7 +214,10 @@ export interface JsonClaudeChatEntry {
    *  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. */
+   *  enters the conversation — not at the end of the whole turn.
+   *  That same boundary moves the entry to the end of the list, since
+   *  it was appended where the user hit enter rather than where claude
+   *  read it. */
   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
@@ -992,12 +995,26 @@ export function jsonClaudeReducer(
       const session = state.sessions[event.payload.sessionId]
       if (!session) return state
       if (!session.entries.some((e) => e.isQueued)) return state
-      const nextEntries = session.entries.map((entry) => {
-        if (!entry.isQueued) return entry
+      // Queued entries were appended where the user hit enter, which is
+      // mid-stream of whatever claude was already saying. Claude doesn't
+      // read them until the agent-loop boundary this event marks, so
+      // move them to the tail — the position they actually occupy in the
+      // conversation, directly before the response that considers them.
+      // Relative order among several queued entries is preserved, and
+      // when they're already at the tail (nothing streamed in between)
+      // the array comes out identical, so no bubble visibly moves.
+      const kept: JsonClaudeChatEntry[] = []
+      const promoted: JsonClaudeChatEntry[] = []
+      for (const entry of session.entries) {
+        if (!entry.isQueued) {
+          kept.push(entry)
+          continue
+        }
         const { isQueued: _drop, ...rest } = entry
         void _drop
-        return rest
-      })
+        promoted.push(rest)
+      }
+      const nextEntries = [...kept, ...promoted]
       return {
         ...state,
         sessions: {