opencode-anthropic-fix 0.1.3 → 0.1.5

package/index.mjs

@@ -111,6 +111,7 @@ async function promptManageAccounts(accountManager) {
 
 export async function AnthropicAuthPlugin({ client, project, directory, worktree, serverUrl, $ }) {
   const config = loadConfig();
+  _pluginConfig = config; // expose to module-level functions (cache stats, response headers)
   // QA fix H6: read emulation settings live from config instead of stale const capture
   // so that runtime toggles via `/anthropic set emulation` take effect immediately
   const getSignatureEmulationEnabled = () => config.signature_emulation.enabled;
@@ -653,6 +654,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
         `telemetry-emulation: ${fresh.telemetry?.emulate_minimal ? "on (silent observer)" : "off"}`,
         `usage-toast: ${fresh.usage_toast ? "on" : "off"}`,
         `adaptive-context: ${fresh.adaptive_context?.enabled ? `on (↑${Math.round((fresh.adaptive_context.escalation_threshold || 150000) / 1000)}K ↓${Math.round((fresh.adaptive_context.deescalation_threshold || 100000) / 1000)}K)${adaptiveContextState.active ? " [ACTIVE]" : ""}` : "off"}`,
+        `anti-verbosity: ${fresh.anti_verbosity?.enabled !== false ? "on" : "off"} (length-anchors: ${fresh.anti_verbosity?.length_anchors !== false ? "on" : "off"})`,
       ];
       await sendCommandMessage(input.sessionID, lines.join("\n"));
       return;
@@ -3041,7 +3043,15 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     sessionMetrics.lastQuota.inputTokens = maxUtilization;
                   }
 
-                  if (maxUtilization > 0.8) {
+                  // Proactive account management is gated on config. When
+                  // account_management.proactive_disabled is true (default),
+                  // we never apply penalties on a 200 OK response — those
+                  // penalties were locking out single-account users whose
+                  // server-side quota was still in `allowed_warning` state.
+                  // The reactive 429 path below is unaffected.
+                  const proactiveDisabled = config.account_management?.proactive_disabled !== false;
+
+                  if (!proactiveDisabled && maxUtilization > 0.8) {
                     const penalty = Math.round((maxUtilization - 0.8) * 50); // 0-10 points
                     accountManager.applyUtilizationPenalty(account, penalty);
                     debugLog("high rate limit utilization", {
@@ -3052,7 +3062,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     });
                   }
 
-                  if (anySurpassed) {
+                  if (!proactiveDisabled && anySurpassed) {
                     accountManager.applySurpassedThreshold(account, surpassedResetAt);
                     debugLog("rate limit threshold surpassed", {
                       accountIndex: account.index,
@@ -3070,8 +3080,10 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                   }
 
                   // Predictive rate limit avoidance: switch account BEFORE hitting 429
-                  // Parse reset timestamps to compute time-weighted risk
-                  if (maxUtilization > 0.6 && accountManager.getAccountCount() > 1) {
+                  // Parse reset timestamps to compute time-weighted risk.
+                  // Gated on proactive_disabled — when true (default), no automatic
+                  // switches happen on 200 OK responses (fully manual rotation).
+                  if (!proactiveDisabled && maxUtilization > 0.6 && accountManager.getAccountCount() > 1) {
                     let highestRisk = 0;
                     for (const win of RATE_LIMIT_WINDOWS) {
                       const utilizationStr = response.headers.get(`anthropic-ratelimit-unified-${win.key}-utilization`);
@@ -3854,6 +3866,9 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
 // ---------------------------------------------------------------------------
 
 /** @type {{turns: number, totalInput: number, totalOutput: number, totalCacheRead: number, totalCacheWrite: number, totalWebSearchRequests: number, recentCacheRates: number[], sessionCostUsd: number, costBreakdown: {input: number, output: number, cacheRead: number, cacheWrite: number}, sessionStartTime: number, lastQuota: {tokens: number, requests: number, inputTokens: number, updatedAt: number, fiveHour: {utilization: number, resets_at: string|null, status: string|null, surpassedThreshold: number|null}, sevenDay: {utilization: number, resets_at: string|null, status: string|null, surpassedThreshold: number|null}, overallStatus: string|null, representativeClaim: string|null, fallback: string|null, fallbackPercentage: number|null, overageStatus: string|null, overageReason: string|null, lastPollAt: number}, lastStopReason: string | null, perModel: Record<string, {input: number, output: number, cacheRead: number, cacheWrite: number, costUsd: number, turns: number}>, lastModelId: string | null, lastRequestBody: string | null, tokenBudget: {limit: number, used: number, continuations: number, outputHistory: number[]}}} */
+/** Module-level config ref for functions outside AnthropicAuthPlugin closure. */
+let _pluginConfig = null;
+
 const sessionMetrics = {
   turns: 0,
   totalInput: 0,
@@ -4777,6 +4792,9 @@ function updateSessionMetrics(usage, model) {
     sessionMetrics.lastModelId = model;
   }
 
+  // Write cache transparency stats to disk for TUI consumption.
+  writeCacheStatsFile(usage, model, hitRate);
+
   // Token budget tracking (A9)
   if (sessionMetrics.tokenBudget.limit > 0) {
     sessionMetrics.tokenBudget.used += usage.outputTokens;
@@ -4798,6 +4816,63 @@ function getAverageCacheHitRate() {
   return rates.reduce((a, b) => a + b, 0) / rates.length;
 }
 
+/**
+ * Write cache transparency stats to a well-known JSON file for TUI consumption.
+ * The OpenCode TUI watches this file to display cache metrics in the status bar.
+ * @param {UsageStats} usage - Current turn usage
+ * @param {string} model - Model used
+ * @param {number} hitRate - Cache hit rate for this turn (0-1)
+ */
+function writeCacheStatsFile(usage, model, hitRate) {
+  try {
+    const statsPath = join(getConfigDir(), "cache-stats.json");
+    const avgHitRate = getAverageCacheHitRate();
+    const totalPrompt = sessionMetrics.totalInput + sessionMetrics.totalCacheRead + sessionMetrics.totalCacheWrite;
+    const sessionHitRate = totalPrompt > 0 ? sessionMetrics.totalCacheRead / totalPrompt : 0;
+
+    // Calculate cache savings in USD
+    const pricing = MODEL_PRICING[model] || MODEL_PRICING["claude-opus-4-6"] || { input: 15, cacheRead: 1.5 };
+    const savedPerMToken = pricing.input - (pricing.cacheRead || pricing.input * 0.1);
+    const sessionSavingsUsd = (sessionMetrics.totalCacheRead / 1_000_000) * savedPerMToken;
+
+    const stats = {
+      // Per-turn stats (latest request)
+      turn: {
+        input_tokens: usage.inputTokens,
+        output_tokens: usage.outputTokens,
+        cache_read_tokens: usage.cacheReadTokens,
+        cache_write_tokens: usage.cacheWriteTokens,
+        cache_hit_rate: Math.round(hitRate * 1000) / 1000,
+        model,
+      },
+      // Session-level stats
+      session: {
+        turns: sessionMetrics.turns,
+        total_input: sessionMetrics.totalInput,
+        total_output: sessionMetrics.totalOutput,
+        total_cache_read: sessionMetrics.totalCacheRead,
+        total_cache_write: sessionMetrics.totalCacheWrite,
+        session_hit_rate: Math.round(sessionHitRate * 1000) / 1000,
+        avg_recent_hit_rate: Math.round(avgHitRate * 1000) / 1000,
+        cost_usd: Math.round(sessionMetrics.sessionCostUsd * 10000) / 10000,
+        cache_savings_usd: Math.round(sessionSavingsUsd * 10000) / 10000,
+      },
+      // Config state
+      config: {
+        cache_ttl: _pluginConfig?.cache_policy?.ttl ?? "1h",
+        boundary_marker: _pluginConfig?.cache_policy?.boundary_marker ?? false,
+        anti_verbosity: _pluginConfig?.anti_verbosity?.enabled !== false,
+        length_anchors: _pluginConfig?.anti_verbosity?.length_anchors !== false,
+      },
+      timestamp: new Date().toISOString(),
+    };
+
+    writeFileSync(statsPath, JSON.stringify(stats, null, 2));
+  } catch {
+    // Non-critical — silently ignore write failures
+  }
+}
+
 // --- Phase 5: Auto-strategy adaptation ---
 // strategyState is created per-plugin instance inside AnthropicAuthPlugin() to avoid
 // cross-instance pollution (critical for test isolation and multi-instance scenarios).
@@ -5310,6 +5385,33 @@ const COMPACT_TITLE_GENERATOR_SYSTEM_PROMPT = [
   "- Keep important technical terms, numbers, and filenames when present.",
 ].join("\n");
 
+/**
+ * Anti-verbosity system prompt text.
+ * Extracted from CC v2.1.100 (gated on quiet_salted_ember A/B test for Opus 4.6).
+ * Significantly reduces output token count by instructing the model to be concise.
+ */
+const ANTI_VERBOSITY_SYSTEM_PROMPT = [
+  "# Communication style",
+  "Assume users can't see most tool calls or thinking — only your text output. Before your first tool call, state in one sentence what you're about to do. While working, give short updates at key moments: when you find something, when you change direction, or when you hit a blocker. Brief is good — silent is not. One sentence per update is almost always enough.",
+  "",
+  "Don't narrate your internal deliberation. User-facing text should be relevant communication to the user, not a running commentary on your thought process. State results and decisions directly, and focus user-facing text on relevant updates for the user.",
+  "",
+  "When you do write updates, write so the reader can pick up cold: complete sentences, no unexplained jargon or shorthand from earlier in the session. But keep it tight — a clear sentence is better than a clear paragraph.",
+  "",
+  "End-of-turn summary: one or two sentences. What changed and what's next. Nothing else.",
+  "",
+  "Match responses to the task: a simple question gets a direct answer, not headers and sections.",
+  "",
+  "In code: default to writing no comments. Never write multi-paragraph docstrings or multi-line comment blocks — one short line max. Don't create planning, decision, or analysis documents unless the user asks for them — work from conversation context, not intermediate files.",
+].join("\n");
+
+/**
+ * Numeric length anchors text.
+ * Extracted from CC v2.1.100. Hard word-count limits for output.
+ */
+const NUMERIC_LENGTH_ANCHORS_PROMPT =
+  "Length limits: keep text between tool calls to ≤25 words. Keep final responses to ≤100 words unless the task requires more detail.";
+
 /**
  * Returns the persistent device ID (64-char hex string).
  * Migrates legacy UUID-format values to the new 64-hex format automatically.
@@ -5722,6 +5824,24 @@ function buildAnthropicBillingHeader(version, firstUserMessage, provider) {
 // Opencode's customizations after ~5800 chars diverge and trigger extra usage billing.
 const MAX_SAFE_SYSTEM_TEXT_LENGTH = 5000;
 
+// A5: Subagent CC-prefix cache.
+//
+// Context: opencode/packages/opencode/src/session/llm.ts:110 uses
+//   `input.agent.prompt ? [input.agent.prompt] : SystemPrompt.provider(model)`
+// so any agent with a custom prompt (explore, fast, title, summary, etc.)
+// fires WITHOUT the base CC prompt — the server-side fingerprint match fails
+// and the request is billed as pay-as-you-go credits instead of Max-plan usage.
+//
+// Fix: on the first main-agent call (where the anchor is present), cache the
+// sanitized CC prefix. On subsequent subagent calls (anchor missing), prepend
+// the cached prefix to the sanitized blocks so the fingerprint matches again.
+//
+// The cache lives at module scope because buildSystemPromptBlocks is re-entered
+// per request. It gets populated exactly once per process on the first main call.
+const MAX_SUBAGENT_CC_PREFIX = MAX_SAFE_SYSTEM_TEXT_LENGTH;
+const SUBAGENT_CC_ANCHOR = "You are an interactive";
+let cachedCCPrompt = null;
+
 function sanitizeSystemText(text) {
   // QA fix M4: use word boundaries to avoid mangling URLs and code identifiers
   let sanitized = text.replace(/\bOpenCode\b/g, "Claude Code").replace(/\bopencode\b/gi, "Claude");
@@ -6035,12 +6155,58 @@ function buildSystemPromptBlocks(system, signature) {
     text: compactSystemText(sanitizeSystemText(item.text), signature.promptCompactionMode),
   }));
 
+  // A5: Subagent CC-prefix cache/inject (see constant declaration above for context).
+  //
+  // After sanitize, main-agent blocks start with "You are an interactive..." because
+  // sanitizeSystemText() strips everything before that anchor. Subagent blocks
+  // (custom prompts from input.agent.prompt) do NOT start with the anchor —
+  // they start with whatever the agent template says (e.g., "You are a file search
+  // specialist.").
+  //
+  // This logic runs ONLY for Anthropic requests with signature enabled (signature.enabled
+  // is false for non-Anthropic providers), and skips the title-generator fast path
+  // because that one is replaced wholesale with COMPACT_TITLE_GENERATOR_SYSTEM_PROMPT below.
+  if (signature.enabled && !titleGeneratorRequest && sanitized.length > 0) {
+    const firstText = typeof sanitized[0]?.text === "string" ? sanitized[0].text : "";
+    const hasCcAnchor = firstText.startsWith(SUBAGENT_CC_ANCHOR);
+
+    if (hasCcAnchor) {
+      // Main-agent path: cache the prefix on the first hit so subagents can reuse it.
+      // We slice to MAX_SUBAGENT_CC_PREFIX to avoid unbounded growth if the upstream
+      // sanitize limit is ever raised.
+      if (!cachedCCPrompt) {
+        cachedCCPrompt = firstText.slice(0, MAX_SUBAGENT_CC_PREFIX);
+      }
+    } else if (cachedCCPrompt) {
+      // Subagent path: prepend the cached CC prefix so the fingerprint matches.
+      // We prepend, not concatenate, so the original subagent prompt stays as a
+      // separate block — dedupeSystemBlocks and splitSysPromptPrefix handle the
+      // join on their own downstream.
+      sanitized = [{ type: "text", text: cachedCCPrompt }, ...sanitized];
+    }
+    // If !hasCcAnchor && !cachedCCPrompt: no-op. The cache primes on the very
+    // first main call in a process. In practice opencode always fires a main
+    // call before any subagent, so this branch is only hit in synthetic tests.
+  }
+
   if (titleGeneratorRequest) {
     sanitized = [{ type: "text", text: COMPACT_TITLE_GENERATOR_SYSTEM_PROMPT }];
   } else if (signature.promptCompactionMode !== "off") {
     sanitized = dedupeSystemBlocks(sanitized);
   }
 
+  // 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)) {
+    const avConfig = signature.antiVerbosity;
+    if (avConfig?.enabled !== false) {
+      sanitized.push({ type: "text", text: ANTI_VERBOSITY_SYSTEM_PROMPT });
+    }
+    if (avConfig?.length_anchors !== false) {
+      sanitized.push({ type: "text", text: NUMERIC_LENGTH_ANCHORS_PROMPT });
+    }
+  }
+
   if (!signature.enabled) {
     return sanitized;
   }
@@ -6148,10 +6314,20 @@ function buildAnthropicBetaHeader(
   }
 
   betas.push(FAST_MODE_BETA_FLAG); // "fast-mode-2026-02-01"
-  betas.push(EFFORT_BETA_FLAG); // "effort-2025-11-24"
 
-  // Interleaved thinking — always-on unless explicitly disabled
-  if (!isTruthyEnv(process.env.DISABLE_INTERLEAVED_THINKING)) {
+  // effort-2025-11-24 — real CC's Lyz() only pushes this flag when rE(model)
+  // is true (Opus 4.6 / Sonnet 4.6). Pushing it for non-adaptive models like
+  // Haiku is a fingerprint mismatch vs real CC and can contaminate billing
+  // attribution even when the request body has no effort field.
+  if (isAdaptiveThinkingModel(model)) {
+    betas.push(EFFORT_BETA_FLAG); // "effort-2025-11-24"
+  }
+
+  // Interleaved thinking — real CC's i01 pushes via hv4(model), which is
+  // (firstParty && non-Claude-3). Claude 3.x models don't support interleaved
+  // thinking and real CC never sends this flag for them, so emitting it
+  // diverges the fingerprint for legacy Haiku/Sonnet 3.x requests.
+  if (!isTruthyEnv(process.env.DISABLE_INTERLEAVED_THINKING) && !/claude-3-/i.test(model)) {
     betas.push("interleaved-thinking-2025-05-14");
   }
 
@@ -6549,6 +6725,27 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
       parsed.thinking = normalizeThinkingBlock(parsed.thinking, parsed.model || "");
     }
 
+    // Fingerprint fix: real Claude Code v2.1.87+ nests the effort control inside
+    // `output_config.effort` (via Lyz() in cli.js). opencode's provider transform
+    // for variant=max on Opus 4.6 / Sonnet 4.6 sets `effort` at the top level,
+    // which causes Anthropic's server to fingerprint the body as non-CC and bill
+    // it as pay-as-you-go — surfacing as "You're out of extra usage" even on a
+    // valid Max plan. Move it into output_config when we're talking to an
+    // adaptive-thinking model so the wire shape matches real CC.
+    if (typeof parsed.effort === "string" && parsed.model && isAdaptiveThinkingModel(parsed.model)) {
+      if (!parsed.output_config || typeof parsed.output_config !== "object") {
+        parsed.output_config = {};
+      }
+      if (!("effort" in parsed.output_config)) {
+        parsed.output_config.effort = parsed.effort;
+      }
+      delete parsed.effort;
+    } else if (Object.prototype.hasOwnProperty.call(parsed, "effort")) {
+      // Non-adaptive models never carry a top-level effort in real CC — strip it
+      // to avoid polluting the fingerprint for models like Haiku.
+      delete parsed.effort;
+    }
+
     // Claude Code temperature rule: when extended thinking is active (any type),
     // temperature must be omitted (undefined). Otherwise default to 1.
     const thinkingActive =
@@ -6584,7 +6781,7 @@ function transformRequestBody(body, signature, runtime, betaHeader, config) {
     const modelId = parsed.model || "";
     // Extract first user message text for billing hash computation (cch)
     const firstUserMessage = extractFirstUserMessageText(parsed.messages);
-    const signatureWithModel = { ...signature, modelId, firstUserMessage };
+    const signatureWithModel = { ...signature, modelId, firstUserMessage, antiVerbosity: config?.anti_verbosity };
     // Sanitize system prompt and optionally inject Claude Code identity/billing blocks.
     parsed.system = buildSystemPromptBlocks(normalizeSystemTextBlocks(parsed.system), signatureWithModel);
 
@@ -7092,10 +7289,18 @@ function transformResponse(response, onUsage, onAccountError) {
     },
   });
 
+  // Inject cache transparency headers (session-level, available before stream completes).
+  const responseHeaders = new Headers(response.headers);
+  responseHeaders.set("x-opencode-cache-hit-rate", String(Math.round(getAverageCacheHitRate() * 1000) / 1000));
+  responseHeaders.set("x-opencode-cache-read-total", String(sessionMetrics.totalCacheRead));
+  responseHeaders.set("x-opencode-session-cost", String(Math.round(sessionMetrics.sessionCostUsd * 10000) / 10000));
+  responseHeaders.set("x-opencode-turns", String(sessionMetrics.turns));
+  responseHeaders.set("x-opencode-anti-verbosity", _pluginConfig?.anti_verbosity?.enabled !== false ? "on" : "off");
+
   return new Response(stream, {
     status: response.status,
     statusText: response.statusText,
-    headers: response.headers,
+    headers: responseHeaders,
   });
 }
 
@@ -7373,4 +7578,34 @@ function extractFileIds(body) {
   return ids;
 }
 
+// Internals exposed for tests only. Do not consume from production code paths.
+//
+// IMPORTANT: do NOT add a new `export` declaration here. Opencode's plugin
+// loader (opencode/packages/opencode/src/plugin/index.ts:74-79) iterates
+// `Object.values(mod)` of the loaded module and throws "Plugin export is not
+// a function" if ANY export is not a plugin function. A named `export const
+// __testing__ = {...}` object would break plugin loading entirely.
+//
+// Instead, attach the test hooks as a PROPERTY of the exported function.
+// Functions are objects in JS, so this is valid. The module surface still
+// has only one exported value (the AnthropicAuthPlugin function), which is
+// what the loader expects. Tests reach internals via
+// `import { AnthropicAuthPlugin } from "./index.mjs"` then
+// `AnthropicAuthPlugin.__testing__`.
+AnthropicAuthPlugin.__testing__ = {
+  sanitizeSystemText,
+  compactSystemText,
+  dedupeSystemBlocks,
+  normalizeSystemTextBlocks,
+  buildSystemPromptBlocks,
+  get cachedCCPrompt() {
+    return cachedCCPrompt;
+  },
+  resetCachedCCPrompt() {
+    cachedCCPrompt = null;
+  },
+  SUBAGENT_CC_ANCHOR,
+  CLAUDE_CODE_IDENTITY_STRING,
+};
+
 export default AnthropicAuthPlugin;

package/lib/config.mjs

@@ -102,6 +102,8 @@ import { randomBytes } from "node:crypto";
  * @property {{ enabled: boolean, default: number, completion_threshold: number }} token_budget
  * @property {{ enabled: boolean, threshold_percent: number }} microcompact
  * @property {{ enabled: boolean, default_cooldown_ms: number, poll_quota_on_overload: boolean }} overload_recovery
+ * @property {{ proactive_disabled: boolean }} account_management
+ * @property {{ enabled: boolean, length_anchors: boolean }} anti_verbosity
  */
 
 /** @type {AnthropicAuthConfig} */
@@ -241,6 +243,26 @@ export const DEFAULT_CONFIG = {
     /** Whether to poll /api/oauth/usage on 529 exhaustion for smarter cooldowns. */
     poll_quota_on_overload: true,
   },
+  /** Account management: control automatic account penalties and switching.
+   *  When proactive_disabled is true (default), the plugin will NOT apply
+   *  utilization penalties, surpassed-threshold penalties, or predictive
+   *  switches based on response headers (200 OK responses). Reactive 429
+   *  handling still works. This makes account switching fully manual and
+   *  prevents single-account users from being locally locked out by warning
+   *  thresholds the server still allows. */
+  account_management: {
+    proactive_disabled: true,
+  },
+  /** Anti-verbosity: inject conciseness instructions into system prompt for Opus 4.6.
+   *  Mirrors CC v2.1.100 anti_verbosity + numeric_length_anchors sections (gated on
+   *  quiet_salted_ember A/B test in CC; unconditional here since we always want savings).
+   *  Only activates when model is opus-4-6. */
+  anti_verbosity: {
+    /** Master switch: inject anti-verbosity communication style instructions. */
+    enabled: true,
+    /** Also inject numeric length anchors (≤25 words between tool calls, ≤100 words final). */
+    length_anchors: true,
+  },
 };
 
 export const VALID_STRATEGIES = ["sticky", "round-robin", "hybrid"];
@@ -278,6 +300,7 @@ function createDefaultConfig() {
     token_budget: { ...DEFAULT_CONFIG.token_budget },
     microcompact: { ...DEFAULT_CONFIG.microcompact },
     overload_recovery: { ...DEFAULT_CONFIG.overload_recovery },
+    account_management: { ...DEFAULT_CONFIG.account_management },
   };
 }
 
@@ -675,6 +698,27 @@ function validateConfig(raw) {
     };
   }
 
+  // Account management sub-config
+  if (raw.account_management && typeof raw.account_management === "object") {
+    const am = /** @type {Record<string, unknown>} */ (raw.account_management);
+    config.account_management = {
+      proactive_disabled:
+        typeof am.proactive_disabled === "boolean"
+          ? am.proactive_disabled
+          : DEFAULT_CONFIG.account_management.proactive_disabled,
+    };
+  }
+
+  // Anti-verbosity sub-config
+  if (raw.anti_verbosity && typeof raw.anti_verbosity === "object") {
+    const av = /** @type {Record<string, unknown>} */ (raw.anti_verbosity);
+    config.anti_verbosity = {
+      enabled: typeof av.enabled === "boolean" ? av.enabled : DEFAULT_CONFIG.anti_verbosity.enabled,
+      length_anchors:
+        typeof av.length_anchors === "boolean" ? av.length_anchors : DEFAULT_CONFIG.anti_verbosity.length_anchors,
+    };
+  }
+
   return config;
 }
 
@@ -761,6 +805,27 @@ function applyEnvOverrides(config) {
     config.adaptive_context.enabled = false;
   }
 
+  // Account management: env override for proactive penalties / predictive switch.
+  // Set to 1/true to disable all proactive account management (matches default).
+  // Set to 0/false to re-enable the legacy proactive behavior.
+  if (env.OPENCODE_ANTHROPIC_PROACTIVE_DISABLED === "1" || env.OPENCODE_ANTHROPIC_PROACTIVE_DISABLED === "true") {
+    config.account_management.proactive_disabled = true;
+  }
+  if (env.OPENCODE_ANTHROPIC_PROACTIVE_DISABLED === "0" || env.OPENCODE_ANTHROPIC_PROACTIVE_DISABLED === "false") {
+    config.account_management.proactive_disabled = false;
+  }
+
+  // Anti-verbosity: env override for conciseness injection.
+  if (env.OPENCODE_ANTHROPIC_ANTI_VERBOSITY === "1" || env.OPENCODE_ANTHROPIC_ANTI_VERBOSITY === "true") {
+    config.anti_verbosity.enabled = true;
+  }
+  if (env.OPENCODE_ANTHROPIC_ANTI_VERBOSITY === "0" || env.OPENCODE_ANTHROPIC_ANTI_VERBOSITY === "false") {
+    config.anti_verbosity.enabled = false;
+  }
+  if (env.OPENCODE_ANTHROPIC_LENGTH_ANCHORS === "0" || env.OPENCODE_ANTHROPIC_LENGTH_ANCHORS === "false") {
+    config.anti_verbosity.length_anchors = false;
+  }
+
   return config;
 }
 

package/package.json

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