Capture
One read of Claude Code CLI
3 pages moved out of 186 read.
model-config Changed · +1 / -1 lines
from line 557
To turn off 1M context, set `CLAUDE_CODE_DISABLE_1M_CONTEXT=1`. Claude Code removes 1M model variants from the model picker. On models with a native 1M window, such as Sonnet 5 and Fable 5, it also treats the model as having a 200K context window: * With auto-compaction on, sessions compact at the 200K boundary through [auto-compaction](#set-the-auto-compact-window). Setting the auto-compact window above 200K doesn't lift the hold, because Claude Code caps that window at the model's context window. -* With auto-compaction off, sessions stop at the 200K boundary with a [`Prompt is too long` error](/docs/en/errors#prompt-is-too-long) instead of compacting. +* With auto-compaction off, sessions stop at the 200K boundary with the [context-limit error](/docs/en/errors#prompt-is-too-long) instead of compacting. Before v2.1.223, Claude Code held only Sonnet 5, Opus 4.8, and Opus 5 sessions to 200K. See [environment variables](/docs/en/env-vars).
errors Changed · +61 / -4 lines
### Message too large for cross-session delivery
from line 80
| `Couldn't reconnect to your Remote Control session` | [Network](#couldnt-reconnect-to-your-remote-control-session) | | `N sessions ended while this machine was offline — the environment was cleaned up on the server and can't be resumed.` | [Network](#sessions-ended-while-this-machine-was-offline) | | `Couldn't share the transcript.` | [Network](#couldnt-share-the-transcript) | +| `Couldn't show context usage: the remote sent a reply this version can't display` | [Network](#the-remote-sent-a-reply-this-version-cant-display) | +| `The remote session sent a reply this version can't display` | [Network](#the-remote-sent-a-reply-this-version-cant-display) | | `Prompt is too long` / `Input is too long for requested model` | [Request errors](#prompt-is-too-long) | | `Prompt is too long · automatic compaction failed:` | [Request errors](#prompt-is-too-long) | +| `Context limit reached · /compact or /clear to continue` | [Request errors](#prompt-is-too-long) | +| `Context limit reached · /clear to continue` | [Request errors](#prompt-is-too-long) | | `Context exceeds the ...-token limit by ... tokens` in `/context` output | [Request errors](#context-exceeds-the-token-limit) | | `Error during compaction: Conversation too long` | [Request errors](#error-during-compaction-conversation-too-long) | | `Request too large` | [Request errors](#request-too-large) |
from line 141
| `pkill: refusing to run` | [Tool errors](#pkill-pattern-matches-the-claude-code-process) | | `Failed to write to <name>'s inbox — nothing was sent` | [Tool errors](#failed-to-write-to-a-teammate-inbox) | | `Failed to write the plan approval request to the lead's inbox — plan not submitted` | [Tool errors](#failed-to-write-to-a-teammate-inbox) | +| `Message too large for cross-session delivery` | [Tool errors](#message-too-large-for-cross-session-delivery) | | `Can't open MCP settings while no terminal is attached to this background session` | [Background session errors](#commands-refused-in-a-background-session) | | `Can't open MCP settings in a background session` | [Background session errors](#commands-refused-in-a-background-session) | | `blocked because the path is spelled in a form that cannot be safely resolved` | [Background session errors](#write-or-command-blocked-because-the-path-cannot-be-safely-resolved) |
from line 1104
* When Claude Code lists kept worktrees under this message, pick up any uncommitted work from them * Run `claude remote-control` to start a fresh environment +<h3 id="the-remote-sent-a-reply-this-version-cant-display"> + The remote sent a reply this version can't display +</h3> + +`/context` shows this line in a terminal [attached to a cloud session](/docs/en/claude-code-on-the-web#send-follow-ups-from-the-cli): + +```text theme={null} +Couldn't show context usage: the remote sent a reply this version can't display +``` + +While your terminal is attached, `/context` and `/btw` ask the cloud session for their answer. Sometimes the answer arrives in a form your terminal's Claude Code can't render. The usual cause is a version difference between the two. `/context` then shows the line above instead of the usage breakdown. `/btw` shows `The remote session sent a reply this version can't display` instead of its answer. The cloud session keeps running, and other commands still work. + +**What to do:** + +* Update Claude Code with `claude update`, reattach, and rerun the command +* If the line still appears, run `/feedback` and name the command + +Before v2.1.235, this case showed a raw JavaScript error instead, such as `undefined is not an object`. + <h3 id="couldnt-share-the-transcript"> Couldn't share the transcript </h3>
from line 1152
Prompt is too long ``` +In an interactive session, Claude Code shows this error as: + +```text theme={null} +Context limit reached · /compact or /clear to continue +``` + +The line names only `/clear` when [`DISABLE_COMPACT`](/docs/en/env-vars) is set. Longer forms of the error, such as the compaction-failed form below, keep the `Prompt is too long ·` wording. In `-p` output and the transcript, the text stays `Prompt is too long`. + +When you turned auto-compact off in your [user settings](/docs/en/settings#available-settings), the line also says so: + +```text theme={null} +Context limit reached · /compact or /clear to continue · auto-compact is off · /config to turn it on +``` + +The **Auto-compact** toggle in `/config` writes `autoCompactEnabled` to user settings. The hint appears only when a `/config` change would take effect. For example, it doesn't appear when [`DISABLE_AUTO_COMPACT`](/docs/en/env-vars) or [`DISABLE_COMPACT`](/docs/en/env-vars) turned auto-compact off. It also doesn't appear when a higher-precedence scope, such as project or managed settings, set `autoCompactEnabled` to `false`. Nor does it appear in a terminal attached to a cloud session, where the cloud session owns auto-compact. Before v2.1.235, the line carried no auto-compact hint. + Amazon Bedrock reports this condition as `Input is too long for requested model.`, which Claude Code handles the same way. Before v2.1.217, Claude Code didn't recognize the Bedrock wording, so auto-compact never triggered on it and `/compact` failed with the same error. When automatic compaction ran on this turn and failed on an underlying error, such as an unavailable model or an authentication failure, the message names that error after a separator:
from line 1176
Prompt is too long · automatic compaction failed: <the underlying error> ``` -Resolve the named error first; `/compact` fails on the same error until you do. Before v2.1.229, a failed automatic compaction surfaced the bare `Prompt is too long` without the cause. +Resolve the named error first; `/compact` fails on the same error until you do. Before v2.1.229, a failed automatic compaction surfaced `Prompt is too long` without the cause. **What to do:**
from line 1185
* Disable MCP servers you are not using with `/mcp disable <name>` to remove their tool definitions from context * Trim large `CLAUDE.md` memory files, or move instructions into [path-scoped rules](/docs/en/memory#path-specific-rules) that load only when relevant * Subagents inherit every MCP tool definition from the parent session, which can fill their context window before the first turn. Disable MCP servers you are not using before spawning subagents. -* Auto-compact is on by default and normally prevents this error. If you have set [`DISABLE_AUTO_COMPACT`](/docs/en/env-vars), re-enable it or run `/compact` manually before the window fills. +* Auto-compact is on by default and normally prevents this error. If you turned it off in `/config` or with [`DISABLE_AUTO_COMPACT`](/docs/en/env-vars), turn it back on. If you keep it off, run `/compact` yourself before the window fills. See [Explore the context window](/docs/en/context-window) for an interactive view of how context fills up. ### Context exceeds the token limit -`/context` shows this warning at the top of its output when the conversation has grown past the model's context window. Requests fail with [`Prompt is too long`](#prompt-is-too-long) until you free space. +`/context` shows this warning at the top of its output when the conversation has grown past the model's context window. Requests fail with [`Prompt is too long`](#prompt-is-too-long) until you free space. An interactive session shows that error as the `Context limit reached` line. ```text theme={null} Context exceeds the 200k-token limit by 94k tokens — run /compact or /clear to continue.
from line 1220
Error during compaction: Conversation too long. Press esc twice to go up a few messages and try again. ``` -This can happen when the window is already full at the moment auto-compact triggers, or when you run `/compact` after seeing `Prompt is too long`. +This can happen when the window is already full at the moment auto-compact triggers, or when you run `/compact` after seeing [`Prompt is too long`](#prompt-is-too-long). In an interactive session, that error is the `Context limit reached` line. **What to do:**
from line 2006
* Ask the sender to resend the message; contention for the inbox lock is transient and clears on retry * Check free disk space, and check that `~/.claude/teams` and the files under it are writable by your user + +### Message too large for cross-session delivery + +Claude's [cross-session message](/docs/en/cross-session-messaging) to another of your sessions on this machine was too long to send. Claude Code refused it, and the receiving session got nothing. The refusal appears in the sending session's tool result, not as a banner in your terminal. It names both sizes and how to make the message fit: + +```text wrap theme={null} +Failed to send to api-worker: Message too large for cross-session delivery: the serialized message is 1,203,844 characters and the limit is 1,048,576. Shorten the message text — put bulk content in a file the recipient can read rather than in the message — or split it into smaller messages. +``` + +Resending the same text fails the same way. + +**What to do:** + +* Ask Claude to summarize the message, or to put the bulk content in a file and send the file's path +* Ask Claude to split the content across several shorter messages + +Before v2.1.235, Claude Code reported an oversized message as sent. The receiving session dropped it unread. ## Background session errors
cross-session-messaging Changed · +2 / -1 lines
from line 59
The receiving Claude reads the message between tool calls during an active turn, so a running tool is never interrupted. When the receiving session is idle, Claude Code starts a new turn with the message. -Between two ordinary interactive sessions with default settings, Claude Code delivers the message. Delivery isn't guaranteed in every configuration, though. The receiving session checks each arriving message against its own [inbound controls](#control-inbound-messages), and the check ends in one of three outcomes: +Between two ordinary interactive sessions with default settings, Claude Code delivers the message. Delivery isn't guaranteed in every configuration, though. Claude Code refuses a message [over the size cap](#limitations) in the sending session, before it leaves. The receiving session checks each arriving message against its own [inbound controls](#control-inbound-messages), and the check ends in one of three outcomes: * **Delivered**: Claude Code passes the message to the receiving Claude. * **Held**: Claude Code sets the message aside undelivered. A held message reaches Claude only when you approve it or a later mode or settings change allows it.
from line 261
The limits here are properties of the messaging channel itself and apply wherever the feature runs. For platform and provider gaps, see [Availability](#availability) instead. * **Plain text only**: Claude sends only plain text across sessions. Structured [agent team](/docs/en/agent-teams) protocol messages stay within a team. +* **Same-machine message size is capped**: Claude Code refuses a message to a session on this machine once its serialized form passes about a million characters. The refusal [names the exact sizes](/docs/en/errors#message-too-large-for-cross-session-delivery). Nothing reaches the receiving session. * **Message loops are throttled**: Claude Code rate-limits repeated messages per sender, drops identical repeats arriving within a short window, and caps accepted messages waiting for Claude to read them at 50 per session. A message loop between two sessions therefore stops on its own. ## Related resources