[FEATURE] Thinking-aware interactive mode: real-time thinking visibility with informed mid-turn correction queuing (Cursor parity)

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

Cursor's IDE integration with Claude 4.6 Opus (via its claude-4.6-opus-high-thinking model configuration) provides a fundamentally different interaction paradigm than Claude Code currently offers — one built around visible, real-time extended thinking paired with informed mid-turn correction queuing. These two capabilities work together to create a tighter human-in-the-loop feedback cycle that Claude Code lacks entirely.

What Cursor does today:

1. Real-time thinking visibility: When Cursor dispatches a request to Claude 4.6 Opus with extended thinking enabled, the model's <thinking> blocks are streamed to the user in real-time within the IDE. Users watch the model reason through the problem live — evaluating trade-offs, planning which files to read, deciding on implementation approaches, catching its own mistakes. This is not a post-hoc log; it is a live stream of the reasoning process as it unfolds.

1. Informed correction queuing: Because the user can see what the model is thinking before it acts, they can proactively queue corrections or supply additional context while the agent is still in its reasoning phase. If the user sees the model heading toward the wrong file, misunderstanding a requirement, or making an incorrect assumption about the codebase, they can intervene before the model commits to that path by executing tool calls. The user's queued input is incorporated into the model's next decision point rather than arriving after the damage is done.

1. Thinking-aware interaction loop: The combination creates a collaborative feedback loop: the model thinks → the user sees the reasoning → the user corrects or adds context → the model incorporates the correction. This is qualitatively different from the current Claude Code model of: the model thinks invisibly → the model acts → the user sees the result → the user reacts to mistakes after the fact.

What Claude Code does today:

• Extended thinking tokens are generated but entirely hidden from the user. The user sees a spinner with a randomized verb ("Thinking", "Reasoning", "Pondering") and a duration counter, but zero insight into what the model is actually reasoning about.
• Messages typed during the agent's turn are queued blindly — the user has no visibility into the model's reasoning to make an informed decision about what to correct or when to intervene. They are typing corrections into a void.
• The /btw mechanism exists for non-interrupting side-channel messages, but it is a blind injection with no feedback about whether the context was needed or how it changed the model's approach.
• The Ctrl-O keybinding that once toggled thinking visibility has been removed or no longer functions in recent versions.

The gap is not just "show thinking" — it is the interaction model. Existing issues (#33163, #36006) request displaying thinking content, and others (#30492, #34835) request better message queuing. But the real value — and what Cursor demonstrates — is that these features are coupled: visible thinking makes correction queuing informed rather than blind, and informed queuing makes visible thinking actionable rather than merely decorative.

Proposed Solution

Implement a thinking-aware interactive mode that combines real-time thinking visibility with informed mid-turn steering:

1. Stream thinking content in real-time as the model generates it, displayed in a visually distinct region (dimmed, collapsible, or in a sidebar/panel). This should be opt-in via a configuration setting (e.g., thinkingDisplay: "streaming" | "collapsed" | "hidden") and default to "collapsed" showing the first few lines with a toggle to expand.

1. Thinking-aware input prompt: Keep the input prompt active and accepting keystrokes while the model's thinking is streaming. When the user types a correction or additional context:

• Show a clear indicator that the message will be queued (not interrupt)
• Deliver the queued message at the next natural break point (between thinking and tool execution, or between sequential tool calls)
• Display a visual confirmation when the queued message has been incorporated

1. Reasoning-phase intervention: Allow users to press a dedicated key (e.g., Ctrl-I for "intervene") while thinking is streaming to pause the model's turn at the end of the current thinking block, inject the user's correction, and resume. This is distinct from Escape (which discards the turn) and from blind queuing (which waits for the turn to fully complete).

1. Thinking transcript in session logs: Persist thinking content in JSONL transcripts (currently only encrypted signatures are stored) so users can review reasoning after the fact, which is valuable for debugging agent behavior and refining CLAUDE.md instructions.

Alternative Solutions

• Thinking-only (no interaction changes): Simply expose thinking content read-only, as #36006 proposes. This is valuable but misses the interaction model that makes Cursor's implementation powerful. Users would see the model going wrong but have no better mechanism to correct it than they do today.
• Queuing-only (no thinking visibility): Improve message queuing per #34835 and #30492 without showing thinking. This helps but leaves users guessing about when and what to correct — they are still intervening blindly.
• Hook-based approach: Expose thinking blocks via hooks (#39343) so external tools can render them. This is composable but adds integration burden and latency compared to native TUI support.

Priority

High - Significant impact on productivity

Feature Category

Interactive mode (TUI)

Use Case Example

Scenario: A user asks Claude Code to refactor an authentication module from session-based to JWT-based tokens across 12 files.

Today (Claude Code):

1. User sends the request
2. Spinner shows "Thinking... 45s" — user has no idea what approach Claude is planning
3. Claude begins executing: reads files, makes changes, runs into an issue with a legacy middleware it didn't account for
4. 3 minutes and 15 tool calls later, Claude presents results that assumed the wrong auth library
5. User says "No, we use jose not jsonwebtoken" — Claude starts over, re-reading the same 12 files

With this feature (Cursor-like):

1. User sends the request
2. Thinking stream shows: "The auth module uses express-session... I'll plan the migration to JWT. Looking at the imports, it seems like they might be using jsonwebtoken..."
3. User sees the wrong assumption forming, types: "We use the jose library, not jsonwebtoken. Check package.json"
4. The correction is injected before Claude starts executing tool calls
5. Claude incorporates the correction into its plan and executes correctly the first time

The time, token, and frustration savings compound with task complexity.

Additional Context

Related issues (this request is distinct from but complementary to all of these):

• #33163 — Requests re-enabling thinking visibility (subset of this proposal)
• #36006 — Proposes collapsed/expanded thinking display (subset of this proposal)
• #30492 — Requests real-time steering/priority messages (complementary — this proposal adds the visibility that makes steering informed)
• #34835 — Requests message queuing UX (complementary — this proposal adds thinking context that makes queuing decisions better)
• #38053 — Requests hot context injection for agent pools (parallel concern for multi-agent)
• #39343 — Requests thinking blocks in hooks (composable alternative)

Competitive context: Cursor's implementation demonstrates that this interaction model is technically feasible with Claude's API (they use the same extended thinking API). The gap is in Claude Code's TUI not surfacing the thinking tokens that the API already provides and not building the interaction affordances around them. This is a significant competitive differentiator that Cursor currently holds over Claude Code for complex agentic workflows.