[FEATURE] Compose-while-working with send-time choice of interrupt vs queue (Codex-style)

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Today, interactive mode has two input states during an active turn:

1. Type into the box — the message is queued and submits when the current turn finishes. There is no way to interrupt.
2. Press Esc first — cancels the running turn immediately, then you can type a redirect.

There is no flow where the user can: (a) notice the agent going wrong mid-turn, (b) compose a careful redirect while the agent keeps working, and (c) at send time choose whether to interrupt-and-redirect or queue.

The current Esc-first path forces commitment to interrupting before the user has finished thinking through the redirect. That creates time pressure to compose quickly, or it pauses the agent prematurely just to draft a message that might end up being \"actually, keep going.\" There is no clean \"I see something going wrong but I'm not yet sure I want to interrupt\" state.

This matters most for non-trivial redirects — multi-line corrections, careful wording, paste-in of a stack trace or doc snippet — where composition time is real and the user wants to think while the agent works.

Proposed Solution

Allow composing input during an active turn without auto-interrupting (this is already the default). At send time, expose two distinct send actions:

• Enter → queue (current default — submit after the turn ends)
• Shift+Enter (or some other modifier) → interrupt + submit as redirect (equivalent to Esc then submit, but as a single keystroke once the message is already written)

A persistent UI cue near the input box, e.g.: \"Enter to queue · Shift+Enter to break in.\"

This is purely additive: Enter still queues, Esc still hard-interrupts. The new modifier just collapses the two-step \"Esc, then type, then Enter\" into a one-step \"type, then Shift+Enter\" — and crucially lets the user defer the interrupt/queue decision until they've actually finished writing.

Alternative Solutions

• Esc-first workflow (current): works, but forces the interrupt decision before composition. Most redirect messages are short, but the ones that matter most (careful corrections, pasted context) are the ones where composition time is real.
• Type, queue, then /cancel queued message and re-submit as interrupt: indirect, error-prone, and doesn't exist as a single flow today.
• Codex (OpenAI's CLI) supports exactly this pattern: typing during agent work doesn't interrupt, and at send time the user picks between interrupt vs queue via a modifier key. It feels natural in practice — you don't lose work, and you don't have to decide before you're ready.

Priority

Medium - Would be very helpful

Feature Category

Interactive mode (TUI)

Use Case Example

1. Claude is partway through a multi-file refactor. I notice it's about to rename a symbol I want to keep.
2. I start typing a redirect: \"hold off on renaming FooBar — I want to discuss the naming first, here's why…\" — a few sentences with context.
3. Claude keeps working while I type. Halfway through composing, I realize it's already past the rename and is now doing something fine — so I hit Enter to queue.
4. Alternative: I finish composing and see it's still on the problematic step, so I hit Shift+Enter to interrupt and submit as redirect.

The decision is made after I've finished thinking, not before I've started.

Additional Context

Adjacent issues (related but distinct, mentioned for context):

• #50246 — Message queue mode — proposed Shift+Enter to queue vs Enter to interrupt, back when the default was interrupt-on-Enter. The default has since flipped to queue-on-Enter, so the polarity of the ask is now inverted: it's interrupt that needs a send-time modifier, not queue.
• #34835 — Clarifying prompt for stop vs queue — same underlying ambiguity, different UX (prompt vs send-time modifier).
• #30492 — Real-time steering: priority message channel — broader scope (mid-tool-call injection).
• #59684 (closed as dup) — Inject instructions into running task — also broader (additive injection rather than redirect).

This request is narrower: just give send-time choice between the two existing behaviors (queue / interrupt), so users don't have to pre-commit before composing.