@tormentalabs/claude-code-wire-compat 0.1.0-rc.16 → 0.1.0

package/CHANGELOG.md

@@ -2,7 +2,138 @@
 
 All notable changes to this project will be documented in this file.
 
-## [0.1.0-rc.16] - Unreleased
+## [0.1.0] - 2026-07-28
+
+First stable release.
+
+There is NO runtime code change relative to `0.1.0-rc.17`:
+`git diff --stat 5c6881b d7e2901 -- src package.json` is empty, so `dist/` is
+byte-identical to the `0.1.0-rc.17` build. Everything this release contains is
+described in the release candidate entries below; they are not repeated here.
+The packed content differs from `0.1.0-rc.17` by `README.md` and by the added
+TypeScript sources described below — the executed code is unchanged, which
+`npm run test:pack` confirms by an unchanged consumer digest.
+
+### Added
+
+- **The tarball now ships the TypeScript sources.** `src` is added to the
+  `files` allowlist. The build emits 40 `.js.map` and `.d.ts.map` files that
+  reference `../src/*.ts` and carry no `sourcesContent`, so every source map in
+  the published package resolved to nothing in a consumer's debugger. Shipping
+  the sources is also the coherent option for a GPL-3.0-or-later package whose
+  `NOTICE` already offers corresponding source: the offer and the tarball now
+  agree. Only `.ts` files are packed under `src/`, pinned exactly by
+  `test/pack/pack-policy.test.ts`; the allowlist itself is pinned by
+  `test/governance/release-policy.test.ts` and
+  `test/governance/package-policy.test.ts`.
+- The ported protocol-documentation corpus and `docs/ATTRIBUTION.md` are now in
+  the repository. Neither is packed into the tarball.
+
+### Changed
+
+- `README.md` no longer describes the package as a bootstrap release candidate
+  whose request-building behavior arrives later. That statement was false — the
+  package builds and parses requests — and it was the text rendered on the
+  npmjs.com package page.
+
+## [0.1.0-rc.17] - 2026-07-28
+
+### Added
+
+- **Root `suppressIdentityBlock` (seam S8).** The canonical identity block was
+  composed unconditionally, so a consumer switch whose meaning is "send neither
+  canonical block" — `token_economy.lean_system_non_main` in the `opencode`
+  plugin, which removed billing AND identity before it migrated to this package
+  — was a silent no-op. `suppressIdentityBlock: true` omits the identity block
+  entirely, which with `suppressBillingBlock` makes four canonical prefixes
+  legitimate: `[billing, identity]`, `[identity]`, `[billing]` and `[]`. Only a
+  boolean is accepted; anything else is `INVALID_INPUT`.
+  `evidence.identityBlockSuppressed` is emitted only when the block was actually
+  removed, mirroring `billingBlockSuppressed` exactly, so evidence stays
+  byte-identical for every request that ignores the seam. Recorded in
+  `docs/source-trace.md` as governance ledger L16.
+
+  This is a DIFFERENT field from the L10 `cacheControl.suppressIdentityBlock`,
+  which keeps the block and drops only its `cache_control` marker. The name
+  collision is deliberate — symmetry with `suppressBillingBlock` at the root was
+  judged worth more than a novel name — and the JSDoc of each field states what
+  it does and names the other by its full path.
+
+  The caller-block drop stays UNCONDITIONAL: a caller block byte-equal to the
+  identity text is removed even when the canonical one was suppressed, matching
+  the genuine client and keeping the parser's absence check below sound.
+
+- **`preserveThinkingBlockCacheControl` (seam S9).** `thinking` and
+  `redacted_thinking` blocks were pinned to a strict allowlist — `signature`,
+  `thinking`, `type` and `data`, `type` — so a request carrying `cache_control`
+  on a reasoning block was rejected outright with `INVALID_INPUT`. The consumer
+  had no legal way out, and this is a PRODUCTION failure rather than a test
+  artefact: the Anthropic API answers a mutated reasoning block with
+
+  > `400 ... thinking or redacted_thinking blocks in the latest assistant`
+  > `message cannot be modified. These blocks must remain as they were in the`
+  > `original response.`
+
+  so `delete block.cache_control` before the call is itself the modification
+  that triggers the 400. `preserveThinkingBlockCacheControl: true` accepts the
+  key and copies it to the body VERBATIM — caller key order intact, no TTL
+  applied, no breakpoint placed. Only a boolean is accepted; anything else is
+  `INVALID_INPUT`.
+
+  The allowlist grows by `cache_control` and by NOTHING else: an unknown key on
+  a reasoning block is still `INVALID_INPUT` with the seam active. The value
+  passes the same `cache_control` validator every other block uses —
+  `{ type: "ephemeral" }` with an optional `ttl` — so a malformed marker still
+  fails closed; the `scope` key that `text` blocks tolerate for legacy reasons
+  is deliberately NOT accepted, the API never returning it on a reasoning block.
+  The marker takes no part in this package's cache-control machinery:
+  `applySystemCacheControl` is untouched and `applyMessageCacheControl` already
+  exempts reasoning blocks from both the strip and the breakpoint pass.
+
+  `evidence.thinkingBlockCacheControlPreserved` is emitted only when the seam
+  was active AND at least one emitted block actually carried a marker — opting
+  in without using it records nothing — mirroring `billingBlockSuppressed`
+  exactly, so evidence stays byte-identical for every request that ignores the
+  seam. `parseBuiltClaudeCodeRequest` CONFIRMS that claim against the body
+  before it checks byte length or digest, so a forgery that is byte-length
+  preserving and evidence-self-consistent is refused by the structural check
+  rather than incidentally by arithmetic. Recorded in `docs/source-trace.md` as
+  governance ledger L17.
+
+### Changed
+
+- **`parseBuiltClaudeCodeRequest` no longer INFERS the canonical prefix from the
+  identity block's position; it READS the length from evidence and VERIFIES it
+  structurally.** With two independent seams an empty prefix is
+  indistinguishable from a caller-only array, so position inference is no longer
+  decidable: the rc.16 discriminator would have hit its unconditional failure
+  path on every request built with both seams active. The parser now takes
+  `evidence.billingBlockSuppressed` and `evidence.identityBlockSuppressed` as
+  the claimed prefix length and confirms every block that claim implies —
+  billing by its fixed `x-anthropic-billing-header: cc_version=` head (the tail
+  is per-request), identity by the byte-exact identity text. This is strictly
+  stronger than what it replaces, which never inspected the billing slot at all:
+  an envelope built with `suppressBillingBlock` whose evidence hid that fact was
+  previously accepted.
+
+  Verification is **asymmetric, deliberately**. A claim that identity was
+  suppressed is refuted by finding the identity text ANYWHERE in the array,
+  which is sound because `buildCanonicalSystem` drops caller blocks equal to it
+  unconditionally and merges runs with `\n`, so the text cannot legitimately
+  survive. There is no mirror check for billing: a caller block may legitimately
+  begin with the billing header text, so its presence proves nothing.
+
+  The match is on TEXT, never on `cache_control` — the L10 seam can legitimately
+  emit the identity block with no marker — and the assertion remains an
+  EQUALITY.
+
+- **`emittedSystemBlockCount` is computed from both seams instead of a
+  constant.** `CANONICAL_SYSTEM_BLOCKS` and `CANONICAL_SYSTEM_BLOCKS_WITHOUT_BILLING`
+  were removed: a constant cannot express the empty prefix the two seams produce
+  together. The build path now subtracts one slot per canonical block that
+  actually survived.
+
+## [0.1.0-rc.16] - 2026-07-28
 
 ### Added
 

package/README.md

@@ -4,7 +4,7 @@ Claude Wire Compat
 
 An ESM-only, runtime-neutral TypeScript package for constructing a pinned Claude Code Messages wire contract.
 
-> **Status:** bootstrap release candidate. Runtime request-building behavior is intentionally introduced in later releases.
+> **Status:** stable. `buildClaudeCodeRequest` and `parseBuiltClaudeCodeRequest` build and read back the pinned wire contract. The package performs no I/O: credentials, transport, persistence, refresh coordination, and retries remain the consumer's responsibility.
 
 ## Package
 
@@ -18,6 +18,58 @@ The package targets Node.js 20 or newer and is designed to remain portable to Bu
 
 The only accepted `profile` value is the exported `CLAUDE_CODE_2_1_195_PROFILE` singleton. Any other object, even a structurally identical clone, is rejected with `ClaudeCodeWireError` code `INVALID_INPUT`. This deliberate fail-closed behaviour prevents callers from substituting an unpinned protocol profile.
 
+## Protocol documentation
+
+The wire contract this package pins was reverse engineered before it was
+implemented. That research is preserved under [`docs/protocol/`](./docs/protocol)
+so a future maintainer can re-derive the contract when Claude Code ships a new
+version. It is ported verbatim from
+[opencode-anthropic-fix](https://github.com/marco-jardim/opencode-anthropic-fix)
+at commit `466d500` under GPL-3.0-or-later; every file carries a provenance
+header and is listed in [docs/ATTRIBUTION.md](./docs/ATTRIBUTION.md).
+
+**These documents describe the upstream plugin and Claude Code itself, not this
+package's API.** The normative mapping from those findings to this package's
+contract is [docs/source-trace.md](./docs/source-trace.md).
+
+Protocol knowledge corpus:
+
+- [Reverse engineering](./docs/protocol/reverse-engineering.md) — the full
+  authentication and API reverse-engineering record.
+- [HTTP headers and system prompt](./docs/protocol/http-headers-and-system-prompt.md)
+  — header composition and system-prompt mimicry.
+- [Fingerprint extraction](./docs/protocol/fingerprint-extraction.md) — how the
+  client fingerprint and metadata are derived.
+- [Message flow](./docs/protocol/message-flow.md) — end-to-end request and
+  response flow.
+- [Tool use examples](./docs/protocol/tool-use-examples.md) — tool_use and
+  tool_result pairing in practice.
+- [Code comparison reference](./docs/protocol/code-comparison-reference.md) —
+  side-by-side comparison against the genuine client.
+- [Divergence analysis](./docs/protocol/divergence-analysis.md) — every observed
+  divergence from the genuine client.
+- [Divergence executive summary](./docs/protocol/divergence-executive-summary.md)
+  — the condensed version of that analysis.
+- [Quick reference](./docs/protocol/quick-reference.md) — condensed lookup of
+  headers, betas, and switches.
+- [System-prompt search results](./docs/protocol/system-prompt-search-results.md)
+  — where each system-prompt fragment was found in the analysed build.
+- [Cache transparency](./docs/protocol/cache-transparency.md) — anti-verbosity
+  and prompt-cache observability.
+- [Beta decision table](./docs/protocol/beta-decision-table.md) — which beta
+  identifiers are sent under which conditions.
+
+Per-version wire analyses — [why they exist and when a new one is
+required](./docs/protocol/versions/README.md):
+
+- [Claude Code 2.1.119](./docs/protocol/versions/claude-code-2.1.119-analysis.md)
+- [Claude Code 2.1.133](./docs/protocol/versions/claude-code-2.1.133-analysis.md)
+- [Claude Code 2.1.143](./docs/protocol/versions/claude-code-2.1.143-analysis.md)
+- [Claude Code 2.1.150](./docs/protocol/versions/claude-code-2.1.150-analysis.md)
+- [Claude Code 2.1.159](./docs/protocol/versions/claude-code-2.1.159-analysis.md)
+- [Claude Code 2.1.195](./docs/protocol/versions/claude-code-2.1.195-analysis.md)
+  — the release this package's profile pins.
+
 ## Development
 
 ```sh

package/dist/build-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-request.d.ts","sourceRoot":"","sources":["../src/build-request.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,iCAAiC,EACjC,sBAAsB,EAMtB,yBAAyB,EACzB,0BAA0B,EAC1B,sBAAsB,EAGvB,MAAM,gBAAgB,CAAC;AA+mCxB,2DAA2D;AAC3D,wBAAsB,iCAAiC,CACrD,KAAK,EAAE,0BAA0B,EACjC,OAAO,GAAE,yBAAuD,GAC/D,OAAO,CAAC,iCAAiC,CAAC,CAiF5C;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,sBAAsB,EAC7B,OAAO,GAAE,yBAAuD,GAC/D,OAAO,CAAC,sBAAsB,CAAC,CA6IjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,yBAAuD,GAC/D,sBAAsB,CAgFxB"}
+{"version":3,"file":"build-request.d.ts","sourceRoot":"","sources":["../src/build-request.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,iCAAiC,EACjC,sBAAsB,EAMtB,yBAAyB,EACzB,0BAA0B,EAC1B,sBAAsB,EAGvB,MAAM,gBAAgB,CAAC;AAwvCxB,2DAA2D;AAC3D,wBAAsB,iCAAiC,CACrD,KAAK,EAAE,0BAA0B,EACjC,OAAO,GAAE,yBAAuD,GAC/D,OAAO,CAAC,iCAAiC,CAAC,CAiF5C;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,sBAAsB,EAC7B,OAAO,GAAE,yBAAuD,GAC/D,OAAO,CAAC,sBAAsB,CAAC,CA8JjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,yBAAuD,GAC/D,sBAAsB,CA+FxB"}

package/dist/build-request.js

@@ -54,6 +54,8 @@ const INPUT_KEYS = new Set([
     "additionalBetas",
     "suppressBetas",
     "suppressBillingBlock",
+    "suppressIdentityBlock",
+    "preserveThinkingBlockCacheControl",
     "betaOverrides",
     "metadataOverrides",
     "extraHeaders",
@@ -81,10 +83,16 @@ const COUNT_TOKENS_INPUT_KEYS = new Set([
     "extraHeaders",
 ]);
 const BUILT_KEYS = new Set(["url", "method", "headers", "body", "evidence"]);
-/** Counts the billing and identity blocks of the default canonical prefix. */
-const CANONICAL_SYSTEM_BLOCKS = 2;
-/** Counts the identity block alone, once `suppressBillingBlock` removed billing. */
-const CANONICAL_SYSTEM_BLOCKS_WITHOUT_BILLING = 1;
+/**
+ * The self-describing prefix of the canonical billing block's text.
+ *
+ * `buildBillingBlock` emits
+ * `x-anthropic-billing-header: cc_version=<version>.<fingerprint>; ...`, whose
+ * tail varies per request, so only this fixed head can anchor a structural
+ * check. It is what lets the parser CONFIRM that a request which claims to
+ * carry the billing block actually carries it.
+ */
+const BILLING_BLOCK_TEXT_PREFIX = "x-anthropic-billing-header: cc_version=";
 const EVIDENCE_KEYS = new Set([
     "profileId",
     "url",
@@ -100,6 +108,8 @@ const EVIDENCE_KEYS = new Set([
     "droppedExtraHeaderNames",
     "suppressedBetaNames",
     "billingBlockSuppressed",
+    "identityBlockSuppressed",
+    "thinkingBlockCacheControlPreserved",
 ]);
 const CAPABILITY_KEYS = [
     "thinking",
@@ -511,6 +521,26 @@ function validateExtraHeaderPolicy(value) {
 function validateSuppressBillingBlock(value) {
     return parseBoolean(value);
 }
+/**
+ * Validates the package-extension identity-block suppression flag.
+ *
+ * Same contract as `validateSuppressBillingBlock`: only a boolean states a
+ * decision, because coercing a truthy string would silently drop a canonical
+ * block the genuine client always sends.
+ */
+function validateSuppressIdentityBlock(value) {
+    return parseBoolean(value);
+}
+/**
+ * Validates the package-extension thinking-block `cache_control` seam flag.
+ *
+ * Same contract as the suppression flags: only a boolean states a decision,
+ * because coercing a truthy string would silently widen the thinking-block
+ * allowlist this package pins against the genuine client.
+ */
+function validatePreserveThinkingBlockCacheControl(value) {
+    return parseBoolean(value);
+}
 function createEffectiveProfile(pinnedProfile, override) {
     if (override === undefined)
         return pinnedProfile;
@@ -573,6 +603,12 @@ function validateInput(input) {
     const suppressBillingBlock = Object.hasOwn(input, "suppressBillingBlock")
         ? validateSuppressBillingBlock(ownValue(input, "suppressBillingBlock"))
         : false;
+    const suppressIdentityBlock = Object.hasOwn(input, "suppressIdentityBlock")
+        ? validateSuppressIdentityBlock(ownValue(input, "suppressIdentityBlock"))
+        : false;
+    const preserveThinkingBlockCacheControl = Object.hasOwn(input, "preserveThinkingBlockCacheControl")
+        ? validatePreserveThinkingBlockCacheControl(ownValue(input, "preserveThinkingBlockCacheControl"))
+        : false;
     return {
         source: input,
         clientRequestId,
@@ -581,6 +617,8 @@ function validateInput(input) {
         betaOverrides,
         extraHeaderPolicy,
         suppressBillingBlock,
+        suppressIdentityBlock,
+        preserveThinkingBlockCacheControl,
     };
 }
 function validateCountTokensInput(input) {
@@ -818,33 +856,102 @@ function parseEvidence(value) {
                 billingBlockSuppressed: parseBoolean(ownValue(value, "billingBlockSuppressed")),
             }
             : {}),
+        ...(Object.hasOwn(value, "identityBlockSuppressed")
+            ? {
+                identityBlockSuppressed: parseBoolean(ownValue(value, "identityBlockSuppressed")),
+            }
+            : {}),
+        // Rehydrated here because `assertExactKeys` above already accepts the key:
+        // omitting this branch would silently DROP it, and the round-trip equality
+        // every seam test asserts would fail on an envelope that is entirely legal.
+        ...(Object.hasOwn(value, "thinkingBlockCacheControlPreserved")
+            ? {
+                thinkingBlockCacheControlPreserved: parseBoolean(ownValue(value, "thinkingBlockCacheControlPreserved")),
+            }
+            : {}),
     };
 }
+/** Reads an own property of a value that is not asserted to be a record. */
+function ownProperty(value, key) {
+    return isRecord(value) && Object.hasOwn(value, key)
+        ? ownValue(value, key)
+        : undefined;
+}
+/**
+ * Reports whether the emitted `messages` carry a reasoning block that actually
+ * kept a `cache_control` key.
+ *
+ * This is what makes `evidence.thinkingBlockCacheControlPreserved` a record of
+ * what the seam DID rather than of what it was allowed to do, and it is the
+ * check that refutes an envelope claiming the seam over a body carrying no such
+ * block. Presence of the KEY is the test, not truthiness: `cache_control: null`
+ * is a preserved marker too, exactly as it is on every other block type.
+ */
+function hasThinkingBlockCacheControl(messages) {
+    if (!Array.isArray(messages))
+        return false;
+    return messages.some((message) => {
+        const content = ownProperty(message, "content");
+        return (Array.isArray(content) &&
+            content.some((block) => {
+                const type = ownProperty(block, "type");
+                return ((type === "thinking" || type === "redacted_thinking") &&
+                    ownProperty(block, "cache_control") !== undefined);
+            }));
+    });
+}
 /** Reads a system block's `text` without asserting the block's shape. */
 function systemBlockText(block) {
-    return isRecord(block) && Object.hasOwn(block, "text")
-        ? ownValue(block, "text")
-        : undefined;
+    return ownProperty(block, "text");
+}
+/** Recognises the canonical billing block by its fixed, self-describing head. */
+function isBillingBlockText(text) {
+    return typeof text === "string" && text.startsWith(BILLING_BLOCK_TEXT_PREFIX);
 }
 /**
- * Infers how many canonical blocks the emitted `system` array carries.
+ * VERIFIES how many canonical blocks the emitted `system` array carries.
+ *
+ * The root seams `suppressBillingBlock` and `suppressIdentityBlock` make four
+ * prefixes legitimate — `[billing, identity]`, `[identity]`, `[billing]` and
+ * `[]` — so no probe over the array alone can tell them apart: an empty prefix
+ * is indistinguishable from a caller-only array. The prefix length is therefore
+ * READ from the evidence flags, which the builder emits only when suppression
+ * actually removed a block.
  *
- * The prefix used to be the constant `CANONICAL_SYSTEM_BLOCKS`, but
- * `suppressBillingBlock` makes it either `[billing, identity]` or `[identity]`.
- * The discriminator is therefore the POSITION of the pinned identity text, not
- * arithmetic over the array length and never `cache_control`: the
- * `suppressIdentityBlock` seam can emit the identity block with no cache
- * marker, so a marker probe would misread a legitimate request. An array whose
- * identity block sits at neither position was not produced by this package.
+ * Evidence is not trusted blindly. Each block the flags claim is present is
+ * confirmed in place: billing by its `x-anthropic-billing-header: cc_version=`
+ * head (its tail is per-request), identity by the byte-exact `IDENTITY_TEXT`;
+ * a claim that identity was suppressed is confirmed by that text being absent
+ * from the whole array. This is strictly stronger than the position probe it
+ * replaces, which never checked the billing slot at all. Never `cache_control`:
+ * the
+ * `cacheControl.suppressIdentityBlock` seam can emit the identity block with no
+ * marker, so a marker probe would misread a legitimate request.
  */
-function canonicalSystemPrefixLength(system) {
-    if (systemBlockText(system[1]) === IDENTITY_TEXT) {
-        return CANONICAL_SYSTEM_BLOCKS;
+function canonicalSystemPrefixLength(system, billingSuppressed, identitySuppressed) {
+    let index = 0;
+    if (!billingSuppressed) {
+        if (!isBillingBlockText(systemBlockText(system[index])))
+            fail();
+        index += 1;
     }
-    if (systemBlockText(system[0]) === IDENTITY_TEXT) {
-        return CANONICAL_SYSTEM_BLOCKS_WITHOUT_BILLING;
+    if (identitySuppressed) {
+        // The identity text cannot appear ANYWHERE in a body built with the seam
+        // active: `buildCanonicalSystem` drops a caller block equal to it
+        // unconditionally, and merging joins with `\n`, so no merged run can equal
+        // it either. Absence is therefore checkable, which is what refutes a claim
+        // of suppression made over a body that still carries the block.
+        //
+        // No mirror check exists for billing: a caller block may legitimately begin
+        // with the billing header text, so its presence proves nothing.
+        if (system.some((block) => systemBlockText(block) === IDENTITY_TEXT)) {
+            fail();
+        }
+        return index;
     }
-    return fail();
+    if (systemBlockText(system[index]) !== IDENTITY_TEXT)
+        fail();
+    return index + 1;
 }
 function parseBody(value) {
     let parsed;
@@ -916,6 +1023,12 @@ function evidenceRequest(input, callerModel) {
         request.capabilities = input.capabilities;
     if (input.betaOverrides !== undefined)
         request.betaOverrides = input.betaOverrides;
+    // The body builder owns the thinking-block allowlist, so the seam flag has to
+    // reach it. It is forwarded only when the caller stated it, keeping the
+    // normalized request shape identical for every request that ignores the seam.
+    if (input.preserveThinkingBlockCacheControl !== undefined)
+        request.preserveThinkingBlockCacheControl =
+            input.preserveThinkingBlockCacheControl;
     if (input.thinking !== undefined)
         request.thinking = input.thinking;
     if (input.effort !== undefined)
@@ -1036,7 +1149,7 @@ export async function buildClaudeCodeRequest(input, profile = CLAUDE_CODE_2_1_19
         });
         const billing = await createBillingBlock(fingerprintText(validated.source), effectiveProfile.cliVersion, validated.crypto);
         const metadata = buildCorrelatedMetadata(identity, validated.source.metadata, validated.source.metadataOverrides);
-        const system = buildCanonicalSystem(validated.source.system, billing, identity, validated.suppressBillingBlock);
+        const system = buildCanonicalSystem(validated.source.system, billing, identity, validated.suppressBillingBlock, validated.suppressIdentityBlock);
         const canonicalBody = buildCanonicalBody(evidenceRequest(validated.source, validated.source.model), effectiveModel, system, metadata, effectiveProfile);
         const composedBetas = composeBetasWithAudit({
             rawModel: validated.source.model,
@@ -1089,10 +1202,12 @@ export async function buildClaudeCodeRequest(input, profile = CLAUDE_CODE_2_1_19
             // The canonical system merges adjacent caller blocks and drops any
             // block equal to the identity text, so only the emitted count keeps
             // `systemBlockCount === body.system.length - <canonical>` true.
+            // Symmetric arithmetic over the two suppression seams: each canonical
+            // block that survived costs one slot. A single constant cannot express
+            // the empty prefix both seams together produce.
             emittedSystemBlockCount: system.length -
-                (validated.suppressBillingBlock
-                    ? CANONICAL_SYSTEM_BLOCKS_WITHOUT_BILLING
-                    : CANONICAL_SYSTEM_BLOCKS),
+                (validated.suppressBillingBlock ? 0 : 1) -
+                (validated.suppressIdentityBlock ? 0 : 1),
             // Emitted only for the opted-in policy, so evidence for every other
             // request keeps the shape it had before the seam existed.
             ...(validated.extraHeaderPolicy === "dropConflicting"
@@ -1109,6 +1224,20 @@ export async function buildClaudeCodeRequest(input, profile = CLAUDE_CODE_2_1_19
             ...(validated.suppressBillingBlock
                 ? { billingBlockSuppressed: true }
                 : {}),
+            // Emitted only when the identity block was actually removed, on the
+            // same terms as `billingBlockSuppressed`: the parser reads both flags
+            // to know the length of the canonical prefix it must verify.
+            ...(validated.suppressIdentityBlock
+                ? { identityBlockSuppressed: true }
+                : {}),
+            // Emitted only when the seam was active AND a reasoning block actually
+            // carried the marker. Opting in without using it records nothing, so
+            // the audit states what happened on the wire rather than what the
+            // caller was permitted to do.
+            ...(validated.preserveThinkingBlockCacheControl &&
+                hasThinkingBlockCacheControl(canonicalBody["messages"])
+                ? { thinkingBlockCacheControlPreserved: true }
+                : {}),
         }, validated.crypto);
         return deepFreeze({
             url: effectiveProfile.endpoint,
@@ -1148,6 +1277,15 @@ export function parseBuiltClaudeCodeRequest(value, profile = CLAUDE_CODE_2_1_195
         const parsedBody = parseBody(body);
         const headers = parseHeaders(ownValue(value, "headers"));
         const evidence = parseEvidence(ownValue(value, "evidence"));
+        // Reading evidence is not trusting evidence. A claim that the seam
+        // preserved a marker is confirmed against the body, and it is confirmed
+        // HERE — before the byte-length and digest checks — so that a forgery which
+        // is byte-length preserving and evidence-self-consistent is refused by the
+        // structural check rather than incidentally by arithmetic.
+        if (evidence.thinkingBlockCacheControlPreserved === true &&
+            !hasThinkingBlockCacheControl(parsedBody["messages"])) {
+            fail();
+        }
         const sessionId = headerValue(headers, "x-claude-code-session-id");
         const additionalHeaders = splitDynamicAndExtraHeaders(headers);
         const expectedHeaders = buildOrderedHeaders({
@@ -1186,7 +1324,7 @@ export function parseBuiltClaudeCodeRequest(value, profile = CLAUDE_CODE_2_1_195
             evidence.systemBlockCount !==
                 (Array.isArray(parsedBody["system"])
                     ? parsedBody["system"].length -
-                        canonicalSystemPrefixLength(parsedBody["system"])
+                        canonicalSystemPrefixLength(parsedBody["system"], evidence.billingBlockSuppressed === true, evidence.identityBlockSuppressed === true)
                     : -1)) {
             fail();
         }