[FEATURE] Inject context into a running agent mid-reasoning without interrupting or queuing

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

When Claude is working through a complex multi-step task in Claude Code or Cowork, it often reasons out loud about decisions, "I need to determine which storage approach to use," or "it's unclear whether this should route to X or Y." As the user watching that reasoning, I frequently already know the answer to the question Claude is asking itself. But there is no way to hand it that answer without breaking its flow.
Today the only two options are:

• Queue: the message waits until the entire turn completes, by which point Claude has already guessed and moved on, often down the wrong path.
• Interrupt: stops the current work entirely, losing momentum and forcing a re-plan.

Neither lets me do the thing I actually want: pass a piece of context into the live reasoning process so Claude can incorporate it on the next step and keep going.

Proposed Solution

A third input mode, distinct from queue and interrupt, that injects a user message into the running agent's context as supplemental information, without halting execution. Claude would pick it up at its next reasoning checkpoint and factor it in, the same way it would consider anything in context, then continue the task.
Possible UX:

• A modifier (e.g. a dedicated "add context" button, or Shift+modifier on send) that flags the message as inject-don't-interrupt
• A small indicator confirming the context was received and will be applied at the next step
• Especially valuable in Cowork and for long-running or multi-agent tasks where the user can see questions form in real time

Alternative Solutions

Currently I either interrupt (losing the in-progress work and forcing a re-plan) or queue (the message sits until the turn ends, by which point Claude has already made the decision I wanted to weigh in on). Neither captures the real-time "answer the question it's asking right now" need. No workaround exists for injecting context into live reasoning.

Priority

High - Significant impact on productivity

Feature Category

Interactive mode (TUI)

Use Case Example

1. I ask Claude to build a multi-step feature in Cowork.
2. Mid-task it reasons: "I need to decide on a storage approach for these files."
3. I already know the answer (use Vercel Blob), but if I queue it, Claude picks a different option before reading my message; if I interrupt, I lose its progress.
4. With this feature, I'd inject "use Vercel Blob" as context and Claude would factor it in at its next step without stopping, saving a full re-plan cycle.

This compounds with longer-reasoning modes. In Ultracode (Code) or Max effort (Cowork), turns run long and a single turn often ends with Claude asking permission to take an action, or returning several multiple-choice questions at once. So even a queued message doesn't help, the turn might surface five questions and a dozen permission prompts before it actually ends. By then I've either had to interrupt and lose the work, or sit and watch it make decisions I could have answered in one line if I could inject context mid-stream. The longer and more autonomous the reasoning, the more this gap costs. And the cost isn't just time. Every re-plan after an interrupt re-runs reasoning I already paid for, burning tokens and eating into session usage limits, to arrive at a decision I could have settled with a one-line injection.

Additional Context

Why This Matters
This is the natural complement to the queue feature already requested in #30677 and #50246, and a softer version of #21419 and #41665. Queue is for "do this next." Interrupt is for "stop." This is for "here's an answer to the question you're currently asking yourself, keep going." That middle ground is missing and it's the most common real-time interaction I want during complex sessions.
Prior art: OpenAI shipped a comparable capability for ChatGPT (an "Update" control, around late 2025) that lets users add context or corrections to an in-progress query without restarting it, and the model incorporates the input and continues. They aimed it specifically at long-running, high-tier work like Deep Research and GPT-5 Pro, where re-running wastes both time and prompt quota, the same cost dynamic described above. The exact mechanism may differ (pause-and-resume vs. true mid-stream injection), but the user-facing need it addresses is identical.