opencode-anthropic-fix 0.1.14 → 0.1.18

package/index.mjs

@@ -7,6 +7,7 @@ import xxhashInit from "xxhash-wasm";
 import { AccountManager } from "./lib/accounts.mjs";
 import { authorize as oauthAuthorize, exchange as oauthExchange, refreshToken } from "./lib/oauth.mjs";
 import { loadConfig, loadConfigFresh, saveConfig, CLIENT_ID, getConfigDir } from "./lib/config.mjs";
+import { loadContextHintDisabledFlag, saveContextHintDisabledFlag } from "./lib/context-hint-persist.mjs";
 import { loadAccounts, saveAccounts, clearAccounts, createDefaultStats } from "./lib/storage.mjs";
 import { applyOAuthCredentials, resetAccountTracking } from "./lib/account-state.mjs";
 import { acquireRefreshLock, releaseRefreshLock } from "./lib/refresh-lock.mjs";
@@ -192,12 +193,25 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
   //   - 529 / overloaded → disable for session (temporary overload)
   // When disabled, we strip context-hint from betas + body on subsequent requests so
   // we don't keep triggering the same rejection and churning the cache.
+  // Persisted disable: if a prior session saw a 400 rejecting the context-hint
+  // beta (account lacks access), skip the beta from turn 1 of every subsequent
+  // session. Delete ~/.config/opencode/context-hint-disabled.flag (or the
+  // %APPDATA%\opencode equivalent on Windows) to re-enable once access is
+  // granted. See lib/context-hint-persist.mjs.
+  const _persistedCtxHint = loadContextHintDisabledFlag();
   const contextHintState = {
     /** Permanently disabled for this session after a server rejection. */
-    disabled: false,
+    disabled: _persistedCtxHint.disabled === true,
     /** Number of 422/424 compactions applied this session (for telemetry). */
     compactionsApplied: 0,
   };
+  if (contextHintState.disabled) {
+    debugLog(
+      "context-hint: loaded persisted disable flag",
+      _persistedCtxHint.status ? `status=${_persistedCtxHint.status}` : "",
+      _persistedCtxHint.timestamp ? `ts=${new Date(_persistedCtxHint.timestamp).toISOString()}` : "",
+    );
+  }
 
   // Token economy — session state for layered compaction strategies.
   const tokenEconomySession = {
@@ -2364,7 +2378,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
             if (
               config.override_model_limits.enabled &&
               !isTruthyEnv(process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT) &&
-              (hasOneMillionContext(model.id) || isOpus46Model(model.id))
+              (hasOneMillionContext(model.id) || isOpus46Model(model.id) || isOpus47Model(model.id))
             ) {
               model.limit = {
                 ...(model.limit ?? {}),
@@ -2902,6 +2916,33 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                 // v2.1.107: cch attestation via xxHash64(body, seed) & 0xFFFFF
                 const finalBody = await computeAndReplaceCCH(body);
 
+                // Opt-in: dump the OUTGOING body (post-cch) so diagnostics reflect
+                // exactly what went on the wire. Previously dumped `body` which
+                // still had the cch=00000 placeholder — that confused debugging.
+                // Rotates at 10 files to cap disk usage. Files live under
+                // ~/.opencode/opencode-anthropic-fix/request-dumps/.
+                if (config.token_economy?.debug_dump_bodies === true && typeof finalBody === "string") {
+                  try {
+                    const fs = await import("node:fs");
+                    const path = await import("node:path");
+                    const os = await import("node:os");
+                    const dir = path.join(os.homedir(), ".opencode", "opencode-anthropic-fix", "request-dumps");
+                    fs.mkdirSync(dir, { recursive: true });
+                    // Rotate: keep last 10
+                    const existing = fs
+                      .readdirSync(dir)
+                      .filter((f) => f.startsWith("req-") && f.endsWith(".json"))
+                      .sort();
+                    while (existing.length >= 10) {
+                      fs.unlinkSync(path.join(dir, existing.shift()));
+                    }
+                    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+                    fs.writeFileSync(path.join(dir, `req-${ts}.json`), finalBody);
+                  } catch {
+                    // Disk full, permissions, whatever — never block the request.
+                  }
+                }
+
                 // Execute the request
                 let response;
                 try {
@@ -3235,15 +3276,31 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     ) {
                       contextHintState.disabled = true;
                       betaLatchState.dirty = true;
-                      debugLog("context-hint: beta rejected by server (400), disabling for session");
+                      // Persist across sessions: a 400 "Unexpected value" on the
+                      // context-hint beta means the account lacks access to the
+                      // beta entirely. Re-attempting next session would burn
+                      // another turn to the same rejection.
+                      saveContextHintDisabledFlag({
+                        reason: "beta_unsupported_400",
+                        status: 400,
+                      });
+                      debugLog("context-hint: beta rejected by server (400), disabling + persisting");
+                      // Retry without the beta. The latch above drops the header
+                      // and the body field on the rebuilt request.
+                      attempt--;
+                      continue;
                     } else if (response.status === 409) {
                       contextHintState.disabled = true;
                       betaLatchState.dirty = true;
                       debugLog("context-hint: 409 conflict, disabling for session");
+                      attempt--;
+                      continue;
                     } else if (response.status === 529 && errorBody && errorBody.includes("context_hint")) {
                       contextHintState.disabled = true;
                       betaLatchState.dirty = true;
                       debugLog("context-hint: 529 overloaded referencing hint, disabling for session");
+                      attempt--;
+                      continue;
                     } else if (
                       (response.status === 422 || response.status === 424) &&
                       !requestInit._contextHintCompactAttempted
@@ -3978,6 +4035,11 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
       }
 
       output.context.push(contextParts.join("\n"));
+
+      // TODO(B3): wire rolling-summarizer once per-session message capture exists
+      // (requires chat.messages.transform accumulator). Module exists at
+      // lib/rolling-summarizer.mjs — call summarize(messages, {haikuCall}) here
+      // behind config.token_economy.rolling_summarizer when messages are available.
     },
   };
 }
@@ -3990,49 +4052,59 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
 /** Module-level config ref for functions outside AnthropicAuthPlugin closure. */
 let _pluginConfig = null;
 
-const sessionMetrics = {
-  turns: 0,
-  totalInput: 0,
-  totalOutput: 0,
-  totalCacheRead: 0,
-  totalCacheWrite: 0,
-  totalWebSearchRequests: 0,
-  recentCacheRates: [], // rolling window of last 5 turns
-  sessionCostUsd: 0,
-  costBreakdown: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-  sessionStartTime: Date.now(),
-  lastQuota: {
-    tokens: 0,
-    requests: 0,
-    inputTokens: 0,
-    updatedAt: 0,
-    // Window-based unified headers from response
-    fiveHour: { utilization: 0, resets_at: null, status: null, surpassedThreshold: null },
-    sevenDay: { utilization: 0, resets_at: null, status: null, surpassedThreshold: null },
-    // Overall/fallback/overage from response headers
-    overallStatus: null,
-    representativeClaim: null,
-    fallback: null,
-    fallbackPercentage: null,
-    overageStatus: null,
-    overageReason: null,
-    // Usage endpoint polling (A6)
-    lastPollAt: 0,
-  },
-  lastStopReason: null, // tracks most recent stop_reason for output cap escalation
-  perModel: {}, // Map<modelId, { input, output, cacheRead, cacheWrite, costUsd, turns }>
-  lastModelId: null,
-  lastRequestBody: null, // Last intercepted request body (JSON string, capped 2MB) for /anthropic context
-  /** Token budget tracking (A9) */
-  tokenBudget: {
-    limit: 0, // 0 = unset
-    used: 0, // accumulated output tokens
-    continuations: 0,
-    outputHistory: [], // last 5 output token deltas
-  },
-  /** Tools used in this session (populated from assistant tool_use blocks in messages) */
-  usedTools: new Set(),
-};
+/**
+ * Factory for the initial sessionMetrics shape. Returns a fresh object each
+ * call so the reset helper (and any future test hook) doesn't alias nested
+ * state (lastQuota, perModel, costBreakdown, tokenBudget, usedTools Set).
+ * Keep this in sync with the type annotation above.
+ */
+function createInitialSessionMetrics() {
+  return {
+    turns: 0,
+    totalInput: 0,
+    totalOutput: 0,
+    totalCacheRead: 0,
+    totalCacheWrite: 0,
+    totalWebSearchRequests: 0,
+    recentCacheRates: [], // rolling window of last 5 turns
+    sessionCostUsd: 0,
+    costBreakdown: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    sessionStartTime: Date.now(),
+    lastQuota: {
+      tokens: 0,
+      requests: 0,
+      inputTokens: 0,
+      updatedAt: 0,
+      // Window-based unified headers from response
+      fiveHour: { utilization: 0, resets_at: null, status: null, surpassedThreshold: null },
+      sevenDay: { utilization: 0, resets_at: null, status: null, surpassedThreshold: null },
+      // Overall/fallback/overage from response headers
+      overallStatus: null,
+      representativeClaim: null,
+      fallback: null,
+      fallbackPercentage: null,
+      overageStatus: null,
+      overageReason: null,
+      // Usage endpoint polling (A6)
+      lastPollAt: 0,
+    },
+    lastStopReason: null, // tracks most recent stop_reason for output cap escalation
+    perModel: {}, // Map<modelId, { input, output, cacheRead, cacheWrite, costUsd, turns }>
+    lastModelId: null,
+    lastRequestBody: null, // Last intercepted request body (JSON string, capped 2MB) for /anthropic context
+    /** Token budget tracking (A9) */
+    tokenBudget: {
+      limit: 0, // 0 = unset
+      used: 0, // accumulated output tokens
+      continuations: 0,
+      outputHistory: [], // last 5 output token deltas
+    },
+    /** Tools used in this session (populated from assistant tool_use blocks in messages) */
+    usedTools: new Set(),
+  };
+}
+
+const sessionMetrics = createInitialSessionMetrics();
 
 // ---------------------------------------------------------------------------
 // Adaptive 1M context state
@@ -5419,6 +5491,174 @@ function applyContextHintCompaction(messages, opts = {}) {
   };
 }
 
+/**
+ * Tools whose output is trivially reproducible by re-running with the same
+ * arguments. Stateful tools (bash, edit, write, etc.) never dedupe — their
+ * outputs may reflect non-idempotent side effects that the transcript needs
+ * to preserve.
+ */
+const REPRODUCIBLE_TOOL_NAMES = new Set(["read", "grep", "glob", "ls", "list", "find"]);
+
+/**
+ * Title-case a tool name for the stub string ("read" → "Read", "grep" → "Grep").
+ * Pure; no locale.
+ */
+function titleCaseToolName(name) {
+  if (typeof name !== "string" || name.length === 0) return "";
+  return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+}
+
+/**
+ * Minimal deterministic stable-stringify for args canonicalization.
+ * Sorts object keys at every depth before serialization so that
+ * `{a:1,b:2}` and `{b:2,a:1}` produce the same string.
+ *
+ * Arrays are traversed in order. Non-plain objects (Date, Map, etc.) fall
+ * through to `JSON.stringify` — we don't expect them in tool args, but the
+ * fallback keeps the function total.
+ */
+function stableStringifyForDedupe(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => stableStringifyForDedupe(v)).join(",") + "]";
+  }
+  const keys = Object.keys(value).sort();
+  const parts = [];
+  for (const k of keys) {
+    parts.push(JSON.stringify(k) + ":" + stableStringifyForDedupe(value[k]));
+  }
+  return "{" + parts.join(",") + "}";
+}
+
+/**
+ * Session-wide tool-result dedupe. Pure over `messages`.
+ *
+ * Walks the conversation once to collect every `tool_use` + `tool_result`
+ * pair where the tool is in `REPRODUCIBLE_TOOL_NAMES` (case-insensitive).
+ * Groups them by `(toolName, stableStringify(args))`. For every group
+ * containing more than one call, keeps the LATEST result verbatim and
+ * replaces each earlier result's `content` with a stub:
+ *
+ *   `[<ToolTitleCase> of <argsKey> superseded by later read at msg #<N>]`
+ *
+ * where `N` is the message index of the latest call's user-message.
+ *
+ * `tool_use_id` and any other `tool_result` fields are preserved. Assistant
+ * `tool_use` blocks are NEVER modified — only the paired user `tool_result`.
+ *
+ * Cache-stable: decision is a pure function of message history, so rerunning
+ * over an unchanged prefix yields byte-identical output.
+ *
+ * @param {Array} messages — Parsed messages array
+ * @returns {{ messages: Array, changed: boolean, stats: { deduped: number } }}
+ */
+function applySessionToolResultDedupe(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { messages, changed: false, stats: { deduped: 0 } };
+  }
+
+  // Pass 1: build tool_use_id → { name, argsKey } for reproducible tools.
+  const idToMeta = new Map();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg?.role !== "assistant" || !Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block?.type !== "tool_use") continue;
+      const name = typeof block.name === "string" ? block.name : "";
+      if (!REPRODUCIBLE_TOOL_NAMES.has(name.toLowerCase())) continue;
+      const argsKey = stableStringifyForDedupe(block.input ?? {});
+      idToMeta.set(block.id, { name, argsKey });
+    }
+  }
+
+  // Pass 2: collect tool_result locations by group key, preserving order.
+  /** @type {Map<string, Array<{msgIdx: number, blockIdx: number, toolUseId: string, name: string, argsKey: string}>>} */
+  const groups = new Map();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg?.role !== "user" || !Array.isArray(msg.content)) continue;
+    for (let j = 0; j < msg.content.length; j++) {
+      const block = msg.content[j];
+      if (block?.type !== "tool_result") continue;
+      const meta = idToMeta.get(block.tool_use_id);
+      if (!meta) continue;
+      const groupKey = meta.name.toLowerCase() + "\u0000" + meta.argsKey;
+      let arr = groups.get(groupKey);
+      if (!arr) {
+        arr = [];
+        groups.set(groupKey, arr);
+      }
+      arr.push({
+        msgIdx: i,
+        blockIdx: j,
+        toolUseId: block.tool_use_id,
+        name: meta.name,
+        argsKey: meta.argsKey,
+      });
+    }
+  }
+
+  // Build supersede map: "msgIdx:blockIdx" → stub string.
+  const supersedeStubs = new Map();
+  let deduped = 0;
+  // Deterministic iteration: sort group entries by group key before processing.
+  const sortedEntries = Array.from(groups.entries()).sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+  for (const [, occurrences] of sortedEntries) {
+    if (occurrences.length < 2) continue;
+    const latest = occurrences[occurrences.length - 1];
+    const stub =
+      "[" +
+      titleCaseToolName(latest.name) +
+      " of " +
+      latest.argsKey +
+      " superseded by later read at msg #" +
+      latest.msgIdx +
+      "]";
+    for (let k = 0; k < occurrences.length - 1; k++) {
+      const occ = occurrences[k];
+      supersedeStubs.set(occ.msgIdx + ":" + occ.blockIdx, stub);
+      deduped += 1;
+    }
+  }
+
+  if (deduped === 0) {
+    return { messages, changed: false, stats: { deduped: 0 } };
+  }
+
+  // Pass 3: rewrite. Preserve tool_use_id and other fields.
+  const out = messages.map((msg, i) => {
+    if (msg?.role !== "user" || !Array.isArray(msg.content)) return msg;
+    let mutated = false;
+    const newContent = msg.content.map((block, j) => {
+      if (block?.type !== "tool_result") return block;
+      const stub = supersedeStubs.get(i + ":" + j);
+      if (!stub) return block;
+      mutated = true;
+      return { ...block, content: stub };
+    });
+    return mutated ? { ...msg, content: newContent } : msg;
+  });
+
+  return { messages: out, changed: true, stats: { deduped } };
+}
+
+/**
+ * Dispatch wrapper: only apply `applySessionToolResultDedupe` when the
+ * `token_economy_strategies.tool_result_dedupe_session_wide` flag is true.
+ * When disabled, returns the input `messages` by identity (not a copy) so
+ * callers can cheaply detect "no-op" with reference equality.
+ *
+ * @param {Array} messages
+ * @param {object} [config]
+ * @returns {Array}
+ */
+function maybeApplySessionToolResultDedupe(messages, config) {
+  const flag = config?.token_economy_strategies?.tool_result_dedupe_session_wide;
+  if (flag !== true) return messages;
+  const result = applySessionToolResultDedupe(messages);
+  return result.messages;
+}
+
 /**
  * TTL-based thinking strip. When the time since the last strip exceeds the
  * cache TTL (roughly the point at which the prompt prefix cache would expire),
@@ -6112,6 +6352,16 @@ function isOpus46Model(model) {
   return /claude-opus-4[._-]6|opus[._-]4[._-]6/i.test(model);
 }
 
+/**
+ * Detects claude-opus-4.7 / claude-opus-4-7 model IDs.
+ * @param {string | undefined} model
+ * @returns {boolean}
+ */
+function isOpus47Model(model) {
+  if (!model) return false;
+  return /claude-opus-4[._-]7|opus[._-]4[._-]7/i.test(model);
+}
+
 /**
  * Detects claude-sonnet-4.6 / claude-sonnet-4-6 model IDs.
  * @param {string | undefined} body
@@ -6124,12 +6374,12 @@ function isSonnet46Model(model) {
 
 /**
  * Detects models that support adaptive thinking ({type: "adaptive"}).
- * Currently: Opus 4.6 and Sonnet 4.6.
+ * Currently: Opus 4.6, Opus 4.7, and Sonnet 4.6.
  * @param {string | undefined} body
  * @returns {boolean}
  */
 function isAdaptiveThinkingModel(model) {
-  return isOpus46Model(model) || isSonnet46Model(model);
+  return isOpus46Model(model) || isOpus47Model(model) || isSonnet46Model(model);
 }
 
 /**
@@ -6143,8 +6393,9 @@ function isEligibleFor1MContext(model) {
   if (!model) return false;
   // Explicit 1m suffix/tag in model name
   if (/(^|[-_ ])1m($|[-_ ])|context[-_]?1m|\[1m\]/i.test(model)) return true;
-  // CC v2.1.97 U01: claude-sonnet-4* (any Sonnet 4.x) or opus-4-6
-  return /claude-sonnet-4|sonnet[._-]4/i.test(model) || isOpus46Model(model);
+  // CC v2.1.97 U01: claude-sonnet-4* (any Sonnet 4.x) or opus-4-6.
+  // Opus 4.7 (successor to 4.6) is also 1M-context eligible.
+  return /claude-sonnet-4|sonnet[._-]4/i.test(model) || isOpus46Model(model) || isOpus47Model(model);
 }
 
 /**
@@ -6809,8 +7060,12 @@ function buildSystemPromptBlocks(system, signature) {
   }
 
   // Anti-verbosity injection (CC v2.1.100 quiet_salted_ember equivalent).
-  // Only for Opus 4.6 and non-title-generator requests.
-  if (!titleGeneratorRequest && signature.modelId && isOpus46Model(signature.modelId)) {
+  // Applies to Opus 4.6 / 4.7 for non-title-generator requests.
+  if (
+    !titleGeneratorRequest &&
+    signature.modelId &&
+    (isOpus46Model(signature.modelId) || isOpus47Model(signature.modelId))
+  ) {
     const avConfig = signature.antiVerbosity;
     if (avConfig?.enabled !== false) {
       sanitized.push({ type: "text", text: ANTI_VERBOSITY_SYSTEM_PROMPT });
@@ -7473,6 +7728,15 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
         }
       }
 
+      // (1b) Session-wide reproducible-tool result dedupe (Phase C C3, opt-in)
+      // Pure over message history; runs before microcompact so dedup'd stubs
+      // are visible to downstream size estimation. Gated by
+      // token_economy_strategies.tool_result_dedupe_session_wide (default off).
+      if (config?.token_economy_strategies?.tool_result_dedupe_session_wide === true) {
+        const res = applySessionToolResultDedupe(parsed.messages);
+        if (res.changed) parsed.messages = res.messages;
+      }
+
       // (2) Proactive microcompact (client-side, pre-422)
       if (te.proactive_microcompact !== false) {
         const estimated = estimatePromptTokensFromParsed(parsed);
@@ -7561,7 +7825,7 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
     // Preserves: first paragraph (identity/role), lines containing MUST/NEVER/CRITICAL/
     // IMPORTANT, section headers, and short blocks. Drops verbose body paragraphs.
     const tailThreshold = signature.systemPromptTailTurns ?? 6;
-    if (signature.systemPromptTailing !== false && runtime.turns >= tailThreshold && Array.isArray(parsed.system)) {
+    if (signature.systemPromptTailing === true && runtime.turns >= tailThreshold && Array.isArray(parsed.system)) {
       const maxChars = signature.systemPromptTailMaxChars ?? 2000;
       for (let i = 0; i < parsed.system.length; i++) {
         const block = parsed.system[i];
@@ -7779,6 +8043,10 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
 
     // Fast mode: inject speed parameter for Opus 4.6 only (v2.1.97 restriction).
     // Real CC v2.1.97 xJ() checks: model.includes("opus-4-6") — Sonnet is NOT eligible.
+    // NOTE: Deliberately NOT extended to Opus 4.7. xJ() is a fingerprint-sensitive
+    // check tied to the exact real-CC version we mirror; blindly enabling
+    // speed:"fast" for 4.7 could diverge from real CC's behavior for that model.
+    // Revisit once a real-CC dump confirms xJ() matches opus-4-7.
     const fastModeEnabled = signature.fastMode && !isFalsyEnv(process.env.OPENCODE_ANTHROPIC_DISABLE_FAST_MODE);
     let fastModeAutoApplied = false;
     if (
@@ -8566,6 +8834,11 @@ AnthropicAuthPlugin.__testing__ = {
   buildSystemPromptBlocks,
   stripMcpPrefixFromParsedEvent,
   CORE_TOOL_NAMES,
+  // exposed for determinism regression tests (phase C1)
+  applyContextHintCompaction,
+  // exposed for session-dedupe regression tests (phase C3)
+  applySessionToolResultDedupe,
+  maybeApplySessionToolResultDedupe,
   get cachedCCPrompt() {
     return cachedCCPrompt;
   },
@@ -8574,6 +8847,24 @@ AnthropicAuthPlugin.__testing__ = {
   },
   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. */
+  setSessionTurnsForTest(n) {
+    sessionMetrics.turns = n;
+  },
+  /** Test-only: reset session metrics between tests.
+   *  Uses createInitialSessionMetrics() so every tracked field — including
+   *  nested objects (lastQuota, perModel, costBreakdown, tokenBudget) and the
+   *  usedTools Set — is restored to its initial value. Mutates the existing
+   *  sessionMetrics object in place because many module-level references
+   *  close over it. */
+  resetSessionMetricsForTest() {
+    const fresh = createInitialSessionMetrics();
+    for (const key of Object.keys(sessionMetrics)) {
+      delete sessionMetrics[key];
+    }
+    Object.assign(sessionMetrics, fresh);
+  },
 };
 
 export default AnthropicAuthPlugin;

package/lib/config.mjs

@@ -195,11 +195,20 @@ export const DEFAULT_CONFIG = {
     redact_thinking: false,
     /** Enable context-hint-2026-04-09 beta (CC v2.1.110+). When on, the server
      *  MAY reject 422/424 and trigger client-side compaction retries.
-     *  Server-side rollout is partial — many accounts 400-reject the beta.
-     *  Off by default; the plugin still mimics CC's error-handling semantics
-     *  when a user opts in. Even when on, the beta is only sent for requests
-     *  classified as "main-thread" (see classifyRequestRole). */
-    context_hint: false,
+     *  Default ON (Phase C2). Server-side gating + contextHintState.disabled
+     *  latching means compatible servers use it and incompatible ones fall
+     *  back cleanly via the 400/409/529 error paths. Explicit opt-out via
+     *  `token_economy.context_hint: false` is respected. Even when on, the
+     *  beta is only sent for requests classified as "main-thread" (see
+     *  classifyRequestRole). */
+    context_hint: true,
+
+    /** Dump outgoing request bodies to
+     *  `~/.opencode/opencode-anthropic-fix/request-dumps/` (rotating, last 10).
+     *  Diagnostic tool — enable, run 3-4 conversation turns, ship the files
+     *  so we can diff what's changing between turns. Writes raw JSON bodies,
+     *  so contains user conversation content — don't enable on a shared host. */
+    debug_dump_bodies: false,
 
     /** Conservative mode (default ON). Disables every history-rewriting and
      *  tool-array transform below that can invalidate the prompt-cache prefix
@@ -274,6 +283,29 @@ export const DEFAULT_CONFIG = {
     // response-stream rewriting that breaks normal tool-execution semantics.
     // Tracked as future work — not exposed as a config flag here.
   },
+  /** Advanced strategies that may trade cache stability for verbosity reduction.
+   *  Default OFF because most produce a net cache loss on long sessions. */
+  token_economy_strategies: {
+    /** System prompt tailing: after N turns, trim large system blocks.
+     *  Default OFF — causes cache break over history cached under the
+     *  pre-tail system hash. Opt in for short sessions with huge prompts. */
+    system_prompt_tailing: false,
+    /** Turn count at which tailing starts (if enabled). */
+    system_prompt_tail_turns: 6,
+    /** Max chars per system block after tailing. */
+    system_prompt_tail_max_chars: 2000,
+    /** Tool deferral (send sparse schemas until first use). Default OFF. */
+    tool_deferral: false,
+    /** Tool description compaction (strip example output). Default OFF. */
+    tool_description_compaction: false,
+    /** Adaptive tool set (main vs subagent roles). Default OFF. */
+    adaptive_tool_set: false,
+    /** Replace old reproducible-tool results (Read/Grep/Glob/LS) with stubs
+     *  when a later call with identical args produces a fresh result. Saves
+     *  10-20% on long sessions. Pure over message history → cache-stable.
+     *  Off by default (conservative mode territory). */
+    tool_result_dedupe_session_wide: false,
+  },
   /** Output cap: default max_tokens to save context window. */
   output_cap: {
     enabled: true,
@@ -369,6 +401,7 @@ function createDefaultConfig() {
     adaptive_context: { ...DEFAULT_CONFIG.adaptive_context },
     willow_mode: { ...DEFAULT_CONFIG.willow_mode },
     token_economy: { ...DEFAULT_CONFIG.token_economy },
+    token_economy_strategies: { ...DEFAULT_CONFIG.token_economy_strategies },
     output_cap: { ...DEFAULT_CONFIG.output_cap },
     preconnect: { ...DEFAULT_CONFIG.preconnect },
     overflow_recovery: { ...DEFAULT_CONFIG.overflow_recovery },
@@ -656,6 +689,10 @@ function validateConfig(raw) {
         typeof te.redact_thinking === "boolean" ? te.redact_thinking : DEFAULT_CONFIG.token_economy.redact_thinking,
       context_hint: typeof te.context_hint === "boolean" ? te.context_hint : DEFAULT_CONFIG.token_economy.context_hint,
       conservative: typeof te.conservative === "boolean" ? te.conservative : DEFAULT_CONFIG.token_economy.conservative,
+      debug_dump_bodies:
+        typeof te.debug_dump_bodies === "boolean"
+          ? te.debug_dump_bodies
+          : DEFAULT_CONFIG.token_economy.debug_dump_bodies,
       ttl_thinking_strip:
         typeof te.ttl_thinking_strip === "boolean"
           ? te.ttl_thinking_strip
@@ -708,6 +745,45 @@ function validateConfig(raw) {
     };
   }
 
+  // Token-economy strategies sub-config (A2: default-off advanced knobs)
+  if (raw.token_economy_strategies && typeof raw.token_economy_strategies === "object") {
+    const tes = /** @type {Record<string, unknown>} */ (raw.token_economy_strategies);
+    config.token_economy_strategies = {
+      system_prompt_tailing:
+        typeof tes.system_prompt_tailing === "boolean"
+          ? tes.system_prompt_tailing
+          : DEFAULT_CONFIG.token_economy_strategies.system_prompt_tailing,
+      system_prompt_tail_turns: clampNumber(
+        tes.system_prompt_tail_turns,
+        1,
+        1000,
+        DEFAULT_CONFIG.token_economy_strategies.system_prompt_tail_turns,
+      ),
+      system_prompt_tail_max_chars: clampNumber(
+        tes.system_prompt_tail_max_chars,
+        100,
+        50_000,
+        DEFAULT_CONFIG.token_economy_strategies.system_prompt_tail_max_chars,
+      ),
+      tool_deferral:
+        typeof tes.tool_deferral === "boolean"
+          ? tes.tool_deferral
+          : DEFAULT_CONFIG.token_economy_strategies.tool_deferral,
+      tool_description_compaction:
+        typeof tes.tool_description_compaction === "boolean"
+          ? tes.tool_description_compaction
+          : DEFAULT_CONFIG.token_economy_strategies.tool_description_compaction,
+      adaptive_tool_set:
+        typeof tes.adaptive_tool_set === "boolean"
+          ? tes.adaptive_tool_set
+          : DEFAULT_CONFIG.token_economy_strategies.adaptive_tool_set,
+      tool_result_dedupe_session_wide:
+        typeof tes.tool_result_dedupe_session_wide === "boolean"
+          ? tes.tool_result_dedupe_session_wide
+          : DEFAULT_CONFIG.token_economy_strategies.tool_result_dedupe_session_wide,
+    };
+  }
+
   // Output cap sub-config
   if (raw.output_cap && typeof raw.output_cap === "object") {
     const oc = /** @type {Record<string, unknown>} */ (raw.output_cap);

package/lib/context-hint-persist.mjs

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getConfigDir } from "./config.mjs";
+
+const FLAG_FILENAME = "context-hint-disabled.flag";
+const FLAG_VERSION = 1;
+
+/**
+ * @typedef {object} ContextHintFlag
+ * @property {true} disabled
+ * @property {string} [reason]
+ * @property {number} [status]
+ * @property {number} [timestamp]
+ * @property {number} [version]
+ */
+
+/**
+ * @returns {string}
+ */
+export function getContextHintFlagPath() {
+  return join(getConfigDir(), FLAG_FILENAME);
+}
+
+/**
+ * @returns {{ disabled: boolean, reason?: string, status?: number, timestamp?: number }}
+ */
+export function loadContextHintDisabledFlag() {
+  const p = getContextHintFlagPath();
+  if (!existsSync(p)) return { disabled: false };
+  try {
+    const raw = readFileSync(p, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && parsed.disabled === true) {
+      return {
+        disabled: true,
+        reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
+        status: typeof parsed.status === "number" ? parsed.status : undefined,
+        timestamp: typeof parsed.timestamp === "number" ? parsed.timestamp : undefined,
+      };
+    }
+  } catch {
+    // Corrupted or unreadable — treat as not disabled.
+  }
+  return { disabled: false };
+}
+
+/**
+ * Persist a permanent disable flag for the context-hint beta. Best-effort;
+ * disk failures are swallowed so they never abort a session.
+ * @param {{ reason: string, status: number }} params
+ */
+export function saveContextHintDisabledFlag({ reason, status }) {
+  const p = getContextHintFlagPath();
+  try {
+    mkdirSync(dirname(p), { recursive: true });
+    /** @type {ContextHintFlag} */
+    const payload = {
+      disabled: true,
+      reason,
+      status,
+      timestamp: Date.now(),
+      version: FLAG_VERSION,
+    };
+    writeFileSync(p, JSON.stringify(payload, null, 2), "utf-8");
+  } catch {
+    // Best-effort.
+  }
+}

package/lib/rolling-summarizer.mjs

@@ -0,0 +1,215 @@
+/**
+ * Deterministic rolling summarizer — Phase B Task B3.
+ *
+ * Produces a byte-identical string summary for a given message array so the
+ * Anthropic prompt cache stays warm across compaction boundaries.
+ *
+ * Invariants (enforced by test/rolling-summarizer.test.mjs):
+ *  - No Date.now / new Date / Math.random / performance.now anywhere.
+ *  - temperature: 0 on the Haiku call.
+ *  - Object iteration is sorted before join.
+ *  - The Haiku call is injected as `haikuCall(request)` so tests stay offline.
+ *
+ * @module lib/rolling-summarizer
+ */
+
+/** Haiku 4.5 — deterministic, cheap summarization model. */
+export const MODEL = "claude-haiku-4-5-20251001";
+
+/** Forced to 0 — non-zero temperature would break the byte-equality guarantee. */
+export const TEMPERATURE = 0;
+
+/** Default length bound for the full rendered `<session-summary>` block. */
+export const DEFAULT_MAX_CHARS = 2000;
+
+/** Canonical template — every field is a placeholder, never a timestamp. */
+export const TEMPLATE = [
+  "<session-summary>",
+  "Previous conversation summarized for context efficiency.",
+  "",
+  "Key topics covered:",
+  "{topics}",
+  "",
+  "Outstanding state:",
+  "{outstanding}",
+  "",
+  "Files touched:",
+  "{files}",
+  "</session-summary>",
+].join("\n");
+
+/** Fixed sections the Haiku response is expected to emit, in this exact order. */
+const SECTIONS = ["TOPICS", "OUTSTANDING", "FILES"];
+
+/** Always-present fallback when a section is missing from the Haiku reply. */
+const EMPTY_SECTION = "(none)";
+
+/** @typedef {{role: string, content: string}} Message */
+/** @typedef {{topics: string, outstanding: string, files: string}} ParsedSections */
+/** @typedef {{model: string, temperature: number, prompt: string}} HaikuRequest */
+/** @typedef {(req: HaikuRequest) => Promise<string>} HaikuCall */
+
+/**
+ * Serialize an object with keys in sorted order.  JSON.stringify follows
+ * insertion order in V8, so sorting first guarantees byte-equality across
+ * property-order-varied inputs.
+ * @param {Record<string, unknown>} obj
+ * @returns {string}
+ */
+function stableStringify(obj) {
+  const keys = Object.keys(obj).sort();
+  const parts = keys.map((k) => JSON.stringify(k) + ":" + JSON.stringify(obj[k]));
+  return "{" + parts.join(",") + "}";
+}
+
+/**
+ * Build the prompt text fed to Haiku.  Pure; no timestamps, no IDs.
+ * Uses sorted-key serialization so the output doesn't change if the caller
+ * built `{role, content}` vs `{content, role}`.
+ * @param {Message[]} messages
+ * @param {number} maxChars — soft cap used to trim oldest messages first.
+ * @returns {string}
+ */
+export function buildPrompt(messages, maxChars) {
+  const rendered = messages.map((m) => {
+    // Re-shape every message in a canonical sorted form so insertion order
+    // of {role, content} vs {content, role} cannot affect the bytes.
+    const norm = stableStringify({ role: String(m.role ?? ""), content: String(m.content ?? "") });
+    // Render as "role: content" for the model — deterministic and readable.
+    const parsed = JSON.parse(norm);
+    return `${parsed.role}: ${parsed.content}`;
+  });
+
+  // Keep under the cap by trimming the oldest entries first.  Deterministic:
+  // no randomness, purely length-driven.
+  let body = rendered.join("\n");
+  let dropped = 0;
+  while (body.length > maxChars && rendered.length - dropped > 1) {
+    dropped += 1;
+    body = rendered.slice(dropped).join("\n");
+  }
+
+  const header = [
+    "Summarize the conversation below for context compaction.",
+    "Respond with EXACTLY these three sections, in this order:",
+    "TOPICS:",
+    "- <bullet per topic>",
+    "OUTSTANDING:",
+    "- <bullet per outstanding item, or (none)>",
+    "FILES:",
+    "- <bullet per touched file, or (none)>",
+    "Do not include dates, times, IDs, greetings, or apologies.",
+    "---",
+  ].join("\n");
+
+  return `${header}\n${body}`;
+}
+
+/**
+ * Parse Haiku's "TOPICS:\n...\nOUTSTANDING:\n...\nFILES:\n..." reply into
+ * the three fields the template expects.  Unknown sections are ignored.
+ * Missing sections fall back to EMPTY_SECTION so the output stays stable.
+ * @param {string} raw
+ * @returns {ParsedSections}
+ */
+export function parseHaikuResponse(raw) {
+  /** @type {Record<string, string[]>} */
+  const buckets = {};
+  for (const name of SECTIONS) buckets[name] = [];
+
+  let current = /** @type {string | null} */ (null);
+  const lines = String(raw ?? "").split(/\r?\n/);
+  for (const line of lines) {
+    const match = line.match(/^([A-Z]+)\s*:\s*$/);
+    if (match && SECTIONS.includes(match[1])) {
+      current = match[1];
+      continue;
+    }
+    if (current && line.trim() !== "") {
+      buckets[current].push(line);
+    }
+  }
+
+  const pick = (name) => {
+    const arr = buckets[name];
+    if (!arr || arr.length === 0) return EMPTY_SECTION;
+    return arr.join("\n");
+  };
+
+  return {
+    topics: pick("TOPICS"),
+    outstanding: pick("OUTSTANDING"),
+    files: pick("FILES"),
+  };
+}
+
+/**
+ * Render the canonical TEMPLATE with parsed sections substituted in.
+ * If the result exceeds `maxChars`, sections are truncated deterministically
+ * from the longest one first until the total fits.
+ * @param {ParsedSections} parsed
+ * @param {number} maxChars
+ * @returns {string}
+ */
+export function formatTemplate(parsed, maxChars) {
+  /** @type {ParsedSections} */
+  let current = {
+    topics: parsed.topics || EMPTY_SECTION,
+    outstanding: parsed.outstanding || EMPTY_SECTION,
+    files: parsed.files || EMPTY_SECTION,
+  };
+
+  const render = (sec) =>
+    TEMPLATE.replace("{topics}", sec.topics).replace("{outstanding}", sec.outstanding).replace("{files}", sec.files);
+
+  let out = render(current);
+  // Deterministic truncation: iterate sections in a fixed order and shorten
+  // the longest until we fit.  No Math.random, no timing-based bail.
+  let guard = 0;
+  while (out.length > maxChars && guard < 1000) {
+    guard += 1;
+    const names = /** @type {(keyof ParsedSections)[]} */ (["topics", "outstanding", "files"]);
+    // Pick the longest section; ties broken by fixed order above.
+    let longestName = names[0];
+    for (const n of names) {
+      if (current[n].length > current[longestName].length) longestName = n;
+    }
+    const longest = current[longestName];
+    if (longest.length <= EMPTY_SECTION.length) break;
+    // Chop 10% (at least 8 chars) off the end of the longest section.
+    const chop = Math.max(8, Math.floor(longest.length * 0.1));
+    current = { ...current, [longestName]: longest.slice(0, Math.max(EMPTY_SECTION.length, longest.length - chop)) };
+    out = render(current);
+  }
+
+  // Final hard cap: if we somehow still exceed, slice the envelope.  Still
+  // deterministic (input-driven only).
+  if (out.length > maxChars) {
+    const closing = "\n</session-summary>";
+    const head = out.slice(0, Math.max(0, maxChars - closing.length));
+    out = head + closing;
+  }
+  return out;
+}
+
+/**
+ * Summarize `messages` into a canonical `<session-summary>` string.
+ *
+ * @param {Message[]} messages
+ * @param {{maxChars?: number, haikuCall: HaikuCall}} opts
+ *   - maxChars: soft cap on the returned string (default 2000).
+ *   - haikuCall: dependency-injected Haiku invoker — `(request) => Promise<string>`.
+ * @returns {Promise<string>}
+ */
+export async function summarize(messages, opts) {
+  if (!opts || typeof opts.haikuCall !== "function") {
+    throw new Error("summarize() requires opts.haikuCall");
+  }
+  const maxChars = typeof opts.maxChars === "number" ? opts.maxChars : DEFAULT_MAX_CHARS;
+  const prompt = buildPrompt(Array.isArray(messages) ? messages : [], maxChars);
+  /** @type {HaikuRequest} */
+  const request = { model: MODEL, prompt, temperature: TEMPERATURE };
+  const raw = await opts.haikuCall(request);
+  const parsed = parseHaikuResponse(String(raw ?? ""));
+  return formatTemplate(parsed, maxChars);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.1.14",
+  "version": "0.1.18",
   "license": "GPL-3.0-or-later",
   "main": "./index.mjs",
   "files": [