# Claude Code v2.1.278 > Claude Code v2.1.278, released 19 Sep 2026 (2026-09-19). 27 entries read out of the shipped bundle. Unofficial, and not affiliated with Anthropic. Web version: https://changelogs.core-directive.com/v/2.1.278 This build's seven gated additions cluster around a single unreleased feature: a billing notice warning some users that auto mode is still charging them for classifier requests even though they can't act on it yet. The notice would surface as a dialog in interactive sessions, as stderr text or a stream-json warning event in non-interactive and headless sessions, and pressing Escape on it cancels the in-flight tool call it interrupted. Behind it, auto mode's core permission-decision flow has been rebuilt to check this billing logic before falling back to the local classifier, and a new gate called tengu_quiet_lantern controls when the server classifier falls back to local at all. None of this is switched on yet; the model/context panel does gain a new "Auto mode server" row, but it's part of the same still-dark feature. Three things are live today. Sessions connecting through a Unix socket (via ANTHROPIC_UNIX_SOCKET) now lose server-side auto mode classification unless they're on an SSH remote connection. The status panel that already shows model, MCP, and theme now also lists the current permission mode, and a new diagnostics row reports whether the auto mode server classifier is Enabled or Disabled. The one fix this release addresses an SDK startup diagnostic: a specific shutdown reason was never making it into its own diagnostic log line, and that assignment bug is now corrected. ## What probably matters to you Anything you can use today, anything that visibly changes, and anything worth poking at. One line each, open for detail. ### New 'auto mode classifier billing notice' dialog, built but tier-gated A new dialog warns some users that auto mode is still billing them for classifier requests **Unclear.** The three related gates (`tengu_velvet_heron`, `tengu_auto_mode_server_fallback_notice`, `tengu_auto_mode_server_fallback_notice_closed`) are unread, so it's unclear which accounts this dialog reaches. **What** Claude Code now has a new pop-up dialog that can appear while working in auto mode. It tells the user: "We're changing auto mode to no longer charge for classifier requests in Claude Code," and explains that this particular session doesn't qualify for the change, so classifier requests (the background checks auto mode uses to decide whether a tool call needs permission) keep being billed as before. The dialog only appears in a specific situation: auto mode tried to use a server-side classifier this session, was refused, and has fallen back to Claude Code's own local classifier, which is billed. From the dialog, pressing Enter continues and accepts the billed classifier call; pressing Escape cancels the tool call instead. **Why** This gives people a heads-up that they're paying for classifier requests that others may not be, and a way to back out of a specific tool call rather than being billed silently. The related settings that control this behavior haven't been read yet, so it isn't yet known who sees this dialog in practice. - Flag `tengu_velvet_heron`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Auto Mode - Tier: Nothing to try yet - Useful: 3/5 - Signal: 4/5 - Present in the build but not switched on ### The main system prompt gained text The main system prompt gained new text, including a mention of 'control' **Unclear.** The evidence only confirms new text was added and that it contains the word 'control'; what the addition says or does is not established. **What** The main system prompt, the instructions Claude Code sends to the model at the start of every conversation, gained additional text. This was measured directly from the prompt as sent by the running client, across both the CLI and SDK versions and across anonymous and account-linked variants, and the added text includes the word `control`. **Why** Changes to the system prompt can affect how Claude behaves in subtle ways across all sessions, since this prompt is sent every time regardless of what a user asks. The exact content and purpose of the addition are not established beyond the one quoted word. - Area: System Prompt - Tier: Under the hood - Useful: 3/5 - Signal: 4/5 ### Auto-mode classifier now distrusts unix-socket proxies unless SSH remote Sessions using ANTHROPIC_UNIX_SOCKET now lose server-side auto mode classification unless connecting over SSH remote **What** The check that decides whether a session counts as first-party (and so gets access to the server-side auto-mode classifier) now treats a session using `ANTHROPIC_UNIX_SOCKET` as third-party, disabling that server-side classifier, unless `CLAUDE_CODE_ENTRYPOINT` is set to `ssh-remote`. **Why** This closes a gap where a unix-socket connection could otherwise be treated as trusted first-party access to the server-side classifier; it's only allowed through when the entry point is specifically the SSH remote case. - Area: Auto Mode - Names: `ANTHROPIC_UNIX_SOCKET`, `CLAUDE_CODE_ENTRYPOINT` - Tier: You'll notice - Useful: 2/5 - Signal: 3/5 ### 'Auto mode server' status row added to the model/context panel The model/context status panel gains an 'Auto mode server' row showing Enabled or Disabled **What** The status panel that shows model and context details now includes a new row labeled 'Auto mode server', showing either 'Enabled' or 'Disabled'. This value is computed by checking the resolved classifier mode and whether the current model is a reduced-capability ('gimped') one. **Why** This gives users visibility into whether an automatic mode-selection server feature is active for their current model and session, where previously this state wasn't surfaced in the panel at all. - Flag `tengu_quiet_lantern`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Status Panel - Names: `tengu_quiet_lantern` - Tier: Nothing to try yet - Useful: 2/5 - Signal: 3/5 - Present in the build but not switched on ### Gateway/proxy detection feeding the billing notice message Claude Code now detects LLM gateways and swaps the billing notice for a gateway-specific message with a docs link **What** Claude Code can now detect whether the current base URL points to a known LLM gateway or proxy service, such as litellm, helicone, portkey, cloudflare-ai-gateway, kong, braintrust, bifrost, or databricks. It does this either by recognizing the hostname or by noticing a gateway during an actual request. When a gateway is detected, the billing notice text changes: instead of the usual message, it tells the admin that the session is ineligible because requests are going through that gateway, and links to a docs page (`auto-mode-classifier-billing`) explaining how to fix it. **Why** This helps admins understand why a billing-related feature isn't working when their traffic is routed through a gateway or proxy, rather than leaving them with a generic or confusing notice. - Flag `tengu_velvet_heron`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Auto Mode - Names: `litellm`, `helicone`, `portkey` - Tier: Under the hood - Useful: 2/5 - Signal: 3/5 ### Third-party server classifier gating tightened Auto mode's server-classifier eligibility check adds a new exclusion and respects CLAUDE_CODE_AUTO_MODE_SERVER as an override **What** The logic that decides whether auto mode uses the server-side classifier (versus falling back to local-only classification) now excludes a specific case of first-party providers from that fallback path, and explicitly checks the `CLAUDE_CODE_AUTO_MODE_SERVER` environment variable as an override when deciding whether the feature is enabled at all. **Why** This narrows exactly which sessions are eligible for server-side classifier fallback, and makes sure an explicit `CLAUDE_CODE_AUTO_MODE_SERVER` setting is respected rather than being overridden by other logic. - Flag `tengu_quiet_lantern`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Auto Mode - Names: `CLAUDE_CODE_AUTO_MODE_SERVER` - Tier: Under the hood - Useful: 2/5 - Signal: 3/5 ## Improvements ### Model/cwd status panel now shows the current permission mode The status panel that shows Model, MCP, and theme now also lists the current permission mode **What** The status panel Claude Code shows (the one listing things like Model, MCP servers, and theme) now includes a row for the current permission mode, driven by a new `permissionMode` value passed into that panel. **Why** This lets users see at a glance which permission mode they're in — for example whether tool calls are being auto-approved or require confirmation — without having to check settings separately. - Area: Status Panel - Tier: You'll notice - Useful: 3/5 - Signal: 2/5 ### Auto mode server status surfaced as Enabled/Disabled A new diagnostics row reports auto mode's server classifier as Enabled or Disabled **What** A new diagnostics helper builds a status row labeled "Auto mode server" that reports either "Enabled" or "Disabled", based on a check of whether the auto-mode classifier resolves to server-side ("arbiter") mode and whether the current model is excluded from it. **Why** This gives users a direct way to see, in diagnostics output, whether their session is actually using the server-side auto-mode classifier or not, rather than having to infer it from behavior. - Area: Status Panel - Tier: You'll notice - Useful: 2/5 - Signal: 2/5 ## Bug Fixes ### SDK startup diagnostic message assignment bug fixed Fixed a bug where a specific SDK shutdown reason never appeared in its own diagnostic log line **What** In the SDK's startup-exit diagnostic logging, the code path for a permanently-closed transport (the connection used to talk to the SDK) was writing its message into the wrong variable, so that reason likely never actually showed up in the printed `SDKStartup: exiting without result` diagnostic line. This has been corrected. **Why** This means diagnostic logs for SDK shutdowns will now correctly report "transport closed permanently" as the reason when that's what happened, making it easier to debug why an SDK session exited. - Area: Elsewhere - Tier: You'll notice - Useful: 1/5 - Signal: 1/5 ## In Development ### Declining the billing notice cancels the in-flight tool call Pressing Escape on the new billing notice cancels the tool call it interrupted **What** When the new classifier billing notice dialog is showing and the user presses Escape to decline, the tool call that triggered the notice is denied outright, with the reason recorded as "Cancelled at the classifier billing notice." **Why** This gives users a real way to stop a tool call rather than just dismissing a warning: declining the notice means the action doesn't go through. - Flag `tengu_velvet_heron`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Auto Mode - Names: `Escape` - Tier: Nothing to try yet - Useful: 2/5 - Signal: 3/5 - Present in the build but not switched on ### Billing notice surfaces as a stderr/stream-json warning in headless (print) mode The classifier billing notice prints to stderr or a stream-json warning when there's no dialog to show **What** In headless usage, such as `-p`/print mode or when output is set to stream-json, there's no interactive screen to show a pop-up dialog on. In those cases, the same classifier billing notice message is instead written to stderr, or emitted as a stream-json `warning` event when `--verbose` stream-json output is being used. **Why** This makes sure scripts and automated runs still get told when auto mode has fallen back to billed classifier requests, instead of the notice silently disappearing because there's no dialog surface to show it on. - Flag `tengu_velvet_heron`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Auto Mode - Names: `--verbose` - Tier: Nothing to try yet - Useful: 2/5 - Signal: 3/5 - Present in the build but not switched on ### Auto-mode permission decision flow reworked around the new billing notice Auto mode's core permission check was rebuilt to run the new billing-notice logic before falling back to the local classifier **What** The main function that decides whether a tool call needs permission in auto mode was restructured to check for the new billing-notice/fallback condition before calling the local classifier, and a new "no result" handler is now threaded through both the fast-path check (used in `acceptEdits` mode) and the main classification path. **Why** This ties the classifier billing notice into the actual permission decision flow, so a missing server verdict is handled consistently everywhere a tool call gets checked, rather than only in one code path. - Flag `tengu_velvet_heron`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Auto Mode - Tier: Nothing to try yet - Useful: 2/5 - Signal: 3/5 - Present in the build but not switched on ### Non-interactive/stream-json sessions get a stderr/warning-event billing notice instead of a dialog Non-interactive sessions now get the billing notice as stderr text or a stream-json warning event instead of a popup **Unclear.** Which gate(s) control this and what the billing notice specifically concerns are not established by the evidence. **What** When Claude Code runs in a mode without an interactive display, such as with `--output-format stream-json --verbose` (a mode that streams structured JSON events instead of a normal terminal view, with `--verbose` showing full turn-by-turn output), a billing notice that would normally appear as a dialog is now delivered differently. It's emitted as a `warning` event in the stream-json output, or written directly to standard error (`stderr`) otherwise, before normal output begins. **Why** This lets automated or scripted sessions that can't show a dialog still receive the same billing notice, in a form that fits the output format they're already consuming. - Flag `tengu_velvet_heron`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Auto Mode - Names: `--verbose` - Tier: Nothing to try yet - Useful: 2/5 - Signal: 3/5 - Present in the build but not switched on ### New gate tengu_quiet_lantern controls arbiter local-fallback triggers A new gate, tengu_quiet_lantern, controls whether the server classifier falls back to local when unsupported **What** A new feature flag, `tengu_quiet_lantern`, has been added to control whether auto mode's server-side ("arbiter") classifier falls back to local classification specifically when the server returns no result or reports the feature as unsupported. **Why** This lets the server-classifier fallback behavior be turned on or off independently for different accounts, rather than being hard-coded into every install. Nothing has been read yet about which accounts have it on. - Flag `tengu_quiet_lantern`: Not enough to say (read for one account on one subscription tier against v2.1.278; this account: no value returned, anonymous baseline: no value returned, compiled default: on) These values were read against a different version of Claude Code, so treat them as the nearest reading available instead of one taken on this release. - Area: Auto Mode - Names: `tengu_quiet_lantern` - Tier: Nothing to try yet - Useful: 1/5 - Signal: 2/5 - Present in the build but not switched on ## Internal Changes ### Session-scoped 'server classifier refused' latch drives permanent local fallback Once the server refuses classification once, auto mode sticks to local classification for the rest of the session **What** Claude Code now remembers, for the rest of a session, if the server says it won't run server-side auto-mode classification (or silently drops the answer). The first time that happens, it's logged as a warning and a session-long flag is set so every later classification check goes straight to the local classifier instead of trying the server again. **Why** This avoids repeatedly asking a server that has already said no, and makes the fallback to local (billed) classification consistent and predictable for the rest of that session rather than flipping back and forth. - Area: Auto Mode - Tier: Under the hood - Useful: 2/5 - Signal: 2/5 ### New content-routing refusal-category allowlist for cyber/frontier_llm A new allowlist restricts routing based on refusal category to just 'cyber' and 'frontier_llm' **Unclear.** The finding does not say what effect this routing decision has on the user-visible response. **What** Claude Code has internal logic for routing certain requests based on an `apiRefusalCategory` value (a label describing why a response was refused). A new function now only keeps that route active when the refusal category is `cyber` or `frontier_llm`, and only if a few other conditions also hold: the visible route wasn't already declined, an internal check (`JB()`) passes, and a feature or permission check (`G$()`) also passes. **Why** This narrows an internal routing decision to two specific refusal categories, likely limiting when this content-routing path applies. The practical effect for most users is invisible, since it governs internal handling rather than anything surfaced directly. - Area: Elsewhere - Tier: Under the hood - Useful: 2/5 - Signal: 2/5 ### Request-latches class reworked from two Maps to scalar per-session fields Internal per-session request-latch storage was restructured from two maps to individual fields **Unclear.** The finding does not explain what behavioral difference, if any, this restructuring produces. **What** The internal object that tracks per-session request state (exposed as `host.requestLatches`) changed how it stores some of its data. Two fields that used to be Maps (key-value lookup structures) are now a plain boolean and two new placeholder fields, alongside other existing maps used for different purposes. This structure backs several internal checks, including ones related to server classifier fallback choices and observed gateways. **Why** This is an internal data-structure change with no direct user-facing effect described, but it underlies features like gateway detection and classifier fallback handling mentioned elsewhere in this release. - Area: Elsewhere - Names: `host.requestLatches` - Tier: Under the hood - Useful: 1/5 - Signal: 2/5 ### Per-agent prompt-dump state can now be cleared/deleted Debugging 'dumpPrompts' state can now be cleared per agent or globally **What** Claude Code has an internal debugging feature called `dumpPrompts` that keeps track of state per agent (per subagent, a separate Claude instance handling part of a task). New helper functions let this state be cleared for a single agent or wiped out entirely. **Why** This is a developer-facing debugging tool rather than something end users interact with directly, but it means the tracked dump state can now be reset instead of only accumulating. - Area: Elsewhere - Names: `dumpPrompts` - Tier: Under the hood - Useful: 2/5 - Signal: 1/5 ### New telemetry for server-side auto-mode classifier fallback/notice New analytics events track when auto mode falls back to local classification and when the billing notice shows **What** Claude Code now records new telemetry events for the server-side auto-mode classifier fallback behavior: - when the server-side classifier doesn't return a result and auto mode falls back to local classification - when the new billing notice dialog is shown - when the billing notice dialog is closed **Why** This lets Anthropic measure how often auto mode falls back to local (billed) classification and how users respond to the new billing notice, without affecting anything the user sees directly. - Area: Auto Mode - Tier: Under the hood - Useful: 1/5 - Signal: 1/5 ### New request-latch state for server-side classifier fallback and gateway tracking Session state now tracks the inference gateway seen and any classifier fallback choice made **What** Claude Code's internal per-session state object gained new tracking for the auto-mode server classifier fallback: - which inference gateway was observed for the session - whether a fallback choice was made when the server-side classifier is unavailable, and what that choice was - a one-shot flag for announcing that fallback to the user (so the announcement only happens once) - whether the third-party server classifier was refused for this session **Why** This gives the new server-classifier fallback and billing-notice features a place to remember what's already happened in a session, so users aren't shown the same fallback notice repeatedly or asked to re-decide something already settled. - Area: Auto Mode - Tier: Under the hood - Useful: 1/5 - Signal: 1/5 ### Auto mode classifier: new 'stale session' verdict message Auto mode now has a distinct message for sessions with no stored classifier result **What** The function that produces a message when auto mode's classifier has no verdict now also handles a new case: a session where no stored result exists for an action, distinct from the existing case where a verdict was simply never requested. **Why** This lets Claude Code report more precisely why a classifier decision is missing, rather than lumping a stale or missing stored result together with a request that was never made. - Area: Auto Mode - Tier: Under the hood - Useful: 1/5 - Signal: 1/5 ### Dialog registration map reshuffled (Slack Connect / sign-in dialogs) Internal dialog registration was reorganized, affecting Slack Connect and Slack sign-in dialogs **Unclear.** It isn't clear whether the two new entries correspond to new dialogs or just a different way of registering existing ones. **What** The internal map that registers which component implements which UI dialog was restructured: a previously merged entry now uses a different pairing of helper functions, and two new entries were added to the end of the list. This affects dialogs including the Slack Connect consent prompt and the Slack sign-in offer prompt. **Why** This is an internal reorganization of how dialogs are wired up; the finding doesn't indicate any visible behavior change for these dialogs. - Area: Elsewhere - Tier: Under the hood - Useful: 1/5 - Signal: 1/5 ### New function captures custom ANTHROPIC_BASE_URL host for firstParty sessions A new helper captures the custom hostname when ANTHROPIC_BASE_URL points somewhere other than Anthropic's API **Unclear.** The finding doesn't say what consumes this captured hostname, only that it's produced in this specific case. **What** A new helper function returns the hostname from `ANTHROPIC_BASE_URL` in the specific case where the session is still classified as first-party but the base URL isn't `api.anthropic.com`, and no unix socket is in use. **Why** This appears to support telemetry or diagnostics around proxy or gateway hosts that don't match Anthropic's usual API address, likely to help identify unrecognized custom endpoints. - Area: Auto Mode - Names: `ANTHROPIC_BASE_URL` - Tier: Under the hood - Useful: 1/5 - Signal: 1/5 ### Third-party classifier availability check reworked The check for whether the server-side auto-mode classifier can be used was reworked internally **Unclear.** It's unclear from the evidence what the new predicate and the swapped function actually change in terms of which providers qualify. **What** The function that gates whether the server-side auto-mode classifier is usable changed its handling of third-party providers: it now checks a new predicate on the resolved provider, and calls a different negated function than before when deciding availability. **Why** This is an internal change to how third-party providers are evaluated for server-side classifier eligibility; the finding doesn't specify what practical difference it makes for users. - Area: Auto Mode - Tier: Under the hood - Useful: 1/5 - Signal: 1/5 ### Server classifier 'no result' reason renamed The internal label for a server classifier 'no result' case was renamed **What** Claude Code sometimes asks a server-side classifier (an internal system that helps decide how a request should be handled) to make a decision, and logs a reason code when that classifier doesn't return a usable answer. That reason code changed from `server_no_result` to `server_results_not_held`. **Why** This is an internal telemetry label rather than something a user sees directly. It does not change behavior on its own, but anyone tracking this diagnostic string should expect the new name. - Area: Auto Mode - Tier: Under the hood - Useful: 1/5 - Signal: 1/5 ### New request-latch queries for thinking resumption/highlights refusal Two new checks report whether 'thinking resumption' or 'thinking highlights' requests were refused **Unclear.** The finding does not say what consumes these new checks or what a user would see when one of these is true. **What** Claude Code keeps internal state (called request latches) tracking things about the current session's requests. Two small new helpers can now check whether that state indicates a request for 'thinking resumption' or 'thinking highlights' was refused. **Why** These are internal diagnostic helpers, so the direct impact isn't visible to users, but they suggest Claude Code is tracking more specifically when these particular thinking-related features get refused. - Area: Elsewhere - Tier: Under the hood - Useful: 1/5 - Signal: 1/5 ### Version bump only This release is version 2.1.278, bumped from 2.1.277 **What** This group of changes is purely the build version metadata (version number, build time, and git commit hash) being updated from 2.1.277 to 2.1.278, repeated across the many copies of that metadata embedded throughout the bundled code. **Why** This is a routine version bump with no functional change on its own. - Area: Elsewhere - Tier: Under the hood - Useful: 1/5 - Signal: 0/5