opencode-anthropic-fix 0.6.0 → 2.0.0

package/index.mjs

@@ -3,19 +3,14 @@ import { stdin, stdout } from "node:process";
 import { randomBytes, randomUUID, createHash as createHashCrypto } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve, basename } from "node:path";
-import { AccountManager, RATE_LIMIT_KEY_FAST } from "./lib/accounts.mjs";
+import { AccountManager, RATE_LIMIT_KEY_FAST, warnOnEphemeralTokenRotation } from "./lib/accounts.mjs";
 import {
   authorize as oauthAuthorize,
   exchange as oauthExchange,
   parseOAuthCallback,
   refreshToken,
 } from "./lib/oauth.mjs";
-import {
-  FALLBACK_CLAUDE_CLI_VERSION,
-  CLAUDE_CODE_NPM_LATEST_URL,
-  CLAUDE_CODE_BUILD_TIME,
-  resolveBetaShortcut,
-} from "./lib/request-headers.mjs";
+import { resolveBetaShortcut } from "./lib/betas.mjs";
 import { loadConfig, loadConfigFresh, saveConfig, getConfigDir } from "./lib/config.mjs";
 import { loadAccounts, saveAccounts, clearAccounts, createDefaultStats } from "./lib/storage.mjs";
 import { acquireRefreshLock, releaseRefreshLock } from "./lib/refresh-lock.mjs";
@@ -37,7 +32,7 @@ import {
   maybeApplySessionToolResultDedupe,
   applyContextHintCompaction,
 } from "./lib/token-economy/transforms.mjs";
-import { shouldMicrocompact, buildMicrocompactBetas } from "./lib/token-economy/microcompact.mjs";
+import { shouldMicrocompact } from "./lib/token-economy/microcompact.mjs";
 import { redactSecrets, redactString } from "./lib/redact.mjs";
 import {
   createTransformedSSEStream,
@@ -49,7 +44,12 @@ import { isTruthyEnv } from "./lib/env.mjs";
 import { sessionMetrics, createInitialSessionMetrics, getAverageCacheHitRate } from "./lib/session-metrics.mjs";
 import { repairOrphanedToolUseBlocks } from "./lib/mimicry/request-helpers.mjs";
 import { resolveCacheTtl, shouldPlaceToolBreakpoint, updateBoundaryStability } from "./lib/mimicry/cache.mjs";
-import { SERVICE_WIDE_MAX_RETRIES, CONSECUTIVE_529_FALLBACK_THRESHOLD } from "./lib/tuning.mjs";
+import {
+  SERVICE_WIDE_MAX_RETRIES,
+  CONSECUTIVE_529_FALLBACK_THRESHOLD,
+  FOREGROUND_REFRESH_EXPIRY_BUFFER_MS,
+} from "./lib/tuning.mjs";
+import { isTokenExpired, isTokenUsable } from "./lib/account-state.mjs";
 import {
   computeServiceRetrySleepMs,
   selectFallbackModel,
@@ -58,7 +58,6 @@ import {
 } from "./lib/retry/overload-loop.mjs";
 import {
   buildRequestHeaders,
-  buildAnthropicBetaHeader,
   parseRequestBodyMetadata,
   extractFileIds,
   stripStainlessHelperMarkers,
@@ -68,25 +67,31 @@ import {
   compactSystemText,
   compactToolDescription,
   dedupeSystemBlocks,
-  getCachedCCPrompt,
   isTitleGeneratorSystemBlocks,
   normalizeSystemTextBlocks,
-  resetCachedCCPrompt,
   sanitizeSystemText,
   CLAUDE_CODE_IDENTITY_STRING,
-  SUBAGENT_CC_ANCHOR,
 } from "./lib/mimicry/system-prompt.mjs";
-import { buildAdapterTransport, resolveAdapterEnv } from "./lib/mimicry/adapter-input.mjs";
-import { buildWireCompatibleRequest, buildWireCompatibleCountTokensRequest } from "./lib/mimicry/wire-compat.mjs";
 import {
+  ADAPTER_COUNT_TOKENS_PATHNAMES,
+  ADAPTER_MESSAGES_PATHNAMES,
+  assertAdapterBodyUsable,
+  buildAdapterTransport,
+  resolveAdapterEnv,
+} from "./lib/mimicry/adapter-input.mjs";
+import { buildPassthroughHeaders, stripNonApiBodyFields } from "./lib/passthrough-headers.mjs";
+import {
+  buildWireCompatibleRequest,
+  buildWireCompatibleCountTokensRequest,
+  WIRE_PROFILE,
   hasOneMillionContext,
-  isEligibleFor1MContext,
+  isEligibleFor1MContextWire,
   isOpus46Model,
   isOpus47Model,
   isOpus48Model,
-} from "./lib/mimicry/models.mjs";
+} from "./lib/mimicry/wire-compat.mjs";
 
-export { isFable5Model, isMythos5Model, isAdaptiveThinkingModel } from "./lib/mimicry/models.mjs";
+export { isFable5Model, isMythos5Model, isAdaptiveThinkingModel } from "./lib/mimicry/wire-compat.mjs";
 
 // Max times a single logical request may fall back from fast->standard speed on
 // the same account before giving up the fast attempt entirely. 1 is enough: one
@@ -298,18 +303,6 @@ export async function AnthropicAuthPlugin({ client }) {
   let willowLastSuggestionTime = 0;
   let _lastOAuthPruneTime = 0; // QA fix L-oauthPrune: throttle for periodic prune
 
-  // Beta header latching: once a beta is sent in a session, it stays on for
-  // the rest of the session to prevent cache key churn (~50-70K tokens per flip).
-  // Cleared on /clear or /compact if needed.
-  const betaLatchState = {
-    /** @type {Set<string>} betas that have been sent at least once this session */
-    sent: new Set(),
-    /** When true, a config change invalidated the latch and next request rebuilds. */
-    dirty: false,
-    /** @type {string | null} The last computed beta header string (for latching). */
-    lastHeader: null,
-  };
-
   // F4: Session-level latch for rejected custom betas.
   // When a custom beta triggers a 400/anthropic-beta or 413-with-signal rejection,
   // its canonical name is stored here so subsequent requests within
@@ -1240,8 +1233,6 @@ export async function AnthropicAuthPlugin({ client }) {
           te.token_efficient_tools = enabled;
           saveConfig({ token_economy: te });
           config.token_economy = te;
-          // Invalidate latched betas so the change takes effect next request
-          betaLatchState.dirty = true;
         },
         "redact-thinking": () => {
           const enabled = value === "on" || value === "true" || value === "1";
@@ -1251,7 +1242,6 @@ export async function AnthropicAuthPlugin({ client }) {
           te.redact_thinking = enabled;
           saveConfig({ token_economy: te });
           config.token_economy = te;
-          betaLatchState.dirty = true;
         },
         "tool-deferral": () => {
           const enabled = value === "on" || value === "true" || value === "1";
@@ -1439,7 +1429,7 @@ export async function AnthropicAuthPlugin({ client }) {
        */
       async function getFilesAuth(acct) {
         let tok = acct.access;
-        if (!tok || !acct.expires || acct.expires < Date.now()) {
+        if (!tok || isTokenExpired(acct.expires)) {
           tok = await refreshAccountTokenSingleFlight(acct);
         }
         return {
@@ -2215,7 +2205,9 @@ export async function AnthropicAuthPlugin({ client }) {
     return config.account_selection_strategy;
   }
 
-  let claudeCliVersion = FALLBACK_CLAUDE_CLI_VERSION;
+  // Baseline CLI version, read from the wire package's profile through the
+  // adapter seam. `fetchLatestClaudeCodeVersion` may raise it at runtime.
+  let claudeCliVersion = WIRE_PROFILE.cliVersion;
   const signatureSessionId = randomUUID();
   const signatureUserId = getOrCreateDeviceId();
   if (shouldFetchClaudeCodeVersion) {
@@ -2297,7 +2289,7 @@ export async function AnthropicAuthPlugin({ client }) {
           // Ignore idle failure here; foreground path handles refresh decisions.
         }
 
-        if (account.access && account.expires && account.expires > Date.now()) {
+        if (account.access && isTokenUsable(account.expires)) {
           return account.access;
         }
       } else {
@@ -2410,7 +2402,7 @@ export async function AnthropicAuthPlugin({ client }) {
     const excluded = new Set([activeAccount.index]);
     const candidates = accountManager
       .getEnabledAccounts(excluded)
-      .filter((acc) => !acc.expires || acc.expires <= now + getIdleRefreshWindowMs())
+      .filter((acc) => isTokenExpired(acc.expires, getIdleRefreshWindowMs(), now))
       .filter((acc) => {
         const last = idleRefreshLastAttempt.get(acc.id) ?? 0;
         return now - last >= getIdleRefreshMinIntervalMs();
@@ -2577,7 +2569,26 @@ export async function AnthropicAuthPlugin({ client }) {
 
               // Transform URL once (shared across retries)
               const requestInit = init ?? {};
-              const { requestInput, requestUrl } = transformRequestUrl(input);
+              // The emulation flag decides whether the URL may be reshaped at
+              // all (`?beta=true`, `/messages` -> `/v1/messages`). Read here,
+              // live, because `/anthropic set` can flip it between requests.
+              const { requestInput, requestUrl } = transformRequestUrl(input, getSignatureEmulationEnabled());
+
+              // A host may hand us a `Request` carrying the body, with the init
+              // empty — `fetchFn(new Request(url, {body}), {})`. Every body-aware
+              // stage downstream (`_parsedBodyOnce`, `transformRequestBody`, the
+              // adapter, the retry-loop rewrites) reads `requestInit.body` and
+              // would silently see nothing, so the body is lifted onto the init
+              // once, here. `clone()` keeps the original Request readable, which
+              // matters because `requestInput` is still what gets sent when no
+              // adapter URL is adopted.
+              if (requestInit.body == null && input instanceof Request && input.body != null) {
+                try {
+                  requestInit.body = await input.clone().text();
+                } catch (error) {
+                  debugLog(`could not read the body off the host Request: ${error.message}`);
+                }
+              }
               const requestMethod = String(
                 requestInit.method || (requestInput instanceof Request ? requestInput.method : "POST"),
               ).toUpperCase();
@@ -2732,7 +2743,7 @@ export async function AnthropicAuthPlugin({ client }) {
                 let accessToken;
                 // Per-account token refresh
                 // Refresh 5 minutes before expiry to avoid mid-request token expiration (RE doc §1.10)
-                if (!account.access || !account.expires || account.expires < Date.now() + 300_000) {
+                if (!account.access || isTokenExpired(account.expires, FOREGROUND_REFRESH_EXPIRY_BUFFER_MS)) {
                   const attemptedRefreshToken = account.refreshToken;
                   try {
                     accessToken = await refreshAccountTokenSingleFlight(account);
@@ -2892,14 +2903,12 @@ export async function AnthropicAuthPlugin({ client }) {
                 const _baseTE = config.token_economy || {};
                 const _tokenEconomy = { ..._baseTE, __requestRole: _requestRole };
 
-                // Microcompact: inject clear betas at high context utilization
-                let _microcompactBetas = null;
+                // Microcompact: track high context utilization (state + toast only)
                 if (requestInit.body) {
                   const estimatedTokens = _parsedBodyOnce
                     ? estimatePromptTokensFromParsed(_parsedBodyOnce)
                     : estimatePromptTokens(requestInit.body);
                   if (shouldMicrocompact(estimatedTokens, config)) {
-                    _microcompactBetas = buildMicrocompactBetas();
                     if (!microcompactState.active) {
                       microcompactState.active = true;
                       microcompactState.lastActivatedTurn = sessionMetrics.turns;
@@ -2928,68 +2937,53 @@ export async function AnthropicAuthPlugin({ client }) {
                       }
                       return false;
                     });
-                let computedBetaHeader = buildAnthropicBetaHeader(
-                  "",
-                  getSignatureEmulationEnabled(),
-                  _reqModel,
-                  _sessionFilteredCustomBetas,
-                  getEffectiveStrategy(),
-                  requestUrl?.pathname,
-                  _reqHasFileRefs,
-                  _adaptiveOverride,
-                  _tokenEconomy,
-                  _microcompactBetas, // NEW
-                );
-
-                // Beta header latching: once a beta has been sent in this session,
-                // keep sending it to avoid server-side cache key churn (~50-70K tokens
-                // per flip). The latch is sticky-on: new betas can be added but never
-                // removed mid-session unless explicitly invalidated by config change.
-                {
-                  const currentBetas = computedBetaHeader
-                    .split(",")
-                    .map((b) => b.trim())
-                    .filter(Boolean);
-                  // Add all current betas to the latch set
-                  for (const b of currentBetas) betaLatchState.sent.add(b);
-                  // If a config change dirtied the latch, rebuild from current (allow removal)
-                  if (betaLatchState.dirty) {
-                    betaLatchState.dirty = false;
-                    betaLatchState.sent = new Set(currentBetas);
-                  }
-                  // Merge latched betas that aren't in the current set
-                  const merged = new Set(currentBetas);
-                  for (const b of betaLatchState.sent) merged.add(b);
-                  // Custom-beta strip kill switch: when the server rejected our custom
-                  // betas (customBetasStripped latch fired), evict them from the latch so
-                  // they do not re-appear on the retry attempt.
-                  // F1: delete both the raw alias AND the canonical form so that aliases
-                  // like "cache-diag" (cache-diagnosis-2026-04-07) are fully evicted.
-                  if (customBetasStripped && config.custom_betas?.length) {
-                    for (const b of config.custom_betas) {
-                      const canonical = resolveBetaShortcut(b);
-                      merged.delete(b);
-                      merged.delete(canonical);
-                      betaLatchState.sent.delete(b);
-                      betaLatchState.sent.delete(canonical);
-                    }
-                  }
-                  // F4: Evict session-rejected betas from the latch on every request so
-                  // they cannot re-enter the sent set from a prior latched header.
-                  if (sessionRejectedBetas.size > 0) {
-                    const _now = Date.now();
-                    for (const [_canonical, _rejectedAt] of sessionRejectedBetas) {
-                      if (_now - _rejectedAt <= SESSION_REJECTED_BETA_TTL_MS) {
-                        merged.delete(_canonical);
-                        betaLatchState.sent.delete(_canonical);
-                      } else {
-                        sessionRejectedBetas.delete(_canonical);
-                      }
-                    }
-                  }
-                  computedBetaHeader = [...merged].join(",");
-                  betaLatchState.lastHeader = computedBetaHeader;
-                }
+                // PHASE 2.2.3 — THE BETA LATCH IS GONE. It used to merge every
+                // beta ever sent this session back into this value, to avoid
+                // server-side cache-key churn from a beta flipping mid-session.
+                // It was INERT on both live paths: `buildRequestHeaders`
+                // recomputes its own `mergedBetas` from the incoming header, and
+                // the adapter has the package compose the list from
+                // `customBetas`. Neither ever read the latched value, so the only
+                // thing it reached was the `task-budgets-2026-03-13` check in
+                // `transformRequestBody` below.
+                //
+                // The two evictions the latch carried are not lost: both act on
+                // `_sessionFilteredCustomBetas` above, BEFORE the header is
+                // composed — `customBetasStripped` empties the custom set, and
+                // `sessionRejectedBetas` filters the individual betas the API
+                // rejected. That is the mechanism that actually reaches the wire.
+                //
+                // PHASE 4.1 — THE LEGACY BETA FORGE IS GONE FROM THIS PATH. The
+                // whole ~12-param `buildAnthropicBetaHeader` call used to live
+                // here for ONE consumer: `transformRequestBody` tested the
+                // resulting header string for `task-budgets-2026-03-13` to decide
+                // whether to preserve or inject `output_config`
+                // (lib/mimicry/request-body.mjs). Nothing else read it — the
+                // outgoing `anthropic-beta` header is composed by the shared
+                // package on every adapter turn and recomputed from scratch by
+                // `buildRequestHeaders` on every legacy one.
+                //
+                // It is now a BOOLEAN, derived here from the same gates the
+                // adapter path applies to a custom beta. This MIRRORS
+                // `buildAdditionalBetas` in lib/mimicry/adapter-input.mjs — keep
+                // the two in step:
+                //  (a) signature emulation off ⇒ the plugin forges no Claude Code
+                //      fingerprint at all, so no custom beta reaches the wire;
+                //  (b) `_sessionFilteredCustomBetas` is the same list the adapter
+                //      is handed as `customBetas` (already `customBetasStripped`-
+                //      emptied and `sessionRejectedBetas`-filtered above), and the
+                //      adapter shortcut-expands each entry through
+                //      `BETA_SHORTCUTS` — `resolveBetaShortcut` is that expansion;
+                //  (c) `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS` drops every member
+                //      of `EXPERIMENTAL_BETA_FLAGS` from the composed list
+                //      (adapter-input.mjs:490), and `task-budgets-2026-03-13` is a
+                //      member (lib/betas.mjs) — so the flag suppresses it.
+                // There is no pathname gate to mirror: `transformRequestBody` only
+                // runs on the adapter path, i.e. a messages endpoint.
+                const _taskBudgetsActive =
+                  getSignatureEmulationEnabled() &&
+                  !isTruthyEnv(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS) &&
+                  _sessionFilteredCustomBetas.some((b) => resolveBetaShortcut(b) === "task-budgets-2026-03-13");
 
                 // Cache TTL session latching: latch the cache policy at session start
                 // so mid-session toggles don't bust the server-side prompt cache.
@@ -3003,81 +2997,98 @@ export async function AnthropicAuthPlugin({ client }) {
                   config.cache_policy || { ttl: "1h", ttl_supported: true };
 
                 // Single decision point for the whole request: does this turn go
-                // through the shared wire package, or through the legacy
-                // buildRequestHeaders path?
+                // through the shared wire package?
                 //
-                // Two conditions remain now that multi-provider support is gone:
-                //  1. signature emulation on — with it off the plugin emits only
-                //     3 headers and a minimal beta set, while the package always
-                //     emits the full Claude Code set;
-                //  2. a messages endpoint the package has a surface for. Both
-                //     qualify now: `buildClaudeCodeRequest` for /v1/messages and
+                // PHASE 2.2 — THE ADAPTER IS UNCONDITIONAL. Two conditions, and
+                // neither of them is about the body any more:
+                //  1. signature emulation on — with it off the plugin does not
+                //     forge a Claude Code fingerprint at all, so there is
+                //     nothing for the package to build;
+                //  2. a messages endpoint the package has a surface for:
+                //     `buildClaudeCodeRequest` for /v1/messages and
                 //     `buildClaudeCodeCountTokensRequest` for
                 //     /v1/messages/count_tokens, each pinning its OWN endpoint.
-                //     The endpoint pin is inert either way — `built.url` is never
-                //     adopted (see the consumption comment below), so the URL on
-                //     the wire stays the one transformRequestUrl produced and a
-                //     custom ANTHROPIC_BASE_URL survives.
                 //
                 // The former first-party check is now structural: the plugin only
                 // speaks to first-party Anthropic, so it is always satisfied.
-                //  3. a JSON body is actually present. The main-turn surface
-                //     requires `model` and `max_tokens`; the count surface
-                //     requires `model` and `messages` and accepts no
-                //     `max_tokens` at all. Either way a bodiless request must
-                //     keep using the legacy path rather than throwing
-                //     INVALID_INPUT.
+                //
+                // THE BODY IS NO LONGER A ROUTING INPUT. It used to be: a
+                // bodiless or unparsable body silently fell back to the legacy
+                // forge, which put a REQUEST WITH A DIFFERENT FINGERPRINT on the
+                // wire mid-session. That dual path is what this phase removes.
+                // A body the package cannot consume is now a hard error
+                // (`assertAdapterBodyUsable`), never a quiet downgrade.
+                // Endpoints outside the set above still pass through untouched.
                 const _adapterPathname = requestUrl?.pathname;
-                const _isCountTokens =
-                  _adapterPathname === "/v1/messages/count_tokens" || _adapterPathname === "/messages/count_tokens";
+                const _isCountTokens = ADAPTER_COUNT_TOKENS_PATHNAMES.has(_adapterPathname);
+                // Read ONCE per attempt. The config is runtime-mutable
+                // (`/anthropic set`), and a flip between the routing decision,
+                // the body transform and the header construction would emit a
+                // half-emulated request.
+                const _emulationEnabled = getSignatureEmulationEnabled();
                 const _useAdapter =
-                  getSignatureEmulationEnabled() &&
-                  (_adapterPathname === "/v1/messages" || _adapterPathname === "/messages" || _isCountTokens) &&
-                  typeof requestInit.body === "string" &&
-                  requestInit.body.length > 0;
+                  _emulationEnabled && (ADAPTER_MESSAGES_PATHNAMES.has(_adapterPathname) || _isCountTokens);
+                if (_useAdapter) {
+                  // Validated against the INCOMING body, before transformRequestBody
+                  // gets a chance to normalize it: the diagnostic has to name what
+                  // the host actually sent. `_parsedBodyOnce` is not usable as the
+                  // signal — the retry paths below null it out after rewriting a
+                  // perfectly valid body.
+                  assertAdapterBodyUsable(requestInit.body, _adapterPathname);
+                }
 
-                const body = transformRequestBody(
-                  requestInit.body,
-                  {
-                    enabled: getSignatureEmulationEnabled(),
-                    claudeCliVersion,
-                    promptCompactionMode: getPromptCompactionMode(),
-                    useAdapter: _useAdapter,
-                    cachePolicy: effectiveCachePolicy,
-                    fastMode: config.fast_mode || false,
-                    // When the account's fast pool is cooling down, suppress
-                    // speed:"fast" so this turn runs at standard speed on the same
-                    // account instead of re-hitting the exhausted fast pool.
-                    fastRateLimited: accountManager.isFastRateLimited(account),
-                    strategy: getEffectiveStrategy(),
-                    toolDeferral: config.token_economy_strategies?.tool_deferral,
-                    toolDescriptionCompaction: config.token_economy_strategies?.tool_description_compaction,
-                    adaptiveToolSet: config.token_economy_strategies?.adaptive_tool_set,
-                    systemPromptTailing: config.token_economy_strategies?.system_prompt_tailing,
-                    systemPromptTailTurns: config.token_economy_strategies?.system_prompt_tail_turns,
-                    systemPromptTailMaxChars: config.token_economy_strategies?.system_prompt_tail_max_chars,
-                  },
-                  {
-                    persistentUserId: signatureUserId,
-                    sessionId: signatureSessionId,
-                    accountId: getAccountIdentifier(account),
-                    turns: sessionMetrics.turns,
-                    usedTools: sessionMetrics.usedTools,
-                    tokenEconomySession,
-                    requestRole: _requestRole,
-                    isSubagent: _isSubagent,
-                    // Adaptive cache-breakpoint placement: pass the per-boundary
-                    // stability snapshot so transformRequestBody can anchor the
-                    // cache_control marker on the most-stable boundary instead of
-                    // the (possibly thrashing) last tool. Only populated once the
-                    // detector is enabled and has a baseline.
-                    cacheBoundaryStability: config.cache_break_detection?.adaptive_breakpoint
-                      ? cacheBreakState.boundaryStability
-                      : null,
-                  },
-                  computedBetaHeader,
-                  config,
-                );
+                // PHASE 2.2 — EMULATION OFF DOES NOT TRANSFORM THE BODY AT ALL.
+                // `transformRequestBody` used to run on every request and apply
+                // its non-gated structural normalizations (output cap, thinking,
+                // effort -> output_config, system sanitize/compact) even with
+                // emulation off. That is policy the host never asked for. The
+                // only exceptions are the fields the first-party API rejects
+                // outright (`betas`, the stainless-helper markers) — see
+                // stripNonApiBodyFields.
+                const body = !_emulationEnabled
+                  ? stripNonApiBodyFields(requestInit.body)
+                  : transformRequestBody(
+                      requestInit.body,
+                      {
+                        enabled: _emulationEnabled,
+                        claudeCliVersion,
+                        promptCompactionMode: getPromptCompactionMode(),
+                        useAdapter: _useAdapter,
+                        cachePolicy: effectiveCachePolicy,
+                        fastMode: config.fast_mode || false,
+                        // When the account's fast pool is cooling down, suppress
+                        // speed:"fast" so this turn runs at standard speed on the same
+                        // account instead of re-hitting the exhausted fast pool.
+                        fastRateLimited: accountManager.isFastRateLimited(account),
+                        strategy: getEffectiveStrategy(),
+                        toolDeferral: config.token_economy_strategies?.tool_deferral,
+                        toolDescriptionCompaction: config.token_economy_strategies?.tool_description_compaction,
+                        adaptiveToolSet: config.token_economy_strategies?.adaptive_tool_set,
+                        systemPromptTailing: config.token_economy_strategies?.system_prompt_tailing,
+                        systemPromptTailTurns: config.token_economy_strategies?.system_prompt_tail_turns,
+                        systemPromptTailMaxChars: config.token_economy_strategies?.system_prompt_tail_max_chars,
+                      },
+                      {
+                        persistentUserId: signatureUserId,
+                        sessionId: signatureSessionId,
+                        accountId: getAccountIdentifier(account),
+                        turns: sessionMetrics.turns,
+                        usedTools: sessionMetrics.usedTools,
+                        tokenEconomySession,
+                        requestRole: _requestRole,
+                        isSubagent: _isSubagent,
+                        // Adaptive cache-breakpoint placement: pass the per-boundary
+                        // stability snapshot so transformRequestBody can anchor the
+                        // cache_control marker on the most-stable boundary instead of
+                        // the (possibly thrashing) last tool. Only populated once the
+                        // detector is enabled and has a baseline.
+                        cacheBoundaryStability: config.cache_break_detection?.adaptive_breakpoint
+                          ? cacheBreakState.boundaryStability
+                          : null,
+                      },
+                      _taskBudgetsActive,
+                      config,
+                    );
                 logTransformedSystemPrompt(body);
 
                 // Toast on first fast-mode application in session (reset on toggle)
@@ -3119,13 +3130,27 @@ export async function AnthropicAuthPlugin({ client }) {
                 // body that deliberately carries NO system, metadata or
                 // max_tokens. Legacy path: unchanged, byte for byte.
                 //
-                // The URL deliberately stays whatever transformRequestUrl already
-                // produced. `built.url` is the package's pinned endpoint
+                // The URL is assembled from BOTH sources: origin from the host,
+                // path and query from the package. `built.url` is the pinned
+                // endpoint the headers and body were composed for
                 // (`https://api.anthropic.com/v1/messages?beta=true`, or
                 // `.../v1/messages/count_tokens?beta=true` on the count surface),
-                // which would override a custom ANTHROPIC_BASE_URL or proxy
-                // endpoint. transformRequestUrl already appends `?beta=true` to
-                // both endpoints itself, so discarding `built.url` costs nothing.
+                // so the package stays the owner of the envelope — canonical path
+                // plus `?beta=true` — and cannot drift from the body it built.
+                // The ORIGIN, though, belongs to whoever the host addressed: a
+                // custom provider baseURL (gateway, LiteLLM, corporate proxy)
+                // arrives on `requestUrl`, and so does OPENCODE_MITM_BASE_URL,
+                // which transformRequestUrl already applied. Taking the package's
+                // origin as well would silently redirect those deployments to
+                // api.anthropic.com.
+                //
+                // No gateway path PREFIX can be lost this way: the `_useAdapter`
+                // gate only admits pathnames in {/v1/messages, /messages,
+                // /v1/messages/count_tokens, /messages/count_tokens}, so a
+                // prefixed endpoint never reaches the adapter in the first place.
+                //
+                // transformRequestUrl still owns the URL outright on the legacy /
+                // emulation-off path.
                 const _adapterSignature = {
                   enabled: getSignatureEmulationEnabled(),
                   claudeCliVersion,
@@ -3136,6 +3161,7 @@ export async function AnthropicAuthPlugin({ client }) {
 
                 let requestHeaders;
                 let adapterBody;
+                let adapterRequestInput;
                 let legacyStrippedBody;
                 if (_useAdapter) {
                   const _adapterResult = buildAdapterTransport({
@@ -3181,14 +3207,61 @@ export async function AnthropicAuthPlugin({ client }) {
                       : await buildWireCompatibleRequest(body, _adapterResult.transport);
                     requestHeaders = built.headers;
                     adapterBody = built.body;
+                    try {
+                      // Origin from the HOST, path+query from the PACKAGE.
+                      // `requestUrl` already carries the provider's configured
+                      // baseURL and already had OPENCODE_MITM_BASE_URL applied by
+                      // transformRequestUrl, so copying its origin is what keeps a
+                      // gateway / LiteLLM / proxy deployment reachable. With no
+                      // usable `requestUrl` the package's own origin stands.
+                      const _adapterUrl = new URL(built.url);
+                      if (requestUrl) {
+                        _adapterUrl.protocol = requestUrl.protocol;
+                        _adapterUrl.hostname = requestUrl.hostname;
+                        _adapterUrl.port = requestUrl.port;
+                      }
+                      adapterRequestInput =
+                        input instanceof Request ? new Request(_adapterUrl.toString(), input) : _adapterUrl;
+                    } catch (error) {
+                      // Unparsable package URL — fall back to the transformed URL.
+                      debugLog(`adapter url adoption skipped (${error.message}); keeping the transformed url`);
+                    }
                   } else {
-                    debugLog(`adapter not applicable (${_adapterResult.reason}); using the legacy request path`);
+                    // Unreachable by construction, and it must STAY unreachable:
+                    // `buildAdapterTransport` declines on exactly two conditions,
+                    // a non-anthropic provider and signature emulation off, and
+                    // the call site above pins `provider: "anthropic"` while
+                    // `_useAdapter` already required emulation on. Falling back to
+                    // the legacy forge here would silently restore the dual path
+                    // Phase 2.2 removed, so a decline is an error instead.
+                    throw new Error(
+                      `opencode-anthropic-fix: the Claude Code wire adapter declined a request it must handle ` +
+                        `(${_adapterResult.reason}) on ${_adapterPathname}. This is a plugin bug — ` +
+                        `the legacy request path is no longer reachable with signature emulation on.`,
+                    );
                   }
                 }
 
+                if (!requestHeaders && !_emulationEnabled) {
+                  // PHASE 2.2 — EMULATION OFF IS PURE PASSTHROUGH PLUS THE AUTH
+                  // ENVELOPE. No mimicry function composes these headers: the
+                  // host's set goes out as it arrived, minus the two credentials
+                  // that must not travel with our bearer, plus `authorization`
+                  // and an ADDITIVE `oauth-2025-04-20`. The forged claude-cli
+                  // user-agent and the substituted beta list — the two mimicry
+                  // vectors that used to survive with emulation off — are gone.
+                  // See lib/passthrough-headers.mjs for why the envelope is not
+                  // mimicry.
+                  requestHeaders = buildPassthroughHeaders(input, requestInit, accessToken);
+                }
+
                 if (!requestHeaders) {
-                  // Legacy path, and the fallback whenever the adapter declined:
-                  // a bodiless request, or a transport the translation refused.
+                  // Emulation ON, on an endpoint the package has no surface for
+                  // (files, models, a gateway-prefixed route). Unchanged, and the
+                  // only caller of the legacy forge left: on a messages or
+                  // count_tokens turn the adapter above always produced headers,
+                  // which `test/conformance/adapter-unconditional.test.mjs`
+                  // observes directly.
                   requestHeaders = buildRequestHeaders(
                     input,
                     requestInit,
@@ -3273,7 +3346,7 @@ export async function AnthropicAuthPlugin({ client }) {
                       debugLog("failed to write outgoing request headers to debug-headers.log", e);
                     }
                   }
-                  response = await fetch(requestInput, {
+                  response = await fetch(adapterRequestInput ?? requestInput, {
                     ...requestInit,
                     body: finalBody,
                     headers: requestHeaders,
@@ -4457,7 +4530,7 @@ export async function AnthropicAuthPlugin({ client }) {
 
       const getAccessToken = async () => {
         let tok = account.access;
-        if (!tok || !account.expires || account.expires < Date.now()) {
+        if (!tok || isTokenExpired(account.expires)) {
           tok = await refreshAccountTokenSingleFlight(account);
         }
         if (!tok) throw new Error("no access token available for Haiku call");
@@ -5172,7 +5245,7 @@ function resolveAdaptiveContext(bodyString, model, adaptiveConfig, parsedBody) {
   }
 
   // Model must be eligible for 1M context at all (includes Opus 4.6)
-  if (!isEligibleFor1MContext(model)) {
+  if (!isEligibleFor1MContextWire(model)) {
     return false;
   }
 
@@ -5423,6 +5496,12 @@ function writeCacheStatsFile(usage, model, hitRate) {
 
 // --- Phase 5: Minimal telemetry emulation ("Silent Observer") ---
 
+// Host telemetry payload only (ClaudeCodeInternalEvent env block) — never sent
+// on /v1/messages, so it is not part of the wire-compat surface.
+// Real build markers extracted from the 2.1.195 native binary (Bun-embedded JS):
+// `BUILD_TIME:"2026-06-26T01:00:56Z"`.
+const CLAUDE_CODE_BUILD_TIME = "2026-06-26T01:00:56Z";
+
 class TelemetryEmitter {
   #enabled = false;
   #sent = false;
@@ -5828,9 +5907,10 @@ function getAccountIdentifier(account) {
  * @param {{ use1MContext?: boolean }} [adaptiveOverride] - When set, overrides the static hasOneMillionContext() check.
  * @param {boolean} [fastModeActive] - When true, emits FAST_MODE_BETA_FLAG (fast-mode-2026-02-01).
  *   Must be derived structurally from the already-transformed outgoing body (body.includes('"speed":"fast"')).
- *   Only passed from the buildRequestHeaders call site (after body transform). The pre-transform
- *   computedBetaHeader call site (index.mjs:2905) leaves this undefined so the latch never
- *   accumulates fast-mode independently of actual body content.
+ *   Only passed from the buildRequestHeaders call site (after body transform), which is now the
+ *   ONLY call site: the pre-transform `computedBetaHeader` caller was deleted in Phase 4.1. Its
+ *   sole consumer, the `task-budgets-2026-03-13` check in transformRequestBody, takes a derived
+ *   boolean instead (see `_taskBudgetsActive` in the interceptor).
  * @returns {string}
  */
 // Mirrors CC's Kw(model) effort eligibility: returns false for claude-3-* and the
@@ -5865,6 +5945,9 @@ function getAccountIdentifier(account) {
  * @returns {string}
  */
 
+// Host update polling only (npm registry lookup), not mimicry.
+const CLAUDE_CODE_NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
+
 /**
  * Resolve latest claude-code package version from npm registry.
  * Returns null on timeout/network/parse failures.
@@ -5915,13 +5998,20 @@ async function fetchLatestClaudeCodeVersion(timeoutMs = 1200) {
  */
 
 /**
- * Transform the request URL: add ?beta=true to /v1/messages and /v1/messages/count_tokens.
- * Preserves behaviors F1-F3.
+ * Transform the request URL: add ?beta=true to /v1/messages and
+ * /v1/messages/count_tokens, normalizing a `/messages` path to `/v1/messages`
+ * on the way. Preserves behaviors F1-F3.
+ *
+ * Both of those are CLAUDE CODE SHAPE, so both are gated on `emulateSignature`.
+ * The `OPENCODE_MITM_BASE_URL` rewrite is not, and applies either way.
  *
  * @param {any} input
+ * @param {boolean} [emulateSignature] Whether signature emulation is on for this
+ *   request. Read at the call site rather than here: the config is
+ *   runtime-mutable and this function lives outside the plugin closure.
  * @returns {{requestInput: any, requestUrl: URL | null}}
  */
-function transformRequestUrl(input) {
+function transformRequestUrl(input, emulateSignature = true) {
   let requestInput = input;
   let requestUrl = null;
   try {
@@ -5934,7 +6024,14 @@ function transformRequestUrl(input) {
     requestUrl = null;
   }
 
-  if (requestUrl && !requestUrl.searchParams.has("beta")) {
+  // PHASE 2.2 (QA finding 1) — THE URL REWRITE IS MIMICRY, SO IT IS GATED.
+  // `?beta=true` is the endpoint the genuine Claude Code client pins, and
+  // normalizing `/messages` to `/v1/messages` is the same kind of client-shape
+  // assumption. With signature emulation off the plugin forges nothing, and
+  // that has to include the URL: the host's URL goes out exactly as the host
+  // wrote it. The MITM rewrite below stays unconditional — it is a debug and
+  // conformance knob the operator asked for, not a disguise.
+  if (emulateSignature && requestUrl && !requestUrl.searchParams.has("beta")) {
     const p = requestUrl.pathname;
     // SDK may send to /messages (base URL includes /v1) or /v1/messages (base URL is root)
     const isMessages =
@@ -6076,7 +6173,7 @@ function applyDiskAuthIfFresher(account, diskAuth, options = {}) {
   const diskTokenUpdatedAt = diskAuth.tokenUpdatedAt || 0;
   const memTokenUpdatedAt = account.tokenUpdatedAt || 0;
   const diskHasDifferentAuth = diskAuth.refreshToken !== account.refreshToken || diskAuth.access !== account.access;
-  const memAuthExpired = !account.expires || account.expires <= Date.now();
+  const memAuthExpired = isTokenExpired(account.expires);
   const allowExpiredFallback = options.allowExpiredFallback === true;
   if (diskTokenUpdatedAt <= memTokenUpdatedAt && !(allowExpiredFallback && diskHasDifferentAuth && memAuthExpired)) {
     return false;
@@ -6112,7 +6209,7 @@ async function refreshAccountToken(account, client, _source = "foreground", { on
     // Accept CC credential if:
     //   - expiresAt is in the future (normal case), OR
     //   - expiresAt is 0/missing (CC didn't provide expiry — trust the token, let API 401 if stale)
-    if (match && (match.expiresAt === 0 || match.expiresAt > Date.now())) {
+    if (match && (match.expiresAt === 0 || isTokenUsable(match.expiresAt))) {
       account.access = match.accessToken;
       account.expires = match.expiresAt || Date.now() + 3600_000; // default 1h if unknown
       markTokenStateUpdated(account);
@@ -6148,7 +6245,7 @@ async function refreshAccountToken(account, client, _source = "foreground", { on
   if (!lock.acquired) {
     const diskAuth = await readDiskAccountAuth(account.id);
     const adopted = applyDiskAuthIfFresher(account, diskAuth, { allowExpiredFallback: true });
-    if (adopted && account.access && account.expires && account.expires > Date.now()) {
+    if (adopted && account.access && isTokenUsable(account.expires)) {
       return account.access;
     }
     throw new Error("Refresh lock busy");
@@ -6159,14 +6256,21 @@ async function refreshAccountToken(account, client, _source = "foreground", { on
     const adopted = applyDiskAuthIfFresher(account, diskAuthBeforeRefresh);
     // Apply fresher disk tokens for both foreground and idle paths — prevents an
     // unnecessary HTTP refresh when another process already rotated the token.
-    if (adopted && account.access && account.expires && account.expires > Date.now()) {
+    if (adopted && account.access && isTokenUsable(account.expires)) {
       return account.access;
     }
 
-    const json = await refreshToken(account.refreshToken, { signal: AbortSignal.timeout(15_000) });
+    // `clientId` is undefined for every normal account, which means "use the
+    // default". Only a CLAUDE_CODE_OAUTH_CLIENT_ID-seeded env account carries one
+    // (contract §5.2, divergence D10).
+    const json = await refreshToken(account.refreshToken, {
+      signal: AbortSignal.timeout(15_000),
+      clientId: account.clientId,
+    });
 
     account.access = json.access_token;
     account.expires = Date.now() + json.expires_in * 1000;
+    warnOnEphemeralTokenRotation(account, json.refresh_token);
     if (json.refresh_token) {
       account.refreshToken = json.refresh_token;
     }
@@ -6294,13 +6398,6 @@ AnthropicAuthPlugin.__testing__ = {
   maybeApplySessionToolResultDedupe,
   // exposed for experimental.session.summarize integration tests
   runHaikuSessionSummarize,
-  get cachedCCPrompt() {
-    return getCachedCCPrompt();
-  },
-  resetCachedCCPrompt() {
-    resetCachedCCPrompt();
-  },
-  SUBAGENT_CC_ANCHOR,
   CLAUDE_CODE_IDENTITY_STRING,
   /** Test-only: drive the session turn counter so code paths gated on
    *  `sessionMetrics.turns >= N` can be exercised without a real SSE stream. */