[FEATURE] claude.ai: decouple automatic context management from Code Execution, and add a recoverable session handoff

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

Two issues distinct from context visibility:

1. Discoverability. Automatic context management — where Claude summarizes earlier turns rather than hard-stopping — requires Code Execution and File Creation to be enabled. Nothing in the settings UI indicates that a file-creation toggle governs conversation longevity. Users running long research sessions hit hard length limits without ever knowing a setting existed that would have prevented it.
2. No handoff primitive, and no recovery once the limit is reached. When a conversation hits the length limit it becomes terminal: the user cannot ask for a summary, because generating one requires response headroom the window no longer has. The recommended remedy — summarize and paste into a new chat — is only available before the failure, which means it depends on the user predicting a limit the interface gives them no way to see (see #38605). After the failure, the session's decisions and reasoning are readable but not extractable; recovering them means the user re-reading and re-typing the thread themselves.

Even when a summary is obtained in time, it is lossy in a predictable direction: summaries preserve conclusions and drop the options that were considered and rejected along with the reasons for rejection. The successor conversation then re-proposes work the previous one already ruled out.

Proposed Solution

1. Either enable automatic context management independently of Code Execution, or surface it as its own labeled setting ("Automatic context management") with a plain-language description of the tradeoff, including its effect on usage limits.
2. Add a "Continue in new chat" action on any conversation. It should generate a structured handoff containing: decisions made with their stated reasoning; options considered and rejected, with the rejection rationale; open questions; and verbatim identifiers referenced in the thread (document IDs, ticket keys, exact titles). Let the user edit it before it seeds the new conversation. This action must remain available on a conversation that has already reached its limit — generated server-side against the stored thread rather than as a model turn inside the exhausted window.

Alternative Solutions

Manual summarize-and-paste, which requires acting before the wall and explicitly requesting the rejected options. Forking by editing an earlier message, which discards everything after the edit point. Past-chat search in a new conversation, which retrieves passages but not a decision record. Third-party Chrome extensions sell "context handoff" as a paid feature, indicating demand and no first-party equivalent.

Priority

High - Significant impact on productivity

Feature Category

Other

Use Case Example

Use Case Example 1 (discoverability):

A product manager runs a three-hour research session in claude.ai — reviewing source documents, working through a risk assessment, making a sequence of decisions with reasoning attached to each. The session ends at the length limit. Only afterwards does the user learn that automatic context management exists and would have prevented the hard stop, but is gated behind a setting labeled Code Execution and File Creation. Nothing in that label or its description suggests it governs how long a conversation can run. The user had no reason to enable it and no way to discover the connection.

Use Case Example 2 (recovery):

The same session hits the limit. The user asks Claude to summarize the decisions made so the work can continue in a new chat. Claude cannot respond — producing a summary requires response headroom the window no longer has. The thread is readable but inert. The user's options are to re-read three hours of conversation and manually re-type the decisions, or abandon the reasoning and restart. A "Continue in new chat" action generated server-side against the stored thread would resolve this in one click, because the constraint is the live context window, not the availability of the conversation data.

Additional Context

Related: #38605 requests a persistent context usage indicator for Cowork and claude.ai. This request is complementary and does not duplicate it. Visibility tells a user when to hand off; it does not produce the handoff, and it does not help once the limit has already been reached.

Prior art on the recovery half: Claude Code has /compact and a live context breakdown, so the underlying compaction machinery already exists — the gap is that neither the trigger nor the resulting summary is exposed on the claude.ai surface. Third-party Chrome extensions currently sell "context handoff" for claude.ai as a paid feature, which indicates demand and no first-party equivalent.

Scope note: the two items are filed together because they address the same failure from opposite ends — item 1 reduces how often conversations terminate, item 2 makes termination survivable when it happens. They could be split if triage prefers.

Happy to test either behind a flag.