diff --git a/.github/scripts/pr-carry-attribution.cjs b/.github/scripts/pr-carry-attribution.cjs
index fa4894330d8..401b3b50ba2 100644
--- a/.github/scripts/pr-carry-attribution.cjs
+++ b/.github/scripts/pr-carry-attribution.cjs
@@ -49,7 +49,16 @@ const SENTENCE_END_RE = /[.!?](?:\s|$)|\n/;
 function carryWindow(text, from) {
   const slice = text.slice(from, from + 80);
   const end = slice.search(SENTENCE_END_RE);
-  return end === -1 ? slice : slice.slice(0, end);
+  if (end !== -1) return slice.slice(0, end);
+
+  // Finish only the number already started in this window (including a bare
+  // hash at the cap). The bounded suffix check and forward digit walk keep
+  // untrusted text linear and leave owner/repo qualifiers intact for REF_RE.
+  let to = from + slice.length;
+  if (/#\d*$/.test(slice)) {
+    while (to < text.length && text[to] >= "0" && text[to] <= "9") to++;
+  }
+  return text.slice(from, to);
 }
 
 const TRAILER_RE = /^[ \t]*co-authored-by:[ \t]*(.+)$/gim;
diff --git a/.github/scripts/pr-carry-attribution.test.cjs b/.github/scripts/pr-carry-attribution.test.cjs
index 8d94fc707ba..0f4781dfe67 100644
--- a/.github/scripts/pr-carry-attribution.test.cjs
+++ b/.github/scripts/pr-carry-attribution.test.cjs
@@ -4,6 +4,7 @@ const { describe, it } = require("node:test");
 const assert = require("node:assert/strict");
 const {
   assessCarryAttribution,
+  carryWindow,
   referencedCarryNumbers,
 } = require("./pr-carry-attribution.cjs");
 
@@ -291,6 +292,38 @@ describe("assessCarryAttribution", () => {
     assert.deepEqual(failures[0].paths, ["#3193"]);
   });
 
+  it("keeps the complete references from the #7223 subject", () => {
+    const subject = "carry Combo visibility, workspace panes, Windows picker and Gentle Shell (#7195, #6767";
+    assert.deepEqual([...referencedCarryNumbers(subject)], [7195, 6767]);
+  });
+
+  it("finishes a number or hash at the cap without admitting the next reference", () => {
+    for (const reference of ["#6767", "other/repo#6767"]) {
+      for (let included = 1; included <= 5; included++) {
+        const padding = " ".repeat(80 - reference.length + 5 - included);
+        const text = padding + reference + " #3192";
+        assert.equal(carryWindow(text, 0), padding + reference);
+        assert.deepEqual(
+          [...referencedCarryNumbers("carry" + text)],
+          reference.startsWith("#") ? [6767] : [],
+        );
+      }
+    }
+  });
+
+  it("excludes references starting at or beyond the cap and after a newline", () => {
+    for (const padding of [80, 81]) {
+      assert.deepEqual([...referencedCarryNumbers("carry" + " ".repeat(padding) + "#3192")], []);
+    }
+    assert.deepEqual([...referencedCarryNumbers("carry #3193\n#3192")], [3193]);
+  });
+
+  it("completes a long numeric suffix without scanning the following text", () => {
+    const digits = "7".repeat(100_000);
+    const text = " ".repeat(79) + "#" + digits;
+    assert.equal(carryWindow(text + " #3192", 0), text);
+  });
+
   it("reads a trailer that only exists on a branch commit", () => {
     assert.deepEqual(
       assessCarryAttribution(
diff --git a/desktop/src-tauri/Cargo.lock b/desktop/src-tauri/Cargo.lock
index 27029e21b8c..ffe3177df6b 100644
--- a/desktop/src-tauri/Cargo.lock
+++ b/desktop/src-tauri/Cargo.lock
@@ -2645,7 +2645,7 @@ dependencies = [
 
 [[package]]
 name = "opencodex-desktop"
-version = "2.87.0"
+version = "2.88.0"
 dependencies = [
  "base64 0.22.1",
  "dbus",
diff --git a/desktop/src-tauri/Cargo.toml b/desktop/src-tauri/Cargo.toml
index bf22aa60fb7..e2646bca247 100644
--- a/desktop/src-tauri/Cargo.toml
+++ b/desktop/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "opencodex-desktop"
-version = "2.87.0"
+version = "2.88.0"
 description = "OpenCodex desktop shell"
 authors = ["OpenCodex contributors"]
 license = "MIT"
diff --git a/desktop/src-tauri/tauri.conf.json b/desktop/src-tauri/tauri.conf.json
index 3f2e7ce5a4f..50ce2387eff 100644
--- a/desktop/src-tauri/tauri.conf.json
+++ b/desktop/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "OpenCodex",
-  "version": "2.87.0",
+  "version": "2.88.0",
   "identifier": "com.opencodex.desktop",
   "build": {
     "frontendDist": "../ui",
diff --git a/docs-site/src/content/docs/fr/guides/providers.md b/docs-site/src/content/docs/fr/guides/providers.md
index 1e5af166a64..ea1114dcdaa 100644
--- a/docs-site/src/content/docs/fr/guides/providers.md
+++ b/docs-site/src/content/docs/fr/guides/providers.md
@@ -396,6 +396,8 @@ des indications propres au fournisseur ainsi qu'un `Retry-After` synthétique ;
 reste prioritaire. L'attente et la nouvelle tentative avec la même clé restent facultatives et s'activent avec
 [`retryOn429`](/fr/reference/configuration/).
 
+Sur les routes officielles `https://opencode.ai/zen/v1` et `https://opencode.ai/inference/v1` du fournisseur canonique `opencode-zen` avec authentification par clé API, Gemini utilise automatiquement l’API native Google en mode `googleMode: ai-studio` (par défaut). Les identifiants Zen sont conservés, y compris Flash sans suffixe `-tiered`. Claude utilise automatiquement Anthropic Messages, quel que soit `googleMode`. Au chargement des configurations enregistrées, seules les anciennes surcharges Chat/Responses admissibles de ces modèles natifs sont ignorées, ainsi que les préférences admissibles de l’outil hébergé `image_generation` propres à Responses. Les fournisseurs personnalisés, les routes sans authentification par clé et les autres préférences restent inchangés.
+
 **Le niveau sans clé `opencode-free` est actuellement fermé aux clients tiers.** Zen refuse toute requête
 qui arrive sans en-tête `x-opencode-session` et répond avec le type d'erreur `MissingSessionID` et le message
 « OpenCode's free tier can only be used in OpenCode ». Le contrôle porte uniquement sur la présence de
diff --git a/docs-site/src/content/docs/getting-started/quickstart.md b/docs-site/src/content/docs/getting-started/quickstart.md
index e8db9304b51..92e0ed79459 100644
--- a/docs-site/src/content/docs/getting-started/quickstart.md
+++ b/docs-site/src/content/docs/getting-started/quickstart.md
@@ -154,6 +154,10 @@ It stops before publishing a new runtime or changing those settings. Retry start
 local connectivity recovers; an installed background service retries through its service manager.
 A timeout does not permanently turn the new process into a secondary instance.
 
+IPv6 does not need to be enabled on loopback. Startup checks whether each loopback
+address can be bound locally and skips an unavailable family. Timeouts on an available
+family still stop startup until ownership can be verified.
+
 ## Next
 
 - [How It Works](/getting-started/how-it-works/) — what happens to each request.
diff --git a/docs-site/src/content/docs/guides/chatgpt-desktop.md b/docs-site/src/content/docs/guides/chatgpt-desktop.md
index 887493f1935..458acdfbedf 100644
--- a/docs-site/src/content/docs/guides/chatgpt-desktop.md
+++ b/docs-site/src/content/docs/guides/chatgpt-desktop.md
@@ -126,6 +126,17 @@ app-server until you run one of them. A single output line longer than 8 MiB is
 passed through unparsed rather than buffered.
 
 This standalone shim does not rewrite conversation metadata or route model calls.
-Other app gates or upstream refusals can still prevent sending. Evidence reported
-on an exhausted Plus account also used an intercept, so it does not establish
-that this shim alone resolves every desktop send lock.
+Other app gates or upstream refusals can still prevent sending. An attached launcher
+or a passing filter self-test does not prove that the app's gate data crosses this pipe.
+
+Reporter observations in [#6196](https://github.com/lidge-jun/opencodex/issues/6196)
+on October 2 and 13, 2026 describe an attached shim with Send still disabled at
+natural quota exhaustion. On Desktop 26.1007.30912 with OpenCodex 2.84.0, the
+reporter observed no eligible rate-limit RPC messages while the renderer's gate
+used a separate usage transport. This shim cannot rewrite data that never reaches
+its stdout filter. These are build-specific field reports, not a new live
+verification or proof that every Desktop build uses the same transport.
+
+The remaining signed-in composer behavior stays tracked in #6196. Earlier success
+with a combined shim/intercept configuration does not establish shim-only
+sufficiency, and the closed, unmerged #6365 intercept is not a shipped remedy.
diff --git a/docs-site/src/content/docs/guides/claude-code.md b/docs-site/src/content/docs/guides/claude-code.md
index 159886a85e0..eb1b9b9d14a 100644
--- a/docs-site/src/content/docs/guides/claude-code.md
+++ b/docs-site/src/content/docs/guides/claude-code.md
@@ -962,7 +962,7 @@ The proxy translates every Anthropic Messages API request into the Codex Respons
 | User `tool_result` | `function_call_output` (`is_error` → `[tool error]` prefix) |
 | `tool_reference` in a tool result | Text `Tool loaded: <tool_name>` in the paired result; preserves loaded-tool names without adding declarations or enabling translated server-side deferral |
 | `thinking` / `redacted_thinking` replay | `reasoning` items with bounded `ocxr1` envelopes for signatures and redacted payloads |
-| Function tools | `{type: "function"}` (`web_search*` → `{type: "web_search"}`). On a route to `api.anthropic.com`, the typed `web_search_*` and `web_fetch_*` declarations are also sent to Anthropic as declared and run server-side, unless the web-search sidecar supplies `web_search` itself. Each search or fetch comes back to the client as its `server_tool_use` block and its `web_search_tool_result` or `web_fetch_tool_result` |
+| Function tools | `{type: "function"}` (`web_search*` → `{type: "web_search"}`). On a route to `api.anthropic.com`, the typed `web_search_*` and `web_fetch_*` declarations are also sent to Anthropic as declared and run server-side, unless the web-search sidecar supplies `web_search` itself. A search or fetch with a matching call and complete input comes back to the client as its `server_tool_use` block and its `web_search_tool_result` or `web_fetch_tool_result`, verbatim. Orphan results are dropped without synthesizing a call, while the surrounding text is preserved. When the client sends a complete pair back in its history, the next `api.anthropic.com` request carries it in place only if the following block uniquely identifies its original turn. Repeated anchors, unmatched or duplicate call/result ids, malformed call input, or a result appearing before its call drop the exchange. Call input must be an object with a nonempty search query or fetch URL string; other destinations never see the exchange |
 | `tool_choice` | `auto`→`auto`, `none`→`none`, `any`→`required`, named function→`{type:"function",name}`, hosted WebSearch/web_search→`{type:"web_search"}` |
 | `max_tokens` | `max_output_tokens` |
 | `stop_sequences` | `stop` |
diff --git a/docs-site/src/content/docs/guides/codex-integration.md b/docs-site/src/content/docs/guides/codex-integration.md
index d4f611149c4..82cf7aaf446 100644
--- a/docs-site/src/content/docs/guides/codex-integration.md
+++ b/docs-site/src/content/docs/guides/codex-integration.md
@@ -427,6 +427,14 @@ provider advertises `supports_websockets = true` only when `"websockets": true`;
 built-in provider may try WebSocket first, and a disabled proxy returns `426` so Codex falls back to
 HTTP/SSE.
 
+The proxy admits up to 128 client-facing Responses WebSocket connections. When a new connection
+finds all 128 slots occupied, it closes the least recently used idle connection to make room. Connections
+with an active response, pending client tool or approval results, a native steering/injection
+session, or buffered output are protected. If no idle connection can be released, the new
+connection receives the existing `503` capacity response. A reclaimed client can reconnect for
+later requests using the existing continuation handling. This happens only under connection
+pressure, needs no setting, and does not change voice connections or upstream connection reuse.
+
 If a canonical ChatGPT forward continuation references expired or missing local replay state,
 opencodex returns `previous_response_not_found` before sending anything upstream. Codex's
 WebSocket client recognizes this error and can reconnect with its full retained context,
diff --git a/docs-site/src/content/docs/guides/providers.md b/docs-site/src/content/docs/guides/providers.md
index 45a3340944a..bbbf9a61325 100644
--- a/docs-site/src/content/docs/guides/providers.md
+++ b/docs-site/src/content/docs/guides/providers.md
@@ -87,6 +87,26 @@ modalities are declared; Kimi omits `capabilities` for unknown or text-only mode
 a supported capability field keep their existing configuration shape. After updating opencodex,
 regenerate or refresh the client configuration managed by opencodex to receive the updated metadata.
 
+## Replayed Anthropic thinking signatures
+
+On the Responses endpoint, an Anthropic-compatible upstream can reject a replayed thinking
+signature because it belongs to a different conversation prefix. When the error explicitly
+identifies this signature-binding problem, opencodex can remove replayed signed/redacted thinking
+and retry once within the request's send budget. This covers HTTP 400 refusals and initial stream
+errors before output or tool activity. Hosted web search and image/video bridges share one recovery
+limit across their model iterations: only the rejected inference is resent, while completed sidecar
+calls and tool results are retained. An empty-completion retry shares its request's allowance;
+ordinary continuations after output cannot use it. A failed replacement is
+returned without another signature retry. Other errors keep their existing handling.
+
+Sidecar recovery is disabled when enforced spend accounting cannot establish receipts for earlier
+ordinary sidecar sends. It never increases a caller or Combo send allowance.
+
+Only a successful, nonempty completion remembers the rejection for that conversation and serving
+identity for five minutes. Only the refused opaque payloads are suppressed when they can be
+identified; newly issued thinking remains replayable. Plaintext history remains available; a failed or cancelled retry does
+not disable thinking replay on later requests.
+
 ## Auth modes
 
 Provider configs accept three `authMode` values (`key` is the default). The built-in registry also
@@ -178,6 +198,13 @@ this does not turn off the model's internal reasoning. A thought signature is co
 metadata and can accompany ordinary text, so its presence alone does not hide that text.
 OpenCodex preserves unmarked answer text even when its wording sounds like planning or analysis.
 
+Gemini models, Argon in particular, sometimes skip thinking on a tool-calling turn and write their
+planning into the visible progress text, for example a progress line followed by "Let's read
+google.ts next." Once that text is sent back as history, the model tends to repeat the pattern
+on every later turn. To stop it from spreading, OpenCodex sends Gemini only the first sentence of
+the text that came before a tool call in earlier turns. Final answers are sent back in full, and
+what your client displays is not changed.
+
 The built-in `google-antigravity` model list is Gemini 3.8 Flash (`gemini-3.8-flash`), Gemini 4 Argon
 (`gemini-4-argon`), Claude Opus 5.5 (`claude-opus-5-5`), and Claude Sonnet 5.5
 (`claude-sonnet-5-5`), each with low, medium, and high efforts. What you actually see is your
@@ -842,7 +869,7 @@ headers. That is separate from the keyless desktop quota OpenCode advertises
 synthetic `Retry-After`; an upstream `Retry-After` still takes precedence. Same-key
 wait-and-retry remains opt-in via [`retryOn429`](/reference/configuration/).
 
-Gemini models on `opencode-zen` use Google's native API automatically when the provider uses an API key, the default `googleMode` (`ai-studio`), and either `https://opencode.ai/zen/v1` or `https://opencode.ai/inference/v1`. Use the model IDs listed by Zen; OpenCodex preserves them, including Flash IDs without a `-tiered` suffix. Older Gemini Chat/Responses overrides and Responses-only hosted-tool preferences are ignored when reading saved configurations.
+Gemini models on `opencode-zen` use Google's native API automatically when the provider uses an API key, the default `googleMode` (`ai-studio`), and either `https://opencode.ai/zen/v1` or `https://opencode.ai/inference/v1`. Use the model IDs listed by Zen; OpenCodex preserves them, including Flash IDs without a `-tiered` suffix. Claude models on these API-key routes use Anthropic Messages automatically, regardless of `googleMode`. When loading saved configurations, OpenCodex ignores eligible older Gemini and Claude Chat/Responses overrides only for native models in the canonical keyed `opencode-zen` provider on these official Zen routes. It also ignores eligible Responses-only `image_generation` hosted-tool preferences; custom providers, non-key routes, and other preferences remain unchanged.
 
 **The keyless `opencode-free` tier is currently closed to third-party clients.** Zen refuses
 any request that arrives without an `x-opencode-session` header, answering with error type
diff --git a/docs-site/src/content/docs/guides/web-dashboard.md b/docs-site/src/content/docs/guides/web-dashboard.md
index 77d8d4fcd7a..252f7650d39 100644
--- a/docs-site/src/content/docs/guides/web-dashboard.md
+++ b/docs-site/src/content/docs/guides/web-dashboard.md
@@ -149,6 +149,9 @@ its request and attempt failure cause is `transport-ambiguous`, with resend perm
 `refused-ambiguous`: the upstream may already have processed the turn. A genuine provider
 429 remains `rate-limit` with resend permission `permitted`.
 
+A Codex move to another account after HTTP 402 appears as **Account quota exhausted (402)**
+in the attempt's recovery details and counts as a quota recovery in exported metrics.
+
 Logs filters combine surface, intercepted requests, provider, exact model, status, time,
 speed, and conversation ID over the currently loaded request ring. Provider and model
 choices also include fallback attempts; model matching ignores case and surrounding spaces
@@ -207,8 +210,10 @@ without a matching price or usable usage are counted as excluded beside that amo
 reports pricing coverage fields. Usage that was only partly measured (`unreported` or `unsupported`)
 is not priced, and one excluded part excludes the whole request from that row's priced count. A
 leg that reached no upstream, or that upstream refused with an HTTP error before any output, spent
-nothing and does not; a leg whose response began (or ended without a status) but reported no usage
-may have been billed, so it does. A row with only excluded requests shows an em dash with that count
+nothing and does not; a client cancellation (499), or a leg whose response began or ended without
+a status but reported no usage, may have been billed, so it does. A refusal followed by a measured
+successful send contributes that send's cost to the summary even when the aggregate usage status
+is `unreported`. A row with only excluded requests shows an em dash with that count
 instead of a zero-dollar estimate, and a displayed zero-dollar value is a confirmed priced estimate.
 An older proxy that reports no coverage fields keeps a bare em dash with no count, so missing
 coverage stays distinct from an all-excluded row and from a confirmed zero estimate.
diff --git a/docs-site/src/content/docs/ja/guides/providers.md b/docs-site/src/content/docs/ja/guides/providers.md
index 3323995b0fc..f539c96b981 100644
--- a/docs-site/src/content/docs/ja/guides/providers.md
+++ b/docs-site/src/content/docs/ja/guides/providers.md
@@ -284,6 +284,8 @@ Chat リクエストは設定済みの Bearer キーを使います。公開一
 **OpenCode Zen**（`opencode-zen`）とキー不要の **OpenCode Free** プリセットは
 `https://opencode.ai/zen/v1` を共有します。このゲートウェイ上の無料モデルは、しばしばおおよそ毎分 15–20 リクエストの短時間レート制限に当たります（コミュニティ計測。OpenCode は RPM を公表しません）。Zen は `Retry-After` / `X-RateLimit-*` ヘッダーなしの汎用 429 を返すことがあります。これはキー不要デスクトップ枠（`opencode-free` で Big Pickle/無料モデル約 200 回 / 5 時間）とは別です。Zen がそのような 429 で `Retry-After` を省略した場合、opencodex はクライアント向けエラーに案内を足し、合成 `Retry-After` を付けます（上流の `Retry-After` があればそれが優先されます）。同一キーの待機再試行は [`retryOn429`](/ja/reference/configuration/) でオプトインします。
 
+正規の `opencode-zen` プロバイダーで API キー認証と公式ルート `https://opencode.ai/zen/v1` または `https://opencode.ai/inference/v1` を使用すると、Gemini は既定の `googleMode: ai-studio` で Google ネイティブ API を自動的に使用します。Zen のモデル ID は、`-tiered` 接尾辞のない Flash ID もそのまま保持します。Claude は `googleMode` に関係なく Anthropic Messages を使用します。保存済み設定の読み込み時、これらのネイティブモデルの適格な旧 Chat/Responses オーバーライドと、適格な Responses 専用 `image_generation` ホストツール設定のみを無視します。カスタムプロバイダー、キー認証以外のルート、その他の設定は変更しません。
+
 **キー不要の `opencode-free` 枠は、現在サードパーティのクライアントに閉じられています。** Zen は `x-opencode-session` ヘッダーを伴わないリクエストをすべて拒否し、エラータイプ `MissingSessionID` と "OpenCode's free tier can only be used in OpenCode" というメッセージを返します。関門はヘッダーの有無だけを見るため、プロキシは値をでっち上げれば通過できますが、opencodex はそうしません。セッション識別子とバージョン付きの `opencode/<version>` User-Agent を作って送ることは、自分が OpenCode クライアントであると主張することであり、OpenCode はこのキー不要の枠についてサードパーティ連携の契約を公開していません。その方法で得た HTTP 200 は許可ではなく、突破された関門にすぎません。そこで opencodex は回避せずに制限を報告します。`opencode-free` へのリクエストは、上流の関門を説明するエラーを返します。
 
 同じモデルに至るサポートされた経路は、[opencode.ai/auth](https://opencode.ai/auth) で発行した OpenCode Zen API キーを使う **`opencode-zen`** プリセットです。OpenCode が後にキー不要の枠へのサードパーティ経路を公開すれば、opencodex もそれに従えます。それまでこのプリセットは制限を記録する役割を担います。上流の規約: [opencode.ai/docs/zen](https://opencode.ai/docs/zen/)。
diff --git a/docs-site/src/content/docs/ko/guides/providers.md b/docs-site/src/content/docs/ko/guides/providers.md
index e4cd967e63c..71e0fcb6d1f 100644
--- a/docs-site/src/content/docs/ko/guides/providers.md
+++ b/docs-site/src/content/docs/ko/guides/providers.md
@@ -282,6 +282,8 @@ Chat 요청은 설정한 Bearer 키를 사용하며 공개 모델 목록은 키
 **OpenCode Zen**(`opencode-zen`)과 키 없는 **OpenCode Free** 프리셋은
 `https://opencode.ai/zen/v1`을 공유합니다. 그 게이트웨이의 무료 모델은 종종 분당 약 15–20회 요청의 짧은 창 속도 제한에 걸립니다(커뮤니티 측정; OpenCode는 RPM을 공개하지 않음). Zen은 `Retry-After` / `X-RateLimit-*` 헤더 없는 일반 429를 반환할 수 있습니다. 이는 키 없는 데스크톱 할당량(`opencode-free`에서 약 5시간당 Big Pickle/무료 모델 200회)과 별개입니다. Zen이 그런 429에서 `Retry-After`를 생략하면 opencodex는 클라이언트 오류에 안내를 더하고 합성 `Retry-After`를 붙입니다(업스트림 `Retry-After`가 있으면 그것이 우선). 동일 키 대기 재시도는 [`retryOn429`](/ko/reference/configuration/)로 선택합니다.
 
+정식 `opencode-zen` 제공자에서 API 키 인증과 공식 경로 `https://opencode.ai/zen/v1` 또는 `https://opencode.ai/inference/v1`을 사용하면 Gemini는 기본 `googleMode: ai-studio`에서 Google 네이티브 API를 자동으로 사용합니다. Zen 모델 ID는 `-tiered` 접미사가 없는 Flash ID도 그대로 유지합니다. Claude는 `googleMode`와 관계없이 Anthropic Messages를 사용합니다. 저장된 설정을 읽을 때 이 네이티브 모델의 조건에 맞는 기존 Chat/Responses 재정의와 조건에 맞는 Responses 전용 `image_generation` 호스팅 도구 선호 설정만 무시합니다. 사용자 지정 제공자, 키 인증이 아닌 경로, 그 밖의 선호 설정은 그대로 유지합니다.
+
 **키 없는 `opencode-free` 등급은 현재 서드파티 클라이언트에 닫혀 있습니다.** Zen은 `x-opencode-session` 헤더가 없는 요청을 모두 거부하고, 오류 타입 `MissingSessionID`와 "OpenCode's free tier can only be used in OpenCode" 메시지를 돌려줍니다. 관문은 헤더가 있는지만 보기 때문에 프록시가 값을 지어내 통과할 수도 있지만, opencodex는 그렇게 하지 않습니다. 세션 식별자와 버전이 붙은 `opencode/<version>` User-Agent를 만들어 보내는 것은 자신이 OpenCode 클라이언트라고 주장하는 일이고, OpenCode는 이 키 없는 등급에 서드파티 연동 계약을 공개한 적이 없습니다. 그렇게 받아낸 HTTP 200은 허가가 아니라 뚫린 관문일 뿐입니다. 그래서 opencodex는 우회하지 않고 제한을 그대로 알립니다. `opencode-free`로 보낸 요청은 업스트림 관문을 설명하는 오류를 돌려받습니다.
 
 같은 모델로 가는 지원 경로는 [opencode.ai/auth](https://opencode.ai/auth)에서 발급받은 OpenCode Zen API 키를 쓰는 **`opencode-zen`** 프리셋입니다. 나중에 OpenCode가 키 없는 등급의 서드파티 경로를 공개하면 opencodex도 따라갈 수 있고, 그때까지 이 프리셋은 제한을 기록해 두는 역할을 합니다. 업스트림 약관: [opencode.ai/docs/zen](https://opencode.ai/docs/zen/).
diff --git a/docs-site/src/content/docs/reference/configuration/providers.md b/docs-site/src/content/docs/reference/configuration/providers.md
index 700e060ca9b..a8e4499e9a6 100644
--- a/docs-site/src/content/docs/reference/configuration/providers.md
+++ b/docs-site/src/content/docs/reference/configuration/providers.md
@@ -672,7 +672,9 @@ The effective label order is operator `modelDisplayNames`, then provider catalog
 normal `provider/model` fallback. The routed selector remains `xai/grok-4.6`, while the upstream
 wire model remains `grok-4.6`. Labels are display only. They do not change authentication, adapter
 behavior, routing, billing, or upstream request construction. Removing a map entry resets only its
-label. A management client can set or reset one label with
+label. For built-in OpenAI API models, use
+`providers.openai-apikey.modelDisplayNames`; the label survives catalog refreshes.
+A management client can set or reset one label with
 `PUT /api/providers/:provider/model-display-names` and a body of
 `{ "modelId": "grok-4.6", "displayName": "Grok 4.6" }`; send `displayName: null` to reset it.
 Provider `PATCH` does not edit this map. Use this dedicated `PUT` endpoint to change or remove labels.
diff --git a/docs-site/src/content/docs/reference/proxy-formats.md b/docs-site/src/content/docs/reference/proxy-formats.md
index b16260d19ee..6d245819c6e 100644
--- a/docs-site/src/content/docs/reference/proxy-formats.md
+++ b/docs-site/src/content/docs/reference/proxy-formats.md
@@ -437,6 +437,13 @@ it is on the wire.
 
 Responses rejected at authentication or origin admission never reach this wrapper and carry no id.
 
+Logged `POST /v1/chat/completions` replies also carry `x-opencodex-request-id`, exposed through
+CORS, for JSON, streaming, handler errors and logged pre-handler refusals. This is the gateway
+history id, independent of the response body's completion id. Caller and upstream values cannot
+replace it. Rejections without a request-log owner, including authentication, origin, drain and
+active-turn refusals, carry no id. Streaming headers identify the eventual history row before
+final usage is saved.
+
 Logged `POST /v1/messages` replies carry the same OCX request-history id in **both**
 `request-id` and `x-opencodex-request-id`. This applies to native and translated replies,
 streaming and JSON, and logged refusals. Claude Code can use its persisted `requestId`
diff --git a/docs-site/src/content/docs/ru/guides/providers.md b/docs-site/src/content/docs/ru/guides/providers.md
index 85d9ab24996..6234f0f3e46 100644
--- a/docs-site/src/content/docs/ru/guides/providers.md
+++ b/docs-site/src/content/docs/ru/guides/providers.md
@@ -305,6 +305,8 @@ Zen может отвечать общими 429 без заголовков `Re
 в ошибку клиента и синтетический `Retry-After`; при наличии upstream `Retry-After` он имеет
 приоритет. Повтор с тем же ключом по-прежнему включается через [`retryOn429`](/ru/reference/configuration/).
 
+На официальных маршрутах `https://opencode.ai/zen/v1` и `https://opencode.ai/inference/v1` канонического провайдера `opencode-zen` с аутентификацией API-ключом Gemini автоматически использует нативный API Google в стандартном режиме `googleMode: ai-studio`. Идентификаторы моделей Zen сохраняются, включая Flash без суффикса `-tiered`. Claude использует Anthropic Messages независимо от `googleMode`. При загрузке сохранённой конфигурации игнорируются только допустимые старые переопределения Chat/Responses для этих нативных моделей и допустимые настройки размещённого инструмента `image_generation`, предназначенные только для Responses. Пользовательские провайдеры, маршруты без аутентификации ключом и остальные настройки не меняются.
+
 **Бесключевой уровень `opencode-free` сейчас закрыт для сторонних клиентов.** Zen отклоняет любой
 запрос без заголовка `x-opencode-session`, возвращая тип ошибки `MissingSessionID` и сообщение
 «OpenCode's free tier can only be used in OpenCode». Проверяется только наличие заголовка, поэтому
diff --git a/docs-site/src/content/docs/tr/guides/providers.md b/docs-site/src/content/docs/tr/guides/providers.md
index 1c18a2fc04e..e74ecfe739f 100644
--- a/docs-site/src/content/docs/tr/guides/providers.md
+++ b/docs-site/src/content/docs/tr/guides/providers.md
@@ -436,6 +436,8 @@ ekler; bir yukarı akış `Retry-After`'ı yine de önceliklidir. Aynı anahtarl
 bekle ve yeniden dene özelliği [`retryOn429`](/tr/reference/configuration/)
 aracılığıyla isteğe bağlı kalır.
 
+Standart `opencode-zen` sağlayıcısının API anahtarıyla kimlik doğrulanan resmi `https://opencode.ai/zen/v1` ve `https://opencode.ai/inference/v1` yollarında Gemini, varsayılan `googleMode: ai-studio` modunda Google'ın yerel API'sini otomatik kullanır. Zen model kimlikleri, `-tiered` eki olmayan Flash kimlikleri dahil korunur. Claude, `googleMode` değerinden bağımsız olarak Anthropic Messages kullanır. Kaydedilmiş yapılandırmalar yüklenirken yalnızca bu yerel modellerin uygun eski Chat/Responses geçersiz kılmaları ve uygun, yalnızca Responses'a özgü `image_generation` barındırılan araç tercihleri yok sayılır. Özel sağlayıcılar, anahtar kimlik doğrulaması kullanmayan yollar ve diğer tercihler değişmez.
+
 **Anahtarsız `opencode-free` katmanı şu anda üçüncü taraf istemcilere kapalıdır.** Zen,
 `x-opencode-session` başlığı olmadan gelen her isteği reddeder ve `MissingSessionID` hata
 tipiyle "OpenCode's free tier can only be used in OpenCode" mesajını döndürür. Kapıda
diff --git a/docs-site/src/content/docs/zh-cn/guides/providers.md b/docs-site/src/content/docs/zh-cn/guides/providers.md
index dbc1a20d9b9..c6ef72b88a3 100644
--- a/docs-site/src/content/docs/zh-cn/guides/providers.md
+++ b/docs-site/src/content/docs/zh-cn/guides/providers.md
@@ -281,6 +281,8 @@ MiniMax 和 MiniMax (CN) 的提供商卡片也会在配置的密钥有有效 Cod
 **OpenCode Zen**（`opencode-zen`）与免密钥的 **OpenCode Free** 预设共用
 `https://opencode.ai/zen/v1`。该网关上的免费模型常会触发约每分钟 15–20 次请求的短窗口限流（社区观测；OpenCode 未公布 RPM）。Zen 可能返回不带 `Retry-After` / `X-RateLimit-*` 的通用 429。这与免密钥桌面配额（`opencode-free` 上约每 5 小时 200 次 Big Pickle/免费模型请求）是分开的。当这类 429 省略 `Retry-After` 时，opencodex 会在客户端错误中补充说明并附带合成的 `Retry-After`；若上游已提供 `Retry-After`，则仍以它为准。同密钥等待重试仍可通过 [`retryOn429`](/zh-cn/reference/configuration/) 选择开启。
 
+在规范 `opencode-zen` 提供商中，使用 API 密钥认证和官方路由 `https://opencode.ai/zen/v1` 或 `https://opencode.ai/inference/v1` 时，Gemini 会在默认 `googleMode: ai-studio` 下自动使用 Google 原生 API。Zen 模型 ID 保持不变，包括没有 `-tiered` 后缀的 Flash ID。Claude 使用 Anthropic Messages，不受 `googleMode` 影响。加载已保存的配置时，仅忽略这些原生模型符合条件的旧 Chat/Responses 覆盖设置，以及符合条件的 Responses 专用 `image_generation` 托管工具偏好。自定义提供商、非密钥认证路由及其他偏好保持不变。
+
 **免密钥的 `opencode-free` 层级目前对第三方客户端关闭。** Zen 会拒绝任何不带 `x-opencode-session` 头的请求，返回错误类型 `MissingSessionID` 和消息 "OpenCode's free tier can only be used in OpenCode"。这道关卡只检查该头是否存在，因此代理完全可以编一个值蒙混过去，但 opencodex 不这么做。伪造会话标识并附上带版本号的 `opencode/<version>` User-Agent，等于声称自己就是 OpenCode 客户端，而 OpenCode 并未公布这一免密钥层级的第三方集成约定；用这种方式换来的 HTTP 200 是绕过了准入检查，而不是获得了许可。因此 opencodex 选择如实报告限制：发往 `opencode-free` 的请求会返回一条解释上游关卡的错误。
 
 通往同一批模型的受支持路径，是使用 [opencode.ai/auth](https://opencode.ai/auth) 获取的 OpenCode Zen API 密钥、走带密钥的 **`opencode-zen`** 预设。若 OpenCode 之后公布了免密钥层级的第三方接入方式，opencodex 可以跟进；在此之前，这个预设的作用是记录该限制。上游条款：[opencode.ai/docs/zen](https://opencode.ai/docs/zen/)。
diff --git a/docs-site/src/content/docs/zh-tw/guides/providers.md b/docs-site/src/content/docs/zh-tw/guides/providers.md
index c0d81d33176..4d0f008be09 100644
--- a/docs-site/src/content/docs/zh-tw/guides/providers.md
+++ b/docs-site/src/content/docs/zh-tw/guides/providers.md
@@ -345,6 +345,8 @@ Bearer 金鑰；公開模型清單無法驗證金鑰有效性。
 error 加入 provider guidance 與 synthetic `Retry-After`；若上游有 `Retry-After`，仍以上游值為準。
 same-key wait-and-retry 仍需透過 [`retryOn429`](/zh-tw/reference/configuration/) 明確 opt-in。
 
+在標準 `opencode-zen` 提供者中，使用 API 金鑰驗證及官方路由 `https://opencode.ai/zen/v1` 或 `https://opencode.ai/inference/v1` 時，Gemini 會在預設 `googleMode: ai-studio` 下自動使用 Google 原生 API。Zen 模型 ID 維持不變，包括沒有 `-tiered` 後綴的 Flash ID。Claude 使用 Anthropic Messages，不受 `googleMode` 影響。載入已儲存的設定時，僅忽略這些原生模型符合條件的舊 Chat/Responses 覆寫設定，以及符合條件的 Responses 專用 `image_generation` 託管工具偏好。自訂提供者、非金鑰驗證路由及其他偏好維持不變。
+
 **無 key 的 `opencode-free` tier 目前對第三方 client 關閉。** Zen 會拒絕任何沒有帶 `x-opencode-session`
 header 的 request，回傳 error type `MissingSessionID` 與訊息 "OpenCode's free tier can only be used in
 OpenCode"。這道 gate 只檢查該 header 是否存在，因此 proxy 大可捏造一個值通過，但 opencodex 不這麼做。
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index 3b784e086f7..22c5edac19d 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -1148,6 +1148,7 @@ export const de: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "API-Schlüssel erneut authentifiziert",
   "logs.detail.attempt.recovery.oauthAccount403": "Kontovalidierung erforderlich (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "Konto rate-limitiert (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "Kontingent des Kontos erschöpft (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "Veralteter verschlüsselter Zustand verworfen",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "Reasoning-Aufwand reduziert",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "Schnellmodus abgelehnt, erneut mit Standardtempo versucht",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index a10c82ade62..350a21304ae 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -1206,6 +1206,7 @@ export const en = {
   "logs.detail.attempt.recovery.key401": "API key re-authentication",
   "logs.detail.attempt.recovery.oauthAccount403": "Account validation required (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "Account rate-limited (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "Account quota exhausted (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "Stale encrypted state dropped",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "Reasoning effort downgraded",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "Fast mode refused, retried at standard speed",
diff --git a/gui/src/i18n/fr.ts b/gui/src/i18n/fr.ts
index d61681fcfc9..a17e39b0bd0 100644
--- a/gui/src/i18n/fr.ts
+++ b/gui/src/i18n/fr.ts
@@ -1182,6 +1182,7 @@ export const fr: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "Ré-authentification de la clé API",
   "logs.detail.attempt.recovery.oauthAccount403": "Validation du compte requise (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "Compte limité (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "Quota du compte épuisé (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "État chiffré obsolète abandonné",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "Effort de raisonnement réduit",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "Mode rapide refusé, nouvel essai à vitesse standard",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index 1ae152fdee0..08799fa8f3f 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -1089,6 +1089,7 @@ export const ja: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "API キーの再認証",
   "logs.detail.attempt.recovery.oauthAccount403": "アカウントの検証が必要 (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "アカウントのレート制限 (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "アカウントのクォータ枯渇 (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "古い暗号化状態を破棄",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "推論強度を下げて再試行",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "高速モードが拒否され、標準速度で再試行",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index a7faa3c9e47..0781408ca97 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -1187,6 +1187,7 @@ export const ko: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "API 키 재인증",
   "logs.detail.attempt.recovery.oauthAccount403": "계정 확인 필요 (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "계정 속도 제한 (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "계정 할당량 소진 (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "만료된 암호화 상태 제거",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "추론 강도 하향",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "빠른 모드 거부, 표준 속도로 재시도",
diff --git a/gui/src/i18n/pt.ts b/gui/src/i18n/pt.ts
index dac0f93fdc8..5d0f1dd1761 100644
--- a/gui/src/i18n/pt.ts
+++ b/gui/src/i18n/pt.ts
@@ -1201,6 +1201,7 @@ export const pt: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "Reautenticação da chave de API",
   "logs.detail.attempt.recovery.oauthAccount403": "Validação da conta necessária (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "Conta com limite de taxa (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "Cota da conta esgotada (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "Estado criptografado obsoleto descartado",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "Esforço de raciocínio reduzido",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "Modo rápido recusado, repetido em velocidade padrão",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index 8603d20b578..ad8863b0cce 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -1165,6 +1165,7 @@ export const ru: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "Повторная аутентификация API-ключа",
   "logs.detail.attempt.recovery.oauthAccount403": "Требуется проверка аккаунта (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "Ограничение частоты для аккаунта (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "Квота аккаунта исчерпана (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "Устаревшее зашифрованное состояние отброшено",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "Уровень рассуждения понижен",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "Быстрый режим отклонён, повтор со стандартной скоростью",
diff --git a/gui/src/i18n/tr.ts b/gui/src/i18n/tr.ts
index 008e8be47e4..147e954d1c9 100644
--- a/gui/src/i18n/tr.ts
+++ b/gui/src/i18n/tr.ts
@@ -1192,6 +1192,7 @@ export const tr: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "API anahtarı yeniden doğrulandı",
   "logs.detail.attempt.recovery.oauthAccount403": "Hesap doğrulaması gerekli (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "Hesap hız sınırına takıldı (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "Hesap kotası tükendi (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "Eski şifreli durum bırakıldı",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "Akıl yürütme düzeyi düşürüldü",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "Hızlı mod reddedildi, standart hızda yeniden denendi",
diff --git a/gui/src/i18n/vi.ts b/gui/src/i18n/vi.ts
index 0f432ac4923..18fa8b93963 100644
--- a/gui/src/i18n/vi.ts
+++ b/gui/src/i18n/vi.ts
@@ -1186,6 +1186,7 @@ export const vi: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "Xác thực lại khóa API",
   "logs.detail.attempt.recovery.oauthAccount403": "Cần xác minh tài khoản (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "Tài khoản bị giới hạn tần suất (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "Tài khoản đã hết hạn mức (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "Đã bỏ trạng thái mã hóa cũ",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "Đã giảm mức suy luận",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "Chế độ nhanh bị từ chối, thử lại ở tốc độ chuẩn",
diff --git a/gui/src/i18n/zh-TW.ts b/gui/src/i18n/zh-TW.ts
index 1bc86ff154c..783ea79a4fc 100644
--- a/gui/src/i18n/zh-TW.ts
+++ b/gui/src/i18n/zh-TW.ts
@@ -3002,6 +3002,7 @@ export const zhTW: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "API 金鑰重新驗證",
   "logs.detail.attempt.recovery.oauthAccount403": "需要驗證帳號 (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "帳號速率受限 (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "帳號配額已用盡 (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "已捨棄過期加密狀態",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "已降低推理強度",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "快速模式遭拒，改以標準速度重試",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index a0240c48491..dacb18d70ea 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -1160,6 +1160,7 @@ export const zh: Record<TKey, string> = {
   "logs.detail.attempt.recovery.key401": "API 密钥重新认证",
   "logs.detail.attempt.recovery.oauthAccount403": "需要验证账号 (403)",
   "logs.detail.attempt.recovery.oauthAccount429": "账号速率受限 (429)",
+  "logs.detail.attempt.recovery.oauthAccount402": "账号配额已用尽 (402)",
   "logs.detail.attempt.recovery.opaqueBlobRejection": "已丢弃过期加密状态",
   "logs.detail.attempt.recovery.reasoningEffortDowngrade": "已降低推理强度",
   "logs.detail.attempt.recovery.anthropicFastDowngrade": "快速模式被拒，按标准速度重试",
diff --git a/gui/src/pages/Logs.tsx b/gui/src/pages/Logs.tsx
index 922634b69ec..a1f5858f394 100644
--- a/gui/src/pages/Logs.tsx
+++ b/gui/src/pages/Logs.tsx
@@ -355,6 +355,7 @@ const RECOVERY_KIND_KEYS = {
   "rate-limit-429": "logs.detail.attempt.recovery.rateLimit429",
   "anthropic-oauth-429": "logs.detail.attempt.recovery.anthropicOauth429",
   "oauth-account-429": "logs.detail.attempt.recovery.oauthAccount429",
+  "oauth-account-402": "logs.detail.attempt.recovery.oauthAccount402",
   "image-413": "logs.detail.attempt.recovery.image413",
   "empty-completion": "logs.detail.attempt.recovery.emptyCompletion",
   "console-go-upload-retry": "logs.detail.attempt.recovery.consoleGoUpload",
diff --git a/package.json b/package.json
index 0ea7b8da08e..5b09a0263be 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.87.0",
+  "version": "2.88.0",
   "description": "Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code",
   "type": "module",
   "main": "./bin/package-main.mjs",
diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json
index f8bd26a990d..edab985cdac 100644
--- a/scripts/test-layout/layout.json
+++ b/scripts/test-layout/layout.json
@@ -219,6 +219,7 @@
     "anthropic-tail-guard.test.ts": "adapters/anthropic",
     "anthropic-progress-updates.test.ts": "adapters/anthropic",
     "anthropic-thinking-signature.test.ts": "adapters/anthropic",
+    "anthropic-replay.test.ts": "adapters/anthropic",
     "anthropic-opaque-strip.test.ts": "adapters/anthropic",
     "anthropic-tool-call-id.test.ts": "adapters/anthropic",
     "anthropic-messages-passthrough.test.ts": "adapters/anthropic",
@@ -315,6 +316,7 @@
     "catalog-zero-credit-picker.test.ts": "codex-integration",
     "chat-completions-deferred-tools.test.ts": "responses", "passthrough-deferred-tools.test.ts": "responses",
     "chat-completions-endpoint.test.ts": "responses",
+    "chat-request-id-endpoint.test.ts": "responses",
     "chat-completions-pool-mode.test.ts": "responses",
     "chat-conversation-affinity.test.ts": "responses",
     "chat-inbound-developer-position.test.ts": "responses",
@@ -518,6 +520,7 @@
     "cli-start-auxiliary-bind.test.ts": "cli",
     "cli-start-journal-order.test.ts": "cli",
     "sibling-home-client-sync.test.ts": "cli",
+    "cross-home-loopback-family.test.ts": "cli",
     "cli-status-hub-state.test.ts": "cli",
     "cli-status-json.test.ts": "cli",
     "cli-status-oauth-health.test.ts": "cli",
@@ -722,6 +725,7 @@
     "codex-warmup.test.ts": "codex-integration",
     "codex-web-search-switch.test.ts": "codex-integration",
     "codex-websocket-registry.test.ts": "codex-integration",
+    "websocket-capacity-activity.test.ts": "codex-integration",
     "codex-write-lock.test.ts": "codex-integration",
     "coding-agent-tool-result-images.test.ts": "adapters",
     "cold-spawn-warmup.test.ts": "ci-workflows",
@@ -954,6 +958,7 @@
     "gcp-adc.test.ts": "adapters/google",
     "gemini-37-flash-migration.test.ts": "adapters/google",
     "gemini-4-argon-antigravity.test.ts": "adapters/google",
+    "gemini-progress-history.test.ts": "adapters/google",
     "antigravity-account-roster.test.ts": "adapters/google",
     "gemini-inline.test.ts": "images",
     "gemini-web-search.test.ts": "adapters/google",
@@ -1504,6 +1509,10 @@
     "responses-account-change-scrub.test.ts": "responses",
     "responses-account-label.test.ts": "responses",
     "responses-anthropic-fast-downgrade.test.ts": "responses",
+    "responses-anthropic-thinking-signature-recovery.test.ts": "responses",
+    "responses-web-search-thinking-signature-recovery.test.ts": "responses",
+    "responses-anthropic-thinking-recovery.test.ts": "responses",
+    "responses-anthropic-legal-history.test.ts": "responses",
     "responses-azure-opaque-blob-recovery.test.ts": "responses",
     "responses-bare-echo-helper-fence.test.ts": "responses",
     "responses-canonical-only-top-level-fields.test.ts": "responses",
@@ -1656,6 +1665,7 @@
     "server-request-body-size.test.ts": "server",
     "server-search.test.ts": "server",
     "server-startup-reconcile-resilience.test.ts": "server",
+    "server-startup-codex-off.test.ts": "server",
     "server-stop-config-hardening.test.ts": "server",
     "server-xai-chat-reasoning-streaming.test.ts": "server",
     "server-xai-header-parity.test.ts": "server",
@@ -1917,6 +1927,8 @@
     "winsw.test.ts": "service",
     "workflow-budget.test.ts": "lib",
     "ws-ambiguous-resend.test.ts": "responses", "ws-pre-output-refusal.test.ts": "responses", "responses-pool-overload-failover.test.ts": "responses", "compact-transient-alternate.test.ts": "responses",
+    "ws-capacity-reclamation.test.ts": "responses",
+    "ws-capacity-tool-ownership.test.ts": "responses",
     "ws-endpoint.test.ts": "responses",
     "ws-failure-stage.test.ts": "responses",
     "ws-native-injection.test.ts": "responses",
diff --git a/src/adapters/anthropic-rejection-memo.ts b/src/adapters/anthropic-rejection-memo.ts
new file mode 100644
index 00000000000..1d24ec9d76f
--- /dev/null
+++ b/src/adapters/anthropic-rejection-memo.ts
@@ -0,0 +1,71 @@
+import { createHash } from "node:crypto";
+import type { TranslatorBudget } from "../lib/translator-budget";
+import type { AdapterRequest } from "./base";
+import type { OcxParsedRequest } from "../types";
+
+type Block = Record<string, unknown>;
+type Policy = { mode: "blanket" } | { mode: "selective"; fingerprints: ReadonlySet<string> };
+const requests = new WeakMap<AdapterRequest, ReadonlySet<string>>();
+const responses = new WeakMap<Response, ReadonlySet<string>>();
+const policies = new WeakMap<object, Policy>();
+const owner = (parsed: OcxParsedRequest) => parsed._reasoningReplayScope ?? parsed;
+/** Domain-separated opaque bytes, deliberately independent of plaintext and untrusted hints. */
+export function anthropicOpaqueFingerprint(block: Block): string | undefined {
+  const value = block.type === "thinking" ? block.signature : block.type === "redacted_thinking" ? block.data : undefined;
+  if (typeof value !== "string" || value.length === 0) return;
+  return createHash("sha256").update(String(block.type)).update("\0").update(value).digest("hex");
+}
+export function captureAnthropicRejectionPayloads(request: AdapterRequest, body: Block, budget?: TranslatorBudget): void {
+  requests.delete(request);
+  if (!budget || !Array.isArray(body.messages)) return;
+  let retained = 0;
+  let complete = false;
+  const fingerprints = new Set<string>();
+  try {
+  for (const message of body.messages) {
+    if (!message || typeof message !== "object") return;
+    if (typeof message.content === "string") continue;
+    if (!Array.isArray(message.content)) return;
+    for (const block of message.content) {
+      if (!block || typeof block !== "object") return;
+      if (block.type !== "thinking" && block.type !== "redacted_thinking") continue;
+      const value = block.type === "thinking" ? block.signature : block.data;
+      if (typeof value !== "string" || value.length === 0) return;
+      const temporary = budget.reserveTransient(Buffer.byteLength(value) * 2, { kind: "reasoning" });
+      let fingerprint: string | undefined;
+      try { fingerprint = anthropicOpaqueFingerprint(block); } finally { temporary.release(); }
+      if (!fingerprint) return;
+      if (!fingerprints.has(fingerprint)) {
+        if (fingerprints.size >= 256) return;
+        // Includes Set/hex storage and later defensive copies; owned until turn disposal.
+        budget.chargeRetained(256, { kind: "reasoning" }); retained += 256;
+        fingerprints.add(fingerprint);
+      }
+    }
+  }
+  if (fingerprints.size) { requests.set(request, fingerprints); complete = true; }
+  } catch { /* An uncollectable set keeps the legacy blanket policy. */ }
+  finally { if (!complete) budget.releaseRetained(retained, { kind: "reasoning" }); }
+}
+export function bindAnthropicRejectionResponse(request: AdapterRequest | undefined, response: Response): void {
+  const fingerprints = request && requests.get(request);
+  if (fingerprints) responses.set(response, fingerprints); else responses.delete(response);
+}
+export function rejectedAnthropicPayloads(response: Response | undefined): ReadonlySet<string> | undefined {
+  const value = response && responses.get(response);
+  return value && new Set(value);
+}
+export function bindAnthropicRejectionPolicy(parsed: OcxParsedRequest, policy: Policy | undefined): void {
+  if (policy) policies.set(owner(parsed), policy); else policies.delete(owner(parsed));
+}
+export function anthropicRejectionPolicy(parsed: OcxParsedRequest): Policy | undefined { return policies.get(owner(parsed)); }
+
+/** Filter only refused opaque bytes; newly issued thinking in this request remains replayable. */
+export function keepAnthropicReplayBlock(parsed: OcxParsedRequest, block: Block): boolean {
+  const fingerprint = anthropicOpaqueFingerprint(block);
+  if (!fingerprint) return true;
+  if (parsed._stripReasoningEncryptedContent === true) return false;
+  const policy = anthropicRejectionPolicy(parsed);
+  return policy ? policy.mode === "selective" && !policy.fingerprints.has(fingerprint)
+    : true;
+}
diff --git a/src/adapters/anthropic-replay.ts b/src/adapters/anthropic-replay.ts
new file mode 100644
index 00000000000..e91f933d654
--- /dev/null
+++ b/src/adapters/anthropic-replay.ts
@@ -0,0 +1,135 @@
+import { isConformingToolCallId } from "./tool-call-id";
+import type { AdapterEvent, OcxAssistantMessage } from "../types";
+import { isTranslatorBudgetExceededError, type TranslatorBudget, type TranslatorTransientReservation } from "../lib/translator-budget";
+import { jsonUtf8Bytes } from "../lib/json-byte-size";
+
+type Block = Record<string, unknown>;
+export interface AnthropicReplaySnapshot { readonly content: readonly Block[]; release(): void }
+const enabled = new WeakSet<Response>();
+const terminals = new WeakMap<object, AnthropicReplaySnapshot>();
+const pending = new WeakMap<Response, AnthropicReplaySnapshot>();
+const owners = new WeakMap<object, Response>();
+const issued = new WeakSet<object>();
+const messages = new WeakMap<object, AnthropicReplaySnapshot>();
+export function enableAnthropicReplayCapture(response: Response): () => void {
+  enabled.add(response);
+  return () => { enabled.delete(response); pending.get(response)?.release(); pending.delete(response); };
+}
+export function takeAnthropicReplay(event: object): AnthropicReplaySnapshot | undefined {
+  const snapshot = terminals.get(event); terminals.delete(event);
+  const owner = owners.get(event); if (owner) pending.delete(owner); owners.delete(event); return snapshot;
+}
+export function bindAnthropicReplay(message: OcxAssistantMessage, snapshot: AnthropicReplaySnapshot): void {
+  if (!issued.has(snapshot)) throw new Error("Untrusted Anthropic replay snapshot");
+  messages.set(message, snapshot);
+}
+/** Top-level copies let cache-control decoration leave the captured provider response untouched. */
+export function anthropicReplayContent(message: OcxAssistantMessage): Block[] | undefined {
+  const snapshot = messages.get(message);
+  if (snapshot && !issued.has(snapshot)) throw new Error("Expired Anthropic replay snapshot");
+  return snapshot?.content.map(block => ({ ...block }));
+}
+
+/** Capture only explicitly opted-in search streams; no client data can manufacture a snapshot. */
+export function createAnthropicReplayCapture(response: Response, budget: TranslatorBudget) {
+  if (!enabled.delete(response)) return undefined;
+  let bytes = 0, valid = true, transferred = false;
+  let active: number | undefined;
+  let started = false, stopped = false;
+  const toolIds = new Set<string>();
+  const blocks: Array<{ value: Block; text: string[]; thinking: string[]; args: string[] }> = [];
+  const release = () => { if (bytes) budget.releaseRetained(bytes, { kind: "retained_collectors" }); bytes = 0; };
+  const invalidate = () => { valid = false; release(); blocks.length = 0; toolIds.clear(); active = undefined; };
+  const retain = (value: unknown) => {
+    // Charge each frame once, before retaining its values. This conservative linear bound also
+    // covers array/object overhead and replacement signatures without serializing a growing block.
+    try {
+      const size = jsonUtf8Bytes(value) * 4 + 64;
+      budget.chargeRetained(size, { kind: "retained_collectors" }); bytes += size;
+      return true;
+    } catch (error) {
+      if (!isTranslatorBudgetExceededError(error)) throw error;
+      invalidate();
+      return false;
+    }
+  };
+  return {
+    invalidate,
+    accept(data: Record<string, unknown>): void {
+      if (!valid) return;
+      const type = data.type;
+      if (type === "ping") return;
+      if (type === "message_start") {
+        const message = data.message as Block | undefined;
+        if (started || (message?.content !== undefined && (!Array.isArray(message.content) || message.content.length > 0))) invalidate();
+        else started = true;
+        return;
+      }
+      if (!started || stopped) { invalidate(); return; }
+      if (type === "message_stop") { stopped = true; if (active !== undefined) invalidate(); return; }
+      if (type === "content_block_start") {
+        const block = data.content_block as Block | undefined;
+        if (active !== undefined || data.index !== blocks.length || !block
+          || !(block.type === "text" && typeof block.text === "string"
+            || block.type === "thinking" && typeof block.thinking === "string"
+            || block.type === "redacted_thinking" && typeof block.data === "string"
+            || block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string"
+              && !!block.input && typeof block.input === "object" && !Array.isArray(block.input))) { invalidate(); return; }
+        if (block.type === "tool_use") {
+          const id = block.id as string;
+          if (!isConformingToolCallId(id) || toolIds.has(id)) { invalidate(); return; }
+          toolIds.add(id);
+        }
+        if (!retain(block)) return;
+        active = blocks.length;
+        blocks.push({ value: { ...block, ...(Array.isArray(block.citations) ? { citations: [...block.citations] } : {}) }, text: typeof block.text === "string" ? [block.text] : [],
+          thinking: typeof block.thinking === "string" ? [block.thinking] : [], args: [] });
+      } else if (type === "content_block_delta") {
+        const delta = data.delta as Block | undefined;
+        if (active === undefined || data.index !== active || !delta) { invalidate(); return; }
+        const block = blocks[active]!;
+        if (!retain(delta)) return;
+        if (delta.type === "text_delta" && block.value.type === "text" && typeof delta.text === "string") block.text.push(delta.text);
+        else if (delta.type === "thinking_delta" && block.value.type === "thinking" && typeof delta.thinking === "string") block.thinking.push(delta.thinking);
+        else if (delta.type === "signature_delta" && block.value.type === "thinking" && typeof delta.signature === "string") block.value.signature = delta.signature;
+        else if (delta.type === "input_json_delta" && block.value.type === "tool_use" && typeof delta.partial_json === "string") block.args.push(delta.partial_json);
+        else if (delta.type === "citations_delta" && block.value.type === "text" && delta.citation && typeof delta.citation === "object") {
+          const citations = block.value.citations;
+          if (citations !== undefined && !Array.isArray(citations)) { invalidate(); return; }
+          if (citations === undefined) block.value.citations = [delta.citation];
+          else (citations as unknown[]).push(delta.citation);
+        } else invalidate();
+      } else if (type === "content_block_stop") {
+        if (active === undefined || data.index !== active) { invalidate(); return; }
+        active = undefined;
+      } else if (type !== "message_start" && type !== "message_delta" && type !== "message_stop" && type !== "ping") invalidate();
+    },
+    finish(event: AdapterEvent): void {
+      if (!valid || !stopped || active !== undefined || event.type !== "done") { invalidate(); return; }
+      let reservation: TranslatorTransientReservation | undefined;
+      try {
+        reservation = budget.reserveTransient(bytes * 2, { kind: "retained_collectors" });
+        const content = blocks.map(block => {
+          const value = block.value;
+          if (value.type === "text") value.text = block.text.join("");
+          if (value.type === "thinking") {
+            value.thinking = block.thinking.join("");
+            if (typeof value.signature !== "string" || value.signature.length === 0) throw new Error("incomplete thinking signature");
+          }
+          if (value.type === "tool_use" && block.args.length) {
+            value.input = JSON.parse(block.args.join(""));
+            if (!value.input || typeof value.input !== "object" || Array.isArray(value.input)) throw new Error("invalid tool input");
+          }
+          return Object.freeze(value);
+        });
+        const snapshot = { content: Object.freeze(content), release: () => { issued.delete(snapshot); release(); } };
+        issued.add(snapshot);
+        terminals.set(event, snapshot); owners.set(event, response); pending.set(response, snapshot);
+        blocks.length = 0; toolIds.clear();
+        transferred = true;
+      } catch { invalidate(); }
+      finally { reservation?.release(); }
+    },
+    discard(): void { if (!transferred) invalidate(); },
+  };
+}
diff --git a/src/adapters/anthropic-tool-catalog.ts b/src/adapters/anthropic-tool-catalog.ts
new file mode 100644
index 00000000000..34bd84cd07d
--- /dev/null
+++ b/src/adapters/anthropic-tool-catalog.ts
@@ -0,0 +1,11 @@
+import { isAllowedToolChoice, toolChoiceToolPredicate, type OcxParsedRequest } from "../types";
+import { rejectsForcedToolChoice } from "./anthropic-model-contract";
+
+/** The catalog actually advertised on the wire, independently of whether calling it is enabled. */
+export function anthropicDeclaredTools(parsed: OcxParsedRequest) {
+  const tools = parsed.context.tools ?? [];
+  const choice = parsed.options.toolChoice;
+  return isAllowedToolChoice(choice)
+    || (rejectsForcedToolChoice(parsed.modelId) && typeof choice === "object" && choice !== null && "name" in choice)
+    ? tools.filter(toolChoiceToolPredicate(choice, tools)) : tools;
+}
diff --git a/src/adapters/anthropic.ts b/src/adapters/anthropic.ts
index 653d91593ce..441f3e23e4c 100644
--- a/src/adapters/anthropic.ts
+++ b/src/adapters/anthropic.ts
@@ -1,3 +1,6 @@
+import { captureAnthropicRejectionPayloads, keepAnthropicReplayBlock } from "./anthropic-rejection-memo";
+import { anthropicDeclaredTools } from "./anthropic-tool-catalog";
+import { anthropicReplayContent, createAnthropicReplayCapture } from "./anthropic-replay";
 import { withAnthropicProgressUpdates } from "./anthropic-progress";
 import type { IncomingMeta, ProviderAdapter } from "./base";
 import { createAdapterTierMetadata, type AdapterTierMetadata } from "../providers/fastwire";
@@ -17,7 +20,7 @@ import type {
   OcxToolResultMessage,
   OcxUsage,
 } from "../types";
-import { isAllowedToolChoice, namespacedToolName, resolveToolChoiceWireName, toolChoiceToolPredicate } from "../types";
+import { isAllowedToolChoice, namespacedToolName, resolveToolChoiceWireName } from "../types";
 import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM_INSTRUCTION, applyClaudeToolPrefix, stripClaudeToolPrefix } from "../oauth/anthropic";
 import { parseDataUrl } from "./image";
 import { enforceAnthropicImageLimits } from "./anthropic-image-guard";
@@ -283,7 +286,7 @@ function normalizeTtlOrdering(body: Record<string, unknown>): void {
   }
 }
 
-function isLikelyRealAnthropicThinkingSignature(signature: string | undefined): signature is string {
+export function isLikelyRealAnthropicThinkingSignature(signature: string | undefined): signature is string {
   if (typeof signature !== "string" || signature.length < 16) return false;
   if (/^(fc|call|msg|rs|resp|reasoning|item|ws|tool|func|function)[-_]/i.test(signature)) return false;
   return /^[A-Za-z0-9+/_=-]+$/.test(signature);
@@ -522,13 +525,13 @@ function streamedToolArgumentsParse(assembled: string): boolean {
   }
 }
 
-/** A string field of a server tool's streamed input (web_search `query`, web_fetch `url`); "" when it did not parse. */
-function serverToolInputField(json: string, key: "query" | "url"): string {
+/** A server tool's complete streamed input; undefined when it cannot be recovered. */
+function serverToolInput(json: string): Record<string, unknown> | undefined {
   try {
-    const value = (JSON.parse(json) as Record<string, unknown> | null)?.[key];
-    return typeof value === "string" ? value : "";
+    const input = JSON.parse(json) as unknown;
+    return isAnthropicRecord(input) ? input : undefined;
   } catch {
-    return "";
+    return undefined;
   }
 }
 
@@ -735,7 +738,16 @@ function orphanToolResultContent(msg: OcxToolResultMessage): string | unknown[]
 function messagesToAnthropicFormat(
   parsed: OcxParsedRequest,
   toolNames: { toWire: (name: string) => string },
+  serverReplay?: ReadonlyMap<string, readonly Record<string, unknown>[]>,
 ): { system: string | undefined; messages: unknown[] } {
+  // The client's server-tool exchanges go back ahead of the block they preceded. Their anchors are
+  // unique in the caller's history (replayedAnthropicServerBlocks drops repeated ones); each is used once.
+  const pendingReplay = new Map(serverReplay);
+  const replayed = (anchor: string) => {
+    const blocks = pendingReplay.get(anchor) ?? [];
+    pendingReplay.delete(anchor);
+    return blocks;
+  };
   // One allocator for the whole request: a tool_result must resolve to the SAME wire id its
   // call got, and two distinct raw ids must never collapse into one. Conforming ids are claimed
   // first so a rewritten id can never squat on an id another call legitimately owns.
@@ -750,8 +762,8 @@ function messagesToAnthropicFormat(
     }
   }
   const toolCatalogNudge = buildNonOpenAIToolCatalogNudgeForTools(
-    parsed.context.tools,
-    parsed.options.toolChoice,
+    anthropicDeclaredTools(parsed),
+    undefined,
     tool => toolNames.toWire(namespacedToolName(tool.namespace, tool.name)),
   );
   const systemParts = [...(parsed.context.systemPrompt ?? []), ...(toolCatalogNudge ? [toolCatalogNudge] : [])];
@@ -781,6 +793,7 @@ function messagesToAnthropicFormat(
       case "assistant": {
         const aMsg = msg as OcxAssistantMessage;
         const preface: unknown[] = [];
+
         const toolUses: unknown[] = [];
         const originalOrder: unknown[] = [];
         const appendPreface = (block: unknown) => { preface.push(block); originalOrder.push(block); };
@@ -789,9 +802,13 @@ function messagesToAnthropicFormat(
         for (const part of aMsg.content) {
           if (part.type === "text") {
             const text = (part as OcxTextContent).text;
+            for (const b of replayed(`text:${text}`)) appendPreface(b);
             if (text) appendPreface({ type: "text", text });
           } else if (part.type === "thinking") {
             const t = part as OcxThinkingContent;
+            // Server blocks that preceded this reasoning keep their place, even when it is dropped below.
+            for (const data of t.redacted ?? []) for (const b of replayed(`redacted:${data}`)) appendPreface(b);
+            for (const b of replayed(`thinking:${t.signature}`)) appendPreface(b);
             // History minted under another serving identity (or already rejected as opaque) is not
             // this destination's to verify: drop its opaque blocks, as the Responses passthrough does.
             if (parsed._stripReasoningEncryptedContent === true) continue;
@@ -806,6 +823,7 @@ function messagesToAnthropicFormat(
             }
           } else if (part.type === "toolCall") {
             const tc = part as OcxToolCall;
+            for (const b of replayed(`call:${tc.id}`)) appendPreface(b);
             const flatName = namespacedToolName(tc.namespace, tc.name);
             // Normalized here, and identically for the matching tool_result above, so a history
             // replayed from another provider path keeps its call/result pairing (#1767).
@@ -824,9 +842,15 @@ function messagesToAnthropicFormat(
         }
         // Anthropic treats text/thinking after tool_use as ending the tool turn, which makes
         // earlier tool_use ids look unpaired (#620 / common multi-step history shape).
-        // Signed native blocks bind the source ordering, including updates between tool calls.
-        // Keep the legacy repair only for unsigned/cross-provider history.
-        const content = signed ? originalOrder : [...preface, ...toolUses];
+        const captured = anthropicReplayContent(aMsg);
+        if (captured) {
+          const expected = toolUses as Array<{ id: string; name: string }>;
+          const actual = captured.filter(block => block.type === "tool_use");
+          if (actual.length !== expected.length || actual.some((block, index) => block.id !== expected[index]?.id || block.name !== expected[index]?.name)) {
+            throw new Error("Anthropic search replay tool identity changed");
+          }
+        }
+        const content = (captured ?? (signed ? originalOrder : [...preface, ...toolUses])).filter(block => keepAnthropicReplayBlock(parsed, block as Record<string, unknown>));
         if (content.length === 0) break;
         messages.push({ role: "assistant", content });
         if (toolUseIds.length > 0) {
@@ -889,9 +913,7 @@ function messagesToAnthropicFormat(
 
 function toolsToAnthropicFormat(parsed: OcxParsedRequest, toolNames: { toWire: (name: string) => string }): unknown[] | undefined {
   if (!parsed.context.tools || parsed.context.tools.length === 0) return undefined;
-  const tools = isAllowedToolChoice(parsed.options.toolChoice)
-    ? parsed.context.tools.filter(toolChoiceToolPredicate(parsed.options.toolChoice, parsed.context.tools))
-    : parsed.context.tools;
+  const tools = anthropicDeclaredTools(parsed);
   if (tools.length === 0) return undefined;
   const converted = tools.map(t => ({
     name: toolNames.toWire(namespacedToolName(t.namespace, t.name)),
@@ -998,7 +1020,9 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         throw new Error("anthropic provider requires a non-empty apiKey (authMode: key)");
       }
 
-      const { system, messages } = messagesToAnthropicFormat(parsed, toolNames);
+      // Only api.anthropic.com runs Anthropic's server tools, so only it gets their history back.
+      const { system, messages } = messagesToAnthropicFormat(parsed, toolNames,
+        usesNativeAnthropicEndpoint(provider) ? parsed._anthropicServerReplay : undefined);
       // Before image normalization, so the framing block is present for every downstream pass.
       if (isAgentRouterEndpoint(provider.baseUrl)) applyAgentRouterLanguageFraming(messages);
       // Primary image layer: resize/re-encode to fit Anthropic limits without dropping
@@ -1210,7 +1234,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
       enforceCacheControlLimit(body, explicitLimit);
       normalizeTtlOrdering(body);
 
-      return {
+      const request = {
         url,
         method: "POST",
         headers,
@@ -1224,6 +1248,8 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
           fastSpeed?.value ?? null,
         ),
       };
+      captureAnthropicRejectionPayloads(request, body, incoming?.translatorBudget);
+      return request;
     },
 
     async *parseStream(
@@ -1236,6 +1262,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         return;
       }
 
+      const replayCapture = createAnthropicReplayCapture(response, budget);
       const budgetEncoder = new TextEncoder();
       let currentBlockType = "";
       let currentToolCallId = "";
@@ -1270,11 +1297,13 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
           yield anthropicContentFilterIncomplete(pendingStopReason, usageFromAnthropic(pendingUsage));
           return;
         }
-        yield {
+        const done: AdapterEvent = {
           type: "done",
           usage: usageFromAnthropic(pendingUsage),
           ...(pendingStopReason ? { stopReason: pendingStopReason } : {}),
         };
+        replayCapture?.finish(done);
+        yield done;
       };
 
       try {
@@ -1294,6 +1323,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         try {
           parsed = JSON.parse(payload);
         } catch {
+          replayCapture?.invalidate();
           debugDroppedFrame("anthropic", payload);
           continue;
         }
@@ -1301,10 +1331,12 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         // it and the `data.type` read below crashed the stream. Drop a non-record frame the same
         // way an unparseable one is dropped, so the message_stop check still governs the outcome.
         if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          replayCapture?.invalidate();
           debugDroppedFrame("anthropic", payload);
           continue;
         }
         const data = parsed as Record<string, unknown>;
+        replayCapture?.accept({ ...data, type: record.event || data.type });
 
         switch (record.event || data.type) {
               case "message_start": {
@@ -1317,6 +1349,9 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
               case "content_block_start": {
                 const block = data.content_block as { type: string; id?: string; name?: unknown; data?: string; thinking?: string; tool_use_id?: unknown; content?: unknown } | undefined;
                 if (!block) break;
+                // Even an unmodeled server tool or empty block is semantic progress.
+                // Fence replays before a later refusal; unknown blocks must not look like pings.
+                yield { type: "heartbeat", replayUnsafe: true };
                 currentBlockType = block.type;
                 if (block.type === "thinking") {
                   // Preserve even a display:omitted block boundary. The bridge can then
@@ -1336,36 +1371,26 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   // no result in this response and must not surface as a completed search.
                   serverSearch = { id: block.id, json: "", streaming: true };
                 }
-                if (block.type === "web_search_tool_result" && typeof block.tool_use_id === "string") {
+                if ((block.type === "web_search_tool_result" || block.type === "web_fetch_tool_result") && typeof block.tool_use_id === "string") {
+                  // The begin/end pair the sidecar emits, plus both blocks verbatim so the Claude client holds a
+                  // replayable copy. Without this response's matching call and complete input, drop the
+                  // exchange instead of inventing a call that could poison the client's next request.
+                  const fetch = block.type === "web_fetch_tool_result";
+                  const input = serverSearch?.id === block.tool_use_id ? serverToolInput(serverSearch.json) : undefined;
+                  if (!input) break;
                   const hits = Array.isArray(block.content) ? block.content as Array<{ url?: unknown; title?: unknown }> : undefined;
-                  // The begin/end pair the sidecar emits. A result whose call came in an earlier response has no query here.
-                  const query = serverSearch?.id === block.tool_use_id ? serverToolInputField(serverSearch.json, "query") : "";
                   yield { type: "web_search_call_begin", id: block.tool_use_id };
                   yield {
                     type: "web_search_call_end",
                     id: block.tool_use_id,
-                    queries: query ? [query] : [],
-                    // A failed search carries one error object instead of the hit list.
-                    status: hits ? "completed" : "failed",
+                    queries: typeof input.query === "string" && input.query.length > 0 ? [input.query] : [],
+                    // A failed call carries one error object instead of the hit list / fetched page.
+                    status: (fetch ? (block.content as { type?: unknown } | undefined)?.type === "web_fetch_result" : hits) ? "completed" : "failed",
                     sources: (hits ?? []).flatMap(h => typeof h.url === "string"
                       ? [{ url: h.url, ...(typeof h.title === "string" ? { title: h.title } : {}) }] : []),
-                  };
-                  serverSearch = undefined;
-                }
-                if (block.type === "web_fetch_tool_result" && typeof block.tool_use_id === "string") {
-                  // Relayed as the same cell, opened at the result for the same reason; the result is
-                  // carried verbatim (a web_fetch_result document or a web_fetch_tool_error).
-                  const result = block.content ?? { type: "web_fetch_tool_error", error_code: "unavailable" };
-                  const url = (result as { url?: unknown }).url;
-                  yield { type: "web_search_call_begin", id: block.tool_use_id };
-                  yield {
-                    type: "web_search_call_end",
-                    id: block.tool_use_id,
-                    queries: [],
-                    status: (result as { type?: unknown }).type === "web_fetch_result" ? "completed" : "failed",
-                    fetch: {
-                      url: typeof url === "string" ? url : serverSearch?.id === block.tool_use_id ? serverToolInputField(serverSearch.json, "url") : "",
-                      result,
+                    anthropic: {
+                      use: { type: "server_tool_use", id: block.tool_use_id, name: fetch ? "web_fetch" : "web_search", input },
+                      result: block as Record<string, unknown>,
                     },
                   };
                   serverSearch = undefined;
@@ -1415,8 +1440,8 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   yield { type: "tool_call_delta", arguments: delta.partial_json };
                 } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string" && serverSearch?.streaming
                     && serverSearch.json.length < 4096) {
-                  // Capped: an input past 4 KiB loses its label (query / url), never the call.
-                  serverSearch.json += delta.partial_json;
+                  // Capped: input that cannot be recovered drops its exchange instead of inventing a call.
+                  serverSearch.json += delta.partial_json.slice(0, 4096 - serverSearch.json.length);
                 }
                 break;
               }
@@ -1463,8 +1488,13 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                 break;
               }
               case "error": {
-                const err = data.error as { message?: string } | undefined;
-                yield { type: "error", message: err?.message ?? "Anthropic error" };
+                const err = data.error as { message?: unknown; type?: unknown; code?: unknown; status?: unknown } | undefined;
+                yield { type: "error", message: typeof err?.message === "string" ? err.message : "Anthropic error",
+                  ...(typeof err?.type === "string" ? { errorType: err.type } : {}),
+                  ...(typeof err?.code === "string" ? { code: err.code } : {}),
+                  ...(typeof err?.status === "number" && Number.isInteger(err.status) && err.status >= 400 && err.status <= 599
+                    ? { status: err.status } : {}),
+                };
                 return;
               }
         }
@@ -1483,6 +1513,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
         // one-terminal-event contract for consumers that keep draining the generator.
         return;
       } finally {
+        replayCapture?.discard();
         if (currentToolCallId) budget.closeCall(currentToolCallId);
       }
       if (!emittedDone) {
diff --git a/src/adapters/google-progress-history.ts b/src/adapters/google-progress-history.ts
new file mode 100644
index 00000000000..68802f9145c
--- /dev/null
+++ b/src/adapters/google-progress-history.ts
@@ -0,0 +1,53 @@
+/**
+ * Gemini progress-text history trimming.
+ *
+ * Gemini models, observed on Gemini 4 Argon over Cloud Code Assist, sometimes skip their thinking
+ * channel on a tool-calling turn and plan in the visible text instead. The provider sends that
+ * planning as an ordinary text part without a thought marker, for example a progress line in the
+ * user's language followed by "Let's read google.ts 580-1700 first." Once one turn like that is
+ * replayed as history, the model copies the pattern on the turns that follow, so the leak grows
+ * through the rest of the session. Replaying the same 300K-token request with the leaked tails
+ * removed from the history stopped the leak, while stronger system-prompt wording did not.
+ *
+ * The fix is on the history side only. Text that precedes the tool call of a replayed model turn is
+ * intermediate progress, and the Google brevity instruction already asks for a single short line
+ * there, so it is replayed as its lead sentence. A turn Codex marks `final_answer` and text after a
+ * tool call are replayed whole. Visible output is never rewritten, final
+ * answers (turns without tool calls) are replayed in full, and the split is punctuation-based so
+ * it works the same in every language without matching any wording.
+ */
+
+/**
+ * Sentence end: ASCII terminal punctuation followed by whitespace or the end (so "google.ts" and
+ * "3.5" are not boundaries), a script's own sentence terminator (CJK 。！？, Devanagari
+ * ।॥, Arabic ۔؟, Armenian ։, Ethiopic ።, Myanmar ။), or a line break. Closing quotes, brackets and
+ * Markdown emphasis right after the punctuation belong to the sentence.
+ */
+const SENTENCE_END = /[.!?]["'\u201D\u2019)\]*_`]*(?=\s|$)|[\u3002\uFF01\uFF1F\u0964\u0965\u06D4\u061F\u0589\u1362\u104B]["'\u201D\u2019\u300D\u300F)\]*_`]*|\n/g;
+
+/** A boundary that only closes a leading list marker ("1.", "a.") or a common abbreviation ("e.g."). */
+const NOT_A_SENTENCE = /^(?:\d{1,3}|[a-z])\.$|(?:^|\s)(?:e\.g|i\.e|etc|vs)\.$/i;
+
+/** Whether replayed progress text for this model is trimmed to its lead sentence. */
+export function trimsGeminiProgressHistory(modelId: string): boolean {
+  return /gemini/i.test(modelId);
+}
+
+/**
+ * The lead sentence of a replayed progress text, or undefined when nothing usable remains.
+ * Text without a sentence boundary is already a single sentence and is returned whole.
+ */
+export function geminiProgressLead(text: string): string | undefined {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return undefined;
+  SENTENCE_END.lastIndex = 0;
+  let end = trimmed.length;
+  for (let match = SENTENCE_END.exec(trimmed); match; match = SENTENCE_END.exec(trimmed)) {
+    const boundary = match.index + match[0].length;
+    if (!NOT_A_SENTENCE.test(trimmed.slice(0, boundary).trim())) { end = boundary; break; }
+  }
+  const lead = trimmed.slice(0, end).trim();
+  // A code-fence opener is not a sentence; replaying it alone would leave an unclosed fence.
+  if (lead.length === 0 || lead.startsWith("```")) return undefined;
+  return lead;
+}
diff --git a/src/adapters/google.ts b/src/adapters/google.ts
index 0bed1927387..5093fe09179 100644
--- a/src/adapters/google.ts
+++ b/src/adapters/google.ts
@@ -44,6 +44,7 @@ import {
   type TranslatorBudget,
 } from "../lib/translator-budget";
 import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
+import { geminiProgressLead, trimsGeminiProgressHistory } from "./google-progress-history";
 import { configuredReasoningEfforts, mapReasoningEffort } from "../reasoning-effort";
 
 // Google-family models (Gemini/Vertex/Antigravity) tend to emit long running commentary between
@@ -466,11 +467,26 @@ function messagesToGeminiFormat(
         const aMsg = msg as OcxAssistantMessage;
         const parts: unknown[] = [];
         const toolCalls: Array<{ wireCallId: string; wireName: string }> = [];
+        // Progress text before a Gemini tool call replays as its lead sentence, so planning the
+        // model leaked into visible text is not copied forward (google-progress-history.ts).
+        const trimProgress = trimsGeminiProgressHistory(identityModelId)
+          && aMsg.phase !== "final_answer"
+          && aMsg.content.some(part => part.type === "toolCall");
+        let progressLeadKept = false;
+        let afterToolCall = false;
         for (const p of aMsg.content) {
           if (p.type === "text") {
-            const textPart = geminiTextPart((p as OcxTextContent).text);
+            let text: unknown = (p as OcxTextContent).text;
+            if (trimProgress && !afterToolCall) {
+              if (progressLeadKept || typeof text !== "string") continue;
+              text = geminiProgressLead(text);
+              if (text === undefined) continue;
+              progressLeadKept = true;
+            }
+            const textPart = geminiTextPart(text);
             if (textPart) parts.push(textPart);
           } else if (p.type === "toolCall") {
+            afterToolCall = true;
             const tc = p as OcxToolCall;
             // Preserve the thought signature on the function-call part so Antigravity/Gemini-3
             // reasoning continuity survives history-driven (stateless) turns, not just same-process
diff --git a/src/bridge/internal.ts b/src/bridge/internal.ts
index 45e70a610c4..4c2f7e2352d 100644
--- a/src/bridge/internal.ts
+++ b/src/bridge/internal.ts
@@ -1,5 +1,6 @@
 import type {
   AdapterEvent,
+  AnthropicServerBlocks,
   OcxMessagePhase,
   OcxProviderContinuationState,
   OcxProviderOpaqueToolCallMetadata,
@@ -186,9 +187,12 @@ export function adapterFailureFromEvent(event: Extract<AdapterEvent, { type: "er
  * This fixes items created from here on. History recorded before it is repaired at the
  * replay boundary by `backfillWebSearchQueries()` in the Responses adapter.
  */
-export function webSearchAction(queries: string[], fetch?: { url: string }): Record<string, unknown> {
+export function webSearchAction(queries: string[], anthropic?: AnthropicServerBlocks): Record<string, unknown> {
   // Anthropic's server-side web_fetch opens one page instead of searching.
-  if (fetch) return { type: "open_page", url: fetch.url };
+  if (anthropic?.use.name === "web_fetch") {
+    const url = (anthropic.result.content as { url?: unknown } | undefined)?.url ?? (anthropic.use.input as { url?: unknown }).url;
+    return { type: "open_page", url: typeof url === "string" ? url : "" };
+  }
   const first = queries[0] ?? "";
   return { type: "search", query: first, queries: queries.length > 0 ? queries : [first] };
 }
diff --git a/src/bridge/response-json.ts b/src/bridge/response-json.ts
index 6ac31fb3e24..72d0bdbc0f1 100644
--- a/src/bridge/response-json.ts
+++ b/src/bridge/response-json.ts
@@ -547,9 +547,9 @@ function buildResponseJSONWithBudget(
         const safeSources = safeWebSearchSources(e.sources);
         pushOutput({
           type: "web_search_call", id: `ws_${uuid()}`, status: e.status ?? "completed",
-          action: webSearchAction(e.queries, e.fetch),
+          action: webSearchAction(e.queries, e.anthropic),
           ...(safeSources.length > 0 ? { sources: safeSources } : {}),
-          ...(e.fetch ? { fetch_result: e.fetch.result } : {}),
+          ...(e.anthropic ? { anthropic_blocks: e.anthropic } : {}),
         });
         if (safeSources.length > 0) {
           for (const source of safeSources) {
diff --git a/src/bridge/sse.ts b/src/bridge/sse.ts
index 4f929edceef..79bd5a4c4db 100644
--- a/src/bridge/sse.ts
+++ b/src/bridge/sse.ts
@@ -1,6 +1,7 @@
 import { anthropicProgressItems } from "../responses/anthropic-progress";
 import type {
   AdapterEvent,
+  AnthropicServerBlocks,
   OcxMessagePhase,
   OcxProviderContinuationState,
   OcxProviderOpaqueToolCallMetadata,
@@ -685,15 +686,15 @@ export function bridgeToResponsesSSE(
       // leaves a "Searching the web" spinner spinning forever.
       // `sources` rides on the done item (additive field; codex-rs serde ignores unknown fields) so
       // downstream translators (claude outbound) can fill web_search_tool_result content.
-      // `fetch` (Anthropic's server-side web_fetch) makes the cell a page open and rides its result
-      // verbatim as `fetch_result`, for the same claude outbound translator.
-      const closeCurrentWebSearch = (status: "completed" | "failed", queries: string[], sources?: { url: string; title?: string }[], fetch?: { url: string; result: unknown }) => {
+      // `anthropic` (Anthropic's server-side call) rides verbatim as `anthropic_blocks`, for the same
+      // claude outbound translator; a web_fetch makes the cell a page open.
+      const closeCurrentWebSearch = (status: "completed" | "failed", queries: string[], sources?: { url: string; title?: string }[], anthropic?: AnthropicServerBlocks) => {
         if (!currentWebSearch) return;
         const item = {
           type: "web_search_call", id: currentWebSearch.itemId, status,
-          action: webSearchAction(queries, fetch),
+          action: webSearchAction(queries, anthropic),
           ...(sources && sources.length > 0 ? { sources } : {}),
-          ...(fetch ? { fetch_result: fetch.result } : {}),
+          ...(anthropic ? { anthropic_blocks: anthropic } : {}),
         };
         emit("response.output_item.done", { output_index: currentWebSearch.outputIndex, item });
         retainFinishedItem(item as OutputItem);
@@ -1231,7 +1232,7 @@ export function bridgeToResponsesSSE(
                 currentWebSearch = { itemId: wsItemId2, eventId: event.id, outputIndex };
               }
               const safeSources = safeWebSearchSources(event.sources);
-              closeCurrentWebSearch(event.status ?? "completed", event.queries, safeSources, event.fetch);
+              closeCurrentWebSearch(event.status ?? "completed", event.queries, safeSources, event.anthropic);
               // Queue this search's sources for the next assistant message (dedup by URL).
               if (safeSources.length > 0) {
                 for (const source of safeSources) {
diff --git a/src/claude/inbound-content-options.ts b/src/claude/inbound-content-options.ts
index 1358de6e1a8..25139ea20f4 100644
--- a/src/claude/inbound-content-options.ts
+++ b/src/claude/inbound-content-options.ts
@@ -87,6 +87,72 @@ export function declaredAnthropicServerTools(raw: unknown): Rec[] | undefined {
   return tools.length > 0 ? tools : undefined;
 }
 
+/** Validate original call/result order without inventing inputs or pairing a later call backwards. */
+function replayableServerRun(run: readonly Rec[]): boolean {
+  const pending = new Map<string, Rec>();
+  const completed = new Set<string>();
+  for (const block of run) {
+    if (block.type === "server_tool_use") {
+      const { id, name, input } = block;
+      if (typeof id !== "string" || !id.startsWith("srvtoolu_") || pending.has(id) || completed.has(id)
+        || (name !== "web_search" && name !== "web_fetch") || !isRec(input)) return false;
+      const prototype = Object.getPrototypeOf(input);
+      const required = input[name === "web_search" ? "query" : "url"];
+      if ((prototype !== Object.prototype && prototype !== null)
+        || typeof required !== "string" || required.trim().length === 0) return false;
+      pending.set(id, block);
+    } else {
+      const id = block.tool_use_id;
+      if (typeof id !== "string") return false;
+      const call = pending.get(id);
+      if (!call || block.type !== `${call.name}_tool_result`
+        || (Array.isArray(block.content) && !block.content.every(h => isRec(h) && typeof h.encrypted_content === "string"))) return false;
+      pending.delete(id);
+      completed.add(id);
+    }
+  }
+  return completed.size > 0 && pending.size === 0;
+}
+
+/**
+ * Completed Anthropic server-tool exchanges (`server_tool_use` + `web_search_tool_result` /
+ * `web_fetch_tool_result`) in the caller's assistant history. The Responses body drops them, so
+ * an Anthropic destination re-inserts them out of body, keyed by the block that follows each run
+ * in its message: `call:<tool_use id>`, `text:<text>`, `thinking:<signature>` or
+ * `redacted:<data>`, all of which survive translation. An anchor that occurs more than once in the
+ * assistant history (string content included) cannot name one owner, so its run stays dropped,
+ * as it was before replay existed. A run with none, an unpaired call, a
+ * non-Anthropic id, or a search hit without `encrypted_content` is not replayable and stays dropped.
+ */
+export function replayedAnthropicServerBlocks(raw: unknown): Map<string, Rec[]> | undefined {
+  if (!isRec(raw) || !Array.isArray(raw.messages)) return undefined;
+  const out = new Map<string, Rec[]>();
+  const seen = new Map<string, number>();
+  const count = (anchor: string) => seen.set(anchor, (seen.get(anchor) ?? 0) + 1);
+  for (const message of raw.messages) {
+    if (!isRec(message) || message.role !== "assistant") continue;
+    if (typeof message.content === "string") count(`text:${message.content}`);
+    if (!Array.isArray(message.content)) continue;
+    let run: Rec[] = [];
+    for (const block of message.content.filter(isRec)) {
+      if (block.type === "server_tool_use" || block.type === "web_search_tool_result" || block.type === "web_fetch_tool_result") {
+        // The caller's breakpoints are dropped on this lane, as for the declared tools above.
+        run.push({ ...block, cache_control: undefined });
+        continue;
+      }
+      const anchor = block.type === "tool_use" ? `call:${String(block.id)}`
+        : block.type === "text" ? `text:${String(block.text)}`
+        : block.type === "thinking" ? `thinking:${String(block.signature)}`
+        : block.type === "redacted_thinking" ? `redacted:${String(block.data)}` : undefined;
+      if (anchor) count(anchor);
+      if (anchor && replayableServerRun(run)) out.set(anchor, run);
+      run = [];
+    }
+  }
+  for (const anchor of out.keys()) if ((seen.get(anchor) ?? 0) > 1) out.delete(anchor);
+  return out.size > 0 ? out : undefined;
+}
+
 export function toolChoiceToResponses(choice: unknown, body: Rec): void {
   if (!isRec(choice)) return;
   if (choice.disable_parallel_tool_use === true) body.parallel_tool_calls = false;
diff --git a/src/claude/outbound.ts b/src/claude/outbound.ts
index c920d9acdb8..19c92d43603 100644
--- a/src/claude/outbound.ts
+++ b/src/claude/outbound.ts
@@ -223,16 +223,24 @@ export function sanitizeWebSearchInput(input: unknown): Rec {
 /**
  * Map a Responses `web_search_call` item to its Anthropic pair: the server_tool_use
  * input (query/queries) and the web_search_tool_result content (hits, or the error
- * object when the search failed). An item carrying `fetch_result` is Anthropic's
- * server-side web_fetch and maps to web_fetch + its web_fetch_tool_result, verbatim.
- * Shared by the SSE and JSON translation paths.
+ * object when the search failed). An item carrying `anthropic_blocks` came from Anthropic's
+ * own server-side call and maps back to those blocks verbatim (`srvtoolu_` id,
+ * `encrypted_content`, web_fetch), so the client can replay them on its next turn.
+ * Shared by the SSE, JSON and direct translation paths.
  */
 export function webSearchPairFromItem(item: Rec): {
-  id: string; name: "web_search" | "web_fetch"; resultType: string; input: Rec; resultContent: unknown; completed: boolean;
+  id: string; name: string; resultType: string; input: Rec; resultContent: unknown; completed: boolean;
 } {
   const action = isRec(item.action) ? item.action : {};
-  const id = typeof item.id === "string" && item.id.length > 0 ? item.id : `srvtoolu_${uuid()}`;
   const completed = item.status !== "failed";
+  const { use, result } = isRec(item.anthropic_blocks) ? item.anthropic_blocks : {};
+  if (isRec(use) && isRec(result) && typeof use.id === "string" && isRec(use.input)
+    && (use.name === "web_search" || use.name === "web_fetch")
+    && result.tool_use_id === use.id && result.type === `${use.name}_tool_result`) {
+    return { id: use.id, name: use.name, resultType: result.type, input: use.input, resultContent: result.content, completed };
+  }
+  const id = typeof item.id === "string" && item.id.length > 0 ? item.id : `srvtoolu_${uuid()}`;
+  // An item emitted before `anthropic_blocks` carried a server web_fetch as `fetch_result`.
   if (item.fetch_result !== undefined) {
     const input = { url: typeof action.url === "string" ? action.url : "" };
     return { id, name: "web_fetch", resultType: "web_fetch_tool_result", input, resultContent: item.fetch_result, completed };
diff --git a/src/cli/cross-home-owner.ts b/src/cli/cross-home-owner.ts
index 3d420e47598..a296d7698cb 100644
--- a/src/cli/cross-home-owner.ts
+++ b/src/cli/cross-home-owner.ts
@@ -26,6 +26,7 @@ import {
 } from "../server/proxy-liveness";
 import { directLocalHttpFetch } from "../server/direct-local-http";
 import type { RuntimePortState } from "../config/process-state";
+import { loopbackFamilyAvailability } from "./loopback-family";
 
 const MAX_HINT_BYTES = 256 * 1024;
 // Far above any real Grok config; discovery must not stall startup when Grok sync is off.
@@ -128,13 +129,19 @@ function loopbackPort(raw: string | null): number | null {
   }
 }
 
+type CrossHomeOwnerOptions = {
+  homeDir?: string;
+  io?: LivenessIo;
+  loopbackAvailabilityFn?: typeof loopbackFamilyAvailability;
+};
+
 /** Returns only a different process with an identity-checked /healthz response. */
-export async function findCrossHomeOwner(options: { homeDir?: string; io?: LivenessIo } = {}): Promise<number | null> {
+export async function findCrossHomeOwner(options: CrossHomeOwnerOptions = {}): Promise<number | null> {
   const verdict = await findCrossHomeOwnerDetailed(options);
   return verdict.kind === "owner" ? verdict.port : null;
 }
 
-export async function findCrossHomeOwnerDetailed(options: { homeDir?: string; io?: LivenessIo } = {}): Promise<CrossHomeOwnerVerdict> {
+export async function findCrossHomeOwnerDetailed(options: CrossHomeOwnerOptions = {}): Promise<CrossHomeOwnerVerdict> {
   const io = options.io ?? {};
   const nowFn = io.nowFn ?? Date.now;
   const timeoutMs = io.timeoutMs ?? START_OWNERSHIP_LIVENESS.timeoutMs ?? 1_500;
@@ -205,6 +212,8 @@ export async function findCrossHomeOwnerDetailed(options: { homeDir?: string; io
   }
 
   const queue = [...candidates];
+  const availability = new Map<string, ReturnType<typeof loopbackFamilyAvailability>>();
+  const checkAvailability = options.loopbackAvailabilityFn ?? loopbackFamilyAvailability;
   const probed = new Set<number>();
   for (const port of queue) {
     if (probed.has(port)) continue;
@@ -225,6 +234,11 @@ export async function findCrossHomeOwnerDetailed(options: { homeDir?: string; io
         noteIndeterminate(port, "ownership discovery ran out of its shared time budget");
         break;
       }
+      // Disabled loopback IPv6 can route ::1 off-host and time out. An ephemeral
+      // local bind proves address absence without treating an available family's
+      // timeout as empty. Unknown bind failures retain the existing probes.
+      if (!availability.has(hostname)) availability.set(hostname, checkAvailability(hostname));
+      if (availability.get(hostname) === "unavailable") continue;
       const identity = await proxyIdentityAt(port, { hostname }, probeIo);
       if (identity === null) {
         // A null identity is not "free": distinguish a unanimous connect refusal
diff --git a/src/cli/loopback-family.ts b/src/cli/loopback-family.ts
new file mode 100644
index 00000000000..fdded605e57
--- /dev/null
+++ b/src/cli/loopback-family.ts
@@ -0,0 +1,31 @@
+/** A failed connect cannot distinguish an absent loopback address from a slow owner. */
+export type LoopbackFamilyAvailability = "available" | "unavailable" | "unknown";
+
+function bindLoopback(hostname: string): { stop(): void } {
+  return Bun.listen({ hostname, port: 0, socket: { data(socket) { socket.end(); } } });
+}
+
+/**
+ * Ask the kernel whether the concrete local address can be bound, independently of
+ * routing/connect timeouts. Only address/family absence permits skipping discovery;
+ * permissions, resource exhaustion and other failures leave owner evidence unknown.
+ * The ephemeral listener is closed synchronously and never accepts client traffic.
+ */
+export function loopbackFamilyAvailability(
+  hostname: string,
+  bindFn: (hostname: string) => { stop(): void } = bindLoopback,
+): LoopbackFamilyAvailability {
+  const address = hostname === "[::1]" ? "::1" : hostname;
+  if (address !== "::1" && address !== "127.0.0.1") return "unknown";
+  let listener: { stop(): void };
+  try {
+    listener = bindFn(address);
+  } catch (error) {
+    const code = (error as { code?: unknown } | null)?.code;
+    return code === "EADDRNOTAVAIL" || code === "EAFNOSUPPORT"
+      || code === "EPROTONOSUPPORT"
+      ? "unavailable" : "unknown";
+  }
+  listener.stop();
+  return "available";
+}
diff --git a/src/codex/catalog/routed-gather.ts b/src/codex/catalog/routed-gather.ts
index 99f7e64d3db..13bf24a7064 100644
--- a/src/codex/catalog/routed-gather.ts
+++ b/src/codex/catalog/routed-gather.ts
@@ -102,7 +102,7 @@ import type {
   CatalogTrustedOpenAiApiPolicySnapshot,
 } from "../convergence-types";
 import type { CatalogGatherProviderAuthOutcome, CatalogGatherProviderModelOutcome, GatherFlightCapture, ModelsAuthResolverFactory } from "./gather-capture";
-import { applyProviderConfigHints, configuredAutoCompactTokenLimit, configuredMaxInputTokens, configuredReasoningSummarySupport, modelInputModalities, routedMaxOutputTokens, withVisionSidecarInput } from "./model-hints";
+import { applyProviderConfigHints, configuredAutoCompactTokenLimit, configuredMaxInputTokens, configuredModelDisplayName, configuredReasoningSummarySupport, modelInputModalities, routedMaxOutputTokens, withVisionSidecarInput } from "./model-hints";
 import { resolveComboCatalogMember } from "./combo-member";
 import { captureGatherFlight, captureTrustedOpenAiApiPolicy, gatherFlightKey, keyedGatherBytesIdentity, withCanonicalOpenAiForwardAuthDefault } from "./gather-capture";
 import { fetchProviderModelsWithAuth, observedModelsAuthResolver, refreshingModelsAuthResolver } from "./provider-models";
@@ -886,10 +886,12 @@ function augmentRoutedModelsWithCapturedOpenAiApiRows(
       undefined,
       metadataConfigDir,
     );
+    const displayName = configuredModelDisplayName(configured, id);
     return {
       provider: OPENAI_API_PROVIDER_ID,
       id,
       owned_by: OPENAI_API_PROVIDER_ID,
+      ...(displayName ? { displayName } : {}),
       ...(contextWindow ? { contextWindow } : {}),
       ...(maxInputTokens ? { maxInputTokens } : {}),
       ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
diff --git a/src/codex/websocket-activity.ts b/src/codex/websocket-activity.ts
new file mode 100644
index 00000000000..5173cec7067
--- /dev/null
+++ b/src/codex/websocket-activity.ts
@@ -0,0 +1,161 @@
+import { createHash } from "node:crypto";
+import { isAuthorizedProviderExecutedCall, type ProviderExecutedCallType } from "../server/responses-undeclared-tool-guard";
+
+// Logical recency avoids clock adjustments and ties between messages in one millisecond.
+let activityOrder = 0;
+const MAX_PENDING_RESULTS = 1024;
+const MAX_RESULT_ID_LENGTH = 1024;
+const resultTypes: Readonly<Record<string, string>> = {
+  function_call: "function_call_output",
+  custom_tool_call: "custom_tool_call_output",
+  local_shell_call: "function_call_output",
+  shell_call: "shell_call_output",
+  computer_call: "computer_call_output",
+  apply_patch_call: "apply_patch_call_output",
+  tool_search_call: "tool_search_output",
+  mcp_approval_request: "mcp_approval_response",
+};
+
+function record(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function resultKey(type: string, id: string): string {
+  return createHash("sha256").update(JSON.stringify([type, id])).digest("hex");
+}
+
+/** Content-free activity owned by one admitted incoming Responses socket. */
+export class CodexWebSocketActivity {
+  lastUsed = ++activityOrder;
+  closing = false;
+  private turns = 0;
+  private pendingResults = new Set<string>();
+  private returnedResults = new Set<string>();
+  // Hashed identities only; null marks a route-authorized provider-owned call.
+  private argumentCalls = new Map<string, { type: string; result: string | null }>();
+  // Unknown/oversized identities cannot safely prove that client work finished.
+  private untrackedResults = false;
+
+  get idle(): boolean {
+    return !this.closing && this.turns === 0 && this.pendingResults.size === 0 && !this.untrackedResults;
+  }
+
+  touch(): void {
+    this.lastUsed = ++activityOrder;
+  }
+
+  /** Each turn retains its own busy reference, including superseded async cleanup. */
+  beginTurn(input: unknown): () => void {
+    this.turns += 1;
+    this.touch();
+    this.acceptResults(input);
+    // Ordinary creates start a new response even when its upstream omits response.created.
+    // Prior results settle old waits, but cannot suppress new calls reusing their IDs.
+    this.returnedResults.clear();
+    this.argumentCalls.clear();
+    let finished = false;
+    return () => {
+      if (finished) return;
+      finished = true;
+      this.turns -= 1;
+      if (this.turns === 0) this.touch();
+    };
+  }
+
+  /** Called only after admission or native control accepts the client's results. */
+  acceptResults(input: unknown): void {
+    if (this.untrackedResults) return;
+    if (Array.isArray(input)) {
+      for (const item of input) {
+        if (!record(item) || typeof item.type !== "string") continue;
+        const id = item.type === "mcp_approval_response" ? item.approval_request_id : item.call_id;
+        if (typeof id === "string" && id.length <= MAX_RESULT_ID_LENGTH) {
+          // Ordinary Codex shell results use function_call_output; native steering
+          // also accepts its explicit local_shell_call_output continuation stub.
+          const type = item.type === "local_shell_call_output" ? "function_call_output" : item.type;
+          const key = resultKey(type, id);
+          if (this.pendingResults.delete(key)) {
+            if (this.returnedResults.size >= MAX_PENDING_RESULTS) { this.protectUntracked(); return; }
+            else this.returnedResults.add(key);
+          }
+        }
+      }
+    }
+  }
+
+  /** Preserve tool waits even when the response terminal omits its output array. */
+  observePayload(payload: string, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void {
+    if (this.untrackedResults) return;
+    let frame: unknown;
+    try { frame = JSON.parse(payload); } catch { return; }
+    if (!record(frame)) return;
+    // Native injection can return a result before the same terminal repeats its call.
+    if (frame.type === "response.created") {
+      this.returnedResults.clear();
+      this.argumentCalls.clear();
+    }
+    if (frame.type === "response.output_item.added") this.rememberArgumentCall(frame.item, providerExecuted);
+    if (frame.type === "response.function_call_arguments.done" || frame.type === "response.custom_tool_call_input.done") {
+      const type = frame.type === "response.function_call_arguments.done" ? "function_call" : "custom_tool_call";
+      const call = typeof frame.item_id === "string" && frame.item_id.length <= MAX_RESULT_ID_LENGTH
+        ? this.argumentCalls.get(resultKey("item", frame.item_id)) : undefined;
+      if (!call || call.type !== type) this.protectUntracked();
+      else if (call.result !== null) this.observeResultKey(call.result);
+    }
+    if (frame.type === "response.output_item.done") this.observeOutput(frame.item, providerExecuted);
+    if (["response.completed", "response.incomplete", "response.failed"].includes(String(frame.type))
+      && record(frame.response) && Array.isArray(frame.response.output)) {
+      for (const item of frame.response.output) this.observeOutput(item, providerExecuted);
+    }
+  }
+
+  private rememberArgumentCall(item: unknown, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void {
+    if (!record(item) || (item.type !== "function_call" && item.type !== "custom_tool_call")) return;
+    if (typeof item.id !== "string" || !item.id.length || item.id.length > MAX_RESULT_ID_LENGTH) return;
+    const key = resultKey("item", item.id);
+    const hosted = providerExecuted && isAuthorizedProviderExecutedCall(item, providerExecuted);
+    if (!hosted && (typeof item.call_id !== "string" || !item.call_id.length || item.call_id.length > MAX_RESULT_ID_LENGTH)) {
+      if (this.argumentCalls.has(key)) this.protectUntracked();
+      return;
+    }
+    const result = hosted ? null : resultKey(resultTypes[item.type]!, item.call_id as string);
+    const previous = this.argumentCalls.get(key);
+    if (previous) {
+      if (previous.type !== item.type || previous.result !== result) this.protectUntracked();
+      return;
+    }
+    if (this.argumentCalls.size >= MAX_PENDING_RESULTS) { this.protectUntracked(); return; }
+    // An unfinished argument stream alone does not prove the client started work.
+    this.argumentCalls.set(key, { type: item.type, result });
+  }
+
+  private observeOutput(item: unknown, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void {
+    if (this.untrackedResults) return;
+    if (!record(item) || typeof item.type !== "string") return;
+    // Hosted execution may publish both the call and its result in the output stream.
+    this.acceptResults([item]);
+    if (!Object.hasOwn(resultTypes, item.type)) return;
+    if (providerExecuted && isAuthorizedProviderExecutedCall(item, providerExecuted)) return;
+    if (item.type === "tool_search_call" && item.execution !== "client") return;
+    const id = item.type === "mcp_approval_request" ? item.id
+      : item.type === "local_shell_call" || item.type === "tool_search_call" ? item.call_id ?? item.id : item.call_id;
+    if (typeof id !== "string" || !id.length || id.length > MAX_RESULT_ID_LENGTH) {
+      this.protectUntracked();
+      return;
+    }
+    this.observeResultKey(resultKey(resultTypes[item.type]!, id));
+  }
+
+  private observeResultKey(key: string): void {
+    if (this.pendingResults.has(key) || this.returnedResults.has(key)) return;
+    if (this.pendingResults.size >= MAX_PENDING_RESULTS) this.protectUntracked();
+    else this.pendingResults.add(key);
+  }
+
+  private protectUntracked(): void {
+    this.untrackedResults = true;
+    this.pendingResults.clear();
+    this.returnedResults.clear();
+    this.argumentCalls.clear();
+  }
+}
diff --git a/src/codex/websocket-registry.ts b/src/codex/websocket-registry.ts
index 91af86aecb4..405179972b0 100644
--- a/src/codex/websocket-registry.ts
+++ b/src/codex/websocket-registry.ts
@@ -1,23 +1,47 @@
 import type { ServerWebSocket } from "bun";
 import type { WsData } from "../server/ws-bridge";
 import { createAdmissionGate, type AdmissionMetrics, type AdmissionReservation } from "../lib/admission";
+import { CodexWebSocketActivity } from "./websocket-activity";
 
 export const MAX_TRACKED_CODEX_WEBSOCKETS = 128;
 const websocketGate = createAdmissionGate("codex_websockets", MAX_TRACKED_CODEX_WEBSOCKETS);
+const admittedSockets = new Set<ServerWebSocket<WsData>>();
+
+function reclaimOldestIdleSocket(): void {
+  let oldest: ServerWebSocket<WsData> | undefined;
+  for (const ws of admittedSockets) {
+    const activity = ws.data.responsesActivity;
+    if (!activity?.idle || ws.data.nativeControl || ws.readyState !== 1 || ws.getBufferedAmount() !== 0) continue;
+    if (!oldest || activity.lastUsed < oldest.data.responsesActivity!.lastUsed) oldest = ws;
+  }
+  if (!oldest) return;
+  // Fence late frames before closing. Only the actual close callback releases admission.
+  oldest.data.responsesActivity!.closing = true;
+  try {
+    oldest.close(1001, "Idle Responses connection reclaimed");
+  } catch {
+    // A failed/delayed close never manufactures a free slot or retries another victim.
+    if (oldest.readyState === 1) oldest.data.responsesActivity!.closing = false;
+  }
+}
 
 export function tryReserveCodexWebSocket(): AdmissionReservation<ServerWebSocket<WsData>> | null {
+  if (websocketGate.metrics().active >= MAX_TRACKED_CODEX_WEBSOCKETS) reclaimOldestIdleSocket();
   const gateLease = websocketGate.tryAcquire();
   if (!gateLease) return null;
   let socket: ServerWebSocket<WsData> | undefined;
   let active = true;
   return {
     bind(value) {
-      if (!active) return;
+      if (!active || socket) return;
       socket = value;
+      socket.data.responsesActivity = new CodexWebSocketActivity();
+      admittedSockets.add(socket);
     },
     release() {
       if (!active) return;
       active = false;
+      if (socket) admittedSockets.delete(socket);
       socket = undefined;
       gateLease.release();
     },
diff --git a/src/config/opencode-zen-upgrade.ts b/src/config/opencode-zen-upgrade.ts
index 974e69ebe23..f3b1da60582 100644
--- a/src/config/opencode-zen-upgrade.ts
+++ b/src/config/opencode-zen-upgrade.ts
@@ -1,4 +1,4 @@
-import { openCodeZenBaseUrl } from "../types/opencode-zen";
+import { openCodeZenBaseUrl, openCodeZenKeyBaseUrl, type OpenCodeZenDestination } from "../types/opencode-zen";
 import { declaredUnsupportedHostedTools, isHostedToolUnsupportedForModel } from "../responses/hosted-tool-policy";
 
 function record(value: unknown): Record<string, unknown> | undefined {
@@ -6,8 +6,9 @@ function record(value: unknown): Record<string, unknown> | undefined {
     ? value as Record<string, unknown> : undefined;
 }
 
-function isGeminiModel(model: string): boolean {
-  return model.trim().toLowerCase().startsWith("gemini-");
+function isNativeZenModel(model: string, provider: OpenCodeZenDestination): boolean {
+  const folded = model.trim().toLowerCase();
+  return folded.startsWith("claude-") || (folded.startsWith("gemini-") && openCodeZenBaseUrl(provider) !== undefined);
 }
 
 /** Repair legacy Zen wire overrides and dependent preferences in file-backed reads only. */
@@ -15,7 +16,7 @@ export function sanitizeOpenCodeZenOverridesForLoad(parsed: unknown): void {
   const providers = record(record(parsed)?.providers);
   const provider = providers && Object.hasOwn(providers, "opencode-zen")
     ? record(providers["opencode-zen"]) : undefined;
-  if (!provider || !openCodeZenBaseUrl(provider)) return;
+  if (!provider || !openCodeZenKeyBaseUrl(provider)) return;
   const overrides = record(provider.modelAdapters) ?? {};
   const preferences = record(provider.modelPreferHostedTools);
   let preferencesChanged = false;
@@ -25,7 +26,7 @@ export function sanitizeOpenCodeZenOverridesForLoad(parsed: unknown): void {
       // Capture the old wire before deleting overrides. An explicit non-Responses entry
       // must not inherit a provider-wide Responses default for this migration.
       const oldAdapter = Object.hasOwn(overrides, model) ? overrides[model] : provider.adapter;
-      if (!isGeminiModel(model) || oldAdapter !== "openai-responses"
+      if (!isNativeZenModel(model, provider) || oldAdapter !== "openai-responses"
         || !Array.isArray(tools) || tools.length === 0 || tools.some(tool => tool !== "image_generation")
         || isHostedToolUnsupportedForModel(model, "image_generation", undefined, unsupported)) continue;
       delete preferences[model];
@@ -37,16 +38,16 @@ export function sanitizeOpenCodeZenOverridesForLoad(parsed: unknown): void {
   for (const [model, adapter] of Object.entries(overrides)) {
     // Retain invalid preference/wire pairs so repeated normalization cannot admit them.
     if (preferences && Object.hasOwn(preferences, model)) continue;
-    if (isGeminiModel(model) && (adapter === "openai-chat" || adapter === "openai-responses")) {
+    if (isNativeZenModel(model, provider) && (adapter === "openai-chat" || adapter === "openai-responses")) {
       delete overrides[model];
       overridesChanged = true;
     }
   }
   if (overridesChanged) {
     if (Object.keys(overrides).length === 0) delete provider.modelAdapters;
-    console.warn("OpenCode Zen Gemini models now use the native Google API; obsolete Chat/Responses overrides were ignored while loading config.json.");
+    console.warn("OpenCode Zen Gemini and Claude models now use their native APIs; obsolete Chat/Responses overrides were ignored while loading config.json.");
   }
   if (preferencesChanged) {
-    console.warn("OpenCode Zen Gemini models now use the native Google API; legacy Responses-only hosted-tool preferences were ignored while loading config.json.");
+    console.warn("OpenCode Zen Gemini and Claude models now use their native APIs; legacy Responses-only hosted-tool preferences were ignored while loading config.json.");
   }
 }
diff --git a/src/images/loop.ts b/src/images/loop.ts
index 9d729678cd8..77ec229f71b 100644
--- a/src/images/loop.ts
+++ b/src/images/loop.ts
@@ -1,3 +1,5 @@
+import type { createAnthropicThinkingRecovery } from "../server/responses/anthropic-thinking-recovery";
+import { bindAnthropicRejectionResponse } from "../adapters/anthropic-rejection-memo";
 /**
  * Media bridge agentic loop — supports both image and video generation sidecars.
  *
@@ -23,7 +25,7 @@ import { bridgeToResponsesSSE } from "../bridge";
 import { isTerminalRefusalIncomplete } from "../bridge/terminal-refusal";
 import { clearableDeadline, idleDeadline } from "../lib/abort";
 import { readBoundedResponseBody } from "../lib/bounded-body";
-import { applyUpstreamRecoveryInit, fetchWithResetRetry, prepareSameTarget429Wait } from "../lib/upstream-retry";
+import { applyUpstreamRecoveryInit, fetchWithResetRetry, prepareSameTarget429Wait, isNonReplayableResponse, SendBudgetExhaustedError } from "../lib/upstream-retry";
 import { rateLimitRetryDelayMs } from "../providers/key-failover";
 import { releaseProviderRequestSlot, sendTrackingRequestSlot, type ProviderRequestSlot } from "../providers/request-pacing";
 import {
@@ -33,7 +35,7 @@ import {
   TRANSLATOR_MAX_TURN_BYTES,
   TranslatorBudgetExceededError,
 } from "../lib/translator-budget";
-import { parseStreamWithProgress, RoutedModelInactivityError, WebSearchStreamProtocolError } from "../web-search/progress-stream";
+import { parseStreamWithProgress, RoutedModelInactivityError, WebSearchStreamProtocolError, WebSearchAdapterEventError } from "../web-search/progress-stream";
 import { fulfillImageCall } from "./fulfill";
 import { parseVideoCallArgs, pollVideoWithHeartbeats, buildVideoResult, createVideoBudget } from "./fulfill-video";
 import { submitVideoJob } from "./xai-video-client";
@@ -270,17 +272,18 @@ function extractIterationThinking(events: AdapterEvent[]): OcxThinkingContent[]
   return parts;
 }
 
-function jsonError(status: number, message: string): Response {
-  return new Response(JSON.stringify({ error: { message, type: "upstream_error", code: null } }), {
+function jsonError(status: number, message: string, event?: Extract<AdapterEvent, { type: "error" }>): Response {
+  return new Response(JSON.stringify({ error: { message, type: event?.errorType ?? "upstream_error", code: event?.code ?? null,
+    ...(event?.retryable === false ? { retryable: false } : {}) } }), {
     status,
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", ...(event?.retryable === false ? { "x-should-retry": "false" } : {}) },
   });
 }
 
 /** Hard provider/parse failure inside an iteration. The eager first iteration converts it to a
  *  non-2xx jsonError; later (already-streaming) iterations surface it as an in-stream error event. */
 class LoopError extends Error {
-  constructor(readonly status: number, message: string) {
+  constructor(readonly status: number, message: string, readonly event?: Extract<AdapterEvent, { type: "error" }>) {
     super(message);
     this.name = "LoopError";
   }
@@ -291,6 +294,7 @@ class LoopError extends Error {
  * metadata, and the optional image/video bridge plans.
  */
 export interface ImageBridgeDeps {
+  thinkingRecovery?: ReturnType<typeof createAnthropicThinkingRecovery>;
   parsed: OcxParsedRequest;
   clientToolCatalogRestriction?: ClientToolCatalogRestriction;
   adapter: ProviderAdapter;
@@ -321,7 +325,7 @@ export interface ImageBridgeDeps {
   /** Provider-specific fetch (e.g. xAI transport wrapper). Falls back to global fetch. */
   fetchImpl?: typeof globalThis.fetch;
   /** Bind physical dispatch to this iteration's built request; pacing remains owned by the loop. */
-  fetchForRequest?: (request: AdapterRequest, parsed: OcxParsedRequest, adapter: ProviderAdapter) => typeof globalThis.fetch;
+  fetchForRequest?: (request: AdapterRequest, parsed: OcxParsedRequest, adapter: ProviderAdapter, recovery?: AttemptRecoveryKind) => typeof globalThis.fetch;
   /** Reserve the routed provider's next request-start slot before each adapter dispatch. */
   waitForRequestSlot?: (signal?: AbortSignal) => Promise<ProviderRequestSlot | void>;
   /** Raw adapter usage at the terminal event, pre wire-normalization (see bridgeToResponsesSSE onUsage). */
@@ -464,6 +468,8 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
   interface IterationResponse {
     response: Response;
     responseAdapter: ProviderAdapter;
+    parsed?: OcxParsedRequest;
+    retryThinking?: () => Promise<IterationResponse>;
     /** runTurn events are already bounded; consume them without replaying or charging twice. */
     collectedEvents?: AdapterEvent[];
   }
@@ -634,7 +640,7 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
           cachedRequest = request;
           cachedAdapter = requestAdapter;
         }
-        const requestFetch = deps.fetchForRequest?.(request, iterParsed, requestAdapter) ?? fetchImpl;
+        const requestFetch = deps.fetchForRequest?.(request, iterParsed, requestAdapter, recovery) ?? fetchImpl;
         let response: Response;
         try {
           if (requestAdapter.fetchResponse) {
@@ -685,7 +691,8 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
         } finally {
           request.releaseBodyObservation?.();
         }
-        return { response, responseAdapter: requestAdapter };
+        bindAnthropicRejectionResponse(request, response);
+        return { response, responseAdapter: requestAdapter, parsed: iterParsed };
       };
 
       let prepared = await fetchOnce(adapter);
@@ -739,9 +746,18 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
         prepared = await fetchOnce(adapter, rotated.recoveryKind);
       }
 
+      if (await deps.thinkingRecovery?.prepareHttp(prepared.response, prepared.responseAdapter.name, iterParsed)) {
+        try { void prepared.response.body?.cancel().catch(() => {}); } catch { /* closed */ }
+        cachedRequest = undefined;
+        prepared = await fetchOnce(adapter, "opaque-blob-rejection");
+      }
       // Final headers have arrived. Clear only the deadline timer before ANY body read.
       headerDeadline.clear();
       if (!prepared.response.ok) {
+        if (deps.thinkingRecovery && prepared.responseAdapter.name === "anthropic") {
+          const event = await deps.thinkingRecovery.projectHttpFailure(prepared.response, signal);
+          throw new LoopError(event.status ?? prepared.response.status, event.message, event);
+        }
         let body: Awaited<ReturnType<typeof readBoundedResponseBody>>;
         try {
           body = await readBoundedResponseBody(prepared.response, { signal });
@@ -762,9 +778,21 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
         const suffix = formatted ? `: ${formatted.slice(0, 400)}` : "";
         throw new LoopError(prepared.response.status, `Provider error ${prepared.response.status}${suffix}`);
       }
-      return prepared;
+      return { ...prepared, retryThinking: async () => {
+        cachedRequest = undefined;
+        headerDeadline = clearableDeadline(connectTimeoutMs, signal);
+        try { return await fetchOnce(adapter, "opaque-blob-rejection"); }
+        catch (error) {
+          if (signal.aborted) throw new LoopError(499, "client closed request during image-bridge");
+          if (headerDeadline.didExpire()) throw new LoopError(504,
+            `Provider response-header timeout after ${connectTimeoutMs}ms during image-bridge`);
+          throw error;
+        } finally { headerDeadline.clear(); deps.onIterationEnd?.(); }
+      } };
     } catch (error) {
       if (isTranslatorBudgetExceededError(error)) throw error;
+      if (error instanceof SendBudgetExhaustedError) throw new LoopError(429, error.message,
+        { type: "error", status: 429, errorType: "rate_limit_error", code: error.code, message: error.message, retryable: false });
       if (headerDeadline.didExpire()) {
         throw new LoopError(504, `Provider response-header timeout after ${connectTimeoutMs}ms during image-bridge`);
       }
@@ -791,14 +819,31 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
     const iterationBudget = prepared.collectedEvents ? undefined : createIterationEventBudget();
     try {
       if (iterationBudget) {
-        const parse = prepared.responseAdapter.parseStream.bind(prepared.responseAdapter);
-        for await (const event of parseStreamWithProgress(prepared.response, parse, {
-          signal,
-          inactivityTimeoutMs: stallTimeoutMs,
-          translatorBudget,
-          // A pass that fails was still billed; the error terminal below reports it with the hidden passes.
-          onErrorUsage: usage => { hiddenUsage = addUsage(hiddenUsage, usage); },
-        })) {
+        const parse = async function* (current: IterationResponse): AsyncGenerator<AdapterEvent> {
+          if (!current.response.ok && deps.thinkingRecovery) {
+            yield await deps.thinkingRecovery.projectHttpFailure(current.response, signal);
+            return;
+          }
+          try {
+            yield* parseStreamWithProgress(current.response, current.responseAdapter.parseStream.bind(current.responseAdapter), {
+              signal, inactivityTimeoutMs: stallTimeoutMs, translatorBudget,
+              preserveAdapterError: deps.thinkingRecovery !== undefined,
+              onErrorUsage: usage => { hiddenUsage = addUsage(hiddenUsage, usage); },
+            });
+          } catch (error) {
+            if (!(error instanceof WebSearchAdapterEventError)) throw error;
+            if (!error.replaySafe) yield { type: "heartbeat", replayUnsafe: true };
+            yield isNonReplayableResponse(current.response)
+              ? { ...error.event, message: "Provider stream error: upstream diagnostic withheld for a non-replayable failure", retryable: false }
+              : error.event;
+          }
+        };
+        const source = deps.thinkingRecovery && prepared.retryThinking
+          ? deps.thinkingRecovery.wrap(parse(prepared), async function* () {
+              yield* parse(await prepared.retryThinking!());
+            }, () => prepared.responseAdapter.name, !isNonReplayableResponse(prepared.response), prepared.response, prepared.parsed)
+          : parse(prepared);
+        for await (const event of source) {
           if (event.type === "heartbeat") yield event;
           else {
             iterationBudget.retain(event);
@@ -812,6 +857,9 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
         throw error;
       }
       if (signal.aborted) throw new LoopError(499, "client closed request during image-bridge");
+      if (error instanceof LoopError) throw error;
+      if (error instanceof SendBudgetExhaustedError) throw new LoopError(429, error.message,
+        { type: "error", status: 429, errorType: "rate_limit_error", code: error.code, message: error.message, retryable: false });
       if (error instanceof RoutedModelInactivityError) throw new LoopError(504, error.message);
       if (error instanceof WebSearchStreamProtocolError) throw new LoopError(502, error.message);
       throw new LoopError(502, `Provider stream error: ${error instanceof Error ? error.message : String(error)}`);
@@ -829,8 +877,9 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
       if (terminal.code === "translation_buffer_limit") {
         throw new TranslatorBudgetExceededError("retained_collectors", TRANSLATOR_MAX_TURN_BYTES);
       }
-      throw new LoopError(502, terminal.message);
+      throw new LoopError(terminal.status ?? 502, terminal.message, terminal);
     }
+    deps.thinkingRecovery?.observeIteration(events);
     return scanEventsForImageCall(events, mediaToolNames);
   };
 
@@ -845,7 +894,9 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
       firstPrepared = await prepareIterationDrained(maxRounds <= 0);
     } catch (e) {
       if (abortSignal) abortSignal.removeEventListener("abort", linkAbort);
-      if (e instanceof LoopError) return jsonError(e.status, e.message);
+      if (e instanceof LoopError) return jsonError(e.status, e.message, e.event);
+      if (e instanceof SendBudgetExhaustedError) return jsonError(429, e.message,
+        { type: "error", status: 429, errorType: "rate_limit_error", code: e.code, message: e.message, retryable: false });
       throw e;
     }
   }
@@ -1101,7 +1152,7 @@ export async function runWithImageBridge(deps: ImageBridgeDeps): Promise<Respons
             yield {
               type: "error",
               message: e instanceof LoopError ? e.message : (e instanceof Error ? e.message : String(e)),
-              ...(e instanceof LoopError ? { status: e.status } : {}),
+              ...(e instanceof LoopError ? { status: e.status, ...(e.event ?? {}) } : {}),
               ...(usage ? { usage } : {}),
             };
           }
diff --git a/src/lib/request-failure-model.ts b/src/lib/request-failure-model.ts
index 7ac0cb9ba61..dc924ac2874 100644
--- a/src/lib/request-failure-model.ts
+++ b/src/lib/request-failure-model.ts
@@ -223,6 +223,8 @@ const RECOVERY_KIND_CAUSE = {
   "rate-limit-429": "rate-limit",
   "anthropic-oauth-429": "rate-limit",
   "oauth-account-429": "rate-limit",
+  // A 402 is the account's quota, not a transient limit; only another account can serve it.
+  "oauth-account-402": "quota-exhausted",
   "image-413": "payload-too-large",
   // The gateway rejects a body it accepts seconds later and the replay is byte-identical, so
   // nothing about the payload was wrong; the origin declined to take it at that moment.
diff --git a/src/oauth/generic-account-failover.ts b/src/oauth/generic-account-failover.ts
index c8cbd8e042c..9fca39601c3 100644
--- a/src/oauth/generic-account-failover.ts
+++ b/src/oauth/generic-account-failover.ts
@@ -483,7 +483,8 @@ export function noteGenericPoolSelection(
  * Cool the account that actually 429'd and name the next eligible one, or null.
  *
  * Returns the id only; the caller mints the credential so a failed refresh does not leave the
- * cooldown applied to an account we then could not use.
+ * cooldown applied to an account we then could not use. `commit: false` still cools the failed
+ * account but only peeks the round-robin ring, for callers that will not dispatch the answer.
  */
 export function rotateGenericOAuthAccountOn429(
   config: OcxConfig,
@@ -492,9 +493,10 @@ export function rotateGenericOAuthAccountOn429(
   retryAfterHeader: string | null | undefined,
   now = Date.now(),
   requestedModelId?: string | null,
+  commit = true,
 ): string | null {
   return rotateGenericOAuthAccountOnRefusal(config, providerName, failedAccountId, "rate",
-    retryAfterHeader, now, requestedModelId);
+    retryAfterHeader, now, requestedModelId, undefined, commit);
 }
 
 /** Kiro adds account-scoped refusal classes; all other providers retain their 429 policy. */
@@ -507,6 +509,7 @@ export function rotateGenericOAuthAccountOnRefusal(
   now = Date.now(),
   requestedModelId?: string | null,
   monthlyCooldownMs?: number,
+  commit = true,
 ): string | null {
   if (kind === "other" || (providerName !== "kiro" && kind !== "rate")) return null;
   if (!isGenericOAuthFailoverEnabled(config, providerName)) return null;
@@ -566,8 +569,8 @@ export function rotateGenericOAuthAccountOnRefusal(
   }
   if (strategy === "round-robin") {
     // PICK here, not peek: the failure already happened and this answer is the one being used,
-    // so the ring genuinely advances.
-    return pickRoundRobinAccount(
+    // so the ring genuinely advances. A caller that only asks whether a sibling exists peeks.
+    return (commit ? pickRoundRobinAccount : peekRoundRobinAccount)(
       genericPoolKey(providerName),
       candidates,
       genericStickyLimit(config, providerName),
diff --git a/src/protocols/encoders/adapter-events.ts b/src/protocols/encoders/adapter-events.ts
index bb1be5ad2d9..cf240923bef 100644
--- a/src/protocols/encoders/adapter-events.ts
+++ b/src/protocols/encoders/adapter-events.ts
@@ -28,7 +28,7 @@
  * completed-response effects belong to the caller, which folds the same events with
  * `buildResponseJSON` at the terminal through `beforeTerminal`.
  */
-import type { AdapterEvent, OcxMessagePhase, OcxProviderContinuationState, OcxUsage } from "../../types";
+import type { AdapterEvent, AnthropicServerBlocks, OcxMessagePhase, OcxProviderContinuationState, OcxUsage } from "../../types";
 import { normalizeDeclaredToolName } from "../../types";
 import { coerceIntegerToolArguments } from "../../lib/tool-argument-integers";
 import { classifyError, isCyberPolicyCode, type OcxErrorPayload } from "../../lib/errors";
@@ -61,7 +61,7 @@ export interface ClientWebSearch {
   status: "completed" | "failed";
   queries: string[];
   sources: { url: string; title?: string }[];
-  fetch?: { url: string; result: unknown };
+  anthropic?: AnthropicServerBlocks;
 }
 
 /**
@@ -412,9 +412,9 @@ export function encodeAdapterEventStream(
     budget.closeCall(call.callId);
     currentToolCall = null;
   };
-  const closeCurrentWebSearch = (status: "completed" | "failed", queries: string[], sources?: { url: string; title?: string }[], fetch?: ClientWebSearch["fetch"]) => {
+  const closeCurrentWebSearch = (status: "completed" | "failed", queries: string[], sources?: { url: string; title?: string }[], anthropic?: AnthropicServerBlocks) => {
     if (!currentWebSearch) return;
-    writer.webSearchDone({ itemId: currentWebSearch.itemId, status, queries, sources: sources ?? [], ...(fetch ? { fetch } : {}) });
+    writer.webSearchDone({ itemId: currentWebSearch.itemId, status, queries, sources: sources ?? [], ...(anthropic ? { anthropic } : {}) });
     currentWebSearch = null;
   };
   const appendToolArgs = (call: OpenToolCall, fragment: string) => {
@@ -689,7 +689,7 @@ export function encodeAdapterEventStream(
               if (currentWebSearch) closeCurrentWebSearch("completed", []);
               currentWebSearch = { itemId: `ws_${uuid()}`, eventId: event.id };
             }
-            closeCurrentWebSearch(event.status ?? "completed", event.queries, safeWebSearchSources(event.sources), event.fetch);
+            closeCurrentWebSearch(event.status ?? "completed", event.queries, safeWebSearchSources(event.sources), event.anthropic);
             break;
           }
           case "done": {
diff --git a/src/protocols/encoders/messages.ts b/src/protocols/encoders/messages.ts
index 9aee92aee3b..9eee75fdb15 100644
--- a/src/protocols/encoders/messages.ts
+++ b/src/protocols/encoders/messages.ts
@@ -345,9 +345,9 @@ function createAnthropicMessageWriter(
         type: "web_search_call",
         id: search.itemId,
         status: search.status,
-        action: webSearchAction(search.queries, search.fetch),
+        action: webSearchAction(search.queries, search.anthropic),
         ...(search.sources.length > 0 ? { sources: search.sources } : {}),
-        ...(search.fetch ? { fetch_result: search.fetch.result } : {}),
+        ...(search.anthropic ? { anthropic_blocks: search.anthropic } : {}),
       });
       const toolIndex = blockIndex++;
       emit("content_block_start", {
diff --git a/src/providers/opencode-zen-rate-limit.ts b/src/providers/opencode-zen-rate-limit.ts
index 383c9f70ae6..788ab730b37 100644
--- a/src/providers/opencode-zen-rate-limit.ts
+++ b/src/providers/opencode-zen-rate-limit.ts
@@ -70,6 +70,9 @@ export function enrichOpenCodeZenRateLimitMessage(
   message: string,
   opts: {
     status: number;
+    /** Parsed upstream error type, when available. */
+    upstreamErrorType?: string | null;
+    upstreamErrorCode?: string | null;
     providerName?: string;
     baseUrl?: string;
     adapter?: string;
@@ -84,7 +87,9 @@ export function enrichOpenCodeZenRateLimitMessage(
 ): string {
   if (opts.status !== 429) return message;
   if (!isOpenCodeZenRateLimitProvider(opts)) return message;
-  if (!/rate\s*limit/i.test(message)) return message;
+  const errorText = `${opts.upstreamErrorType ?? ""} ${opts.upstreamErrorCode ?? ""} ${message}`.replace(/[_-]/g, " ");
+  if (/\b(?:quota|billing)\b|\busage\s+limit\b|\binsufficient\s+(?:credits?|balance|funds)\b|\b(?:credits?|balance)\s+(?:exhausted|depleted)\b/i.test(errorText)) return message;
+  if (opts.upstreamErrorType !== "rate_limit_error" && !/rate\s*limit/i.test(message)) return message;
   if (message.includes(ENRICHMENT_MARKER)) return message;
 
   const upstreamRetry = validateClientRetryAfterHeader(
@@ -165,7 +170,7 @@ export function enrichOpenCodeZenFreeTierMessage(
 }
 
 /**
- * Single entry point for Zen upstream-error guidance on the Responses wire: short-window
+ * Single entry point for Zen upstream-error guidance on Responses and native Messages: short-window
  * rate limits first, then the keyless free-tier admission refusal. Each layer is a no-op
  * outside its own case, so the composition is safe for every other upstream failure.
  */
diff --git a/src/responses/reasoning-replay-cache.ts b/src/responses/reasoning-replay-cache.ts
index 09a4502a99a..213fe24cd9f 100644
--- a/src/responses/reasoning-replay-cache.ts
+++ b/src/responses/reasoning-replay-cache.ts
@@ -46,6 +46,7 @@ export function nativeReasoningTagMatches(expected: string | undefined, presente
 const MAX_TOTAL_BYTES = 256 * 1024;
 const TTL_MS = 60 * 60 * 1000;
 const OPAQUE_BLOB_REJECTION_TTL_MS = 5 * 60 * 1000;
+const MAX_OPAQUE_BLOB_REJECTION_FINGERPRINTS = 256;
 const replayIdentityKey = randomBytes(32);
 const CREDENTIAL_HEADER_NAMES = new Set([
   "authorization",
@@ -78,8 +79,14 @@ interface ServingIdentityEntry {
 interface OpaqueBlobRejectionEntry {
   bytes: number;
   at: number;
+  /** Undefined retains the legacy blanket rejection; only payload digests are stored here. */
+  fingerprints?: ReadonlySet<string>;
 }
 
+export type ReasoningReplayOpaqueBlobRejection =
+  | { mode: "blanket" }
+  | { mode: "selective"; fingerprints: ReadonlySet<string> };
+
 const entries = new Map<string, CacheEntry>();
 const servingIdentities = new Map<string, ServingIdentityEntry>();
 const opaqueBlobRejections = new Map<string, OpaqueBlobRejectionEntry>();
@@ -310,18 +317,57 @@ export function reasoningReplayOpaqueBlobRejectionMemoized(
   return opaqueBlobRejections.has(key);
 }
 
+/** Undefined means no live memo; a selective result owns a defensive copy of its digests. */
+export function getReasoningReplayOpaqueBlobRejection(
+  scope: OcxReasoningReplayScopeRef | undefined,
+): ReasoningReplayOpaqueBlobRejection | undefined {
+  const key = opaqueBlobRejectionKeyFor(scope);
+  if (!key) return undefined;
+  sweepExpiredOpaqueBlobRejections(now());
+  const entry = opaqueBlobRejections.get(key);
+  return entry === undefined ? undefined : entry.fingerprints === undefined ? { mode: "blanket" }
+    : { mode: "selective", fingerprints: new Set(entry.fingerprints) };
+}
+
+/** Incomplete, invalid or unbounded enumerations cannot safely narrow the legacy rejection. */
+function boundedRejectionFingerprints(fingerprints: ReadonlySet<string> | undefined): Set<string> | undefined {
+  if (fingerprints === undefined) return undefined;
+  const copy = new Set<string>();
+  try {
+    // The intrinsic validates a real Set without trusting an overridden iterator or size getter.
+    for (const value of Set.prototype.values.call(fingerprints) as IterableIterator<unknown>) {
+      if (typeof value !== "string" || value.length !== 64 || !/^[a-f0-9]{64}$/.test(value)
+        || copy.size >= MAX_OPAQUE_BLOB_REJECTION_FINGERPRINTS) return undefined;
+      copy.add(value);
+    }
+  } catch { return undefined; }
+  return copy.size > 0 ? copy : undefined;
+}
+
 /** Record only after a blobless retry succeeded for this durable serving identity. */
 export function rememberReasoningReplayOpaqueBlobRejection(
   scope: OcxReasoningReplayScopeRef | undefined,
+  fingerprints?: ReadonlySet<string>,
 ): void {
   const key = opaqueBlobRejectionKeyFor(scope);
   if (!key) return;
-  const bytes = Buffer.byteLength(key, "utf8");
-  if (bytes > MAX_TOTAL_BYTES) return;
+  const keyBytes = Buffer.byteLength(key, "utf8");
+  if (keyBytes > MAX_TOTAL_BYTES) return;
   const at = now();
   sweepExpiredOpaqueBlobRejections(at);
-  if (opaqueBlobRejections.has(key)) deleteOpaqueBlobRejection(key);
-  opaqueBlobRejections.set(key, { bytes, at });
+  const previous = opaqueBlobRejections.get(key);
+  let merged = previous && previous.fingerprints === undefined ? undefined : boundedRejectionFingerprints(fingerprints);
+  if (merged && previous?.fingerprints) {
+    for (const fingerprint of previous.fingerprints) {
+      merged.add(fingerprint);
+      if (merged.size > MAX_OPAQUE_BLOB_REJECTION_FINGERPRINTS) { merged = undefined; break; }
+    }
+  }
+  // A near-limit key can still retain its existing blanket memo if the digest set will not fit.
+  if (merged && keyBytes + merged.size * 64 > MAX_TOTAL_BYTES) merged = undefined;
+  const bytes = keyBytes + (merged?.size ?? 0) * 64;
+  if (previous) deleteOpaqueBlobRejection(key);
+  opaqueBlobRejections.set(key, { bytes, at, ...(merged ? { fingerprints: merged } : {}) });
   opaqueBlobRejectionTotalBytes += bytes;
   while (
     (opaqueBlobRejectionTotalBytes > MAX_TOTAL_BYTES || opaqueBlobRejections.size > MAX_ENTRIES)
diff --git a/src/routing/analytics.ts b/src/routing/analytics.ts
index 5c4411c3b8c..b6c8c7db1d5 100644
--- a/src/routing/analytics.ts
+++ b/src/routing/analytics.ts
@@ -12,7 +12,7 @@
  */
 
 import type { PersistedUsageEntry } from "../usage/log";
-import { estimateRequestCost, serviceTierContext } from "../usage/cost";
+import { computeEntryCost } from "../usage/summary";
 import { openRequestHistoryIndex, requestHistoryDb } from "./history/indexer";
 
 export const ANALYTICS_MAX_ROWS = 50_000;
@@ -122,6 +122,7 @@ const COOLDOWN_RECOVERY_KINDS = new Set([
   "oauth-account-403",
   "anthropic-oauth-429",
   "oauth-account-429",
+  "oauth-account-402",
 ]);
 
 function percentile(sorted: number[], p: number): number | undefined {
@@ -158,19 +159,10 @@ function cooldownTriggering(entry: PersistedUsageEntry | null, status: number):
   });
 }
 
-function successCostUsd(
-  row: Pick<ScannedRow, "provider" | "model">,
-  entry: PersistedUsageEntry,
-): number | null {
-  if (!entry.usage) return null;
-  const estimate = estimateRequestCost({
-    provider: row.provider,
-    model: row.model,
-    usage: entry.usage,
-    usageStatus: entry.usageStatus,
-    serviceTier: serviceTierContext(entry),
-  });
-  return estimate ? estimate.cost.total : null;
+/** Same attempt-aware pricing as /api/usage, so a refused retry before a measured send is priced. */
+function successCostUsd(entry: PersistedUsageEntry): number | null {
+  const { isPriced, costTotal } = computeEntryCost(entry);
+  return isPriced ? costTotal : null;
 }
 
 export async function computeRoutingAnalytics(
@@ -245,7 +237,7 @@ export async function computeRoutingAnalytics(
     if (kind === "success") {
       const entry = parseEntry(row.rowJson);
       if (entry) {
-        rowCostUsd = successCostUsd(row, entry);
+        rowCostUsd = successCostUsd(entry);
         if (rowCostUsd !== null) {
           costTotalUsd += rowCostUsd;
           costCount += 1;
diff --git a/src/server/claude-messages.ts b/src/server/claude-messages.ts
index d450d49ba5d..2d06e4e4db8 100644
--- a/src/server/claude-messages.ts
+++ b/src/server/claude-messages.ts
@@ -33,7 +33,7 @@ import { resolveAlias, claudeCodeNativeAlias, legacyAliasForNative } from "../cl
 import { recordDesktopRequest } from "../claude/desktop-health";
 import { stripOneMillionMarker } from "../claude/context-windows";
 import { captureClaudeInbound } from "../claude/inbound-debug";
-import { declaredAnthropicServerTools } from "../claude/inbound-content-options";
+import { declaredAnthropicServerTools, replayedAnthropicServerBlocks } from "../claude/inbound-content-options";
 import { claudeCodeForIngress } from "../claude/intercept/model-bindings";
 import { classifyInterceptClient } from "../claude/intercept/client-class";
 import { analyzeClaudeCompatibility, isClaudeCompatibilityMode } from "../claude/compatibility";
@@ -1133,6 +1133,7 @@ async function handleClaudeMessagesWithBudget(
     nativeReasoningMint,
     // Out of body like the replay above: the core hands these to an Anthropic destination only.
     anthropicServerTools: declaredAnthropicServerTools(anthropicBody),
+    anthropicServerReplay: replayedAnthropicServerBlocks(anthropicBody),
     claudeGoAffinity: { sessionLane: claudeGoSessionLane },
     claudeNativeSessionId,
     stripClaudeMainAuthForNoncanonicalForward: true,
diff --git a/src/server/index.ts b/src/server/index.ts
index d7e60c1c953..0850f3c1761 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -267,17 +267,17 @@ function startServerWithSpendLedgerOwner(port: number | undefined, deps: StartSe
     startupOwnershipHomes = homes;
     startupOwnershipStatePaths = statePaths;
   } catch { /* inspection below stays unknown */ }
-  const startupCacheOwnership = inspectStartupOwnership(
+  const startupCacheOwnership = shouldSyncCodexOnStart(config) ? inspectStartupOwnership(
     deps,
     startupOwnershipHomes,
     startupOwnershipStatePaths,
     startupWindowsTaskListingCache,
-  );
+  ) : null;
   // Startup cache invalidation is best-effort and applies only when startup sync is enabled.
   // Check OFF before taking K: on Windows K resolves SID + LocalAppData through PowerShell,
   // and run 35093667426 exceeded healthy controls by 33.8 s against that 30 s child budget.
   // The permit callback still re-reads intent under K to close a concurrent disable race.
-  if (shouldSyncCodexOnStart(config) && startupCacheOwnership.ownership === "owned" && startupOwnershipHomes !== null) {
+  if (startupCacheOwnership?.ownership === "owned" && startupOwnershipHomes !== null) {
     try {
       const startupCodexHome = startupOwnershipHomes.codexHome;
       // #1046: record whether this actually rewrote the cache. `handleStart` ORs this
@@ -549,12 +549,12 @@ function startServerWithSpendLedgerOwner(port: number | undefined, deps: StartSe
   // clients; no Codex request can use this lifecycle in that state.
   // Re-probe here instead of trusting the earlier cache decision: startup work
   // between the two sites must not widen the service-install race.
-  const nativeOwnership = inspectStartupOwnership(
+  const nativeOwnership = shouldSyncCodexOnStart(config) ? inspectStartupOwnership(
     deps,
     startupOwnershipHomes,
     startupOwnershipStatePaths,
-  );
-  const preparedNativeMainLifecycle = nativeOwnership.ownership !== "foreign"
+  ) : null;
+  const preparedNativeMainLifecycle = nativeOwnership !== null && nativeOwnership.ownership !== "foreign"
     && startupOwnershipHomes !== null
     ? prepareNativeMainStartupLifecycle(
       deps.nativeMainStartup,
@@ -600,7 +600,7 @@ function startServerWithSpendLedgerOwner(port: number | undefined, deps: StartSe
       return retryPreparedNativeMainLifecycle.start();
     },
   };
-  const nativeMainLifecycle: NativeMainStartupLifecycle = shouldSyncCodexOnStart(config)
+  const nativeMainLifecycle: NativeMainStartupLifecycle = nativeOwnership !== null
     ? nativeOwnership.ownership === "owned"
       ? preparedNativeMainLifecycle
         ? preparedNativeMainLifecycle.start()
diff --git a/src/server/index/live-sideband.ts b/src/server/index/live-sideband.ts
index 8c4b639eb5f..d0840bdc626 100644
--- a/src/server/index/live-sideband.ts
+++ b/src/server/index/live-sideband.ts
@@ -40,8 +40,9 @@ export const MAX_WS_FRAME_BYTES = 50 * 1024 * 1024;
  *
  * What must never happen is neither: an immortal socket plus a destination that silently accepts
  * the orphaned delta. `tests/responses/ws-endpoint.test.ts` holds exactly that pair together.
- * Raising the timeout off 0 is still worth doing for its own reasons (a dead peer holds a socket
- * forever today), and Bun caps the value at 255 seconds, well inside the bound below.
+ * Responses admission separately reclaims its least recently used idle connection under
+ * capacity pressure. That is not a time limit, so expired-reference validation remains required.
+ * Keeping this shared timeout at 0 also preserves quiet live/voice sessions.
  */
 export const WEBSOCKET_IDLE_TIMEOUT_SECONDS = 0;
 /** Ceiling a finite websocket idle timeout must stay under, in seconds. See above. */
diff --git a/src/server/index/serve-options.ts b/src/server/index/serve-options.ts
index 72af800ba1a..56557344e91 100644
--- a/src/server/index/serve-options.ts
+++ b/src/server/index/serve-options.ts
@@ -1618,11 +1618,17 @@ export function createServeOptions(ctx: ServeOptionsContext) {
         // Promote a caller `x-session-id` before admission, as Responses and Messages do (#6520):
         // the ChatGPT bridge forwards only canonical session headers, so the raw marker is lost.
         const sessionReq = withCallerSessionIdentity(req, admission);
-        return runAdmittedHttpTurn(sessionReq, policy, async turnAdmissionLease => withCors(
-          await handleChatCompletions(sessionReq, config, logCtx, { requestId, start, turnAdmissionLease, admission }),
-          req,
-          policy,
-        ), { requestId, start, logCtx });
+        // Only expose an id when the handler or a logged refusal owns its history row.
+        let ownsRequestLog = false;
+        const response = await runAdmittedHttpTurn(sessionReq, policy, async turnAdmissionLease => {
+          ownsRequestLog = true;
+          return withCors(
+            await handleChatCompletions(sessionReq, config, logCtx, { requestId, start, turnAdmissionLease, admission }),
+            req,
+            policy,
+          );
+        }, { requestId, start, logCtx, onLogged: () => { ownsRequestLog = true; } });
+        return ownsRequestLog ? withRequestLogId(response, requestId) : response;
       }
 
       if (url.pathname === "/v1/audio/transcriptions" && req.method === "POST") {
diff --git a/src/server/index/websocket-handler.ts b/src/server/index/websocket-handler.ts
index b0e4057517e..e39f2e71403 100644
--- a/src/server/index/websocket-handler.ts
+++ b/src/server/index/websocket-handler.ts
@@ -89,6 +89,7 @@ import {
 import type { ServeOptionsContext } from "./serve-options";
 import type { RequestMetricsRecorder } from "../request-metrics";
 import { resolveInboundBodyLimitBytes } from "../request-decompress";
+import { responseToolOwnership } from "../responses/response-tool-ownership";
 
 /**
  * The WebSocket half of the Bun.serve options, split out of serve-options.ts to keep that file
@@ -184,6 +185,8 @@ export function createWebsocketHandler(
           }
           return;
         }
+        if (ws.data.responsesActivity?.closing) return;
+        ws.data.responsesActivity?.touch();
         const rawBytes = typeof raw === "string" ? Buffer.byteLength(raw) : raw.byteLength;
         if (rawBytes > MAX_WS_FRAME_BYTES) {
           sendJsonFrame(ws, buildWsErrorFrame(413, {
@@ -223,6 +226,7 @@ export function createWebsocketHandler(
             if (frame.type === "response.inject") {
               if (!ws.data.nativeControl?.inject) throw new NativeSteeringError("injection_not_supported", "Native injection is disabled or unavailable on this route.");
               ws.data.nativeControl.inject(frame);
+              ws.data.responsesActivity?.acceptResults(frame.input);
               return;
             }
             if (frame.type === "response.steer") {
@@ -230,7 +234,10 @@ export function createWebsocketHandler(
               ws.data.nativeControl.steer(frame);
               return;
             }
-            if (ws.data.nativeControl?.continue(frame)) return;
+            if (ws.data.nativeControl?.continue(frame)) {
+              ws.data.responsesActivity?.acceptResults(frame.input);
+              return;
+            }
           } catch (error) {
             sendJsonFrame(ws, buildWsErrorFrame(400, {
               type: "invalid_request_error",
@@ -294,6 +301,7 @@ export function createWebsocketHandler(
         }
 
         // Only a genuinely admitted turn may receive steering or continuations.
+        const finishActivity = ws.data.responsesActivity?.beginTurn(frame.input);
         ws.data.nativeControl = nativeControl;
         const payload: Record<string, unknown> = { ...frame };
         delete payload.type;
@@ -346,11 +354,16 @@ export function createWebsocketHandler(
                 terminalRecorder = recorder;
               },
             });
+            const observeLog = nativeControl?.relayActive
+              ? createNativeSteeringLogObserver(logCtx, () => recordFirstOutput(logCtx, start))
+              : (payload: string) => inspectResponseLogSsePayload(logCtx, payload);
+            const providerExecuted = responseToolOwnership(response);
             await sendResponseToWebSocket(ws, response, isCurrent, {
               untilEof: nativeControl?.relayActive === true,
-              onSsePayload: nativeControl?.relayActive
-                ? createNativeSteeringLogObserver(logCtx, () => recordFirstOutput(logCtx, start))
-                : payload => inspectResponseLogSsePayload(logCtx, payload),
+              onSsePayload: payload => {
+                ws.data.responsesActivity?.observePayload(payload, providerExecuted);
+                observeLog(payload);
+              },
               onTerminal: status => {
                 terminalRecorder?.(status, logCtx.terminalHttpStatus);
                 finalizeLog(httpStatusForRequestLogTerminal(status, logCtx), {
@@ -392,6 +405,7 @@ export function createWebsocketHandler(
               /* socket already gone or send dropped */
             }
           } finally {
+            finishActivity?.();
             turnAdmissionLease.release();
             if (ws.data.nativeControl === nativeControl) ws.data.nativeControl = undefined;
             if (!logged && turnAbort.signal.aborted) finalizeLog(499);
diff --git a/src/server/lifecycle.ts b/src/server/lifecycle.ts
index 97d1d5caa72..c9e6670ee14 100644
--- a/src/server/lifecycle.ts
+++ b/src/server/lifecycle.ts
@@ -38,6 +38,7 @@ export interface ActiveTurnLease extends AdmissionLease {
   attach(lease: AdmissionLease): void;
   bindAbortSignal(signal: AbortSignal): () => void;
   bindAbortController(ac: AbortController): void;
+  unbindAbortController(ac: AbortController): void;
   beginCodexAccountSelection(): CodexAccountSelectionAdmission;
   isTransferred(): boolean;
 }
@@ -231,6 +232,17 @@ export function tryAdmitTurn(sessionLaneId?: string, clientSignal?: AbortSignal)
       activeTurns.set(ac, lease);
       lease.bindAbortSignal(ac.signal);
     },
+    unbindAbortController(ac) {
+      if (!controllers.delete(ac)) return;
+      if (activeTurns.get(ac) === lease) activeTurns.delete(ac);
+      const listener = abortListeners.get(ac.signal);
+      if (listener) {
+        ac.signal.removeEventListener("abort", listener);
+        abortListeners.delete(ac.signal);
+      }
+      // A completed child relay cannot retire its still-running parent turn.
+      if (controllers.size === 0) lease.release();
+    },
     beginCodexAccountSelection() {
       const mainProfileDraining = nativeMainDrainOwners.size > 0;
       let selectionActive = active && !mainProfileDraining;
@@ -327,7 +339,7 @@ export function unregisterTurn(ac: AbortController): void {
     turnReleaseMisses += 1;
     return;
   }
-  lease.release();
+  lease.unbindAbortController(ac);
 }
 export function isDraining(): boolean { return shutdownDraining || temporaryDrainOwners.size > 0; }
 export function getActiveTurnCount(): number { return turnGate.metrics().active; }
diff --git a/src/server/messages-native.ts b/src/server/messages-native.ts
index e67683f2578..eccee246fc8 100644
--- a/src/server/messages-native.ts
+++ b/src/server/messages-native.ts
@@ -44,6 +44,7 @@ import { classifyError } from "../lib/errors";
 import { relaySseWithPayloadRewrite } from "./sse-payload-rewrite";
 import { redactSecretString } from "../lib/redact";
 import { resolveClientRetryAfter } from "../lib/retry-after";
+import { enrichOpenCodeZenUpstreamMessage } from "../providers/opencode-zen-rate-limit";
 import { isTranslatorBudgetExceededError, type TranslatorBudget } from "../lib/translator-budget";
 import {
   applyReplayRefusalClientHeaders,
@@ -845,7 +846,7 @@ export async function handleNativeMessages(options: HandleNativeMessagesOptions)
       upstream.abort();
       return fail(499, "Client cancelled request", "api_error");
     }
-    return retainUpstreamMessagesRequestId(nativeMessagesErrorResponse(response, bodyText, finishLog), response.headers);
+    return retainUpstreamMessagesRequestId(nativeMessagesErrorResponse(response, bodyText, finishLog, route.providerName, activeProvider), response.headers);
   }
 
   const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
@@ -999,7 +1000,7 @@ function isNativeOverflowError(error: Rec, message: string): boolean {
  * Messages path, so a client sees the same contract on either lane: transient 5xx become 529
  * with a retry hint, and a proxy-side replay refusal keeps its no-retry marking.
  */
-function nativeMessagesErrorResponse(response: Response, bodyText: string, finishLog: FinishLog): Response {
+function nativeMessagesErrorResponse(response: Response, bodyText: string, finishLog: FinishLog, providerName: string, provider: OcxProviderConfig): Response {
   let upstreamType: string | undefined;
   let upstreamCode: string | undefined;
   let upstreamMessage: string | undefined;
@@ -1013,8 +1014,20 @@ function nativeMessagesErrorResponse(response: Response, bodyText: string, finis
     }
   } catch { /* keep generic classification */ }
   const detail = formatAnthropicErrorBody(response.status, response.headers, bodyText);
-  const message = upstreamMessage
+  const rawMessage = upstreamMessage
     ?? (detail ? `Provider error ${response.status}: ${detail}` : `Provider error ${response.status}`);
+  const message = enrichOpenCodeZenUpstreamMessage(rawMessage, {
+    status: response.status,
+    providerName,
+    baseUrl: provider.baseUrl,
+    adapter: provider.adapter,
+    authMode: provider.authMode,
+    hasApiKey: Boolean(provider.apiKey?.trim()),
+    upstreamRetryAfter: response.headers.get("retry-after"),
+    upstreamErrorType: upstreamType,
+    upstreamErrorCode: upstreamCode,
+    supportsHttpSameKeyRetry: true,
+  });
   const classified = classifyError(
     response.status,
     upstreamType ?? (response.status === 401 ? "authentication_error"
diff --git a/src/server/responses-undeclared-tool-guard.ts b/src/server/responses-undeclared-tool-guard.ts
index e0a8b7029ad..d64a802b2ab 100644
--- a/src/server/responses-undeclared-tool-guard.ts
+++ b/src/server/responses-undeclared-tool-guard.ts
@@ -298,7 +298,7 @@ export function collectProviderExecutedCallTypes(body: unknown): Set<ProviderExe
   return callTypes;
 }
 
-function isAuthorizedProviderExecutedCall(
+export function isAuthorizedProviderExecutedCall(
   item: Record<string, unknown>,
   callTypes: ProviderExecutedCallTypes,
 ): boolean {
diff --git a/src/server/responses/adapter-continuation.ts b/src/server/responses/adapter-continuation.ts
index 030d4b22185..55f06a0f8bf 100644
--- a/src/server/responses/adapter-continuation.ts
+++ b/src/server/responses/adapter-continuation.ts
@@ -1,3 +1,4 @@
+import { bindAnthropicRejectionResponse } from "../../adapters/anthropic-rejection-memo";
 import { rotateAnthropicAccountOnResponseForInstance } from "../../oauth/anthropic-account-refusal";
 import type { ResponsesRequestContext } from "./core-options";
 import type { PreparedResponsesRequest } from "./request-prepare";
@@ -29,6 +30,7 @@ import {
   applyUpstreamRecoveryInit,
   isNonReplayableResponse,
   prepareSameTarget429Wait,
+  SendBudgetExhaustedError,
 } from "../../lib/upstream-retry";
 import { unwrapUpstreamRetryEvidenceError } from "../../codex/auth-context";
 import { AdmissionModelDeniedError, MODEL_NOT_ALLOWED_FOR_KEY } from "../admission-model-scope";
@@ -121,6 +123,7 @@ export function createAdapterContinuations(
     | "rateLimitRetries"
     | "stallTimeoutMs"
     | "localUpstream"
+    | "thinkingSignatureRecovery"
    >,
 ) {
   const { options, logCtx, config } = requestContext;
@@ -159,6 +162,10 @@ export function createAdapterContinuations(
         errorType: MODEL_NOT_ALLOWED_FOR_KEY, code: MODEL_NOT_ALLOWED_FOR_KEY, retryable: false,
       };
     }
+    if (refusal instanceof SendBudgetExhaustedError) return {
+      type: "error", status: 429, errorType: "rate_limit_error", code: refusal.code,
+      message: refusal.message, retryable: false,
+    };
     return {
       type: "error",
       message: `Provider continuation failed: ${redactSecretString(error instanceof Error ? error.message : String(error))}`,
@@ -309,6 +316,14 @@ export function createAdapterContinuations(
         const recoveryKind = nextContinuationRecoveryKind;
         nextContinuationRecoveryKind = undefined;
         response = await fetchContinuation(recoveryKind);
+        bindAnthropicRejectionResponse(transportState.sameTargetRequest, response);
+        if (initialRecoveryKind === "empty-completion" && await adapterExchange.thinkingSignatureRecovery.prepareHttp(
+          response, transportState.activeAdapter.name, nextParsed,
+        )) {
+          try { void response.body?.cancel().catch(() => {}); } catch { /* closed */ }
+          invalidateSameTargetRequest();
+          response = await fetchContinuation("opaque-blob-rejection");
+        }
         if (kiroRefusalPendingReplay) {
           try { void kiroRefusalPendingReplay.body?.cancel().catch(() => {}); } catch { /* already closed */ }
           kiroRefusalPendingReplay = undefined;
@@ -704,24 +719,25 @@ export function createAdapterContinuations(
       // listener that can cancel its reader even while the parser holds the body lock.
       // The shared signal is not aborted on timeout: this generator must still emit
       // the error that the already-live Responses bridge turns into a terminal.
-      if (nextParsed.stream) {
-        yield* readResponseStreamWithInactivity(
-          response,
-          upstream.signal,
-          bodyInactivityMs,
-          guarded => transportState.activeAdapter.parseStream(guarded, translatorBudget, logCtx.activeTierMetadata),
-        );
-      } else if (transportState.activeAdapter.parseResponse) {
-        yield* await readResponseBodyWithInactivity(
-          response,
-          upstream.signal,
-          bodyInactivityMs,
-          guarded => transportState.activeAdapter.parseResponse!(guarded, translatorBudget, logCtx.activeTierMetadata),
-        );
-      } else {
-        try { void response.body?.cancel().catch(() => {}); } catch { /* already closed */ }
-        yield { type: "error", message: "Provider continuation does not support response parsing" };
-      }
+      const parse = async function* (current: Response): AsyncGenerator<AdapterEvent> {
+        if (!current.ok) {
+          yield await adapterExchange.thinkingSignatureRecovery.projectHttpFailure(current, upstream.signal);
+        } else if (nextParsed.stream) {
+          yield* readResponseStreamWithInactivity(current, upstream.signal, bodyInactivityMs,
+            guarded => transportState.activeAdapter.parseStream(guarded, translatorBudget, logCtx.activeTierMetadata));
+        } else if (transportState.activeAdapter.parseResponse) {
+          yield* await readResponseBodyWithInactivity(current, upstream.signal, bodyInactivityMs,
+            guarded => transportState.activeAdapter.parseResponse!(guarded, translatorBudget, logCtx.activeTierMetadata));
+        } else {
+          try { void current.body?.cancel().catch(() => {}); } catch { /* closed */ }
+          yield { type: "error", message: "Provider continuation does not support response parsing" };
+        }
+      };
+      yield* adapterExchange.thinkingSignatureRecovery.wrap(parse(response), async function* () {
+        invalidateSameTargetRequest();
+        yield* parse(await fetchContinuation("opaque-blob-rejection"));
+      }, () => transportState.activeAdapter.name,
+      initialRecoveryKind === "empty-completion" && !isNonReplayableResponse(response), response, nextParsed);
     } catch (error) {
       // Classify the thrown error before reading signal state: cancelling the stalled
       // source can synchronously abort the shared signal, which would otherwise report
diff --git a/src/server/responses/adapter-delivery.ts b/src/server/responses/adapter-delivery.ts
index 4e46859c10b..01a1af78cdc 100644
--- a/src/server/responses/adapter-delivery.ts
+++ b/src/server/responses/adapter-delivery.ts
@@ -23,6 +23,9 @@ import { resolveStallTimeoutMs } from "../../stall-timeout";
 import { clientEncoderForDelivery, deliverClientEncodedResponse } from "../inference/client-encoder-delivery";
 import { noteKiroServedSuccess } from "../../providers/kiro-usage";
 import { persistKiroAccountState } from "../../providers/kiro-account-state-disk";
+import { readDisplaySafeErrorText, normalizeUpstreamErrorText } from "./core-errors";
+import { sanitizeNonReplayableUpstreamError } from "./non-replayable-error";
+import { isNonReplayableResponse } from "../../lib/upstream-retry";
 import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
 import { guardEmptyToolCatalogEvents, guardEmptyToolCatalogStream } from "../../lib/empty-tool-catalog";
 
@@ -49,7 +52,7 @@ export async function deliverAdapterResponse(
     | "notifyResponseComplete"
   >,
   completionPolicy: Pick<ResponsesCompletionPolicy, "emptyCompletionGuardEnabled">,
-  adapterExchange: Pick<AdapterExchange, "upstreamResponse" | "upstream" | "cleanupUpstreamAbort" | "localUpstream">,
+  adapterExchange: Pick<AdapterExchange, "upstreamResponse" | "upstream" | "cleanupUpstreamAbort" | "localUpstream" | "thinkingSignatureRecovery" | "refetchThinkingSignature">,
   continuationState: Pick<AdapterContinuations, "terminalGuardEnabled" | "fetchTerminalGuardContinuation" | "fetchGuardedEmptyCompletionRetry">,
 ): Promise<Response> {
   const { logCtx, options, config } = requestContext;
@@ -61,7 +64,7 @@ export async function deliverAdapterResponse(
     rememberKiroDeliveredFinalAnswer,
     responseStateOptions,
   } = requestState;
-  const { upstreamResponse, upstream, cleanupUpstreamAbort, localUpstream } = adapterExchange;
+  const { upstreamResponse, upstream, cleanupUpstreamAbort, localUpstream, thinkingSignatureRecovery, refetchThinkingSignature } = adapterExchange;
   const {
     terminalGuardEnabled,
     fetchTerminalGuardContinuation,
@@ -77,6 +80,43 @@ export async function deliverAdapterResponse(
   const { routedCompaction } = sidecarState;
   const bodyInactivityMs = resolveStallTimeoutMs(config.stallTimeoutSec, { localUpstream });
   const upstreamRequestsStream = parsed.stream || isCanonicalOpenAiForwardProvider(route.provider);
+  const recoverThinkingSignature = (events: AsyncIterable<AdapterEvent>): AsyncIterable<AdapterEvent> =>
+    thinkingSignatureRecovery.wrap(events, async function* () {
+      const result = await refetchThinkingSignature();
+      let response = "failed" in result ? result.failed : result;
+      // A replacement can be an HTTP/auth/budget refusal; never feed its JSON body to an SSE parser.
+      if (!response.ok) {
+        // A local refusal closes the upstream signal before returning its generated JSON.
+        // Reading that bounded local body still honors caller cancellation.
+        const errorSignal = "failed" in result ? options.abortSignal ?? new AbortController().signal : upstream.signal;
+        const nonReplayable = isNonReplayableResponse(response);
+        if (nonReplayable) response = await sanitizeNonReplayableUpstreamError(response, errorSignal);
+        const body = await readDisplaySafeErrorText(response, errorSignal, "Upstream recovery failed");
+        const error = normalizeUpstreamErrorText(body, "Upstream recovery failed");
+        yield { type: "error", status: response.status, message: error.message ?? error.safeText,
+          errorType: error.type ?? "upstream_error", ...(error.code ? { code: error.code } : {}),
+          ...(nonReplayable ? { retryable: false } : {}) };
+        return;
+      }
+      try {
+        const retryEvents = upstreamRequestsStream
+          ? readResponseStreamWithInactivity(response, upstream.signal, bodyInactivityMs,
+            guarded => transportState.activeAdapter.parseStream(guarded, translatorBudget, logCtx.activeTierMetadata))
+          : (async function* () {
+              yield* await readResponseBodyWithInactivity(response, upstream.signal, bodyInactivityMs,
+                guarded => transportState.activeAdapter.parseResponse!(guarded, translatorBudget, logCtx.activeTierMetadata));
+            })();
+        for await (const event of retryEvents) {
+          options.onCompactionRecoveryAdapterEvent?.(event);
+          yield event;
+        }
+      } catch (error) {
+        if (!(error instanceof ResponseBodyInactivityError)) throw error;
+        yield { type: "error", message: "Upstream recovery response body stalled before completing",
+          status: 504, errorType: "upstream_error" };
+      }
+    }, () => transportState.activeAdapter.name, !isNonReplayableResponse(upstreamResponse), upstreamResponse);
+
   const clientToolCatalog = requestState.clientToolCatalogRestriction && route.provider.authMode !== "forward"
     ? requestState.clientToolCatalogRestriction : undefined;
   const deliveryToolBridgeMaps = clientToolCatalog
@@ -110,15 +150,16 @@ export async function deliverAdapterResponse(
         throw error;
       }
     })();
+    const recoveredEvents = recoverThinkingSignature(initialEventStream);
     const eventStream = terminalGuardEnabled
       ? guardTerminalEventStream({
           parsed,
-          firstEvents: initialEventStream,
+          firstEvents: recoveredEvents,
           adapterName: transportState.activeAdapter.name,
           maxAutoContinuations: 1,
           continuation: next => fetchTerminalGuardContinuation(next, undefined, !parsed.stream),
         })
-      : initialEventStream;
+      : recoveredEvents;
     // Optional advisor guard (registered per request by the sidecar planner; absent unless the
     // user enabled the advisor): holds synthetic `advisor` tool calls, consults the configured
     // expert model, and re-dispatches the worker. Sits inside the empty-completion guard so an
@@ -147,6 +188,7 @@ export async function deliverAdapterResponse(
     // One completion owner for both deliveries: the bridge calls it from its terminal, the
     // direct client encoder from the fold of the same events.
     const onCompletedResponse = (response: Record<string, unknown>, providerState?: OcxProviderContinuationState) => {
+      if (!options.abortSignal?.aborted) thinkingSignatureRecovery.rememberSuccess(response);
       const served = transportState.sentOAuthSnapshot;
       if (transportState.activeAdapter.name === "kiro" && response.status === "completed" && served
         && noteKiroServedSuccess(served.accountId, served.generation)) persistKiroAccountState();
@@ -250,18 +292,22 @@ export async function deliverAdapterResponse(
         ));
       }
       for (const event of initialEvents) options.onCompactionRecoveryAdapterEvent?.(event);
+      const recoveredEvents: AdapterEvent[] = [];
+      for await (const event of recoverThinkingSignature((async function* () { yield* initialEvents; })())) {
+        recoveredEvents.push(event);
+      }
       let guardedEvents: AdapterEvent[];
       if (terminalGuardEnabled) {
         guardedEvents = [];
         for await (const event of guardTerminalEventStream({
           parsed,
-          firstEvents: (async function* () { yield* initialEvents; })(),
+          firstEvents: (async function* () { yield* recoveredEvents; })(),
           adapterName: transportState.activeAdapter.name,
           maxAutoContinuations: 1,
           continuation: next => fetchTerminalGuardContinuation(next, undefined, !parsed.stream),
         })) guardedEvents.push(event);
       } else {
-        guardedEvents = initialEvents;
+        guardedEvents = recoveredEvents;
       }
       // Optional advisor guard — same semantics as the streaming branch above.
       if (parsed._advisorGuard) {
@@ -325,6 +371,7 @@ export async function deliverAdapterResponse(
     // #1926 gap 2: same buffered-path durability bound as the primary branch.
     await awaitThoughtSignatureDurability();
     if (adapterResponseReachedServingTerminal(events, json)) {
+      if (!options.abortSignal?.aborted) thinkingSignatureRecovery.rememberSuccess(json);
       const served = transportState.sentOAuthSnapshot;
       if (transportState.activeAdapter.name === "kiro" && json.status === "completed" && served
         && noteKiroServedSuccess(served.accountId, served.generation)) persistKiroAccountState();
diff --git a/src/server/responses/adapter-dispatch.ts b/src/server/responses/adapter-dispatch.ts
index afb473ab583..6d228c4721e 100644
--- a/src/server/responses/adapter-dispatch.ts
+++ b/src/server/responses/adapter-dispatch.ts
@@ -1,3 +1,4 @@
+import { bindAnthropicRejectionResponse } from "../../adapters/anthropic-rejection-memo";
 import { deferPhysicalSendReporter } from "./deferred-send-reporter";
 import { spendLedgerStorageErrorResponse } from "./spend-storage-error";
 import { classifyAnthropic429 } from "../../oauth/anthropic-rate-limit-policy";
@@ -87,6 +88,7 @@ import {
   reasoningEffortRejectionText,
   anthropicFastRefused,
 } from "./core-opaque-recovery";
+import { createAnthropicThinkingRecovery } from "./anthropic-thinking-recovery";
 import { shouldAttemptImageTierRetry } from "../image-retry";
 import {
   isTransientConsoleGoUploadRejection,
@@ -591,7 +593,7 @@ export async function prepareAdapterExchange(
   let rateLimitRetries = 0;
   // Shared with the terminal-guard continuation below: an image-tier reduction that let the
   // main request clear a 413 must not be forgotten on the very next continuation build.
-  if (!upstreamResponse.ok) {
+  // Recovery helpers also serve initial HTTP-200 adapter errors during delivery.
     // Recovery loop: multi-key 429 failover + at most ONE opaque-state rebuild and ONE
     // anthropic 413 tightened retry
     // (devlog/260714_image_normalization_pipeline/030). One mutable activeAdapter serves
@@ -600,6 +602,9 @@ export async function prepareAdapterExchange(
     // 413→429 rotation cannot silently undo the tightening.
     let imageRetryAttempted = false;
     const opaqueBlobRecoveryGuard: OpaqueBlobRecoveryGuard = { attempted: false };
+    const thinkingSignatureRecovery = createAnthropicThinkingRecovery(
+      parsed, upstream.signal, opaqueBlobRecoveryGuard, () => !sendBudgetExhausted(),
+    );
     // Console Go answers a transient 400 "Invalid upload request." for bodies it accepts
     // moments later; at most one byte-identical replay is allowed per request.
     const consoleGoUploadRetryGuard: { attempted: boolean } = { attempted: false };
@@ -863,6 +868,11 @@ export async function prepareAdapterExchange(
         return { failed: formatErrorResponse(502, "upstream_error", msg) };
       }
     };
+    const refetchThinkingSignature = () => {
+      invalidateSameTargetRequest();
+      return rebuildAndRefetch("opaque-blob-rejection");
+    };
+  if (!upstreamResponse.ok) {
     const rotateAntigravityAuth = async (
       failedResponse: Response,
       recovery: AttemptRecoveryKind,
@@ -920,6 +930,17 @@ export async function prepareAdapterExchange(
           return await sanitizeNonReplayableUpstreamError(upstreamResponse, upstream.signal);
         } finally { cleanupUpstreamAbort(); }
       }
+      bindAnthropicRejectionResponse(transportState.sameTargetRequest, upstreamResponse);
+      if (await thinkingSignatureRecovery.prepareHttp(
+        upstreamResponse, transportState.activeAdapter.name,
+      )) {
+        try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* closed */ }
+        invalidateSameTargetRequest();
+        const result = await rebuildAndRefetch("opaque-blob-rejection");
+        if ("failed" in result) return result.failed;
+        upstreamResponse = result;
+        continue recovery;
+      }
      if (
        upstreamResponse.status === 401
        && isOAuth401ReplayProvider
@@ -1877,6 +1898,8 @@ export async function prepareAdapterExchange(
             authMode: route.provider.authMode,
             hasApiKey: Boolean(route.provider.apiKey?.trim()),
             upstreamRetryAfter,
+            upstreamErrorType: normalized.type,
+            upstreamErrorCode: normalized.code,
             // This recovery path is the HTTP Responses wire; custom runTurn transports
             // never reach enrichOpenCodeZenUpstreamMessage here.
             supportsHttpSameKeyRetry: true,
@@ -1902,6 +1925,7 @@ export async function prepareAdapterExchange(
     }
   }
 
+  bindAnthropicRejectionResponse(transportState.sameTargetRequest, upstreamResponse);
   cancelBodyOnAbort(upstreamResponse.body, upstream.signal);
 
   return {
@@ -1911,6 +1935,8 @@ export async function prepareAdapterExchange(
     stallTimeoutMs,
     localUpstream,
     upstreamResponse,
+    thinkingSignatureRecovery,
+    refetchThinkingSignature,
     rateLimitPolicy,
     get rateLimitRetries(): typeof rateLimitRetries {
       return rateLimitRetries;
diff --git a/src/server/responses/anthropic-thinking-recovery.ts b/src/server/responses/anthropic-thinking-recovery.ts
new file mode 100644
index 00000000000..4bf6005bfa4
--- /dev/null
+++ b/src/server/responses/anthropic-thinking-recovery.ts
@@ -0,0 +1,153 @@
+import { anthropicRejectionPolicy, bindAnthropicRejectionPolicy, rejectedAnthropicPayloads } from "../../adapters/anthropic-rejection-memo";
+import { normalizeUpstreamErrorText, readDisplaySafeErrorText } from "./core-errors";
+import { sanitizeNonReplayableUpstreamError } from "./non-replayable-error";
+import { isLikelyRealAnthropicThinkingSignature } from "../../adapters/anthropic";
+import type { AdapterEvent, OcxParsedRequest } from "../../types";
+import { upstreamErrorMessageFromPayload } from "../../lib/errors";
+import { readBoundedResponseBody } from "../../lib/bounded-body";
+import { isNonReplayableResponse } from "../../lib/upstream-retry";
+import { rememberReasoningReplayOpaqueBlobRejection } from "../../responses/reasoning-replay-cache";
+import { prepareOpaqueBlobRecovery, type OpaqueBlobRecoveryGuard } from "./core-opaque-recovery";
+
+/** Only the explicit conversation-binding refusal authorizes removing signed history. */
+export function isAnthropicThinkingSignatureBindingRejectionMessage(message: string): boolean {
+  return message.includes("Invalid `signature` in `thinking` block")
+    && message.includes("The block is bound to a different conversation");
+}
+
+function carriesThinkingState(parsed: OcxParsedRequest): boolean {
+  return parsed.context.messages.some(message => message.role === "assistant"
+    && message.content.some(part => part.type === "thinking"
+      && (isLikelyRealAnthropicThinkingSignature(part.signature)
+        || part.redacted?.some(data => typeof data === "string" && data.length > 0))));
+}
+
+/** One request owns both the HTTP refusal and initial-event recovery, never a fresh retry guard. */
+export function createAnthropicThinkingRecovery(
+  parsed: OcxParsedRequest,
+  signal: AbortSignal,
+  guard: OpaqueBlobRecoveryGuard,
+  canRetry: () => boolean,
+) {
+  let rejectedScope: OcxParsedRequest["_reasoningReplayScope"];
+  let rejectedPayloads: ReadonlySet<string> | undefined;
+  let armed = false;
+  let outputSeen = false;
+  let completed = false;
+  let failed = false;
+  let remembered = false;
+
+  const prepare = (message: string, adapterName: string, attempt = parsed, response?: Response): boolean => {
+    if (signal.aborted || !canRetry() || adapterName !== "anthropic" || guard.attempted
+      || parsed._stripReasoningEncryptedContent === true || !carriesThinkingState(attempt)
+      || !isAnthropicThinkingSignatureBindingRejectionMessage(message)) return false;
+    rejectedPayloads = rejectedAnthropicPayloads(response);
+    // A real send must prove that it serialized opaque history; otherwise rebuilding could
+    // repeat the same request. Direct event-policy callers have no HTTP body to identify.
+    if (response && !rejectedPayloads?.size) return false;
+    const previous = anthropicRejectionPolicy(parsed);
+    if (rejectedPayloads && previous?.mode === "selective") {
+      const merged = new Set(previous.fingerprints);
+      for (const payload of rejectedPayloads) merged.add(payload);
+      rejectedPayloads = merged.size <= 256 ? merged : undefined;
+    }
+    guard.attempted = true;
+    armed = true;
+    const scope = parsed._reasoningReplayScope;
+    rejectedScope = scope ? { ...scope, current: scope.current ? { ...scope.current } : undefined } : undefined;
+    if (!rejectedPayloads) {
+      prepareOpaqueBlobRecovery(parsed);
+      if (attempt !== parsed) prepareOpaqueBlobRecovery(attempt);
+    }
+    const policy = rejectedPayloads ? { mode: "selective" as const, fingerprints: rejectedPayloads } : { mode: "blanket" as const };
+    bindAnthropicRejectionPolicy(parsed, policy);
+    bindAnthropicRejectionPolicy(attempt, policy);
+    return true;
+  };
+
+  const prepareHttp = async (response: Response, adapterName: string, attempt = parsed): Promise<boolean> => {
+    if (signal.aborted || !canRetry() || response.status !== 400 || isNonReplayableResponse(response)
+      || adapterName !== "anthropic" || guard.attempted
+      || parsed._stripReasoningEncryptedContent === true || !carriesThinkingState(attempt)) return false;
+    try {
+      const body = await readBoundedResponseBody(response.clone(), { signal });
+      if (!body.displaySafe || body.truncated) return false;
+      const message = upstreamErrorMessageFromPayload(JSON.parse(body.text) as unknown);
+      return typeof message === "string" && prepare(message, adapterName, attempt, response);
+    } catch {
+      return false;
+    }
+  };
+
+  const observe = (event: AdapterEvent): void => {
+    if (!armed) return;
+    if (event.type === "error" || event.type === "incomplete") failed = true;
+    if (event.type === "done") completed = true;
+    if ((event.type === "text_delta" && event.text.length > 0) || event.type === "tool_call_end") outputSeen = true;
+  };
+
+  async function* wrap(
+    events: AsyncIterable<AdapterEvent>,
+    retry: () => AsyncIterable<AdapterEvent>,
+    adapterName: () => string,
+    replayAllowed = true,
+    response?: Response,
+    attempt = parsed,
+  ): AsyncGenerator<AdapterEvent> {
+    let source = events;
+    let replaySafe = replayAllowed;
+    while (true) {
+      const iterator = source[Symbol.asyncIterator]();
+      let recovered = false;
+      try {
+        while (true) {
+          const next = await iterator.next();
+          if (next.done) return;
+          const event = next.value;
+          if (replaySafe && event.type === "error" && prepare(event.message, adapterName(), attempt, response)) {
+            // Close the rejected body before acquiring another dispatch/pacing slot.
+            await iterator.return?.();
+            source = retry();
+            recovered = true;
+            break;
+          }
+          // Even hidden reasoning, boundaries, and tool activity fence a replay. A heartbeat
+          // carrying a side-effect latch is never evidence that a turn is safe to repeat.
+          replaySafe &&= event.type === "heartbeat" && event.replayUnsafe !== true;
+          observe(event);
+          yield event;
+        }
+      } finally {
+        if (!recovered) await iterator.return?.();
+      }
+    }
+  }
+
+  const rememberSuccess = (response: Readonly<Record<string, unknown>>): void => {
+    // HTTP 200, EOF, or a guard-generated completion alone cannot prove the stripped send worked.
+    // The delivery owner calls this only after its bridge/fold validated a successful terminal.
+    if (!armed || remembered || signal.aborted || failed || !completed || !outputSeen
+      || response.status !== "completed" || !Array.isArray(response.output) || response.output.length === 0
+      || !rejectedScope
+      || rejectedScope.clientThreadId !== parsed._reasoningReplayScope?.clientThreadId
+      || JSON.stringify(rejectedScope.current) !== JSON.stringify(parsed._reasoningReplayScope?.current)) return;
+    remembered = true;
+    rememberReasoningReplayOpaqueBlobRejection(rejectedScope, rejectedPayloads);
+  };
+  // The search owner supplies only a fully validated current iteration, never search-card output.
+  const observeIteration = (events: readonly AdapterEvent[]): void => {
+    outputSeen = false;
+    completed = false;
+    for (const event of events) observe(event);
+  };
+  const projectHttpFailure = async (response: Response, abortSignal: AbortSignal): Promise<Extract<AdapterEvent, { type: "error" }>> => {
+    const nonReplayable = isNonReplayableResponse(response);
+    if (nonReplayable) response = await sanitizeNonReplayableUpstreamError(response, abortSignal);
+    const text = await readDisplaySafeErrorText(response, abortSignal, `Provider error ${response.status}`);
+    const error = normalizeUpstreamErrorText(text, `Provider error ${response.status}`);
+    return { type: "error", status: response.status, message: error.message ?? error.safeText,
+      errorType: error.type ?? "upstream_error", ...(error.code ? { code: error.code } : {}),
+      ...(nonReplayable ? { retryable: false } : {}) };
+  };
+  return { prepareHttp, prepareEvent: prepare, observeIteration, projectHttpFailure, wrap, rememberSuccess };
+}
diff --git a/src/server/responses/combo-stream-preflight.ts b/src/server/responses/combo-stream-preflight.ts
index 390097b0762..5cdc1b4ddb6 100644
--- a/src/server/responses/combo-stream-preflight.ts
+++ b/src/server/responses/combo-stream-preflight.ts
@@ -4,6 +4,7 @@ import { comboFailureDecision } from "../../combos";
 import { httpStatusFromTerminalError } from "../../lib/errors";
 import type { RequestFailureStage } from "../../lib/request-failure-model";
 import type { RequestLogContext } from "../request-log";
+import { carryResponseToolOwnership } from "./response-tool-ownership";
 import { createSseInspector } from "../relay";
 import { MAX_CLIENT_SSE_FRAME_BYTES } from "../sse-frame-buffer";
 
@@ -198,11 +199,11 @@ function replayBufferedResponse(
       reader.cancel(reason).catch(() => undefined);
     },
   });
-  return new Response(body, {
+  return carryResponseToolOwnership(response, new Response(body, {
     status: response.status,
     statusText: response.statusText,
     headers: response.headers,
-  });
+  }));
 }
 
 function failedTerminalResponse(
diff --git a/src/server/responses/compaction-recovery.ts b/src/server/responses/compaction-recovery.ts
index 1b23aa6744a..f35c6a8d39f 100644
--- a/src/server/responses/compaction-recovery.ts
+++ b/src/server/responses/compaction-recovery.ts
@@ -1,4 +1,5 @@
 import type { AdapterEvent, OcxConfig } from "../../types";
+import { carryResponseToolOwnership } from "./response-tool-ownership";
 import { routeConcreteModel, type RouteResult } from "../../router";
 import { copyPlainData } from "../../lib/plain-data";
 import { jsonUtf8Bytes } from "../../lib/json-byte-size";
@@ -78,6 +79,7 @@ async function bufferedJson(response: Response, signal: AbortSignal): Promise<{
   headers.delete("content-length");
   headers.delete("content-encoding");
   const replacement = new Response(bytes.bytes, { status: response.status, statusText: response.statusText, headers });
+  carryResponseToolOwnership(response, replacement);
   if (isNonReplayableResponse(response)) markResponseNonReplayable(replacement);
   try {
     const json: unknown = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.bytes));
diff --git a/src/server/responses/core-codex-account.ts b/src/server/responses/core-codex-account.ts
index de3152da035..7f73f04c4ce 100644
--- a/src/server/responses/core-codex-account.ts
+++ b/src/server/responses/core-codex-account.ts
@@ -975,8 +975,8 @@ export async function retryCodexPoolOnAlternateAccount(
   const maxRetrySends = retrySameConfirmedAccount ? 7 : 1;
   let retrySendCount = 0;
   // The gated-model 400 has no roster kind; it stays unattributed as before.
-  const moveRecovery: AttemptRecoveryKind | undefined = outcomeStatus === 429 || outcomeStatus === 402
-    ? "oauth-account-429"
+  const moveRecovery: AttemptRecoveryKind | undefined = outcomeStatus === 429 ? "oauth-account-429"
+    : outcomeStatus === 402 ? "oauth-account-402"
     : isTransientUpstreamStatus(outcomeStatus) ? "transient-5xx" : undefined;
   let upstreamResponse: Response;
   try {
diff --git a/src/server/responses/core-combo.ts b/src/server/responses/core-combo.ts
index 3104433d4c7..ce76e36637c 100644
--- a/src/server/responses/core-combo.ts
+++ b/src/server/responses/core-combo.ts
@@ -144,7 +144,8 @@ function cooledPoolAccountLabel(config: OcxConfig, providerName: string, modelId
  * through `accountLogLabel`, but the per-request account budget can end the pool's own rotation
  * before the last refused account is recorded. Hand that account to the pool's rotator, which
  * cools it under the pool's own Retry-After policy, and spare the target only when the pool still
- * has an eligible sibling. A lone account or an all-cooled pool returns null and cools the target.
+ * has an eligible sibling. The rotator only peeks round-robin here: nothing is sent to that sibling.
+ * A lone account or an all-cooled pool returns null and cools the target.
  */
 function cooledGenericOAuthAccountLabel(
   config: OcxConfig, providerName: string, modelId: string, label: string | undefined, retryAfter: string | undefined,
@@ -155,7 +156,7 @@ function cooledGenericOAuthAccountLabel(
   const matches = getAccountSet(providerName)?.accounts.filter(account =>
     oauthAccountLogLabel(account.id, base) === label) ?? [];
   return matches.length === 1
-    && rotateGenericOAuthAccountOn429(config, providerName, matches[0]!.id, retryAfter, Date.now(), modelId)
+    && rotateGenericOAuthAccountOn429(config, providerName, matches[0]!.id, retryAfter, Date.now(), modelId, false)
     ? label : undefined;
 }
 
diff --git a/src/server/responses/core-lifetime.ts b/src/server/responses/core-lifetime.ts
index 2dd337ae534..4050f4be44f 100644
--- a/src/server/responses/core-lifetime.ts
+++ b/src/server/responses/core-lifetime.ts
@@ -1,4 +1,5 @@
 import type { TranslatorBudget } from "../../lib/translator-budget";
+import { carryResponseToolOwnership } from "./response-tool-ownership";
 import { finalizeTranslatorBudgetResponse } from "../../lib/translator-budget";
 import { isNonReplayableResponse, markResponseNonReplayable } from "../../lib/upstream-retry";
 import {
@@ -50,7 +51,7 @@ export function finalizeOwnedTranslatorBudget(response: Response, budget: Transl
   if (isPreinspectedJsonResponse(response)) markPreinspectedJsonResponse(finalizedResponse);
   if (isNonReplayableResponse(response)) markResponseNonReplayable(finalizedResponse);
   if (runTurnAdapterSseResponses.has(response)) runTurnAdapterSseResponses.add(finalizedResponse);
-  return finalizedResponse;
+  return carryResponseToolOwnership(response, finalizedResponse);
 }
 
 /** Release a serving-account slot when the client body ends, errors or is cancelled. */
@@ -75,7 +76,7 @@ export function finalizeAccountLease(response: Response, release: () => void, on
   if (isEagerRelaySseResponse(response)) markEagerRelaySseResponse(wrapped);
   if (isPreinspectedJsonResponse(response)) markPreinspectedJsonResponse(wrapped);
   if (runTurnAdapterSseResponses.has(response)) runTurnAdapterSseResponses.add(wrapped);
-  return wrapped;
+  return carryResponseToolOwnership(response, wrapped);
 }
 
 
diff --git a/src/server/responses/core-options.ts b/src/server/responses/core-options.ts
index daac9b1cebe..3ee37545491 100644
--- a/src/server/responses/core-options.ts
+++ b/src/server/responses/core-options.ts
@@ -177,6 +177,8 @@ export interface HandleResponsesOptions {
   nativeReasoningMint?: { owner?: NativeReasoningOwner };
   /** The Claude client's typed `web_search_*` / `web_fetch_*` declarations; kept only for `inboundWire: "anthropic"`. */
   anthropicServerTools?: readonly Record<string, unknown>[];
+  /** The Claude client's replayable server-tool exchanges (`replayedAnthropicServerBlocks`); same scope. */
+  anthropicServerReplay?: ReadonlyMap<string, readonly Record<string, unknown>[]>;
   /** Droid's per-request effort default; each concrete combo or policy target applies it only if its ladder allows it. */
   droidDefaultEffort?: string;
   /** PF-07: the Chat source a combo child may send natively; set only by the Chat ingress. */
diff --git a/src/server/responses/core-replay.ts b/src/server/responses/core-replay.ts
index 35f5d2569d6..567b0cbd42d 100644
--- a/src/server/responses/core-replay.ts
+++ b/src/server/responses/core-replay.ts
@@ -1,3 +1,5 @@
+import { bindAnthropicRejectionPolicy } from "../../adapters/anthropic-rejection-memo";
+import { getReasoningReplayOpaqueBlobRejection } from "../../responses/reasoning-replay-cache";
 import type {
   OcxProviderContinuationOwner,
   OcxProviderContinuationState,
@@ -177,8 +179,10 @@ export function bindRouteReasoningReplayScope(args: {
       parsed._dropForeignReasoningItemIds = true;
     }
   }
+  const rejectionMemo = getReasoningReplayOpaqueBlobRejection(parsed._reasoningReplayScope);
+  bindAnthropicRejectionPolicy(parsed, adapterName === "anthropic" ? rejectionMemo : undefined);
   if (reasoningReplayOpaqueBlobRejectionMemoized(parsed._reasoningReplayScope)) {
-    parsed._stripReasoningEncryptedContent = true;
+    if (adapterName !== "anthropic" || rejectionMemo?.mode !== "selective") parsed._stripReasoningEncryptedContent = true;
     parsed._stripNativeCompactionEncryptedContent = true;
     parsed._dropForeignReasoningItemIds = true;
   }
diff --git a/src/server/responses/passthrough-execution.ts b/src/server/responses/passthrough-execution.ts
index c41c1c3acc9..5d72e561493 100644
--- a/src/server/responses/passthrough-execution.ts
+++ b/src/server/responses/passthrough-execution.ts
@@ -14,6 +14,7 @@ import { guardDirectPassthroughBodyInactivity } from "../../lib/response-body-in
 import { resolveStallTimeoutMs } from "../../stall-timeout";
 import { releaseUpstreamHostAdmission } from "../../codex/upstream-host-health";
 import { releaseCodexAuthContextProbeLease } from "../../codex/auth-context";
+import { attachResponseToolOwnership } from "./response-tool-ownership";
 
 /** Owns the native host lease across dispatch, recovery, and response construction. */
 export async function executePassthroughResponse(
@@ -50,11 +51,11 @@ export async function executePassthroughResponse(
     // Delivery has already classified SSE (including a missing upstream content type)
     // and consumed bounded JSON/errors. Guard only its remaining direct body, outside
     // the relay/lifetime wrappers so their prefetch cannot arm our inactivity clock.
-    return guardDirectPassthroughBodyInactivity(
+    return attachResponseToolOwnership(guardDirectPassthroughBodyInactivity(
       response,
       nativeExchange.upstream.signal,
       resolveStallTimeoutMs(requestContext.config.stallTimeoutSec, { localUpstream: nativeExchange.localUpstream }),
-    );
+    ), nativeExchange.providerExecutedCallTypes);
   } finally {
     if (nativeHostState.lease) {
       releaseUpstreamHostAdmission(nativeHostState.lease);
diff --git a/src/server/responses/request-prepare.ts b/src/server/responses/request-prepare.ts
index 71f1ec132e1..e7ebf8eedf8 100644
--- a/src/server/responses/request-prepare.ts
+++ b/src/server/responses/request-prepare.ts
@@ -476,6 +476,7 @@ export async function prepareResponsesRequest(
       parsed._nativeReasoningReplay = options.nativeReasoningReplay;
       parsed._nativeReasoningMint = options.nativeReasoningMint;
       parsed._anthropicServerTools = options.anthropicServerTools;
+      parsed._anthropicServerReplay = options.anthropicServerReplay;
     }
     parsed._promptCacheKeyIsSharedCohort = options.promptCacheKeyIsSharedCohort;
     // The body may have been rebuilt since the inbound observation (previous-response
diff --git a/src/server/responses/response-effects.ts b/src/server/responses/response-effects.ts
index 9b29aae01c4..e901594e401 100644
--- a/src/server/responses/response-effects.ts
+++ b/src/server/responses/response-effects.ts
@@ -90,6 +90,7 @@ export function createResponsesEffects(
     delete parsed.context.tools;
     delete parsed._webSearch;
     delete parsed._anthropicServerTools;
+    delete parsed._anthropicServerReplay;
     delete parsed.options.toolChoice;
     delete parsed.options.parallelToolCalls;
     // The compaction turn is a plain prose summary; a surviving structured-output format
diff --git a/src/server/responses/response-tool-ownership.ts b/src/server/responses/response-tool-ownership.ts
new file mode 100644
index 00000000000..323095a24da
--- /dev/null
+++ b/src/server/responses/response-tool-ownership.ts
@@ -0,0 +1,21 @@
+import type { ProviderExecutedCallType } from "../responses-undeclared-tool-guard";
+
+// Route-authorized execution ownership follows only the response selected for delivery.
+// It never becomes a wire header or mutable state shared by competing route attempts.
+const providerCalls = new WeakMap<Response, ReadonlySet<ProviderExecutedCallType>>();
+
+export function attachResponseToolOwnership(response: Response, types: ReadonlySet<ProviderExecutedCallType>): Response {
+  if (types.size > 0) providerCalls.set(response, new Set(types));
+  return response;
+}
+
+export function responseToolOwnership(response: Response): ReadonlySet<ProviderExecutedCallType> | undefined {
+  return providerCalls.get(response);
+}
+
+/** Carry ownership only when rebuilding the same selected response body. */
+export function carryResponseToolOwnership(source: Response, target: Response): Response {
+  const types = providerCalls.get(source);
+  if (types) providerCalls.set(target, types);
+  return target;
+}
diff --git a/src/server/responses/sidecar-execution.ts b/src/server/responses/sidecar-execution.ts
index dd4fdd3ed8e..fc4ebb65ead 100644
--- a/src/server/responses/sidecar-execution.ts
+++ b/src/server/responses/sidecar-execution.ts
@@ -1,3 +1,4 @@
+import { createAnthropicThinkingRecovery } from "./anthropic-thinking-recovery";
 import { rotateAnthropicAccountOnResponseForInstance } from "../../oauth/anthropic-account-refusal";
 import type { ResponsesRequestContext } from "./core-options";
 import type { PreparedResponsesRequest } from "./request-prepare";
@@ -20,7 +21,7 @@ import {
   runWithImageBridge,
   clampImageMaxRounds,
 } from "../../images";
-import type { ProviderAdapter } from "../../adapters/base";
+import type { AdapterRequest, ProviderAdapter } from "../../adapters/base";
 import type { OcxParsedRequest, OcxUsage } from "../../types";
 import { rotateProviderTransportOn429, rateLimitRetryPolicyFor } from "../../providers/key-failover";
 import {
@@ -32,7 +33,7 @@ import {
   failoverAccountSnapshot,
 } from "../../oauth/generic-account-failover";
 import { classifyKiroRefusal } from "../../adapters/kiro-refusal";
-import { isNonReplayableResponse } from "../../lib/upstream-retry";
+import { isNonReplayableResponse, SendBudgetExhaustedError } from "../../lib/upstream-retry";
 import { unwrapUpstreamRetryEvidenceError } from "../../codex/auth-context";
 import { AdmissionModelDeniedError, admissionModelDeniedResponse } from "../admission-model-scope";
 import { noteKiroMonthlyRefusal, noteKiroServedSuccess } from "../../providers/kiro-usage";
@@ -100,7 +101,7 @@ export async function executeResponsesSidecars(
     | "notifyResponseComplete"
     | "cancelResponseCompletion"
   >,
-  sendBudgetState: Pick<ResponsesSendBudget, "reserveCredentialHop" | "refundableAdapterDispatchBudget" | "adapterDispatchBudget" | "noteInitialDispatch" | "noteAdapterPhysicalSend" | "noteAdapterRecoveryWithheld" | "pendingHopPermit">,
+  sendBudgetState: Pick<ResponsesSendBudget, "sendBudgetExhausted" | "reserveCredentialHop" | "refundableAdapterDispatchBudget" | "adapterDispatchBudget" | "noteInitialDispatch" | "noteAdapterPhysicalSend" | "noteAdapterRecoveryWithheld" | "pendingHopPermit">,
 ) {
   const { config, options, logCtx } = requestContext;
   const antigravityPoolActivated = requestState.route.providerName === "google-antigravity"
@@ -379,7 +380,7 @@ export async function executeResponsesSidecars(
       recoveryKind = "oauth-account-429";
       if (!options.comboInitialSend && canRunWebSearch && route.providerName === "google-antigravity")
         sendBudgetState.pendingHopPermit = hop.permit;
-      else sidecarBudget.ownCredentialHop(hop.permit);
+      else sidecarBudget.ownCredentialHop(hop.permit, (canRunWebSearch || !!imgPlan || !!vidPlan) && transportState.adapter.name === "anthropic");
     } else if (
       // Anthropic's pool is excluded from generic failover, so without this arm a 429 inside a
       // web-search or image-bridge turn was terminal even with the pool fully enabled -- while
@@ -421,7 +422,7 @@ export async function executeResponsesSidecars(
       }
       recoveryKind = originalResponse?.status === 401 ? "oauth-401"
         : originalResponse?.status === 403 ? "oauth-account-403" : "anthropic-oauth-429";
-      sidecarBudget.ownCredentialHop(hop.permit);
+      sidecarBudget.ownCredentialHop(hop.permit, (canRunWebSearch || !!imgPlan || !!vidPlan) && transportState.adapter.name === "anthropic");
     } else {
       // No key pool, no generic OAuth roster, no Anthropic pool could produce a replacement
       // credential. The 429 is terminal for this sidecar turn.
@@ -454,6 +455,35 @@ export async function executeResponsesSidecars(
     });
     return { adapter: rotatedAdapter, recoveryKind };
   };
+  // One guard follows the active sidecar across all iterations. Enforced spend has no
+  // authoritative receipt for earlier legacy sends, so recovery cannot claim headroom there.
+  const thinkingRecovery = createAnthropicThinkingRecovery(parsed,
+    options.abortSignal ?? new AbortController().signal, { attempted: false },
+    () => !sendBudgetState.sendBudgetExhausted()
+      && !!sendBudgetState.adapterDispatchBudget
+      && sendBudgetState.adapterDispatchBudget.spendEnforced !== true);
+  const thinkingReceipt = (request: AdapterRequest, adapter: ProviderAdapter, recovery?: AttemptRecoveryKind) =>
+    adapter.name !== "anthropic" ? {} : { onPhysicalDispatch: () => {
+      if (recovery === "opaque-blob-rejection") {
+        const decision = sendBudgetState.adapterDispatchBudget?.reserveDispatch({
+          sendClass: "repair", targetKey: `${route.providerName}|${request.url}|${route.modelId}`,
+        });
+        if (sendBudgetState.adapterDispatchBudget?.spendEnforced || !decision?.allowed) {
+          if (decision?.allowed) decision.permit.release();
+          throw new SendBudgetExhaustedError("sidecar thinking recovery");
+        }
+        try { sendBudgetState.noteInitialDispatch(decision.permit); }
+        finally { decision.permit.release(); }
+      } else {
+        const existing = sidecarBudget.fetchOptions(adapter).onPhysicalDispatch;
+        if (existing) existing();
+        else {
+          const prepaid = sendBudgetState.pendingHopPermit;
+          sendBudgetState.pendingHopPermit = undefined;
+          sendBudgetState.noteInitialDispatch(prepaid);
+        }
+      }
+    } };
   // A loop's hidden rounds before a rotation were spent by the account it left. Bill them to that
   // account's attempt while it is still open; the next send seals it. Declined when that send
   // keeps the account (no new attempt), so the loop's final total still carries them.
@@ -520,6 +550,7 @@ export async function executeResponsesSidecars(
     );
     const imgResponse = await runWithImageBridge({
       parsed, adapter: transportState.adapter,
+      ...(transportState.adapter.name === "anthropic" ? { thinkingRecovery } : {}),
       clientToolCatalogRestriction: route.provider.authMode === "forward" ? undefined : requestState.clientToolCatalogRestriction,
       incomingMeta: { headers: requestState.selectedForwardHeaders, providerName: route.providerName, abortSignal: options.abortSignal, translatorBudget, ...(options.comboInitialSend ? { providerFetch: imageProviderFetch } : {}), ...sidecarBudget.incomingMeta },
       onProducerStart: sidecarBudget.takeProducerOwnership,
@@ -540,10 +571,11 @@ export async function executeResponsesSidecars(
       stallTimeoutSec: config.stallTimeoutSec,
       waitForRequestSlot: imageProviderFetch.waitForPacing,
       fetchImpl: imageProviderFetch.unpacedFetch ?? imageProviderFetch,
-      fetchForRequest: (request, iterParsed, adapter) => {
+      fetchForRequest: (request, iterParsed, adapter, recovery) => {
         const fetch = providerFetch(route.provider, options.codexWsRuntimeIdentity, {
           dispatchOverride: oauthDispatch(request, iterParsed),
           providerName: route.providerName, modelId: route.modelId, ...sidecarBudget.fetchOptions(adapter),
+          ...thinkingReceipt(request, adapter, recovery),
         });
         return fetch.unpacedFetch ?? fetch;
       },
@@ -569,6 +601,7 @@ export async function executeResponsesSidecars(
       ...(options.forceEmptyResponseId ? { forceEmptyResponseId: true } : {}),
       terminalRefusalAsFailed: inboundWire !== "chat" && inboundWire !== "anthropic",
       onCompletedResponse: (response, providerState) => {
+        if (!options.abortSignal?.aborted) thinkingRecovery.rememberSuccess(response);
         const served = transportState.replayOAuthCredentialSnapshot;
         if (route.providerName === "kiro" && response.status === "completed" && served
           && noteKiroServedSuccess(served.accountId, served.generation)) persistKiroAccountState();
@@ -618,11 +651,13 @@ export async function executeResponsesSidecars(
       })(input, init)) as typeof globalThis.fetch;
     const loopResponse = await runWithWebSearch({
       parsed, adapter: transportState.adapter,
+      ...(transportState.adapter.name === "anthropic" ? { thinkingRecovery } : {}),
       clientToolCatalogRestriction: route.provider.authMode === "forward" ? undefined : requestState.clientToolCatalogRestriction,
       onIterationEnd: sidecarBudget.releaseUnsentHop,
-      fetchForRequest: (request, iterParsed, adapter) => providerFetch(route.provider, options.codexWsRuntimeIdentity, {
+      fetchForRequest: (request, iterParsed, adapter, recovery) => providerFetch(route.provider, options.codexWsRuntimeIdentity, {
         dispatchOverride: oauthDispatch(request, iterParsed),
         providerName: route.providerName, modelId: route.modelId, ...sidecarBudget.fetchOptions(adapter),
+        ...thinkingReceipt(request, adapter, recovery),
       }),
       incomingMeta: {
         headers: requestState.selectedForwardHeaders,
@@ -683,6 +718,7 @@ export async function executeResponsesSidecars(
         if (route.providerName === "kiro" && response.status === "completed" && served
           && noteKiroServedSuccess(served.accountId, served.generation)) persistKiroAccountState();
         commitReasoningReplayServingRoute();
+        if (!options.abortSignal?.aborted) thinkingRecovery.rememberSuccess(response);
         notifyResponseComplete(response);
       },
     });
diff --git a/src/server/responses/sidecar-send-budget.ts b/src/server/responses/sidecar-send-budget.ts
index 8d0402a22a1..c2bed679260 100644
--- a/src/server/responses/sidecar-send-budget.ts
+++ b/src/server/responses/sidecar-send-budget.ts
@@ -22,8 +22,8 @@ export function createSidecarSendBudget(
   };
   return {
     /** Retain a Combo hop until dispatch; direct requests keep eager settlement. */
-    ownCredentialHop(permit?: SingleUseDispatchPermit): void {
-      if (!initial) { permit?.use(); return; } // Preserve direct callers' reporting contract.
+    ownCredentialHop(permit?: SingleUseDispatchPermit, retainUntilDispatch = false): void {
+      if (!initial && !retainUntilDispatch) { permit?.use(); return; } // Preserve direct callers' reporting contract.
       releaseHop();
       hopPermit = permit;
       budget.pendingHopPermit = permit;
diff --git a/src/server/ws-bridge.ts b/src/server/ws-bridge.ts
index da2d2c50883..4009a48c1d7 100644
--- a/src/server/ws-bridge.ts
+++ b/src/server/ws-bridge.ts
@@ -11,6 +11,7 @@ import { BoundedSseFrameBuffer } from "./sse-frame-buffer";
 import { sseDataPayload as parseSseBlock } from "./sse-payload-rewrite";
 import { safeResponseHeaders } from "./safe-response-headers";
 import type { AudioSocketTarget } from "./audio-dictation";
+import type { CodexWebSocketActivity } from "../codex/websocket-activity";
 
 export { safeResponseHeaders } from "./safe-response-headers";
 
@@ -19,6 +20,7 @@ type ResponsesTerminalReporter = (status: ResponsesTerminalStatus) => void;
 type ResponsesPayloadObserver = (payload: string) => void;
 
 export interface WsData {
+  responsesActivity?: CodexWebSocketActivity;
   nativeControl?: NativeResponseControl;
   /** Content-free per-turn explanation; never a model capability assertion. */
   nativeSteeringUnavailable?: string;
diff --git a/src/types.ts b/src/types.ts
index 2abde60e2af..f94998ed276 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -61,6 +61,7 @@ export type {
   OcxProviderContinuationOwner,
   OcxProviderContinuationState,
   AdapterEvent,
+  AnthropicServerBlocks,
   OcxUrlCitation,
   OcxUsage,
 } from "./types/request";
diff --git a/src/types/opencode-zen.ts b/src/types/opencode-zen.ts
index 0452a7bc966..c3d7fedd18c 100644
--- a/src/types/opencode-zen.ts
+++ b/src/types/opencode-zen.ts
@@ -1,14 +1,14 @@
-/** Fixed-key OpenCode Zen destinations exposing the native Gemini endpoint. */
+/** Fixed-key OpenCode Zen destinations supporting native model protocols. */
 export interface OpenCodeZenDestination {
   readonly baseUrl?: unknown;
   readonly authMode?: unknown;
   readonly googleMode?: unknown;
 }
 
-export function openCodeZenBaseUrl(provider: OpenCodeZenDestination | undefined): string | undefined {
+/** Match the official Zen destination and API-key authentication. */
+export function openCodeZenKeyBaseUrl(provider: OpenCodeZenDestination | undefined): string | undefined {
   if (!provider || typeof provider.baseUrl !== "string") return undefined;
   if (provider.authMode !== undefined && provider.authMode !== "key") return undefined;
-  if (provider.googleMode !== undefined && provider.googleMode !== "ai-studio") return undefined;
   try {
     const url = new URL(provider.baseUrl.trim());
     const pathname = url.pathname.replace(/\/+$/, "");
@@ -20,6 +20,12 @@ export function openCodeZenBaseUrl(provider: OpenCodeZenDestination | undefined)
   }
 }
 
+/** Gemini's native endpoint applies only in AI Studio mode. */
+export function openCodeZenBaseUrl(provider: OpenCodeZenDestination | undefined): string | undefined {
+  if (provider?.googleMode !== undefined && provider.googleMode !== "ai-studio") return undefined;
+  return openCodeZenKeyBaseUrl(provider);
+}
+
 /** Keep the selected destination; Zen omits AI Studio's /v1beta segment. */
 export function openCodeZenGeminiEndpoint(provider: OpenCodeZenDestination, modelId: string): string | undefined {
   const baseUrl = openCodeZenBaseUrl(provider);
diff --git a/src/types/request.ts b/src/types/request.ts
index 229d42c9ed5..6e014690b6c 100644
--- a/src/types/request.ts
+++ b/src/types/request.ts
@@ -68,6 +68,11 @@ export interface OcxParsedRequest {
    * them, and only for api.anthropic.com; every other destination never sees them.
    */
   _anthropicServerTools?: readonly Record<string, unknown>[];
+  /**
+   * Completed server-tool exchanges from the Claude client's history, keyed by the block that
+   * followed them (`call:<tool_use id>` / `text:<text>`). Same audience as `_anthropicServerTools`.
+   */
+  _anthropicServerReplay?: ReadonlyMap<string, readonly Record<string, unknown>[]>;
   /**
    * Boundary between replayed history and this turn's newly appended input. Usually the
    * items the proxy restored from local previous_response_id state; also set when the
@@ -414,6 +419,9 @@ export interface OcxProviderContinuationState {
   [provider: string]: Record<string, unknown> | undefined;
 }
 
+/** One Anthropic server-side call as the API returned it: `server_tool_use` + its `*_tool_result`. */
+export interface AnthropicServerBlocks { use: Record<string, unknown>; result: Record<string, unknown> }
+
 export type AdapterEvent =
   | { type: "heartbeat"; replayUnsafe?: true; preflightReady?: true }
   | { type: "text_delta"; text: string; phase?: OcxMessagePhase;
@@ -443,8 +451,8 @@ export type AdapterEvent =
   | { type: "web_search_call_begin"; id: string }
   | {
       type: "web_search_call_end"; id: string; queries: string[]; status?: "completed" | "failed"; sources?: OcxUrlCitation[];
-      /** Anthropic's server-side web_fetch (adapters/anthropic.ts): the opened page and its `web_fetch_tool_result` content, verbatim. */
-      fetch?: { url: string; result: unknown };
+      /** Anthropic's server-side call (adapters/anthropic.ts): its `server_tool_use` and result block, verbatim. */
+      anthropic?: AnthropicServerBlocks;
     }
   | {
       type: "done";
diff --git a/src/types/wire.ts b/src/types/wire.ts
index c00c010e854..6c43fb9b5cc 100644
--- a/src/types/wire.ts
+++ b/src/types/wire.ts
@@ -1,5 +1,5 @@
 import { isOpenCodeGoGeminiDestination, OPENCODE_GO_BASE_URL, OPENCODE_GO_MODEL_WIRES, OPENCODE_GO_LEGACY_NAME_PINS, type OpenCodeGoDestination } from "./opencode-go";
-import { openCodeZenBaseUrl, type OpenCodeZenDestination } from "./opencode-zen";
+import { openCodeZenBaseUrl, openCodeZenKeyBaseUrl, type OpenCodeZenDestination } from "./opencode-zen";
 
 /**
  * Accepted values for the per-provider upstream HTTP-version pin (#1668). Shared by the
@@ -106,7 +106,9 @@ const CREDENTIAL_PINNED_ADAPTERS: Readonly<Record<string, Readonly<Record<string
 
 function prefixPinsFor(providerName: string, provider: WirePinProvider | undefined): Readonly<Record<string, string>> | undefined {
   if (Object.hasOwn(CREDENTIAL_PINNED_ADAPTERS, providerName)) return CREDENTIAL_PINNED_ADAPTERS[providerName];
-  if (providerName === "opencode-zen" && openCodeZenBaseUrl(provider)) return { "gemini-": "google" };
+  if (providerName === "opencode-zen" && openCodeZenKeyBaseUrl(provider)) {
+    return openCodeZenBaseUrl(provider) ? { "gemini-": "google", "claude-": "anthropic" } : { "claude-": "anthropic" };
+  }
   if (!provider || !Object.hasOwn(WIRE_ADAPTER_PIN_PREFIXES, providerName)) return undefined;
   const rule = WIRE_ADAPTER_PIN_PREFIXES[providerName]!;
   return normalizedEndpoint(provider.baseUrl) === rule.endpoint ? rule.prefixes : undefined;
diff --git a/src/usage/summary.ts b/src/usage/summary.ts
index cc1406a7688..eefdf747bdf 100644
--- a/src/usage/summary.ts
+++ b/src/usage/summary.ts
@@ -665,8 +665,12 @@ function addEstimatedCost(
   entry: Pick<PersistedUsageEntry, "usageStatus" | "usage" | "attempts">,
   costInfo: EntryCostInfo,
 ): void {
-  if (entry.usageStatus === "unreported" || entry.usageStatus === "unsupported"
-    || (!entry.usage && !entry.attempts?.length)) {
+  // A row of attempts reads `unreported` when any leg lacks usage. Once one leg is measured the row
+  // is metered and the attempt-level pricing decides, matching the model and provider breakdowns.
+  const measuredAttempt = entry.attempts?.some(attempt => attempt.usage && isMeasuredStatus(attempt.usageStatus));
+  if (!measuredAttempt
+    && (entry.usageStatus === "unreported" || entry.usageStatus === "unsupported"
+      || (!entry.usage && !entry.attempts?.length))) {
     totals.unmeteredRequests += 1;
     return;
   }
@@ -822,7 +826,9 @@ function blankRequestCounts(): UsageRequestCounts {
 function spentNothing(attempt: NonNullable<PersistedUsageEntry["attempts"]>[number] | undefined): boolean {
   if (!attempt || attempt.usage) return false;
   if (attempt.sendCount === 0 || attempt.locallyAnswered === true) return true;
-  return attempt.status >= 400 && attempt.streamAborted !== true && attempt.firstOutputMs === undefined;
+  // A 499 is the client hanging up on a send upstream may already be generating for.
+  return attempt.status >= 400 && attempt.status !== 499
+    && attempt.streamAborted !== true && attempt.firstOutputMs === undefined;
 }
 
 function bumpRequestCounts(counts: UsageRequestCounts, facts: number, amount = 1): void {
diff --git a/src/usage/telemetry-contract.ts b/src/usage/telemetry-contract.ts
index 157d372f7c7..69247569cdf 100644
--- a/src/usage/telemetry-contract.ts
+++ b/src/usage/telemetry-contract.ts
@@ -32,6 +32,7 @@ export const ATTEMPT_RECOVERY_KIND_ROSTER = Object.freeze([
   "rate-limit-429",
   "anthropic-oauth-429",
   "oauth-account-429",
+  "oauth-account-402",
   "image-413",
   "console-go-upload-retry",
   "opaque-blob-rejection",
diff --git a/src/web-search/anthropic-history.ts b/src/web-search/anthropic-history.ts
new file mode 100644
index 00000000000..49abfd2f8bd
--- /dev/null
+++ b/src/web-search/anthropic-history.ts
@@ -0,0 +1,59 @@
+import type { AdapterEvent, OcxAssistantContentPart, OcxThinkingContent, OcxToolCall } from "../types";
+
+/** Rebuild one validated Anthropic model response without changing its search arguments or order. */
+export function anthropicSearchAssistantContent(events: readonly AdapterEvent[]): OcxAssistantContentPart[] {
+  const content: OcxAssistantContentPart[] = [];
+  let thinking: OcxThinkingContent | undefined;
+  let text: Extract<OcxAssistantContentPart, { type: "text" }> | undefined;
+  let call: OcxToolCall | undefined;
+  let argumentsText = "";
+  for (const event of events) {
+    if (event.type === "heartbeat") continue;
+    // A signature is a replacement snapshot until the next semantic block starts.
+    if (thinking?.signature !== undefined && event.type !== "thinking_signature") thinking = undefined;
+    if (event.type !== "text_delta") text = undefined;
+    switch (event.type) {
+      case "thinking_delta":
+        if (!thinking) { thinking = { type: "thinking", thinking: "" }; content.push(thinking); }
+        thinking.thinking += event.thinking;
+        break;
+      case "thinking_signature":
+        if (!thinking) { thinking = { type: "thinking", thinking: "" }; content.push(thinking); }
+        thinking.signature = event.signature;
+        break;
+      case "redacted_thinking":
+        thinking = undefined;
+        content.push({ type: "thinking", thinking: "", redacted: [event.data] });
+        break;
+      case "text_delta":
+        thinking = undefined;
+        if (event.anthropicThinkingSignature) {
+          text = undefined;
+          content.push({ type: "thinking", thinking: event.text, signature: event.anthropicThinkingSignature });
+          break;
+        }
+        if (!text) { text = { type: "text", text: "" }; content.push(text); }
+        text.text += event.text;
+        break;
+      case "tool_call_start":
+        thinking = undefined;
+        call = { type: "toolCall", id: event.id, name: event.name, arguments: {},
+          ...(event.providerMetadata ? { providerMetadata: event.providerMetadata } : {}) };
+        content.push(call);
+        argumentsText = "";
+        break;
+      case "tool_call_delta":
+        argumentsText += event.arguments;
+        break;
+      case "tool_call_end": {
+        if (!call) throw new Error("search history has an unpaired tool call");
+        const args: unknown = JSON.parse(argumentsText || "{}");
+        if (!args || typeof args !== "object" || Array.isArray(args)) throw new Error("search history tool input is not an object");
+        call.arguments = args as Record<string, unknown>;
+        call = undefined;
+        break;
+      }
+    }
+  }
+  return content;
+}
diff --git a/src/web-search/loop.ts b/src/web-search/loop.ts
index 034538a5986..82b486f06ce 100644
--- a/src/web-search/loop.ts
+++ b/src/web-search/loop.ts
@@ -1,3 +1,8 @@
+import { bindAnthropicRejectionResponse } from "../adapters/anthropic-rejection-memo";
+import { anthropicDeclaredTools } from "../adapters/anthropic-tool-catalog";
+import { enableAnthropicReplayCapture, takeAnthropicReplay, bindAnthropicReplay, type AnthropicReplaySnapshot } from "../adapters/anthropic-replay";
+import { anthropicSearchAssistantContent } from "./anthropic-history";
+import type { createAnthropicThinkingRecovery } from "../server/responses/anthropic-thinking-recovery";
 import type { AdapterRequest, IncomingMeta, ProviderAdapter } from "../adapters/base";
 import type { AdapterEvent, OcxConfig, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxProviderOpaqueToolCallMetadata, OcxThinkingContent, OcxUsage, RateLimitRetryPolicy } from "../types";
 import { namespacedToolName, toolChoiceToolPredicate } from "../types";
@@ -18,7 +23,7 @@ import type { WebSearchBackendId } from "./index";
 import { pacingHeaderDeadline } from "./header-deadline";
 import { redactSecretString } from "../lib/redact";
 import { readBoundedResponseBody } from "../lib/bounded-body";
-import { applyUpstreamRecoveryInit, fetchWithResetRetry, prepareSameTarget429Wait } from "../lib/upstream-retry";
+import { applyUpstreamRecoveryInit, fetchWithResetRetry, prepareSameTarget429Wait, isNonReplayableResponse, SendBudgetExhaustedError } from "../lib/upstream-retry";
 import { rateLimitRetryDelayMs } from "../providers/key-failover";
 import {
   isTranslatorBudgetExceededError,
@@ -26,7 +31,7 @@ import {
   TranslatorBudgetExceededError,
 } from "../lib/translator-budget";
 import { formatWebSearchResults } from "./format-result";
-import { parseStreamWithProgress, RoutedModelInactivityError, WebSearchStreamProtocolError } from "./progress-stream";
+import { parseStreamWithProgress, RoutedModelInactivityError, WebSearchStreamProtocolError, WebSearchAdapterEventError } from "./progress-stream";
 import { WEB_SEARCH_TOOL_NAME } from "./synthetic-tool";
 
 const SSE_HEADERS = {
@@ -204,6 +209,9 @@ function extractIterationThinking(events: AdapterEvent[]): OcxThinkingContent[]
   };
 
   for (const e of events) {
+    // Match the bridge: consecutive signature snapshots update one block. The next
+    // semantic event (including an empty thinking-block start) closes that block.
+    if (signature !== undefined && e.type !== "thinking_signature" && e.type !== "heartbeat") flushVisible();
     if (e.type === "text_delta" && e.anthropicThinkingSignature) {
       flushVisible();
       flushRaw();
@@ -216,7 +224,6 @@ function extractIterationThinking(events: AdapterEvent[]): OcxThinkingContent[]
       rawReasoning += e.text;
     } else if (e.type === "thinking_signature") {
       signature = e.signature;
-      flushVisible();
     } else if (e.type === "redacted_thinking") {
       flushVisible();
       flushRaw();
@@ -234,8 +241,8 @@ function normalizeQuery(q: string): string {
 }
 
 /**
- * Transient developer-role nudge appended ONLY to the forced-answer pass's request (never the
- * persisted `messages`). It tells the model to ground its final answer in the web results already
+ * Developer nudge for the forced-answer pass. Anthropic keeps its first sent position in the
+ * request-local history; other providers append it only for that iteration. It tells the model to ground its final answer in the web results already
  * gathered this turn. Citation wording is conditional — a failed/empty search still wants an answer,
  * just without fabricated sources.
  */
@@ -252,10 +259,8 @@ function forcedAnswerNudge(): OcxMessage {
 }
 
 /**
- * Transient developer-role nudge for the ONE recovery pass after a forced answer came back empty.
- * The recovery also removes every tool, so the model has nothing to call and can only return text;
- * this turn says so explicitly rather than relying on the removal alone. Like {@link forcedAnswerNudge}
- * it is iteration-local and never touches the persisted `messages`.
+ * Developer nudge for the ONE recovery pass after an empty forced answer. Tool calls are disabled;
+ * Anthropic retains its declared catalog and this nudge in request-local history for prefix fidelity.
  */
 function forcedAnswerRetryNudge(): OcxMessage {
   return {
@@ -269,17 +274,17 @@ function forcedAnswerRetryNudge(): OcxMessage {
   };
 }
 
-function jsonError(status: number, message: string): Response {
-  return new Response(JSON.stringify({ error: { message, type: "upstream_error", code: null } }), {
+function jsonError(status: number, message: string, event?: Extract<AdapterEvent, { type: "error" }>): Response {
+  return new Response(JSON.stringify({ error: { message, type: event?.errorType ?? "upstream_error", code: event?.code ?? null, ...(event?.retryable === false ? { retryable: false } : {}) } }), {
     status,
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", ...(event?.retryable === false ? { "x-should-retry": "false" } : {}) },
   });
 }
 
 /** Hard provider/parse failure inside an iteration. The eager first iteration converts it to a
  *  non-200 jsonError; later (already-streaming) iterations surface it as an in-stream error event. */
 class LoopError extends Error {
-  constructor(readonly status: number, message: string) {
+  constructor(readonly status: number, message: string, readonly event?: Extract<AdapterEvent, { type: "error" }>) {
     super(message);
     this.name = "LoopError";
   }
@@ -351,7 +356,8 @@ export interface WebSearchLoopDeps {
   /** Observe the exact adapter request selected for each routed-model iteration. */
   onRequestBuilt?: (request: AdapterRequest) => void;
   /** Request-scoped executor retains the core's selection binding across loop retries. */
-  fetchForRequest?: (request: AdapterRequest, parsed: OcxParsedRequest, adapter: ProviderAdapter) => typeof globalThis.fetch;
+  thinkingRecovery?: ReturnType<typeof createAnthropicThinkingRecovery>;
+  fetchForRequest?: (request: AdapterRequest, parsed: OcxParsedRequest, adapter: ProviderAdapter, recovery?: AttemptRecoveryKind) => typeof globalThis.fetch;
   /** Called before each routed-model dispatch in the loop, for attempt telemetry. Same-target 429 replays pass the `rate-limit-429` recovery kind. */
   onAttemptSend?: (recovery?: AttemptRecoveryKind) => void;
   /**
@@ -412,8 +418,11 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
     : 300_000;
 
   const messages: OcxMessage[] = [...parsed.context.messages];
+  const replaySnapshots = new Set<AnthropicReplaySnapshot>();
   const loopT0 = Date.now();
-  const allTools = parsed.context.tools ?? [];
+  const allTools = adapter.name === "anthropic" ? anthropicDeclaredTools(parsed) : parsed.context.tools ?? [];
+  let forcedNudgeAdded = false;
+  let emptyNudgeAdded = false;
   let searchesExecuted = 0;
   let executedSearchCount = 0;
   // Queries whose search already failed this turn — repeats are short-circuited so a model that keeps
@@ -448,8 +457,11 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
   interface IterationResponse {
     response: Response;
     responseAdapter: ProviderAdapter;
+    recover?: (error: WebSearchAdapterEventError) => Promise<IterationResponse | undefined>;
   }
   type IterationSplit = ReturnType<typeof scanEventsForWebSearch> & {
+    events: AdapterEvent[];
+    anthropicReplay?: AnthropicReplaySnapshot;
     /**
      * How many leading passthrough events were already delivered live this iteration. They are
      * exactly the first N passthrough entries (live delivery stops before the first event that
@@ -464,6 +476,38 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
   const rateLimitRetryPolicy = deps.retryOn429Policy ?? null;
   let rateLimitRetries = 0;
 
+  const requireSuccessfulHeaders = async (prepared: IterationResponse): Promise<void> => {
+    if (!prepared.response.ok) {
+      if (deps.thinkingRecovery && prepared.responseAdapter.name === "anthropic") {
+        const event = await deps.thinkingRecovery.projectHttpFailure(prepared.response, signal);
+        throw new LoopError(event.status ?? prepared.response.status, event.message, event);
+      }
+      let body: Awaited<ReturnType<typeof readBoundedResponseBody>>;
+      try {
+        body = await readBoundedResponseBody(prepared.response, { signal });
+      } catch {
+        // The response status is authoritative even when its untrusted error body fails while
+        // being read (including a synchronous getReader() failure). Never route that failure
+        // through the adapter formatter or the generic transport error, which could expose its
+        // raw message. A parent/client cancellation still owns the request lifecycle as 499.
+        if (signal.aborted) throw new LoopError(499, "client closed request during web-search");
+        throw new LoopError(prepared.response.status, `Provider error ${prepared.response.status}`);
+      }
+      let formatted = "";
+      if (body.displaySafe && !body.truncated && body.text.trim() && prepared.responseAdapter.formatErrorBody) {
+        try {
+          formatted = prepared.responseAdapter.formatErrorBody(
+            prepared.response.status,
+            prepared.response.headers,
+            body.text,
+          ).trim();
+        } catch { /* formatter hooks are best-effort; unsafe raw text is never the fallback */ }
+      }
+      const suffix = formatted ? `: ${formatted.slice(0, 400)}` : "";
+      throw new LoopError(prepared.response.status, `Provider error ${prepared.response.status}${suffix}`);
+    }
+  };
+
   // Acquire one iteration's final response headers. The first call is drained eagerly so an initial
   // connect/header/HTTP failure stays a non-2xx JSON response. Its successful BODY is deliberately
   // left unread until the downstream Responses SSE bridge exists.
@@ -473,24 +517,30 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
    * restart) before the `on429` key rotation.
    */
   const prepareIterationEvents = async function* (forceAnswer: boolean): AsyncGenerator<AdapterEvent, IterationResponse> {
-    // On the forced-answer pass the model is asked to answer from the results already in
-    // `messages`. A weak model can still produce a thin answer that
-    // ignores what the search found, which reads to the user as "the search did nothing". Nudge it
-    // (iteration-locally — never mutate the shared `messages`) to actually use the gathered results.
-    // Only when a REAL search ran (executedSearchCount, not empty-query/limit/repeat placeholders).
-    let iterMessages: OcxMessage[] = forceAnswer && executedSearchCount > 0
-      ? [...messages, forcedAnswerNudge()]
-      : messages;
-    // #1001 follow-up: the recovery pass for an empty forced answer. Removing every tool leaves the
-    // model nothing to call, and the extra developer turn asks it for the text it just failed to
-    // produce. `toolChoice: "none"` is what drops those definitions in the adapter, so the retry
-    // cannot repeat the same empty or tool-shaped response.
     const recoveringEmptyAnswer = forceAnswer && emptyAnswerRetries > 0;
-    if (recoveringEmptyAnswer) iterMessages = [...iterMessages, forcedAnswerRetryNudge()];
+    const preserveAnthropicPrefix = adapter.name === "anthropic";
+    let iterMessages = messages;
+    if (preserveAnthropicPrefix) {
+      // Once sent, each nudge is part of subsequent signatures' bound prefix. Keep its
+      // original position even when a forced-answer response makes another tool call.
+      if (forceAnswer && executedSearchCount > 0 && !forcedNudgeAdded) {
+        const nudge = forcedAnswerNudge();
+        if (nudge.role === "developer" && typeof nudge.content === "string") nudge.content = [{ type: "text", text: nudge.content }];
+        messages.push(nudge); forcedNudgeAdded = true;
+      }
+      if (recoveringEmptyAnswer && !emptyNudgeAdded) {
+        const nudge = forcedAnswerRetryNudge();
+        if (nudge.role === "developer" && typeof nudge.content === "string") nudge.content = [{ type: "text", text: nudge.content }];
+        messages.push(nudge); emptyNudgeAdded = true;
+      }
+    } else {
+      if (forceAnswer && executedSearchCount > 0) iterMessages = [...messages, forcedAnswerNudge()];
+      if (recoveringEmptyAnswer) iterMessages = [...iterMessages, forcedAnswerRetryNudge()];
+    }
     const iterParsed: OcxParsedRequest = {
       ...parsed, stream: true,
       ...(recoveringEmptyAnswer ? { options: { ...parsed.options, toolChoice: "none" as const } } : {}),
-      context: { ...parsed.context, messages: iterMessages, tools: recoveringEmptyAnswer ? [] : allTools },
+      context: { ...parsed.context, messages: iterMessages, tools: recoveringEmptyAnswer && !preserveAnthropicPrefix ? [] : allTools },
     };
     // One cumulative header deadline spans key rotations and reset sends, excluding local pacing.
     // clear() stops only its timer after final headers; the direct turn signal remains attached to
@@ -528,7 +578,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
           cachedRequest = request;
           cachedAdapter = requestAdapter;
         }
-        const requestFetch = headerDeadline.pacedFetch(deps.fetchForRequest?.(request, iterParsed, requestAdapter) ?? routedProviderFetch);
+        const requestFetch = headerDeadline.pacedFetch(deps.fetchForRequest?.(request, iterParsed, requestAdapter, recovery) ?? routedProviderFetch);
         let response: Response;
         try {
           if (requestAdapter.fetchResponse) {
@@ -571,9 +621,33 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
         } finally {
           request.releaseBodyObservation?.();
         }
+        bindAnthropicRejectionResponse(request, response);
         return { response, responseAdapter: requestAdapter };
       };
 
+      const recover = async (error: WebSearchAdapterEventError): Promise<IterationResponse | undefined> => {
+        if (signal.aborted || !error.replaySafe || isNonReplayableResponse(prepared.response)
+          || !deps.thinkingRecovery?.prepareEvent(error.event.message, prepared.responseAdapter.name, iterParsed, prepared.response)) return;
+        cachedRequest = undefined;
+        cachedAdapter = undefined;
+        // The successful headers ended the previous timer; the replacement owns a fresh deadline.
+        headerDeadline = pacingHeaderDeadline(connectTimeoutMs, signal);
+        try {
+          const replacement = await fetchOnce(prepared.responseAdapter, "opaque-blob-rejection");
+          headerDeadline.clear();
+          await requireSuccessfulHeaders(replacement);
+          return replacement;
+        } catch (error) {
+          if (signal.aborted) throw new LoopError(499, "client closed request during web-search");
+          if (headerDeadline.didExpire()) throw new LoopError(504,
+            `Provider response-header timeout after ${connectTimeoutMs}ms during web-search`);
+          if (error instanceof LoopError || error instanceof SendBudgetExhaustedError || isTranslatorBudgetExceededError(error)) throw error;
+          throw new LoopError(502, `Provider unreachable: ${error instanceof Error ? error.message : String(error)}`);
+        } finally {
+          headerDeadline.clear();
+          deps.onIterationEnd?.();
+        }
+      };
       let prepared = await fetchOnce(adapter);
       // Same-target 429 wait-and-retry (opt-in `retryOn429`) BEFORE key rotation: a primary-key
       // rate-limit blip replays on the SAME key; rotation only runs after attempts exhaust.
@@ -644,36 +718,20 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
         prepared = replacement;
       }
 
+      if (await deps.thinkingRecovery?.prepareHttp(prepared.response, prepared.responseAdapter.name, iterParsed)) {
+        try { void prepared.response.body?.cancel().catch(() => {}); } catch { /* closed */ }
+        cachedRequest = undefined;
+        cachedAdapter = undefined;
+        prepared = await fetchOnce(adapter, "opaque-blob-rejection");
+      }
+
+
       // Final headers have arrived. Clear only the deadline timer before ANY body read.
       headerDeadline.clear();
-      if (!prepared.response.ok) {
-        let body: Awaited<ReturnType<typeof readBoundedResponseBody>>;
-        try {
-          body = await readBoundedResponseBody(prepared.response, { signal });
-        } catch {
-          // The response status is authoritative even when its untrusted error body fails while
-          // being read (including a synchronous getReader() failure). Never route that failure
-          // through the adapter formatter or the generic transport error, which could expose its
-          // raw message. A parent/client cancellation still owns the request lifecycle as 499.
-          if (signal.aborted) throw new LoopError(499, "client closed request during web-search");
-          throw new LoopError(prepared.response.status, `Provider error ${prepared.response.status}`);
-        }
-        let formatted = "";
-        if (body.displaySafe && !body.truncated && body.text.trim() && prepared.responseAdapter.formatErrorBody) {
-          try {
-            formatted = prepared.responseAdapter.formatErrorBody(
-              prepared.response.status,
-              prepared.response.headers,
-              body.text,
-            ).trim();
-          } catch { /* formatter hooks are best-effort; unsafe raw text is never the fallback */ }
-        }
-        const suffix = formatted ? `: ${formatted.slice(0, 400)}` : "";
-        throw new LoopError(prepared.response.status, `Provider error ${prepared.response.status}${suffix}`);
-      }
-      return prepared;
+      await requireSuccessfulHeaders(prepared);
+      return { ...prepared, recover };
     } catch (error) {
-      if (isTranslatorBudgetExceededError(error)) throw error;
+      if (isTranslatorBudgetExceededError(error) || error instanceof SendBudgetExhaustedError) throw error;
       if (headerDeadline.didExpire()) {
         throw new LoopError(504, `Provider response-header timeout after ${connectTimeoutMs}ms during web-search`);
       }
@@ -710,15 +768,25 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
     const events: AdapterEvent[] = [];
     let liveWindowOpen = deps.streamRoutedModelOutput === true;
     let streamedPassthroughCount = 0;
+    let anthropicReplay: AnthropicReplaySnapshot | undefined;
+    let releaseCapture = () => {};
     try {
-      const parse = prepared.responseAdapter.parseStream.bind(prepared.responseAdapter);
+      const parse: ProviderAdapter["parseStream"] = (response, budget) => {
+        if (prepared.responseAdapter.name === "anthropic") releaseCapture = enableAnthropicReplayCapture(response);
+        return prepared.responseAdapter.parseStream(response, budget);
+      };
       for await (const event of parseStreamWithProgress(prepared.response, parse, {
         signal,
         inactivityTimeoutMs: routedModelStallTimeoutMs,
         translatorBudget,
+        preserveAdapterError: deps.thinkingRecovery !== undefined,
         // A pass that fails was still billed; the error path reports it with the hidden passes.
         onErrorUsage: usage => { hiddenUsage = mergeUsage(hiddenUsage, usage); },
       })) {
+        if (event.type === "done") {
+          anthropicReplay = takeAnthropicReplay(event);
+          if (anthropicReplay) replaySnapshots.add(anthropicReplay);
+        }
         if (event.type === "heartbeat") yield event;
         // Kiro's explicit-completion protocol marks ordinary assistant text as commentary while
         // it performs a bounded final-answer retry. That text is safe to surface immediately and
@@ -740,12 +808,21 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
         }
       }
     } catch (error) {
-      if (isTranslatorBudgetExceededError(error)) throw error;
+      if (isTranslatorBudgetExceededError(error) || error instanceof SendBudgetExhaustedError) throw error;
       if (signal.aborted) throw new LoopError(499, "client closed request during web-search");
+      if (error instanceof WebSearchAdapterEventError) {
+        const replacement = await prepared.recover?.(error);
+        if (replacement) return yield* consumeIterationEvents(replacement);
+        const event = isNonReplayableResponse(prepared.response)
+          ? { ...error.event, message: "Provider stream error: upstream diagnostic withheld for a non-replayable failure", retryable: false as const }
+          : error.event;
+        throw new LoopError(event.status ?? 502, event.message, event);
+      }
+      if (error instanceof LoopError) throw error;
       if (error instanceof RoutedModelInactivityError) throw new LoopError(504, error.message);
       if (error instanceof WebSearchStreamProtocolError) throw new LoopError(502, error.message);
       throw new LoopError(502, `Provider stream error: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    } finally { releaseCapture(); }
 
     const terminalIndexes = events.flatMap((event, index) =>
       event.type === "done" || event.type === "incomplete" || event.type === "error" ? [index] : []);
@@ -759,7 +836,8 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       }
       throw new LoopError(502, terminal.message);
     }
-    return { ...scanEventsForWebSearch(events), streamedPassthroughCount };
+    deps.thinkingRecovery?.observeIteration(events);
+    return { ...scanEventsForWebSearch(events), streamedPassthroughCount, events, anthropicReplay };
   };
 
   // Execute one model-requested web_search call. The call may batch several queries (native
@@ -768,7 +846,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
   // valid, and surface as ONE search cell carrying every attempted query. A real search (one that
   // hits the sidecar) shows the spinner WHILE the batch runs. Empty/limit/repeat placeholders never
   // emit a cell (matching the prior single-query behavior).
-  async function* runSearchCall(call: WebSearchCall, precedingThinking: OcxThinkingContent[] = []): AsyncGenerator<AdapterEvent> {
+  async function* runSearchCall(call: WebSearchCall, precedingThinking: OcxThinkingContent[] = [], appendAssistant = true): AsyncGenerator<AdapterEvent> {
     const results: { query: string; outcome: SidecarOutcome }[] = [];
     let beganCell = false;
     if (call.queries.length === 0) {
@@ -845,7 +923,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
     const callArgs: Record<string, unknown> = call.queries.length > 1
       ? { queries: call.queries }
       : { query: call.queries[0] ?? "" };
-    messages.push({
+    if (appendAssistant) messages.push({
       role: "assistant",
       content: [
         // Signed thinking must precede tool_use on replay (Anthropic extended thinking), and
@@ -904,7 +982,9 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
     firstPrepared = await prepareIterationDrained(false);
   } catch (e) {
     if (abortSignal) abortSignal.removeEventListener("abort", linkAbort);
-    if (e instanceof LoopError) return jsonError(e.status, e.message);
+    if (e instanceof LoopError) return jsonError(e.status, e.message, e.event);
+    if (e instanceof SendBudgetExhaustedError) return jsonError(429, e.message,
+      { type: "error", message: e.message, errorType: "rate_limit_error", code: e.code, retryable: false });
     throw e;
   }
 
@@ -987,7 +1067,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
                 hiddenUsage = mergeUsage(hiddenUsage, terminalEvent.usage);
                 if (!split.hasMalformedToolCall && !split.hasRealToolCall && emptyAnswerRetries === 0) {
                   emptyAnswerRetries++;
-                  console.warn("[web-search-loop] empty forced answer — retrying once without tools");
+                  console.warn("[web-search-loop] empty forced answer — retrying once with tool calls disabled");
                   yield { type: "heartbeat" };
                   continue;
                 }
@@ -1012,10 +1092,36 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
           for (const event of split.passthrough.slice(split.streamedPassthroughCount)) {
             if (event.type === "text_delta" && event.anthropicThinkingSignature) yield event;
           }
-          const iterationThinking = extractIterationThinking(split.passthrough);
+          const preserveAnthropicHistory = prepared.responseAdapter.name === "anthropic";
+          if (preserveAnthropicHistory) {
+            if (!split.anthropicReplay) throw new LoopError(502, "Anthropic search history cannot be replayed losslessly");
+            const message = { role: "assistant" as const,
+              content: anthropicSearchAssistantContent(split.events), timestamp: Date.now() };
+            const originalCalls = split.anthropicReplay.content.filter(block => block.type === "tool_use");
+            const priorIds = new Set(messages.flatMap(message => message.role === "assistant"
+              ? message.content.filter(part => part.type === "toolCall").map(part => part.id)
+              : message.role === "toolResult" ? [message.toolCallId] : []));
+            if (originalCalls.some(block => priorIds.has(block.id as string))) {
+              throw new LoopError(502, "Anthropic search replay tool identity changed");
+            }
+            const calls = message.content.filter(part => part.type === "toolCall");
+            if (originalCalls.length !== calls.length || originalCalls.some((block, index) => block.id !== calls[index]?.id)) {
+              throw new LoopError(502, "Anthropic search replay tool identity changed");
+            }
+            // The raw input is authoritative, including non-empty content_block_start input.
+            for (const [index, call] of calls.entries()) call.arguments = originalCalls[index]!.input as Record<string, unknown>;
+            for (const call of split.calls) {
+              const original = originalCalls.find(block => block.id === call.id);
+              if (!original) throw new LoopError(502, "Anthropic search replay tool identity changed");
+              call.queries = parseQueries(JSON.stringify(original.input));
+            }
+            bindAnthropicReplay(message, split.anthropicReplay);
+            messages.push(message);
+          }
+          const iterationThinking = preserveAnthropicHistory ? [] : extractIterationThinking(split.passthrough);
           for (const [callIndex, call] of split.calls.entries()) {
             accountRefusalOutputStarted = true;
-            yield* runSearchCall(call, callIndex === 0 ? iterationThinking : []);
+            yield* runSearchCall(call, callIndex === 0 ? iterationThinking : [], !preserveAnthropicHistory);
           }
         } catch (e) {
           // The bridge reports no usage for either error; the iterations already sent still count.
@@ -1029,7 +1135,12 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
               message: "upstream translation buffer exceeded the safe limit",
             };
           } else {
-            yield { type: "error", message: e instanceof LoopError ? e.message : (e instanceof Error ? e.message : String(e)) };
+            if (e instanceof SendBudgetExhaustedError) yield { type: "error", status: 429,
+              errorType: "rate_limit_error", code: e.code, message: e.message, retryable: false };
+            else yield e instanceof LoopError && e.event ? e.event
+              : e instanceof LoopError && deps.thinkingRecovery
+                ? { type: "error", status: e.status, errorType: "upstream_error", message: e.message }
+                : { type: "error", message: e instanceof Error ? e.message : String(e) };
           }
           return;
         }
@@ -1037,6 +1148,8 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       if (hiddenUsage) deps.onUsage?.(hiddenUsage);
       yield { type: "error", message: "web-search loop exceeded its iteration cap" };
     } finally {
+      for (const snapshot of replaySnapshots) snapshot.release();
+      replaySnapshots.clear();
       if (abortSignal) abortSignal.removeEventListener("abort", linkAbort);
     }
   }
diff --git a/src/web-search/progress-stream.ts b/src/web-search/progress-stream.ts
index 521b17d86be..e83de5e1708 100644
--- a/src/web-search/progress-stream.ts
+++ b/src/web-search/progress-stream.ts
@@ -26,7 +26,15 @@ export class WebSearchStreamProtocolError extends Error {
   }
 }
 
+/** Opt-in preserves an adapter refusal before it becomes an untyped parser exception. */
+export class WebSearchAdapterEventError extends Error {
+  constructor(readonly event: Extract<AdapterEvent, { type: "error" }>, readonly replaySafe: boolean) {
+    super(event.message);
+  }
+}
+
 export interface ParseStreamWithProgressOptions {
+  preserveAdapterError?: boolean;
   inactivityTimeoutMs: number;
   translatorBudget: TranslatorBudget;
   signal?: AbortSignal;
@@ -249,6 +257,7 @@ export async function* parseStreamWithProgress(
 
   resetInactivity();
 
+  let replaySafe = true;
   const parserPump = (async (): Promise<void> => {
     let heldTerminal: Extract<AdapterEvent, { type: "done" | "incomplete" }> | undefined;
     try {
@@ -301,9 +310,10 @@ export async function* parseStreamWithProgress(
           if (event.usage) options.onErrorUsage?.(event.usage);
           fail(event.code === "translation_buffer_limit"
             ? new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_TURN_BYTES)
-            : new Error(event.message));
+            : options.preserveAdapterError ? new WebSearchAdapterEventError(event, replaySafe) : new Error(event.message));
           return;
         }
+        replaySafe &&= event.type === "heartbeat" && event.replayUnsafe !== true;
         if (event.type === "done" || event.type === "incomplete") {
           heldTerminal = event;
           // Response-byte inactivity ends once the adapter has produced a terminal event.
diff --git a/structure/INDEX.md b/structure/INDEX.md
index 96f8d2347df..096a550041a 100644
--- a/structure/INDEX.md
+++ b/structure/INDEX.md
@@ -45,6 +45,7 @@ The wire surfaces a client actually talks to.
 | --- | --- |
 | [`local-messaging.md`](local-messaging.md) | Command-local metadata discovery, Unix RPC queued submission, peer envelopes, receipts and owned lifecycle bounds. |
 | [`transports/byte-accounting.md`](transports/byte-accounting.md) | Request-copy and stream-buffer byte accounting shared by parsing, SSE rewriting, the adapters, and the translator budget, plus durable spill admission. |
+| [`transports/anthropic-thinking-recovery.md`](transports/anthropic-thinking-recovery.md) | One-shot exact signature-binding recovery before output, and successful-retry memo boundaries. |
 | [`transports/responses.md`](transports/responses.md) | The Responses HTTP/SSE endpoint, dispatch, credential and upload boundaries, and core module ownership. |
 | [`transports/native-reasoning-retention.md`](transports/native-reasoning-retention.md) | Optional native reasoning ciphertext forwarding on model/account switches, configuration and management controls. |
 | [`transports/responses-wire-shapes.md`](transports/responses-wire-shapes.md) | Mixed-wire model defaults, xAI agent-message continuation, declared-tool membership, and passthrough SSE stream shapes. |
@@ -155,6 +156,9 @@ A source area can be described by more than one doc, because these docs are orga
 | `scripts/generate-ocx-skill-surface.ts` | [`cli-management.md`](cli-management.md) |
 | `skills/ocx/` | [`cli-management.md`](cli-management.md) |
 | `src/adapters/` | [`runtime.md`](runtime.md)<br>[`transports/byte-accounting.md`](transports/byte-accounting.md)<br>[`transports/native-reasoning-retention.md`](transports/native-reasoning-retention.md)<br>[`transports/responses-wire-shapes.md`](transports/responses-wire-shapes.md)<br>[`transports/inventory.md`](transports/inventory.md)<br>[`data-planes/inbound-compat.md`](data-planes/inbound-compat.md)<br>[`providers/anthropic-progress.md`](providers/anthropic-progress.md)<br>[`providers/claude-cli-replay.md`](providers/claude-cli-replay.md)<br>[`providers-and-adapters.md`](providers-and-adapters.md)<br>[`providers/cursor.md`](providers/cursor.md)<br>[`providers/chat-compat.md`](providers/chat-compat.md)<br>[`adapters/registry.md`](adapters/registry.md) |
+| `src/adapters/anthropic-rejection-memo.ts` | [`transports/anthropic-thinking-recovery.md`](transports/anthropic-thinking-recovery.md) |
+| `src/adapters/anthropic-replay.ts` | [`transports/anthropic-thinking-recovery.md`](transports/anthropic-thinking-recovery.md) |
+| `src/adapters/anthropic-tool-catalog.ts` | [`transports/anthropic-thinking-recovery.md`](transports/anthropic-thinking-recovery.md) |
 | `src/adapters/dsh-account.ts` | [`providers/dsh-account.md`](providers/dsh-account.md) |
 | `src/advisor/` | [`advisor.md`](advisor.md) |
 | `src/bridge.ts` | [`transports/responses.md`](transports/responses.md) |
@@ -224,6 +228,7 @@ A source area can be described by more than one doc, because these docs are orga
 | `src/remote-control/` | [`remote-workspace.md`](remote-workspace.md) |
 | `src/remote/` | [`runtime.md`](runtime.md) |
 | `src/responses/` | [`runtime.md`](runtime.md)<br>[`transports/byte-accounting.md`](transports/byte-accounting.md)<br>[`transports/responses.md`](transports/responses.md)<br>[`transports/native-reasoning-retention.md`](transports/native-reasoning-retention.md)<br>[`transports/responses-wire-shapes.md`](transports/responses-wire-shapes.md)<br>[`providers/anthropic-progress.md`](providers/anthropic-progress.md)<br>[`providers-and-adapters.md`](providers-and-adapters.md)<br>[`providers/kiro.md`](providers/kiro.md)<br>[`providers/xai-grok.md`](providers/xai-grok.md)<br>[`providers/chat-compat.md`](providers/chat-compat.md) |
+| `src/responses/reasoning-replay-cache.ts` | [`transports/anthropic-thinking-recovery.md`](transports/anthropic-thinking-recovery.md) |
 | `src/router.ts` | [`runtime.md`](runtime.md) |
 | `src/routing/` | [`catalog.md`](catalog.md) |
 | `src/routing/history/` | [`dashboard-and-usage.md`](dashboard-and-usage.md) |
@@ -237,6 +242,7 @@ A source area can be described by more than one doc, because these docs are orga
 | `src/server/management/model-routes.ts` | [`pricing.md`](pricing.md) |
 | `src/server/responses/advisor-plan-slot.ts` | [`advisor.md`](advisor.md) |
 | `src/server/responses/advisor-slot.ts` | [`advisor.md`](advisor.md) |
+| `src/server/responses/anthropic-thinking-recovery.ts` | [`transports/anthropic-thinking-recovery.md`](transports/anthropic-thinking-recovery.md) |
 | `src/service-manager-probe.ts` | [`ops/service-and-sidecars.md`](ops/service-and-sidecars.md) |
 | `src/service.ts` | [`runtime.md`](runtime.md)<br>[`ops/docs-and-release.md`](ops/docs-and-release.md) |
 | `src/service/` | [`runtime.md`](runtime.md) |
diff --git a/structure/clients/chatgpt-desktop.md b/structure/clients/chatgpt-desktop.md
index dca30b1d079..3cfec90def8 100644
--- a/structure/clients/chatgpt-desktop.md
+++ b/structure/clients/chatgpt-desktop.md
@@ -31,6 +31,14 @@ plain-quota evidence: a cleared plain reached type or a usage window at 100% (`u
 RPC, `used_percent` in the web usage snapshot; every gate field is read in both spellings).
 Usage percentages, resets and window durations remain accurate. Unrelated messages
 and malformed lines remain byte-identical; changed lines are reserialized.
+This is a stdout-projection boundary, not a guarantee that every Desktop composer
+uses that transport. The post-closure reports in
+[#6196](https://github.com/lidge-jun/opencodex/issues/6196) describe an attached shim
+with no eligible rate-limit RPC messages and a still-locked composer on specific
+macOS builds. A launcher override or synthetic rewrite test does not establish
+original-app acceptance. The separate renderer usage transport is outside this
+module's scope; the reported remaining lock stays open without reviving the
+closed local-CA intercept design.
 A per-line rewrite exception preserves that line. A failure in the framing/rewrite
 machinery preserves buffered bytes and switches the rest of the stream to raw
 passthrough. Output-write failures propagate; they are not rewrite failures.
diff --git a/structure/clients/claude-desktop.md b/structure/clients/claude-desktop.md
index 32f81b346b2..ad90f16699d 100644
--- a/structure/clients/claude-desktop.md
+++ b/structure/clients/claude-desktop.md
@@ -569,7 +569,7 @@ Translated tool results in `src/claude/inbound.ts` retain nonempty string `tool_
 
 `src/claude/inbound.ts` bounds the text-carrier skill-directory probe to 4,096 UTF-16 code units, plus one character to recognize the terminating newline. A longer first line is preserved intact instead of being scanned or stubbed; normal POSIX, Windows, mixed and UNC separators retain their basename matching. The existing 10,000-character payload threshold and `claudeCode.blockedSkills` policy remain: `claude-api` is blocked by default, and an explicit empty list disables elision. Native Anthropic passthrough and tool-call/result pairing are unchanged. `tests/claude-integration/claude-inbound.test.ts` covers the exact 4,096/4,097 boundary and a long newline-free carrier.
 
-`src/claude/inbound-content-options.ts` strips Claude Code's leading `x-anthropic-billing-header:` line from a string system prompt or from the first text block of a system array before it becomes Responses `instructions`, dropping a block left empty. The line's `cch` value rotates per request, so keeping it made the translated prefix and the system-derived fallback `prompt_cache_key` change every turn (#6627). The match is anchored at the prompt start, like the Antigravity strip in `src/adapters/google.ts`; native Anthropic passthrough does not use this translation and keeps the client preamble. `tests/claude-integration/claude-inbound.test.ts` covers string and array systems, header-only blocks, later mentions and key stability. The same module's `declaredAnthropicServerTools` reads the caller's typed `web_search_*` / `web_fetch_*` declarations unchanged; `src/server/claude-messages.ts` hands them to the Responses core out of body, like the native reasoning replay, and the core keeps them on `parsed._anthropicServerTools` only for `inboundWire: "anthropic"`, so the translated body and every non-Anthropic leg stay as before. `tests/claude-integration/claude-translated-server-tools.test.ts` covers the Anthropic wire, a third-party Anthropic-compatible endpoint and a GPT leg. The translated Messages lane preserves the caller's output cap for non-canonical Responses gateways; canonical ChatGPT parameter stripping remains in its adapter. An explicit operator `cacheRetention` wins; otherwise `src/claude/inbound.ts` selects long retention only when every declared caller breakpoint requests one hour, including nested content and top-level automatic caching. Mixed TTLs retain the default.
+`src/claude/inbound-content-options.ts` strips Claude Code's leading `x-anthropic-billing-header:` line from a string system prompt or from the first text block of a system array before it becomes Responses `instructions`, dropping a block left empty. The line's `cch` value rotates per request, so keeping it made the translated prefix and the system-derived fallback `prompt_cache_key` change every turn (#6627). The match is anchored at the prompt start, like the Antigravity strip in `src/adapters/google.ts`; native Anthropic passthrough does not use this translation and keeps the client preamble. `tests/claude-integration/claude-inbound.test.ts` covers string and array systems, header-only blocks, later mentions and key stability. The same module's `declaredAnthropicServerTools` reads the caller's typed `web_search_*` / `web_fetch_*` declarations unchanged; `src/server/claude-messages.ts` hands them to the Responses core out of body, like the native reasoning replay, and the core keeps them on `parsed._anthropicServerTools` only for `inboundWire: "anthropic"`, so the translated body and every non-Anthropic leg stay as before. `replayedAnthropicServerBlocks` does the same for the completed `server_tool_use` + `web_search_tool_result` / `web_fetch_tool_result` runs in the caller's assistant history, which the translated body drops: each run is keyed by the block that follows it (a `tool_use` id, text, a thinking signature or redacted thinking data); an anchor that repeats anywhere in the assistant history, string content included, names no single owner, so its run stays dropped. Each result must follow exactly one matching server call in the same assistant turn, with the same id and tool type; duplicate ids, orphan results and reversed pairs stay dropped. Calls require a plain input object with a nonempty `web_search.query` or `web_fetch.url` string. Validation walks the original block sequence once and never pairs a result with a later call. The adapter also drops a streamed result whose matching call or complete input is unavailable, preserving the text without synthesizing an empty-input call. The map travels as `parsed._anthropicServerReplay`. `tests/claude-integration/claude-translated-server-tools.test.ts` covers the Anthropic wire, a third-party Anthropic-compatible endpoint and a GPT leg. The translated Messages lane preserves the caller's output cap for non-canonical Responses gateways; canonical ChatGPT parameter stripping remains in its adapter. An explicit operator `cacheRetention` wins; otherwise `src/claude/inbound.ts` selects long retention only when every declared caller breakpoint requests one hour, including nested content and top-level automatic caching. Mixed TTLs retain the default.
 
 `src/claude/outbound.ts` carries a Responses provider's own `encrypted_content` in an `ocxr1:` `nat` envelope (`src/responses/reasoning-envelope.ts`) only when the serving attempt has committed and `src/server/responses/core-replay.ts` supplied a durable destination and credential owner. The `nat.tag` HMAC binds the exact blob to that owner and the installation's persisted salt. `src/claude/inbound.ts` restores the blob and item id only for the same client-facing model; each route binding verifies the tag against its effective endpoint, including `responsesPath`, and generation-bearing credential, then removes a mismatch from both the raw reasoning item and the parser's thinking-signature carrier before send. Missing owner or tag fails closed, including direct-forward credentials and OAuth generation changes. Native Anthropic ingress projects away every `nat` on both native branches, dropping blob-only blocks and leaving signed or visible-text fields intact. A thinking block that closes before serving commit has no `nat`. Translated bodies that reason request `include: ["reasoning.encrypted_content"]`; a body without reasoning does not. Anthropic `sig` and `red` envelopes keep their existing behavior. `tests/claude-integration/claude-native-reasoning-provenance.test.ts` covers route ownership and native projection.
 
diff --git a/structure/config.md b/structure/config.md
index 34dbbefb924..e00cfec7524 100644
--- a/structure/config.md
+++ b/structure/config.md
@@ -434,7 +434,7 @@ capture/route time and explicit false or empty declarations retain their field-s
 `src/config/provider-validation.ts` owns the pure provider payload checks shared by persisted config,
 CLI writes, and management DTO validation. `src/config.ts` imports those checks for Zod refinement
 and re-exports them as a compatibility facade; it must not grow a second copy. Validation error text,
-ordering, and cross-field rules are part of the write/load contract: management requests and hand-edited `config.json` accept and reject the same provider shapes. Before validation, `src/config/opencode-wire-upgrade.ts` shares the Zen upgrade in `src/config/opencode-zen-upgrade.ts` and normalizes saved Chat/Responses overrides for newly pinned Go Gemini and Qwen models, including previously valid Responses-only hosted-tool preferences. Go uses validation's historical fixed-destination and key-auth rules; its older Anthropic pins and overridable Responses defaults retain normal validation. Runtime and diagnostics-backed reads share this upgrade, preserving unrelated providers, accounts and routing. Reads warn without rewriting the file; explicit edits persist the normalized configuration, and new writes still reject incompatible overrides and preferences. Unsupported authentication modes and invalid override values retain normal validation.
+ordering, and cross-field rules are part of the write/load contract: management requests and hand-edited `config.json` accept and reject the same provider shapes. Before validation, `src/config/opencode-wire-upgrade.ts` shares the Zen Gemini and Claude upgrade in `src/config/opencode-zen-upgrade.ts` and normalizes saved Chat/Responses overrides for newly pinned Go Gemini and Qwen models, including previously valid Responses-only hosted-tool preferences. Go uses validation's historical fixed-destination and key-auth rules; its older Anthropic pins and overridable Responses defaults retain normal validation. Runtime and diagnostics-backed reads share this upgrade, preserving unrelated providers, accounts and routing. Reads warn without rewriting the file; explicit edits persist the normalized configuration, and new writes still reject incompatible overrides and preferences. Unsupported authentication modes and invalid override values retain normal validation.
 
 Provider `projectContext` accepts `"off"` or `"on"` only for native `command-code`; `src/config/schema/leaf-validators.ts` rejects other adapters on load, while `src/config/provider-validation.ts` and `src/server/auth-cors.ts` reject them on management writes. This editor-owned outbound-file field follows [provider and adapter selection](providers-and-adapters.md).
 The Google tool-schema policy uses a closed enum at this boundary. Unknown values fail config load,
diff --git a/structure/dashboard-and-usage.md b/structure/dashboard-and-usage.md
index 2752f7534c8..e4023469732 100644
--- a/structure/dashboard-and-usage.md
+++ b/structure/dashboard-and-usage.md
@@ -290,7 +290,7 @@ neither the old byte window nor the parsed-entry cap can discard an earlier pref
 surface filtering. `managementUsageMaxReadBytes` remains a recognized compatibility setting for
 bounded legacy readers, but it is not an accuracy limit or tuning knob for `GET /api/usage`.
 A Codex-surface response includes an `accounts` breakdown keyed by stable non-PII `accountLogLabel`; cards join it to the management account DTO for 30-day tokens, API-equivalent cost and coverage. New main-pool rows use `main`; legacy bare `openai` rows remain ambiguous.
-A missing `usage.jsonl` returns a zeroed summary with 200 because a fresh install has no usage. Unmeasured requests remain distinct from measured zero through `measured / reported / unreported / unsupported / estimated` counts and their coverage totals. Cost estimates in `src/usage/cost.ts` price only `reported` or `estimated` usage, so a partly measured row is never given a confident, understated cost; per-row `pricedRequests` / `unpricedRequests` count a request once, unpriced when any attempt is unpriceable, while a usage-less attempt that made no physical send (`sendCount === 0` or `locallyAnswered`) or was refused with an HTTP status >= 400 before any output (no `streamAborted`, no `firstOutputMs`) is a known zero. A usage-less attempt whose response began, aborted, or has no error status may have been billed and stays unpriced.
+A missing `usage.jsonl` returns a zeroed summary with 200 because a fresh install has no usage. Unmeasured requests remain distinct from measured zero through `measured / reported / unreported / unsupported / estimated` counts and their coverage totals. Cost estimates in `src/usage/cost.ts` price only `reported` or `estimated` usage, so a partly measured row is never given a confident, understated cost; per-row `pricedRequests` / `unpricedRequests` count a request once, unpriced when any attempt is unpriceable, while a usage-less attempt that made no physical send (`sendCount === 0` or `locallyAnswered`) or was refused with an HTTP status >= 400 other than a 499 client cancel before any output (no `streamAborted`, no `firstOutputMs`) is a known zero, and a row with any measured attempt counts priced or unpriced, never unmetered, whatever its aggregate status. A usage-less attempt whose response began, aborted, was cancelled by the client, or has no error status may have been billed and stays unpriced.
 Normal dashboard pages use the document as their vertical scroller. In `gui/src/styles.css`, body horizontal overflow is clipped without creating a second scrollport; the mobile open-drawer state also locks document overflow. The shared sidebar stays viewport-height through the end of Codex and Claude account pages. `gui/tests/shared-scroll-browser.ts` checks the built entry and App styles with short/long content, both themes, desktop chrome, collapsed navigation and mobile widths. The Usage tab renders that shape and the main Dashboard shows its 30-day summary. The 200-entry in-memory `requestLog` is not the aggregation source; the JSONL ledger is. Usage table scrollports in `gui/src/styles-usage-workspace.css` contain absolute screen-reader captions so long tables do not extend the outer document beyond the report; `gui/tests/usage-scroll-browser.ts` measures that boundary and last-row reachability at desktop and mobile widths.
 Ledger read failures instead return `500 { error: "read_failed" }`. Shared GUI usage admission reads that body before classifying HTTP failure and also rejects the legacy HTTP-200 envelope, so every shared cache retains its last valid report rather than fabricating zero totals.
 > Decision record: [ADR-0106](decisions/ADR-0106-usage-read-failure-contract.md)
@@ -381,7 +381,7 @@ roster the exporter itself iterates. The count is
 deliberately not restated here: it was written as eight, a bounded label value was added, and the
 documentation then contradicted the output it describes. A
 logical request increments once, physical sends sum the finalized attempt counts, and each distinct
-recovery kind already retained on an attempt contributes once to its coarse class. The Antigravity validation-refusal sibling resend records `oauth-account-403`, which Logs labels from the shared recovery roster.
+recovery kind already retained on an attempt contributes once to its coarse class. The Antigravity validation-refusal sibling resend records `oauth-account-403`, which Logs labels from the shared recovery roster. A Codex HTTP 402 account move records `oauth-account-402`, maps to `quota-exhausted` and the `quota` metric class, and has a localized Logs label; HTTP 429 remains a rate-limit recovery.
 `opencodex_request_failures_total` counts the cause the recorder derived and never re-derives one,
 and it labels a counter only: no histogram carries a cause. HTTP 200 never
 overrides a failed terminal event. Duration observes every valid finalized duration; TTFT observes
diff --git a/structure/data-planes/images.md b/structure/data-planes/images.md
index 3c47481e8c7..5b66c935c0c 100644
--- a/structure/data-planes/images.md
+++ b/structure/data-planes/images.md
@@ -24,6 +24,8 @@ Codex Spark exception; standalone Images retain the separate relay contract belo
 
 Shared parsing and streaming follow the [request-copy](../transports/byte-accounting.md#request-copy-accounting) and [stream-buffer accounting](../transports/byte-accounting.md#stream-buffer-accounting) contracts. Response-attached WebSocket telemetry follows the [stage record identity contract](../transports/responses-wire-shapes.md#passthrough-sse-stream-shapes-314).
 
+Fetch-based Anthropic model iterations use the [thinking-signature recovery contract](../transports/anthropic-thinking-recovery.md#imagevideo-model-iterations), without repeating completed media calls.
+
 Fetch-based Anthropic image bridge account recovery follows [the revoked-token contract](../providers/anthropic-account-pool.md#revoked-oauth-access-token-recovery), including output commitment and send-budget gates.
 
 ## Hosted Responses image display
diff --git a/structure/data-planes/inbound-compat.md b/structure/data-planes/inbound-compat.md
index ca39ab063b2..39feeb31e8a 100644
--- a/structure/data-planes/inbound-compat.md
+++ b/structure/data-planes/inbound-compat.md
@@ -320,7 +320,14 @@ its defaults and exclusions are owned by [Responses transport](../transports/res
 
 The provider summary default applies at Responses ingress; native Chat and Anthropic inbound preferences keep their existing handling. Raw content is never renamed to a summary. See [bridge contract](../providers/chat-compat.md).
 
-## Messages request-log correlation
+## Chat and Messages request-log correlation
+
+The Chat Completions HTTP boundary in `src/server/index/serve-options.ts` publishes its generated
+request-history id as `x-opencodex-request-id`, exposed through CORS. JSON, SSE, handler errors
+and logged pre-handler refusals share the final history row's id; caller and upstream ids cannot
+replace it. Unlogged auth, origin, drain and active-turn refusals receive no correlation id.
+Stream headers identify the eventual row, not completed persistence.
+`tests/responses/chat-request-id-endpoint.test.ts` covers this boundary.
 
 The Messages HTTP boundary in `src/server/index/serve-options.ts` publishes its generated
 request-log id in both `request-id` and `x-opencodex-request-id`. Native, translated, streamed,
diff --git a/structure/data-planes/protocol-paths.md b/structure/data-planes/protocol-paths.md
index f7d0c65fd3e..6b682b88ded 100644
--- a/structure/data-planes/protocol-paths.md
+++ b/structure/data-planes/protocol-paths.md
@@ -389,7 +389,7 @@ managed-client steps already applied to the body (alias/modelMap resolution, `oc
 directives). The caller-forward passthrough is decided earlier, on the caller's own credential,
 and returns before this point; the two branches share no credential and no header. The body sent
 is `envelope.freshBody()` when a source envelope exists, otherwise the ingress's own body.
-`src/server/messages-native.ts` is imported lazily, only for an eligible route.
+`src/server/messages-native.ts` is imported lazily, only for an eligible route. Native Messages errors reuse the shared OpenCode Zen guidance before resolving client retry headers. A Zen rate-limit 429, identified by message or explicit `rate_limit_error` type, without an upstream retry hint receives the same 15-second hint as the translated path; quota/billing and spent-usage-limit errors remain unchanged and valid upstream retry headers retain precedence. Both native Messages and `src/server/responses/adapter-dispatch.ts` forward parsed error types and codes to the shared guidance.
 
 Configured admission-key model scope also applies to separately billed Advisor models before
 managed native key or OAuth dispatch. `src/server/messages-native-scope.ts` resolves active
diff --git a/structure/manifest.json b/structure/manifest.json
index f18f37f1e98..8d556d6d56c 100644
--- a/structure/manifest.json
+++ b/structure/manifest.json
@@ -249,6 +249,19 @@
         "src/responses/"
       ]
     },
+    {
+      "path": "transports/anthropic-thinking-recovery.md",
+      "tier": 3,
+      "title": "Anthropic Thinking-Signature Recovery",
+      "scope": "One-shot exact signature-binding recovery before output, and successful-retry memo boundaries.",
+      "documents": [
+        "src/server/responses/anthropic-thinking-recovery.ts",
+        "src/adapters/anthropic-rejection-memo.ts",
+        "src/adapters/anthropic-replay.ts",
+        "src/adapters/anthropic-tool-catalog.ts",
+        "src/responses/reasoning-replay-cache.ts"
+      ]
+    },
     {
       "path": "transports/responses.md",
       "tier": 3,
diff --git a/structure/providers-and-adapters.md b/structure/providers-and-adapters.md
index e4f670bafbd..aab02c118d2 100644
--- a/structure/providers-and-adapters.md
+++ b/structure/providers-and-adapters.md
@@ -55,9 +55,9 @@ Direct MCP names emitted in a verified custom code-mode catalog follow the
 [Responses restoration boundary](transports/responses-wire-shapes.md#direct-mcp-calls-in-code-mode).
 Ordinary structured functions named `exec` do not opt into this compatibility path.
 
-RunTurn hosted search uses `src/web-search/run-turn-loop.ts`: synthetic calls remain private, progress reaches the bridge during collection, and a validated terminal precedes search execution. Complete search calls remain actionable at a truncated `done`; cancellation prevents subsequent queries and calls. OAuth preflight replay in `src/server/responses/run-turn-execution.ts` retains the synthetic tool while refreshing credential-scoped route state. In `src/server/responses/sidecar-execution.ts`, a search plan takes priority over image/video bridge execution for both transports; only fetch-capable adapters enter the fetch search loop. Its Antigravity structured-403 rotation and physical-send accounting follow [Account refusal and rotation boundaries](transports/responses-failover.md#account-refusal-and-rotation-boundaries).
+RunTurn hosted search uses `src/web-search/run-turn-loop.ts`: synthetic calls remain private, progress reaches the bridge during collection, and a validated terminal precedes search execution. Complete search calls remain actionable at a truncated `done`; cancellation prevents subsequent queries and calls. OAuth preflight replay in `src/server/responses/run-turn-execution.ts` retains the synthetic tool while refreshing credential-scoped route state. In `src/server/responses/sidecar-execution.ts`, a search plan takes priority over image/video bridge execution for both transports; only fetch-capable adapters enter the fetch search loop. Anthropic replay and signature repair follow the [thinking recovery contract](transports/anthropic-thinking-recovery.md), with no local prefix validator or beta-header changes. Its Antigravity structured-403 rotation and physical-send accounting follow [Account refusal and rotation boundaries](transports/responses-failover.md#account-refusal-and-rotation-boundaries).
 
-Both search loops keep `web_search` declared after the search budget is exhausted. Further calls receive a paired limit-reached result without another physical search; at most `maxSearches + 3` model iterations run before a terminal error. Ordinary caller tools and cancellation still end the loop; final client tool output follows the [explicit empty client-catalog boundary](transports/responses-wire-shapes.md#declared-tool-membership-by-inbound-wire), after internal search execution. Empty-answer recovery alone removes all tools.
+Both search loops keep `web_search` declared after the search budget is exhausted. Further calls receive a paired limit-reached result without another physical search; at most `maxSearches + 3` model iterations run before a terminal error. Ordinary caller tools and cancellation still end the loop; final client tool output follows the [explicit empty client-catalog boundary](transports/responses-wire-shapes.md#declared-tool-membership-by-inbound-wire), after internal search execution. Empty-answer recovery disables tool calls; Anthropic retains its declared catalog to preserve the bound prefix.
 
 Combo preflight allows the private search tool only while a search plan is active; client tool declaration checks and replay-unsafe heartbeat protection remain enforced.
 
@@ -203,7 +203,7 @@ rewrite rules and the routed-id settlement.
 | `src/adapters/openai-responses/transport.ts` | Shared Responses URL, configured auth and caller-header construction for ordinary requests and explicitly enabled custom native v1 compact. Its compact-handoff metadata copier uses the existing client-header allowlist, never credentials, through internal request construction and Codex auth materialization. Protocol capability never grants canonical identity; v2 trigger and native blob replay remain independently declared. |
 | `src/responses/muse-tool-name-alias.ts` | Host-gated Meta Muse 64-char tool-name alias/restore used by the Responses passthrough. |
 | `src/adapters/openai-chat.ts`, `src/adapters/openai-chat/` | OpenAI-compatible Chat Completions bridge, split into leaves (`wire.ts`, `messages.ts`, `response-events.ts`, `passthrough.ts`, `parallel-tool-calls.ts`, `reasoning-wire.ts`, `serialized-tool-call-content.ts`, `tool-call-validation.ts`, `tool-call-id-remint.ts`, `tool-schema.ts`, `errors.ts`). `parallel-tool-calls.ts` owns the `parallel_tool_calls` wire value for both the translated and native builders, so the three provider states — configured opt-out, configured opt-in, and the unset default that forwards only a caller's explicit `false` — cannot drift between them. `reasoning-wire.ts` applies explicit gateway-object and tool-bearing effort-omission declarations to both builders; absent declarations leave native raw forwarding unchanged. Its client delivery shapes in `src/chat/outbound.ts` and `src/server/chat-native-sse.ts` relay the upstream `service_tier` echo on non-stream, folded-stream, and synthesized-SSE bodies, never inventing the key when the upstream omits it. |
-| `src/adapters/anthropic.ts` | Anthropic Messages bridge. A `refusal` or `content_filter` stop reason yields an explicit `incomplete` event with `retryable: false` rather than `done` with that stopReason (#4312); `max_tokens` remains `done`. For a Responses client the bridge delivers that event, and the same one from the Kiro adapter, as a terminal `response.failed` ([Adapter-to-Responses bridge](transports/responses.md#adapter-to-responses-bridge)). It is the wire that defines `tools[*].strict` and `tools[*].allowed_callers`, so a rebuilt declaration carries both: an explicit `strict: true` and any `allowed_callers` the caller declared. An absent `strict` stays absent, because the Messages inbound records it as `false` and a `false` on the wire would read as an opt-out nobody asked for. Anthropic Fast uses the native `anthropic-speed` FastWire: a set decision sends `speed: "fast"` with `fast-mode-2026-02-01` in one case-insensitively merged, deduplicated `anthropic-beta` header that preserves OAuth betas. Stream and buffered `usage.speed` echoes confirm fast or downgrade to standard; no echo leaves the request assumed. `tests/adapters/anthropic/anthropic-fast-speed.test.ts` pins the wire and echoes. Anthropic Fast is opt-in: the registry marks both Anthropic entries `fastOptIn`, and `src/providers/fast-opt-in.ts` (`providerFastSwitchOff`) keeps Fast off until `providers.<name>.fastEnabled` is `true`. An off switch is provider capability `false`, applied in the FastPolicy authority (`service-tier.ts`), `resolveModelPolicy`, and router registry enrichment, so no model-level Fast toggle, `--fast` row, or proxy-generated `speed` field is produced. Native Claude Messages passthrough still forwards a `speed` field the caller sends itself, outside the proxy Fast policy. `tests/adapters/anthropic/anthropic-fast-opt-in.test.ts` pins the default, the switch, and the management PATCH/GET. For `api.anthropic.com` only, the Claude client's typed web tools (`parsed._anthropicServerTools`) follow the function tools unchanged, minus the caller's `cache_control`; a function tool of the same name wins, so the web-search sidecar's `web_search` keeps priority and `web_fetch` is still carried. No beta header is added: both tools are GA. Each streamed `web_search_tool_result` becomes a `web_search_call_begin`/`web_search_call_end` pair (the query of its `server_tool_use` in the same response, hit URLs and titles, or `failed` for an error result), which the Claude outbound renders back as the same block pair; a search Anthropic defers beside a client `tool_use` has no result in that response and surfaces nothing, and the replayed pair is dropped by the inbound translation, so a result without `encrypted_content` never reaches Anthropic. A streamed `web_fetch_tool_result` opens and closes the same cell with `fetch` set (the fetched URL and Anthropic's result content, verbatim); the bridge records it as an `open_page` `web_search_call` carrying `fetch_result`, and the Claude outbound renders it back as `server_tool_use` `web_fetch` + that `web_fetch_tool_result`, not counted in `web_search_requests`. Citations are not relayed. `tests/claude-integration/claude-translated-server-tools.test.ts` pins the wire, the sidecar priority, the bridge's client stream and JSON, and the direct encoder's stream. |
+| `src/adapters/anthropic.ts` | Anthropic Messages bridge. A `refusal` or `content_filter` stop reason yields an explicit `incomplete` event with `retryable: false` rather than `done` with that stopReason (#4312); `max_tokens` remains `done`. For a Responses client the bridge delivers that event, and the same one from the Kiro adapter, as a terminal `response.failed` ([Adapter-to-Responses bridge](transports/responses.md#adapter-to-responses-bridge)). It is the wire that defines `tools[*].strict` and `tools[*].allowed_callers`, so a rebuilt declaration carries both: an explicit `strict: true` and any `allowed_callers` the caller declared. An absent `strict` stays absent, because the Messages inbound records it as `false` and a `false` on the wire would read as an opt-out nobody asked for. Anthropic Fast uses the native `anthropic-speed` FastWire: a set decision sends `speed: "fast"` with `fast-mode-2026-02-01` in one case-insensitively merged, deduplicated `anthropic-beta` header that preserves OAuth betas. Stream and buffered `usage.speed` echoes confirm fast or downgrade to standard; no echo leaves the request assumed. `tests/adapters/anthropic/anthropic-fast-speed.test.ts` pins the wire and echoes. Anthropic Fast is opt-in: the registry marks both Anthropic entries `fastOptIn`, and `src/providers/fast-opt-in.ts` (`providerFastSwitchOff`) keeps Fast off until `providers.<name>.fastEnabled` is `true`. An off switch is provider capability `false`, applied in the FastPolicy authority (`service-tier.ts`), `resolveModelPolicy`, and router registry enrichment, so no model-level Fast toggle, `--fast` row, or proxy-generated `speed` field is produced. Native Claude Messages passthrough still forwards a `speed` field the caller sends itself, outside the proxy Fast policy. `tests/adapters/anthropic/anthropic-fast-opt-in.test.ts` pins the default, the switch, and the management PATCH/GET. For `api.anthropic.com` only, the Claude client's typed web tools (`parsed._anthropicServerTools`) follow the function tools unchanged, minus the caller's `cache_control`; a function tool of the same name wins, so the web-search sidecar's `web_search` keeps priority and `web_fetch` is still carried. No beta header is added: both tools are GA. Each streamed `web_search_tool_result` or `web_fetch_tool_result` becomes a `web_search_call_begin`/`web_search_call_end` pair (the query of its `server_tool_use` in the same response, hit URLs and titles, or `failed` for an error result) carrying `anthropic`: that `server_tool_use` with its complete streamed input and the result block, verbatim. An orphan result, a result with a different call id, or a result whose call input cannot be parsed is dropped with no synthetic call; the surrounding text is preserved. Streamed server-tool input retains at most 4,096 characters, slicing each incoming fragment to the remaining capacity; an oversized input that cannot be recovered drops its exchange under the same rule. The bridge and the direct encoder keep both on the `web_search_call` item as `anthropic_blocks` (a fetch is an `open_page` action), and the Claude outbound renders them back unchanged, with the original `srvtoolu_` id, `encrypted_content` and `page_age`; a fetch is not counted in `web_search_requests`. A search Anthropic defers beside a client `tool_use` has no result in that response and surfaces nothing. On the next turn, `messagesToAnthropicFormat` re-inserts the client's replayed pairs (`parsed._anthropicServerReplay`) ahead of the `tool_use`, text or thinking block that followed them, for `api.anthropic.com` only. An anchor must occur exactly once across assistant history, counting string and block content alike; repeated anchors drop their exchanges and preserve the other turns. Replay requires one-to-one call/result ids and matching tool types within the same assistant turn, with the call preceding its result in the original sequence. A single forward pass tracks pending calls and rejects reversed pairs, duplicate ids and orphan results. Calls require a plain input object with a nonempty `web_search.query` or `web_fetch.url` string; malformed input, a pair without `encrypted_content`, or a pair with no following anchor stays dropped. Stored `anthropic_blocks` restore only when call id, result id, tool/result types and input object agree; malformed metadata falls back to the rebuilt pair. Citations, a deferred search and `pause_turn` are not resumed. `tests/claude-integration/claude-translated-server-tools.test.ts` pins the wire, the sidecar priority, the bridge's client stream and JSON, and the direct encoder's stream. |
 | `src/adapters/anthropic-model-contract.ts` | Per-family Anthropic Messages wire rules, shared by the adapter and the web-search and vision sidecars, measured live on 2026-09-29, with Haiku 5.5 documented on 2026-10-08: adaptive vs budget thinking (Haiku 5.5+ is adaptive); explicit `thinking: disabled` (Sonnet 5.0 up to but excluding 5.5, Haiku 5.5+ without effort); the `between_tools` floor that replaces it on Sonnet 5.5+ (sent without an effort, since xhigh/max reject it); forced `tool_choice` downgraded to `auto` on Opus 5.5, Fable 5.1+ and Sonnet 5.5+; `temperature`/`top_p` dropped on Opus 4.7+, Sonnet 5+, Haiku 5.5+ and every Fable, which 400 on any non-default value; `top_p` dropped when sent with `temperature` on the 4.5/4.6 families, which take either alone but not both; and sidecar thinking-off fields, a low effort with no `thinking` for Opus 5.5 and Fable, which reject both off switches. Dotted Bedrock ids do not parse as a family, and the Messages-native passthrough forwards caller fields unchanged. `tests/adapters/anthropic/anthropic-sonnet-5-5-contract.test.ts` and `tests/adapters/anthropic/anthropic-haiku-5-5-contract.test.ts` pin the family table. |
 | `src/adapters/google.ts` | Gemini bridge. The final wire compiler owns [endpoint-scoped tool-schema loss policy](providers/google.md#google-tool-schema-loss-reporting): compatible mode changes no request bytes, strict initial loss creates no physical send, and strict non-direct repair creates no changed repair send. A caller-declared strict tool selects `functionCallingConfig.mode: "VALIDATED"` in place of the absent-choice default; `NONE`, `ANY` and a forced-name choice are stronger constraints the caller asked for and are never overwritten. |
 | `src/adapters/unique-tool-call-ids.ts` | Request-scoped tool-call-id uniqueness for every `openai-chat` provider. An upstream that mints an id from the call's position in its response repeats `call-0-0` on every turn; a Messages client has already paired that id, drops the duplicate, and is left with a call that has no result, so the turn reads as empty and the model re-issues it indefinitely. Only a **repeat** is rewritten — the first occurrence stays byte-identical, leaving prompt-cache keys, reasoning-replay lookups and already-unique upstreams untouched. The ids to avoid come from the caller's history, captured in `buildRequest` (the only point that sees it) and applied at emission, never at ingestion: ingestion matches streamed deltas against the id upstream sent, so rewriting there would strip a pending call of its identity mid-stream. A repeat takes a `-<n>` suffix, never `_<n>`, because `<earlier>_<digits>` reads as a batch sub-call of `<earlier>`; occupied-set search resumes by suffix width and retained base prefix, including when siblings converge as `-9` becomes `-10`. Covered by `tests/adapters/openai/openai-chat-tool-call-id-remint.test.ts`. |
@@ -563,7 +563,7 @@ same way. `src/types/wire.ts` owns accepted wire enumerations such as the per-pr
 config load, management writes and fetch, so no boundary accepts a value another rejects. It also hard-pins OpenCode Go's
 Anthropic models across runtime and static policy resolution, even with Chat/Responses overrides. The existing `opencode-go` preset pins saved URLs to its canonical endpoint; its inference alias supplies destination metadata and affinity to differently named rows. `src/types/opencode-go.ts` shares exact native pins (including Qwen3.7 Plus/3.8 Max/3.8 Flash) and overridable Responses defaults (including GPT 6 Luna); new native pins use the pinned canonical Go key destination even in pure policy captures of saved rows, while the five legacy name pins retain compatibility; unknown models retain Chat. `tests/providers/opencode-go-model-protocols.test.ts` covers resolution and dispatch. Every `dsh-account` model is pinned to the `dsh-account` adapter whatever `baseUrl` says, because that adapter is the [DSH account token's destination boundary](providers/dsh-account.md#destinations).
 
-For canonical `opencode-zen`, `src/types/wire.ts` pins `gemini-*` to `google`, including when a Chat/Responses override is configured. `src/types/opencode-zen.ts` shares the destination check with `src/adapters/google.ts`: only `https://opencode.ai/zen/v1` and `https://opencode.ai/inference/v1` qualify, with key auth and AI Studio mode (both may be unset), no URL credentials, query or fragment, and optional trailing slashes. The adapter appends `/models/<encoded-model-id>:generateContent` or `:streamGenerateContent?alt=sse` to the selected base, sends `x-goog-api-key`, and skips AI Studio's `-tiered` model renames. The pin does not apply to `opencode-free`, OpenCode Go, custom destinations, OAuth/forward auth, Vertex or Cloud Code Assist.
+For canonical `opencode-zen`, `src/types/wire.ts` pins `gemini-*` to `google` and `claude-*` to `anthropic`, including when a Chat/Responses override is configured. `src/types/opencode-zen.ts` shares the destination check with `src/adapters/google.ts`: only `https://opencode.ai/zen/v1` and `https://opencode.ai/inference/v1` qualify, with key auth (which may be unset), no URL credentials, query or fragment, and optional trailing slashes. Claude uses the existing Anthropic Messages adapter and does not depend on the Google mode setting. Zen rate-limit guidance in `src/providers/opencode-zen-rate-limit.ts` accepts an explicit `rate_limit_error` even without matching message text, excludes quota/billing and spent-usage-limit failures using structured type/code and message cues, and preserves valid upstream retry headers. The Google adapter appends `/models/<encoded-model-id>:generateContent` or `:streamGenerateContent?alt=sse` to the selected base, sends `x-goog-api-key`, and skips AI Studio's `-tiered` model renames. These pins do not apply to `opencode-free`, OpenCode Go, custom destinations or OAuth/forward auth. The Gemini pin additionally requires AI Studio mode (which may be unset), excluding Vertex and Cloud Code Assist.
 
 `src/types/config.ts` declares the optional per-phase `memoryModels` setting;
 `src/types/request.ts` carries the selected phase through combo handoffs without changing the
diff --git a/structure/providers/generic-account-pool.md b/structure/providers/generic-account-pool.md
index 1ba25dc9ce3..26846e9af1b 100644
--- a/structure/providers/generic-account-pool.md
+++ b/structure/providers/generic-account-pool.md
@@ -23,3 +23,11 @@ are excluded. `tests/oauth/generic-session-affinity.test.ts` and
 `tests/server/server-generic-oauth-affinity.test.ts` exercise these boundaries with synthetic accounts.
 
 `src/types/provider.ts` declares the optional `sessionAffinity` mode; omission keeps existing behavior.
+
+## Combo sibling probes
+
+`src/server/responses/core-combo.ts` asks `src/oauth/generic-account-failover.ts` whether a refused
+account has an eligible sibling before cooling the whole target. This probe records the refused
+account's cooldown but passes `commit: false`, so it only peeks at a round-robin pool. An unsent
+sibling does not consume a sticky turn. Dispatching callers retain the default committed pick.
+`tests/oauth/generic-oauth-combo-account-cooldown.test.ts` covers this distinction.
diff --git a/structure/providers/google.md b/structure/providers/google.md
index 074909d87dd..ca74f843867 100644
--- a/structure/providers/google.md
+++ b/structure/providers/google.md
@@ -131,6 +131,29 @@ valid requests.
 
 > Decision record: [ADR-5008](../decisions/ADR-5008-google-opening-functioncall-repair.md)
 
+## Gemini progress-text history
+
+Gemini sometimes skips its thinking channel on a tool-calling turn and plans in visible text
+instead: a progress line followed by unmarked planning such as "Let's read google.ts next."
+Replayed whole, that tail is copied by every later turn of the session. When
+`messagesToGeminiFormat` serializes an assistant turn that contains a tool call for a model id
+containing `gemini`, the text before the turn's first tool call is replayed as the lead sentence
+of its first non-empty text part; the other text parts before the call are dropped. Text after a
+tool call and turns with Responses `phase: "final_answer"` are replayed whole.
+`src/adapters/google-progress-history.ts` owns the split: ASCII `.`, `!` or `?` followed by
+whitespace, a script's own sentence terminator (CJK, Devanagari, Arabic, Armenian, Ethiopic,
+Myanmar), or a line break, with trailing closing quotes,
+brackets and Markdown emphasis kept. Boundaries that only close a leading list marker or
+`e.g.`/`i.e.`/`etc.`/`vs.` are skipped. It never matches wording.
+
+Final answers (assistant turns without tool calls), non-Gemini models such as Claude on
+Antigravity, tool calls, their signatures and client-visible output are unchanged. A leak in the
+current response is still delivered as ordinary text; the trim keeps it from propagating.
+The trade-off is that facts a model states only in pre-call text, beyond its first sentence, are
+not replayed; the call, its result and any final answer still are.
+`tests/adapters/google/gemini-progress-history.test.ts` covers CCA and AI Studio Gemini, the
+`final_answer` and Claude exemptions, text after a call and the split.
+
 ## Structured output on generateContent
 
 A caller's Responses `text.format` reaches the Gemini wire as
diff --git a/structure/runtime.md b/structure/runtime.md
index 57f8ea1c825..35542264e3a 100644
--- a/structure/runtime.md
+++ b/structure/runtime.md
@@ -165,6 +165,8 @@ their own files. `src/grok/inject.ts` holds the shared canonical config-write lo
 
 ## Lifecycle
 
+Cross-home discovery in `src/cli/cross-home-owner.ts` checks concrete loopback address availability through `src/cli/loopback-family.ts` before probing each family. A synchronous ephemeral bind is immediately closed; only address/family-unavailable errors exclude that address. This prevents a disabled IPv6 loopback's off-host `::1` connect timeout from blocking startup. Other bind errors retain discovery, and a timeout on an available or unknown family still produces an indeterminate owner verdict. Live owners on either available family retain identity and attestation checks.
+
 Startup catalog sync and native restore apply the [retired-native policy](catalog.md#shared-catalog). Foreground exit cleanup in `src/cli/index.ts` delegates restoration through the existing sibling/recycle teardown gates; approved external URLs follow [custom-provider consent](codex-provider-routing.md), while unapproved provider configuration and history remain unchanged. Guarded tests isolate the owner registry used by cross-home discovery beneath their selected home, including children without a registry override; production retains the shared locator. See [test state isolation](ops/test-sandbox-cleanup.md).
 `src/server/background-lifecycle.ts` registers low-quota protection for each live server, flushes pending saves before releasing its owner, binds its own event ledger to management requests, and unregisters it on failed startup or stop; with no pending save, owner release remains synchronous. The protection writer loads config persistence only when a threshold schedules a save; see [configuration](config.md#codex-pool-low-quota-protection). Codex quota processing has shared and Reserve scopes; retired model evidence is suppressed as
 described in [OpenAI quota ownership](providers/openai-tiers.md#public-provider-contract).
@@ -202,8 +204,8 @@ independent. Ordinary stop drains the spend reporters after listener teardown be
 reference. `src/server/index/spend-ledger-lifecycle.ts` also holds the lease through failed-start listener rollback. Enforced seeds remain live until reporters close and settlement plus send-ID forgetting are durable; scope totals survive forgetting. SQLite and the OS release a crashed owner; no PID, timestamp,
 TTL or lock-file deletion participates in recovery. Startup passes the provider roster and top-level pool aliases with the spend policy; live state reconciliation refreshes both without opening an unused ledger. Under the [request-start policy](transports/responses-spend.md#durable-spend-reservations), existing requests retain their initial enforcement mode, numeric ceilings and L; changed limits apply to later requests. HTTP admission checks [historical continuity](transports/responses-spend.md#historical-pool-continuity-and-rollback) even without a root; failed accounting reads release the active-turn lease. Rooted continuity denials record exactly one workflow refusal event before response formatting.
 
-An explicit Codex integration OFF skips startup cache invalidation before the user-scoped catalog
-serialization lock is resolved. Explicit `sync` and `sync-cache` retain their catalog-only override.
+An explicit Codex integration OFF skips startup ownership probes, native-main preparation and cache invalidation before resolving the catalog lock.
+Enabled startup retains separate fresh ownership decisions. Explicit `sync` and `sync-cache` retain their catalog-only override.
 
 `startServer` composes up to four sockets in one synchronous startup transaction: the public data listener, optional unauthenticated data-loopback and hub-management listeners, and the optional `hub-link` listener, which opens only for a recorded link and persists its concrete `127.0.0.1:<listenerPort>`. HTTP Responses/Messages apply the [caller header contract](data-planes/inbound-compat.md#http-caller-conversation-identity) before turn admission and dispatch. Linked-machine data uses the [connection-bound relay contract](remote-link.md#connection-bound-relay-authentication); client-local credentials and routing policy remain unchanged.
 The data-loopback socket serves a fixed data-plane allowlist: Responses and its compact sibling,
@@ -380,9 +382,9 @@ Automatic Codex pool selection and account status share the [plan exclusion cont
 
 ### Empty forced search answers
 
-Both search loops keep `web_search` declared after the search budget is exhausted. Further calls receive a paired limit-reached result without another physical search; at most `maxSearches + 3` model iterations run before a terminal error. Ordinary caller tools and cancellation still end the loop. Empty-answer recovery alone removes all tools. `src/web-search/loop.ts` makes at most one extra answer attempt after a clean forced-answer terminal with no visible output or tool call, only while an iteration remains. The recovery has no tools and reuses gathered search results. Malformed calls fail before refusal/truncation passthrough, and well-formed recognized refusal/truncation terminals pass through unchanged, including empty or partial answers. The extra generation may incur provider usage. `src/web-search/run-turn-loop.ts` shares this recovery and checks the ceiling before dispatch so it cannot start an unused request; below the search cap, `emptyCompletionRetry` permits one identical empty-answer retry per request with current tools and results. Errors and invalid terminals never authorize another search. Batched results from one call share one 8,000-character budget in `src/web-search/format-result.ts`, planned per query before serialization (#6621): every query keeps its label and status, shortened answers and unlisted sources carry markers with their original counts outside the untrusted boundary, structured output stays one valid JSON document, and a batch whose fixed parts alone overflow is condensed to status lines with a per-status count of any query that still did not fit.
+Both search loops keep `web_search` declared after the search budget is exhausted. Further calls receive a paired limit-reached result without another physical search; at most `maxSearches + 3` model iterations run before a terminal error. Ordinary caller tools and cancellation still end the loop. Empty-answer recovery alone disables tool calls; Anthropic keeps its declared catalog stable. `src/web-search/loop.ts` makes at most one extra answer attempt after a clean forced-answer terminal with no visible output or tool call, only while an iteration remains. The recovery disables tool calls and reuses gathered search results. Malformed calls fail before refusal/truncation passthrough, and well-formed recognized refusal/truncation terminals pass through unchanged, including empty or partial answers. The extra generation may incur provider usage. `src/web-search/run-turn-loop.ts` shares this recovery and checks the ceiling before dispatch so it cannot start an unused request; below the search cap, `emptyCompletionRetry` permits one identical empty-answer retry per request with current tools and results. Errors and invalid terminals never authorize another search. Batched results from one call share one 8,000-character budget in `src/web-search/format-result.ts`, planned per query before serialization (#6621): every query keeps its label and status, shortened answers and unlisted sources carry markers with their original counts outside the untrusted boundary, structured output stays one valid JSON document, and a batch whose fixed parts alone overflow is condensed to status lines with a per-status count of any query that still did not fit.
 
-`src/web-search/loop.ts` uses `src/web-search/header-deadline.ts` to suspend the cumulative response-header deadline while each physical send awaits local pacing admission. Ordinary fetches, adapter executors, reset retries and pool-key rotations retain the remaining budget after admission; same-target 429 backoff still clears and restarts that budget. The default remains 200,000 ms. Client cancellation remains linked during queued admission and after final headers, and the existing pacing slot wrapper retains leases through body completion or cancellation. Streaming retry heartbeats and body inactivity deadlines keep their existing ownership. `tests/web-search/web-search-pacing-deadline.test.ts` covers queued success, real header stalls, queued cancellation, retry admission and cumulative rotation time. OpenAI sidecar 429 replays run only when their backoff fits the remaining sidecar deadline; otherwise the original 429 remains the routing-health outcome rather than becoming a timeout. Reset recovery and 429 replays share one three-send budget per search, so the two layers cannot multiply physical sends. Direct vision/search helpers and the alpha/search relay retain the resolver's live [stored-account credit policy](codex-account-controls.md#stored-account-authentication-policy) through physical sends and retries; a local hold prevents the send without becoming an upstream connection failure.
+Anthropic hosted-search model iterations use the [request-scoped thinking-signature recovery policy](transports/anthropic-thinking-recovery.md), retaining completed searches and tool results. `src/web-search/loop.ts` uses `src/web-search/header-deadline.ts` to suspend the cumulative response-header deadline while each physical send awaits local pacing admission. Ordinary fetches, adapter executors, reset retries and pool-key rotations retain the remaining budget after admission; same-target 429 backoff still clears and restarts that budget. The default remains 200,000 ms. Client cancellation remains linked during queued admission and after final headers, and the existing pacing slot wrapper retains leases through body completion or cancellation. Streaming retry heartbeats and body inactivity deadlines keep their existing ownership. `tests/web-search/web-search-pacing-deadline.test.ts` covers queued success, real header stalls, queued cancellation, retry admission and cumulative rotation time. OpenAI sidecar 429 replays run only when their backoff fits the remaining sidecar deadline; otherwise the original 429 remains the routing-health outcome rather than becoming a timeout. Reset recovery and 429 replays share one three-send budget per search, so the two layers cannot multiply physical sends. Direct vision/search helpers and the alpha/search relay retain the resolver's live [stored-account credit policy](codex-account-controls.md#stored-account-authentication-policy) through physical sends and retries; a local hold prevents the send without becoming an upstream connection failure.
 
 ### Loop usage accounting
 
diff --git a/structure/transports/anthropic-thinking-recovery.md b/structure/transports/anthropic-thinking-recovery.md
new file mode 100644
index 00000000000..3739e683901
--- /dev/null
+++ b/structure/transports/anthropic-thinking-recovery.md
@@ -0,0 +1,117 @@
+# Anthropic Thinking-Signature Recovery
+
+`src/server/responses/anthropic-thinking-recovery.ts` owns one request-scoped recovery for
+Anthropic history rejected as bound to another conversation. The exact backtick-bearing
+signature-validation phrase and the conversation-binding phrase must both be present.
+The request must contain a signature that the real Anthropic adapter would replay, or a
+nonempty redacted-thinking block. The adapter's existing signature predicate is shared.
+
+`src/server/responses/adapter-dispatch.ts` checks a complete, bounded, display-safe HTTP 400
+error body; non-replayable responses remain terminal. `src/server/responses/adapter-delivery.ts`
+checks initial HTTP-200 adapter errors before terminal/empty-completion guards. Both use the
+same opaque-recovery guard and the existing request send budget, pacing and rebuild owner.
+Only harmless heartbeats may precede a streamed recovery: text, thinking, boundaries, tool
+activity and replay-unsafe heartbeats fence replay. The rejected iterator closes before refetch.
+
+Recovery records only digests of the opaque blocks actually serialized by the adapter, using
+`src/adapters/anthropic-rejection-memo.ts`. The request-local policy removes those blocks and
+leaves plaintext history and newly issued thinking intact. If bounded collection is unavailable, recovery is withheld rather than risking a byte-identical resend.
+A replacement HTTP refusal retains its status, safe error message/type and code; its body is
+not parsed as SSE. Cancellation, budget exhaustion and a second rejection cannot trigger another
+signature recovery. Empty-completion retries in `src/server/responses/adapter-continuation.ts` share this guard and
+rebuild through their existing pacing/send owner. Ordinary continuations after output cannot
+recover signatures. Anthropic has no `runTurn` recovery.
+
+Only a delivery-validated completed response with actual text/tool output and an observed
+successful terminal can memoize the rejection. Errors, incomplete/empty responses, missing
+terminals, cancellation and changed serving identity cannot memoize it. The existing thread and
+durable-serving-identity key and five-minute TTL in `src/responses/reasoning-replay-cache.ts` are
+unchanged. Selective memos retain at most 256 payload digests within the existing cache byte cap;
+merged sets that cannot fit fall back to the existing blanket policy. `src/server/responses/core-replay.ts`
+binds a memo only for the current serving scope; a serving-identity change retains its independent
+blanket strip. No prefix hashes or local prefix validator participate in replay admission.
+
+`tests/responses/responses-anthropic-thinking-signature-recovery.test.ts` exercises the actual
+Anthropic adapter with synthetic HTTP/SSE; `tests/responses/responses-anthropic-thinking-recovery.test.ts`
+pins heartbeat/side-effect fences, exact classification, iterator cleanup and memo boundaries.
+
+## Hosted search iterations
+
+Search history uses the bridge's signature snapshot semantics: consecutive signature updates,
+including intervening heartbeats, replace one block's signature. The next semantic event closes
+that block, so a genuine empty thinking-block start remains a separate signed block.
+
+`src/server/responses/sidecar-execution.ts` supplies the same request-owned policy to
+`src/web-search/loop.ts`. Only the current routed-model iteration is rebuilt; completed searches,
+tool results, and history remain intact. Request caches are invalidated and the rejection policy
+persists into later iterations. HTTP 400 classification runs after existing 429/key recovery.
+`src/web-search/progress-stream.ts` has an opt-in typed adapter-error handoff before its normal
+exception conversion, with a per-send semantic/replay-unsafe fence and original-body cleanup.
+A streamed replacement gets a fresh header deadline; an HTTP refusal retains its current deadline.
+
+The Anthropic search HTTP receipt admits a repair against the shared dispatch budget and settles
+it once. Ordinary direct search sends retain their existing reporting contract; Combo bookings
+and credential-hop permits are settled rather than charged twice. Recovery is conservatively
+unavailable with enforced spend accounting because this legacy direct search lane cannot prove
+receipts for earlier ordinary sends. No explicit caller or Combo allowance is increased, and the
+ordinary search iteration limit/admission behavior is unchanged.
+
+Only a validated current model iteration contributes completion/output evidence; search cards
+cannot establish memo success. The final bridge completion still commits the memo, subject to
+cancellation and unchanged serving scope. Replacement HTTP errors keep status/type/code and
+non-replayable diagnostics remain withheld. A failed repair is terminal, including a replacement
+429; it does not start another credential/rate-limit ladder. The actual-adapter hosted-search contract lives in
+`tests/responses/responses-web-search-thinking-signature-recovery.test.ts`.
+
+## Lossless in-memory search continuations
+
+`src/adapters/anthropic-replay.ts` captures known Anthropic assistant content blocks from the
+original SSE frames only for search streams explicitly opted in by the loop. Private WeakMaps
+bind complete snapshots to terminal events and then to loop-owned assistant messages; request
+parsers, clients, response persistence and logs cannot supply or receive this metadata. The
+collector validates ordered start/delta/stop indices and message completion, charges retained
+bytes incrementally, and releases unclaimed attempts on cancellation and claimed snapshots when
+the loop exits. Unknown blocks/deltas, dropped malformed frames and incomplete histories make
+continuation fail before any hosted search executes. Every block start fences signature retries,
+including server tools that have no public adapter-event representation.
+Capture budget pressure invalidates and releases only that capture, preserving ordinary parsing
+and healthy final answers. A further hosted search still requires a complete lossless snapshot;
+unavailable capture never authorizes a lossy continuation or another physical search.
+
+`src/web-search/anthropic-history.ts` supplies canonical tool identities while the raw snapshot
+preserves text-block boundaries, citations, original input objects, opaque thinking and block
+order on the wire. Parallel calls stay in one assistant turn; their results keep the existing
+search budgets and duplicate-query suppression. Tool-name/id rewrites must agree with the raw
+snapshot or serialization fails closed. This is request-local search fidelity, not a durable
+cross-request transcript format or a guarantee for unsupported provider block types.
+Signed progress commentary remains signed thinking in the loop's internal history, so a later
+binding refusal can identify and remove that payload while preserving completed search results.
+
+Anthropic forced-answer nudges are appended once to request-local history and remain in their
+original sent positions. An empty-answer retry retains the same declared tool catalog and changes
+only `tool_choice` to `none`; it does not remove definitions. `src/adapters/anthropic-tool-catalog.ts`
+shares the effective advertised catalog between serializer, system guidance and search-loop setup,
+including `allowed_tools` restrictions and Opus 5.5 named-tool compatibility narrowing. This avoids
+changing bound tools/system or widening permissions during the retry. Other adapters keep their
+existing empty-answer policy. Hosted search disabled by the incoming choice remains disabled.
+
+`tests/adapters/anthropic/anthropic-replay.test.ts` pins opt-in ownership, cancellation, malformed
+indices, bounded admission, forged/expired snapshot rejection and idempotent budget release.
+Nonconforming or repeated tool IDs fail before search execution, including IDs already present
+in the request-local history, rather than waiting for the next serializer to reject normalization.
+
+## Image/video model iterations
+
+`src/images/loop.ts` uses the same request-scoped recovery supplied by
+`src/server/responses/sidecar-execution.ts`. Both HTTP 400 and initial stream refusals rebuild
+only the current model send. Completed media calls and their tool results remain in loop history;
+recovery cannot repeat a media fulfillment. The loop keeps its pacing slot and fresh replacement
+header deadline. Replacement failures retain status/type/code and release unused permits.
+As in search, enforced spend without authoritative earlier-send receipts withholds recovery.
+Send-budget refusals in later iterations retain the same non-retryable 429 identity as initial
+admission refusals, including after a completed media call.
+
+`tests/responses/responses-anthropic-thinking-signature-recovery.test.ts` covers media repair,
+completed tool retention, progress fences, and empty-completion recovery. Legal oldest-thinking
+removal, changed system prompts on Sonnet 4.5 tool continuations, and rotating image URLs remain
+upstream decisions, covered by `tests/responses/responses-anthropic-legal-history.test.ts`.
diff --git a/structure/transports/responses.md b/structure/transports/responses.md
index b1e586d3e89..dd674c1d7b5 100644
--- a/structure/transports/responses.md
+++ b/structure/transports/responses.md
@@ -71,7 +71,7 @@ silence. It cannot observe the client's workspace or prove whether a successful
 repository state. Consequently, the active-turn and session-lane gates are concurrency admission
 limits, the translator budget follows [live retained-byte ownership](byte-accounting.md#stream-buffer-accounting), the response-state caps are cache
 retention limits, and the stall watchdog is a silence limit. None is a cumulative continuation or
-semantic no-progress budget. The turn lease in `src/server/lifecycle.ts` subscribes to HTTP ingress cancellation, internal decision cancellation and every registered controller. Cancellation snapshots only that turn's controllers, releases its admission, session-lane reference, attached workflow leases and native-main ownership, then aborts the snapshot with the cancellation reason. It does not await upstream work or owner finalization, even when the owner remains suspended; other turns retain their controllers and admission. Late controllers abort immediately without registering or transferring ownership, and cancelled selections cannot claim a native-main account. Live/Realtime acquisition binds ingress cancellation until WebSocket upgrade transfers ownership. Normal completion detaches the listeners; late finalizers remain idempotent and do not release newly admitted turns. `tests/codex-integration/active-turn-disconnect.test.ts` covers these cancellation and ownership boundaries.
+semantic no-progress budget. The turn lease in `src/server/lifecycle.ts` subscribes to HTTP ingress cancellation, internal decision cancellation and every registered controller. Cancellation snapshots only that turn's controllers, releases its admission, session-lane reference, attached workflow leases and native-main ownership, then aborts the snapshot with the cancellation reason. It does not await upstream work or owner finalization, even when the owner remains suspended; other turns retain their controllers and admission. Late controllers abort immediately without registering or transferring ownership, and cancelled selections cannot claim a native-main account. Live/Realtime acquisition binds ingress cancellation until WebSocket upgrade transfers ownership. Normal controller completion detaches only that controller and its listener; the last owner or an explicit parent release settles the lease. A completed combo relay cannot retire its parent WebSocket turn or cancel the next attempt, and a completed child's late abort cannot cancel former siblings. Late finalizers remain idempotent. `tests/codex-integration/active-registry-admission.test.ts` covers these shared-owner boundaries. `tests/codex-integration/active-turn-disconnect.test.ts` covers these cancellation and ownership boundaries.
 
 > Decision record: [ADR-0031](../decisions/ADR-0031-responses-http-sse.md)
 > Decision record: [ADR-0032](../decisions/ADR-0032-responses-http-sse.md)
@@ -428,13 +428,13 @@ The continuation-note and continuation-wire tests establish prompt and wire cont
 | `policy-refusal.ts` | Rewrites an allowlisted non-combo HTTP 403 model refusal (`isUpstreamPolicyRefusal` in `src/lib/errors.ts`) from an xAI destination only (`isXaiResponsesDestination`: api.x.ai or the Grok CLI proxy, on either wire) to an HTTP 200 Responses `incomplete` / `content_filter` payload, JSON or SSE, for both `adapter-dispatch.ts` and `passthrough-delivery.ts`. A streamed rewrite takes the turn admission lease and releases it when the body finishes, so the refusal stays inside active-turn accounting. Combo attempts keep the original 403 so failover classifies it as a hop. |
 | `sidecar-execution.ts`, `sidecar-send-budget.ts` | Image/video versus web-search execution, shared rotation, and adapter-aware prepaid inference/producer ownership under the [spend contract](responses-spend.md#prepaid-initial-sends). |
 | `completion-policy.ts`, `run-turn-execution.ts` | Empty-completion eligibility and adapter-owned event turns; refreshed retries reject previously failed key bindings and revalidate after each queued admission; adapter-owned CLI spawns receive the post-setup `IncomingMeta.beforePhysicalSend` fence, with [replacement-key readmission](responses-failover.md#upstream-key-attempt-accounting). |
-| `adapter-dispatch.ts` | Translated initial dispatch, bounded recovery and the shared continuation retry counter. Initial and rebuilt adapter budget refusals retain the HTTP 413 [byte-accounting contract](byte-accounting.md#request-copy-accounting); ordinary build errors remain 400. |
+| `adapter-dispatch.ts` | Translated initial dispatch, bounded recovery (including [Anthropic thinking-signature recovery](anthropic-thinking-recovery.md)) and the shared continuation retry counter. Initial and rebuilt adapter budget refusals retain the HTTP 413 [byte-accounting contract](byte-accounting.md#request-copy-accounting); ordinary build errors remain 400. |
 | `adapter-continuation.ts`, `adapter-delivery.ts` | Continuation event sources and final streaming/buffered bridging; a streamed turn with a `clientEncoder` option is handed to `src/server/inference/client-encoder-delivery.ts` instead of the bridge. |
 
 Reusable helpers live in `core-auth.ts`, `core-codex-account.ts`, `core-combo.ts`,
 `core-combo-failure.ts`, `core-combo-native.ts`, `combo-requested-effort.ts`, `core-errors.ts`, `core-lifetime.ts`, `core-normalize.ts`,
 `core-opaque-recovery.ts` and `core-replay.ts`. `core-options.ts` owns the public option types
-and small composition contracts, including [finite model-refusal evidence](../providers-and-adapters.md#combo-model-refusal-evidence). Existing public helper names are re-exported by `core.ts`. After an admitted Anthropic OAuth pool rotation, `adapter-dispatch.ts` rebinds reasoning replay to the committed credential snapshot; `adapter-continuation.ts` rebinds both its continuation clone and the outer request that persists the response. The replacement send strips the previous account's private state, while persisted ownership and the next turn follow the serving account. Codex alternate-account sends in `core-codex-account.ts` record `oauth-account-429` for quota recovery and `transient-5xx` for transient recovery, preserving the first response's wire status when sealing its attempt; gated-model moves keep their existing unattributed kind.
+and small composition contracts, including [finite model-refusal evidence](../providers-and-adapters.md#combo-model-refusal-evidence). Existing public helper names are re-exported by `core.ts`. After an admitted Anthropic OAuth pool rotation, `adapter-dispatch.ts` rebinds reasoning replay to the committed credential snapshot; `adapter-continuation.ts` rebinds both its continuation clone and the outer request that persists the response. The replacement send strips the previous account's private state, while persisted ownership and the next turn follow the serving account. Codex alternate-account sends in `core-codex-account.ts` record `oauth-account-402` for HTTP 402 quota recovery, `oauth-account-429` for HTTP 429 rate-limit recovery, and `transient-5xx` for transient recovery, preserving the first response's wire status when sealing its attempt; gated-model moves keep their existing unattributed kind.
 Adapter construction remains with the existing registry; `fetch-helpers.ts` remains a leaf. For Kiro OAuth with load settings, `request-transport.ts` acquires a lease on the admitted account and transfers it before a reactive replacement send; cancellation permanently fences the request holder so recovery cannot install a late lease after abort cleanup. `core.ts` and `core-lifetime.ts` release the lease on returned-body completion, error, or cancellation, outside the inner admission `finally`.
 
 Mutable values are not copied across phases. A phase exposes only the values consumed by later
diff --git a/structure/transports/streaming-health.md b/structure/transports/streaming-health.md
index a3a8becb95a..d93dad0b0bb 100644
--- a/structure/transports/streaming-health.md
+++ b/structure/transports/streaming-health.md
@@ -256,6 +256,38 @@ egress. HTTP/SSE fallback retains Bun fetch's own proxy rules, which do not cons
 The endpoint handles `response.create`, ignores `response.processed`, supports warmup
 `generate: false`, and feeds the same request pipeline as HTTP/SSE.
 
+Incoming Responses connections share a 128-socket admission limit. Only when a new upgrade
+finds that limit full, the handler reclaims the least recently used eligible idle connection.
+Message handling and turn completion refresh a monotonic use order; connection age alone
+does not choose the victim. Eligibility requires an open socket, no active turn, no pending
+client tool or approval result, no retained native steering/injection owner, and no buffered
+outbound bytes. A superseded turn remains active until its own cleanup finishes.
+
+Tool and approval identities are tracked across output items and terminal snapshots. Function argument
+and custom-tool input completion also establish waits, correlated through `response.output_item.added`,
+even if EOF precedes the completed item or terminal. An added item with unfinished arguments alone
+establishes no wait. Only matching client or upstream results retire waits, suppressing completion echoes.
+Tracking retains bounded identity hashes; overflow or ambiguous completion identities protect the
+connection until close. A terminal does not make a connection idle while its client tool runs.
+
+The tracker reuses the final route's provider-executed tool classification, including declarations
+injected into the outbound request. `src/server/responses/response-tool-ownership.ts` carries that
+classification with the selected Response through body wrappers; failed combo attempts cannot
+authorize the winning response's calls. Hosted xAI search therefore creates no client-result wait.
+Each admitted ordinary turn starts a fresh returned-result deduplication scope after settling prior
+results, even if its upstream omits `response.created`. Native control keeps same-response echo
+suppression. `tests/responses/ws-capacity-tool-ownership.test.ts` covers these ownership boundaries.
+
+The victim is marked closing before sending close code 1001 with reason
+`Idle Responses connection reclaimed`. Only its ordinary close callback releases the
+admission lease. After requesting closure, the current upgrade immediately attempts reservation once.
+If every socket is protected, the close fails, or the callback has not yet released the lease,
+that upgrade receives the existing HTTP 503 `Codex WebSockets capacity reached` response.
+A later upgrade can acquire the released slot; admission never exceeds the limit. Reclamation
+does not delete saved continuation state; a client can reconnect through the existing upgrade
+and replay path. This policy adds no idle timer or configuration and does not change the
+separate Live/Realtime sockets or upstream connection reuse. Client disconnect releases socket admission independently of upstream cleanup: the eager relay may continue its existing bounded post-cancel drain for up to 15 seconds to observe a real terminal while a replacement socket already completes new work.
+
 Registry-declared per-model compatibility hints (`modelResponsesUpstreamStreaming`) may ask the
 upstream Responses endpoint for bounded JSON on ANY client transport — WebSocket or ordinary
 HTTP/SSE. The bridge reframes that JSON into the same Responses event sequence
diff --git a/tests/adapters/anthropic/anthropic-message-stop-termination.test.ts b/tests/adapters/anthropic/anthropic-message-stop-termination.test.ts
index 0c8f37058fb..b171a63e083 100644
--- a/tests/adapters/anthropic/anthropic-message-stop-termination.test.ts
+++ b/tests/adapters/anthropic/anthropic-message-stop-termination.test.ts
@@ -94,6 +94,7 @@ describe("Anthropic message_stop termination (#6766)", () => {
     try {
       const events = await collect(stream(new Response(turn() + tail), budget, false));
       expect(events).toEqual([
+        { type: "heartbeat", replayUnsafe: true },
         { type: "text_delta", text: "ok" },
         { type: "done", usage, stopReason: "end_turn" },
       ]);
@@ -105,7 +106,8 @@ describe("Anthropic message_stop termination (#6766)", () => {
     const budget = createTranslatorBudget();
     try {
       const events = await collect(stream(new Response(turn() + tail), budget, true));
-      // Raw-byte progress may add heartbeats before the validated terminal.
+      // Raw-byte progress may add harmless heartbeats, but the semantic replay fence survives.
+      expect(events.filter(event => event.type === "heartbeat" && event.replayUnsafe)).toEqual([{ type: "heartbeat", replayUnsafe: true }]);
       expect(events.filter(event => event.type !== "heartbeat")).toEqual([
         { type: "text_delta", text: "ok" },
         { type: "done", usage, stopReason: "end_turn" },
@@ -122,6 +124,7 @@ describe("Anthropic message_stop termination (#6766)", () => {
       const events = await collect(stream(new Response(wire), budget, false));
       expect(events).toEqual([
         { type: "heartbeat" }, { type: "heartbeat" }, { type: "heartbeat" },
+        { type: "heartbeat", replayUnsafe: true },
         { type: "text_delta", text: "ok" },
         { type: "done", usage, stopReason: "end_turn" },
       ]);
@@ -141,7 +144,7 @@ describe("Anthropic message_stop termination (#6766)", () => {
           ? { type: "incomplete", reason: "content_filter", retryable: false,
               message: `upstream ended the turn with stop_reason "${stopReason}"`, usage }
           : { type: "done", stopReason, usage };
-        expect(events).toEqual([{ type: "text_delta", text: "ok" }, expected]);
+        expect(events).toEqual([{ type: "heartbeat", replayUnsafe: true }, { type: "text_delta", text: "ok" }, expected]);
         expectReleased(budget);
       } finally { budget.dispose(); }
     },
@@ -200,7 +203,8 @@ describe("Anthropic message_stop termination (#6766)", () => {
       + frame("message_stop") + frame("ping");
     try {
       const events = await collect(stream(new Response(wire), budget, false));
-      expect(events.map(event => event.type)).toEqual(["tool_call_start", "tool_call_delta", "done"]);
+      expect(events.map(event => event.type)).toEqual(["heartbeat", "tool_call_start", "tool_call_delta", "done"]);
+      expect(events[0]).toEqual({ type: "heartbeat", replayUnsafe: true });
       // Existing behavior does not invent tool_call_end for an unclosed block.
       expect(events.at(-1)).toEqual({ type: "done", usage: undefined, stopReason: "tool_use" });
       expectReleased(budget);
@@ -213,6 +217,7 @@ describe("Anthropic message_stop termination (#6766)", () => {
       content_block: { type: "tool_use", id: "call_cancel", name: "web_search" } }));
     const iterator = stream(upstream.response, budget, false);
     try {
+      expect((await iterator.next()).value).toEqual({ type: "heartbeat", replayUnsafe: true });
       expect((await iterator.next()).value?.type).toBe("tool_call_start");
       expect(budget.snapshot().activeCalls).toBe(1);
       await iterator.return(undefined);
@@ -231,7 +236,8 @@ describe("Anthropic message_stop termination (#6766)", () => {
       + frame("message_stop") + frame("ping");
     try {
       const events = await collect(stream(new Response(wire), budget, false));
-      expect(events.map(event => event.type)).toEqual(["tool_call_start", "error"]);
+      expect(events.map(event => event.type)).toEqual(["heartbeat", "tool_call_start", "error"]);
+      expect(events[0]).toEqual({ type: "heartbeat", replayUnsafe: true });
       expect(events.at(-1)).toMatchObject({ type: "error", status: 502,
         errorType: "upstream_error", code: "translation_buffer_limit" });
       expectReleased(budget, 1);
diff --git a/tests/adapters/anthropic/anthropic-progress-updates.test.ts b/tests/adapters/anthropic/anthropic-progress-updates.test.ts
index b02d8adf70e..b349743c45b 100644
--- a/tests/adapters/anthropic/anthropic-progress-updates.test.ts
+++ b/tests/adapters/anthropic/anthropic-progress-updates.test.ts
@@ -25,6 +25,7 @@ async function eventsFor(blocks: Record<string, unknown>[], streaming: boolean,
   const adapter = withTestTranslatorBudget(createAnthropicAdapter({ ...provider, baseUrl }, "none"));
   const request = await adapter.buildRequest(parseRequest({ model, input: "question", reasoning: { effort: "high" } }));
   const events: AdapterEvent[] = [];
+  let wireResponse: Response | undefined;
   if (streaming) {
     const frames = blocks.flatMap((block, index) => [
       frame("content_block_start", { index, content_block: block.type === "thinking" ? { type: "thinking", thinking: "", signature: "" } : block }),
@@ -36,11 +37,12 @@ async function eventsFor(blocks: Record<string, unknown>[], streaming: boolean,
       frame("content_block_stop", { index }),
     ]);
     frames.push(frame("message_delta", { delta: { stop_reason: "tool_use" } }), frame("message_stop"));
-    for await (const event of adapter.parseStream(new Response(frames.join("")))) events.push(event);
+    wireResponse = new Response(frame("message_start", { message: { content: [] } }) + frames.join(""));
+    for await (const event of adapter.parseStream(wireResponse.clone())) events.push(event);
   } else {
     events.push(...await adapter.parseResponse!(new Response(JSON.stringify({ content: blocks, stop_reason: "tool_use" }))));
   }
-  return { adapter, request, events };
+  return { adapter, request, events, wireResponse };
 }
 
 for (const streaming of [false, true]) {
@@ -195,7 +197,7 @@ test("internal terminal continuation replays signed progress instead of unsigned
 
 for (const streamRoutedModelOutput of [false, true]) test(`hosted search displays signed commentary once and retains replay (live=${streamRoutedModelOutput})`, async () => {
   const search = { ...tool, name: "web_search", input: { query: "docs" } };
-  const { adapter, events } = await eventsFor([empty, redacted, update, search], true);
+  const { adapter, wireResponse } = await eventsFor([empty, redacted, update, search], true);
   let pass = 0;
   let replay: unknown;
   const fetchSpy = spyOn(globalThis, "fetch").mockImplementation(async () => new Response(
@@ -205,18 +207,19 @@ for (const streamRoutedModelOutput of [false, true]) test(`hosted search display
   ));
   try {
     const response = await runWithWebSearch({
-      parsed: parseRequest({ model, input: "look up docs", stream: true, tools: [{ type: "web_search" }] }),
+      parsed: parseRequest({ model, input: "look up docs", stream: true, reasoning: { effort: "high" }, tools: [{ type: "web_search" }] }),
       adapter: { ...adapter,
         async buildRequest(parsed, meta) {
           const request = await adapter.buildRequest(parsed, meta);
           replay = JSON.parse(request.body as string).messages;
           return request;
         },
-        fetchResponse: async () => new Response("synthetic"),
-        async *parseStream() {
-          if (pass++ === 0) yield* events;
-          else { yield { type: "text_delta", text: "Final answer." }; yield { type: "done" }; }
-        },
+        fetchResponse: async () => pass++ === 0 ? wireResponse!.clone() : new Response(
+          frame("message_start", { message: { content: [] } })
+          + frame("content_block_start", { index: 0, content_block: { type: "text", text: "" } })
+          + frame("content_block_delta", { index: 0, delta: { type: "text_delta", text: "Final answer." } })
+          + frame("content_block_stop", { index: 0 })
+          + frame("message_delta", { delta: { stop_reason: "end_turn" } }) + frame("message_stop")),
       },
       incomingMeta: { headers: new Headers(), translatorBudget: createTestTranslatorBudget() },
       forwardProvider: { adapter: "openai-responses", baseUrl: "https://sidecar.invalid", authMode: "forward" },
diff --git a/tests/adapters/anthropic/anthropic-replay.test.ts b/tests/adapters/anthropic/anthropic-replay.test.ts
new file mode 100644
index 00000000000..1b865777048
--- /dev/null
+++ b/tests/adapters/anthropic/anthropic-replay.test.ts
@@ -0,0 +1,110 @@
+import { test, expect } from "bun:test";
+import { createTranslatorBudget } from "../../../src/lib/translator-budget";
+import { createAnthropicAdapter } from "../../../src/adapters/anthropic";
+import {
+  enableAnthropicReplayCapture, createAnthropicReplayCapture, takeAnthropicReplay,
+  bindAnthropicReplay, anthropicReplayContent,
+} from "../../../src/adapters/anthropic-replay";
+
+function start(limit = 100_000) {
+  const response = new Response();
+  const budget = createTranslatorBudget({ maxTurnBytes: limit });
+  const cleanup = enableAnthropicReplayCapture(response);
+  const capture = createAnthropicReplayCapture(response, budget)!;
+  capture.accept({ type: "message_start" });
+  capture.accept({ type: "content_block_start", index: 0, content_block: { type: "text", text: "initial" } });
+  return { budget, capture, cleanup };
+}
+function complete(capture: ReturnType<typeof start>["capture"]) {
+  capture.accept({ type: "content_block_stop", index: 0 });
+  capture.accept({ type: "message_stop" });
+  const done = { type: "done" } as const;
+  capture.finish(done);
+  return done;
+}
+
+test("capture cancellation releases retained bytes idempotently", () => {
+  const { budget, capture, cleanup } = start();
+  expect(budget.snapshot().currentBytes).toBeGreaterThan(0);
+  capture.discard(); cleanup(); capture.discard();
+  expect(budget.snapshot().currentBytes).toBe(0);
+});
+test("invalid index releases bytes and cannot issue a snapshot", () => {
+  const { budget, capture, cleanup } = start();
+  capture.accept({ type: "content_block_stop", index: 9 });
+  expect(takeAnthropicReplay(complete(capture))).toBeUndefined();
+  cleanup();
+  expect(budget.snapshot().currentBytes).toBe(0);
+});
+test("response cleanup releases an unclaimed complete snapshot", () => {
+  const { budget, capture, cleanup } = start();
+  complete(capture); capture.discard();
+  expect(budget.snapshot().currentBytes).toBeGreaterThan(0);
+  cleanup();
+  expect(budget.snapshot().currentBytes).toBe(0);
+});
+test("claim transfers ownership until release; external and expired snapshots are refused", () => {
+  const { budget, capture, cleanup } = start();
+  const snapshot = takeAnthropicReplay(complete(capture))!;
+  const message = { role: "assistant", content: [], timestamp: 0 } as const;
+  const mutableMessage = { ...message, content: [] };
+  bindAnthropicReplay(mutableMessage, snapshot);
+  expect(anthropicReplayContent(mutableMessage)).toEqual([{ type: "text", text: "initial" }]);
+  expect(() => bindAnthropicReplay(mutableMessage, { content: [], release() {} })).toThrow();
+  cleanup(); capture.discard();
+  expect(budget.snapshot().currentBytes).toBeGreaterThan(0);
+  snapshot.release(); snapshot.release();
+  expect(budget.snapshot().currentBytes).toBe(0);
+  expect(() => bindAnthropicReplay(mutableMessage, snapshot)).toThrow();
+  expect(() => anthropicReplayContent(mutableMessage)).toThrow();
+});
+test("budget overflow invalidates optional capture without throwing or refunding other owners", () => {
+  const { budget, capture, cleanup } = start(1_000);
+  budget.chargeRetained(100, { kind: "retained_collectors" });
+  expect(() => capture.accept({ type: "content_block_delta", index: 0,
+    delta: { type: "text_delta", text: "x".repeat(2_000) } })).not.toThrow();
+  expect(takeAnthropicReplay(complete(capture))).toBeUndefined();
+  expect(budget.snapshot().currentBytes).toBe(100);
+  capture.discard(); cleanup();
+  expect(budget.snapshot().currentBytes).toBe(100);
+  budget.releaseRetained(100, { kind: "retained_collectors" });
+  expect(budget.snapshot().currentBytes).toBe(0);
+  budget.dispose();
+});
+
+test("finish reservation pressure invalidates capture and preserves foreign retained bytes", () => {
+  const { budget, capture, cleanup } = start(1_000);
+  budget.chargeRetained(500, { kind: "retained_collectors" });
+  let done: ReturnType<typeof complete> | undefined;
+  expect(() => { done = complete(capture); }).not.toThrow();
+  expect(takeAnthropicReplay(done!)).toBeUndefined();
+  expect(budget.snapshot().currentBytes).toBe(500);
+  cleanup();
+  budget.releaseRetained(500, { kind: "retained_collectors" });
+  expect(budget.snapshot().currentBytes).toBe(0);
+  budget.dispose();
+});
+
+test("optional capture pressure does not replace a healthy adapter terminal", async () => {
+  const budget = createTranslatorBudget({ maxTurnBytes: 6_000 });
+  const adapter = createAnthropicAdapter({ adapter: "anthropic", baseUrl: "https://synthetic.invalid", apiKey: "synthetic" });
+  const text = "x".repeat(1_000);
+  const response = new Response([
+    { type: "message_start", message: { content: [] } },
+    { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } },
+    { type: "content_block_delta", index: 0, delta: { type: "text_delta", text } },
+    { type: "content_block_stop", index: 0 },
+    { type: "message_stop" },
+  ].map(data => `event: ${data.type}\ndata: ${JSON.stringify(data)}\n\n`).join(""));
+  const cleanup = enableAnthropicReplayCapture(response);
+  try {
+    const events = [];
+    for await (const event of adapter.parseStream(response, budget)) events.push(event);
+    expect(events.filter(event => event.type === "error")).toEqual([]);
+    expect(events.some(event => event.type === "text_delta" && event.text === text)).toBe(true);
+    expect(events.at(-1)?.type).toBe("done");
+    expect(takeAnthropicReplay(events.at(-1)!)).toBeUndefined();
+    expect(budget.snapshot().overflows).toBeGreaterThan(0);
+    expect(budget.snapshot().currentBytes).toBe(0);
+  } finally { cleanup(); budget.dispose(); }
+});
diff --git a/tests/adapters/anthropic/anthropic-sidecar-account-failover.test.ts b/tests/adapters/anthropic/anthropic-sidecar-account-failover.test.ts
index f0504412a53..d80477ea2f7 100644
--- a/tests/adapters/anthropic/anthropic-sidecar-account-failover.test.ts
+++ b/tests/adapters/anthropic/anthropic-sidecar-account-failover.test.ts
@@ -71,14 +71,14 @@ beforeAll(async () => {
       parsed: OcxParsedRequest;
       adapter: ProviderAdapter;
       incomingMeta: IncomingMeta;
-      fetchForRequest: (request: AdapterRequest, parsed: OcxParsedRequest) => typeof fetch;
+      fetchForRequest: (request: AdapterRequest, parsed: OcxParsedRequest, adapter: ProviderAdapter) => typeof fetch;
       on429?: (retryAfter: string | null, headers: Headers, parsed: OcxParsedRequest, response: Response) => Promise<
         { adapter: ProviderAdapter; recoveryKind: AttemptRecoveryKind } | null
       >;
     }) => {
       // This is a dispatch seam test. The real loop is covered in anthropic-quota-dispatch.
       const first = await args.adapter.buildRequest(args.parsed, args.incomingMeta);
-      const refused = await args.fetchForRequest(first, args.parsed)(first.url, {
+      const refused = await args.fetchForRequest(first, args.parsed, args.adapter)(first.url, {
         method: first.method, headers: first.headers, body: first.body,
       });
       expect(refused.status).toBe(429);
@@ -91,7 +91,7 @@ beforeAll(async () => {
       // proven end to end rather than against a hand-written stub.
       expect(rotated.recoveryKind).toBe("anthropic-oauth-429");
       const second = await rotated.adapter.buildRequest(args.parsed, args.incomingMeta);
-      return args.fetchForRequest(second, args.parsed)(second.url, {
+      return args.fetchForRequest(second, args.parsed, rotated.adapter)(second.url, {
         method: second.method, headers: second.headers, body: second.body,
       });
     },
diff --git a/tests/adapters/google/gemini-progress-history.test.ts b/tests/adapters/google/gemini-progress-history.test.ts
new file mode 100644
index 00000000000..afad0fd6614
--- /dev/null
+++ b/tests/adapters/google/gemini-progress-history.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import { createGoogleAdapter as createGoogleAdapterProduction } from "../../../src/adapters/google";
+import { geminiProgressLead } from "../../../src/adapters/google-progress-history";
+import { ANTIGRAVITY_MODEL_EFFORTS } from "../../../src/providers/antigravity-models";
+import type { OcxParsedRequest, OcxProviderConfig } from "../../../src/types";
+import { withTestTranslatorBudget } from "../../helpers/translator-budget";
+
+// Shape of a live Gemini 4 Argon tool turn (2026-10-17): a progress line in the user's language
+// with the model's planning appended as ordinary, unmarked text. Replayed whole, later turns
+// copied the tail; replayed as the lead sentence, they did not.
+const LEAKED = "앞선 배치에서 잘린 google.ts를 마저 읽겠습니다. Let's read google.ts 580-1700 first.";
+const LEAD = "앞선 배치에서 잘린 google.ts를 마저 읽겠습니다.";
+
+const antigravity = {
+  adapter: "google", baseUrl: "https://daily-cloudcode-pa.googleapis.com", googleMode: "cloud-code-assist",
+  project: "proj-123", apiKey: "ya29.token", modelReasoningEfforts: ANTIGRAVITY_MODEL_EFFORTS,
+} as OcxProviderConfig;
+const aiStudio = { adapter: "google", baseUrl: "https://generativelanguage.googleapis.com/v1beta", apiKey: "k" } as OcxProviderConfig;
+
+function history(phase?: "commentary" | "final_answer"): OcxParsedRequest["context"]["messages"] {
+  return [
+    { role: "user", content: "google.ts를 읽어줘" },
+    { role: "assistant", ...(phase ? { phase } : {}), content: [
+      { type: "text", text: LEAKED },
+      { type: "text", text: "Maybe the classifier is wrong." },
+      { type: "toolCall", id: "call_1", name: "exec", arguments: { cmd: "cat google.ts" } },
+      { type: "text", text: "After the call. Kept whole." },
+    ] },
+    { role: "toolResult", toolCallId: "call_1", toolName: "exec", content: [{ type: "text", text: "ok" }] },
+    { role: "assistant", content: [{ type: "text", text: "Final answer. It keeps every sentence." }] },
+    { role: "user", content: "계속" },
+  ] as unknown as OcxParsedRequest["context"]["messages"];
+}
+
+async function modelTexts(provider: OcxProviderConfig, modelId: string, phase?: "commentary" | "final_answer"): Promise<string[][]> {
+  const parsed = {
+    modelId, stream: false, options: {},
+    context: { messages: history(phase), systemPrompt: [], tools: [] },
+  } as unknown as OcxParsedRequest;
+  const req = await withTestTranslatorBudget(createGoogleAdapterProduction(provider)).buildRequest(parsed);
+  const body = JSON.parse(req.body);
+  const contents = (body.request ?? body).contents as Array<{ role: string; parts: Array<{ text?: string }> }>;
+  return contents.filter(c => c.role === "model")
+    .map(c => c.parts.filter(p => typeof p.text === "string").map(p => p.text!));
+}
+
+describe("Gemini progress-text history", () => {
+  test("Argon tool turns replay only the lead sentence before the call; final answers stay whole", async () => {
+    expect(await modelTexts(antigravity, "gemini-4-argon")).toEqual([
+      [LEAD, "After the call. Kept whole."], ["Final answer. It keeps every sentence."],
+    ]);
+    expect(await modelTexts(antigravity, "gemini-4-argon", "commentary")).toEqual([
+      [LEAD, "After the call. Kept whole."], ["Final answer. It keeps every sentence."],
+    ]);
+  });
+
+  test("a turn Codex marks final_answer is replayed whole", async () => {
+    expect(await modelTexts(antigravity, "gemini-4-argon", "final_answer")).toEqual([
+      [LEAKED, "Maybe the classifier is wrong.", "After the call. Kept whole."], ["Final answer. It keeps every sentence."],
+    ]);
+  });
+
+  test("AI Studio Gemini gets the same history", async () => {
+    expect(await modelTexts(aiStudio, "gemini-3.5-flash")).toEqual([
+      [LEAD, "After the call. Kept whole."], ["Final answer. It keeps every sentence."],
+    ]);
+  });
+
+  test("Claude on Antigravity keeps its full progress text", async () => {
+    expect(await modelTexts(antigravity, "claude-sonnet-5-5")).toEqual([
+      [LEAKED, "Maybe the classifier is wrong.", "After the call. Kept whole."], ["Final answer. It keeps every sentence."],
+    ]);
+  });
+
+  test("the lead split is punctuation-based and language-neutral", () => {
+    expect(geminiProgressLead("Reading the adapter now! Wait, maybe the encoder too.")).toBe("Reading the adapter now!");
+    expect(geminiProgressLead("1. Read google.ts next.\n2. Then the encoder.")).toBe("1. Read google.ts next.");
+    expect(geminiProgressLead("google.ts와 chat.ts를 읽겠습니다")).toBe("google.ts와 chat.ts를 읽겠습니다");
+    expect(geminiProgressLead("次に google.ts を読みます。Let's go.")).toBe("次に google.ts を読みます。");
+    expect(geminiProgressLead("Done. Let's read google.ts next.")).toBe("Done.");
+    expect(geminiProgressLead("確認します。Let's inspect the encoder next.")).toBe("確認します。");
+    expect(geminiProgressLead("मैं फ़ाइल पढ़ूँगा। Let's read google.ts next.")).toBe("मैं फ़ाइल पढ़ूँगा।");
+    expect(geminiProgressLead("سأقرأ الملف۔ Let's read google.ts next.")).toBe("سأقرأ الملف۔");
+    expect(geminiProgressLead("Reading **the docs.** Let's inspect the encoder next.")).toBe("Reading **the docs.**");
+    expect(geminiProgressLead("Check e.g. the 3.5 encoder first. Then more.")).toBe("Check e.g. the 3.5 encoder first.");
+    expect(geminiProgressLead("  \n ")).toBeUndefined();
+    expect(geminiProgressLead("```js\nconst x = 1;\n```")).toBeUndefined();
+  });
+});
diff --git a/tests/adapters/reasoning-replay-identity.test.ts b/tests/adapters/reasoning-replay-identity.test.ts
index a63d63555fd..4472d920fc3 100644
--- a/tests/adapters/reasoning-replay-identity.test.ts
+++ b/tests/adapters/reasoning-replay-identity.test.ts
@@ -1,3 +1,6 @@
+import { anthropicOpaqueFingerprint, captureAnthropicRejectionPayloads, bindAnthropicRejectionResponse, rejectedAnthropicPayloads } from "../../src/adapters/anthropic-rejection-memo";
+import { createTranslatorBudget } from "../../src/lib/translator-budget";
+import type { AdapterRequest } from "../../src/adapters/base";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { bridgeToResponsesSSE } from "../../src/bridge";
 import {
@@ -5,6 +8,7 @@ import {
   clearReasoningReplayCacheForTests,
   commitReasoningReplayServingIdentity,
   durableReplayCredentialIdentity,
+  getReasoningReplayOpaqueBlobRejection,
   peekReasoningForCall,
   reasoningReplayCodexCredentialIdentity,
   reasoningReplayCredentialIdentity,
@@ -401,3 +405,202 @@ describe("reasoning replay provider and credential identity", () => {
     expect(peekReasoningForCall(CALL_ID, holder)).toBe("new reasoning");
   });
 });
+
+
+describe("selective opaque-blob rejection memos", () => {
+  const digest = (index: number): string => index.toString(16).padStart(64, "0");
+  const fingerprints = (count: number): Set<string> => new Set(Array.from({ length: count }, (_, index) => digest(index)));
+  beforeEach(() => clearReasoningReplayCacheForTests());
+  afterEach(() => clearReasoningReplayCacheForTests());
+
+  test("distinguishes absent, selective and sticky blanket memos while preserving the boolean API", () => {
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toBeUndefined();
+    expect(reasoningReplayOpaqueBlobRejectionMemoized(scope())).toBe(false);
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(1)]));
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "selective", fingerprints: new Set([digest(1)]) });
+    expect(reasoningReplayOpaqueBlobRejectionMemoized(scope())).toBe(true);
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(1), digest(2)]));
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "selective", fingerprints: new Set([digest(1), digest(2)]) });
+    rememberReasoningReplayOpaqueBlobRejection(scope());
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "blanket" });
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(3)]));
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "blanket" });
+  });
+
+  test("allows 256 distinct digests but falls back to blanket when a merge or one input overflows", () => {
+    rememberReasoningReplayOpaqueBlobRejection(scope(), fingerprints(256));
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "selective", fingerprints: fingerprints(256) });
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(255)]));
+    expect(getReasoningReplayOpaqueBlobRejection(scope())?.mode).toBe("selective");
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(256)]));
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "blanket" });
+    const other = { ...scope(), clientThreadId: "overflow-input" };
+    rememberReasoningReplayOpaqueBlobRejection(other, fingerprints(257));
+    expect(getReasoningReplayOpaqueBlobRejection(other)).toEqual({ mode: "blanket" });
+  });
+
+  test.each([
+    new Set(), new Set(["a".repeat(63)]), new Set(["A".repeat(64)]),
+    new Set(["a".repeat(64) + "\n"]), new Set(["g".repeat(64)]), new Set([null]),
+    null, ["a".repeat(64)], { size: 1, [Symbol.iterator]() { throw new Error("untrusted iterator"); } },
+  ].map(value => ({ value })))("invalid or unreliable fingerprint input falls back without throwing: %j", ({ value }) => {
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(1)]));
+    expect(() => rememberReasoningReplayOpaqueBlobRejection(scope(), value as ReadonlySet<string>)).not.toThrow();
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "blanket" });
+  });
+
+  test("caller-owned input and getter output cannot mutate retained fingerprints", () => {
+    const input = new Set([digest(1)]);
+    rememberReasoningReplayOpaqueBlobRejection(scope(), input);
+    input.clear(); input.add("invalid");
+    const observed = getReasoningReplayOpaqueBlobRejection(scope());
+    expect(observed).toEqual({ mode: "selective", fingerprints: new Set([digest(1)]) });
+    if (observed?.mode !== "selective") throw new Error("selective memo missing");
+    (observed.fingerprints as Set<string>).clear();
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "selective", fingerprints: new Set([digest(1)]) });
+  });
+
+  test("uses durable scope dimensions, ignores volatile generations and refuses incomplete scopes", () => {
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(1)]));
+    expect(getReasoningReplayOpaqueBlobRejection(scope({ credentialIdentity: "new-process-token" }))?.mode).toBe("selective");
+    for (const changed of [
+      { ...scope(), clientThreadId: "different-thread" }, scope({ providerName: "different-provider" }),
+      scope({ providerDestinationDurableIdentity: "different-destination" }), scope({ adapterName: "anthropic" }),
+      scope({ modelId: "different-model" }), scope({ credentialDurableIdentity: "different-credential" }),
+    ]) expect(getReasoningReplayOpaqueBlobRejection(changed)).toBeUndefined();
+    for (const incomplete of [undefined, scope({ credentialDurableIdentity: undefined }), scope({ providerDestinationDurableIdentity: undefined })]) {
+      rememberReasoningReplayOpaqueBlobRejection(incomplete, new Set([digest(1)]));
+      expect(getReasoningReplayOpaqueBlobRejection(incomplete)).toBeUndefined();
+    }
+  });
+
+  test("reads do not refresh five-minute expiry, expired memos do not merge, and clear resets both APIs", () => {
+    let clock = 1000;
+    clearReasoningReplayCacheForTests(() => clock);
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(1)]));
+    clock += 5 * 60 * 1000 - 1;
+    expect(getReasoningReplayOpaqueBlobRejection(scope())?.mode).toBe("selective");
+    clock += 1;
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toBeUndefined();
+    expect(reasoningReplayOpaqueBlobRejectionMemoized(scope())).toBe(false);
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(2)]));
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "selective", fingerprints: new Set([digest(2)]) });
+    rememberReasoningReplayOpaqueBlobRejection(scope());
+    clock += 5 * 60 * 1000;
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(3)]));
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "selective", fingerprints: new Set([digest(3)]) });
+    clearReasoningReplayCacheForTests();
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toBeUndefined();
+    expect(reasoningReplayOpaqueBlobRejectionMemoized(scope())).toBe(false);
+  });
+
+  test("merging refreshes the existing expiry without losing earlier selective digests", () => {
+    let clock = 1000;
+    clearReasoningReplayCacheForTests(() => clock);
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(1)]));
+    clock += 200_000;
+    rememberReasoningReplayOpaqueBlobRejection(scope(), new Set([digest(2)]));
+    clock += 100_000;
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "selective", fingerprints: new Set([digest(1), digest(2)]) });
+    clock += 200_000;
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toBeUndefined();
+  });
+
+  test("fingerprint bytes participate in the existing 256 KiB oldest-entry eviction", () => {
+    let clock = 1000;
+    clearReasoningReplayCacheForTests(() => clock);
+    for (let index = 0; index < 16; index++) {
+      rememberReasoningReplayOpaqueBlobRejection({ ...scope(), clientThreadId: `byte-thread-${index}` }, fingerprints(256));
+      clock++;
+    }
+    expect(getReasoningReplayOpaqueBlobRejection({ ...scope(), clientThreadId: "byte-thread-0" })).toBeUndefined();
+    expect(getReasoningReplayOpaqueBlobRejection({ ...scope(), clientThreadId: "byte-thread-1" })?.mode).toBe("selective");
+    expect(getReasoningReplayOpaqueBlobRejection({ ...scope(), clientThreadId: "byte-thread-15" })?.mode).toBe("selective");
+  });
+
+  test("replacing a selective memo with blanket releases its retained fingerprint bytes", () => {
+    let clock = 1000;
+    clearReasoningReplayCacheForTests(() => clock);
+    rememberReasoningReplayOpaqueBlobRejection(scope(), fingerprints(256));
+    rememberReasoningReplayOpaqueBlobRejection(scope());
+    for (let index = 0; index < 15; index++) {
+      clock++;
+      rememberReasoningReplayOpaqueBlobRejection({ ...scope(), clientThreadId: `byte-thread-${index}` }, fingerprints(256));
+    }
+    expect(getReasoningReplayOpaqueBlobRejection(scope())).toEqual({ mode: "blanket" });
+    expect(getReasoningReplayOpaqueBlobRejection({ ...scope(), clientThreadId: "byte-thread-0" })?.mode).toBe("selective");
+  });
+
+  test("falls back to the old blanket entry when a valid set cannot fit beside a near-limit key", () => {
+    const current = scope().current!;
+    const identity = JSON.stringify([current.providerName, current.providerDestinationDurableIdentity, current.adapterName, current.modelId, current.credentialDurableIdentity]);
+    const overhead = Buffer.byteLength(JSON.stringify(["", identity]));
+    const nearLimit = { ...scope(), clientThreadId: "t".repeat(256 * 1024 - overhead - 1) };
+    rememberReasoningReplayOpaqueBlobRejection(nearLimit, new Set([digest(1)]));
+    expect(getReasoningReplayOpaqueBlobRejection(nearLimit)).toEqual({ mode: "blanket" });
+  });
+});
+
+describe("actual Anthropic rejection capture", () => {
+  const body = (count: number) => ({ messages: [{ role: "assistant", content: Array.from({ length: count }, (_, index) => ({ type: "thinking", signature: `SyntheticCapture${index}` })) }] });
+  test("fingerprints exclude text and metadata and separate opaque domains", () => {
+    const signature = "SyntheticOpaqueBytes";
+    expect(anthropicOpaqueFingerprint({ type: "thinking", signature, thinking: "before", ap: "original" }))
+      .toBe(anthropicOpaqueFingerprint({ type: "thinking", signature, thinking: "after", ap: "forged" }));
+    expect(anthropicOpaqueFingerprint({ type: "thinking", signature }))
+      .not.toBe(anthropicOpaqueFingerprint({ type: "redacted_thinking", data: signature }));
+  });
+  test("complete capture is bounded, charged until disposal, and defensively copied", () => {
+    const budget = createTranslatorBudget();
+    const request = {} as AdapterRequest;
+    const response = new Response(null, { status: 400 });
+    try {
+      captureAnthropicRejectionPayloads(request, body(256), budget);
+      bindAnthropicRejectionResponse(request, response);
+      expect(budget.snapshot().currentBytes).toBe(256 * 256);
+      expect(rejectedAnthropicPayloads(response)?.size).toBe(256);
+      (rejectedAnthropicPayloads(response) as Set<string>).clear();
+      expect(rejectedAnthropicPayloads(response)?.size).toBe(256);
+    } finally { budget.dispose(); }
+    expect(budget.snapshot().currentBytes).toBe(0);
+  });
+  test("overflow and missing budget never narrow the rejection policy", () => {
+    const budget = createTranslatorBudget();
+    const request = {} as AdapterRequest;
+    const response = new Response(null, { status: 400 });
+    try {
+      captureAnthropicRejectionPayloads(request, body(257), budget);
+      bindAnthropicRejectionResponse(request, response);
+      expect(rejectedAnthropicPayloads(response)).toBeUndefined();
+      expect(budget.snapshot().currentBytes).toBe(0);
+      captureAnthropicRejectionPayloads(request, body(1));
+      bindAnthropicRejectionResponse(request, response);
+      expect(rejectedAnthropicPayloads(response)).toBeUndefined();
+    } finally { budget.dispose(); }
+  });
+  test("admission failure refunds only admitted digests", () => {
+    const budget = createTranslatorBudget({ maxTurnBytes: 600 });
+    budget.chargeRetained(123, { kind: "reasoning" });
+    const request = {} as AdapterRequest;
+    const response = new Response(null, { status: 400 });
+    try {
+      captureAnthropicRejectionPayloads(request, body(2), budget);
+      bindAnthropicRejectionResponse(request, response);
+      expect(rejectedAnthropicPayloads(response)).toBeUndefined();
+      expect(budget.snapshot().currentBytes).toBe(123);
+    } finally { budget.dispose(); }
+  });
+  test("failed recapture clears stale request and response ownership", () => {
+    const budget = createTranslatorBudget();
+    const request = {} as AdapterRequest;
+    const response = new Response(null, { status: 400 });
+    try {
+      captureAnthropicRejectionPayloads(request, body(1), budget);
+      bindAnthropicRejectionResponse(request, response);
+      expect(rejectedAnthropicPayloads(response)?.size).toBe(1);
+      captureAnthropicRejectionPayloads(request, { messages: [{ content: null }] }, budget);
+      bindAnthropicRejectionResponse(request, response);
+      expect(rejectedAnthropicPayloads(response)).toBeUndefined();
+    } finally { budget.dispose(); }
+  });
+});
diff --git a/tests/claude-integration/claude-translated-server-tools.test.ts b/tests/claude-integration/claude-translated-server-tools.test.ts
index 75e45c572cf..005cebd1517 100644
--- a/tests/claude-integration/claude-translated-server-tools.test.ts
+++ b/tests/claude-integration/claude-translated-server-tools.test.ts
@@ -3,6 +3,7 @@ import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createAnthropicAdapter } from "../../src/adapters/anthropic";
+import { webSearchPairFromItem } from "../../src/claude/outbound";
 import { handleClaudeMessages } from "../../src/server/claude-messages";
 import type { OcxConfig, OcxParsedRequest, OcxProviderConfig } from "../../src/types";
 import { acquireOwnedSpendHome } from "../helpers/owned-spend-home";
@@ -168,11 +169,40 @@ describe("server-side search across responses", () => {
     expect(blockStarts(clientSse).map(b => b.type)).toEqual(["tool_use"]);
   });
 
-  test("a result whose call came in an earlier response still reaches the client by its tool_use_id", async () => {
-    const { clientSse } = await claudeTurn("https://api.anthropic.com", [MESSAGE_START, ...SEARCH_TURN.slice(5, 10), ...MESSAGE_END]);
-    const starts = blockStarts(clientSse);
-    expect(starts.map(b => b.type)).toEqual(["server_tool_use", "web_search_tool_result", "text"]);
-    expect(starts[1]).toMatchObject({ tool_use_id: starts[0]!.id, content: [{ type: "web_search_result", url: "https://bun.sh/blog" }] });
+  test("an orphan result with a unique anchor never synthesizes or replays a server call", async () => {
+    const mismatched = SEARCH_TURN.map(f => f.type === "content_block_start" && f.index === 1
+      ? { ...f, content_block: { ...(f.content_block as Record<string, unknown>), tool_use_id: "srvtoolu_orphan" } } : f);
+    const truncated = SEARCH_TURN.map((f, i) => i === 2
+      ? { ...f, delta: { type: "input_json_delta", partial_json: `{"query":"${"x".repeat(4096)}` } } : f);
+    for (const frames of [
+      [MESSAGE_START, ...SEARCH_TURN.slice(5, 10), ...MESSAGE_END],
+      [MESSAGE_START, ...fetchTurn(FETCH_RESULT).slice(4)],
+      mismatched,
+      truncated,
+    ]) {
+      const turn = clientContent((await claudeTurn("https://api.anthropic.com", frames)).clientSse);
+      const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", [
+        { role: "user", content: "Search" }, { role: "assistant", content: turn }, { role: "user", content: "More?" },
+      ]);
+      const messages = wire.messages as { content: Record<string, unknown>[] }[];
+      expect(messages[1]!.content).toEqual([{ type: "text", text: "Bun shipped." }]);
+      expect(JSON.stringify(messages)).not.toContain("server_tool_use");
+      expect(JSON.stringify(messages)).not.toContain("web_search_tool_result");
+      expect(JSON.stringify(messages)).not.toContain("web_fetch_tool_result");
+      expect(turn).toEqual([{ type: "text", text: "Bun shipped." }]);
+    }
+  });
+
+  test("a single input fragment past 4 KiB drops its unprovable exchange at the cap", async () => {
+    const query = "q".repeat(5000);
+    const { clientSse } = await claudeTurn("https://api.anthropic.com", [
+      ...SEARCH_TURN.slice(0, 2),
+      { type: "content_block_delta", index: 0, delta: { type: "input_json_delta", partial_json: JSON.stringify({ query }) } },
+      ...SEARCH_TURN.slice(4),
+    ]);
+    expect(blockStarts(clientSse)).toEqual([{ type: "text", text: "" }]);
+    expect(clientContent(clientSse)).toEqual([{ type: "text", text: "Bun shipped." }]);
+    expect(clientSse).not.toContain(query);
   });
 
   test("a replayed search pair without encrypted_content never reaches Anthropic", async () => {
@@ -249,3 +279,206 @@ describe("anthropic adapter: typed web tools beside function tools", () => {
     expect(tools.map(t => t.type ?? "function")).toEqual(["function", "web_fetch_20250910"]);
   });
 });
+
+/** The client's content blocks rebuilt from its SSE, as Claude Code stores them for the next turn. */
+function clientContent(clientSse: string): Record<string, unknown>[] {
+  const blocks: Record<string, unknown>[] = [];
+  const inputs: string[] = [];
+  for (const f of clientFrames(clientSse)) {
+    const i = f.index as number;
+    const delta = f.delta as Record<string, string> | undefined;
+    if (f.type === "content_block_start") blocks[i] = { ...(f.content_block as Record<string, unknown>) };
+    else if (delta?.type === "input_json_delta") inputs[i] = (inputs[i] ?? "") + delta.partial_json;
+    else if (delta?.type === "text_delta") blocks[i]!.text = String(blocks[i]!.text) + delta.text;
+  }
+  return blocks.map((b, i) => inputs[i] ? { ...b, input: JSON.parse(inputs[i]!) } : b);
+}
+
+describe("a server-tool exchange the client replays reaches Anthropic in place", () => {
+  const followUp = (assistant: unknown[], next: unknown = "More?") => [
+    { role: "user", content: "What did Bun release?" }, { role: "assistant", content: assistant }, { role: "user", content: next },
+  ];
+
+  test("web_search pair before text: original srvtoolu_ id and encrypted_content, only to api.anthropic.com", async () => {
+    const turn1 = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse);
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", followUp(turn1));
+    const content = (wire.messages as { content: Record<string, unknown>[] }[])[1]!.content;
+    expect(content.slice(0, 2)).toEqual([
+      { type: "server_tool_use", id: "srvtoolu_1", name: "web_search", input: { query: "bun release" } },
+      SEARCH_TURN[5]!.content_block as Record<string, unknown>,
+    ]);
+    expect(content[2]).toMatchObject({ type: "text", text: "Bun shipped." });
+    expect(content).toHaveLength(3);
+    for (const [baseUrl, target] of [["https://compat.example.com", "anth"], ["https://api.anthropic.com", "gpt"]] as const) {
+      const other = JSON.stringify((await claudeTurn(baseUrl, OK_TURN, target, followUp(turn1))).wire);
+      expect(other).not.toContain("srvtoolu_1");
+      expect(other).toContain("Bun shipped.");
+    }
+  });
+
+  test("web_fetch pair before a client tool_use keeps its place ahead of the tool_use", async () => {
+    const turn1 = clientContent((await claudeTurn("https://api.anthropic.com", fetchTurn(FETCH_RESULT))).clientSse);
+    const toolUse = { type: "tool_use", id: "toolu_1", name: "Read", input: {} };
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth",
+      followUp([...turn1.slice(0, 2), toolUse], [{ type: "tool_result", tool_use_id: "toolu_1", content: "ok" }]));
+    const content = (wire.messages as { content: Record<string, unknown>[] }[])[1]!.content;
+    expect(content).toEqual([
+      { type: "server_tool_use", id: "srvtoolu_f", name: "web_fetch", input: { url: "https://bun.sh/blog" } },
+      { type: "web_fetch_tool_result", tool_use_id: "srvtoolu_f", content: FETCH_RESULT },
+      toolUse,
+    ]);
+  });
+
+  test("a repeated anchor drops its run instead of guessing an owner", async () => {
+    const [use, result] = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse).slice(0, 2);
+    const thinking = (signature: string) => ({ type: "thinking", thinking: `t ${signature}`, signature });
+    const second = [{ ...use, id: "srvtoolu_2" }, { ...result, tool_use_id: "srvtoolu_2" }];
+    const third = [{ ...use, id: "srvtoolu_3" }, { ...result, tool_use_id: "srvtoolu_3" }];
+    const read = (id: string) => ({ type: "tool_use", id, name: "Read", input: {} });
+    // Shape of the maintainer's counterexample on #7236: an earlier string-content turn with the same text,
+    // then repeated text anchors around identical searches, identical calls and signed thinking.
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", [
+      { role: "user", content: "Hi" }, { role: "assistant", content: "Bun shipped." },
+      { role: "user", content: "What did Bun release?" },
+      { role: "assistant", content: [
+        thinking("SigOne0123456789abcdef"), use, result, { type: "text", text: "Bun shipped." },
+        ...second, { type: "text", text: "Bun shipped." }, thinking("SigTwo0123456789abcdef"), ...third, read("toolu_a"), read("toolu_b"),
+      ] },
+      { role: "user", content: [{ type: "tool_result", tool_use_id: "toolu_a", content: "ok" }, { type: "tool_result", tool_use_id: "toolu_b", content: "ok" }] },
+    ]);
+    const ids = (wire.messages as { content: unknown }[])
+      .map(m => Array.isArray(m.content) ? m.content.map(b => { const r = b as Record<string, unknown>; return String(r.id ?? r.tool_use_id ?? r.type); }) : []);
+    expect(ids[1]).toEqual(["text"]);
+    // Only srvtoolu_3, anchored on the unique call toolu_a, replays; the text-anchored runs are ambiguous.
+    expect(ids[3]).toEqual(["thinking", "text", "text", "thinking", "srvtoolu_3", "srvtoolu_3", "toolu_a", "toolu_b"]);
+  });
+
+  test("a string-form assistant cannot steal a later identical text anchor", async () => {
+    const turn = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse);
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", [
+      { role: "user", content: "Hi" }, { role: "assistant", content: "Bun shipped." },
+      { role: "user", content: "Search" }, { role: "assistant", content: turn },
+      { role: "user", content: "More?" },
+    ]);
+    const messages = wire.messages as { content: Record<string, unknown>[] }[];
+    expect(messages[3]!.content).toEqual([{ type: "text", text: "Bun shipped." }]);
+    expect(messages[1]!.content).toEqual([{ type: "text", text: "Bun shipped." }]);
+    expect(JSON.stringify(messages)).not.toContain("server_tool_use");
+    expect(JSON.stringify(messages)).not.toContain("web_search_tool_result");
+  });
+
+  test("repeated identical calls drop ambiguous server exchanges and preserve assistant turns", async () => {
+    const turn = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse);
+    const call = { type: "tool_use", id: "toolu_repeat", name: "Read", input: {} };
+    const result = [{ type: "tool_result", tool_use_id: "toolu_repeat", content: "ok" }];
+    const first = [...turn, call];
+    const second = turn.map(b => b.id === "srvtoolu_1" ? { ...b, id: "srvtoolu_2" }
+      : b.tool_use_id === "srvtoolu_1" ? { ...b, tool_use_id: "srvtoolu_2" } : b);
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", [
+      { role: "user", content: "Hi" }, { role: "assistant", content: "Bun shipped." },
+      { role: "user", content: "Search" }, { role: "assistant", content: first },
+      { role: "user", content: result }, { role: "assistant", content: [...second, call] },
+      { role: "user", content: result },
+    ]);
+    const messages = wire.messages as { content: Record<string, unknown>[] }[];
+    expect(messages[3]!.content).toEqual([{ type: "text", text: "Bun shipped." }, call]);
+    expect(messages[5]!.content).toEqual([{ type: "text", text: "Bun shipped." }, call]);
+    expect(messages[1]!.content).toEqual([{ type: "text", text: "Bun shipped." }]);
+  });
+
+  test("repeated string, thinking and redacted anchors drop exchanges and preserve signed blocks", async () => {
+    const turn = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse);
+    const [use, result, text] = turn;
+    const thinking = { type: "thinking", thinking: "checking", signature: "SigRepeat0123456789abcdef" };
+    const redacted = { type: "redacted_thinking", data: "RedactedRepeat0123456789" };
+    const pair = (id: string) => [{ ...use, id }, { ...result, tool_use_id: id }];
+    const assistant = [thinking, ...pair("srvtoolu_text"), text, redacted,
+      ...pair("srvtoolu_thinking"), thinking, ...pair("srvtoolu_redacted"), redacted,
+      ...pair("srvtoolu_text2"), text];
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", [
+      { role: "user", content: "Hi" }, { role: "assistant", content: "Bun shipped." },
+      { role: "user", content: "Search" }, { role: "assistant", content: assistant },
+      { role: "user", content: "More?" },
+    ]);
+    const messages = wire.messages as { role: string; content: Record<string, unknown>[] }[];
+    // Reasoning splits this source turn into adjacent translated assistant messages.
+    const later = messages.slice(3).filter(m => m.role === "assistant").flatMap(m => m.content);
+    expect(later).toEqual([thinking, text, redacted, thinking, redacted, text]);
+    expect(messages[1]!.content).toEqual([{ type: "text", text: "Bun shipped." }]);
+  });
+
+  test("a pair between thinking blocks stays between them", async () => {
+    const [use, result] = (await claudeTurn("https://api.anthropic.com", SEARCH_TURN).then(r => clientContent(r.clientSse))).slice(0, 2);
+    const thinking = (signature: string) => ({ type: "thinking", thinking: `t ${signature}`, signature });
+    const redacted = { type: "redacted_thinking", data: "RedactedPayload0123456789" };
+    const second = [{ ...use, id: "srvtoolu_2" }, { ...result, tool_use_id: "srvtoolu_2" }];
+    const assistant = [thinking("SigOne0123456789abcdef"), use, result, thinking("SigTwo0123456789abcdef"), ...second, redacted];
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", followUp([...assistant, { type: "text", text: "Bun shipped." }]));
+    const content = (wire.messages as { content: Record<string, unknown>[] }[])[1]!.content;
+    expect(content.map(b => b.id ?? b.tool_use_id ?? b.type)).toEqual([
+      "thinking", "srvtoolu_1", "srvtoolu_1", "thinking", "srvtoolu_2", "srvtoolu_2", "redacted_thinking", "text",
+    ]);
+  });
+
+  test("duplicate or unmatched server-tool ids never replay an orphan result", async () => {
+    const [use, result, text] = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse);
+    const orphan = { ...result, tool_use_id: "srvtoolu_orphan" };
+    for (const blocks of [[use, orphan], [use, use, result, orphan], [use, use, result, result]]) {
+      const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", followUp([...blocks, text]));
+      expect((wire.messages as { content: unknown }[])[1]!.content).toEqual([{ type: "text", text: "Bun shipped." }]);
+    }
+  });
+
+  test("malformed server-tool input drops the exchange without changing its unique text anchor", async () => {
+    const [use, result, text] = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse);
+    for (const [name, field, resultType] of [["web_search", "query", "web_search_tool_result"], ["web_fetch", "url", "web_fetch_tool_result"]] as const) {
+      for (const input of [undefined, null, [], "invalid", {}, { [field]: 42 }, { [field]: "" }, { [field]: "  " }]) {
+        const call = { ...use, name, input };
+        const matched = { ...result, type: resultType, ...(name === "web_fetch" ? { content: FETCH_RESULT } : {}) };
+        const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", followUp([call, matched, text]));
+        const messages = wire.messages as { content: unknown }[];
+        expect(messages[1]!.content).toEqual([{ type: "text", text: "Bun shipped." }]);
+        expect(JSON.stringify(messages)).not.toContain("server_tool_use");
+        expect(JSON.stringify(messages)).not.toContain(resultType);
+      }
+    }
+  });
+
+  test("a result before its call drops the exchange instead of replaying the reversed pair", async () => {
+    const [use, result, text] = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse);
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", followUp([result, use, text]));
+    const messages = wire.messages as { content: unknown }[];
+    expect(messages[1]!.content).toEqual([{ type: "text", text: "Bun shipped." }]);
+    expect(JSON.stringify(messages)).not.toContain("server_tool_use");
+    expect(JSON.stringify(messages)).not.toContain("web_search_tool_result");
+  });
+
+  test("overlapping calls replay in source order when each result follows its own call", async () => {
+    const [use, result, text] = clientContent((await claudeTurn("https://api.anthropic.com", SEARCH_TURN)).clientSse);
+    const secondUse = { ...use, id: "srvtoolu_second" };
+    const secondResult = { ...result, tool_use_id: "srvtoolu_second" };
+    const turn = [use, secondUse, secondResult, result, text];
+    const { wire } = await claudeTurn("https://api.anthropic.com", OK_TURN, "anth", followUp(turn));
+    expect((wire.messages as { content: unknown }[])[1]!.content).toEqual(turn);
+  });
+});
+
+test("a malformed anthropic_blocks falls back to the rebuilt pair", () => {
+  const use = { type: "server_tool_use", id: "srvtoolu_stored", name: "web_search", input: { query: "stored" } };
+  for (const anthropic_blocks of [{}, { use: {}, result: {} }, { use: { id: 1, name: "web_search" }, result: { type: "web_search_tool_result" } },
+    { use, result: { type: "web_search_tool_result", tool_use_id: "srvtoolu_other" } },
+    { use, result: { type: "web_fetch_tool_result", tool_use_id: use.id } },
+    { use: { ...use, input: undefined }, result: { type: "web_search_tool_result", tool_use_id: use.id } },
+  ]) {
+    const pair = webSearchPairFromItem({ type: "web_search_call", id: "ws_1", action: { type: "search", query: "q" }, anthropic_blocks });
+    expect(pair).toMatchObject({ id: "ws_1", name: "web_search", resultType: "web_search_tool_result", input: { query: "q" } });
+  }
+});
+
+test("an item emitted before anthropic_blocks still maps its fetch_result to a web_fetch pair", () => {
+  const pair = webSearchPairFromItem({
+    type: "web_search_call", id: "srvtoolu_old", action: { type: "open_page", url: "https://bun.sh/blog" },
+    fetch_result: FETCH_RESULT,
+  });
+  expect(pair).toMatchObject({ id: "srvtoolu_old", name: "web_fetch", resultType: "web_fetch_tool_result", input: { url: "https://bun.sh/blog" }, resultContent: FETCH_RESULT });
+});
diff --git a/tests/claude-integration/messages-native.test.ts b/tests/claude-integration/messages-native.test.ts
index 583f21667e7..a2e5e65357b 100644
--- a/tests/claude-integration/messages-native.test.ts
+++ b/tests/claude-integration/messages-native.test.ts
@@ -5,7 +5,7 @@
  * key) instead of the Responses replay. Everything here is a local fixture: no real credential
  * or service is reached.
  */
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -397,6 +397,57 @@ describe("managed native Messages", () => {
     expect(seen.map(entry => entry.headers.get("x-api-key"))).toEqual(["fixture-key-alpha", "fixture-key-beta"]);
   });
 
+  for (const { providerName, upstreamRetryAfter, expectedRetryAfter, upstreamMessage = "Rate limit exceeded", upstreamCode, expectedGuidance = providerName === "opencode-zen" } of [
+    { providerName: "opencode-zen", upstreamRetryAfter: undefined, expectedRetryAfter: "15" },
+    { providerName: "opencode-zen", upstreamRetryAfter: "37", expectedRetryAfter: "37" },
+    { providerName: "anth", upstreamRetryAfter: undefined, expectedRetryAfter: "2" },
+    { providerName: "opencode-zen", upstreamRetryAfter: undefined, expectedRetryAfter: "15", upstreamMessage: "Too Many Requests" },
+    { providerName: "opencode-zen", upstreamRetryAfter: undefined, expectedRetryAfter: "2", upstreamMessage: "The usage limit has been reached", expectedGuidance: false },
+    { providerName: "opencode-zen", upstreamRetryAfter: undefined, expectedRetryAfter: "2", upstreamCode: "insufficient_quota", expectedGuidance: false },
+  ]) test(`native ${providerName} 429 preserves pacing policy with Retry-After ${upstreamRetryAfter ?? "absent"} and ${upstreamMessage}`, async () => {
+    const config = fixtureConfig(1);
+    if (providerName !== "anth") {
+      config.providers[providerName] = config.providers.anth!;
+      delete config.providers.anth;
+      config.defaultProvider = providerName;
+      config.providers[providerName]!.baseUrl = "https://opencode.ai/zen/v1";
+    }
+    saveConfig(config);
+    // The Zen preset pins its public URL; intercept fetch so no external service is contacted.
+    const fetchMock = spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+      const request = new Request(input, init);
+      seen.push({ path: new URL(request.url).pathname, headers: request.headers, body: await request.json() as Record<string, unknown> });
+      return Response.json({ type: "error", error: { type: "rate_limit_error", code: upstreamCode, message: upstreamMessage } },
+        { status: 429, headers: upstreamRetryAfter ? { "retry-after": upstreamRetryAfter } : {} });
+    });
+    let result: Awaited<ReturnType<typeof send>>;
+    try {
+      result = await send(config, { ...SOURCE_BODY, model: `${providerName}/claude-x`, stream: false });
+    } finally {
+      fetchMock.mockRestore();
+    }
+    const { requestId, response, text } = result;
+    expect(response.status).toBe(429);
+    expect(response.headers.get("retry-after")).toBe(expectedRetryAfter);
+    expect(seen).toHaveLength(1);
+    expect(seen[0]!.path).toBe(providerName === "opencode-zen" ? "/zen/v1/messages" : "/v1/messages");
+    const row = rowFor(requestId);
+    expect(row.protocolTrace?.mode).toBe("native");
+    const envelope = JSON.parse(text);
+    expect(envelope).toMatchObject({ type: "error", error: { type: "rate_limit_error" } });
+    const message = envelope.error.message;
+    if (expectedGuidance) {
+      expect(message).toContain("15-20 requests per minute");
+      expect(message).toContain("Slow the request pace");
+      expect(message).toContain("providers.opencode-zen.retryOn429");
+      if (upstreamRetryAfter) expect(message).not.toContain("Try again in 15s");
+      else expect(message).toContain("Try again in 15s");
+    } else {
+      expect(message).toBe(upstreamMessage);
+    }
+    expect(row.upstreamError).toBe(message);
+    expect(text).not.toContain("fixture-key-alpha");
+  });
   test("an upstream error answers in Anthropic shape without the key", async () => {
     const config = fixtureConfig(startUpstream(() => Response.json(
       { type: "error", error: { type: "invalid_request_error", message: "bad fixture" } }, { status: 400 })));
diff --git a/tests/cli/cross-home-loopback-family.test.ts b/tests/cli/cross-home-loopback-family.test.ts
new file mode 100644
index 00000000000..83e57cea2fb
--- /dev/null
+++ b/tests/cli/cross-home-loopback-family.test.ts
@@ -0,0 +1,145 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { findCrossHomeOwnerDetailed, markCrossHomeSibling } from "../../src/cli/cross-home-owner";
+import { loopbackFamilyAvailability, type LoopbackFamilyAvailability } from "../../src/cli/loopback-family";
+import { resetSiblingStartForTests, siblingOfLivePort } from "../../src/codex/sibling-start";
+import { LOCAL_ATTESTATION_CHALLENGE_HEADER, LOCAL_ATTESTATION_PROOF_HEADER,
+  createLocalAttestationProof } from "../../src/lib/local-management-attestation";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+const envKeys = ["OPENCODEX_HOME", "CODEX_HOME", "GROK_HOME", "OCX_OWNER_REGISTRY_DIR"] as const;
+const originalEnv = Object.fromEntries(envKeys.map(key => [key, process.env[key]]));
+const roots: string[] = [];
+const port = 10102;
+const ownerPid = process.pid + 1;
+const secret = "A".repeat(43);
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "ocx-loopback-family-"));
+  roots.push(root);
+  const home = join(root, "home");
+  for (const key of envKeys) {
+    const dir = join(root, key.toLowerCase());
+    mkdirSync(dir, { recursive: true });
+    process.env[key] = dir;
+  }
+  mkdirSync(join(home, ".opencodex"), { recursive: true });
+  writeFileSync(join(process.env.CODEX_HOME!, "config.toml"),
+    `model_provider = "opencodex"\n[model_providers.opencodex]\nbase_url = "http://127.0.0.1:${port}/v1"\n`);
+  return { home };
+}
+
+afterEach(() => {
+  resetSiblingStartForTests();
+  for (const key of envKeys) {
+    if (originalEnv[key] === undefined) delete process.env[key];
+    else process.env[key] = originalEnv[key];
+  }
+  for (const root of roots.splice(0)) removeTreeWithRetry(root);
+});
+
+test.each(["EADDRNOTAVAIL", "EAFNOSUPPORT", "EPROTONOSUPPORT"])(
+  "%s from an IPv6 bind proves the family unavailable", code => {
+    expect(loopbackFamilyAvailability("[::1]", hostname => {
+      expect(hostname).toBe("::1");
+      throw Object.assign(new Error("unavailable"), { code });
+    })).toBe("unavailable");
+  },
+);
+
+test.each(["EACCES", "EPERM", "EMFILE", "EADDRINUSE", "ETIMEDOUT", "EINVAL", "ENETUNREACH"])(
+  "%s from a bind does not prove address absence", code => {
+    expect(loopbackFamilyAvailability("[::1]", () => {
+      throw Object.assign(new Error("ambiguous"), { code });
+    })).toBe("unknown");
+  },
+);
+
+test("successful availability check closes the ephemeral listener synchronously", () => {
+  let closed = 0;
+  expect(loopbackFamilyAvailability("127.0.0.1", () => ({ stop() { closed++; } }))).toBe("available");
+  expect(closed).toBe(1);
+  expect(loopbackFamilyAvailability("example.com", () => { throw new Error("must not bind"); })).toBe("unknown");
+});
+
+test("the real kernel bind can check IPv4 loopback availability", () => {
+  expect(loopbackFamilyAvailability("127.0.0.1")).toBe("available");
+});
+
+function probes(ipv6: LoopbackFamilyAvailability, liveHost?: string) {
+  const requests: string[] = [];
+  const checked: string[] = [];
+  return {
+    requests, checked,
+    loopbackAvailabilityFn: (hostname: string) => {
+      checked.push(hostname);
+      return hostname === "[::1]" ? ipv6 : "available" as const;
+    },
+    io: {
+      attempts: 1, timeoutMs: 50,
+      fetchFn: (async (input: string | URL | Request, init?: RequestInit) => {
+        const url = new URL(String(input));
+        requests.push(url.hostname);
+        if (url.hostname === liveHost) {
+          const headers = new Headers();
+          const challenge = new Headers(init?.headers).get(LOCAL_ATTESTATION_CHALLENGE_HEADER);
+          if (challenge) headers.set(LOCAL_ATTESTATION_PROOF_HEADER,
+            createLocalAttestationProof(secret, challenge, ownerPid, port));
+          return Response.json({ service: "opencodex", status: "ok", version: "0.0.0", uptime: 1, pid: ownerPid }, { headers });
+        }
+        // Reproduce the reported connect behavior: the disabled ::1 route times
+        // out while IPv4 refuses. Absence is proven by the bind check, not this.
+        throw Object.assign(new Error("connect failed"), {
+          code: url.hostname === "[::1]" ? "ETIMEDOUT" : "ECONNREFUSED",
+        });
+      }) as typeof fetch,
+    },
+  };
+}
+
+test("IPv4 refusal plus unavailable IPv6 permits startup without dialing the timeout route", async () => {
+  const fx = fixture();
+  const probe = probes("unavailable");
+  expect(await markCrossHomeSibling({ homeDir: fx.home, ...probe })).toBe(false);
+  expect(siblingOfLivePort()).toBeNull();
+  expect(probe.requests.length).toBeGreaterThan(0);
+  expect(probe.requests.every(host => host === "127.0.0.1")).toBe(true);
+  expect(probe.checked).toEqual(["127.0.0.1", "[::1]"]);
+});
+
+test.each(["available", "unknown"] as const)("IPv6 %s plus timeout still refuses startup", async availability => {
+  const fx = fixture();
+  const probe = probes(availability);
+  expect((await findCrossHomeOwnerDetailed({ homeDir: fx.home, ...probe })).kind).toBe("indeterminate");
+  await expect(markCrossHomeSibling({ homeDir: fx.home, ...probe })).rejects.toThrow("refusing startup");
+  expect(probe.requests).toContain("[::1]");
+});
+
+test("an unregistered live IPv4 listener still blocks startup when IPv6 is unavailable", async () => {
+  const fx = fixture();
+  await expect(markCrossHomeSibling({ homeDir: fx.home, ...probes("unavailable", "127.0.0.1") }))
+    .rejects.toThrow("refusing startup");
+});
+
+test("a network-unreachable bind does not hide an unregistered live IPv6 owner", async () => {
+  const fx = fixture();
+  const probe = probes("unknown", "[::1]");
+  const loopbackAvailabilityFn = (hostname: string) => loopbackFamilyAvailability(hostname, () => {
+    if (hostname === "[::1]") throw Object.assign(new Error("route failure"), { code: "ENETUNREACH" });
+    return { stop() {} };
+  });
+  await expect(markCrossHomeSibling({ homeDir: fx.home, ...probe, loopbackAvailabilityFn }))
+    .rejects.toThrow("refusing startup");
+  expect(probe.requests).toContain("[::1]");
+});
+
+test.each(["127.0.0.1", "[::1]"])("an attested live %s owner still makes the start a sibling", async host => {
+  const fx = fixture();
+  writeFileSync(join(fx.home, ".opencodex", "runtime-port.json"), JSON.stringify({
+    pid: ownerPid, port, attestationSecret: secret, hostname: host,
+  }));
+  expect(await markCrossHomeSibling({ homeDir: fx.home, ...probes("available", host) })).toBe(true);
+  expect(siblingOfLivePort()).toBe(port);
+});
diff --git a/tests/codex-integration/active-registry-admission.test.ts b/tests/codex-integration/active-registry-admission.test.ts
index 18d79349cee..e531dcc718c 100644
--- a/tests/codex-integration/active-registry-admission.test.ts
+++ b/tests/codex-integration/active-registry-admission.test.ts
@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { MAX_ACTIVE_TURNS, abortAndReleaseAllTurns, activeRegistryMetrics, trackStreamLifetime, tryAdmitTurn, unregisterTurn } from "../../src/server/lifecycle";
+import { MAX_ACTIVE_TURNS, abortAndReleaseAllTurns, activeRegistryMetrics, registerTurn, trackStreamLifetime, tryAdmitTurn, unregisterTurn } from "../../src/server/lifecycle";
 import { workflowBudgetSnapshot } from "../../src/lib/workflow-budget";
 import {
   MAX_TRACKED_CODEX_WEBSOCKETS,
@@ -243,6 +243,75 @@ describe("active registry admission", () => {
     expect(attachedReleases).toBe(1);
   });
 
+  test("a completed child keeps its parent admitted and cannot cancel the next child", () => {
+    const before = activeRegistryMetrics().activeTurns;
+    const lease = tryAdmitTurn()!;
+    const parent = new AbortController();
+    const first = new AbortController();
+    const next = new AbortController();
+    let released = 0;
+    lease.attach({ release() { released += 1; } });
+    try {
+      registerTurn(parent, lease);
+      registerTurn(first, lease);
+      unregisterTurn(first);
+      expect(activeRegistryMetrics().activeTurns.active).toBe(before.active + 1);
+      expect(released).toBe(0);
+      registerTurn(next, lease);
+      expect(next.signal.aborted).toBe(false);
+      first.abort(new Error("late cleanup of completed child"));
+      unregisterTurn(first);
+      expect(parent.signal.aborted).toBe(false);
+      expect(next.signal.aborted).toBe(false);
+      expect(activeRegistryMetrics().activeTurns.active).toBe(before.active + 1);
+      unregisterTurn(next);
+      expect(released).toBe(0);
+      unregisterTurn(parent);
+      expect(released).toBe(1);
+      expect(activeRegistryMetrics().activeTurns.active).toBe(before.active);
+      expect(activeRegistryMetrics().activeTurns.releaseMisses).toBe(before.releaseMisses);
+    } finally { lease.release(); }
+  });
+
+  test("registering the same sole controller twice still releases on its one completion", () => {
+    const before = activeRegistryMetrics().activeTurns;
+    const lease = tryAdmitTurn()!;
+    const controller = new AbortController();
+    try {
+      registerTurn(controller, lease);
+      registerTurn(controller, lease);
+      unregisterTurn(controller);
+      expect(activeRegistryMetrics().activeTurns.active).toBe(before.active);
+      unregisterTurn(controller);
+      expect(activeRegistryMetrics().activeTurns.releaseMisses).toBe(before.releaseMisses);
+    } finally { lease.release(); }
+  });
+
+  test("parent cancellation after child completion still releases and aborts the active child", () => {
+    const before = activeRegistryMetrics().activeTurns;
+    const lease = tryAdmitTurn()!;
+    const parent = new AbortController();
+    const completed = new AbortController();
+    const pending = new AbortController();
+    const reason = new Error("parent turn superseded");
+    let released = 0;
+    lease.attach({ release() { released += 1; } });
+    try {
+      registerTurn(parent, lease);
+      registerTurn(completed, lease);
+      unregisterTurn(completed);
+      registerTurn(pending, lease);
+      parent.abort(reason);
+      expect(pending.signal.reason).toBe(reason);
+      expect(completed.signal.aborted).toBe(false);
+      expect(released).toBe(1);
+      expect(activeRegistryMetrics().activeTurns.active).toBe(before.active);
+      unregisterTurn(parent);
+      unregisterTurn(pending);
+      expect(activeRegistryMetrics().activeTurns.releaseMisses).toBe(before.releaseMisses);
+    } finally { lease.release(); }
+  });
+
   test("the 256-turn gate bounds concurrency, not sequential continuation count", () => {
     const before = activeRegistryMetrics().activeTurns.active;
     for (let index = 0; index <= MAX_ACTIVE_TURNS; index += 1) {
diff --git a/tests/codex-integration/bearer-admission-routed-provider.test.ts b/tests/codex-integration/bearer-admission-routed-provider.test.ts
index 2ab77af91bd..21d036a0544 100644
--- a/tests/codex-integration/bearer-admission-routed-provider.test.ts
+++ b/tests/codex-integration/bearer-admission-routed-provider.test.ts
@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, setDefaultTimeout, test } from "bun:test";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import http2 from "node:http2";
 import { tmpdir } from "node:os";
@@ -17,10 +17,13 @@ import { handleNativeProfileAPI } from "../../src/codex/native-profile-api";
 import type { NativeProfileManager } from "../../src/codex/native-profile-manager";
 import type { OcxConfig } from "../../src/types";
 import { ownedServiceHomeInspection } from "../helpers/owned-service-home-inspection";
-import { removeTreeWithRetry } from "../helpers/remove-tree";
+import { removeTreeAfterBackgroundWork } from "../helpers/remove-tree";
 import { fakeChatGptJwt } from "../helpers/fake-chatgpt-jwt";
 import { resetVisionDescriptionCache } from "../../src/vision";
 import { SERVER_BUDGET_MS } from "../helpers/test-budget";
+
+// Every case starts a real server; on Windows its config-dir ACL work alone can exceed 5 s.
+setDefaultTimeout(SERVER_BUDGET_MS);
 import { saveCodexAccountCredential } from "../../src/codex/account-store";
 
 /**
@@ -195,7 +198,7 @@ beforeEach(() => {
   }) as typeof fetch;
 });
 
-afterEach(() => {
+afterEach(async () => {
   resetVisionDescriptionCache();
   closeRequestHistoryIndex();
   clearComboTargetCooldowns();
@@ -209,8 +212,9 @@ afterEach(() => {
   else process.env.CODEX_HOME = previousCodexHome;
   if (previousDataToken === undefined) delete process.env.OPENCODEX_API_AUTH_TOKEN;
   else process.env.OPENCODEX_API_AUTH_TOKEN = previousDataToken;
-  if (ocxHome) removeTreeWithRetry(ocxHome);
-  if (codexHome) removeTreeWithRetry(codexHome);
+  // Startup's config-dir ACL hardening may still hold the homes on Windows; settle it first.
+  if (ocxHome) await removeTreeAfterBackgroundWork(ocxHome);
+  if (codexHome) await removeTreeAfterBackgroundWork(codexHome);
   ocxHome = "";
   codexHome = "";
 });
diff --git a/tests/codex-integration/codex-service-manager-probe-hardening.test.ts b/tests/codex-integration/codex-service-manager-probe-hardening.test.ts
index d7b8736ef75..9b1ea42da06 100644
--- a/tests/codex-integration/codex-service-manager-probe-hardening.test.ts
+++ b/tests/codex-integration/codex-service-manager-probe-hardening.test.ts
@@ -230,7 +230,7 @@ describe("Windows ownership probe hardening regressions", () => {
       ...getDefaultConfig(),
       port: 0,
       hostname: "127.0.0.1",
-      clientIntegrations: { codex: false },
+      clientIntegrations: { codex: true },
       subagentModels: [],
     }, null, 2));
 
@@ -278,7 +278,10 @@ describe("Windows ownership probe hardening regressions", () => {
           winswStatus: () => "nonexistent",
         });
         ownerships.push(answer.ownership);
-        return answer;
+        // Exercise enabled startup's two real inspections without taking the unrelated
+        // user-scoped catalog lock (which resolves Windows identity through PowerShell).
+        // Preserve each raw verdict above so a stale second listing still fails this test.
+        return ownerships.length === 1 ? { ownership: "unknown", reason: "cache writes outside this fixture" } : answer;
         } finally {
           setTrustedWindowsSystemDirectoryResolverForTests(null);
         }
diff --git a/tests/codex-integration/model-display-names-management-api.test.ts b/tests/codex-integration/model-display-names-management-api.test.ts
index ea11600e833..95819bb6316 100644
--- a/tests/codex-integration/model-display-names-management-api.test.ts
+++ b/tests/codex-integration/model-display-names-management-api.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { buildCatalogEntries, gatherRoutedModels } from "../../src/codex/catalog";
 import { clearModelCache, getFreshCached, setCached } from "../../src/codex/model-cache";
 import type { CatalogDisposition } from "../../src/codex/convergence-types";
 import { listManagementModelRows, toExportModel } from "../../src/server/management/model-rows";
@@ -32,6 +33,38 @@ afterEach(() => {
 });
 
 describe("model display name management rows", () => {
+  test("OpenAI API labels survive trusted reconstruction into the Codex catalog", async () => {
+    const apiConfig: OcxConfig = {
+      port: 10100,
+      defaultProvider: "openai-apikey",
+      providers: {
+        "openai-apikey": {
+          adapter: "openai-responses",
+          baseUrl: "https://api.openai.com/v1",
+          liveModels: false,
+          modelDisplayNames: { "gpt-6-astra": "6 Astra", "gpt-6.1-sol": "6.1 Sol" },
+        },
+      },
+    };
+    const catalog = async () => buildCatalogEntries(null, [], await gatherRoutedModels(apiConfig));
+    const labeled = await catalog();
+    for (const [slug, displayName] of [
+      ["openai-apikey/gpt-6-astra", "6 Astra"],
+      ["openai-apikey/gpt-6.1-sol", "6.1 Sol"],
+    ]) {
+      expect(labeled.filter(entry => entry.slug === slug)).toHaveLength(1);
+      expect(labeled.find(entry => entry.slug === slug)?.display_name).toBe(displayName);
+    }
+
+    delete apiConfig.providers["openai-apikey"]!.modelDisplayNames;
+    const original = await catalog();
+    for (const entry of labeled) {
+      const baseline = original.find(row => row.slug === entry.slug);
+      expect(baseline).toBeDefined();
+      expect({ ...entry, display_name: baseline!.display_name }).toEqual(baseline);
+    }
+  });
+
   test("reports operator, provider, and fallback display name sources without provider secrets", async () => {
     const operatorConfig = config({ "model-a": "Operator Name" });
     operatorConfig.providers[DISPLAY_PROVIDER].apiKey = "sk-secret-not-for-rows";
diff --git a/tests/codex-integration/websocket-capacity-activity.test.ts b/tests/codex-integration/websocket-capacity-activity.test.ts
new file mode 100644
index 00000000000..4744b38777d
--- /dev/null
+++ b/tests/codex-integration/websocket-capacity-activity.test.ts
@@ -0,0 +1,454 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { ServerWebSocket } from "bun";
+import { CodexWebSocketActivity } from "../../src/codex/websocket-activity";
+import {
+  MAX_TRACKED_CODEX_WEBSOCKETS, codexWebSocketAdmissionMetrics,
+  registerCodexWebSocket, tryReserveCodexWebSocket, unregisterCodexWebSocket,
+} from "../../src/codex/websocket-registry";
+import type { AdmissionReservation } from "../../src/lib/admission";
+import { createWebsocketHandler } from "../../src/server/index/websocket-handler";
+import type { ServeOptionsContext } from "../../src/server/index/serve-options";
+import { MAX_ACTIVE_TURNS, tryAdmitTurn } from "../../src/server/lifecycle";
+import type { NativeResponseControl } from "../../src/server/responses/native-response-control";
+import { sendResponseToWebSocket, type WsData } from "../../src/server/ws-bridge";
+
+type Frame = Record<string, unknown>;
+const leases: AdmissionReservation<ServerWebSocket<WsData>>[] = [];
+const sockets: ServerWebSocket<WsData>[] = [];
+const handler = createWebsocketHandler({ config: {}, deps: {} } as ServeOptionsContext);
+
+afterEach(() => {
+  for (const ws of sockets.splice(0)) unregisterCodexWebSocket(ws);
+  for (const lease of leases.splice(0)) lease.release();
+});
+
+function reserve() {
+  const lease = tryReserveCodexWebSocket();
+  if (lease) leases.push(lease);
+  return lease;
+}
+
+function admittedSocket(mode: "normal" | "delayed" | "throw" = "normal") {
+  const lease = reserve();
+  expect(lease).not.toBeNull();
+  const sent: Frame[] = [];
+  const closed: Array<{ code?: number; reason?: string }> = [];
+  let state = 1;
+  let buffered = 0;
+  const ws = {
+    data: { admissionLease: lease! } as WsData,
+    get readyState() { return state; },
+    getBufferedAmount: () => buffered,
+    send(text: string) { sent.push(JSON.parse(text)); return 1; },
+    close(code?: number, reason?: string) {
+      closed.push({ code, reason });
+      if (mode === "throw") throw new Error("fixture close failure");
+      if (mode === "normal") finishClose();
+    },
+  } as unknown as ServerWebSocket<WsData>;
+  function finishClose() {
+    state = 3;
+    handler.close(ws, 1000, "fixture close");
+  }
+  lease!.bind(ws);
+  registerCodexWebSocket(ws);
+  sockets.push(ws);
+  return { ws, sent, closed, finishClose, activity: ws.data.responsesActivity!,
+    setBuffered(bytes: number) { buffered = bytes; } };
+}
+
+function output(activity: CodexWebSocketActivity, item: Frame) {
+  activity.observePayload(JSON.stringify({ type: "response.output_item.done", item }));
+}
+
+const argumentCompletions = [
+  ["function_call", "response.function_call_arguments.done", "function_call_output"],
+  ["custom_tool_call", "response.custom_tool_call_input.done", "custom_tool_call_output"],
+] as const;
+
+describe("Responses final tool arguments", () => {
+  test.each(argumentCompletions)("%s stays protected after EOF until the real handler accepts its result", async (type, done, result) => {
+    const client = admittedSocket();
+    const finish = client.activity.beginTurn([]);
+    const argumentField = type === "function_call" ? "arguments" : "input";
+    const frames = [
+      { type: "response.output_item.added", item: { type, id: "item", call_id: "call", name: "fixture_tool", [argumentField]: "" } },
+      { type: done, item_id: "item", [argumentField]: "{}" },
+    ];
+    await sendResponseToWebSocket(client.ws, new Response(
+      frames.map(frame => `data: ${JSON.stringify(frame)}\n\n`).join(""),
+      { headers: { "content-type": "text/event-stream" } },
+    ), () => true, { onSsePayload: payload => client.activity.observePayload(payload) });
+    finish();
+    expect(client.sent.map(frame => frame.type)).toEqual(["response.output_item.added", done, "error"]);
+    expect(client.sent.at(-1)).toMatchObject({ error: { message: "Upstream stream ended before response terminal event" } });
+    expect(client.ws.data.cancel).toBeUndefined();
+    const others = Array.from({ length: MAX_TRACKED_CODEX_WEBSOCKETS - 1 }, () => admittedSocket());
+    const finishOthers = others.map(other => other.activity.beginTurn([]));
+    try {
+      expect(reserve()).toBeNull();
+      expect(client.closed).toEqual([]);
+      let accepted = false;
+      client.ws.data.nativeControl = { inject: () => { accepted = true; } } as unknown as NativeResponseControl;
+      handler.message(client.ws, JSON.stringify({ type: "response.inject", input: [{ type: result, call_id: "call", output: "done" }] }));
+      expect(accepted).toBe(true);
+      client.ws.data.nativeControl = undefined;
+      expect(reserve()).not.toBeNull();
+      expect(client.closed).toEqual([{ code: 1001, reason: "Idle Responses connection reclaimed" }]);
+    } finally {
+      client.ws.data.nativeControl = undefined;
+      for (const end of finishOthers) end();
+    }
+  });
+
+  test.each(argumentCompletions)("unfinished %s arguments do not invent pending client work", (type) => {
+    const activity = new CodexWebSocketActivity();
+    const finish = activity.beginTurn([]);
+    activity.observePayload(JSON.stringify({ type: "response.output_item.added", item: { type, id: "item", call_id: "call" } }));
+    finish();
+    expect(activity.idle).toBe(true);
+  });
+
+  test.each(argumentCompletions)("%s completion echoes stay settled and reused identities belong to the next turn", (type, done, resultType) => {
+    const activity = new CodexWebSocketActivity();
+    const call = { type, id: "reused-item", call_id: "reused-call" };
+    const result = { type: resultType, call_id: call.call_id, output: "done" };
+    const added = JSON.stringify({ type: "response.output_item.added", item: call });
+    const completed = JSON.stringify({ type: done, item_id: call.id });
+    for (const created of [true, false]) {
+      const finish = activity.beginTurn([result]);
+      if (created) activity.observePayload(JSON.stringify({ type: "response.created", response: { id: "response" } }));
+      activity.observePayload(added);
+      activity.observePayload(added); // A repeated identity is not a new call.
+      activity.observePayload(completed);
+      finish();
+      expect(activity.idle).toBe(false);
+      activity.acceptResults([result]);
+      activity.observePayload(completed);
+      output(activity, call);
+      activity.observePayload(JSON.stringify({ type: "response.completed", response: { output: [call] } }));
+      expect(activity.idle).toBe(true);
+    }
+  });
+
+  test("native response.created resets argument identities without suppressing a reused call", () => {
+    const activity = new CodexWebSocketActivity();
+    const finish = activity.beginTurn([]);
+    for (const id of ["first", "second"]) {
+      activity.observePayload(JSON.stringify({ type: "response.created", response: { id } }));
+      activity.observePayload(JSON.stringify({ type: "response.output_item.added", item: { type: "function_call", id: "item", call_id: id } }));
+      activity.observePayload(JSON.stringify({ type: "response.function_call_arguments.done", item_id: "item" }));
+      if (id === "first") activity.acceptResults([{ type: "function_call_output", call_id: id }]);
+    }
+    finish();
+    expect(activity.idle).toBe(false);
+    activity.acceptResults([{ type: "function_call_output", call_id: "second" }]);
+    expect(activity.idle).toBe(true);
+  });
+
+  test("hosted custom input completion stays idle only with this response's provider authorization", () => {
+    const activity = new CodexWebSocketActivity();
+    const hosted = new Set([{ itemType: "custom_tool_call", callIdPrefix: "xs_call-" }]);
+    const added = JSON.stringify({ type: "response.output_item.added", item: { type: "custom_tool_call", id: "item", call_id: "xs_call-1" } });
+    const done = JSON.stringify({ type: "response.custom_tool_call_input.done", item_id: "item" });
+    const first = activity.beginTurn([]);
+    activity.observePayload(added, hosted);
+    activity.observePayload(done, hosted);
+    first();
+    expect(activity.idle).toBe(true);
+    const second = activity.beginTurn([]);
+    activity.observePayload(added);
+    activity.observePayload(done);
+    second();
+    expect(activity.idle).toBe(false);
+    activity.acceptResults([{ type: "custom_tool_call_output", call_id: "xs_call-1" }]);
+    expect(activity.idle).toBe(true);
+  });
+
+  test("unknown, oversized and mismatched final argument identities remain protected", () => {
+    for (const item of [
+      undefined,
+      { type: "function_call", id: "", call_id: "call" },
+      { type: "function_call", id: "item", call_id: "" },
+      { type: "function_call", id: "item", call_id: "x".repeat(1025) },
+      { type: "function_call", id: "x".repeat(1025), call_id: "call" },
+      { type: "custom_tool_call", id: "item", call_id: "call" },
+    ]) {
+      const activity = new CodexWebSocketActivity();
+      const finish = activity.beginTurn([]);
+      activity.observePayload(JSON.stringify({ type: "response.output_item.added", item }));
+      activity.observePayload(JSON.stringify({ type: "response.function_call_arguments.done", item_id: item?.id ?? "unknown" }));
+      finish();
+      activity.acceptResults([{ type: "function_call_output", call_id: "call" }]);
+      expect(activity.idle).toBe(false);
+    }
+  });
+
+  test("conflicting or over-budget argument identities conservatively protect the socket", () => {
+    for (const conflict of [true, false]) {
+      const activity = new CodexWebSocketActivity();
+      const finish = activity.beginTurn([]);
+      for (let index = 0; index < (conflict ? 2 : 1025); index += 1) {
+        activity.observePayload(JSON.stringify({ type: "response.output_item.added", item: {
+          type: "function_call", id: conflict ? "conflict" : `item-${index}`, call_id: `call-${index}`,
+        } }));
+      }
+      finish();
+      expect(activity.idle).toBe(false);
+    }
+  });
+
+  test.each(argumentCompletions)("invalid %s redefinitions cannot reuse a prior result identity", (type, done, resultType) => {
+    for (const returnedFirst of [false, true]) {
+      for (const call_id of [undefined, "", "x".repeat(1025)]) {
+        const activity = new CodexWebSocketActivity();
+        const finish = activity.beginTurn([]);
+        const emit = (frame: Frame) => activity.observePayload(JSON.stringify(frame));
+        const result = { type: resultType, call_id: "prior", output: "done" };
+        emit({ type: "response.output_item.added", item: { type, id: "item", call_id: "prior" } });
+        emit({ type: done, item_id: "item" });
+        if (returnedFirst) activity.acceptResults([result]);
+        emit({ type: "response.output_item.added", item: { type, id: "item", call_id } });
+        emit({ type: done, item_id: "item" });
+        finish();
+        expect(activity.idle).toBe(false);
+        if (!returnedFirst) activity.acceptResults([result]);
+        expect(activity.idle).toBe(false);
+      }
+    }
+  });
+});
+
+describe("Responses socket activity", () => {
+  test("overlapping superseded turns each keep their own idempotent busy reference", () => {
+    const activity = new CodexWebSocketActivity();
+    const first = activity.beginTurn([]);
+    const second = activity.beginTurn([]);
+    second();
+    second();
+    expect(activity.idle).toBe(false);
+    first();
+    expect(activity.idle).toBe(true);
+    const third = activity.beginTurn([]);
+    first();
+    expect(activity.idle).toBe(false);
+    third();
+    expect(activity.idle).toBe(true);
+  });
+
+  test.each([
+    ["function_call", "function_call_output"],
+    ["custom_tool_call", "custom_tool_call_output"],
+    ["local_shell_call", "function_call_output"],
+    ["shell_call", "shell_call_output"],
+    ["computer_call", "computer_call_output"],
+    ["apply_patch_call", "apply_patch_call_output"],
+    ["tool_search_call", "tool_search_output"],
+  ])("protects client %s work until its %s arrives", (callType, resultType) => {
+    const activity = new CodexWebSocketActivity();
+    const finish = activity.beginTurn([]);
+    output(activity, { type: callType, call_id: "client-call", execution: "client" });
+    activity.observePayload(JSON.stringify({ type: "response.completed", response: { output: [] } }));
+    finish();
+    expect(activity.idle).toBe(false);
+    const continueTurn = activity.beginTurn([{ type: resultType, call_id: "client-call", output: "done" }]);
+    expect(activity.idle).toBe(false);
+    continueTurn();
+    expect(activity.idle).toBe(true);
+  });
+
+  test("terminal-only tool calls and partial result batches retain all outstanding work", () => {
+    const activity = new CodexWebSocketActivity();
+    const finish = activity.beginTurn([]);
+    output(activity, { type: "function_call", call_id: "first" });
+    activity.observePayload(JSON.stringify({ type: "response.completed", response: { output: [
+      { type: "function_call", call_id: "first" },
+      { type: "custom_tool_call", call_id: "second" },
+      { type: "mcp_approval_request", id: "approval" },
+    ] } }));
+    finish();
+    activity.beginTurn([{ type: "function_call_output", call_id: "first", output: "done" }])();
+    expect(activity.idle).toBe(false);
+    activity.beginTurn([{ type: "function_call_output", call_id: "second", output: "wrong type" },
+      { type: "mcp_approval_response", approval_request_id: "unrelated", approve: true }])();
+    expect(activity.idle).toBe(false);
+    activity.beginTurn([{ type: "custom_tool_call_output", call_id: "second", output: "done" }])();
+    expect(activity.idle).toBe(false);
+    activity.beginTurn([{ type: "mcp_approval_response", approval_request_id: "approval", approve: false }])();
+    expect(activity.idle).toBe(true);
+  });
+
+  test("hosted tools and malformed observations do not invent client work", () => {
+    const activity = new CodexWebSocketActivity();
+    const finish = activity.beginTurn([]);
+    for (const type of ["web_search_call", "file_search_call", "code_interpreter_call", "mcp_call", "tool_search_call", "message"]) {
+      output(activity, { type, id: "hosted-item" });
+    }
+    output(activity, { type: "tool_search_call", execution: "server", call_id: "hosted-search" });
+    for (const payload of ["bad JSON", "null", "[]", JSON.stringify({ type: "response.completed", response: null })]) {
+      activity.observePayload(payload);
+    }
+    finish();
+    expect(activity.idle).toBe(true);
+  });
+
+  test("returned native results ignore terminal echoes but cannot mask a later call reusing its ID", () => {
+    const activity = new CodexWebSocketActivity();
+    const call = { type: "function_call", call_id: "reused" };
+    const result = { type: "function_call_output", call_id: "reused", output: "done" };
+    const finish = activity.beginTurn([]);
+    activity.observePayload(JSON.stringify({ type: "response.created", response: { id: "first" } }));
+    output(activity, call);
+    activity.acceptResults([result]);
+    activity.observePayload(JSON.stringify({ type: "response.completed", response: { output: [call] } }));
+    finish();
+    expect(activity.idle).toBe(true);
+    const finishNext = activity.beginTurn([result]); // Full replay repeats a historical result.
+    activity.observePayload(JSON.stringify({ type: "response.created", response: { id: "second" } }));
+    output(activity, call);
+    finishNext();
+    expect(activity.idle).toBe(false);
+    activity.acceptResults([result]);
+    expect(activity.idle).toBe(true);
+  });
+
+  test("hosted shell output clears its call without waiting for a client result", () => {
+    const activity = new CodexWebSocketActivity();
+    const finish = activity.beginTurn([]);
+    const call = { type: "shell_call", call_id: "hosted-shell", action: { commands: ["pwd"] } };
+    const result = { type: "shell_call_output", call_id: "hosted-shell", output: [] };
+    output(activity, call);
+    output(activity, result);
+    activity.observePayload(JSON.stringify({ type: "response.completed", response: { output: [call, result] } }));
+    finish();
+    expect(activity.idle).toBe(true);
+  });
+
+  test.each(["response.inject", "response.create"])("real handler accounts for accepted native results on %s", type => {
+    const client = admittedSocket();
+    const finish = client.activity.beginTurn([]);
+    const call = { type: "function_call", call_id: "native-call" };
+    output(client.activity, call);
+    let accepted = 0;
+    const accept = () => { accepted += 1; return true; };
+    client.ws.data.nativeControl = { relayActive: true, inject: accept, continue: accept } as unknown as NativeResponseControl;
+    handler.message(client.ws, JSON.stringify({ type, input: [
+      { type: "function_call_output", call_id: "native-call", output: "done" },
+    ] }));
+    expect(accepted).toBe(1);
+    expect(client.activity.idle).toBe(false);
+    client.activity.observePayload(JSON.stringify({ type: "response.completed", response: { output: [call] } }));
+    finish();
+    expect(client.activity.idle).toBe(true);
+    expect(client.sent).toHaveLength(0);
+  });
+
+  test.each(["response.inject", "response.create"])("rejected native results on %s cannot release a client tool wait", type => {
+    const client = admittedSocket();
+    output(client.activity, { type: "function_call", call_id: "native-call" });
+    const reject = () => { throw new Error("fixture rejected result"); };
+    client.ws.data.nativeControl = { relayActive: true, inject: reject, continue: reject } as unknown as NativeResponseControl;
+    handler.message(client.ws, JSON.stringify({ type, input: [
+      { type: "function_call_output", call_id: "native-call", output: "done" },
+    ] }));
+    expect(client.sent).toHaveLength(1);
+    expect(client.sent[0]).toMatchObject({ type: "error", status: 400 });
+    expect(client.activity.idle).toBe(false);
+  });
+
+  test("unknown and oversized client result identities remain conservatively protected", () => {
+    for (const callId of [undefined, "", "x".repeat(1025)]) {
+      const activity = new CodexWebSocketActivity();
+      output(activity, { type: "function_call", call_id: callId });
+      activity.beginTurn([{ type: "function_call_output", call_id: callId, output: "done" }])();
+      expect(activity.idle).toBe(false);
+    }
+    const activity = new CodexWebSocketActivity();
+    const results = Array.from({ length: 1025 }, (_, index) => {
+      const call_id = `bounded-${index}`;
+      output(activity, { type: "function_call", call_id });
+      return { type: "function_call_output", call_id, output: "done" };
+    });
+    activity.beginTurn(results)();
+    expect(activity.idle).toBe(false);
+  });
+
+  test("real handler warmup and turn-capacity refusal do not consume pending client results", () => {
+    const client = admittedSocket();
+    output(client.activity, { type: "function_call", call_id: "pending" });
+    const input = [{ type: "function_call_output", call_id: "pending", output: "done" }];
+    handler.message(client.ws, JSON.stringify({ type: "response.create", generate: false, input }));
+    expect(client.sent.map(frame => frame.type)).toEqual(["response.created", "response.completed"]);
+    expect(client.activity.idle).toBe(false);
+    const turns = Array.from({ length: MAX_ACTIVE_TURNS }, () => tryAdmitTurn());
+    try {
+      expect(turns.every(Boolean)).toBe(true);
+      handler.message(client.ws, JSON.stringify({ type: "response.create", model: "fixture", input }));
+      expect(client.sent.at(-1)).toMatchObject({ type: "error", status: 503 });
+      expect(client.activity.idle).toBe(false);
+    } finally {
+      for (const turn of turns) turn?.release();
+    }
+  });
+});
+
+describe("Responses WebSocket capacity reclamation", () => {
+  test("below capacity leaves idle connections open; at capacity reclaims least recently used", () => {
+    const clients = Array.from({ length: MAX_TRACKED_CODEX_WEBSOCKETS }, () => admittedSocket());
+    expect(clients.every(client => client.closed.length === 0)).toBe(true);
+    clients[0].activity.beginTurn([])();
+    const before = codexWebSocketAdmissionMetrics();
+    expect(reserve()).not.toBeNull();
+    expect(clients[0].closed).toHaveLength(0);
+    expect(clients[1].closed).toEqual([{ code: 1001, reason: "Idle Responses connection reclaimed" }]);
+    expect(clients.slice(2).every(client => client.closed.length === 0)).toBe(true);
+    expect(codexWebSocketAdmissionMetrics()).toMatchObject({ active: MAX_TRACKED_CODEX_WEBSOCKETS, peak: MAX_TRACKED_CODEX_WEBSOCKETS,
+      admitted: before.admitted + 1, rejected: before.rejected });
+  });
+
+  test("skips active turns, client tools, buffered output and native control owners", () => {
+    const clients = Array.from({ length: MAX_TRACKED_CODEX_WEBSOCKETS }, () => admittedSocket());
+    const finish = clients[0].activity.beginTurn([]);
+    output(clients[1].activity, { type: "function_call", call_id: "pending" });
+    clients[2].setBuffered(1);
+    clients[3].ws.data.nativeControl = { relayActive: true } as NativeResponseControl;
+    expect(reserve()).not.toBeNull();
+    expect(clients.slice(0, 4).every(client => client.closed.length === 0)).toBe(true);
+    expect(clients[4].closed).toHaveLength(1);
+    finish();
+  });
+
+  test("all busy or unbound reservations leave the cap intact and reject new admission", () => {
+    const clients = Array.from({ length: MAX_TRACKED_CODEX_WEBSOCKETS - 1 }, () => admittedSocket());
+    const finish = clients.map(client => client.activity.beginTurn([]));
+    expect(reserve()).not.toBeNull(); // An upgrade reserved before its open callback.
+    const before = codexWebSocketAdmissionMetrics();
+    expect(reserve()).toBeNull();
+    expect(clients.every(client => client.closed.length === 0)).toBe(true);
+    expect(codexWebSocketAdmissionMetrics()).toMatchObject({ active: MAX_TRACKED_CODEX_WEBSOCKETS, rejected: before.rejected + 1 });
+    for (const end of finish) end();
+  });
+
+  test.each(["delayed", "throw"] as const)("%s close cannot free admission before the close callback", mode => {
+    const victim = admittedSocket(mode);
+    const others = Array.from({ length: MAX_TRACKED_CODEX_WEBSOCKETS - 1 }, () => admittedSocket());
+    const finish = others.map(client => client.activity.beginTurn([]));
+    expect(reserve()).toBeNull();
+    expect(victim.closed).toHaveLength(1);
+    expect(victim.activity.closing).toBe(mode === "delayed");
+    expect(codexWebSocketAdmissionMetrics().active).toBe(MAX_TRACKED_CODEX_WEBSOCKETS);
+    handler.message(victim.ws, JSON.stringify({ type: "response.create", generate: false }));
+    // A closer that throws while still OPEN must not silently disable the old client.
+    expect(victim.sent).toHaveLength(mode === "delayed" ? 0 : 2);
+    expect(victim.ws.data.turnId).toBe(mode === "delayed" ? undefined : 1);
+    expect(reserve()).toBeNull();
+    expect(victim.closed).toHaveLength(mode === "delayed" ? 1 : 2);
+    expect(others.every(client => client.closed.length === 0)).toBe(true);
+    victim.finishClose();
+    victim.finishClose();
+    expect(codexWebSocketAdmissionMetrics().active).toBe(MAX_TRACKED_CODEX_WEBSOCKETS - 1);
+    expect(reserve()).not.toBeNull();
+    expect(codexWebSocketAdmissionMetrics().active).toBe(MAX_TRACKED_CODEX_WEBSOCKETS);
+    for (const end of finish) end();
+  });
+});
diff --git a/tests/config/config-opencode-zen-upgrade.test.ts b/tests/config/config-opencode-zen-upgrade.test.ts
index bda564bc285..02f5b46b6af 100644
--- a/tests/config/config-opencode-zen-upgrade.test.ts
+++ b/tests/config/config-opencode-zen-upgrade.test.ts
@@ -7,8 +7,32 @@ import { handleConfigCommand } from "../../src/cli/config-command";
 import { flushConfigDirHardeningAndReaps } from "../../src/config/paths";
 import { createTempHome } from "../helpers/temp-home";
 
+test("Claude saved overrides and Responses-only preferences migrate without changing unrelated models", () => {
+  const raw = candidate({ "claude-sonnet-5-5": "openai-chat", "claude-opus-5-5": "openai-responses", "qwen-model": "openai-chat" }, {
+    modelPreferHostedTools: { "claude-opus-5-5": ["image_generation"] },
+  });
+  const warn = spyOn(console, "warn").mockImplementation(() => {});
+  try {
+    sanitizeOpenCodeZenOverridesForLoad(raw);
+    expect(raw.providers["opencode-zen"].modelAdapters).toEqual({ "qwen-model": "openai-chat" });
+    expect(raw.providers["opencode-zen"].modelPreferHostedTools).toBeUndefined();
+    expect(validateConfigCandidate(raw).ok).toBe(true);
+  } finally { warn.mockRestore(); }
+});
+
+test.each(["vertex", "cloud-code-assist"])("Claude migration preserves Google mode %s and Gemini overrides", googleMode => {
+  const raw = candidate({ "claude-opus-5-5": "openai-responses", "gemini-3.7-flash": "openai-responses" }, { googleMode });
+  const warn = spyOn(console, "warn").mockImplementation(() => {});
+  try {
+    sanitizeOpenCodeZenOverridesForLoad(raw);
+    expect(raw.providers["opencode-zen"].modelAdapters).toEqual({ "gemini-3.7-flash": "openai-responses" });
+    expect(raw.providers["opencode-zen"].googleMode).toBe(googleMode);
+    expect(validateConfigCandidate(raw).ok).toBe(true);
+  } finally { warn.mockRestore(); }
+});
+
 const BASES = ["https://opencode.ai/zen/v1", "https://opencode.ai/inference/v1"];
-const WARNING = "OpenCode Zen Gemini models now use the native Google API; obsolete Chat/Responses overrides were ignored while loading config.json.";
+const WARNING = "OpenCode Zen Gemini and Claude models now use their native APIs; obsolete Chat/Responses overrides were ignored while loading config.json.";
 
 function candidate(modelAdapters: unknown, overrides: Record<string, unknown> = {}) {
   return {
diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json
index fcca881b055..b29ec798a94 100644
--- a/tests/fixtures/test-layout-expected.json
+++ b/tests/fixtures/test-layout-expected.json
@@ -233,7 +233,8 @@
   "anthropic-sidecar-account-failover.test.ts": "adapters/anthropic",
   "anthropic-stream-hardening.test.ts": "adapters/anthropic", "anthropic-tail-guard.test.ts": "adapters/anthropic",
   "anthropic-progress-updates.test.ts": "adapters/anthropic",
-  "anthropic-thinking-signature.test.ts": "adapters/anthropic", "anthropic-opaque-strip.test.ts": "adapters/anthropic",
+  "anthropic-thinking-signature.test.ts": "adapters/anthropic",
+  "anthropic-replay.test.ts": "adapters/anthropic", "anthropic-opaque-strip.test.ts": "adapters/anthropic",
   "anthropic-tool-call-id.test.ts": "adapters/anthropic",
   "anthropic-messages-passthrough.test.ts": "adapters/anthropic",
   "anthropic-beta-allowlist.test.ts": "adapters/anthropic",
@@ -293,6 +294,7 @@
   "catalog-vision-sidecar-modalities.test.ts": "codex-integration",
   "catalog-zero-credit-picker.test.ts": "codex-integration", "chat-completions-deferred-tools.test.ts": "responses", "passthrough-deferred-tools.test.ts": "responses",
   "chat-completions-endpoint.test.ts": "responses", "chat-completions-pool-mode.test.ts": "responses",
+  "chat-request-id-endpoint.test.ts": "responses",
   "chat-conversation-affinity.test.ts": "responses", "chat-inbound-developer-position.test.ts": "responses",
   "protocol-contract.test.ts": "responses", "protocol-features.test.ts": "responses",
   "protocol-opaque-state.test.ts": "responses", "protocol-baseline.test.ts": "responses",
@@ -414,6 +416,7 @@
   "cli-restore-back.test.ts": "cli", "cli-route-policy-not-found.test.ts": "cli",
   "cli-start-auxiliary-bind.test.ts": "cli", "cli-start-journal-order.test.ts": "cli",
   "sibling-home-client-sync.test.ts": "cli", "cli-status-hub-state.test.ts": "cli",
+  "cross-home-loopback-family.test.ts": "cli",
   "cli-status-json.test.ts": "cli", "cli-status-oauth-health.test.ts": "cli",
   "cli-stop-json.test.ts": "cli", "cli-storage-inspect.test.ts": "cli",
   "cli-transport-honesty.test.ts": "cli", "cli-update-badge.test.ts": "cli",
@@ -557,7 +560,8 @@
   "codex-user-identity.test.ts": "codex-integration", "codex-v2-gate.test.ts": "codex-integration",
   "codex-agent-thread-limit.test.ts": "codex-integration",
   "codex-warmup.test.ts": "codex-integration", "codex-web-search-switch.test.ts": "codex-integration",
-  "codex-websocket-registry.test.ts": "codex-integration", "codex-write-lock.test.ts": "codex-integration",
+  "codex-websocket-registry.test.ts": "codex-integration",
+  "websocket-capacity-activity.test.ts": "codex-integration", "codex-write-lock.test.ts": "codex-integration",
   "coding-agent-tool-result-images.test.ts": "adapters", "cold-spawn-warmup.test.ts": "ci-workflows",
   "combo-authoritative-reset.test.ts": "codex-integration",
   "combo-codex-exhaustion-cooldown.test.ts": "codex-integration",
@@ -686,7 +690,7 @@
   "flash-route-image-modalities.test.ts": "providers", "format-result.test.ts": "web-search",
   "forward-admission-separation.test.ts": "providers", "fresh-connection-optout.test.ts": "responses",
   "fulfill-video.test.ts": "videos", "gather-routed-models-single-flight.test.ts": "codex-integration",
-  "gcp-adc.test.ts": "adapters/google", "gemini-37-flash-migration.test.ts": "adapters/google", "gemini-4-argon-antigravity.test.ts": "adapters/google", "antigravity-account-roster.test.ts": "adapters/google",
+  "gcp-adc.test.ts": "adapters/google", "gemini-37-flash-migration.test.ts": "adapters/google", "gemini-4-argon-antigravity.test.ts": "adapters/google", "gemini-progress-history.test.ts": "adapters/google", "antigravity-account-roster.test.ts": "adapters/google",
   "gemini-inline.test.ts": "images", "gemini-web-search.test.ts": "adapters/google",
   "generic-session-affinity.test.ts": "oauth",
   "server-generic-oauth-affinity.test.ts": "server",
@@ -1042,6 +1046,10 @@
   "response-log-inspection.test.ts": "server", "response-model-identity.test.ts": "server",
   "responses-4546-incident-regression.test.ts": "responses", "responses-account-change-scrub.test.ts": "responses",
   "responses-account-label.test.ts": "responses", "responses-anthropic-fast-downgrade.test.ts": "responses",
+  "responses-anthropic-thinking-signature-recovery.test.ts": "responses",
+  "responses-web-search-thinking-signature-recovery.test.ts": "responses",
+  "responses-anthropic-thinking-recovery.test.ts": "responses",
+  "responses-anthropic-legal-history.test.ts": "responses",
   "responses-azure-opaque-blob-recovery.test.ts": "responses", "responses-bare-echo-helper-fence.test.ts": "responses",
   "responses-canonical-only-top-level-fields.test.ts": "responses",
   "responses-chatgpt-web-replay-metadata.test.ts": "responses", "responses-code-mode-goal-helpers.test.ts": "responses",
@@ -1126,6 +1134,7 @@
   "server-opencode-go-goal-streaming.test.ts": "server", "server-rate-limit-retry-e2e.test.ts": "server",
   "server-request-body-size.test.ts": "server", "server-search.test.ts": "server",
   "server-startup-reconcile-resilience.test.ts": "server", "server-stop-config-hardening.test.ts": "server",
+  "server-startup-codex-off.test.ts": "server",
   "server-xai-chat-reasoning-streaming.test.ts": "server", "server-xai-header-parity.test.ts": "server",
   "server-xai-oauth-401-replay.test.ts": "server", "server-xai-responses-streaming.test.ts": "server",
   "service-auth-qualified-localhost.test.ts": "service", "service-child-ownership.test.ts": "service",
@@ -1276,6 +1285,8 @@
   "winsw.test.ts": "service",
   "workflow-budget.test.ts": "lib",
   "ws-ambiguous-resend.test.ts": "responses", "ws-pre-output-refusal.test.ts": "responses", "responses-pool-overload-failover.test.ts": "responses", "compact-transient-alternate.test.ts": "responses",
+  "ws-capacity-reclamation.test.ts": "responses",
+  "ws-capacity-tool-ownership.test.ts": "responses",
   "ws-endpoint.test.ts": "responses",
   "ws-failure-stage.test.ts": "responses",
   "ws-native-injection.test.ts": "responses",
diff --git a/tests/helpers/responses-core-source.ts b/tests/helpers/responses-core-source.ts
index d487d4609b5..13867fa68bb 100644
--- a/tests/helpers/responses-core-source.ts
+++ b/tests/helpers/responses-core-source.ts
@@ -47,6 +47,7 @@ export const RESPONSES_CORE_MODULES = [
   "request-transport.ts",
   "request-sidecar-auth.ts",
   "response-effects.ts",
+  "response-tool-ownership.ts",
   "request-send-budget.ts",
   "passthrough-execution.ts",
   "passthrough-dispatch.ts",
@@ -67,6 +68,7 @@ export const RESPONSES_CORE_MODULES = [
   "antigravity-validation-refusal.ts",
   "adapter-continuation.ts",
   "adapter-delivery.ts",
+  "anthropic-thinking-recovery.ts",
   "advisor-slot.ts",
   "advisor-retention.ts",
   "advisor-plan-slot.ts",
diff --git a/tests/lib/failure-stage-model.test.ts b/tests/lib/failure-stage-model.test.ts
index 893f85b6178..078942991fd 100644
--- a/tests/lib/failure-stage-model.test.ts
+++ b/tests/lib/failure-stage-model.test.ts
@@ -199,8 +199,10 @@ describe("recovery kinds speak the shared dictionary", () => {
    * the durable log were forbidden and unfunded.
    */
   test("no recorded recovery classifies as a resend that cannot help", () => {
+    // Except the Codex 402 account move: re-asking the exhausted account is futile, and the move
+    // to another account is a route decision this table explicitly does not make.
     const futile = ATTEMPT_RECOVERY_KIND_ROSTER
       .filter(kind => causeDisposition(causeForRecoveryKind(kind)) === "resend-is-futile");
-    expect(futile).toEqual([]);
+    expect(futile).toEqual(["oauth-account-402"]);
   });
 });
diff --git a/tests/oauth/generic-oauth-combo-account-cooldown.test.ts b/tests/oauth/generic-oauth-combo-account-cooldown.test.ts
index 0ec326ed748..b8ec163c75d 100644
--- a/tests/oauth/generic-oauth-combo-account-cooldown.test.ts
+++ b/tests/oauth/generic-oauth-combo-account-cooldown.test.ts
@@ -12,6 +12,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { clearComboSelectionState, clearComboTargetCooldowns, isComboTargetInCooldown } from "../../src/combos";
 import { clearGenericFailoverHealth, eligibleFailoverAccounts } from "../../src/oauth/generic-account-failover";
+import { genericPoolKey, peekRoundRobinAccount } from "../../src/oauth/pool-kernel";
 import { getAccountSet, saveCredential, setActiveAccount } from "../../src/oauth/store";
 import { clearAccountQuotaCache } from "../../src/providers/quota";
 import { clearResponseStateForTests, flushResponseState } from "../../src/responses/state";
@@ -129,3 +130,20 @@ test("every generic OAuth account spent still cools the combo target", async ()
   expect(sends).toEqual(["1", "2", "B"]);
   expect(isComboTargetInCooldown("pooled", TARGET)).toBe(true);
 }, 20_000);
+
+test("the combo's sibling check does not advance a round-robin pool onto an unsent account", async () => {
+  await seed(5);
+  upstream(4);
+  const roundRobin: OcxConfig = { ...config, pool: { kernel: true }, providers: { ...config.providers,
+    xai: { ...config.providers.xai!, oauthAccountFailover: { strategy: "round-robin", stickyLimit: 3 } } } };
+  const ids = getAccountSet("xai")!.accounts.map(account => account.id);
+  const response = await handleResponses(new Request("http://localhost/v1/responses", {
+    method: "POST", headers: { "content-type": "application/json" },
+    body: JSON.stringify({ model: "combo/pooled", input: "Answer briefly", stream: false }),
+  }), roundRobin, { model: "", provider: "" });
+  expect(await response.text()).toContain("fallback answer");
+  expect(sends).not.toContain("5");
+  expect(isComboTargetInCooldown("pooled", TARGET)).toBe(false);
+  // Account 5 was only probed for eligibility, never sent; the ring must not stick to it.
+  expect(peekRoundRobinAccount(genericPoolKey("xai"), ids, 3)).not.toBe(ids[4]);
+}, 20_000);
diff --git a/tests/providers/opencode-zen-gemini-wire.test.ts b/tests/providers/opencode-zen-gemini-wire.test.ts
index fb5dd4cdc59..ac4b043612e 100644
--- a/tests/providers/opencode-zen-gemini-wire.test.ts
+++ b/tests/providers/opencode-zen-gemini-wire.test.ts
@@ -45,6 +45,16 @@ function expectWire(providerName: string, provider: OcxProviderConfig, modelId:
 }
 
 describe("OpenCode Zen Gemini destination and wire policy", () => {
+  test("Claude uses Messages across runtime, static and Fast policy", () => {
+    for (const baseUrl of BASES) for (const model of ["claude-sonnet-5-5", "claude-opus-5-5", "claude-haiku-5-5", "Claude-future"]) {
+      for (const googleMode of [undefined, "ai-studio", "vertex", "cloud-code-assist"] as const) for (const adapter of ["openai-chat", "openai-responses"] as const) {
+        expectWire("opencode-zen", zen({ baseUrl, googleMode, modelAdapters: { [model]: adapter } }), model, "anthropic");
+      }
+      expectWire("renamed-zen", zen({ baseUrl }), model, "openai-chat");
+      expectWire("opencode-zen", zen({ baseUrl: "https://custom.example.test/v1" }), model, "openai-chat");
+      expectWire("opencode-zen", zen({ baseUrl, authMode: "oauth" }), model, "openai-chat");
+    }
+  });
   test.each(BASES)("pins Gemini models at %s across runtime, static and Fast policy", baseUrl => {
     for (const model of MODELS) for (const override of ["openai-chat", "openai-responses"]) {
       const provider = zen({ baseUrl, modelAdapters: { [model]: override }, supportsServiceTier: true });
@@ -103,13 +113,13 @@ describe("OpenCode Zen Gemini destination and wire policy", () => {
     const authority = captureFastPolicyAuthority("opencode-zen", provider, true);
     provider.baseUrl = "https://custom.example.test/v1";
     expect(Object.isFrozen(prefixes)).toBe(true);
-    expect(prefixes).toEqual({ "gemini-": "google" });
+    expect(prefixes).toEqual({ "gemini-": "google", "claude-": "anthropic" });
     expect(resolveFastPolicy(authority, "gemini-3.7-flash").adapter).toBe("google");
     expect(fastPolicyForModel(provider, "gemini-3.7-flash", "opencode-zen").adapter).toBe("openai-responses");
   });
 
   test("Zen siblings and other provider identities retain their existing wires", () => {
-    for (const model of ["claude-sonnet-5-5", "gpt-6.1-sol", "deepseek-v4-flash", "not-gemini-3.7-flash"]) {
+    for (const model of ["gpt-6.1-sol", "deepseek-v4-flash", "not-gemini-3.7-flash"]) {
       expect(openCodeZenGeminiEndpoint(zen(), model)).toBeUndefined();
       expectWire("opencode-zen", zen(), model, "openai-chat");
       expectWire("opencode-zen", zen({ modelAdapters: { [model]: "openai-responses" } }), model, "openai-responses");
@@ -171,6 +181,29 @@ describe("OpenCode Zen Gemini Responses translation", () => {
     globalThis.fetch = originalFetch;
   });
 
+  test("translated Claude uses parsed rate-limit types and preserves upstream retry hints", async () => {
+    releaseSpendHome = acquireOwnedSpendHome();
+    for (const retryAfter of [undefined, "37"]) {
+      let sends = 0;
+      globalThis.fetch = (async () => {
+        sends++;
+        return Response.json({ type: "error", error: { type: "rate_limit_error", message: "Too Many Requests" } },
+          { status: 429, headers: retryAfter ? { "retry-after": retryAfter } : {} });
+      }) as typeof fetch;
+      const config = { providers: { "opencode-zen": zen() } } as unknown as OcxConfig;
+      const response = await handleResponses(new Request("http://localhost/v1/responses", {
+        method: "POST", headers: { "content-type": "application/json" },
+        body: JSON.stringify({ model: "opencode-zen/claude-sonnet-5-5", input: "hello", stream: false }),
+      }), config, { model: "", provider: "" }, { inboundWire: "responses" });
+      const text = await response.text();
+      expect(response.status, text).toBe(429);
+      expect(response.headers.get("retry-after")).toBe(retryAfter ?? "15");
+      expect(text).toContain("15-20 requests per minute");
+      expect(text.includes("Try again in 15s")).toBe(!retryAfter);
+      expect(sends).toBe(1);
+    }
+  });
+
   // Routing canonicalizes the fixed Zen preset to /zen/v1; both accepted endpoint
   // spellings are exercised without that registry normalization in the adapter cases above.
   for (const baseUrl of [BASES[0]!]) for (const stream of [true, false]) {
diff --git a/tests/providers/opencode-zen-rate-limit.test.ts b/tests/providers/opencode-zen-rate-limit.test.ts
index e8e90d94162..5857f822c02 100644
--- a/tests/providers/opencode-zen-rate-limit.test.ts
+++ b/tests/providers/opencode-zen-rate-limit.test.ts
@@ -78,6 +78,47 @@ describe("opencode-zen rate-limit guidance (#1145)", () => {
     })).toBe(String(OPENCODE_ZEN_SYNTHETIC_RETRY_AFTER_SEC));
   });
 
+  test("explicit rate-limit types receive guidance without matching message text", () => {
+    const enriched = enrichOpenCodeZenUpstreamMessage("Too Many Requests", {
+      status: 429, providerName: "opencode-zen", upstreamErrorType: "rate_limit_error",
+    });
+    expect(enriched).toContain("Try again in 15s");
+    expect(resolveClientRetryAfter({ status: 429, message: enriched })).toBe("15");
+  });
+
+  test("rate limits mentioning a plan or load balancer still receive guidance", () => {
+    for (const message of ["Rate limit exceeded for credit-based plan", "load balancer rate limit", "balanced throughput"]) {
+      expect(enrichOpenCodeZenUpstreamMessage(message, {
+        status: 429, providerName: "opencode-zen", upstreamErrorType: "rate_limit_error",
+      })).toContain("Try again in 15s");
+    }
+  });
+
+  test("quota errors never receive short-window pacing guidance", () => {
+    for (const [upstreamErrorType, message] of [
+      ["insufficient_quota", "Rate limit exceeded"],
+      ["rate_limit_error", "Monthly quota exceeded; rate limit exceeded"],
+      ["insufficient_quota", "Too Many Requests"],
+      ["rate_limit_error", "Rate limit exceeded: insufficient credit"],
+      ["rate_limit_error", "Rate limit exceeded: balance exhausted"],
+      ["billing_error", "Too Many Requests"],
+      ["rate_limit_error", "The usage limit has been reached"],
+      ["usage_limit_reached", "Too Many Requests"],
+    ]) {
+      expect(enrichOpenCodeZenUpstreamMessage(message!, {
+        status: 429, providerName: "opencode-zen", upstreamErrorType,
+      })).toBe(message!);
+    }
+  });
+
+  test("structured quota and billing codes suppress pacing guidance", () => {
+    for (const upstreamErrorCode of ["insufficient_quota", "billing_hard_limit_reached", "usage_limit_reached"]) {
+      expect(enrichOpenCodeZenUpstreamMessage("Rate limit exceeded", {
+        status: 429, providerName: "opencode-zen", upstreamErrorType: "rate_limit_error", upstreamErrorCode,
+      })).toBe("Rate limit exceeded");
+    }
+  });
+
   test("enrichOpenCodeZenRateLimitMessage skips synthetic hint when upstream Retry-After is set", () => {
     const enriched = enrichOpenCodeZenRateLimitMessage(
       "Provider error 429: Rate limit exceeded.",
diff --git a/tests/providers/umans-provider.test.ts b/tests/providers/umans-provider.test.ts
index 755b50570a6..69a0062369d 100644
--- a/tests/providers/umans-provider.test.ts
+++ b/tests/providers/umans-provider.test.ts
@@ -201,9 +201,13 @@ describe("Umans provider", () => {
 
     const events = await collect(createAnthropicAdapter(umansProvider()).parseStream(new Response(stream)));
 
-    expect(events[0]).toEqual({ type: "tool_call_start", id: "toolu_1", name: "web_search" });
-    expect(events[1]).toEqual({ type: "tool_call_delta", arguments: "{\"query\":\"umans\"}" });
-    expect(events[2]).toEqual({ type: "tool_call_end" });
+    expect(events).toEqual([
+      { type: "heartbeat", replayUnsafe: true },
+      { type: "tool_call_start", id: "toolu_1", name: "web_search" },
+      { type: "tool_call_delta", arguments: "{\"query\":\"umans\"}" },
+      { type: "tool_call_end" },
+      { type: "done", usage: undefined, stopReason: undefined },
+    ]);
   });
 
   test("Anthropic adapter strips Umans compatibility prefix from non-streaming tool calls", async () => {
diff --git a/tests/responses/chat-request-id-endpoint.test.ts b/tests/responses/chat-request-id-endpoint.test.ts
new file mode 100644
index 00000000000..5c8030bd8f5
--- /dev/null
+++ b/tests/responses/chat-request-id-endpoint.test.ts
@@ -0,0 +1,177 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { saveConfig } from "../../src/config";
+import { startServer } from "../../src/server";
+import { MAX_ACTIVE_TURNS, tryAdmitTurn } from "../../src/server/lifecycle";
+import { MAX_CONCURRENT_INBOUND_BODY_BYTES, withRaisedInboundBodyAdmission } from "../../src/server/inbound-body-admission";
+import { readRecentUsageEntries } from "../../src/usage/log";
+import { admitWorkflowTurn, chargeWorkflowSends, DEFAULT_WORKFLOW_BUDGET_POLICY, resetWorkflowBudgetsForTest } from "../../src/lib/workflow-budget";
+import { installIsolatedCodexHome, type IsolatedCodexHome } from "../helpers/isolated-codex-home";
+import { drainAndRemoveFixtureRoots } from "../helpers/fixture-teardown";
+import type { OcxConfig } from "../../src/types";
+
+let fixtureHome = "";
+let previousHome: string | undefined;
+let codexHome: IsolatedCodexHome | undefined;
+let proxy: ReturnType<typeof startServer> | undefined;
+let upstream: ReturnType<typeof Bun.serve> | undefined;
+const origin = "http://fixture.example";
+
+beforeEach(() => {
+  previousHome = process.env.OPENCODEX_HOME;
+  fixtureHome = mkdtempSync(join(tmpdir(), "ocx-chat-request-id-"));
+  process.env.OPENCODEX_HOME = fixtureHome;
+  codexHome = installIsolatedCodexHome("ocx-chat-id-codex-");
+  resetWorkflowBudgetsForTest();
+});
+
+afterEach(async () => {
+  await proxy?.stop(true);
+  proxy = undefined;
+  await upstream?.stop(true);
+  upstream = undefined;
+  resetWorkflowBudgetsForTest();
+  await drainAndRemoveFixtureRoots({
+    roots: [{ path: fixtureHome }, ...(codexHome ? [{ path: codexHome.path }] : [])],
+    restoreEnvironment() {
+      if (previousHome === undefined) delete process.env.OPENCODEX_HOME;
+      else process.env.OPENCODEX_HOME = previousHome;
+      codexHome?.restoreEnvironment();
+    },
+  });
+  codexHome = undefined;
+});
+
+function launch(authenticated = false, status = 200, override: Partial<OcxConfig> = {}, hang = false) {
+  upstream = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch() {
+    if (status !== 200) return Response.json({ error: { message: "fixture refusal" } }, { status });
+    const frame = { id: "shared-provider-id", choices: [{ index: 0, delta: { content: "fixture answer" }, finish_reason: "stop" }],
+      usage: { prompt_tokens: 11, completion_tokens: 5, prompt_tokens_details: { cached_tokens: 3 } } };
+    const body = hang ? new ReadableStream<Uint8Array>({ start(controller) {
+      controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify({ ...frame, choices: [{ index: 0, delta: { content: "OPEN" }, finish_reason: null }], usage: undefined })}\n\n`));
+    } }, { highWaterMark: 0 }) : `data: ${JSON.stringify(frame)}\n\ndata: [DONE]\n\n`;
+    return new Response(body, { headers: {
+      "content-type": "text/event-stream", "x-opencodex-request-id": "upstream-controlled",
+    } });
+  } });
+  saveConfig({ port: 0, hostname: authenticated ? "0.0.0.0" : "127.0.0.1", defaultProvider: "mock",
+    codexAutoStart: false, codexShimAutoRestore: false, connectTimeoutMs: 1000,
+    apiKeys: [{ id: "fixture-key-id", name: "fixture", key: "fixture-data-key", createdAt: "2026-01-01T00:00:00Z" }],
+    providers: { mock: { adapter: "openai-chat", baseUrl: `${upstream.url.toString().replace(/\/$/, "")}/v1`,
+      apiKey: "fixture-provider-key", allowPrivateNetwork: true, liveModels: false, models: ["echo"] } },
+    corsAllowOrigins: [origin], ...override,
+  } as OcxConfig);
+  proxy = startServer(0);
+}
+
+function send(stream = false, headers: Record<string, string> = {}, invalid = false, signal?: AbortSignal) {
+  return fetch(`http://127.0.0.1:${proxy!.port}/v1/chat/completions`, { method: "POST", signal, headers: {
+    "content-type": "application/json", authorization: "Bearer fixture-data-key", origin,
+    "x-opencodex-request-id": "caller-controlled", ...headers,
+  }, body: JSON.stringify({ model: "mock/echo", stream, messages: invalid ? null : [{ role: "user", content: "fixture question" }] }) });
+}
+
+async function durableRow(response: Response, expectedStatus: number) {
+  expect(response.status).toBe(expectedStatus);
+  const id = response.headers.get("x-opencodex-request-id");
+  expect(id).toMatch(/^ocx-[a-f0-9]{32}$/);
+  expect(response.headers.get("access-control-allow-origin")).toBe(origin);
+  const exposed = response.headers.get("access-control-expose-headers")!.toLowerCase().split(",").map(name => name.trim());
+  expect(exposed.filter(name => name === "x-opencodex-request-id")).toHaveLength(1);
+  const text = await response.text();
+  let rows = readRecentUsageEntries(100, fixtureHome).filter(row => row.requestId === id);
+  for (let i = 0; i < 100 && rows.length === 0; i++) {
+    await Bun.sleep(10);
+    rows = readRecentUsageEntries(100, fixtureHome).filter(row => row.requestId === id);
+  }
+  expect(rows).toHaveLength(1);
+  expect(rows[0]!.status).toBe(expectedStatus);
+  expect(rows[0]!.inboundProtocol).toBe("chat");
+  return { row: rows[0]!, text, id };
+}
+
+for (const authenticated of [false, true]) {
+  for (const stream of [false, true]) test(`${authenticated ? "authenticated" : "loopback"} Chat ${stream ? "SSE" : "JSON"} correlates to its history row`, async () => {
+    launch(authenticated);
+    const { row, text } = await durableRow(await send(stream), 200);
+    expect(text).toContain("fixture answer");
+    if (stream) expect(text).toContain("[DONE]");
+    else expect(JSON.parse(text).choices[0].message.content).toBe("fixture answer");
+    expect(row.usage).toEqual({ inputTokens: 11, outputTokens: 5, cachedInputTokens: 3 });
+  });
+}
+
+test("concurrent replies with identical upstream completion IDs have distinct history IDs", async () => {
+  launch();
+  const replies = await Promise.all(Array.from({ length: 3 }, () => send()));
+  const records = await Promise.all(replies.map(reply => durableRow(reply, 200)));
+  expect(new Set(records.map(record => record.id)).size).toBe(3);
+});
+
+test("handler-recorded invalid request has a history ID", async () => {
+  launch();
+  await durableRow(await send(false, {}, true), 400);
+});
+
+test("upstream HTTP error has a history ID", async () => {
+  launch(false, 503);
+  await durableRow(await send(), 503);
+});
+
+test("pre-handler workflow refusal has the logged history ID", async () => {
+  launch();
+  const admitted = admitWorkflowTurn("fixture-root", "interactive");
+  expect(admitted?.admitted).toBe(true);
+  if (admitted?.admitted) admitted.lease.release();
+  chargeWorkflowSends("fixture-root", DEFAULT_WORKFLOW_BUDGET_POLICY.maxPhysicalSends);
+  const response = await send(false, { "x-codex-parent-thread-id": "fixture-root" });
+  const { row } = await durableRow(response, 429);
+  expect(response.headers.get("access-control-expose-headers")).toContain("x-opencodex-local-refusal");
+  expect(row.errorCode).toBe(response.headers.get("x-opencodex-local-refusal"));
+});
+
+test("pre-handler body-capacity refusal has a history ID", async () => {
+  launch(false, 200, { maxInboundBodyBytes: MAX_CONCURRENT_INBOUND_BODY_BYTES });
+  const held = await withRaisedInboundBodyAdmission(new Request("http://localhost/v1/chat/completions", {
+    method: "POST", body: "{}",
+  }), "/v1/chat/completions", MAX_CONCURRENT_INBOUND_BODY_BYTES,
+  async () => new Response(new ReadableStream<Uint8Array>({}, { highWaterMark: 0 })));
+  try { await durableRow(await send(), 503); }
+  finally { await held.body!.cancel("fixture released"); }
+});
+
+test("stream cancellation keeps its eventual history ID", async () => {
+  launch(false, 200, {}, true);
+  const client = new AbortController();
+  try {
+    const response = await send(true, {}, false, client.signal);
+    const id = response.headers.get("x-opencodex-request-id");
+    expect(id).toMatch(/^ocx-[a-f0-9]{32}$/);
+    client.abort();
+    await response.body!.cancel().catch(() => {});
+    let row = readRecentUsageEntries(100, fixtureHome).find(entry => entry.requestId === id);
+    for (let i = 0; i < 100 && !row; i++) {
+      await Bun.sleep(10);
+      row = readRecentUsageEntries(100, fixtureHome).find(entry => entry.requestId === id);
+    }
+    expect(row?.status).toBe(499);
+    expect(row?.inboundProtocol).toBe("chat");
+  } finally { client.abort(); }
+});
+
+for (const rejection of ["auth", "origin", "active-turn"] as const) test(`${rejection} refusal has no fabricated history ID`, async () => {
+  launch(true);
+  const leases = rejection === "active-turn" ? Array.from({ length: MAX_ACTIVE_TURNS }, () => tryAdmitTurn()) : [];
+  try {
+    if (leases.length) expect(leases.every(Boolean)).toBe(true);
+    const before = readRecentUsageEntries(100, fixtureHome).length;
+    const response = await send(false, rejection === "auth" ? { authorization: "Bearer invalid-fixture-key" }
+      : rejection === "origin" ? { origin: "https://untrusted.invalid" } : {});
+    expect(response.status).toBe(rejection === "auth" ? 401 : rejection === "origin" ? 403 : 503);
+    expect(response.headers.has("x-opencodex-request-id")).toBe(false);
+    await response.text();
+    expect(readRecentUsageEntries(100, fixtureHome)).toHaveLength(before);
+  } finally { for (const lease of leases) lease?.release(); }
+});
diff --git a/tests/responses/responses-account-label.test.ts b/tests/responses/responses-account-label.test.ts
index c127c0ae2c0..a88745c707c 100644
--- a/tests/responses/responses-account-label.test.ts
+++ b/tests/responses/responses-account-label.test.ts
@@ -11,7 +11,8 @@ import {
   clearThreadAccountMap,
   getCodexUpstreamHealth,
 } from "../../src/codex/routing";
-import type { RequestLogContext } from "../../src/server/request-log";
+import { addFinalRequestLog, type RequestLogContext } from "../../src/server/request-log";
+import { createRequestMetricsOwner } from "../../src/server/request-metrics";
 import { handleResponses } from "../../src/server/responses";
 import type { OcxConfig } from "../../src/types";
 import { removeTreeWithRetry } from "../helpers/remove-tree";
@@ -336,6 +337,37 @@ describe("Responses account usage attribution", () => {
     });
   });
 
+  test("a pre-stream 402 move is recorded and counted as a quota recovery, not a rate limit", async () => {
+    await withPoolHome(async () => {
+      takeSpendHome();
+      const config = poolConfig(["pool-a", "pool-b"]);
+      for (const id of ["pool-a", "pool-b"]) {
+        savePoolCredential(id);
+        updateAccountQuota(id, id === "pool-a" ? 10 : 20);
+      }
+      let sends = 0;
+      globalThis.fetch = (async () => ++sends === 1
+        ? Response.json({ error: { message: "payment required" } }, { status: 402 })
+        : completedResponse("pool-b-response")) as typeof fetch;
+
+      const metrics = createRequestMetricsOwner(123);
+      const logCtx: RequestLogContext = { model: "", provider: "", inboundProtocol: "responses", requestMetricsRecorder: metrics };
+      const response = await handleResponses(request(), config, logCtx, {});
+      expect(response.status).toBe(200);
+      expect(logCtx.attempts?.map(attempt => [attempt.status, attempt.recoveryKinds])).toEqual([
+        [402, []],
+        [0, ["oauth-account-402"]],
+      ]);
+
+      addFinalRequestLog("codex-402-move", Date.now() - 1_000, logCtx, 200, {
+        terminalStatus: "completed", closeReason: "terminal",
+      }, () => {});
+      const recoveries = metrics.snapshot().split("\n").filter(line => line.startsWith("opencodex_recoveries_total{"));
+      expect(recoveries.find(line => line.includes('recovery="quota"'))?.endsWith(" 1")).toBe(true);
+      expect(recoveries.find(line => line.includes('recovery="rate_limit"'))?.endsWith(" 0") ?? true).toBe(true);
+    });
+  });
+
   test("a quota message wrapped in HTTP 502 cools the account and retries an alternate", async () => {
     await withPoolHome(async () => {
       takeSpendHome();
diff --git a/tests/responses/responses-anthropic-legal-history.test.ts b/tests/responses/responses-anthropic-legal-history.test.ts
new file mode 100644
index 00000000000..416004cf1c3
--- /dev/null
+++ b/tests/responses/responses-anthropic-legal-history.test.ts
@@ -0,0 +1,150 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resetWorkflowBudgetsForTest } from "../../src/lib/workflow-budget";
+import { clearReasoningReplayCacheForTests } from "../../src/responses/reasoning-replay-cache";
+import { resetThoughtSignatureReplayForTests } from "../../src/responses/thought-signature-replay";
+import { handleResponses } from "../../src/server/responses/core";
+import type { RequestLogContext } from "../../src/server/request-log";
+import type { OcxConfig } from "../../src/types";
+import { acquireOwnedSpendHome } from "../helpers/owned-spend-home";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+const originalFetch = globalThis.fetch;
+const originalHome = process.env.OPENCODEX_HOME;
+const SIGNATURE = "SyntheticPrefixSignature123456==";
+const SECOND_SIGNATURE = "SyntheticNextPrefixSignature123456==";
+const MODEL = "claude-opus-5-5";
+const TOOLS = [{ type: "function", name: "lookup", description: "Fixture lookup", parameters: { type: "object", properties: {} } }];
+type Item = Record<string, unknown>;
+let home = "";
+let release: (() => void) | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "ocx-prefix-roundtrip-"));
+  process.env.OPENCODEX_HOME = home;
+  release = acquireOwnedSpendHome();
+  clearReasoningReplayCacheForTests();
+  resetThoughtSignatureReplayForTests();
+  resetWorkflowBudgetsForTest();
+});
+afterEach(() => {
+  try { release?.(); } finally {
+    release = undefined;
+    globalThis.fetch = originalFetch;
+    clearReasoningReplayCacheForTests();
+    resetThoughtSignatureReplayForTests();
+    resetWorkflowBudgetsForTest();
+    if (originalHome === undefined) delete process.env.OPENCODEX_HOME;
+    else process.env.OPENCODEX_HOME = originalHome;
+    removeTreeWithRetry(home);
+  }
+});
+
+function config(): OcxConfig {
+  return { defaultProvider: "anthropic-test", emptyCompletionRetry: false, providers: { "anthropic-test": {
+    adapter: "anthropic", baseUrl: "https://anthropic.example.test", authMode: "key",
+    apiKey: "synthetic-test-key", proxy: "direct", models: [MODEL, "claude-sonnet-4-5"],
+  } } } as OcxConfig;
+}
+const user = (text: string): Item => ({ type: "message", role: "user", content: [{ type: "input_text", text }] });
+function request(input: Item[], stream: boolean, overrides: Item = {}): Request {
+  return new Request("http://localhost/v1/responses", {
+    method: "POST", headers: { "content-type": "application/json", "x-codex-parent-thread-id": "prefix-fixture-thread" },
+    body: JSON.stringify({ model: `anthropic-test/${MODEL}`, stream, store: false,
+      instructions: "Preserve the fixture context.", reasoning: { effort: "high", summary: "detailed" },
+      tools: TOOLS, input, ...overrides }),
+  });
+}
+function frame(type: string, data: Item = {}): string {
+  return `event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`;
+}
+function signedFrames(signature = SIGNATURE, thinking = "Complete fixture reasoning"): string[] {
+  return [
+    frame("message_start", { message: { id: "msg_fixture", role: "assistant", content: [], usage: { input_tokens: 2 } } }),
+    frame("content_block_start", { index: 0, content_block: { type: "thinking", thinking: "" } }),
+    frame("content_block_delta", { index: 0, delta: { type: "thinking_delta", thinking } }),
+    frame("content_block_delta", { index: 0, delta: { type: "signature_delta", signature } }),
+    frame("content_block_stop", { index: 0 }),
+  ];
+}
+function upstream(signature = SIGNATURE, tool = false, stream = true): Response {
+  if (!stream) return Response.json({ id: "msg_fixture", type: "message", role: "assistant", model: MODEL,
+    content: [{ type: "thinking", thinking: "Complete fixture reasoning", signature },
+      tool ? { type: "tool_use", id: "tool_fixture", name: "lookup", input: {} } : { type: "text", text: "Fixture answer" }],
+    stop_reason: tool ? "tool_use" : "end_turn", usage: { input_tokens: 2, output_tokens: 3 } });
+  const frames = signedFrames(signature);
+  if (tool) frames.push(
+    frame("content_block_start", { index: 1, content_block: { type: "tool_use", id: "tool_fixture", name: "lookup", input: {} } }),
+    frame("content_block_delta", { index: 1, delta: { type: "input_json_delta", partial_json: "{}" } }),
+    frame("content_block_stop", { index: 1 }),
+  );
+  else frames.push(
+    frame("content_block_start", { index: 1, content_block: { type: "text", text: "" } }),
+    frame("content_block_delta", { index: 1, delta: { type: "text_delta", text: "Fixture answer" } }),
+    frame("content_block_stop", { index: 1 }),
+  );
+  frames.push(frame("message_delta", { delta: { stop_reason: tool ? "tool_use" : "end_turn" }, usage: { output_tokens: 3 } }), frame("message_stop"));
+  return new Response(frames.join(""), { headers: { "content-type": "text/event-stream" } });
+}
+function transport(answer: (index: number, stream: boolean) => Response | Promise<Response>) {
+  const bodies: string[] = [];
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = input instanceof Request ? input.url : String(input);
+    if (!["https://anthropic.example.test/v1/messages", "https://other-anthropic.example.test/v1/messages"].includes(url)) {
+      throw new Error(`Unexpected network target blocked: ${url}`);
+    }
+    bodies.push(String(init?.body));
+    return answer(bodies.length, JSON.parse(String(init?.body)).stream === true);
+  }) as typeof fetch;
+  return bodies;
+}
+async function send(input: Item[], stream = false, overrides: Item = {}, cfg = config(), options: Parameters<typeof handleResponses>[3] = {}) {
+  const log: RequestLogContext = { model: "", provider: "" };
+  const response = await handleResponses(request(input, stream, overrides), cfg, log, options);
+  const text = await response.text();
+  const events = stream ? text.split("\n").filter(line => line.startsWith("data: {"))
+    .map(line => JSON.parse(line.slice(6)) as Item) : [];
+  const json = stream ? undefined : JSON.parse(text);
+  const output = (stream ? events.filter(event => event.type === "response.output_item.done").map(event => event.item)
+    : json?.output ?? []) as Item[];
+  return { response, text, output, log, json, events };
+}
+test("removing only the oldest thinking preserves the remaining valid run", async () => {
+  const bodies = transport((index, stream) => upstream(index === 1 ? SIGNATURE : SECOND_SIGNATURE, false, stream));
+  const first = await send([user("First question")]);
+  const history = [user("First question"), ...first.output, user("Second question")];
+  const second = await send(history);
+  expect(second.response.status).toBe(200);
+  const trimmed = [user("First question"), ...first.output.filter(item => item.type !== "reasoning"),
+    user("Second question"), ...second.output, user("Third question")];
+  const third = await send(trimmed);
+  expect(third.response.status).toBe(200);
+  expect(bodies).toHaveLength(3);
+  expect(bodies[2]).toContain(SECOND_SIGNATURE);
+});
+
+test("rotating image URL with identical bytes is left to upstream validation", async () => {
+  const bodies = transport((_index, stream) => upstream(SIGNATURE, true, stream));
+  const imageUser = (url: string): Item => ({type: "message", role: "user", content: [
+    {type: "input_text", text: "Look at this fixed image"}, {type: "input_image", image_url: url}
+  ]});
+  const first = await send([imageUser("https://images.example.test/fixed.png?signature=old")], false,
+    {model: "anthropic-test/claude-sonnet-4-5"});
+  const next = await send([imageUser("https://images.example.test/fixed.png?signature=new"), ...first.output,
+    {type: "function_call_output", call_id: "tool_fixture", output: "Already executed"}], false,
+    {model: "anthropic-test/claude-sonnet-4-5"});
+  expect(next.response.status).toBe(200);
+  expect(bodies).toHaveLength(2);
+});
+
+test("pre-binding model accepts a changed system on a manual tool continuation", async () => {
+  const bodies = transport((_index, stream) => upstream(SIGNATURE, true, stream));
+  const first = await send([user("Run lookup")], false, {model: "anthropic-test/claude-sonnet-4-5"});
+  const next = await send([user("Run lookup"), ...first.output,
+    {type: "function_call_output", call_id: "tool_fixture", output: "Already executed"}], false,
+    {model: "anthropic-test/claude-sonnet-4-5", instructions: "New system prompt for this next turn."});
+  expect(next.response.status).toBe(200);
+  expect(bodies).toHaveLength(2);
+});
diff --git a/tests/responses/responses-anthropic-thinking-recovery.test.ts b/tests/responses/responses-anthropic-thinking-recovery.test.ts
new file mode 100644
index 00000000000..54e2d19db5f
--- /dev/null
+++ b/tests/responses/responses-anthropic-thinking-recovery.test.ts
@@ -0,0 +1,153 @@
+import { captureAnthropicRejectionPayloads, bindAnthropicRejectionResponse } from "../../src/adapters/anthropic-rejection-memo";
+import { createTranslatorBudget } from "../../src/lib/translator-budget";
+import { afterEach, expect, test } from "bun:test";
+import type { AdapterEvent, OcxParsedRequest } from "../../src/types";
+import { createAnthropicThinkingRecovery, isAnthropicThinkingSignatureBindingRejectionMessage } from "../../src/server/responses/anthropic-thinking-recovery";
+import { clearReasoningReplayCacheForTests, reasoningReplayOpaqueBlobRejectionMemoized } from "../../src/responses/reasoning-replay-cache";
+import { markResponseNonReplayable } from "../../src/lib/upstream-retry";
+
+const MESSAGE = "Invalid `signature` in `thinking` block. The block is bound to a different conversation.";
+const rejection: AdapterEvent = { type: "error", status: 400, message: MESSAGE };
+const success: AdapterEvent[] = [{ type: "text_delta", text: "answer" }, { type: "done" }];
+function parsed(): OcxParsedRequest {
+  return {
+    modelId: "synthetic-model", stream: true, options: {},
+    context: { messages: [{ role: "assistant", content: [{ type: "thinking", thinking: "prior", signature: "SyntheticSignature123456==" }] }] },
+    _reasoningReplayScope: { clientThreadId: "synthetic-thread", current: {
+      providerName: "synthetic-provider", adapterName: "anthropic", modelId: "synthetic-model",
+      providerDestinationIdentity: "destination", providerDestinationDurableIdentity: "durable-destination",
+      credentialIdentity: "credential", credentialDurableIdentity: "durable-credential",
+    } },
+  };
+}
+async function* stream(events: AdapterEvent[]): AsyncGenerator<AdapterEvent> { yield* events; }
+async function collect(events: AsyncIterable<AdapterEvent>): Promise<AdapterEvent[]> {
+  const result: AdapterEvent[] = [];
+  for await (const event of events) result.push(event);
+  return result;
+}
+function httpRejection(message = MESSAGE): Response {
+  const response = Response.json({ error: { message } }, { status: 400 });
+  const request = { url: "https://example.test", method: "POST", headers: {}, body: "" };
+  const budget = createTranslatorBudget();
+  captureAnthropicRejectionPayloads(request, { messages: [{ role: "assistant", content: [
+    { type: "thinking", signature: "SyntheticSignature123456==" },
+  ] }] }, budget);
+  bindAnthropicRejectionResponse(request, response);
+  budget.dispose();
+  return response;
+}
+function fixture() {
+  const request = parsed();
+  const abort = new AbortController();
+  const guard = { attempted: false };
+  const recovery = createAnthropicThinkingRecovery(request, abort.signal, guard, () => true);
+  return { request, abort, guard, recovery };
+}
+afterEach(() => clearReasoningReplayCacheForTests());
+
+test("classifier requires both exact validation phrases including backticks", () => {
+  expect(isAnthropicThinkingSignatureBindingRejectionMessage(MESSAGE)).toBe(true);
+  for (const message of [MESSAGE.replaceAll("`", ""), "Invalid `signature` in `thinking` block", "The block is bound to a different conversation", "invalid signature"]) {
+    expect(isAnthropicThinkingSignatureBindingRejectionMessage(message)).toBe(false);
+  }
+});
+
+for (const prefix of [
+  { type: "heartbeat", replayUnsafe: true },
+  { type: "assistant_boundary" },
+  { type: "thinking_signature", signature: "new-signature" },
+  { type: "redacted_thinking", data: "new-redacted" },
+  { type: "web_search_call_begin", id: "search-effect" },
+] satisfies AdapterEvent[]) {
+  test(`replay fence retains ${prefix.type} and the original rejection`, async () => {
+    const { recovery, guard } = fixture();
+    let retried = false;
+    const events = [prefix, rejection];
+    expect(await collect(recovery.wrap(stream(events), () => { retried = true; return stream(success); }, () => "anthropic"))).toEqual(events);
+    expect(retried).toBe(false);
+    expect(guard.attempted).toBe(false);
+  });
+}
+
+test("harmless ready heartbeats allow exactly one retry and close the old iterator first", async () => {
+  const { recovery, guard, request } = fixture();
+  let closed = false;
+  let calls = 0;
+  const original = (async function* () {
+    try { yield { type: "heartbeat", preflightReady: true } as AdapterEvent; yield rejection; }
+    finally { closed = true; }
+  })();
+  const events = await collect(recovery.wrap(original, () => {
+    expect(closed).toBe(true);
+    calls++;
+    return stream([rejection]);
+  }, () => "anthropic"));
+  expect(events).toEqual([{ type: "heartbeat", preflightReady: true }, rejection]);
+  expect(calls).toBe(1);
+  expect(guard.attempted).toBe(true);
+  expect(request._stripReasoningEncryptedContent).toBe(true);
+  expect(request._dropForeignReasoningItemIds).toBe(true);
+});
+
+test("HTTP classification keeps incomplete/non-JSON/non-replayable bodies terminal", async () => {
+  const marked = Response.json({ error: { message: MESSAGE } }, { status: 400 });
+  markResponseNonReplayable(marked);
+  for (const response of [new Response(MESSAGE, { status: 400 }), Response.json({ error: { message: MESSAGE.slice(0, 30) } }, { status: 400 }), Response.json({ error: { message: MESSAGE } }, { status: 500 }), marked]) {
+    const { recovery, guard } = fixture();
+    expect(await recovery.prepareHttp(response, "anthropic")).toBe(false);
+    expect(guard.attempted).toBe(false);
+    expect(response.bodyUsed).toBe(false);
+  }
+});
+
+test("provider, missing state, pre-stripped and spent guards cannot arm recovery", async () => {
+  for (const variant of ["provider", "state", "stripped", "attempted", "aborted"] as const) {
+    const { recovery, request, guard, abort } = fixture();
+    if (variant === "state") request.context.messages = [];
+    if (variant === "stripped") request._stripReasoningEncryptedContent = true;
+    if (variant === "attempted") guard.attempted = true;
+    if (variant === "aborted") abort.abort();
+    const events = await collect(recovery.wrap(stream([rejection]), () => { throw new Error("unexpected retry"); }, () => variant === "provider" ? "openai-chat" : "anthropic"));
+    expect(events).toEqual([rejection]);
+  }
+});
+
+test("redacted-only history qualifies, and HTTP success alone does not memoize", async () => {
+  const { recovery, request } = fixture();
+  request.context.messages = [{ role: "assistant", content: [{ type: "thinking", thinking: "", redacted: ["synthetic-redacted"] }] }];
+  expect(await recovery.prepareHttp(httpRejection(), "anthropic")).toBe(true);
+  recovery.rememberSuccess({ status: "completed", output: [{ type: "message" }] });
+  expect(reasoningReplayOpaqueBlobRejectionMemoized(request._reasoningReplayScope)).toBe(false);
+  await collect(recovery.wrap(stream(success), () => { throw new Error("unexpected retry"); }, () => "anthropic"));
+  recovery.rememberSuccess({ status: "completed", output: [{ type: "message" }] });
+  expect(reasoningReplayOpaqueBlobRejectionMemoized(request._reasoningReplayScope)).toBe(true);
+});
+
+for (const variant of ["empty", "no-terminal", "error", "incomplete", "cancelled", "changed-identity", "changed-thread", "failed-fold"] as const) {
+  test(`does not memoize a ${variant} replacement`, async () => {
+    const { recovery, request, abort } = fixture();
+    const rejectedScope = structuredClone(request._reasoningReplayScope);
+    const events: AdapterEvent[] = variant === "empty" ? [{ type: "done" }]
+      : variant === "no-terminal" ? [success[0]!]
+      : variant === "error" ? [success[0]!, rejection]
+      : variant === "incomplete" ? [success[0]!, { type: "incomplete", reason: "max_output_tokens" }]
+      : success;
+    await collect(recovery.wrap(stream([rejection]), () => stream(events), () => "anthropic"));
+    if (variant === "cancelled") abort.abort();
+    if (variant === "changed-identity") request._reasoningReplayScope!.current = { ...request._reasoningReplayScope!.current!, credentialDurableIdentity: "another-credential" };
+    if (variant === "changed-thread") request._reasoningReplayScope = { ...request._reasoningReplayScope!, clientThreadId: "another-thread" };
+    recovery.rememberSuccess({ status: variant === "failed-fold" ? "failed" : "completed", output: [{ type: "message" }] });
+    expect(reasoningReplayOpaqueBlobRejectionMemoized(rejectedScope)).toBe(false);
+    expect(reasoningReplayOpaqueBlobRejectionMemoized(request._reasoningReplayScope)).toBe(false);
+  });
+}
+
+test("a stray tool-end and done cannot memoize an empty validated output", async () => {
+  const { recovery, request } = fixture();
+  await collect(recovery.wrap(stream([rejection]), () => stream([
+    { type: "tool_call_end" }, { type: "done" },
+  ]), () => "anthropic"));
+  recovery.rememberSuccess({ status: "completed", output: [] });
+  expect(reasoningReplayOpaqueBlobRejectionMemoized(request._reasoningReplayScope)).toBe(false);
+});
diff --git a/tests/responses/responses-anthropic-thinking-signature-recovery.test.ts b/tests/responses/responses-anthropic-thinking-signature-recovery.test.ts
new file mode 100644
index 00000000000..64c31ff6a95
--- /dev/null
+++ b/tests/responses/responses-anthropic-thinking-signature-recovery.test.ts
@@ -0,0 +1,607 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { httpStatusFromTerminalError } from "../../src/lib/errors";
+import { createRequestExecutionBudget } from "../../src/lib/request-execution-budget";
+import { markResponseNonReplayable, SendBudgetExhaustedError } from "../../src/lib/upstream-retry";
+import { resetWorkflowBudgetsForTest } from "../../src/lib/workflow-budget";
+import { encodeReasoningEnvelope } from "../../src/responses/reasoning-envelope";
+import { clearReasoningReplayCacheForTests } from "../../src/responses/reasoning-replay-cache";
+import { resetThoughtSignatureReplayForTests } from "../../src/responses/thought-signature-replay";
+import * as thoughtSignatureReplay from "../../src/responses/thought-signature-replay";
+import { handleResponses } from "../../src/server/responses/core";
+import type { RequestLogContext } from "../../src/server/request-log";
+import type { OcxConfig } from "../../src/types";
+import { acquireOwnedSpendHome } from "../helpers/owned-spend-home";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+const originalFetch = globalThis.fetch;
+const originalHome = process.env.OPENCODEX_HOME;
+const SIGNATURE = "SyntheticSignature123456==";
+const REDACTED = "synthetic-redacted-thinking";
+const REJECTION = "Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the thinking block and retry.";
+let testDir = "";
+let releaseSpendHome: (() => void) | undefined;
+
+beforeEach(() => {
+  testDir = mkdtempSync(join(tmpdir(), "ocx-anthropic-thinking-recovery-"));
+  process.env.OPENCODEX_HOME = testDir;
+  releaseSpendHome = acquireOwnedSpendHome();
+  clearReasoningReplayCacheForTests();
+  resetThoughtSignatureReplayForTests();
+  resetWorkflowBudgetsForTest();
+});
+
+afterEach(() => {
+  try { releaseSpendHome?.(); } finally {
+    releaseSpendHome = undefined;
+    globalThis.fetch = originalFetch;
+    clearReasoningReplayCacheForTests();
+    resetThoughtSignatureReplayForTests();
+    resetWorkflowBudgetsForTest();
+    if (originalHome === undefined) delete process.env.OPENCODEX_HOME;
+    else process.env.OPENCODEX_HOME = originalHome;
+    removeTreeWithRetry(testDir);
+  }
+});
+
+function config(): OcxConfig {
+  return {
+    defaultProvider: "anthropic-test",
+    emptyCompletionRetry: false,
+    providers: {
+      "anthropic-test": {
+        adapter: "anthropic",
+        baseUrl: "https://anthropic.example.test",
+        authMode: "key",
+        apiKey: "synthetic-test-key",
+        // The mock is the entire transport; inherited SOCKS settings must not bypass it.
+        proxy: "direct",
+        models: ["claude-sonnet-4-5"],
+      },
+    },
+  } as OcxConfig;
+}
+
+function request(stream: boolean, threadId = "thinking-recovery-thread", signed = true): Request {
+  return new Request("http://localhost/v1/responses", {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-codex-parent-thread-id": threadId },
+    body: JSON.stringify({
+      model: "anthropic-test/claude-sonnet-4-5", stream, store: false,
+      tools: [{ type: "function", name: "lookup", parameters: { type: "object", properties: {} } }],
+      input: [
+        { type: "message", role: "user", content: [{ type: "input_text", text: "earlier question" }] },
+        ...(signed ? [{ type: "reasoning", summary: [{ type: "summary_text", text: "earlier reasoning" }],
+          encrypted_content: encodeReasoningEnvelope({ sig: SIGNATURE, red: [REDACTED] }) }] : []),
+        { type: "message", role: "assistant", content: [{ type: "output_text", text: "earlier answer" }] },
+        { type: "message", role: "user", content: [{ type: "input_text", text: "next question" }] },
+      ],
+    }),
+  });
+}
+
+function frame(type: string, data: Record<string, unknown> = {}): string {
+  return `event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`;
+}
+
+function sse(...frames: string[]): Response {
+  return new Response(frames.join(""), { headers: { "content-type": "text/event-stream" } });
+}
+
+function rejection(status = 400, message = REJECTION): Response {
+  return Response.json({ type: "error", error: { type: "invalid_request_error", message } }, { status });
+}
+
+function streamRejection(...prefix: string[]): Response {
+  return sse(...prefix, frame("error", { error: { type: "invalid_request_error", message: REJECTION } }));
+}
+
+function textFrame(text: string): string {
+  return frame("content_block_delta", { index: 0, delta: { type: "text_delta", text } });
+}
+
+function success(stream: boolean, text = "Recovered answer"): Response {
+  if (stream) return sse(
+    frame("message_start", { message: { usage: { input_tokens: 2 } } }),
+    ...(text ? [textFrame(text)] : []),
+    frame("message_delta", { delta: { stop_reason: "end_turn" }, usage: { output_tokens: 3 } }),
+    frame("message_stop"),
+  );
+  return Response.json({
+    id: "msg-recovered", type: "message", role: "assistant", model: "claude-sonnet-4-5",
+    content: text ? [{ type: "text", text }] : [], stop_reason: "end_turn",
+    usage: { input_tokens: 2, output_tokens: 3 },
+  });
+}
+
+function fakeUpstream(answer: (index: number) => Response | Promise<Response>): string[] {
+  const bodies: string[] = [];
+  globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+    bodies.push(String(init?.body));
+    return answer(bodies.length);
+  }) as typeof fetch;
+  return bodies;
+}
+
+async function send(stream: boolean, threadId?: string, options: Parameters<typeof handleResponses>[3] = {}) {
+  const log: RequestLogContext = { model: "", provider: "" };
+  const response = await handleResponses(request(stream, threadId), config(), log, options);
+  const text = await response.text();
+  return { response, text, log };
+}
+
+function expectStrippedRetry(bodies: string[]): void {
+  expect(bodies).toHaveLength(2);
+  expect(bodies[0]).toContain(SIGNATURE);
+  expect(bodies[0]).toContain(REDACTED);
+  expect(bodies[1]).not.toContain(SIGNATURE);
+  expect(bodies[1]).not.toContain(REDACTED);
+  expect(bodies[1]).not.toContain('"type":"thinking"');
+  expect(bodies[1]).toContain("earlier answer");
+  expect(bodies[1]).toContain("next question");
+}
+
+function streamedFailure(text: string): {
+  error: { type: string; code: string; message: string };
+  retryable?: boolean;
+} {
+  const event = text.split("\n").filter(line => line.startsWith("data: {") && line.includes('"type":"response.failed"'))
+    .map(line => JSON.parse(line.slice(6)))[0];
+  expect(event?.response?.status).toBe("failed");
+  return event.response;
+}
+
+describe("Anthropic thinking-signature recovery through Responses dispatch", () => {
+  for (const stream of [false, true]) {
+    test(`HTTP 400 rebuilds once and memoizes only completed output (stream=${stream})`, async () => {
+      const bodies = fakeUpstream(index => index === 1 ? rejection() : success(stream));
+      const result = await send(stream);
+      expect(result.response.status).toBe(200);
+      expect(result.text).toContain("Recovered answer");
+      expectStrippedRetry(bodies);
+      expect(result.log.activeAttempt?.recoveryKinds).toEqual(["opaque-blob-rejection"]);
+      expect(result.log.activeAttempt?.sendCount).toBe(2);
+      await send(stream);
+      expect(bodies).toHaveLength(3);
+      expect(bodies[2]).not.toContain(SIGNATURE);
+      await send(stream, "another-thinking-thread");
+      expect(bodies[3]).toContain(SIGNATURE);
+    });
+
+    test(`failed and empty stripped retries do not poison later replay (stream=${stream})`, async () => {
+      for (const retry of ["http-error", "empty", "adapter-error"] as const) {
+        clearReasoningReplayCacheForTests();
+        const bodies = fakeUpstream(index => index === 1 ? rejection() : index === 2
+          ? retry === "http-error" ? rejection(400, "Unrelated bad request")
+            : retry === "empty" ? success(stream, "")
+              : stream ? streamRejection() : Response.json({ content: [], stop_reason: "error" })
+          : success(stream));
+        await send(stream);
+        expectStrippedRetry(bodies);
+        await send(stream);
+        expect(bodies).toHaveLength(3);
+        expect(bodies[2]).toContain(SIGNATURE);
+      }
+    });
+  }
+
+  test("initial HTTP 200 signature error after harmless pings replaces the stream once", async () => {
+    const bodies = fakeUpstream(index => index === 1
+      ? streamRejection(": keepalive\n\n", frame("ping")) : success(true));
+    const result = await send(true);
+    expect(result.text).toContain("Recovered answer");
+    expect(result.text).toContain("response.completed");
+    expect(result.text).not.toContain("response.failed");
+    expect(result.text).not.toContain(REJECTION);
+    expectStrippedRetry(bodies);
+    await send(true);
+    expect(bodies[2]).not.toContain(SIGNATURE);
+  });
+
+  test("HTTP rejection and its replacement stream share a single recovery allowance", async () => {
+    const bodies = fakeUpstream(index => index === 1 ? rejection() : streamRejection());
+    const result = await send(true);
+    expectStrippedRetry(bodies);
+    expect(result.text).toContain("response.failed");
+    expect(result.text).toContain(REJECTION);
+  });
+
+  test("a second stream rejection is terminal and is not memoized", async () => {
+    const bodies = fakeUpstream(index => index < 3 ? streamRejection() : success(true));
+    const result = await send(true);
+    expectStrippedRetry(bodies);
+    expect(result.text).toContain("response.failed");
+    await send(true);
+    expect(bodies).toHaveLength(3);
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+
+  test("a non-OK replacement is delivered as an error rather than parsed as SSE", async () => {
+    const bodies = fakeUpstream(index => index === 1 ? streamRejection() : index === 2
+      ? rejection(400, "Synthetic replacement refusal") : success(true));
+    const result = await send(true);
+    expectStrippedRetry(bodies);
+    expect(result.text).toContain("Synthetic replacement refusal");
+    expect(result.text).toContain("response.failed");
+    expect(result.text).not.toContain("possible truncation");
+    await send(true);
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+
+  test("a marked non-replayable replacement withholds diagnostics and preserves its terminal identity", async () => {
+    const diagnostic = "synthetic-private-upstream-diagnostic";
+    const bodies = fakeUpstream(index => {
+      if (index === 1) return streamRejection();
+      if (index !== 2) return success(true);
+      const response = Response.json({ error: {
+        type: "invalid_request_error", code: "context_length_exceeded", message: diagnostic,
+      } }, { status: 400 });
+      markResponseNonReplayable(response);
+      return response;
+    });
+    const result = await send(true);
+    expectStrippedRetry(bodies);
+    expect(result.text).not.toContain(diagnostic);
+    const failure = streamedFailure(result.text);
+    expect(failure.error).toEqual({
+      type: "invalid_request_error", code: "context_length_exceeded",
+      message: "Provider error 400: upstream diagnostic withheld for a non-replayable failure",
+    });
+    expect(failure.retryable).toBe(false);
+    expect(httpStatusFromTerminalError(failure.error)).toBe(400);
+    await send(true);
+    expect(bodies).toHaveLength(3);
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+
+  test("a local send-budget refusal retains 429 identity after refetch aborts its upstream signal", async () => {
+    const bodies = fakeUpstream(index => {
+      if (index === 1) return streamRejection();
+      if (index === 2) throw new SendBudgetExhaustedError("synthetic-upstream");
+      return success(true);
+    });
+    const result = await send(true);
+    expectStrippedRetry(bodies);
+    const failure = streamedFailure(result.text);
+    expect(failure.error.type).toBe("rate_limit_error");
+    expect(failure.error.code).toBe("request_send_budget_exhausted");
+    expect(failure.error.message).toContain("request send budget exhausted before dispatch");
+    expect(httpStatusFromTerminalError(failure.error)).toBe(429);
+    expect(result.text).not.toContain("Upstream recovery failed");
+    expect(result.text).not.toContain("Provider unreachable");
+    await send(true);
+    expect(bodies).toHaveLength(3);
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+
+  test("empty, truncated, and incomplete stream retries never memoize rejection", async () => {
+    for (const retry of ["empty", "truncated", "incomplete"] as const) {
+      clearReasoningReplayCacheForTests();
+      const bodies = fakeUpstream(index => index === 1 ? streamRejection() : index === 2
+        ? retry === "empty" ? success(true, "") : retry === "truncated" ? sse(textFrame("Partial answer"))
+          : sse(textFrame("Partial answer"), frame("message_delta", { delta: { stop_reason: "max_tokens" } }), frame("message_stop"))
+        : success(true));
+      const result = await send(true);
+      expectStrippedRetry(bodies);
+      if (retry !== "empty") expect(result.text).not.toContain("event: response.completed");
+      await send(true);
+      expect(bodies).toHaveLength(3);
+      expect(bodies[2]).toContain(SIGNATURE);
+    }
+  });
+
+  for (const initialStreamError of [false, true]) {
+    test(`the shared send budget can deny recovery (initialStreamError=${initialStreamError})`, async () => {
+      const bodies = fakeUpstream(index => index === 1
+        ? initialStreamError ? streamRejection() : rejection() : success(initialStreamError));
+      const budget = createRequestExecutionBudget({
+        maxTotalModelSends: 0, baseSendAllowance: 0, finalRecoveryAllowance: 0,
+        maxAlternateTargetSends: 0, maxTargetTransitions: 0,
+      }, "thinking-recovery-budget-refused");
+      await send(initialStreamError, undefined, { sendBudget: budget });
+      expect(bodies).toHaveLength(1);
+      expect(budget.used).toBe(0);
+      await send(initialStreamError);
+      expect(bodies).toHaveLength(2);
+      expect(bodies[1]).toContain(SIGNATURE);
+    });
+  }
+
+  test("concurrent requests each get one recovery and retain separate conversation memos", async () => {
+    let releaseInitial!: () => void;
+    const initialBarrier = new Promise<void>(resolve => { releaseInitial = resolve; });
+    const bodies = fakeUpstream(async index => {
+      if (index <= 2) {
+        if (index === 2) releaseInitial();
+        await initialBarrier;
+        return rejection();
+      }
+      return success(false);
+    });
+    const results = await Promise.all([send(false, "parallel-thinking-a"), send(false, "parallel-thinking-b")]);
+    expect(results.every(result => result.response.status === 200 && result.text.includes("Recovered answer"))).toBe(true);
+    expect(bodies).toHaveLength(4);
+    expect(bodies.slice(0, 2).every(body => body.includes(SIGNATURE))).toBe(true);
+    expect(bodies.slice(2).every(body => !body.includes(SIGNATURE))).toBe(true);
+    await send(false, "parallel-thinking-a");
+    await send(false, "parallel-thinking-b");
+    expect(bodies).toHaveLength(6);
+    expect(bodies.slice(4).every(body => !body.includes(SIGNATURE))).toBe(true);
+  });
+
+  for (const prefix of [
+    { name: "visible text", frame: textFrame("Already visible") },
+    { name: "thinking output", frame: frame("content_block_start", { index: 0, content_block: { type: "thinking", thinking: "" } }) },
+    { name: "tool call", frame: frame("content_block_start", { index: 0, content_block: { type: "tool_use", id: "call-synthetic", name: "lookup" } }) },
+  ]) {
+    test(`does not resend after ${prefix.name}`, async () => {
+      const bodies = fakeUpstream(() => streamRejection(prefix.frame));
+      const result = await send(true);
+      expect(bodies).toHaveLength(1);
+      expect(result.text).toContain("response.failed");
+      expect(result.text).toContain(REJECTION);
+    });
+  }
+
+  test("unrelated wording and missing replayed thinking never gain a resend", async () => {
+    for (const message of ["Invalid `signature` in `thinking` block", "The block is bound to a different conversation", "Invalid API key"]) {
+      const bodies = fakeUpstream(() => rejection(400, message));
+      const result = await send(false);
+      expect(result.response.status).toBe(400);
+      expect(bodies).toHaveLength(1);
+    }
+    const bodies = fakeUpstream(() => rejection());
+    const result = await handleResponses(request(false, "unsigned-thread", false), config(), { model: "", provider: "" });
+    await result.text();
+    expect(result.status).toBe(400);
+    expect(bodies).toHaveLength(1);
+  });
+
+  test("reasoning that Anthropic never serialized cannot gain an identical resend", async () => {
+    for (const stream of [false, true]) {
+      for (const encrypted of [undefined, "native-provider-opaque-blob",
+        encodeReasoningEnvelope({ sig: "short" }),
+        encodeReasoningEnvelope({ sig: "call_not_a_real_signature" })]) {
+        const bodies = fakeUpstream(() => stream ? streamRejection() : rejection());
+        const base = request(stream);
+        const body = await base.json() as { input: Record<string, unknown>[] };
+        body.input[1] = {
+          type: "reasoning", summary: [{ type: "summary_text", text: "unsigned reasoning" }],
+          ...(encrypted ? { encrypted_content: encrypted } : {}),
+        };
+        const response = await handleResponses(new Request(base.url, {
+          method: "POST", headers: base.headers, body: JSON.stringify(body),
+        }), config(), { model: "", provider: "" });
+        const text = await response.text();
+        expect(bodies).toHaveLength(1);
+        expect(bodies[0]).not.toContain('"type":"thinking"');
+        expect(bodies[0]).not.toContain('"type":"redacted_thinking"');
+        expect(text).toContain(REJECTION);
+      }
+    }
+  });
+
+  test("non-replayable HTTP responses stay terminal", async () => {
+    const bodies = fakeUpstream(() => {
+      const response = rejection();
+      markResponseNonReplayable(response);
+      return response;
+    });
+    const result = await send(false);
+    expect(result.response.status).toBe(400);
+    expect(bodies).toHaveLength(1);
+  });
+
+  test("cancellation before recovery prevents a second send and leaves replay available", async () => {
+    const abort = new AbortController();
+    const bodies = fakeUpstream(index => {
+      if (index === 1) { abort.abort(); return rejection(); }
+      return success(false);
+    });
+    await send(false, undefined, { abortSignal: abort.signal });
+    expect(bodies).toHaveLength(1);
+    await send(false);
+    expect(bodies).toHaveLength(2);
+    expect(bodies[1]).toContain(SIGNATURE);
+  });
+
+  test("cancellation after recovery dispatch cannot memoize an unread HTTP 200", async () => {
+    const abort = new AbortController();
+    const bodies = fakeUpstream(index => {
+      if (index === 1) return streamRejection();
+      if (index === 2) abort.abort();
+      return success(true);
+    });
+    const response = await handleResponses(request(true), config(), { model: "", provider: "" }, { abortSignal: abort.signal });
+    try { await response.text(); } catch { /* client cancellation can reject its stream reader */ }
+    expectStrippedRetry(bodies);
+    await send(true);
+    expect(bodies).toHaveLength(3);
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+
+  test("caller cancellation during buffered durability wait cannot memoize completed recovery", async () => {
+    const abort = new AbortController();
+    const bodies = fakeUpstream(index => index === 1 ? rejection() : success(false));
+    const durability = spyOn(thoughtSignatureReplay, "awaitThoughtSignatureDurability").mockImplementation(async () => {
+      abort.abort();
+    });
+    try {
+      await send(false, undefined, { abortSignal: abort.signal });
+      expect(durability).toHaveBeenCalledTimes(1);
+      expect(abort.signal.aborted).toBe(true);
+      expectStrippedRetry(bodies);
+    } finally {
+      durability.mockRestore();
+    }
+    await send(false);
+    expect(bodies).toHaveLength(3);
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+});
+
+async function mediaRequest(options: Parameters<typeof handleResponses>[3] = {}) {
+  const source = request(true);
+  const body = await source.json() as Record<string, unknown>;
+  body.tools = [{ type: "image_generation" }];
+  const cfg = config();
+  cfg.images = { bridgeEnabled: true };
+  cfg.providers.xai = { adapter: "openai-chat", baseUrl: "https://api.x.ai/v1", authMode: "key", apiKey: "synthetic-image-key", proxy: "direct" };
+  const log: RequestLogContext = { model: "", provider: "" };
+  const response = await handleResponses(new Request(source.url, {
+    method: "POST", headers: source.headers, body: JSON.stringify(body),
+  }), cfg, log, options);
+  return { response, text: await response.text(), log };
+}
+
+for (const rawSse of [false, true]) {
+  test(`media bridge repairs only the rejected inference (initial SSE=${rawSse})`, async () => {
+    const bodies = fakeUpstream(index => index === 1 ? rawSse ? streamRejection(frame("ping")) : rejection() : success(true));
+    const result = await mediaRequest();
+    expect(result.text).toContain("Recovered answer");
+    expectStrippedRetry(bodies);
+    expect(result.log.activeAttempt?.sendCount).toBe(2);
+  });
+  test(`empty-completion retry shares the original recovery allowance (SSE=${rawSse})`, async () => {
+    const bodies = fakeUpstream(index => index === 1 ? success(true, "")
+      : index === 2 ? rawSse ? streamRejection() : rejection() : success(true));
+    const cfg = config(); cfg.emptyCompletionRetry = true;
+    const response = await handleResponses(request(true), cfg, { model: "", provider: "" });
+    expect(await response.text()).toContain("Recovered answer");
+    expect(bodies).toHaveLength(3);
+    expect(bodies[1]).toContain(SIGNATURE);
+    expect(bodies[2]).not.toContain(SIGNATURE);
+  });
+}
+
+test("a later media iteration preserves a structured send-budget refusal after tool execution", async () => {
+  let imageCalls = 0;
+  let inferenceCalls = 0;
+  globalThis.fetch = (async (input: RequestInfo | URL) => {
+    const url = input instanceof Request ? input.url : String(input);
+    if (url === "https://api.x.ai/v1/images/generations") {
+      imageCalls++;
+      return Response.json({ error: { message: "Synthetic image refusal" } }, { status: 400 });
+    }
+    if (url !== "https://anthropic.example.test/v1/messages") throw new Error("Unexpected test network target");
+    if (++inferenceCalls > 1) throw new SendBudgetExhaustedError("synthetic-later-media-send");
+    return sse(frame("message_start", { message: { usage: { input_tokens: 2 } } }),
+      frame("content_block_start", { index: 0, content_block: { type: "tool_use", id: "image_fixture", name: "image_gen", input: {} } }),
+      frame("content_block_delta", { index: 0, delta: { type: "input_json_delta", partial_json: '{"prompt":"fixture"}' } }),
+      frame("content_block_stop", { index: 0 }),
+      frame("message_delta", { delta: { stop_reason: "tool_use" } }), frame("message_stop"));
+  }) as typeof fetch;
+  const result = await mediaRequest();
+  const failure = streamedFailure(result.text);
+  expect(failure.error.type).toBe("rate_limit_error");
+  expect(failure.error.code).toBe("request_send_budget_exhausted");
+  expect(httpStatusFromTerminalError(failure.error)).toBe(429);
+  expect(failure.retryable).toBe(false);
+  expect(imageCalls).toBe(1);
+  expect(inferenceCalls).toBe(2);
+});
+
+test("media repair never repeats an already executed image tool", async () => {
+  const bodies: string[] = [];
+  let imageCalls = 0;
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = input instanceof Request ? input.url : String(input);
+    if (url === "https://api.x.ai/v1/images/generations") {
+      imageCalls++;
+      return Response.json({ error: { message: "Synthetic image refusal" } }, { status: 400 });
+    }
+    if (url !== "https://anthropic.example.test/v1/messages") throw new Error("Unexpected test network target");
+    bodies.push(String(init?.body));
+    if (bodies.length === 1) return sse(
+      frame("message_start", { message: { usage: { input_tokens: 2 } } }),
+      frame("content_block_start", { index: 0, content_block: { type: "tool_use", id: "image_fixture", name: "image_gen", input: {} } }),
+      frame("content_block_delta", { index: 0, delta: { type: "input_json_delta", partial_json: '{"prompt":"fixture"}' } }),
+      frame("content_block_stop", { index: 0 }),
+      frame("message_delta", { delta: { stop_reason: "tool_use" } }), frame("message_stop"));
+    return bodies.length === 2 ? streamRejection() : success(true);
+  }) as typeof fetch;
+  const result = await mediaRequest();
+  expect(result.text).toContain("Recovered answer");
+  expect(imageCalls).toBe(1);
+  expect(bodies).toHaveLength(3);
+  expect(bodies[2]).toContain("image_fixture");
+  expect(bodies[2]).toContain("xAI images API returned 400");
+  expect(bodies[2]).not.toContain(SIGNATURE);
+});
+
+for (const prefix of [textFrame("visible"), frame("content_block_start", {
+  index: 0, content_block: { type: "server_tool_use", id: "effect_fixture", name: "unmodeled" },
+})]) test("media semantic progress fences signature recovery", async () => {
+  const bodies = fakeUpstream(() => streamRejection(prefix));
+  const result = await mediaRequest();
+  expect(result.text).toContain("response.failed");
+  expect(bodies).toHaveLength(1);
+});
+
+test("selective recovery retains earlier rejection memos while accepting new thinking", async () => {
+  const fresh = "SyntheticNewSignature123456==";
+  const newest = "SyntheticNewestSignature123456==";
+  const bodies = fakeUpstream(index => index === 1 || index === 3 ? rejection() : success(false));
+  await send(false);
+  const withFresh = async (signatures: string[]) => {
+    const source = request(false);
+    const body = await source.json() as { input: unknown[] };
+    body.input.splice(body.input.length - 1, 0, ...signatures.map(sig => ({
+      type: "reasoning", encrypted_content: encodeReasoningEnvelope({ sig }),
+    })));
+    return handleResponses(new Request(source.url, { method: "POST", headers: source.headers, body: JSON.stringify(body) }),
+      config(), { model: "", provider: "" });
+  };
+  const second = await withFresh([fresh]);
+  expect(await second.text()).toContain("Recovered answer");
+  expect(bodies[2]).not.toContain(SIGNATURE);
+  expect(bodies[2]).toContain(fresh);
+  expect(bodies[3]).not.toContain(SIGNATURE);
+  expect(bodies[3]).not.toContain(fresh);
+  const third = await withFresh([fresh, newest]);
+  await third.text();
+  expect(bodies).toHaveLength(5);
+  expect(bodies[4]).not.toContain(SIGNATURE);
+  expect(bodies[4]).not.toContain(fresh);
+  expect(bodies[4]).toContain(newest);
+});
+
+test("a memo that already removed every opaque block cannot authorize an identical resend", async () => {
+  const bodies = fakeUpstream(index => index === 2 ? success(false) : rejection());
+  await send(false);
+  const result = await send(false);
+  expect(result.response.status).toBe(400);
+  expect(bodies).toHaveLength(3);
+  expect(bodies[2]).not.toContain(SIGNATURE);
+});
+
+for (const rawSse of [false, true]) test(`media replacement retains structured refusal (SSE=${rawSse})`, async () => {
+  const bodies = fakeUpstream(index => index === 1 ? rawSse ? streamRejection() : rejection()
+    : Response.json({ error: { type: "permission_error", code: "fixture_denied", message: "Synthetic refusal" } }, { status: 403 }));
+  const result = await mediaRequest();
+  if (rawSse) expect(streamedFailure(result.text).error).toMatchObject({ type: "permission_error", code: "fixture_denied" });
+  else {
+    expect(result.response.status).toBe(403);
+    expect(JSON.parse(result.text).error).toMatchObject({ type: "permission_error", code: "fixture_denied" });
+  }
+  expect(bodies).toHaveLength(2);
+});
+
+for (const rawSse of [false, true]) test(`media recovery honors shared exhaustion and cancellation (SSE=${rawSse})`, async () => {
+  const budget = createRequestExecutionBudget({ maxTotalModelSends: 1, baseSendAllowance: 1,
+    finalRecoveryAllowance: 0, maxAlternateTargetSends: 0, maxTargetTransitions: 0 }, "media-recovery-budget");
+  const bodies = fakeUpstream(() => rawSse ? streamRejection() : rejection());
+  await mediaRequest({ sendBudget: budget });
+  expect(bodies).toHaveLength(1);
+  expect(budget.used).toBe(1);
+  const abort = new AbortController();
+  const cancelledBodies = fakeUpstream(() => {
+    abort.abort();
+    return rawSse ? streamRejection() : rejection();
+  });
+  const result = await mediaRequest({ abortSignal: abort.signal });
+  expect(result.text).not.toContain("Recovered answer");
+  expect(cancelledBodies).toHaveLength(1);
+});
diff --git a/tests/responses/responses-core-modules.test.ts b/tests/responses/responses-core-modules.test.ts
index ed1c3fb5a8f..b640d36d7a4 100644
--- a/tests/responses/responses-core-modules.test.ts
+++ b/tests/responses/responses-core-modules.test.ts
@@ -85,14 +85,15 @@ describe("Responses core module boundaries", () => {
     expect(ingress.indexOf("await executePassthroughResponse("))
       .toBeLessThan(ingress.indexOf("const sidecarPlans = await executeResponsesSidecars("));
     expect(native).toContain('if (nativeExchange instanceof Response || nativeExchange.kind === "adapter-handoff") return nativeExchange;');
-    // Delivery is awaited inside the try, and its direct body is wrapped before
-    // the return. What matters is that both awaits stay inside the lease owner,
-    // not that the delivery call is itself the return expression.
+    // Delivery is awaited inside the try, and its direct body is wrapped with
+    // tool ownership before return. Both awaits must stay inside the lease owner;
+    // the delivery call itself need not be the return expression.
     expect(native).toContain("const response = await deliverPassthroughResponse(");
-    expect(native).toContain("return guardDirectPassthroughBodyInactivity(");
+    const guardedReturn = "return attachResponseToolOwnership(guardDirectPassthroughBodyInactivity(";
+    expect(native).toContain(guardedReturn);
     expect(native.indexOf("await deliverPassthroughResponse("))
-      .toBeLessThan(native.indexOf("return guardDirectPassthroughBodyInactivity("));
-    expect(native.indexOf("return guardDirectPassthroughBodyInactivity("))
+      .toBeLessThan(native.indexOf(guardedReturn));
+    expect(native.indexOf(guardedReturn))
       .toBeLessThan(native.indexOf("} finally {"));
     expect(native.indexOf("admissionState.pendingHostAdmissionLease = null;"))
       .toBeLessThan(native.indexOf("await preparePassthroughExchange("));
diff --git a/tests/responses/responses-web-search-thinking-signature-recovery.test.ts b/tests/responses/responses-web-search-thinking-signature-recovery.test.ts
new file mode 100644
index 00000000000..183f0839dc1
--- /dev/null
+++ b/tests/responses/responses-web-search-thinking-signature-recovery.test.ts
@@ -0,0 +1,759 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createRequestExecutionBudget } from "../../src/lib/request-execution-budget";
+import { markResponseNonReplayable, SendBudgetExhaustedError } from "../../src/lib/upstream-retry";
+import { createSpendReservationLedger, DEFAULT_SPEND_RESERVATION_POLICY, type SpendJournal } from "../../src/lib/spend-reservation-ledger";
+import { createRequestSpendTracker } from "../../src/server/responses/request-spend";
+import { resetWorkflowBudgetsForTest } from "../../src/lib/workflow-budget";
+import { encodeReasoningEnvelope } from "../../src/responses/reasoning-envelope";
+import { clearReasoningReplayCacheForTests } from "../../src/responses/reasoning-replay-cache";
+import { resetThoughtSignatureReplayForTests } from "../../src/responses/thought-signature-replay";
+import { handleResponses } from "../../src/server/responses/core";
+import type { RequestLogContext } from "../../src/server/request-log";
+import type { OcxConfig } from "../../src/types";
+import { acquireOwnedSpendHome } from "../helpers/owned-spend-home";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+const originalFetch = globalThis.fetch;
+const originalHome = process.env.OPENCODEX_HOME;
+const SIGNATURE = "SyntheticSearchSignature123456==";
+const REDACTED = "synthetic-search-redacted-thinking";
+const REJECTION = "Invalid `signature` in `thinking` block. The block is bound to a different conversation. Remove the thinking block and retry.";
+let home = "";
+let release: (() => void) | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "ocx-search-thinking-recovery-"));
+  process.env.OPENCODEX_HOME = home;
+  release = acquireOwnedSpendHome();
+  clearReasoningReplayCacheForTests();
+  resetThoughtSignatureReplayForTests();
+  resetWorkflowBudgetsForTest();
+});
+afterEach(() => {
+  try { release?.(); } finally {
+    release = undefined;
+    globalThis.fetch = originalFetch;
+    clearReasoningReplayCacheForTests();
+    resetThoughtSignatureReplayForTests();
+    resetWorkflowBudgetsForTest();
+    if (originalHome === undefined) delete process.env.OPENCODEX_HOME;
+    else process.env.OPENCODEX_HOME = originalHome;
+    removeTreeWithRetry(home);
+  }
+});
+
+function config(): OcxConfig {
+  return {
+    defaultProvider: "anthropic-test", emptyCompletionRetry: false,
+    webSearchSidecar: { backend: "exa", exaApiKey: "synthetic-search-key", maxSearchesPerTurn: 2 },
+    providers: { "anthropic-test": {
+      adapter: "anthropic", baseUrl: "https://anthropic.example.test", authMode: "key",
+      apiKey: "synthetic-test-key", proxy: "direct", models: ["claude-sonnet-4-5"],
+    } },
+  } as OcxConfig;
+}
+function request(stream = true, thread = "search-thinking-thread", signed = true): Request {
+  return new Request("http://localhost/v1/responses", {
+    method: "POST", headers: { "content-type": "application/json", "x-codex-parent-thread-id": thread },
+    body: JSON.stringify({ model: "anthropic-test/claude-sonnet-4-5", stream, store: false,
+      tools: [{ type: "web_search" }, { type: "function", name: "lookup", parameters: { type: "object", properties: {} } }],
+      input: [
+        { type: "message", role: "user", content: [{ type: "input_text", text: "earlier question" }] },
+        ...(signed ? [{ type: "reasoning", summary: [{ type: "summary_text", text: "earlier reasoning" }],
+          encrypted_content: encodeReasoningEnvelope({ sig: SIGNATURE, red: [REDACTED] }) }] : []),
+        { type: "message", role: "assistant", content: [{ type: "output_text", text: "earlier answer" }] },
+        { type: "message", role: "user", content: [{ type: "input_text", text: "search this fixture" }] },
+      ],
+    }),
+  });
+}
+function frame(type: string, data: Record<string, unknown> = {}): string {
+  return `event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`;
+}
+function sse(...frames: string[]): Response {
+  return new Response(frames.join(""), { headers: { "content-type": "text/event-stream" } });
+}
+function rejection(message = REJECTION): Response {
+  return Response.json({ type: "error", error: { type: "invalid_request_error", message } }, { status: 400 });
+}
+function streamRejection(...prefix: string[]): Response {
+  return sse(...prefix, frame("error", { error: { type: "invalid_request_error", message: REJECTION } }));
+}
+function textFrame(text: string): string {
+  return frame("content_block_delta", { index: 0, delta: { type: "text_delta", text } });
+}
+function success(text = "Recovered search answer", stopReason = "end_turn"): Response {
+  return sse(frame("message_start", { message: { usage: { input_tokens: 2 } } }),
+    ...(text ? [textFrame(text)] : []),
+    frame("message_delta", { delta: { stop_reason: stopReason }, usage: { output_tokens: 3 } }), frame("message_stop"));
+}
+function search(id = "ws_fixture", query = "fixture", signature = SIGNATURE): Response {
+  return sse(frame("message_start", { message: { usage: { input_tokens: 2 } } }),
+    frame("content_block_start", { index: 0, content_block: { type: "thinking", thinking: "" } }),
+    frame("content_block_delta", { index: 0, delta: { type: "thinking_delta", thinking: "search reasoning" } }),
+    frame("content_block_delta", { index: 0, delta: { type: "signature_delta", signature } }),
+    frame("content_block_stop", { index: 0 }),
+    frame("content_block_start", { index: 1, content_block: { type: "tool_use", id, name: "web_search", input: {} } }),
+    frame("content_block_delta", { index: 1, delta: { type: "input_json_delta", partial_json: JSON.stringify({ query }) } }),
+    frame("content_block_stop", { index: 1 }),
+    frame("message_delta", { delta: { stop_reason: "tool_use" }, usage: { output_tokens: 3 } }), frame("message_stop"));
+}
+function transport(answer: (index: number, init?: RequestInit) => Response | Promise<Response>) {
+  const bodies: string[] = [];
+  const queries: string[] = [];
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = input instanceof Request ? input.url : String(input);
+    if (url === "https://api.exa.ai/search") {
+      queries.push(String(init?.body));
+      return Response.json({ results: [{ title: "fixture", url: "https://fixture.example.test", text: "retained search result" }] });
+    }
+    if (!["https://anthropic.example.test/v1/messages", "https://other-anthropic.example.test/v1/messages", "https://api.anthropic.com/v1/messages"].includes(url)) throw new Error(`Unexpected network target blocked: ${url}`);
+    bodies.push(String(init?.body));
+    return answer(bodies.length, init);
+  }) as typeof fetch;
+  return { bodies, queries };
+}
+async function send(options: Parameters<typeof handleResponses>[3] = {}, cfg = config(), req = request()) {
+  const log: RequestLogContext = { model: "", provider: "" };
+  const response = await handleResponses(req, cfg, log, options);
+  return { response, text: await response.text(), log };
+}
+function expectStripped(body: string): void {
+  expect(body).not.toContain(SIGNATURE);
+  expect(body).not.toContain(REDACTED);
+  expect(body).not.toContain('"type":"thinking"');
+  expect(body).not.toContain('"type":"redacted_thinking"');
+  expect(body).toContain("earlier answer");
+  expect(body).toContain("search this fixture");
+}
+function removeThinking(body: string): unknown {
+  const parsed = JSON.parse(body);
+  for (const message of parsed.messages) {
+    if (Array.isArray(message.content)) message.content = message.content.filter(
+      (part: { type: string }) => part.type !== "thinking" && part.type !== "redacted_thinking");
+  }
+  return parsed;
+}
+
+describe("hosted web search Anthropic thinking-signature recovery", () => {
+  for (const rawSse of [false, true]) {
+    test(`signed progress created during search remains eligible for recovery (SSE=${rawSse})`, async () => {
+      const cfg = config();
+      cfg.providers["anthropic-test"]!.baseUrl = "https://api.anthropic.com";
+      cfg.providers["anthropic-test"]!.models = ["claude-opus-5-5"];
+      const input = request(true, "search-progress-recovery", false);
+      const body = await input.json() as Record<string, unknown>;
+      body.model = "anthropic-test/claude-opus-5-5";
+      body.reasoning = { effort: "high" };
+      const req = new Request(input.url, { method: "POST", headers: input.headers, body: JSON.stringify(body) });
+      const { bodies, queries } = transport(index => index === 1 ? search() : index === 2
+        ? rawSse ? streamRejection(frame("ping")) : rejection() : success());
+      const result = await send({}, cfg, req);
+      expect(result.text).toContain("Recovered search answer");
+      expect(result.text).not.toContain("response.failed");
+      expect(bodies).toHaveLength(3);
+      expect(JSON.parse(bodies[0]).thinking.display).toBe("updates");
+      expect(bodies[0]).not.toContain(SIGNATURE);
+      expect(bodies[1]).toContain(SIGNATURE);
+      expect(bodies[2]).not.toContain(SIGNATURE);
+      expect(JSON.parse(bodies[2])).toEqual(removeThinking(bodies[1]));
+      expect(queries).toHaveLength(1);
+      expect(bodies[2]).toContain("retained search result");
+      expect(result.log.activeAttempt?.recoveryKinds).toEqual(["opaque-blob-rejection"]);
+    });
+  }
+  for (const stream of [false, true]) {
+    test(`HTTP 400 rebuilds current iteration and memoizes final completion (stream=${stream})`, async () => {
+      const { bodies, queries } = transport(index => index === 1 ? rejection() : success());
+      const result = await send({}, config(), request(stream));
+      expect(result.response.status).toBe(200);
+      expect(result.text).toContain("Recovered search answer");
+      expect(result.text).not.toContain("response.failed");
+      expect(bodies).toHaveLength(2);
+      expect(bodies[0]).toContain(SIGNATURE);
+      expectStripped(bodies[1]);
+      expect(JSON.parse(bodies[1])).toEqual(removeThinking(bodies[0]));
+      expect(queries).toHaveLength(0);
+      expect(result.log.activeAttempt?.recoveryKinds).toEqual(["opaque-blob-rejection"]);
+      await send({}, config(), request(stream));
+      expect(bodies).toHaveLength(3);
+      expectStripped(bodies[2]);
+    });
+  }
+  test("initial raw SSE error after pings retries before any current-send output", async () => {
+    const { bodies } = transport(index => index === 1 ? streamRejection(": keepalive\n\n", frame("ping")) : success());
+    const result = await send();
+    expect(result.text).toContain("Recovered search answer");
+    expect(result.text).toContain("response.completed");
+    expect(result.text).not.toContain(REJECTION);
+    expect(bodies).toHaveLength(2);
+    expectStripped(bodies[1]);
+  });
+  for (const rawSse of [false, true]) {
+    test(`rejection after search replays only current iteration and retains tool history (SSE=${rawSse})`, async () => {
+      const { bodies, queries } = transport(index => index === 1 ? search() : index === 2
+        ? rawSse ? streamRejection(frame("ping")) : rejection() : success());
+      const result = await send();
+      expect(result.text).toContain("Recovered search answer");
+      expect(result.text).not.toContain("response.failed");
+      expect(bodies).toHaveLength(3);
+      expect(queries).toHaveLength(1);
+      expect(bodies[1]).toContain(SIGNATURE);
+      expectStripped(bodies[2]);
+      expect(bodies[2]).toContain("retained search result");
+      expect(bodies[2]).toContain("ws_fixture");
+      expect(JSON.parse(bodies[2])).toEqual(removeThinking(bodies[1]));
+      expect(result.log.activeAttempt?.recoveryKinds).toEqual(["opaque-blob-rejection"]);
+    });
+  }
+
+  test("old stripping persists while newly issued search thinking remains replayable", async () => {
+    const firstFresh = "SyntheticFreshFirstSignature123456==";
+    const secondFresh = "SyntheticFreshSecondSignature123456==";
+    const { bodies, queries } = transport(index => index === 1 ? rejection()
+      : index === 2 ? search("ws_first", "first fixture", firstFresh)
+        : index === 3 ? search("ws_second", "second fixture", secondFresh) : success());
+    const result = await send();
+    expect(result.text).toContain("Recovered search answer");
+    expect(bodies).toHaveLength(4);
+    expect(queries).toHaveLength(2);
+    expectStripped(bodies[1]);
+    for (const body of bodies.slice(2)) { expect(body).not.toContain(SIGNATURE); expect(body).not.toContain(REDACTED); }
+    expect(bodies[2]).toContain(firstFresh);
+    expect(bodies[3]).toContain(firstFresh);
+    expect(bodies[3]).toContain(secondFresh);
+    expect(bodies[3]).toContain("ws_first");
+    expect(bodies[3]).toContain("ws_second");
+    expect(result.log.activeAttempt?.recoveryKinds).toEqual(["opaque-blob-rejection"]);
+  });
+  for (const firstSse of [false, true]) {
+    test(`HTTP and SSE refusals share one request-wide guard across rounds (first SSE=${firstSse})`, async () => {
+      const fresh = "SyntheticFreshGuardSignature123456==";
+      const { bodies, queries } = transport(index => index === 1 ? firstSse ? streamRejection() : rejection()
+        : index === 2 ? search("ws_fixture", "fixture", fresh) : index === 3 ? firstSse ? rejection() : streamRejection() : success());
+      const result = await send();
+      expect(bodies).toHaveLength(3);
+      expect(queries).toHaveLength(1);
+      expectStripped(bodies[1]);
+      expect(bodies[2]).not.toContain(SIGNATURE);
+      expect(bodies[2]).not.toContain(REDACTED);
+      expect(bodies[2]).toContain(fresh);
+      expect(result.text).toContain("response.failed");
+      expect(result.text).toContain(REJECTION);
+      await send();
+      expect(bodies).toHaveLength(4);
+      expect(bodies[3]).toContain(SIGNATURE);
+    });
+    test(`HTTP and SSE refusals share one allowance within a send (first SSE=${firstSse})`, async () => {
+      const { bodies } = transport(index => index === 1 ? firstSse ? streamRejection() : rejection()
+        : firstSse ? rejection() : streamRejection());
+      const result = await send();
+      expect(bodies).toHaveLength(2);
+      expectStripped(bodies[1]);
+      expect(result.text).toContain(REJECTION);
+    });
+  }
+  for (const prefix of [
+    { name: "visible text", value: textFrame("Already visible") },
+    { name: "thinking start", value: frame("content_block_start", { index: 0, content_block: { type: "thinking", thinking: "" } }) },
+    { name: "tool call start", value: frame("content_block_start", { index: 0, content_block: { type: "tool_use", id: "lookup_fixture", name: "lookup", input: {} } }) },
+    { name: "hosted search start", value: frame("content_block_start", { index: 0, content_block: { type: "tool_use", id: "ws_unsafe", name: "web_search", input: {} } }) },
+  ]) for (const afterSearch of [false, true]) {
+    test(`current-send ${prefix.name} fences recovery (prior search=${afterSearch})`, async () => {
+      const { bodies, queries } = transport(index => afterSearch && index === 1 ? search() : streamRejection(prefix.value));
+      const result = await send();
+      expect(bodies).toHaveLength(afterSearch ? 2 : 1);
+      expect(queries).toHaveLength(afterSearch ? 1 : 0);
+      expect(result.text).toContain("response.failed");
+      expect(result.text).toContain(REJECTION);
+    });
+  }
+  for (const retry of ["http", "raw-error", "empty", "truncated", "incomplete", "thinking-only", "search-then-fail"] as const) {
+    test(`a ${retry} replacement cannot memoize stripped history`, async () => {
+      const { bodies } = transport(index => index === 1 ? streamRejection() : index === 2
+        ? retry === "http" ? rejection("Synthetic replacement refusal")
+          : retry === "raw-error" ? streamRejection()
+            : retry === "empty" ? success("")
+              : retry === "truncated" ? sse(textFrame("Partial answer"))
+                : retry === "incomplete" ? success("Partial answer", "max_tokens")
+                  : retry === "thinking-only" ? sse(frame("content_block_start", { index: 0, content_block: { type: "thinking", thinking: "" } }),
+                    frame("content_block_delta", { index: 0, delta: { type: "thinking_delta", thinking: "Only thinking" } }),
+                    frame("content_block_stop", { index: 0 }), frame("message_delta", { delta: { stop_reason: "end_turn" } }), frame("message_stop"))
+                    : search()
+        : index === 3 && retry === "search-then-fail" ? rejection("Synthetic final refusal") : success());
+      const result = await send();
+      expect(bodies).toHaveLength(retry === "search-then-fail" ? 3 : 2);
+      expectStripped(bodies[1]);
+      if (retry === "http") expect(result.text).toContain("Synthetic replacement refusal");
+      if (retry === "search-then-fail") expect(result.text).toContain("Synthetic final refusal");
+      await send();
+      expect(bodies.at(-1)).toContain(SIGNATURE);
+    });
+  }
+  test("non-replayable HTTP refusal never authorizes stripping", async () => {
+    const { bodies } = transport(() => {
+      const response = rejection(); markResponseNonReplayable(response); return response;
+    });
+    const result = await send();
+    expect(result.response.status).toBe(400);
+    expect(bodies).toHaveLength(1);
+    expect(bodies[0]).toContain(SIGNATURE);
+  });
+  test("unrelated refusal text and unsigned history never gain a resend", async () => {
+    for (const message of ["Invalid `signature` in `thinking` block", "The block is bound to a different conversation", "Invalid API key"]) {
+      const { bodies } = transport(() => rejection(message));
+      expect((await send()).response.status).toBe(400);
+      expect(bodies).toHaveLength(1);
+    }
+    const { bodies } = transport(() => rejection());
+    expect((await send({}, config(), request(true, "unsigned-search-thread", false))).response.status).toBe(400);
+    expect(bodies).toHaveLength(1);
+  });
+  for (const combo of [false, true]) for (const rawSse of [false, true]) {
+    test(`shared budget denies recovery without another physical send (Combo=${combo}, SSE=${rawSse})`, async () => {
+      const budget = createRequestExecutionBudget({ maxTotalModelSends: combo ? 1 : 0,
+        baseSendAllowance: combo ? 1 : 0, finalRecoveryAllowance: 0,
+        maxAlternateTargetSends: 0, maxTargetTransitions: 0 }, "search-recovery-refused");
+      const options: Parameters<typeof handleResponses>[3] = { sendBudget: budget };
+      if (combo) {
+        const booking = budget.reserveDispatch({ sendClass: "initial", targetKey: "anthropic-test|https://anthropic.example.test/v1/messages|claude-sonnet-4-5", countedExternally: true });
+        if (!booking.allowed) throw new Error("Synthetic initial booking refused");
+        options.comboAttempt = true;
+        options.comboInitialSend = { permit: booking.permit };
+      }
+      const { bodies } = transport(index => index === 1 ? rawSse ? streamRejection() : rejection() : success());
+      await send(options);
+      expect(bodies).toHaveLength(1);
+      expect(budget.used).toBe(1);
+      await send();
+      expect(bodies).toHaveLength(2);
+      expect(bodies[1]).toContain(SIGNATURE);
+    });
+  }
+  for (const rawSse of [false, true]) {
+    test(`cancellation before recovery prevents dispatch and memo (SSE=${rawSse})`, async () => {
+      const abort = new AbortController();
+      const { bodies } = transport(index => {
+        if (index === 1) { abort.abort(); return rawSse ? streamRejection() : rejection(); }
+        return success();
+      });
+      await send({ abortSignal: abort.signal });
+      expect(bodies).toHaveLength(1);
+      await send();
+      expect(bodies).toHaveLength(2);
+      expect(bodies[1]).toContain(SIGNATURE);
+    });
+  }
+  test("cancellation after recovery dispatch does not memoize an unread success", async () => {
+    const abort = new AbortController();
+    const { bodies } = transport(index => {
+      if (index === 1) return streamRejection();
+      if (index === 2) abort.abort();
+      return success();
+    });
+    try { await send({ abortSignal: abort.signal }); } catch { /* cancelled client read */ }
+    expect(bodies).toHaveLength(2);
+    expectStripped(bodies[1]);
+    await send();
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+  test("success memo is isolated by thread, credential, destination, and model", async () => {
+    const { bodies } = transport(index => index === 1 ? rejection() : success());
+    await send();
+    expect(bodies).toHaveLength(2);
+    await send();
+    expectStripped(bodies[2]);
+    await send({}, config(), request(true, "separate-search-thread"));
+    expect(bodies[3]).toContain(SIGNATURE);
+    const credential = config(); credential.providers["anthropic-test"]!.apiKey = "separate-synthetic-key";
+    await send({}, credential);
+    // A serving-route transition independently strips once; the next stable turn proves no rejection memo crossed identities.
+    await send({}, credential); expect(bodies[5]).toContain(SIGNATURE);
+    const destination = config(); destination.providers["anthropic-test"]!.baseUrl = "https://other-anthropic.example.test";
+    await send({}, destination);
+    await send({}, destination); expect(bodies[7]).toContain(SIGNATURE);
+    const model = config(); model.providers["anthropic-test"]!.models = ["claude-opus-4-5"];
+    const previous = request(); const body = await previous.json(); body.model = "anthropic-test/claude-opus-4-5";
+    await send({}, model, new Request(previous.url, { method: "POST", headers: previous.headers, body: JSON.stringify(body) }));
+    await send({}, model, new Request(previous.url, { method: "POST", headers: previous.headers, body: JSON.stringify(body) }));
+    expect(bodies[9]).toContain(SIGNATURE);
+  });
+
+  test("a completed intermediate search cannot memoize an empty final answer", async () => {
+    const { bodies, queries } = transport(index => index === 1 ? rejection() : index === 2 ? search()
+      : index === 3 ? success("") : success());
+    const result = await send();
+    expect(result.text).toContain("response.completed");
+    expect(queries).toHaveLength(1);
+    expect(bodies).toHaveLength(3);
+    await send();
+    expect(bodies[3]).toContain(SIGNATURE);
+  });
+  for (const combo of [false, true]) for (const rawSse of [false, true]) {
+    test(`successful recovery charges each physical send once (Combo=${combo}, SSE=${rawSse})`, async () => {
+      let charges = 0, refunds = 0;
+      const budget = createRequestExecutionBudget({ maxTotalModelSends: 2, baseSendAllowance: 2,
+        finalRecoveryAllowance: 0, maxAlternateTargetSends: 0, maxTargetTransitions: 0 }, "search-recovery-charged",
+      { charge: () => { charges++; return true; }, refund: () => { refunds++; } });
+      const options: Parameters<typeof handleResponses>[3] = { sendBudget: budget };
+      if (combo) {
+        const booking = budget.reserveDispatch({ sendClass: "initial", targetKey: "anthropic-test|https://anthropic.example.test/v1/messages|claude-sonnet-4-5", countedExternally: true });
+        if (!booking.allowed) throw new Error("Synthetic initial booking refused");
+        options.comboAttempt = true; options.comboInitialSend = { permit: booking.permit };
+      }
+      const { bodies } = transport(index => index === 1 ? rawSse ? streamRejection() : rejection() : success());
+      const result = await send(options);
+      expect(result.text).toContain("Recovered search answer");
+      expect(bodies).toHaveLength(2);
+      expect(budget.used).toBe(2);
+      expect(charges).toBe(2);
+      expect(refunds).toBe(0);
+    });
+  }
+  for (const rawSse of [false, true]) {
+    test(`enforced spend owner refuses unproven recovery even with numeric headroom (SSE=${rawSse})`, async () => {
+      const lines: string[] = [];
+      const journal: SpendJournal = { read: () => [...lines], append: line => { lines.push(line); },
+        rewrite: next => { lines.splice(0, lines.length, ...next); } };
+      const ledger = createSpendReservationLedger({ journal, salt: "search-recovery-enforced", policy: {
+        ...DEFAULT_SPEND_RESERVATION_POLICY, pool: { maxTokens: 1_000_000 },
+      } });
+      const tracker = createRequestSpendTracker({ provider: "anthropic-test", model: "claude-sonnet-4-5",
+        spendPoolId: "anthropic-test", usageLogInputTokens: 10, spendOutputCeilingTokens: 0 }, undefined, ledger);
+      const budget = createRequestExecutionBudget(undefined, "search-recovery-enforced", tracker);
+      const { bodies } = transport(index => index === 1 ? rawSse ? streamRejection() : rejection() : success());
+      const result = await send({ sendBudget: budget });
+      expect(budget.spendEnforced).toBe(true);
+      expect(bodies).toHaveLength(1);
+      expect(result.text).toContain(REJECTION);
+      expect(budget.remainingBaseSends(4)).toBeGreaterThan(0);
+      await send();
+      expect(bodies[1]).toContain(SIGNATURE);
+    });
+  }
+  test("a local retry-budget exception preserves terminal 429 identity", async () => {
+    const { bodies } = transport(index => {
+      if (index === 1) return streamRejection();
+      if (index === 2) throw new SendBudgetExhaustedError("synthetic-search-recovery");
+      return success();
+    });
+    const result = await send();
+    expect(bodies).toHaveLength(2);
+    expectStripped(bodies[1]);
+    const failure = result.text.split("\n").filter(line => line.startsWith("data: {") && line.includes('"type":"response.failed"'))
+      .map(line => JSON.parse(line.slice(6)))[0]?.response;
+    expect(failure?.error.type).toBe("rate_limit_error");
+    expect(failure?.error.code).toBe("request_send_budget_exhausted");
+    expect(result.text).not.toContain("Provider unreachable");
+    await send();
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+  test("a non-replayable replacement withholds diagnostics and retains terminal error identity", async () => {
+    const diagnostic = "synthetic-private-search-diagnostic";
+    const { bodies } = transport(index => {
+      if (index === 1) return streamRejection();
+      if (index !== 2) return success();
+      const response = Response.json({ error: { type: "invalid_request_error", code: "context_length_exceeded", message: diagnostic } }, { status: 400 });
+      markResponseNonReplayable(response); return response;
+    });
+    const result = await send();
+    expect(bodies).toHaveLength(2);
+    const failure = result.text.split("\n").filter(line => line.startsWith("data: {") && line.includes('"type":"response.failed"'))
+      .map(line => JSON.parse(line.slice(6)))[0]?.response;
+    expect(result.text).not.toContain(diagnostic);
+    expect(failure?.error.code).toBe("context_length_exceeded");
+    expect(failure?.retryable).toBe(false);
+    await send();
+    expect(bodies[2]).toContain(SIGNATURE);
+  });
+
+  test("three ordinary search rounds still reach their final answer without recovery", async () => {
+    const cfg = config(); delete cfg.webSearchSidecar!.maxSearchesPerTurn;
+    const { bodies, queries } = transport(index => index <= 3 ? search(`ws_${index}`, `fixture ${index}`) : success());
+    const result = await send({}, cfg);
+    expect(result.text).toContain("Recovered search answer");
+    expect(bodies).toHaveLength(4);
+    expect(queries).toHaveLength(3);
+    expect(bodies.every(body => body.includes(SIGNATURE))).toBe(true);
+    expect(result.log.activeAttempt?.recoveryKinds ?? []).not.toContain("opaque-blob-rejection");
+  });
+  test("an HTTP replacement budget exception retains HTTP 429 and its stable code", async () => {
+    const { bodies } = transport(index => {
+      if (index === 1) return rejection();
+      throw new SendBudgetExhaustedError("synthetic-http-search-recovery");
+    });
+    const result = await send();
+    expect(bodies).toHaveLength(2);
+    expect(result.response.status).toBe(429);
+    expect(JSON.parse(result.text).error).toMatchObject({ type: "rate_limit_error", code: "request_send_budget_exhausted" });
+    expect(result.text).not.toContain("Provider unreachable");
+  });
+  test("an SSE recovery owns a fresh header deadline after the original headers cleared it", async () => {
+    const abort = new AbortController();
+    const fallback = setTimeout(() => abort.abort(), 1500);
+    const cfg = config(); cfg.connectTimeoutMs = 60;
+    const { bodies } = transport((index, init) => {
+      if (index === 1) return streamRejection();
+      return new Promise<Response>((_resolve, reject) => {
+        const signal = init?.signal;
+        if (signal?.aborted) reject(signal.reason);
+        else signal?.addEventListener("abort", () => reject(signal.reason), { once: true });
+      });
+    });
+    try {
+      const result = await send({ abortSignal: abort.signal }, cfg);
+      expect(bodies).toHaveLength(2);
+      expect(abort.signal.aborted).toBe(false);
+      expect(result.text).toContain("response-header timeout");
+      expect(result.text).toContain("response.failed");
+    } finally { clearTimeout(fallback); abort.abort(); }
+  }, 3000);
+  test("a rejected stream whose cancel never settles cannot hold the replacement hostage", async () => {
+    let cancelled = false;
+    const abort = new AbortController();
+    const fallback = setTimeout(() => abort.abort(), 1500);
+    const { bodies } = transport(index => index === 1 ? new Response(new ReadableStream<Uint8Array>({
+      start(controller) { controller.enqueue(new TextEncoder().encode(frame("error", {
+        error: { type: "invalid_request_error", message: REJECTION },
+      }))); },
+      cancel() { cancelled = true; return new Promise<void>(() => {}); },
+    }), { headers: { "content-type": "text/event-stream" } }) : success());
+    try {
+      const result = await send({ abortSignal: abort.signal });
+      expect(abort.signal.aborted).toBe(false);
+      expect(cancelled).toBe(true);
+      expect(bodies).toHaveLength(2);
+      expect(result.text).toContain("Recovered search answer");
+    } finally { clearTimeout(fallback); abort.abort(); }
+  }, 3000);
+
+  test("same-key 429 replay can discover and recover the later signature refusal", async () => {
+    const cfg = config(); cfg.providers["anthropic-test"]!.retryOn429 = { attempts: 1, intervalMs: 1, respectRetryAfter: false };
+    const { bodies } = transport(index => index === 1
+      ? Response.json({ error: { type: "rate_limit_error", message: "Synthetic busy upstream" } }, { status: 429 })
+      : index === 2 ? rejection() : success());
+    const result = await send({}, cfg);
+    expect(result.text).toContain("Recovered search answer");
+    expect(bodies).toHaveLength(3);
+    expect(bodies[0]).toBe(bodies[1]);
+    expectStripped(bodies[2]);
+    expect(result.log.activeAttempt?.recoveryKinds).toEqual(["rate-limit-429", "opaque-blob-rejection"]);
+  });
+  test("an HTTP non-replayable replacement keeps its status, stable code, and no-retry header", async () => {
+    const { bodies } = transport(index => {
+      if (index === 1) return rejection();
+      const response = Response.json({ error: { type: "invalid_request_error", code: "context_length_exceeded",
+        message: "synthetic-private-http-diagnostic" } }, { status: 400 });
+      markResponseNonReplayable(response); return response;
+    });
+    const result = await send();
+    expect(bodies).toHaveLength(2);
+    expect(result.response.status).toBe(400);
+    expect(result.response.headers.get("x-should-retry")).toBe("false");
+    expect(JSON.parse(result.text).error).toMatchObject({ type: "invalid_request_error", code: "context_length_exceeded" });
+    expect(result.text).not.toContain("synthetic-private-http-diagnostic");
+  });
+
+  test("a marked HTTP 200 raw SSE refusal neither replays nor exposes its diagnostic", async () => {
+    const diagnostic = "synthetic-private-first-stream-diagnostic";
+    const { bodies } = transport(() => {
+      const response = sse(frame("error", { error: { type: "invalid_request_error", message: `${REJECTION} ${diagnostic}` } }));
+      markResponseNonReplayable(response); return response;
+    });
+    const result = await send();
+    expect(bodies).toHaveLength(1);
+    expect(result.text).not.toContain(diagnostic);
+    expect(result.text).not.toContain(REJECTION);
+    const failure = result.text.split("\n").filter(line => line.startsWith("data: {") && line.includes('"type":"response.failed"'))
+      .map(line => JSON.parse(line.slice(6)))[0]?.response;
+    expect(failure?.retryable).toBe(false);
+    expect(failure?.error.message).toContain("diagnostic withheld");
+  });
+});
+
+// Signature deltas are replacement snapshots (Anthropic MessageStream), not new blocks.
+for (const separateEmptyBlock of [false, true]) test(`search replay keeps latest signature without merging real blocks (empty next block=${separateEmptyBlock})`, async () => {
+  const replacementSignature = "SyntheticUpdatedSearchSignature123456==";
+  const secondSignature = "SyntheticSecondSearchSignature123456==";
+  const initial = (await search().text()).replaceAll('"index":1', separateEmptyBlock ? '"index":2' : '"index":1');
+  const marker = frame("content_block_stop", { index: 0 });
+  const extra = frame("ping")
+    + frame("content_block_delta", { index: 0, delta: { type: "signature_delta", signature: replacementSignature } })
+    + marker
+    + (separateEmptyBlock
+      ? frame("content_block_start", { index: 1, content_block: { type: "thinking", thinking: "" } })
+        + frame("content_block_delta", { index: 1, delta: { type: "signature_delta", signature: secondSignature } })
+        + frame("content_block_stop", { index: 1 }) : "");
+  const { bodies, queries } = transport(index => index === 1 ? sse(initial.replace(marker, extra)) : success());
+  const result = await send();
+  expect(result.text).toContain("response.completed");
+  expect(bodies).toHaveLength(2);
+  expect(queries).toHaveLength(1);
+  const replayed = JSON.parse(bodies[1]).messages.find((message: { role: string; content: unknown }) =>
+    message.role === "assistant" && Array.isArray(message.content)
+      && message.content.some((part: { type: string; id: string }) => part.type === "tool_use" && part.id === "ws_fixture"));
+  const blocks = replayed.content.filter((part: { type: string }) => part.type === "thinking");
+  expect(blocks).toEqual([
+    { type: "thinking", thinking: "search reasoning", signature: replacementSignature },
+    ...(separateEmptyBlock ? [{ type: "thinking", thinking: "", signature: secondSignature }] : []),
+  ]);
+});
+
+function originalBlockStream(blocks: Record<string, unknown>[], corrupt = ""): Response {
+  return sse(frame("message_start", { message: { usage: { input_tokens: 2 } } }),
+    ...blocks.flatMap((block, index) => [frame("content_block_start", { index, content_block: block }),
+      frame("content_block_stop", { index })]), corrupt,
+    frame("message_delta", { delta: { stop_reason: "tool_use" } }), frame("message_stop"));
+}
+
+test("search continuation preserves raw text boundaries, citations, opaque blocks and parallel original inputs", async () => {
+  const original = [
+    { type: "text", text: "first", citations: [{ type: "char_location", cited_text: "first", document_index: 0, start_char_index: 0, end_char_index: 5 }] },
+    { type: "text", text: "second" },
+    { type: "thinking", thinking: "", signature: SIGNATURE },
+    { type: "redacted_thinking", data: REDACTED },
+    { type: "tool_use", id: "raw_one", name: "web_search", input: { query: "first query", extra_context: { preserve: true } } },
+    { type: "tool_use", id: "raw_two", name: "web_search", input: { queries: ["second query"], original: 2 } },
+  ];
+  const { bodies, queries } = transport(index => index === 1 ? originalBlockStream(original) : success());
+  const result = await send();
+  expect(result.text).toContain("response.completed");
+  expect(queries).toHaveLength(2);
+  expect(bodies).toHaveLength(2);
+  const messages = JSON.parse(bodies[1]).messages;
+  const assistant = messages.findIndex((m: { content: unknown[] }) => Array.isArray(m.content)
+    && m.content.some((b: any) => b.id === "raw_one"));
+  expect(messages[assistant].content).toEqual(original);
+  expect(messages[assistant + 1].content.map((b: any) => b.tool_use_id)).toEqual(["raw_one", "raw_two"]);
+});
+
+for (const malformed of ["unknown block", "unknown delta", "missing stop", "duplicate index", "malformed JSON", "missing message stop", "unexpected initial content"]) {
+  test(`invalid raw search history fails before search execution: ${malformed}`, async () => {
+    let initial = await search().text();
+    if (malformed === "unknown block") initial = initial.replace('"type":"thinking","thinking":""', '"type":"server_tool_use","id":"server_side_effect","name":"web_search","input":{}');
+    if (malformed === "unknown delta") initial = initial.replace('"type":"thinking_delta"', '"type":"unknown_delta"');
+    if (malformed === "missing message stop") initial = initial.replace(frame("message_stop"), "");
+    if (malformed === "unexpected initial content") initial = initial.replace('"message":{"usage":{"input_tokens":2}}', '"message":{"content":[{"type":"text","text":"unobserved"}]}');
+    if (malformed === "missing stop") initial = initial.replace(frame("content_block_stop", { index: 0 }), "");
+    if (malformed === "duplicate index") initial = initial.replaceAll('"index":1', '"index":0');
+    if (malformed === "malformed JSON") initial = initial.replace(frame("content_block_stop", { index: 0 }), 'event: content_block_delta\ndata: {broken\n\n' + frame("content_block_stop", { index: 0 }));
+    const { bodies, queries } = transport(() => sse(initial));
+    const result = await send();
+    expect(result.text).toContain("response.failed");
+    expect(result.text).toContain("cannot be replayed losslessly");
+    expect(bodies).toHaveLength(1);
+    expect(queries).toHaveLength(0);
+  });
+}
+
+test("server tool start fences thinking repair before message completion", async () => {
+  const { bodies, queries } = transport(index => index === 1 ? streamRejection(
+    frame("message_start", { message: {} }),
+    frame("content_block_start", { index: 0, content_block: { type: "server_tool_use", id: "opaque", name: "web_search", input: {} } }),
+    frame("content_block_stop", { index: 0 }),
+  ) : success());
+  const result = await send();
+  expect(result.text).toContain("response.failed");
+  expect(bodies).toHaveLength(1);
+  expect(queries).toHaveLength(0);
+});
+
+for (const failedSearch of [false, true]) test(`parallel repeated queries retain original tool turns and existing execution counts (failed=${failedSearch})`, async () => {
+  const original = [{ type: "thinking", thinking: "parallel", signature: SIGNATURE },
+    ...["repeat_one", "repeat_two"].map(id => ({ type: "tool_use", id, name: "web_search", input: { query: "identical query", extra: id } }))];
+  const { bodies, queries } = transport(index => index === 1 ? originalBlockStream(original) : success());
+  const installedFetch = globalThis.fetch;
+  let failedCount = 0;
+  if (failedSearch) globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    if (String(input) === "https://api.exa.ai/search") { failedCount++; return Response.json({ error: "synthetic failure" }, { status: 400 }); }
+    return installedFetch(input, init);
+  }) as typeof fetch;
+  const result = await send();
+  expect(result.text).toContain("response.completed");
+  expect(failedSearch ? failedCount : queries.length).toBe(failedSearch ? 1 : 2);
+  expect(bodies).toHaveLength(2);
+  const messages = JSON.parse(bodies[1]).messages;
+  const index = messages.findIndex((m: any) => m.role === "assistant" && m.content.some((b: any) => b.id === "repeat_one"));
+  expect(messages[index].content).toEqual(original);
+  expect(messages[index + 1].content.map((b: any) => b.tool_use_id)).toEqual(["repeat_one", "repeat_two"]);
+});
+
+test("forced-answer tool calls and empty retry retain bound catalog and nudge positions", async () => {
+  const { bodies, queries } = transport(index => index <= 3 ? search(`forced_${index}`, `query ${index}`)
+    : index === 4 ? success("") : success());
+  const result = await send();
+  expect(result.text).toContain("response.completed");
+  expect(bodies).toHaveLength(5);
+  expect(queries).toHaveLength(2);
+  const requests = bodies.map(body => JSON.parse(body));
+  for (const current of requests) {
+    expect(current.tools).toEqual(requests[0].tools);
+    expect(current.system).toEqual(requests[0].system);
+  }
+  expect(requests[4].tool_choice).toEqual({ type: "none" });
+  const withoutCache = (value: unknown) => JSON.parse(JSON.stringify(value, (key, item) => key === "cache_control" ? undefined : item));
+  const prefix = withoutCache(requests[2].messages);
+  expect(withoutCache(requests[3].messages).slice(0, prefix.length)).toEqual(prefix);
+  expect(withoutCache(requests[4].messages).slice(0, prefix.length)).toEqual(prefix);
+  for (const current of requests.slice(2)) {
+    expect(JSON.stringify(current.messages).match(/Answer the user's question now using/g)).toHaveLength(1);
+  }
+});
+
+for (const choice of ["auto", "none", { type: "function", name: "web_search" },
+  { type: "allowed_tools", mode: "auto", tools: [{ type: "web_search" }] }]) {
+  test(`Opus search wire catalog remains authorized and stable: ${JSON.stringify(choice)}`, async () => {
+    const cfg = config(); cfg.providers["anthropic-test"].models = ["claude-opus-5-5"];
+    const data = await request().json();
+    data.model = "anthropic-test/claude-opus-5-5";
+    data.reasoning = { effort: "high" };
+    data.tool_choice = choice;
+    const req = new Request("http://localhost/v1/responses", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(data) });
+    const { bodies, queries } = transport(index => choice === "none" ? success() : index <= 2 ? search(`choice_${index}`, `query ${index}`)
+      : index === 3 ? success("") : success());
+    const result = await send({}, cfg, req);
+    expect(result.text).toContain("response.completed");
+    expect(bodies).toHaveLength(choice === "none" ? 1 : 4);
+    expect(queries).toHaveLength(choice === "none" ? 0 : 2);
+    const requests = bodies.map(body => JSON.parse(body));
+    const names = requests[0].tools.map((tool: any) => tool.name);
+    if (choice === "none") expect(names).not.toContain("web_search");
+    else expect(names).toContain("web_search");
+    if (typeof choice === "object") expect(names).not.toContain("lookup");
+    else expect(names).toContain("lookup");
+    for (const current of requests) {
+      expect(current.tools).toEqual(requests[0].tools);
+      expect(current.system).toEqual(requests[0].system);
+      expect(current.thinking).toEqual({ type: "adaptive", display: "summarized" });
+    }
+    expect(requests.at(-1).tool_choice).toEqual({ type: "none" });
+  });
+}
+
+for (const identity of ["unsafe id", "duplicate", "prior collision"]) test(`search refuses non-replayable tool IDs before execution: ${identity}`, async () => {
+  const id = identity === "unsafe id" ? identity : "collision";
+  const { bodies, queries } = transport(index => identity === "duplicate" ? originalBlockStream([
+    { type: "tool_use", id, name: "web_search", input: { query: "one" } },
+    { type: "tool_use", id, name: "web_search", input: { query: "two" } },
+  ]) : search(id, `query ${index}`));
+  const result = await send();
+  expect(result.text).toContain("response.failed");
+  expect(bodies).toHaveLength(identity === "prior collision" ? 2 : 1);
+  expect(queries).toHaveLength(identity === "prior collision" ? 1 : 0);
+});
+
+// All gateway request identifiers in this fixture are synthetic.
+const GENERIC_BEDROCK_SIGNATURE_ERROR = "aws_invoke_error: InvokeModelWithResponseStream: operation error Bedrock Runtime: InvokeModelWithResponseStream, https response error StatusCode: 400, RequestID: 11111111-2222-4333-8444-555555555555, ValidationException: ***.***.content.0: Invalid `signature` in `thinking` block (request id: 20260101000000000000000000syntheticABC)";
+for (const stream of [true, false]) test(`generic Bedrock HTTP signature refusal stays terminal without stripping (stream=${stream})`, async () => {
+  const { bodies, queries } = transport(() => rejection(GENERIC_BEDROCK_SIGNATURE_ERROR));
+  const result = await send({}, config(), request(stream));
+  expect(bodies).toHaveLength(1);
+  expect(queries).toHaveLength(0);
+  expect(bodies[0]).toContain(SIGNATURE);
+  expect(bodies[0]).toContain(REDACTED);
+  expect(result.text).toContain("Invalid `signature` in `thinking` block");
+  expect(result.log.activeAttempt?.recoveryKinds ?? []).toEqual([]);
+});
diff --git a/tests/responses/ws-capacity-reclamation.test.ts b/tests/responses/ws-capacity-reclamation.test.ts
new file mode 100644
index 00000000000..1a6da6f4abe
--- /dev/null
+++ b/tests/responses/ws-capacity-reclamation.test.ts
@@ -0,0 +1,328 @@
+import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { saveConfig } from "../../src/config";
+import { codexWebSocketAdmissionMetrics, MAX_TRACKED_CODEX_WEBSOCKETS } from "../../src/codex/websocket-registry";
+import {
+  clearResponseStateForTests, clearResponseStateMemoryForTests, RESPONSE_TTL_MS,
+  responseStateMetrics, sweepExpiredResponseStates,
+} from "../../src/responses/state";
+import { startServer } from "../../src/server";
+import type { OcxConfig } from "../../src/types";
+import { installIsolatedCodexHome, type IsolatedCodexHome } from "../helpers/isolated-codex-home";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+const originalFetch = globalThis.fetch;
+const previousHome = process.env.OPENCODEX_HOME;
+const MODEL = "fixture/capacity-model";
+type Frame = Record<string, any>;
+type Client = { socket: WebSocket; frames: Frame[]; closed?: CloseEvent; error?: Event };
+let home: string;
+let codex: IsolatedCodexHome;
+let proxy: ReturnType<typeof startServer> | undefined;
+let upstream: ReturnType<typeof Bun.serve> | undefined;
+let finishStream: (() => void) | undefined;
+let upstreamRequests = 0;
+let upstreamCancellations = 0;
+let heldUpstreamSignal: AbortSignal | undefined;
+const upstreamBodies: Frame[] = [];
+const clients: Client[] = [];
+const refusedHandshakes = new Map<string, { status: number; retryAfter: string | null }>();
+let closeReleaseDelayMs = 0;
+
+async function until(condition: () => boolean, description: string, timeoutMs = 5_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!condition()) {
+    if (Date.now() >= deadline) throw new Error(`Timed out: ${description}`);
+    await Bun.sleep(2);
+  }
+}
+
+function sse(event: Frame): Uint8Array {
+  return new TextEncoder().encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+}
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "ocx-ws-capacity-"));
+  process.env.OPENCODEX_HOME = home;
+  clearResponseStateMemoryForTests();
+  codex = installIsolatedCodexHome("ocx-ws-capacity-codex-");
+  upstreamRequests = 0;
+  upstreamCancellations = 0;
+  heldUpstreamSignal = undefined;
+  upstreamBodies.length = 0;
+  finishStream = undefined;
+  refusedHandshakes.clear();
+  closeReleaseDelayMs = 0;
+  globalThis.fetch = ((input: RequestInfo | URL, init?: RequestInit) => {
+    const url = new URL(input instanceof Request ? input.url : String(input));
+    if (url.hostname !== "127.0.0.1" && url.hostname !== "localhost") {
+      throw new Error("Capacity fixture forbids external requests");
+    }
+    if (url.port === String(upstream?.port) && String(init?.body).includes("hold-fixture-stream")) {
+      heldUpstreamSignal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+    }
+    return originalFetch(input, init);
+  }) as typeof fetch;
+  upstream = Bun.serve({
+    // Only proxy cancellation may end a held response; Bun's default idle timeout must not.
+    hostname: "127.0.0.1", port: 0, idleTimeout: 0,
+    async fetch(request) {
+      const body = await request.json() as Frame;
+      upstreamRequests++;
+      upstreamBodies.push(body);
+      const id = `resp_capacity_${upstreamRequests}`;
+      const tool = JSON.stringify(body.input).includes("request-fixture-tool");
+      const hold = JSON.stringify(body.input).includes("hold-fixture-stream");
+      const stream = new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(sse({ type: "response.created", response: { id, status: "in_progress", output: [] } }));
+          const output = tool
+            ? [{ type: "function_call", id: "fc_capacity", call_id: "call_capacity", name: "fixture_tool", arguments: "{}" }]
+            : [{ type: "message", id: "msg_capacity", role: "assistant", content: [{ type: "output_text", text: "capacity fixture completed" }] }];
+          const finish = () => {
+            if (tool) controller.enqueue(sse({ type: "response.output_item.done", output_index: 0, item: output[0] }));
+            controller.enqueue(sse({ type: "response.completed", response: { id, status: "completed", output,
+              usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } }));
+            controller.close();
+          };
+          if (hold) finishStream = finish; else finish();
+        },
+        cancel() { upstreamCancellations++; },
+      });
+      return new Response(stream, { headers: { "content-type": "text/event-stream" } });
+    },
+  });
+  saveConfig({
+    port: 0, hostname: "127.0.0.1", codexAutoStart: false, websockets: true,
+    defaultProvider: "fixture", providers: { fixture: {
+      adapter: "openai-responses", baseUrl: `${upstream.url}v1`, apiKey: "sk-capacity-fixture", upstreamWebsocket: false,
+      allowPrivateNetwork: true, statelessResponses: true,
+    } },
+  } as OcxConfig);
+  expect(codexWebSocketAdmissionMetrics().active).toBe(0);
+  // Observe actual upgrade refusals; delay only the fixture close callback in the delayed row.
+  const originalServe = Bun.serve;
+  const serveSpy = spyOn(Bun, "serve").mockImplementation(((options: any) => originalServe({
+    ...options,
+    async fetch(request: Request, server: any) {
+      const response = await options.fetch(request, server);
+      const attempt = new URL(request.url).searchParams.get("capacity-attempt");
+      if (attempt !== null && response) refusedHandshakes.set(attempt,
+        { status: response.status, retryAfter: response.headers.get("retry-after") });
+      return response;
+    },
+    websocket: { ...options.websocket, close(...args: any[]) {
+      if (closeReleaseDelayMs) setTimeout(() => options.websocket.close(...args), closeReleaseDelayMs);
+      else options.websocket.close(...args);
+    } },
+  })) as typeof Bun.serve);
+  try { proxy = startServer(0); } finally { serveSpy.mockRestore(); }
+});
+
+afterEach(async () => {
+  try {
+    for (const client of clients) client.socket.close();
+    await proxy?.stop(true);
+    await upstream?.stop(true);
+    await until(() => codexWebSocketAdmissionMetrics().active === 0, "all socket reservations released");
+  } finally {
+    clients.length = 0;
+    proxy = undefined;
+    upstream = undefined;
+    globalThis.fetch = originalFetch;
+    clearResponseStateForTests();
+    codex.restore();
+    removeTreeWithRetry(home);
+    if (previousHome === undefined) delete process.env.OPENCODEX_HOME;
+    else process.env.OPENCODEX_HOME = previousHome;
+  }
+});
+
+async function connect(retriesRemaining = MAX_TRACKED_CODEX_WEBSOCKETS): Promise<Client> {
+  const url = new URL("/v1/responses", proxy!.url);
+  url.protocol = "ws:";
+  const attempt = String(clients.length);
+  url.searchParams.set("capacity-attempt", attempt);
+  const client: Client = { socket: new WebSocket(url), frames: [] };
+  clients.push(client);
+  client.socket.addEventListener("message", event => client.frames.push(JSON.parse(String(event.data))));
+  client.socket.addEventListener("close", event => { client.closed = event; });
+  client.socket.addEventListener("error", event => { client.error = event; });
+  await until(() => client.socket.readyState === WebSocket.OPEN || Boolean(client.error || client.closed), "socket handshake");
+  if (client.socket.readyState !== WebSocket.OPEN) {
+    expect(refusedHandshakes.get(attempt)).toEqual({ status: 503, retryAfter: "1" });
+    await until(() => codexWebSocketAdmissionMetrics().active < MAX_TRACKED_CODEX_WEBSOCKETS,
+      "reclaimed socket releases admission before retry");
+    expect(retriesRemaining).toBeGreaterThan(0);
+    return connect(retriesRemaining - 1);
+  }
+  return client;
+}
+
+async function fill(): Promise<Client[]> {
+  const opened: Client[] = [];
+  for (let i = 0; i < MAX_TRACKED_CODEX_WEBSOCKETS; i++) opened.push(await connect());
+  return opened;
+}
+
+async function exchange(client: Client, fields: Frame, terminal = "response.completed"): Promise<Frame> {
+  const start = client.frames.length;
+  client.socket.send(JSON.stringify({ type: "response.create", model: MODEL, input: "fixture input", ...fields }));
+  await until(() => client.frames.slice(start).some(frame => frame.type === terminal || frame.type === "error")
+    || Boolean(client.closed), `socket ${terminal}`);
+  const result = client.frames.slice(start).find(frame => frame.type === terminal || frame.type === "error");
+  expect(result?.type).toBe(terminal);
+  return result!;
+}
+
+function expectBounded(): void {
+  const metrics = codexWebSocketAdmissionMetrics();
+  expect(metrics.active).toBe(MAX_TRACKED_CODEX_WEBSOCKETS);
+  expect(metrics.peak).toBe(MAX_TRACKED_CODEX_WEBSOCKETS);
+  expect(metrics.releaseMisses).toBe(0);
+}
+
+test.each([0, 20])("the 129th handshake reclaims the least recently used idle socket and reconnects cleanly; close delay=%s", async delay => {
+  closeReleaseDelayMs = delay;
+  const opened = await fill();
+  expect(opened.every(client => client.socket.readyState === WebSocket.OPEN)).toBe(true);
+  await exchange(opened[0]!, { generate: false });
+  expect(upstreamRequests).toBe(0);
+  const replacement = await connect();
+  await until(() => Boolean(opened[1]!.closed), "least recently used idle socket closed");
+  expect(opened[1]!.closed?.code).toBe(1001);
+  if (delay) expect([...refusedHandshakes.values()].some(response => response.status === 503)).toBe(true);
+  expect(opened[0]!.socket.readyState).toBe(WebSocket.OPEN);
+  expectBounded();
+  await exchange(replacement, { input: "fresh request after capacity recovery" });
+  expect(upstreamRequests).toBe(1);
+  const reconnected = await connect();
+  await exchange(reconnected, { input: "resubmitted full conversation" });
+  expect(upstreamRequests).toBe(2);
+  expectBounded();
+}, 15_000);
+
+test("concurrent handshakes replace idle sockets without over-admitting or leaking leases", async () => {
+  const opened = await fill();
+  const added = await Promise.all(Array.from({ length: 16 }, () => connect()));
+  await until(() => opened.filter(client => client.closed).length === 16, "all reclaimed clients closed");
+  expect(opened.slice(0, 16).every(client => client.closed?.code === 1001)).toBe(true);
+  expect(opened.slice(16).every(client => client.socket.readyState === WebSocket.OPEN)).toBe(true);
+  expect(added.every(client => client.socket.readyState === WebSocket.OPEN)).toBe(true);
+  expectBounded();
+}, 15_000);
+
+test("capacity pressure preserves a streaming response until it completes", async () => {
+  const opened = await fill();
+  await exchange(opened[0]!, { input: "hold-fixture-stream" }, "response.created");
+  // Refresh every idle socket so the busy connection is the oldest by activity too.
+  for (const client of opened.slice(1)) await exchange(client, { generate: false });
+  await connect();
+  await until(() => Boolean(opened[1]!.closed), "oldest eligible idle socket closed");
+  expect(opened[0]!.socket.readyState).toBe(WebSocket.OPEN);
+  finishStream!();
+  await until(() => opened[0]!.frames.some(frame => frame.type === "response.completed"), "protected stream completes");
+  expect(opened[0]!.frames.some(frame => frame.type === "error")).toBe(false);
+  expectBounded();
+}, 15_000);
+
+test("client tool execution stays protected, and all-busy saturation keeps the 503 refusal", async () => {
+  const opened = await fill();
+  for (const client of opened) {
+    await exchange(client, { input: "request-fixture-tool", tools: [{ type: "function", name: "fixture_tool",
+      parameters: { type: "object", properties: {} } }] });
+  }
+  const rejectedBefore = codexWebSocketAdmissionMetrics().rejected;
+  const response = await fetch(new URL("/v1/responses", proxy!.url), { headers: {
+    connection: "upgrade", upgrade: "websocket", "sec-websocket-version": "13",
+    "sec-websocket-key": Buffer.from("capacity-fixture").toString("base64"),
+  } });
+  expect(response.status).toBe(503);
+  expect(response.headers.get("retry-after")).toBe("1");
+  expect(await response.text()).toContain("Codex WebSockets capacity reached");
+  expect(codexWebSocketAdmissionMetrics().rejected).toBe(rejectedBefore + 1);
+  expect(opened.every(client => client.socket.readyState === WebSocket.OPEN)).toBe(true);
+  await exchange(opened[0]!, { input: [{ type: "function_call_output", call_id: "call_capacity", output: "fixture tool result" }] });
+  await connect();
+  await until(() => Boolean(opened[0]!.closed), "completed tool workflow becomes reclaimable");
+  expect(opened.slice(1).every(client => client.socket.readyState === WebSocket.OPEN)).toBe(true);
+  expectBounded();
+}, 20_000);
+
+test.each([false, true])("disconnect releases admission and allows a fresh request; abrupt=%s", async abrupt => {
+  const baseline = codexWebSocketAdmissionMetrics();
+  const client = await connect();
+  expect(codexWebSocketAdmissionMetrics().active).toBe(baseline.active + 1);
+  if (abrupt) {
+    await exchange(client, { input: "hold-fixture-stream" }, "response.created");
+    expect(heldUpstreamSignal).toBeDefined();
+    expect(heldUpstreamSignal!.aborted).toBe(false);
+    // Bun's client API terminates the real TCP connection without a closing handshake.
+    client.socket.terminate();
+  } else client.socket.close(1000, "fixture normal disconnect");
+  await until(() => codexWebSocketAdmissionMetrics().active === baseline.active,
+    "disconnected socket releases its reservation", 10_000);
+  await until(() => Boolean(client.closed), "client observes close", 10_000);
+  expect(client.closed?.code).toBe(abrupt ? 1006 : 1000);
+  const replacement = await connect();
+  await exchange(replacement, { input: "fresh request after disconnect" });
+  expect(upstreamRequests).toBe(abrupt ? 2 : 1);
+  replacement.socket.close();
+  await until(() => codexWebSocketAdmissionMetrics().active === baseline.active, "replacement reservation released");
+  expect(codexWebSocketAdmissionMetrics().releaseMisses).toBe(baseline.releaseMisses);
+  // Eager relay preserves a real terminal during its existing 15-second discard-drain.
+  // Socket admission and the replacement request must recover before that separate cleanup.
+  if (abrupt) {
+    await until(() => heldUpstreamSignal!.aborted, "abandoned upstream request aborted", 20_000);
+    await until(() => upstreamCancellations === 1, "upstream observed request cancellation");
+  }
+}, 25_000);
+
+test("failed HTTP upgrade releases its reservation before the next handshake", async () => {
+  const baseline = codexWebSocketAdmissionMetrics();
+  const response = await fetch(new URL("/v1/responses", proxy!.url), { headers: {
+    connection: "upgrade", upgrade: "websocket", "sec-websocket-version": "13",
+    // Missing Sec-WebSocket-Key reaches Bun's unsuccessful upgrade after reservation.
+  } });
+  expect(response.status).toBe(426);
+  expect(await response.text()).toContain("WebSocket upgrade failed");
+  expect(codexWebSocketAdmissionMetrics()).toMatchObject({ active: baseline.active,
+    admitted: baseline.admitted + 1, rejected: baseline.rejected, releaseMisses: baseline.releaseMisses });
+  const replacement = await connect();
+  await exchange(replacement, { input: "fresh request after failed handshake" });
+  expect(upstreamRequests).toBe(1);
+  expect(codexWebSocketAdmissionMetrics().active).toBe(baseline.active + 1);
+});
+
+test.each([false, true])("stateless continuation after capacity reclamation preserves full history; expired=%s", async expired => {
+  const original = await connect();
+  const firstInput = { role: "user", content: [{ type: "input_text", text: "Remember the fixture number 47." }] };
+  const first = await exchange(original, { input: [firstInput], store: false });
+  const previousId = first.response.id;
+  expect(typeof previousId).toBe("string");
+  expect(previousId.length).toBeGreaterThan(0);
+  await until(() => responseStateMetrics().count === 1, "first response retains real continuation state");
+  for (let i = 1; i < MAX_TRACKED_CODEX_WEBSOCKETS; i++) await connect();
+  const reconnected = await connect();
+  await until(() => original.closed?.code === 1001, "socket holding the response ID reclaimed");
+  if (expired) {
+    expect(sweepExpiredResponseStates(Date.now() + RESPONSE_TTL_MS + 60_000)).toBe(1);
+    expect(responseStateMetrics().count).toBe(0);
+  }
+  const delta = { role: "user", content: [{ type: "input_text", text: "Use that number in the next answer." }] };
+  const outcome = await exchange(reconnected, { previous_response_id: previousId, input: [delta], store: false },
+    expired ? "error" : "response.completed");
+  if (expired) {
+    expect(outcome).toMatchObject({ type: "error", status: 400, error: { code: "previous_response_not_found" } });
+    expect(upstreamRequests).toBe(1); // Never forward the delta without its missing prefix.
+    await exchange(reconnected, { input: [firstInput, ...first.response.output, delta], store: false });
+  }
+  expect(upstreamRequests).toBe(2); // One initial response and one complete continuation, without a duplicate execution.
+  expect(upstreamBodies[1]!.previous_response_id).toBeUndefined();
+  expect(upstreamBodies[1]!.input).toHaveLength(3);
+  expect(upstreamBodies[1]!.input).toMatchObject([firstInput,
+    { type: "message", role: "assistant", content: [{ type: "output_text", text: "capacity fixture completed" }] }, delta]);
+  expectBounded();
+}, 15_000);
diff --git a/tests/responses/ws-capacity-tool-ownership.test.ts b/tests/responses/ws-capacity-tool-ownership.test.ts
new file mode 100644
index 00000000000..468a6487381
--- /dev/null
+++ b/tests/responses/ws-capacity-tool-ownership.test.ts
@@ -0,0 +1,254 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import type { ServerWebSocket } from "bun";
+import { clearComboSelectionState, clearComboTargetCooldowns } from "../../src/combos";
+import {
+  codexWebSocketAdmissionMetrics, MAX_TRACKED_CODEX_WEBSOCKETS, tryReserveCodexWebSocket,
+} from "../../src/codex/websocket-registry";
+import type { AdmissionReservation } from "../../src/lib/admission";
+import { runOptionalShutdownHooks } from "../../src/lib/optional-shutdown-hooks";
+import { clearKeyCooldowns } from "../../src/providers/key-failover";
+import { createWebsocketHandler } from "../../src/server/index/websocket-handler";
+import type { ServeOptionsContext } from "../../src/server/index/serve-options";
+import { clearRequestLogsForTests } from "../../src/server/request-log";
+import { setRelayPlatformForTests } from "../../src/server/responses/passthrough-delivery";
+import type { WsData } from "../../src/server/ws-bridge";
+import type { OcxConfig } from "../../src/types";
+import { acquireOwnedSpendHome } from "../helpers/owned-spend-home";
+import { createTempHome, type TempHome } from "../helpers/temp-home";
+
+type Frame = Record<string, any>;
+type Handler = ReturnType<typeof createWebsocketHandler>;
+type Client = { ws: ServerWebSocket<WsData>; handler: Handler; sent: Frame[]; closed: number[] };
+const originalFetch = globalThis.fetch;
+const proxyKeys = ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "all_proxy", "no_proxy"];
+const clients: Client[] = [];
+const extraLeases: AdmissionReservation<ServerWebSocket<WsData>>[] = [];
+const finishBusy: Array<() => void> = [];
+let home: TempHome;
+let releaseSpendHome: () => void;
+let savedProxy: Record<string, string | undefined>;
+let upstream: (body: Frame, url: URL) => Response;
+let outbound: Frame[];
+
+async function until(condition: () => boolean): Promise<void> {
+  const deadline = Date.now() + 5_000;
+  while (!condition()) {
+    if (Date.now() >= deadline) throw new Error("WebSocket tool ownership fixture did not settle");
+    await Bun.sleep(1);
+  }
+}
+
+beforeEach(() => {
+  clearComboSelectionState();
+  clearComboTargetCooldowns();
+  clearKeyCooldowns();
+  home = createTempHome("ocx-ws-tool-ownership-");
+  releaseSpendHome = acquireOwnedSpendHome();
+  savedProxy = Object.fromEntries(proxyKeys.map(key => [key, process.env[key]]));
+  for (const key of proxyKeys) delete process.env[key];
+  outbound = [];
+  upstream = () => { throw new Error("Unexpected upstream request in tool ownership fixture"); };
+  globalThis.fetch = (async (input, init) => {
+    const body = JSON.parse(String(init?.body)) as Frame;
+    outbound.push(body);
+    return upstream(body, new URL(input instanceof Request ? input.url : String(input)));
+  }) as typeof fetch;
+  clearRequestLogsForTests();
+  expect(codexWebSocketAdmissionMetrics().active).toBe(0);
+});
+
+afterEach(async () => {
+  try {
+    for (const client of clients) client.ws.close(1000, "fixture teardown");
+    await until(() => clients.every(({ ws }) => !ws.data.cancel && !ws.data.nativeControl));
+  } finally {
+    for (const finish of finishBusy.splice(0)) finish();
+    for (const lease of extraLeases.splice(0)) lease.release();
+    clients.length = 0;
+    clearComboSelectionState();
+    clearComboTargetCooldowns();
+    clearKeyCooldowns();
+    try {
+      runOptionalShutdownHooks();
+    } finally {
+      try { releaseSpendHome(); }
+      finally {
+        setRelayPlatformForTests(undefined);
+        globalThis.fetch = originalFetch;
+        for (const key of proxyKeys) {
+          if (savedProxy[key] === undefined) delete process.env[key];
+          else process.env[key] = savedProxy[key];
+        }
+        home.remove();
+      }
+    }
+  }
+  expect(codexWebSocketAdmissionMetrics().active).toBe(0);
+});
+
+function config(baseUrl = "https://api.x.ai/v1", injectXSearch = false): OcxConfig {
+  return { port: 0, defaultProvider: "fixture", websockets: true, providers: { fixture: {
+    adapter: "openai-responses", baseUrl, authMode: "key", apiKey: "fixture-tool-ownership-key", upstreamWebsocket: false,
+    ...(injectXSearch ? { xaiResponsesXSearch: true, supportsOpenAiWebSearchToolFields: false } : {}),
+  } } } as OcxConfig;
+}
+
+function client(settings = config()): Client {
+  const lease = tryReserveCodexWebSocket();
+  expect(lease).not.toBeNull();
+  const handler = createWebsocketHandler({ config: settings, deps: {} } as ServeOptionsContext);
+  const sent: Frame[] = [];
+  const closed: number[] = [];
+  let state = 1;
+  const ws = {
+    data: { admissionLease: lease!, headers: new Headers({ "thread-id": `tool-ownership-${clients.length}` }) } as WsData,
+    get readyState() { return state; },
+    getBufferedAmount: () => 0,
+    send(text: string) { sent.push(JSON.parse(text)); return 1; },
+    close(code = 1000, reason = "") {
+      if (state === 3) return;
+      state = 3;
+      closed.push(code);
+      handler.close(ws, code, reason);
+    },
+  } as unknown as ServerWebSocket<WsData>;
+  handler.open(ws);
+  const result = { ws, handler, sent, closed };
+  clients.push(result);
+  return result;
+}
+
+async function turn(target: Client, fields: Frame): Promise<Frame[]> {
+  const start = target.sent.length;
+  target.handler.message(target.ws, JSON.stringify({ type: "response.create", model: "fixture/grok-4.6", input: "fixture input", ...fields }));
+  await until(() => target.sent.slice(start).some(frame => frame.type === "error" || frame.type === "response.completed")
+    && !target.ws.data.cancel && !target.ws.data.nativeControl);
+  const frames = target.sent.slice(start);
+  expect(frames.filter(frame => frame.type === "error")).toEqual([]);
+  expect(frames.at(-1)).toMatchObject({ type: "response.completed", response: { status: "completed" } });
+  return frames;
+}
+
+function fillBusyAndReserve(): AdmissionReservation<ServerWebSocket<WsData>> | null {
+  while (codexWebSocketAdmissionMetrics().active < MAX_TRACKED_CODEX_WEBSOCKETS) {
+    finishBusy.push(client().ws.data.responsesActivity!.beginTurn([]));
+  }
+  const lease = tryReserveCodexWebSocket();
+  if (lease) extraLeases.push(lease);
+  expect(codexWebSocketAdmissionMetrics().active).toBe(MAX_TRACKED_CODEX_WEBSOCKETS);
+  return lease;
+}
+
+const hostedCall = { type: "custom_tool_call", id: "ctc_search", call_id: "xs_call-1",
+  name: "x_keyword_search", input: "{}", status: "completed" };
+const clientTool = { type: "function", name: "x_keyword_search", parameters: { type: "object", properties: {} } };
+
+test.each([false, true])("completed xAI hosted search is reclaimable; route-injected declaration=%s", async injected => {
+  const target = client(config(injected ? "https://cli-chat-proxy.grok.com/v1" : "https://api.x.ai/v1", injected));
+  upstream = () => Response.json({ id: "resp_hosted", status: "completed", output: [hostedCall] });
+  const frames = await turn(target, { tools: injected
+    ? [{ type: "web_search", external_web_access: true }]
+    : [{ type: "x_search" }] });
+  expect(outbound).toHaveLength(1);
+  expect(outbound[0].tools.some((tool: Frame) => tool.type === "x_search")).toBe(true);
+  expect(frames.find(frame => frame.type === "response.output_item.done")?.item).toMatchObject(hostedCall);
+  expect(fillBusyAndReserve()).not.toBeNull();
+  expect(target.closed).toEqual([1001]);
+  expect(clients.slice(1).every(other => other.ws.readyState === 1)).toBe(true);
+});
+
+test.each([
+  ["https://api.x.ai/v1", false],
+  ["https://provider.example/v1", true],
+] as const)("declared client custom tool remains protected at %s; x_search declaration=%s", async (baseUrl, declareHosted) => {
+  const target = client(config(baseUrl));
+  upstream = () => Response.json({ id: "resp_client", status: "completed", output: [hostedCall] });
+  const frames = await turn(target, { tools: [clientTool, ...(declareHosted ? [{ type: "x_search" }] : [])] });
+  expect(frames.find(frame => frame.type === "response.output_item.done")?.item).toMatchObject(hostedCall);
+  expect(fillBusyAndReserve()).toBeNull();
+  expect(target.closed).toEqual([]);
+});
+
+function toolStream(id: string, call: Frame, includeCreated: boolean): Response {
+  const frames = [
+    ...(includeCreated ? [{ type: "response.created", response: { id, status: "in_progress", output: [] } }] : []),
+    { type: "response.output_item.done", output_index: 0, item: call },
+    { type: "response.completed", response: { id, status: "completed", output: [call] } },
+  ];
+  return new Response(frames.map(frame => `event: ${frame.type}\ndata: ${JSON.stringify(frame)}\n\n`).join(""),
+    { headers: { "content-type": "text/event-stream" } });
+}
+
+test.each([false, true])("a reused call ID on an ordinary next turn stays protected; response.created=%s", async includeCreated => {
+  const target = client(config("https://provider.example/v1"));
+  const tools = [{ type: "function", name: "fixture_tool", parameters: { type: "object", properties: {} } }];
+  const firstCall = { type: "function_call", id: "fc_first", call_id: "call_0", name: "fixture_tool", arguments: '{"step":1}' };
+  const nextCall = { ...firstCall, id: "fc_next", arguments: '{"step":2}' };
+  upstream = () => toolStream("resp_first", firstCall, true);
+  await turn(target, { tools });
+  expect(target.ws.data.responsesActivity!.idle).toBe(false);
+  upstream = () => toolStream("resp_next", nextCall, includeCreated);
+  const frames = await turn(target, { tools, input: [{ type: "function_call_output", call_id: "call_0", output: "first result" }] });
+  expect(outbound).toHaveLength(2);
+  expect(frames.some(frame => frame.type === "response.created")).toBe(includeCreated);
+  expect(frames.find(frame => frame.type === "response.output_item.done")?.item).toMatchObject(nextCall);
+  expect(fillBusyAndReserve()).toBeNull();
+  expect(target.closed).toEqual([]);
+});
+
+function twoProviderConfig(): OcxConfig {
+  const settings = config();
+  settings.providers.ordinary = config("https://provider.example/v1").providers.fixture!;
+  return settings;
+}
+
+test("switching provider on the same socket does not retain the prior turn's hosted authorization", async () => {
+  const target = client(twoProviderConfig());
+  const hosts: string[] = [];
+  upstream = (_body, url) => {
+    hosts.push(url.host);
+    return Response.json({ id: `resp_switch_${hosts.length}`, status: "completed", output: [hostedCall] });
+  };
+  await turn(target, { tools: [{ type: "x_search" }] });
+  expect(target.ws.data.responsesActivity!.idle).toBe(true);
+  const frames = await turn(target, { model: "ordinary/fixture-model", tools: [clientTool, { type: "x_search" }] });
+  expect(hosts).toEqual(["api.x.ai", "provider.example"]);
+  expect(frames.find(frame => frame.type === "response.output_item.done")?.item).toMatchObject(hostedCall);
+  expect(fillBusyAndReserve()).toBeNull();
+  expect(target.closed).toEqual([]);
+});
+
+test.each([
+  ["darwin", false], ["darwin", true], ["win32", false], ["win32", true],
+] as const)("combo fallback uses the final response's tool ownership; relay=%s hosted final=%s", async (platform, hostedFinal) => {
+  // Exercise the eager Windows relay without changing filesystem/platform identity.
+  setRelayPlatformForTests(platform);
+  const settings = twoProviderConfig();
+  const targets = [{ provider: "fixture", model: "grok-4.6" }, { provider: "ordinary", model: "fixture-model" }];
+  if (hostedFinal) targets.reverse();
+  settings.combos = { ownership: { strategy: "failover", targets } };
+  const target = client(settings);
+  const hosts: string[] = [];
+  upstream = (_body, url) => {
+    hosts.push(url.host);
+    if (hosts.length === 1) {
+      const response = { id: "resp_failed", status: "failed", output: [],
+        error: { type: "server_error", code: "upstream_server_error", message: "fixture first target unavailable" } };
+      return new Response(`data: ${JSON.stringify({ type: "response.failed", response })}\n\n`,
+        { headers: { "content-type": "text/event-stream" } });
+    }
+    return toolStream("resp_fallback", hostedCall, true);
+  };
+  const frames = await turn(target, { model: "combo/ownership", tools: [clientTool, { type: "x_search" }] });
+  expect(hosts).toEqual(hostedFinal ? ["provider.example", "api.x.ai"] : ["api.x.ai", "provider.example"]);
+  expect(outbound).toHaveLength(2);
+  expect(frames.find(frame => frame.type === "response.output_item.done")?.item).toMatchObject(hostedCall);
+  const replacement = fillBusyAndReserve();
+  if (hostedFinal) {
+    expect(replacement).not.toBeNull();
+    expect(target.closed).toEqual([1001]);
+  } else {
+    expect(replacement).toBeNull();
+    expect(target.closed).toEqual([]);
+  }
+});
diff --git a/tests/routing/routing-analytics.test.ts b/tests/routing/routing-analytics.test.ts
index 68e00e77fdb..882f5f49e21 100644
--- a/tests/routing/routing-analytics.test.ts
+++ b/tests/routing/routing-analytics.test.ts
@@ -12,6 +12,7 @@ import {
 } from "../../src/usage/log";
 import { closeRequestHistoryIndex } from "../../src/routing/history/indexer";
 import { computeRoutingAnalytics } from "../../src/routing/analytics";
+import { computeEntryCost } from "../../src/usage/summary";
 import type { OcxConfig } from "../../src/types";
 import { removeTreeWithRetry } from "../helpers/remove-tree";
 
@@ -172,6 +173,24 @@ describe("routing analytics (RI-03)", () => {
     expect(result.priceCoverage).toBe(0);
   });
 
+  test("a refused retry before a measured send is priced, matching /api/usage", async () => {
+    const send = { provider: "openai", model: "gpt-5.5", adapter: "openai-responses", durationMs: 10, sendCount: 1, recoveryKinds: [] };
+    const attempts = [
+      { ...send, ordinal: 1, status: 429, usageStatus: "unreported" as const },
+      { ...send, ordinal: 2, status: 200, usageStatus: "reported" as const, usage: { inputTokens: 100, outputTokens: 10 } },
+    ];
+    const row = entry("r1", {
+      timestamp: 1, status: 200, durationMs: 20, provider: "openai", model: "gpt-5.5",
+      usageStatus: "unreported", usage: { inputTokens: 100, outputTokens: 10 }, attempts,
+    });
+    appendUsageEntry(row);
+
+    const result = await computeRoutingAnalytics({});
+    expect(result.priceCoverage).toBe(1);
+    expect(result.estimatedCostUsdTotalSuccessful).toBe(computeEntryCost(row).costTotal);
+    expect(result.estimatedCostUsdTotalSuccessful).toBeGreaterThan(0);
+  });
+
   test("filters scope the analysis", async () => {
     appendUsageEntry(entry("r1", { timestamp: 1, status: 200, durationMs: 100, provider: "a" }));
     appendUsageEntry(entry("r2", { timestamp: 2, status: 200, durationMs: 100, provider: "b", model: "m2" }));
diff --git a/tests/server/inference-client-encoder-delivery.test.ts b/tests/server/inference-client-encoder-delivery.test.ts
index 0b1c3fd3b7e..0c549364408 100644
--- a/tests/server/inference-client-encoder-delivery.test.ts
+++ b/tests/server/inference-client-encoder-delivery.test.ts
@@ -18,6 +18,7 @@ import type { RequestLogContext, RequestLogEntry } from "../../src/server/reques
 import { markProtocolEntry, protocolTraceForRequest } from "../../src/protocols/trace";
 import { parseRequest } from "../../src/responses/parser";
 import { buildToolBridgeMaps } from "../../src/server/responses";
+import { createAnthropicThinkingRecovery } from "../../src/server/responses/anthropic-thinking-recovery";
 import { deliverAdapterResponse } from "../../src/server/responses/adapter-delivery";
 import { peekReasoningForCall } from "../../src/responses/reasoning-replay-cache";
 import type { AdapterEvent, OcxConfig, OcxReasoningReplayScopeRef, OcxUsage } from "../../src/types";
@@ -287,6 +288,7 @@ describe("deliverAdapterResponse through a client encoder", () => {
       { type: "done" },
     ];
     const completed: Record<string, unknown>[] = [];
+    const upstream = new AbortController();
     const response = await deliverAdapterResponse(
       {
         logCtx: { model: "m", provider: "p" },
@@ -314,7 +316,9 @@ describe("deliverAdapterResponse through a client encoder", () => {
       { emptyCompletionGuardEnabled: false },
       {
         upstreamResponse: new Response(""),
-        upstream: new AbortController(),
+        upstream,
+        thinkingSignatureRecovery: createAnthropicThinkingRecovery(parsed, upstream.signal, { attempted: false }, () => false),
+        refetchThinkingSignature: async () => { throw new Error("unexpected recovery without thinking history"); },
         cleanupUpstreamAbort: () => {},
         localUpstream: false,
       } as unknown as Args[6],
diff --git a/tests/server/loopback-listener-admission.test.ts b/tests/server/loopback-listener-admission.test.ts
index 4f980240ea0..438b79bfe73 100644
--- a/tests/server/loopback-listener-admission.test.ts
+++ b/tests/server/loopback-listener-admission.test.ts
@@ -132,13 +132,13 @@ describe("local client inference wires on the loopback listener (#4236)", () =>
     // It is now served on the loopback listener, so the public config must not be the source
     // of its CORS headers — the same rule the Anthropic routes above already follow.
     const chatStart = source.indexOf('url.pathname === "/v1/chat/completions"');
-    const nextRoute = source.indexOf("url.pathname === \"/v1/live\"", chatStart);
+    const nextRoute = source.indexOf('url.pathname === "/v1/audio/transcriptions"', chatStart);
     expect(chatStart).toBeGreaterThan(-1);
     const branch = source.slice(chatStart, nextRoute);
     // The handler receives the caller-session-promoted request (#6520); CORS still uses req.
     expect(branch).toContain("handleChatCompletions(sessionReq, config, logCtx");
-    expect(branch).toContain("req,\n          policy,\n        )");
-    expect(branch).not.toContain("req,\n          config,\n        )");
+    expect(branch).toMatch(/return withCors\(\s*await handleChatCompletions\([^\n]+\),\s*req,\s*policy,\s*\)/);
+    expect(branch).not.toMatch(/,\s*req,\s*config,\s*\)/);
   });
 });
 
diff --git a/tests/server/server-startup-codex-off.test.ts b/tests/server/server-startup-codex-off.test.ts
new file mode 100644
index 00000000000..699ce9421b5
--- /dev/null
+++ b/tests/server/server-startup-codex-off.test.ts
@@ -0,0 +1,47 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { saveConfig } from "../../src/config";
+import { startServer } from "../../src/server";
+import { installIsolatedCodexHome } from "../helpers/isolated-codex-home";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+test("Codex OFF starts without service-manager probes or native-main preparation", async () => {
+  const priorHome = process.env.OPENCODEX_HOME;
+  const home = mkdtempSync(join(tmpdir(), "ocx-start-codex-off-"));
+  const codex = installIsolatedCodexHome("ocx-start-codex-off-client-");
+  process.env.OPENCODEX_HOME = home;
+  let inspections = 0;
+  let preparations = 0;
+  let server: ReturnType<typeof startServer> | undefined;
+  try {
+    saveConfig({
+      providers: { fixture: { adapter: "openai-chat", baseUrl: "http://127.0.0.1:1/v1", allowPrivateNetwork: true } },
+      defaultProvider: "fixture", port: 0, hostname: "127.0.0.1",
+      clientIntegrations: { codex: false }, checkForUpdates: false,
+      syncResumeHistory: false, claudeCode: { intercept: { enabled: false } },
+    });
+    server = startServer(0, {
+      inspectNativeCodexOwnership: () => {
+        inspections++;
+        return { ownership: "owned", reason: "unused Codex OFF probe" };
+      },
+      nativeMainStartup: {
+        get manager() {
+          preparations++;
+          throw new Error("Codex OFF must not prepare a native manager");
+        },
+      },
+    });
+    expect(inspections).toBe(0);
+    expect(preparations).toBe(0);
+    expect((await fetch(`http://127.0.0.1:${server.port}/healthz`)).status).toBe(200);
+  } finally {
+    await server?.stop(true);
+    codex.restore();
+    if (priorHome === undefined) delete process.env.OPENCODEX_HOME;
+    else process.env.OPENCODEX_HOME = priorHome;
+    removeTreeWithRetry(home);
+  }
+});
diff --git a/tests/usage/usage-partly-measured-cost.test.ts b/tests/usage/usage-partly-measured-cost.test.ts
index 2bafc408a0d..29bb87f49f9 100644
--- a/tests/usage/usage-partly-measured-cost.test.ts
+++ b/tests/usage/usage-partly-measured-cost.test.ts
@@ -1,5 +1,6 @@
 import { expect, test } from "bun:test";
-import { computeEntryCost } from "../../src/usage/summary";
+import { computeEntryCost, summarizeUsage } from "../../src/usage/summary";
+import { aggregateAttemptUsage } from "../../src/server/request-log";
 import type { PersistedUsageEntry } from "../../src/usage/log";
 
 type Attempt = NonNullable<PersistedUsageEntry["attempts"]>[number];
@@ -31,3 +32,73 @@ test("an upstream refusal without usage remains a known zero alongside measured
   expect(result.isPriced).toBe(true);
   expect(result.costTotal).toBeGreaterThan(0);
 });
+
+test("a refused retry and a measured send total the measured cost on the summary", () => {
+  const { usage: _usage, ...withoutUsage } = measured;
+  const attempts: Attempt[] = [{ ...withoutUsage, status: 429, usageStatus: "unreported" }, { ...measured, ordinal: 2 }];
+  // The row request-log writes for a non-combo retry: status and usage aggregate its attempts.
+  const aggregate = aggregateAttemptUsage(attempts);
+  const entry = { ...row(attempts), timestamp: Date.UTC(2026, 5, 28), usageStatus: aggregate.status, usage: aggregate.usage };
+  const { costTotal } = computeEntryCost(entry);
+  expect(summarizeUsage([entry], "30d", Date.UTC(2026, 5, 28, 12)).summary).toMatchObject({
+    requests: 1, pricedRequests: 1, unpricedRequests: 0, unmeteredRequests: 0, estimatedCostUsd: costTotal,
+  });
+});
+
+test("a send the client cancelled before output is an unknown cost, not a known zero", () => {
+  const { usage: _usage, ...withoutUsage } = measured;
+  const attempts: Attempt[] = [measured, { ...withoutUsage, ordinal: 2, status: 499, usageStatus: "unreported" }];
+  const aggregate = aggregateAttemptUsage(attempts);
+  const entry = { ...row(attempts), timestamp: Date.UTC(2026, 5, 28), usageStatus: aggregate.status, usage: aggregate.usage };
+  expect(computeEntryCost(entry).isPriced).toBe(false);
+  const { summary, models } = summarizeUsage([entry], "30d", Date.UTC(2026, 5, 28, 12));
+  expect(summary).toMatchObject({ requests: 1, pricedRequests: 0, unpricedRequests: 1, unmeteredRequests: 0 });
+  expect(models).toEqual([expect.objectContaining({ model: "gpt-5.5", pricedRequests: 0, unpricedRequests: 1 })]);
+});
+
+test("a refusal cannot hide a measured attempt with no matching price", () => {
+  const { usage: _usage, ...withoutUsage } = measured;
+  const attempts: Attempt[] = [
+    { ...withoutUsage, status: 429, usageStatus: "unreported" },
+    { ...measured, ordinal: 2, provider: "unknown-provider", model: "unknown-model" },
+    { ...measured, ordinal: 3 },
+  ];
+  const entryFor = (legs: Attempt[]): PersistedUsageEntry => {
+    const aggregate = aggregateAttemptUsage(legs);
+    return { ...row(legs), timestamp: Date.UTC(2026, 5, 28), usageStatus: aggregate.status, usage: aggregate.usage };
+  };
+  const withRefusal = entryFor(attempts);
+  const withoutRefusal = entryFor(attempts.slice(1));
+  expect(withRefusal.usageStatus).toBe("unreported");
+  expect(withoutRefusal.usageStatus).toBe("reported");
+  const cost = computeEntryCost(withRefusal);
+  const baselineCost = computeEntryCost(withoutRefusal);
+  expect(baselineCost.isPriced).toBe(true);
+  expect(baselineCost.costTotal).toBeGreaterThan(0);
+  expect(cost.attemptEstimates?.map(Boolean)).toEqual([false, false, true]);
+  expect({ ...cost, attemptEstimates: cost.attemptEstimates?.slice(1) }).toEqual(baselineCost);
+  const summarize = (entry: PersistedUsageEntry) => summarizeUsage([entry], "30d", Date.UTC(2026, 5, 28, 12));
+  const actual = summarize(withRefusal);
+  const baseline = summarize(withoutRefusal);
+  const classification = ({ pricedRequests, unpricedRequests, unmeteredRequests, estimatedCostUsd }: typeof actual.summary) =>
+    ({ pricedRequests, unpricedRequests, unmeteredRequests, estimatedCostUsd });
+  expect(classification(baseline.summary)).toEqual({
+    pricedRequests: 1, unpricedRequests: 0, unmeteredRequests: 0, estimatedCostUsd: baselineCost.costTotal,
+  });
+  expect(classification(actual.summary)).toEqual(classification(baseline.summary));
+  // Compare model usage and pricing; the refusal adds an unreported physical attempt.
+  const models = (result: typeof actual) => result.models.map(({ provider, model, requests, inputTokens,
+    outputTokens, totalTokens, pricedRequests, unpricedRequests, priceCoverageRatio, estimatedCostUsd }) =>
+    ({ provider, model, requests, inputTokens, outputTokens, totalTokens,
+      pricedRequests, unpricedRequests, priceCoverageRatio, estimatedCostUsd }))
+    .sort((a, b) => `${a.provider}/${a.model}`.localeCompare(`${b.provider}/${b.model}`));
+  expect(models(actual)).toEqual(models(baseline));
+});
+
+test("a row of known-zero refusals stays unmetered", () => {
+  const { usage: _usage, ...withoutUsage } = measured;
+  const attempts: Attempt[] = [{ ...withoutUsage, status: 429, usageStatus: "unreported" }];
+  const entry = { ...row(attempts), timestamp: Date.UTC(2026, 5, 28) };
+  expect(summarizeUsage([entry], "30d", Date.UTC(2026, 5, 28, 12)).summary)
+    .toMatchObject({ requests: 1, pricedRequests: 0, unpricedRequests: 0, unmeteredRequests: 1 });
+});