opencode-anthropic-fix 0.6.0 → 2.0.0

package/lib/mimicry/request-body.mjs

@@ -21,12 +21,11 @@ import {
 import { resolveCacheTtl, shouldPlaceToolBreakpoint } from "./cache.mjs";
 import {
   isAdaptiveThinkingModel,
+  isClaude3Model,
   isOpus46Model,
   isOpus47Model,
   isOpus48Model,
-  normalizeThinkingBlock,
-  CLAUDE_3_MODEL_RE,
-} from "./models.mjs";
+} from "./wire-compat.mjs";
 import {
   resolveMaxTokens,
   extractFirstUserMessageText,
@@ -34,9 +33,45 @@ import {
   stripSlashCommandMessages,
   repairOrphanedToolUseBlocks,
 } from "./request-helpers.mjs";
-import { isFalsyEnv } from "../env.mjs";
+import { isFalsyEnv, isTruthyEnv } from "../env.mjs";
 import { sessionMetrics } from "../session-metrics.mjs";
 
+/**
+ * Coerce an incoming `thinking` block to the shape the model actually accepts.
+ *
+ * Lives here rather than in a model module because it is a BODY transform, not
+ * a model query: the only model knowledge it needs is `isAdaptiveThinkingModel`,
+ * which now comes from the wire-compat seam. This module is its sole caller.
+ *
+ * @param {any} thinking
+ * @param {string} model
+ * @returns {any}
+ */
+export function normalizeThinkingBlock(thinking, model) {
+  // If thinking is absent or not an object, pass through
+  if (!thinking || typeof thinking !== "object") {
+    return thinking;
+  }
+
+  // Adaptive thinking models always get { type: "adaptive" }
+  // regardless of what format the incoming thinking block has
+  if (isAdaptiveThinkingModel(model)) {
+    // Check for env-var override to force budget_tokens fallback
+    if (isTruthyEnv(process.env.OPENCODE_ANTHROPIC_DISABLE_ADAPTIVE_THINKING)) {
+      // Fallback: return as-is if already budget_tokens shape, otherwise default
+      if (thinking.type === "enabled" && typeof thinking.budget_tokens === "number") {
+        return thinking;
+      }
+      const parsedBudget = parseInt(process.env.MAX_THINKING_TOKENS, 10);
+      return { type: "enabled", budget_tokens: Number.isNaN(parsedBudget) ? 16000 : parsedBudget };
+    }
+    return { type: "adaptive" };
+  }
+
+  // Non-adaptive models: pass through unchanged
+  return thinking;
+}
+
 // Core tool names (CC PascalCase) that are always eager-loaded.
 export const CORE_TOOL_NAMES = new Set([
   "Bash",
@@ -59,11 +94,14 @@ export const CORE_TOOL_NAMES = new Set([
  * @param {string | undefined} body
  * @param {{enabled: boolean, claudeCliVersion: string, promptCompactionMode: 'minimal' | 'off', provider?: string, useAdapter?: boolean}} signature
  * @param {{persistentUserId: string, sessionId: string, accountId: string, turns?: number, usedTools?: Set<string>}} runtime
- * @param {string} [betaHeader] - Pre-computed anthropic-beta header value to inject into the body.
+ * @param {boolean} [taskBudgetsActive] - Whether `task-budgets-2026-03-13` is active for this
+ *   request. Derived by the caller from the same gates the adapter applies to a custom beta
+ *   (signature emulation, shortcut resolution, `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS`); this
+ *   used to be the full pre-computed `anthropic-beta` header string, substring-tested here.
  * @param {import('../config.mjs').AnthropicAuthConfig} [config] - Plugin configuration for output cap
  * @returns {string | undefined}
  */
-export function transformRequestBody(body, signature, runtime, betaHeader, config) {
+export function transformRequestBody(body, signature, runtime, taskBudgetsActive, config) {
   if (!body || typeof body !== "string") return body;
 
   try {
@@ -157,7 +195,7 @@ export function transformRequestBody(body, signature, runtime, betaHeader, confi
       // ⊆ beta invariant, so the 400 never fires.
       if (
         config?.token_economy?.context_management &&
-        !CLAUDE_3_MODEL_RE.test(parsed.model || "") &&
+        !isClaude3Model(parsed.model || "") &&
         !parsed.context_management
       ) {
         parsed.context_management = {
@@ -331,13 +369,10 @@ export function transformRequestBody(body, signature, runtime, betaHeader, confi
       // Mirrors real CC's `--workload <tag>` CLI flag (process-scoped, used by
       // SDK daemon callers spawning cron subprocesses). Empty string -> omit.
       workload: typeof config?.signature_emulation?.workload === "string" ? config.signature_emulation.workload : "",
-      // Adapter path only: suppress the canonical billing + identity blocks
-      // because the shared package prepends its own. Every other stage of the
-      // system pipeline (anti-verbosity, subagent CC-prefix, title-generator
-      // swap, dedupe, compaction, tailing, token-budget block) still runs.
-      suppressCanonicalBlocks: signature.useAdapter === true,
     };
-    // Sanitize system prompt and optionally inject Claude Code identity/billing blocks.
+    // Host system-prompt policy: sanitize, compact, dedupe, anti-verbosity, and
+    // the prompt-cache breakpoint. The canonical billing + identity prefix is
+    // NOT built here — the shared package composes it (see system-prompt.mjs).
     parsed.system = buildSystemPromptBlocks(normalizeSystemTextBlocks(parsed.system), signatureWithModel);
 
     // Strategy 5 — System prompt tailing: after N turns, trim large system blocks
@@ -581,7 +616,9 @@ export function transformRequestBody(body, signature, runtime, betaHeader, confi
     // Task budgets: when the task-budgets beta is active, preserve or inject output_config.
     // The beta unlocks output_config.max_output_tokens for per-task budget control.
     // Model-router compatibility: the beta header + output_config body are forwarded as-is.
-    if (betaHeader && betaHeader.includes("task-budgets-2026-03-13")) {
+    // The signal is a boolean derived by the caller — this used to substring-test a
+    // pre-computed `anthropic-beta` header string built solely for this line.
+    if (taskBudgetsActive) {
       if (!parsed.output_config) {
         // Default: set a reasonable per-task output budget for long-running agentic tasks.
         // Claude Code tasks typically need generous output budgets.

package/lib/mimicry/system-prompt.mjs

@@ -1,13 +1,28 @@
-import { createHash as createHashCrypto } from "node:crypto";
-import { isTruthyEnv, isFalsyEnv } from "../env.mjs";
-import { isOpus46Model, isOpus47Model, isOpus48Model } from "./models.mjs";
-
-const BILLING_HASH_SALT = "59cf53e54c78";
-const BILLING_HASH_INDICES = [4, 7, 20];
+import { isTruthyEnv } from "../env.mjs";
+import { isOpus46Model, isOpus47Model, isOpus48Model } from "./wire-compat.mjs";
 
+/**
+ * The canonical Claude Code identity text.
+ *
+ * The PLUGIN NO LONGER EMITS IT. `@tormentalabs/claude-code-wire-compat`
+ * composes the canonical prefix (billing block + identity block) itself and
+ * drops any caller block byte-equal to the identity text, so the prefix lands
+ * on the wire exactly once. The constant survives here as a host-policy probe:
+ * `compactSystemText` strips a duplicated identity prefix a host prompt may
+ * carry, before the array ever reaches the package.
+ */
 export const CLAUDE_CODE_IDENTITY_STRING = "You are Claude Code, Anthropic's official CLI for Claude.";
-/** Marker that identifies the canonical billing block inside a system array. */
+/** Marker that identifies a canonical billing block inside a system array. */
 export const BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
+/**
+ * Every canonical identity text the wire recognises.
+ *
+ * The package drops a caller block byte-equal to its own `IDENTITY_TEXT`, but
+ * only that one, and only when the block stands alone. The host pipeline joins
+ * blocks before the package sees them, so a host-supplied identity block has to
+ * be dropped HERE or it would end up embedded mid-string in the joined run and
+ * put the canonical prefix on the wire twice.
+ */
 const KNOWN_IDENTITY_STRINGS = new Set([
   CLAUDE_CODE_IDENTITY_STRING,
   "You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK.",
@@ -46,29 +61,6 @@ const ANTI_VERBOSITY_SYSTEM_PROMPT = [
   "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");
 
-// Max system prompt length that passes CC billing validation.
-// The server pattern-matches the system prompt against the real CC prompt.
-// 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;
-export const SUBAGENT_CC_ANCHOR = "You are an interactive";
-let cachedCCPrompt = null;
-
 // Perf: module-scope regexes reused across per-request hot paths. None use the
 // `/g` flag and all are consumed via `.test()`, so a single shared instance is
 // stateless and safe (no `lastIndex` to reset between calls).
@@ -79,19 +71,6 @@ const TAIL_LIST_ITEM_RE = /^\s*[-*]\s/;
 const OPENCODE_ENV_CONTEXT_PREFIX = "Here is some useful information about the environment you are running in:";
 const CC_ENV_CONTEXT_PREFIX = "Here is useful information about the environment you are running in:";
 
-/**
- * Compute the billing cache hash (cch) matching Claude Code's NP1() function.
- * SHA256(salt + chars_at_indices[4,7,20]_from_first_user_msg + version).slice(0,3)
- * @param {string} firstUserMessage
- * @param {string} version
- * @returns {string}
- */
-export function computeBillingCacheHash(firstUserMessage, version) {
-  const chars = BILLING_HASH_INDICES.map((i) => firstUserMessage[i] || "0").join("");
-  const input = `${BILLING_HASH_SALT}${chars}${version}`;
-  return createHashCrypto("sha256").update(input).digest("hex").slice(0, 3);
-}
-
 /**
  * Models eligible for the "simple system prompt" mode that real CC ships in
  * v2.1.133+ under GrowthBook flag `tengu_velvet_cascade` (or forced via
@@ -112,48 +91,6 @@ export function isSimpleSystemPromptEligible(model) {
   return false;
 }
 
-/**
- * Build the billing header block for Claude Code system prompt injection.
- * Claude Code v2.1.97: cc_version includes 3-char fingerprint hash (not model ID).
- * cch is a static "00000" placeholder (xxHash64 attestation removed in v2.1.97).
- *
- * Real CC (system.ts:78): version = `${MACRO.VERSION}.${fingerprint}`
- * Real CC (system.ts:82): cch = ' cch=00000;' (static, no longer computed)
- *
- * @param {string} version - CLI version (e.g., "2.1.97")
- * @param {string} [firstUserMessage] - First user message text for fingerprint computation
- * @param {string} [workloadOverride] - Explicit workload tag from config (`signature_emulation.workload`).
- *   Takes precedence over `CLAUDE_CODE_WORKLOAD` env var. Mirrors real CC's `--workload <tag>` flag.
- * @returns {string}
- */
-export function buildAnthropicBillingHeader(version, firstUserMessage, workloadOverride) {
-  if (isFalsyEnv(process.env.CLAUDE_CODE_ATTRIBUTION_HEADER)) return "";
-  // Real CC sends cc_entrypoint=cli (confirmed via proxy capture).
-  const entrypoint = process.env.CLAUDE_CODE_ENTRYPOINT || "cli";
-  // Fix #1: cc_version suffix is the 3-char fingerprint hash, NOT the model ID.
-  // computeBillingCacheHash() computes SHA256(salt + msg[4]+msg[7]+msg[20] + version)[:3]
-  // which matches computeFingerprint() in the real CC source (utils/fingerprint.ts).
-  // Always call the hash function — even for empty messages the real CC computes
-  // the hash from "000" chars (indices 4,7,20 all missing → fallback "0").
-  const fingerprint = computeBillingCacheHash(firstUserMessage || "", version);
-  const ccVersion = `${version}.${fingerprint}`;
-  // cch: v2.1.97 sends static "cch=00000" — xxHash64 attestation was removed.
-  // The server uses the PRESENCE of cch=00000 as a CC identification signal.
-  // The plugin is first-party only, so cch is always emitted; the former
-  // bedrock/anthropicAws/mantle suppression went away with multi-provider support.
-  const cchPart = " cch=00000;";
-  // Build workload part (upstream concatenates directly, no regex replace).
-  // Config wins over env so `signature_emulation.workload` is portable across hosts.
-  let workloadPart = "";
-  const workload = workloadOverride || process.env.CLAUDE_CODE_WORKLOAD;
-  if (workload) {
-    // QA fix M5: sanitize workload value to prevent header injection.
-    const safeWorkload = String(workload).replace(/[;\s\r\n]/g, "_");
-    if (safeWorkload) workloadPart = ` cc_workload=${safeWorkload};`;
-  }
-  return `x-anthropic-billing-header: cc_version=${ccVersion}; cc_entrypoint=${entrypoint};${cchPart}${workloadPart}`;
-}
-
 export 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");
@@ -348,36 +285,14 @@ export function normalizeSystemTextBlocks(system) {
   return output;
 }
 
-/**
- * Determine the identity string prefix, matching real CC's getCLISyspromptPrefix().
- * Real CC selects based on isNonInteractive + hasAppendSystemPrompt flags.
- * OpenCode is always interactive CLI, so DEFAULT_PREFIX is almost always correct.
- * We check for Agent SDK signals from the environment to match non-interactive cases.
- *
- * @returns {string}
- */
-export function getCLISyspromptPrefix() {
-  // Agent SDK preset: when running within the Claude Agent SDK with CC preset
-  if (isTruthyEnv(process.env.CLAUDE_AGENT_SDK_VERSION) && isTruthyEnv(process.env.CLAUDE_CODE_ENTRYPOINT)) {
-    const entrypoint = process.env.CLAUDE_CODE_ENTRYPOINT || "";
-    if (entrypoint === "agent-sdk" || entrypoint === "sdk") {
-      return "You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK.";
-    }
-  }
-  // Non-interactive agent without CC preset
-  if (isTruthyEnv(process.env.CLAUDE_AGENT_SDK_VERSION) && !isTruthyEnv(process.env.CLAUDE_CODE_ENTRYPOINT)) {
-    return "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
-  }
-  return CLAUDE_CODE_IDENTITY_STRING;
-}
-
 /**
  * Compute the cache_control object for a given cache scope and policy.
- * Mirrors real CC getCacheControl() (src/services/api/claude.ts:358-374).
  *
- * Real CC behavior:
- * - scope 'global' → {type: 'ephemeral', scope: 'global', ttl?: '1h'}
- * - scope 'org'    → {type: 'ephemeral', ttl?: '1h'} (org is internal, NOT on wire)
+ * HOST cache policy: the ttl is the one `request-body.mjs` resolved for this
+ * request (role-scoped / subagent-aware), not a fixed CC value.
+ *
+ * - scope 'global' → {type: 'ephemeral', scope: 'global', ttl?: <resolved>}
+ * - scope 'org'    → {type: 'ephemeral', ttl?: <resolved>} (org is internal, NOT on wire)
  * - scope null     → block gets NO cache_control at all (caller should omit it)
  *
  * @param {'global' | 'org' | null} cacheScope
@@ -396,66 +311,42 @@ export function getCacheControlForScope(cacheScope, cachePolicy) {
 }
 
 /**
- * Split system prompt blocks into structured blocks with cache scoping,
- * matching real CC splitSysPromptPrefix() (src/utils/api.ts:321-435).
+ * Place the host prompt-cache breakpoints over the sanitized system blocks.
  *
- * Real CC has 3 paths that produce 2 distinct wire formats:
+ * This is the cache half of what used to be `splitSysPromptPrefix`. The prefix
+ * half (billing block + identity block) is gone: the shared package composes
+ * the canonical prefix itself. What remains is host policy the package cannot
+ * infer — WHERE the cache breakpoint goes and which ttl/scope it carries.
  *
- * Path A (tool-based cache): skipGlobalCacheForSystemPrompt=true
- *   - billing → cacheScope: null
- *   - identity → cacheScope: 'org'
- *   - rest (joined) → cacheScope: 'org'
- *   Wire result: identical to Path C (org → ephemeral without scope field)
+ * The blocks are joined here, not left loose, because the package joins a run
+ * of caller blocks that share a `cache_control` anyway. Joining first is what
+ * makes the breakpoint land on one deterministic block.
  *
- * Path B (boundary mode): shouldUseGlobalCacheScope() && boundary marker found
- *   - billing → cacheScope: null
- *   - identity → cacheScope: null (NO cache_control in boundary mode!)
- *   - static blocks (before boundary, joined) → cacheScope: 'global'
- *   - dynamic blocks (after boundary, joined) → cacheScope: null
- *
- * Path C (fallback): no global cache feature or no boundary
- *   - billing → cacheScope: null
- *   - identity → cacheScope: 'org'
- *   - rest (joined) → cacheScope: 'org'
+ * Boundary mode (`cache_policy.boundary_marker`, or
+ * `CLAUDE_CODE_FORCE_GLOBAL_CACHE`): everything before the marker is the static
+ * half and takes a `scope: 'global'` breakpoint; everything after is the
+ * dynamic half and takes none.
  *
  * @param {Array<{text: string}>} blocks - Already sanitized/filtered text blocks
- * @param {string | undefined} attributionHeader - The billing header text (or undefined)
- * @param {string} identityString - The identity prefix string
- * @param {boolean} useBoundaryMode - Whether to use Path B (global cache with boundary)
+ * @param {boolean} useBoundaryMode
  * @returns {Array<{text: string, cacheScope: 'global' | 'org' | null}>}
  */
-export function splitSysPromptPrefix(blocks, attributionHeader, identityString, useBoundaryMode) {
-  // Separate known blocks from rest, matching real CC's parsing loop
-  const rest = [];
-  for (const block of blocks) {
-    if (!block.text) continue;
-    // Skip if it's a billing header or identity string (already extracted)
-    if (block.text.startsWith("x-anthropic-billing-header:")) continue;
-    if (KNOWN_IDENTITY_STRINGS.has(block.text)) continue;
-    // Skip the boundary marker itself (real CC skips it in Path A, processes it in Path B)
-    if (block.text === SYSTEM_PROMPT_DYNAMIC_BOUNDARY) continue;
-    rest.push(block.text);
-  }
+export function splitSystemCacheScopes(blocks, useBoundaryMode) {
+  const isDroppedBlock = (text) =>
+    !text ||
+    text.startsWith(BILLING_HEADER_PREFIX) ||
+    KNOWN_IDENTITY_STRINGS.has(text) ||
+    text === SYSTEM_PROMPT_DYNAMIC_BOUNDARY;
 
-  // ====================================================================
-  // Path B: Global cache with boundary marker
-  // Real CC (utils/api.ts:219-262): when shouldUseGlobalCacheScope() &&
-  // boundary marker is found in the system prompt array.
-  // ====================================================================
   if (useBoundaryMode) {
-    // Find boundary marker in the ORIGINAL block array (before filtering)
     const boundaryIndex = blocks.findIndex((b) => b.text === SYSTEM_PROMPT_DYNAMIC_BOUNDARY);
 
     if (boundaryIndex !== -1) {
-      // Classify blocks as static (before boundary) or dynamic (after boundary)
       const staticBlocks = [];
       const dynamicBlocks = [];
       for (let i = 0; i < blocks.length; i++) {
         const text = blocks[i].text;
-        if (!text) continue;
-        if (text === SYSTEM_PROMPT_DYNAMIC_BOUNDARY) continue;
-        if (text.startsWith("x-anthropic-billing-header:")) continue;
-        if (KNOWN_IDENTITY_STRINGS.has(text)) continue;
+        if (isDroppedBlock(text)) continue;
         if (i < boundaryIndex) {
           staticBlocks.push(text);
         } else {
@@ -464,34 +355,40 @@ export function splitSysPromptPrefix(blocks, attributionHeader, identityString,
       }
 
       const result = [];
-      if (attributionHeader) result.push({ text: attributionHeader, cacheScope: null });
-      // Identity: cacheScope null in boundary mode (real CC behavior)
-      result.push({ text: identityString, cacheScope: null });
       const staticJoined = staticBlocks.join("\n");
       if (staticJoined) result.push({ text: staticJoined, cacheScope: "global" });
       const dynamicJoined = dynamicBlocks.join("\n");
       if (dynamicJoined) result.push({ text: dynamicJoined, cacheScope: null });
       return result;
     }
-    // Boundary marker not found — fall through to Path C
+    // Boundary marker not found — fall through to the single-breakpoint shape.
   }
 
-  // ====================================================================
-  // Path C (fallback) / Path A (tool-based): no boundary or no global cache
-  // Real CC (utils/api.ts:264-289): identity and rest get cacheScope 'org'
-  // Path A produces identical wire output to Path C.
-  // ====================================================================
-  const result = [];
-  if (attributionHeader) result.push({ text: attributionHeader, cacheScope: null });
-  result.push({ text: identityString, cacheScope: "org" });
+  const rest = [];
+  for (const block of blocks) {
+    if (isDroppedBlock(block.text)) continue;
+    rest.push(block.text);
+  }
   const restJoined = rest.join("\n");
-  if (restJoined) result.push({ text: restJoined, cacheScope: "org" });
-  return result;
+  return restJoined ? [{ text: restJoined, cacheScope: "org" }] : [];
 }
 
 /**
+ * Apply the HOST system-prompt policy to an already-normalized block array.
+ *
+ * This is host policy ONLY. The Claude Code canonical prefix (billing block +
+ * identity block) is composed by `@tormentalabs/claude-code-wire-compat`, which
+ * also drops any caller block byte-equal to the identity text — so the prefix
+ * reaches the wire exactly once and the plugin never emits it.
+ *
+ * What stays here, in order:
+ *  1. sanitize (OpenCode -> Claude Code) + compaction
+ *  2. title-generator swap, or dedupe of near-identical blocks
+ *  3. anti-verbosity injection (Opus 4.6/4.7, unless simple-system-prompt mode)
+ *  4. host prompt-cache breakpoint placement
+ *
  * @param {Array<{type: string, text: string, cache_control?: {type: string}}>} system
- * @param {{enabled: boolean, claudeCliVersion: string, promptCompactionMode: 'minimal' | 'off', cachePolicy?: {ttl: string, ttl_supported: boolean, boundary_marker?: boolean}}} signature
+ * @param {{promptCompactionMode: 'minimal' | 'off', modelId?: string, simpleSystemPrompt?: boolean, antiVerbosity?: {enabled?: boolean}, cachePolicy?: {ttl: string, ttl_supported: boolean, boundary_marker?: boolean}}} signature
  * @returns {Array<{type: string, text: string, cache_control?: {type: string}}>}
  */
 export function buildSystemPromptBlocks(system, signature) {
@@ -502,40 +399,6 @@ export 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") {
@@ -567,62 +430,14 @@ export function buildSystemPromptBlocks(system, signature) {
     }
   }
 
-  if (!signature.enabled) {
-    return sanitized;
-  }
-
-  // Lean system prompt for non-main requests (title-gen is already handled
-  // above via the COMPACT_TITLE_GENERATOR_SYSTEM_PROMPT swap). For "title"
-  // and "small" request roles — one-off queries that don't belong to the main
-  // REPL thread — we skip billing identity + CC identity injection. This
-  // matches the spirit of real CC's querySource gates: identity context is
-  // for interactive main-thread conversations, not fire-and-forget calls.
-  // Opt-in (default off) because it changes the system-prompt shape.
-  const leanNonMain =
-    signature.leanNonMain === true &&
-    (signature.requestRole === "title" || signature.requestRole === "small") &&
-    !titleGeneratorRequest;
-  if (leanNonMain) {
-    return sanitized;
-  }
-
-  // Build attribution header
-  const billingHeader = buildAnthropicBillingHeader(
-    signature.claudeCliVersion,
-    signature.firstUserMessage,
-    signature.workload,
-  );
-
-  // Select the identity string (matches real CC getCLISyspromptPrefix())
-  const identityString = getCLISyspromptPrefix();
-
-  // Determine cache policy
+  // Host prompt-cache breakpoint. The canonical prefix is NOT built here — the
+  // package prepends its own billing + identity blocks and drops a caller block
+  // equal to the identity text, so the prefix lands on the wire exactly once.
   const effectiveCachePolicy = signature.cachePolicy || { ttl: "1h", ttl_supported: true };
-
-  // Determine if we should use boundary mode (Path B)
-  // Real CC: shouldUseGlobalCacheScope() is a GrowthBook feature flag.
-  // We simulate it via config: boundary_marker=true or CLAUDE_CODE_FORCE_GLOBAL_CACHE=1.
   const useBoundaryMode =
     effectiveCachePolicy.boundary_marker || isTruthyEnv(process.env.CLAUDE_CODE_FORCE_GLOBAL_CACHE);
 
-  // Run the real CC splitSysPromptPrefix algorithm to get blocks with cacheScope
-  const scopedBlocks = splitSysPromptPrefix(sanitized, billingHeader || undefined, identityString, useBoundaryMode);
-
-  // Adapter path only: the shared package prepends its OWN billing block
-  // (index 0) and identity block (index 1), each with its own cache_control
-  // marker. Emitting ours too would duplicate both blocks on the wire.
-  //
-  // This is CONDITIONAL, never unconditional: the legacy path (any request the
-  // signature-emulation adapter declines — non-Anthropic provider, or emulation
-  // off) still builds the request through buildRequestHeaders and depends on
-  // these two blocks being present. Dropping them for every caller would break
-  // that path silently — no error, just a wrong request on the wire.
-  const emittedBlocks =
-    signature.suppressCanonicalBlocks === true ? dropCanonicalPrefixBlocks(scopedBlocks, identityString) : scopedBlocks;
-
-  // Convert scoped blocks to wire format using getCacheControlForScope
-  // (mirrors real CC buildSystemPromptBlocks → map + getCacheControl)
-  return emittedBlocks.map((block) => {
+  return splitSystemCacheScopes(sanitized, useBoundaryMode).map((block) => {
     const cc = getCacheControlForScope(block.cacheScope, effectiveCachePolicy);
     return {
       type: "text",
@@ -631,39 +446,3 @@ export function buildSystemPromptBlocks(system, signature) {
     };
   });
 }
-
-/**
- * Drop the two canonical prefix blocks the shared package prepends itself.
- *
- * Both are matched with the SAME predicates `splitSysPromptPrefix` uses to
- * recognise them on input, and only the FIRST occurrence of each is removed, so
- * a caller-supplied block that happens to repeat the identity string survives.
- *
- * @param {{text: string, cacheScope: string | null}[]} blocks
- * @param {string} identityString
- * @returns {{text: string, cacheScope: string | null}[]}
- */
-function dropCanonicalPrefixBlocks(blocks, identityString) {
-  let billingDropped = false;
-  let identityDropped = false;
-  return blocks.filter((block) => {
-    const text = typeof block.text === "string" ? block.text : "";
-    if (!billingDropped && text.startsWith(BILLING_HEADER_PREFIX)) {
-      billingDropped = true;
-      return false;
-    }
-    if (!identityDropped && text === identityString) {
-      identityDropped = true;
-      return false;
-    }
-    return true;
-  });
-}
-
-export function getCachedCCPrompt() {
-  return cachedCCPrompt;
-}
-
-export function resetCachedCCPrompt() {
-  cachedCCPrompt = null;
-}