diff --git a/AFFINITY.md b/AFFINITY.md
new file mode 100644
index 000000000..eef04e2fb
--- /dev/null
+++ b/AFFINITY.md
@@ -0,0 +1,146 @@
+# Client-carried affinity
+
+Floway can resolve one public model name or alias to several upstream/model
+bindings. Client-carried affinity records which binding produced opaque
+assistant state so a later turn can prefer that binding, or require it when
+the state is not portable.
+
+Affinity is a gateway source membrane, not a protocol or a translation layer.
+Ingress removes Floway metadata before interceptors, translators, and providers
+run. Egress adds it only after events return to the client-facing protocol.
+
+## Envelope and framing
+
+Each API key has a hidden 256-bit `serverSecret` for gateway-private per-key
+data. Normal key CRUD never exposes it; admin export/import preserves it.
+Affinity derives an AES-256-GCM key with HKDF and encrypts:
+
+```ts
+{
+  version: 1,
+  origin?: 'raw' | 'base64' | 'base64url',
+  affinity: {
+    upstreamId: string,
+    modelId: string,
+    rules?: AliasRules,
+    upstreamItemId?: string,
+    syntheticItem?: true,
+    boundItem?: {
+      type: string,
+      upstreamItemId?: string,
+      contentHash: string,
+    },
+  },
+}
+```
+
+Routing strength is not serialized. Ingress derives `prefer` or `force` from
+the carrier's current protocol location.
+
+The carrier has no delimiter or magic prefix:
+
+```text
+original bytes || IV[12] || ciphertext+tag || encryptedLength:u16be
+```
+
+The original bytes and a length-delimited protocol/slot domain are additional
+authenticated data. Canonical Base64 and unpadded canonical Base64URL values
+are decoded before the encrypted trailer is appended, so existing data is not
+Base64-encoded twice. Other strings are stored as UTF-16 code units, preserving
+even lone surrogates exactly. A synthetic carrier has no `origin` and no
+original bytes.
+
+Authentication failure, an invalid frame, an unknown envelope, or another
+key's carrier is foreign. Foreign values pass through byte-for-byte and add no
+routing evidence, which allows nested Floway deployments to unwrap their own
+layers independently.
+
+## Ingress and routing
+
+Ingress authenticates all recognized opaque fields and builds a request-local
+candidate payload factory. Each attempt receives a fresh source payload:
+
+- ordinary/discardable blobs restore only for exact upstream, model, and
+  optional alias rules;
+- force-state blobs restore for any candidate with the required upstream and
+  model, regardless of alias rules;
+- incompatible owned blobs and authenticated synthetic elements are removed;
+- foreign blobs remain unchanged.
+
+Every owned carrier also adds an exact-rules preference. The latest preferred
+target that remains available moves first. Responses compaction and
+program/program-output state additionally force upstream and model. Force
+never narrows alias rules; an exact preferred rule variant still wins when it
+is available.
+
+Responses expands `previous_response_id` and hydrates complete stored items
+before affinity ingress. Persistence contains no separate routing record.
+
+## Egress layers
+
+Egress performs two independent operations:
+
+1. wrap every natural opaque/signature value with restoration metadata;
+2. ensure the first logical assistant element has a carrier when no natural
+   value provides one.
+
+Chat Completions, Messages, and Responses do not buffer visible deltas for
+affinity. Gemini deliberately delays one complete upstream event; the window
+never grows beyond that event.
+
+### Chat Completions
+
+One choice is one logical element. `reasoning_opaque` is last-write-wins per
+choice. Visible deltas pass through; Floway emits one wrapped natural or
+synthetic opaque snapshot immediately before `finish_reason`, or immediately
+before `[DONE]` when the upstream omits a finish reason.
+
+### Messages
+
+`signature_delta` is last-write-wins. Thinking text passes through and the
+wrapped signature is emitted immediately before `content_block_stop`.
+`redacted_thinking.data` is wrapped at block start. If the first block cannot
+carry a blob, Floway inserts a `redacted_thinking` prefix at index zero and
+shifts every original block index by one.
+
+### Gemini
+
+Gemini buffers at most one upstream event. Signature snapshots for each
+same-event logical element are reduced to the latest value and placed on that
+element's first content-bearing Part. Across events, a late signature can move
+back only onto the immediately preceding buffered chunk. Empty text and
+`thought` metadata alone do not make a Part content-bearing. Immediate
+signature-only prefixes/trailers are moved onto adjacent content when the
+one-event window can determine ownership.
+
+This adds one upstream event of latency. It deliberately favors direct Google
+GenAI Chat compatibility and cannot repair a first-wins client when a natural
+function signature arrives more than one continuation after the first chunk.
+The evidence and exact client tradeoffs are recorded beside the
+[Gemini affinity egress state machine](./packages/gateway/src/data-plane/chat/gemini/affinity/egress.ts).
+
+### Responses
+
+Natural carriers include top-level `encrypted_content`, program `fingerprint`,
+and `agent_message.content[].encrypted_content`. A carrier-capable first item
+without a natural value receives one at `output_item.done`; a program without
+a natural fingerprint receives a synthetic fingerprint in the same slot.
+
+Other first items and `program_output` items receive an adjacent reasoning
+prefix. Its `output_item.added` event is emitted immediately
+without buffering the bound item's visible stream. Its encrypted
+`output_item.done` is emitted immediately before the bound item's done event,
+using the final upstream ID and a canonical SHA-256 content hash that excludes
+the replaceable item ID. The hash also applies Codex's output-to-history
+projection: message/function-call `status` and empty output-text `annotations`
+or `logprobs` are omitted. Terminal output contains the same completed prefix.
+Output indexes and sequence numbers include each inserted lifecycle event.
+
+On replay, the authenticated type and content hash must match the adjacent
+item. A mismatch is a client input error. Preferred bindings restore IDs only
+for exact optional rules; force-item bindings restore across rule variants on
+the same upstream/model. Stored server-private payloads are re-keyed to the
+restored wire ID before Responses interceptors run.
+
+Failed/error streams do not invent a missing final carrier. A prefix already
+opened before an eventual failure cannot be retracted.
diff --git a/AGENTS.md b/AGENTS.md
index 655aa2bfa..f6c7c320d 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -188,6 +188,15 @@ use declared subpath exports. Tests are co-located as `*_test.ts`; each
 package has its own `vitest.config.ts`, and the root config aggregates them
 through `test.projects`.
 
+Client-carried affinity is a source-protocol membrane. Shared codec, routing,
+and request context live under `data-plane/chat/shared/affinity`; each source
+protocol owns its `affinity/ingress.ts` and `affinity/egress.ts`. Wire behavior
+lives in `AFFINITY.md`, and candidate ordering lives in `RESOLUTION.md`.
+
+Native Responses persistence is independent from affinity. It stores complete
+API-key-scoped items and snapshots for 30 days; HTTP `store: false` writes no
+state, while WebSocket `store: false` is session-local.
+
 Everything else — provider interfaces, request execution flow, interceptor
 shapes, translation pair layout, control-plane route surface, flag
 resolution, pricing — lives in the code and its comments. Read the relevant
diff --git a/README.md b/README.md
index e54d4829b..21b50afd5 100644
--- a/README.md
+++ b/README.md
@@ -137,9 +137,8 @@ Open the deployed URL (or `http://localhost:8788` for Node), log in with
    official Codex account login remains available for account-backed services.
 
 Import/export of upstreams, keys, and search config is in Settings. The
-payload format is tied to the running deployment, so import only accepts a
-file produced by a deployment at the same version — re-export from the
-current deployment before importing.
+current payload format is version 11 and is tied to the running deployment, so
+import only accepts that exact version. Re-export before moving a deployment.
 
 ## Server Tools
 
@@ -164,15 +163,21 @@ then both surfaces use that provider's alpha-search endpoint, while Messages
 search continues using the general provider. Passthrough failures are returned
 without falling back to another search backend.
 
+## Client-carried Affinity
+
+Chat-shaped APIs carry encrypted per-key routing affinity inside their native
+opaque reasoning/signature fields. Requests using this feature must continue
+through the same Floway deployment and API key. See [AFFINITY.md](./AFFINITY.md)
+for protocol placement and compatibility details.
+
 ## Stateful Responses
 
 `/v1/responses` stores replayable Responses input and output items for API-key
 scoped HTTP requests. Clients can send `previous_response_id` to continue from
 a stored snapshot, or resend full input history; repeated full-history input is
-deduplicated by content hash instead of stored again. HTTP `store: false` does
-not create durable snapshots or input payload rows, but it keeps output item
-metadata for routing; if a later `store: true` request echoes that item with a
-full payload, the metadata row is filled in place.
+deduplicated by content hash instead of stored again. Complete items and
+snapshots expire 30 days after their latest snapshot reference. HTTP
+`store: false` writes no state; affinity is carried independently by the client.
 
 The same endpoint accepts `GET` WebSocket upgrades for streaming Responses
 events. WebSocket `store: false` keeps replay state only inside the open
diff --git a/RESOLUTION.md b/RESOLUTION.md
index fc87164dd..a8ce5bfb4 100644
--- a/RESOLUTION.md
+++ b/RESOLUTION.md
@@ -394,15 +394,13 @@ Candidates are ordered before they reach dispatch:
 - Within a single upstream, the unprefixed branch precedes the prefixed
   one when both apply.
 
-For Responses-shape inbound, the affinity walk
-(`classifyResponsesItemAffinity`) adjusts the ordering by stored-item
-affinity before dispatch sees it. It resolves stored ids from metadata,
-rejects an `item_reference` whose durable payload is unavailable, and uses
-the referenced row's actual item type to determine upstream affinity. The
-candidate rewrite then bulk-loads the payloads it needs and replaces every
-`item_reference` with the stored item before the upstream request is built.
-The affinity walk never invents new candidates; it only narrows or re-orders
-the list the resolver produced.
+Chat-shaped ingress authenticates client-carried affinity before dispatch.
+Ordinary carriers prefer the latest available candidate with the same upstream,
+model, and optional alias rules. Non-portable state forces the recorded
+upstream and model but never forces alias rules; an exact-rule preferred variant
+still wins when available. Affinity only reorders or narrows candidates already
+produced by resolution. Protocol placement and restoration are documented in
+[AFFINITY.md](./AFFINITY.md).
 
 Serve dispatches the first candidate of the ordered list exactly once.
 The attempt's non-throwing result — an SSE-stream event handoff (chat) or
@@ -428,3 +426,5 @@ internal-debug failure — is the request's final answer; an upstream
   retain both candidate paths instead of deduping. The unprefixed
   candidate precedes the prefix-stripped one in the ordered list, so it
   is the one dispatched.
+- A missing preferred affinity target falls back normally. A missing forced
+  upstream/model target is an explicit error.
diff --git a/TRANSLATION.md b/TRANSLATION.md
index 283b66a69..3185129de 100644
--- a/TRANSLATION.md
+++ b/TRANSLATION.md
@@ -758,7 +758,9 @@ historical custom tool call items unchanged.
   order when later visible output arrives before earlier reasoning/tool output
   is complete.
 - Chat -> Messages stream translation keeps opaque-only reasoning in source
-  order and flushes pending final usage before `message_stop`.
+  order and flushes pending final usage before `message_stop`. Chat
+  `reasoning_opaque` and Messages `signature_delta` values are replacement
+  snapshots, not string fragments to concatenate.
 - Tool/function argument streams guard against infinite whitespace in generated
   arguments and emit an error rather than continuing a degenerate stream.
 
@@ -773,6 +775,9 @@ historical custom tool call items unchanged.
 - Messages <-> Chat may still carry Anthropic opaque thinking through Chat
   `reasoning_opaque`, because that is a Messages/Chat compatibility surface and
   not a Responses encrypted-reasoning bridge.
+- Floway affinity and native Responses persistence remain outside pure
+  translators; their source-boundary behavior is documented in
+  [AFFINITY.md](./AFFINITY.md).
 
 ## Standard OpenAI Field Policy
 
diff --git a/apps/platform-node/src/migrate_test.ts b/apps/platform-node/src/migrate_test.ts
index b3ef99c57..5e61a6ae8 100644
--- a/apps/platform-node/src/migrate_test.ts
+++ b/apps/platform-node/src/migrate_test.ts
@@ -32,6 +32,7 @@ test('applies all real migration files against a fresh sqlite', () => withTemp(a
   const colNames = apiKeyCols.results.map(r => r.name).toSorted();
   assertEquals(colNames.includes('id'), true);
   assertEquals(colNames.includes('key'), true);
+  assertEquals(colNames.includes('server_secret'), true);
 
   // Every migration was recorded.
   const recorded = await db.prepare('SELECT COUNT(*) AS n FROM _migrations').first<{ n: number }>();
diff --git a/apps/web/src/components/settings/ExportSection.vue b/apps/web/src/components/settings/ExportSection.vue
index 748110a48..b2d8a1583 100644
--- a/apps/web/src/components/settings/ExportSection.vue
+++ b/apps/web/src/components/settings/ExportSection.vue
@@ -47,7 +47,7 @@ const exportData = async () => {
 <template>
   <div :class="framed && 'glass-card p-5 sm:p-6 animate-in delay-2'">
     <h3 class="text-white font-semibold mb-1">Export Data</h3>
-    <p class="text-sm text-gray-400 mb-4">Download API keys, upstreams, proxies, web search config, and usage data as a JSON file.</p>
+    <p class="text-sm text-gray-400 mb-4">Download API keys, server secrets, upstreams, proxies, web search config, and usage data as a JSON file. Treat the file like a database backup.</p>
     <label class="mb-4 flex items-start gap-3 rounded-md border border-white/5 bg-surface-800/50 p-3">
       <Checkbox v-model="exportIncludePerformance" class="mt-0.5" />
       <span>
diff --git a/apps/web/src/components/settings/ImportSection.vue b/apps/web/src/components/settings/ImportSection.vue
index 661630a16..8733f929a 100644
--- a/apps/web/src/components/settings/ImportSection.vue
+++ b/apps/web/src/components/settings/ImportSection.vue
@@ -20,7 +20,7 @@ interface ExportPayload {
 
 // The dashboard only round-trips the current export format. Older exports are
 // rejected rather than silently coerced.
-const EXPORT_VERSION = 10 as const;
+const EXPORT_VERSION = 11 as const;
 
 const api = useApi();
 
diff --git a/packages/gateway/migrations/0057_api_key_server_secret.sql b/packages/gateway/migrations/0057_api_key_server_secret.sql
new file mode 100644
index 000000000..93a2009bd
--- /dev/null
+++ b/packages/gateway/migrations/0057_api_key_server_secret.sql
@@ -0,0 +1,44 @@
+CREATE TABLE api_keys_new (
+  id TEXT PRIMARY KEY,
+  user_id INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  key TEXT NOT NULL UNIQUE,
+  created_at TEXT NOT NULL,
+  last_used_at TEXT,
+  upstream_ids TEXT,
+  deleted_at TEXT,
+  dump_retention_seconds INTEGER,
+  server_secret TEXT NOT NULL
+    CHECK (length(server_secret) = 64 AND server_secret NOT GLOB '*[^0-9a-f]*')
+);
+
+INSERT INTO api_keys_new (
+  id,
+  user_id,
+  name,
+  key,
+  created_at,
+  last_used_at,
+  upstream_ids,
+  deleted_at,
+  dump_retention_seconds,
+  server_secret
+)
+SELECT
+  id,
+  user_id,
+  name,
+  key,
+  created_at,
+  last_used_at,
+  upstream_ids,
+  deleted_at,
+  dump_retention_seconds,
+  lower(hex(randomblob(32)))
+FROM api_keys;
+
+DROP TABLE api_keys;
+ALTER TABLE api_keys_new RENAME TO api_keys;
+
+CREATE INDEX idx_api_keys_user ON api_keys(user_id) WHERE deleted_at IS NULL;
+CREATE UNIQUE INDEX idx_api_keys_server_secret ON api_keys(server_secret);
diff --git a/packages/gateway/migrations/0058_responses_full_state.sql b/packages/gateway/migrations/0058_responses_full_state.sql
new file mode 100644
index 000000000..b1d450782
--- /dev/null
+++ b/packages/gateway/migrations/0058_responses_full_state.sql
@@ -0,0 +1,101 @@
+-- Pre-0058 rows keep their complete payload and fully backed snapshot graph,
+-- but their upstream_id/upstream_item_id affinity cannot be converted into the
+-- new client-carried envelope: the old schema never stored canonical model or
+-- alias rules, and SQL cannot perform the per-key AEAD transform. Preserved
+-- history therefore resumes through normal routing with no legacy affinity.
+CREATE TABLE responses_items_new (
+  id TEXT NOT NULL,
+  api_key_id TEXT NOT NULL,
+  item_type TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  content_hash TEXT,
+  created_at INTEGER NOT NULL,
+  CHECK (length(id) > 0),
+  CHECK (length(api_key_id) > 0),
+  CHECK (length(item_type) > 0),
+  CHECK (length(payload_json) > 0),
+  CHECK (content_hash IS NULL OR length(content_hash) > 0)
+);
+
+INSERT INTO responses_items_new (
+  id,
+  api_key_id,
+  item_type,
+  payload_json,
+  content_hash,
+  created_at
+)
+SELECT
+  id,
+  api_key_id,
+  CASE WHEN item_type = 'compaction_summary' THEN 'compaction' ELSE item_type END,
+  payload_json,
+  content_hash,
+  CASE
+    -- SQL cannot move an existing spilled payload into a later expiry bucket.
+    -- Keep its original file-backed horizon; inline rows can retain the latest
+    -- reference time directly.
+    WHEN json_extract(payload_json, '$.storage') = 'file' THEN created_at
+    ELSE MAX(created_at, refreshed_at)
+  END
+FROM responses_items
+WHERE api_key_id IS NOT NULL
+  AND length(api_key_id) > 0
+  AND payload_json IS NOT NULL
+  AND length(payload_json) > 0;
+
+CREATE TABLE responses_snapshots_new (
+  id TEXT NOT NULL,
+  api_key_id TEXT NOT NULL,
+  item_ids_json TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  CHECK (length(id) > 0),
+  CHECK (length(api_key_id) > 0),
+  CHECK (length(item_ids_json) > 0)
+);
+
+INSERT INTO responses_snapshots_new (
+  id,
+  api_key_id,
+  item_ids_json,
+  created_at
+)
+SELECT
+  snapshot.id,
+  snapshot.api_key_id,
+  snapshot.item_ids_json,
+  MIN(
+    MAX(snapshot.created_at, snapshot.refreshed_at),
+    (
+      SELECT MIN(item.created_at)
+      FROM json_each(CASE WHEN json_valid(snapshot.item_ids_json) THEN snapshot.item_ids_json ELSE '[]' END) AS ref
+      JOIN responses_items_new AS item
+        ON item.api_key_id = snapshot.api_key_id
+        AND item.id = ref.value
+    )
+  )
+FROM responses_snapshots AS snapshot
+WHERE snapshot.api_key_id IS NOT NULL
+  AND length(snapshot.api_key_id) > 0
+  AND json_valid(snapshot.item_ids_json)
+  AND json_type(CASE WHEN json_valid(snapshot.item_ids_json) THEN snapshot.item_ids_json ELSE 'null' END) = 'array'
+  AND json_array_length(CASE WHEN json_valid(snapshot.item_ids_json) THEN snapshot.item_ids_json ELSE '[]' END) > 0
+  AND NOT EXISTS (
+    SELECT 1
+    FROM json_each(CASE WHEN json_valid(snapshot.item_ids_json) THEN snapshot.item_ids_json ELSE '[]' END) AS ref
+    LEFT JOIN responses_items_new AS item
+      ON item.api_key_id = snapshot.api_key_id
+      AND item.id = ref.value
+    WHERE ref.type <> 'text' OR item.id IS NULL
+  );
+
+DROP TABLE responses_snapshots;
+DROP TABLE responses_items;
+ALTER TABLE responses_items_new RENAME TO responses_items;
+ALTER TABLE responses_snapshots_new RENAME TO responses_snapshots;
+
+CREATE UNIQUE INDEX idx_responses_items_id_scope ON responses_items (id, api_key_id);
+CREATE INDEX idx_responses_items_content_hash ON responses_items (api_key_id, content_hash);
+CREATE INDEX idx_responses_items_created_at ON responses_items (created_at);
+CREATE UNIQUE INDEX idx_responses_snapshots_id_scope ON responses_snapshots (id, api_key_id);
+CREATE INDEX idx_responses_snapshots_created_at ON responses_snapshots (created_at);
diff --git a/packages/gateway/src/app-control_test.ts b/packages/gateway/src/app-control_test.ts
index 3479275b2..532a1c124 100644
--- a/packages/gateway/src/app-control_test.ts
+++ b/packages/gateway/src/app-control_test.ts
@@ -50,6 +50,7 @@ test('API key users only see their own key in /api/keys', async () => {
     userId: 1,
     name: 'Other key',
     key: 'raw_other_key',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-03-15T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
@@ -99,6 +100,7 @@ test('/api/token-usage scopes to the actor\'s keys when called with an API key',
     userId: 1,
     name: 'Other key',
     key: 'raw_other_key',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-03-15T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
@@ -149,6 +151,7 @@ test('/api/token-usage in self-by-key mode includes per-key metadata for the act
     userId: apiKey.userId,
     name: 'Actor secondary',
     key: 'raw_actor_secondary',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-03-16T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
diff --git a/packages/gateway/src/control-plane/api-keys/routes.ts b/packages/gateway/src/control-plane/api-keys/routes.ts
index 88c716ced..99ae13bb7 100644
--- a/packages/gateway/src/control-plane/api-keys/routes.ts
+++ b/packages/gateway/src/control-plane/api-keys/routes.ts
@@ -4,6 +4,7 @@ import { type CtxWithJson } from '../../middleware/zod-validator.ts';
 import { getRepo } from '../../repo/index.ts';
 import type { ApiKey } from '../../repo/types.ts';
 import { CUSTOM_API_KEY_MAX_LENGTH, generateApiKeyToken, type KeySource } from '../../shared/api-key-tokens.ts';
+import { generateServerSecret } from '../../shared/server-secret.ts';
 import type { createKeyBody, rotateKeyBody, updateKeyBody } from '../schemas.ts';
 import { ownedKeyOr404 } from '../shared/owned-key.ts';
 
@@ -34,6 +35,9 @@ const normalizeCustomKey = (value: unknown): string | Response => {
 const duplicateKeyResponse = () =>
   Response.json({ error: 'An API key with that raw key already exists.' }, { status: 409 });
 
+const isRawKeyUniqueConstraint = (error: unknown): boolean =>
+  /UNIQUE constraint failed: api_keys\.key(?:\b|$)/i.test(error instanceof Error ? error.message : String(error));
+
 const findAnyByRawKey = async (rawKey: string): Promise<ApiKey | null> =>
   (await getRepo().apiKeys.listIncludingDeleted()).find(key => key.key === rawKey) ?? null;
 
@@ -45,8 +49,7 @@ const saveGeneratedKey = async (template: Omit<ApiKey, 'key'>): Promise<ApiKey |
       await getRepo().apiKeys.save(key);
       return key;
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.toLowerCase().includes('unique') || message.toLowerCase().includes('constraint')) continue;
+      if (isRawKeyUniqueConstraint(error)) continue;
       throw error;
     }
   }
@@ -61,8 +64,7 @@ const saveCustomKey = async (template: Omit<ApiKey, 'key'>, rawKey: string): Pro
     await getRepo().apiKeys.save(key);
     return key;
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.toLowerCase().includes('unique') || message.toLowerCase().includes('constraint')) return duplicateKeyResponse();
+    if (isRawKeyUniqueConstraint(error)) return duplicateKeyResponse();
     throw error;
   }
 };
@@ -121,6 +123,7 @@ export const createKey = async (c: CtxWithJson<typeof createKeyBody>) => {
     id: crypto.randomUUID(),
     userId,
     name: body.name,
+    serverSecret: generateServerSecret(),
     createdAt: new Date().toISOString(),
     upstreamIds: body.upstream_ids ?? null,
     deletedAt: null,
diff --git a/packages/gateway/src/control-plane/api-keys/routes_test.ts b/packages/gateway/src/control-plane/api-keys/routes_test.ts
index 300959f53..3b7842ad8 100644
--- a/packages/gateway/src/control-plane/api-keys/routes_test.ts
+++ b/packages/gateway/src/control-plane/api-keys/routes_test.ts
@@ -1,4 +1,4 @@
-import { test } from 'vitest';
+import { test, vi } from 'vitest';
 
 import { initDumpBroker, initDumpStore } from '../../dump/registry.ts';
 import { installDumpStubs } from '../../dump/test-fixtures.ts';
@@ -12,6 +12,16 @@ const ownerPatch = (id: string, body: unknown, rawKey: string) =>
     body: JSON.stringify(body),
   });
 
+test('GET /api/keys never exposes the server-side server secret', async () => {
+  const { apiKey } = await setupAppTest();
+  const response = await requestApp('/api/keys', { headers: { 'x-api-key': apiKey.key } });
+  assertEquals(response.status, 200);
+  const body = (await response.json()) as Array<Record<string, unknown>>;
+  assertEquals(body.length, 1);
+  assertEquals(Object.hasOwn(body[0]!, 'serverSecret'), false);
+  assertEquals(Object.hasOwn(body[0]!, 'server_secret'), false);
+});
+
 test('PATCH /api/keys/:id accepts a custom upstream whitelist + order', async () => {
   const { repo, apiKey } = await setupAppTest();
   await repo.upstreams.save(buildCustomUpstreamRecord({ id: 'up_x', name: 'X' }));
@@ -133,12 +143,15 @@ test('POST /api/keys creates a key under the actor with optional upstream_ids',
     body: JSON.stringify({ name: 'side-key', upstream_ids: ['up_x'] }),
   });
   assertEquals(response.status, 201);
-  const body = (await response.json()) as { id: string; key: string; upstream_ids: string[] | null };
+  const body = (await response.json()) as { id: string; key: string; upstream_ids: string[] | null } & Record<string, unknown>;
   assertEquals(/^sk-[A-Za-z0-9]{20}T3BlbkFJ[A-Za-z0-9]{20}$/.test(body.key), true);
   assertEquals(body.upstream_ids, ['up_x']);
+  assertEquals(Object.hasOwn(body, 'serverSecret'), false);
+  assertEquals(Object.hasOwn(body, 'server_secret'), false);
   const stored = await repo.apiKeys.getById(body.id);
   assertExists(stored);
   assertEquals(stored.userId, apiKey.userId);
+  assertEquals(/^[0-9a-f]{64}$/.test(stored.serverSecret), true);
 });
 
 test('POST /api/keys mints a generated key when key_source is generate', async () => {
@@ -180,6 +193,43 @@ test('POST /api/keys stores a custom key verbatim and rejects duplicates', async
   assertEquals(duplicate.status, 409);
 });
 
+test.each([
+  'UNIQUE constraint failed: api_keys.server_secret',
+  'CHECK constraint failed: length(server_secret) = 64',
+])('POST /api/keys exposes non-key database constraints: %s', async message => {
+  const { repo, apiKey } = await setupAppTest();
+  const save = vi.spyOn(repo.apiKeys, 'save').mockRejectedValue(new Error(message));
+  try {
+    const response = await requestApp('/api/keys', {
+      method: 'POST',
+      headers: { 'x-api-key': apiKey.key, 'content-type': 'application/json' },
+      body: JSON.stringify({ name: 'constraint-test', key_source: 'custom', custom_key: 'custom-value' }),
+    });
+    assertEquals(response.status, 500);
+    if (!(await response.text()).includes(message)) throw new Error(`expected response to expose ${message}`);
+  } finally {
+    save.mockRestore();
+  }
+});
+
+test('POST /api/keys does not retry a generated key after a server-secret constraint', async () => {
+  const { repo, apiKey } = await setupAppTest();
+  const message = 'UNIQUE constraint failed: api_keys.server_secret';
+  const save = vi.spyOn(repo.apiKeys, 'save').mockRejectedValue(new Error(message));
+  try {
+    const response = await requestApp('/api/keys', {
+      method: 'POST',
+      headers: { 'x-api-key': apiKey.key, 'content-type': 'application/json' },
+      body: JSON.stringify({ name: 'constraint-test', key_source: 'generate' }),
+    });
+    assertEquals(response.status, 500);
+    assertEquals(save.mock.calls.length, 1);
+    if (!(await response.text()).includes(message)) throw new Error(`expected response to expose ${message}`);
+  } finally {
+    save.mockRestore();
+  }
+});
+
 test('POST /api/keys rejects malformed custom key requests', async () => {
   const { apiKey } = await setupAppTest();
   const missing = await requestApp('/api/keys', {
@@ -205,15 +255,18 @@ test('POST /api/keys rejects malformed custom key requests', async () => {
 });
 
 test('POST /api/keys/:id/rotate mints a generated key by default', async () => {
-  const { apiKey } = await setupAppTest();
+  const { apiKey, repo } = await setupAppTest();
   const response = await requestApp(`/api/keys/${apiKey.id}/rotate`, {
     method: 'POST',
     headers: { 'x-api-key': apiKey.key, 'content-type': 'application/json' },
     body: JSON.stringify({}),
   });
   assertEquals(response.status, 200);
-  const body = (await response.json()) as { key: string };
+  const body = (await response.json()) as { key: string } & Record<string, unknown>;
   assertEquals(/^sk-[A-Za-z0-9]{20}T3BlbkFJ[A-Za-z0-9]{20}$/.test(body.key), true);
+  assertEquals(Object.hasOwn(body, 'serverSecret'), false);
+  assertEquals(Object.hasOwn(body, 'server_secret'), false);
+  assertEquals((await repo.apiKeys.getById(apiKey.id))?.serverSecret, apiKey.serverSecret);
 });
 
 test('POST /api/keys/:id/rotate accepts a caller-provided key when key_source is custom', async () => {
diff --git a/packages/gateway/src/control-plane/data-transfer/routes.ts b/packages/gateway/src/control-plane/data-transfer/routes.ts
index cfd76e7b4..6ca4492f1 100644
--- a/packages/gateway/src/control-plane/data-transfer/routes.ts
+++ b/packages/gateway/src/control-plane/data-transfer/routes.ts
@@ -3,10 +3,9 @@
 // Ephemeral stored Responses state is omitted from exports and cleared on
 // replace imports; clients can regenerate it through normal Responses use.
 //
-// The export contains every credential the gateway holds — provider API keys,
-// GitHub tokens, Codex refresh tokens, and proxy URIs that embed passwords /
-// UUIDs / PSKs. The endpoint is admin-only via x-api-key; operators are
-// responsible for handling the dumped file with the same care as a DB backup.
+// The export contains the listed persisted credentials: API-key server
+// secrets, provider keys/tokens, and credential-bearing proxy URIs. The
+// endpoint is admin-only; handle the file with the same care as a DB backup.
 
 import type { Context } from 'hono';
 
@@ -24,6 +23,7 @@ import type { ApiKey, PerformanceBucketRow, PerformanceMetric, PerformanceTeleme
 import { backgroundSchedulerFromContext } from '../../runtime/background.ts';
 import { getRuntimeLocation } from '../../runtime/runtime-info.ts';
 import { PASSWORD_HASH_SCHEME } from '../../shared/passwords.ts';
+import { parseServerSecret } from '../../shared/server-secret.ts';
 import { isWebSearchProviderName } from '../../shared/web-search-providers.ts';
 import { parseUpstreamIdsValue } from '../api-keys/upstream-ids.ts';
 import { USERNAME_PATTERN, type exportQuery, type importBody, DUMP_RETENTION_MAX_SECONDS } from '../schemas.ts';
@@ -48,12 +48,25 @@ interface SerializedProxy {
   dial_timeout_seconds: number | null;
 }
 
+interface SerializedApiKey {
+  id: string;
+  userId: number;
+  name: string;
+  key: string;
+  serverSecret: string;
+  createdAt: string;
+  lastUsedAt?: string;
+  upstreamIds: string[] | null;
+  deletedAt: string | null;
+  dumpRetentionSeconds: number | null;
+}
+
 interface ExportPayload {
-  version: 10;
+  version: 11;
   exportedAt: string;
   data: {
     users: User[];
-    apiKeys: ApiKey[];
+    apiKeys: SerializedApiKey[];
     upstreams: SerializedUpstreamRecord[];
     proxies: SerializedProxy[];
     usage: UsageRecord[];
@@ -64,7 +77,7 @@ interface ExportPayload {
   };
 }
 
-const EXPORT_VERSION = 10;
+const EXPORT_VERSION = 11;
 const SEARCH_USAGE_HOUR_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}$/;
 const PERFORMANCE_METRICS = new Set<PerformanceMetric>(['ttft_ms', 'tpot_us']);
 const UPSTREAM_PROVIDERS = new Set<UpstreamProviderKind>(ALL_PROVIDER_KINDS);
@@ -284,6 +297,7 @@ const parseApiKeyRecords = (value: unknown): { type: 'ok'; records: ApiKey[] } |
         userId: record.userId,
         name: nonEmptyString(record.name, 'name'),
         key: nonEmptyString(record.key, 'key'),
+        serverSecret: parseServerSecret(record.serverSecret),
         createdAt: nonEmptyString(record.createdAt, 'createdAt'),
         ...(record.lastUsedAt !== undefined ? { lastUsedAt: nonEmptyString(record.lastUsedAt, 'lastUsedAt') } : {}),
         upstreamIds: upstreamIdsParsed.value,
@@ -350,6 +364,7 @@ const parseUserRecords = (value: unknown): { type: 'ok'; records: User[] } | { t
 const validateApiKeyIdentities = (records: readonly ApiKey[], existing: readonly ApiKey[], mode: 'merge' | 'replace'): string | null => {
   const ids = new Map<string, number>();
   const rawKeys = new Map<string, string>();
+  const serverSecrets = new Map<string, string>();
 
   for (let i = 0; i < records.length; i++) {
     const record = records[i];
@@ -360,15 +375,24 @@ const validateApiKeyIdentities = (records: readonly ApiKey[], existing: readonly
     const existingRawKeyId = rawKeys.get(record.key);
     if (existingRawKeyId !== undefined) return `duplicate apiKeys raw key used by ${existingRawKeyId} and ${record.id}`;
     rawKeys.set(record.key, record.id);
+
+    const existingServerSecretId = serverSecrets.get(record.serverSecret);
+    if (existingServerSecretId !== undefined) return `duplicate apiKeys server secret used by ${existingServerSecretId} and ${record.id}`;
+    serverSecrets.set(record.serverSecret, record.id);
   }
 
   if (mode === 'merge') {
     const existingRawKeys = new Map(existing.map(record => [record.key, record.id]));
+    const existingServerSecrets = new Map(existing.map(record => [record.serverSecret, record.id]));
     for (const record of records) {
       const existingId = existingRawKeys.get(record.key);
       if (existingId !== undefined && existingId !== record.id) {
         return `apiKeys raw key for ${record.id} conflicts with existing api key ${existingId}`;
       }
+      const existingServerSecretId = existingServerSecrets.get(record.serverSecret);
+      if (existingServerSecretId !== undefined && existingServerSecretId !== record.id) {
+        return `apiKeys server secret for ${record.id} conflicts with existing api key ${existingServerSecretId}`;
+      }
     }
   }
 
@@ -676,7 +700,18 @@ export const exportData = async (c: CtxWithQuery<typeof exportQuery>) => {
     exportedAt: new Date().toISOString(),
     data: {
       users,
-      apiKeys,
+      apiKeys: apiKeys.map(key => ({
+        id: key.id,
+        userId: key.userId,
+        name: key.name,
+        key: key.key,
+        serverSecret: key.serverSecret,
+        createdAt: key.createdAt,
+        ...(key.lastUsedAt !== undefined ? { lastUsedAt: key.lastUsedAt } : {}),
+        upstreamIds: key.upstreamIds,
+        deletedAt: key.deletedAt,
+        dumpRetentionSeconds: key.dumpRetentionSeconds,
+      } satisfies SerializedApiKey)),
       upstreams: upstreams.map(upstreamRecordToFullJson),
       proxies: proxies.map(p => ({ id: p.id, name: p.name, url: p.url, dial_timeout_seconds: p.dialTimeoutSeconds })),
       usage,
diff --git a/packages/gateway/src/control-plane/data-transfer/routes_test.ts b/packages/gateway/src/control-plane/data-transfer/routes_test.ts
index 2aab55dbb..2af19c107 100644
--- a/packages/gateway/src/control-plane/data-transfer/routes_test.ts
+++ b/packages/gateway/src/control-plane/data-transfer/routes_test.ts
@@ -31,6 +31,7 @@ const KEY_A: ApiKey = {
   userId: 1,
   name: 'Alice',
   key: 'raw-a',
+  serverSecret: '11'.repeat(32),
   createdAt: '2026-01-01T00:00:00.000Z',
   lastUsedAt: '2026-01-02T00:00:00.000Z',
   upstreamIds: null,
@@ -43,6 +44,7 @@ const KEY_B: ApiKey = {
   userId: 1,
   name: 'Bob',
   key: 'raw-b',
+  serverSecret: '22'.repeat(32),
   createdAt: '2026-02-01T00:00:00.000Z',
   upstreamIds: null,
   deletedAt: null,
@@ -227,15 +229,10 @@ const SEARCH_USAGE_2: SearchUsageRecord = {
 const STORED_RESPONSES_ITEM: StoredResponsesItem = {
   id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA',
   apiKeyId: 'key-a',
-  upstreamId: null,
-  upstreamItemId: null,
   itemType: 'message',
-  origin: 'synthetic',
-  contentHash: null,
-  encryptedContentHash: null,
+  contentHash: 'stored-content-hash',
   payload: { item: { type: 'message', id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA', role: 'assistant', content: [] } },
   createdAt: 1_000,
-  refreshedAt: 1_000,
 };
 
 const PERFORMANCE_1: PerformanceTelemetryRecord = {
@@ -295,7 +292,7 @@ const doExport = async (app: Hono, includePerformance = false) => {
   return (await resp.json()) as Record<string, any>;
 };
 
-const doImport = async (app: Hono, mode: string, data: unknown, version: unknown = 10) => {
+const doImport = async (app: Hono, mode: string, data: unknown, version: unknown = 11) => {
   const resp = await app.request('/import', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -333,13 +330,13 @@ test('import validates generic pricing selectors', async () => {
   assertEquals(String(fractional.body.error).includes('positive safe integer'), true);
 });
 
-test('export emits the v10 envelope with users and upstreams', async () => {
+test('export emits the v11 envelope with users and upstreams', async () => {
   const { app, repo } = setup();
   await repo.users.save(SEED_ADMIN);
 
   const result = await doExport(app);
 
-  assertEquals(result.version, 10);
+  assertEquals(result.version, 11);
   assertEquals(typeof result.exportedAt, 'string');
   assertEquals(result.data.users, [SEED_ADMIN]);
   assertEquals(result.data.apiKeys, []);
@@ -404,8 +401,8 @@ test('import rejects any version other than the current one before deleting data
   await repo.apiKeys.save(KEY_A);
   await repo.upstreams.save(CUSTOM_UPSTREAM);
 
-  const VERSION_ERROR = 'version must be 10 — older export formats are not supported; re-export from the current deployment';
-  const priorVersion = await doImport(app, 'replace', { apiKeys: [] }, 3);
+  const VERSION_ERROR = 'version must be 11 — older export formats are not supported; re-export from the current deployment';
+  const previousV10 = await doImport(app, 'replace', latestImportData(), 10);
   const ancientVersion = await doImport(app, 'replace', { apiKeys: [] }, 1);
   const missingVersionResponse = await app.request('/import', {
     method: 'POST',
@@ -414,8 +411,8 @@ test('import rejects any version other than the current one before deleting data
   });
   const missingVersion = { status: missingVersionResponse.status, body: (await missingVersionResponse.json()) as Record<string, any> };
 
-  assertEquals(priorVersion.status, 400);
-  assertEquals(priorVersion.body.error, VERSION_ERROR);
+  assertEquals(previousV10.status, 400);
+  assertEquals(previousV10.body.error, VERSION_ERROR);
   assertEquals(ancientVersion.status, 400);
   assertEquals(ancientVersion.body.error, VERSION_ERROR);
   assertEquals(missingVersion.status, 400);
@@ -697,7 +694,7 @@ test('import rejects negative historical unit prices with a dimension-specific e
   assertEquals(result.body.error, 'invalid usage at index 0: rates.input must be a finite non-negative number');
 });
 
-test('v10 import requires exact usage token and rate maps', async () => {
+test('v11 import requires exact usage token and rate maps', async () => {
   const { app } = setup();
   const missingTokens = await doImport(app, 'replace', latestImportData({
     usage: [{ ...USAGE_2, tokens: undefined }],
@@ -796,20 +793,53 @@ test('import rejects api key unique identity conflicts before mutating', async (
   const duplicateId = await doImport(app, 'replace', latestImportData({
     apiKeys: [KEY_B, { ...KEY_B, name: 'Duplicate Bob' }],
   }));
+  const duplicateServerSecret = await doImport(app, 'replace', latestImportData({
+    apiKeys: [KEY_B, { ...KEY_A, id: 'key-c', key: 'secret-c', serverSecret: KEY_B.serverSecret }],
+  }));
   const mergeExistingRawKeyConflict = await doImport(app, 'merge', latestImportData({
     apiKeys: [{ ...KEY_B, key: KEY_A.key }],
   }));
+  const mergeExistingServerSecretConflict = await doImport(app, 'merge', latestImportData({
+    apiKeys: [{ ...KEY_B, serverSecret: KEY_A.serverSecret }],
+  }));
 
   assertEquals(duplicateRawKey.status, 400);
   assertEquals(duplicateRawKey.body.error, 'invalid apiKeys: duplicate apiKeys raw key used by key-b and key-c');
   assertEquals(duplicateId.status, 400);
   assertEquals(duplicateId.body.error, 'invalid apiKeys: duplicate apiKeys id key-b at indexes 0 and 1');
+  assertEquals(duplicateServerSecret.status, 400);
+  assertEquals(duplicateServerSecret.body.error, 'invalid apiKeys: duplicate apiKeys server secret used by key-b and key-c');
   assertEquals(mergeExistingRawKeyConflict.status, 400);
   assertEquals(mergeExistingRawKeyConflict.body.error, 'invalid apiKeys: apiKeys raw key for key-b conflicts with existing api key key-a');
+  assertEquals(mergeExistingServerSecretConflict.status, 400);
+  assertEquals(mergeExistingServerSecretConflict.body.error, 'invalid apiKeys: apiKeys server secret for key-b conflicts with existing api key key-a');
   assertEquals(await repo.apiKeys.list(), [KEY_A]);
   assertEquals(await repo.upstreams.list(), [CUSTOM_UPSTREAM]);
 });
 
+test('import requires an exact lowercase hexadecimal serverSecret on every api key', async () => {
+  const { app, repo } = setup();
+  await repo.apiKeys.save(KEY_A);
+
+  const malformed = [
+    { ...KEY_B, serverSecret: undefined },
+    { ...KEY_B, serverSecret: 'aa'.repeat(31) },
+    { ...KEY_B, serverSecret: 'AA'.repeat(32) },
+    { ...KEY_B, serverSecret: `${'aa'.repeat(31)}zz` },
+  ];
+
+  for (const key of malformed) {
+    const result = await doImport(app, 'replace', latestImportData({ apiKeys: [key] }));
+    assertEquals(result.status, 400);
+    assertEquals(
+      result.body.error,
+      'invalid apiKeys at index 0: serverSecret must be exactly 64 lowercase hexadecimal characters',
+    );
+  }
+
+  assertEquals(await repo.apiKeys.list(), [KEY_A]);
+});
+
 test('import preserves a positive dumpRetentionSeconds on api keys', async () => {
   const { app, repo } = setup();
 
@@ -891,7 +921,7 @@ test('import rejects legacy enabled_fixes payloads before mutating', async () =>
   assertEquals(await repo.upstreams.list(), [CUSTOM_UPSTREAM]);
 });
 
-test('import rejects missing latest-v10 arrays before clearing existing data', async () => {
+test('import rejects missing latest-v11 arrays before clearing existing data', async () => {
   const { app, repo } = setup();
   await repo.apiKeys.save(KEY_A);
   await repo.upstreams.save(CUSTOM_UPSTREAM);
@@ -917,14 +947,14 @@ test('import rejects missing latest-v10 arrays before clearing existing data', a
 test('import validates mode and data before mutating', async () => {
   const { app } = setup();
 
-  const invalidMode = await doImport(app, 'invalid', {}, 10);
+  const invalidMode = await doImport(app, 'invalid', {}, 11);
   const missingData = await app.request('/import', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ mode: 'replace', version: 10 }),
+    body: JSON.stringify({ mode: 'replace', version: 11 }),
   });
-  const missingUpstreams = await doImport(app, 'merge', {}, 10);
-  const emptyMerge = await doImport(app, 'merge', latestImportData(), 10);
+  const missingUpstreams = await doImport(app, 'merge', {}, 11);
+  const emptyMerge = await doImport(app, 'merge', latestImportData(), 11);
 
   assertEquals(invalidMode.status, 400);
   assertEquals(invalidMode.body.error, "mode must be 'merge' or 'replace'");
@@ -1076,7 +1106,7 @@ test('import replace wipes proxy_upstream_backoffs alongside the proxies it cool
   assertEquals(await repo.proxyBackoffs.listAll(), []);
 });
 
-test('v10 export/import round-trips users and per-key user_id', async () => {
+test('v11 export/import round-trips users and per-key user_id', async () => {
   const { app, repo } = setup();
   await repo.users.save(SEED_ADMIN);
   await repo.users.save(USER_BOB);
@@ -1084,10 +1114,10 @@ test('v10 export/import round-trips users and per-key user_id', async () => {
   await repo.apiKeys.save({ ...KEY_B, userId: USER_BOB.id });
 
   const exportResult = await doExport(app);
-  assertEquals(exportResult.version, 10);
+  assertEquals(exportResult.version, 11);
   assertEquals(exportResult.data.users.map((u: any) => u.id).sort(), [SEED_ADMIN.id, USER_BOB.id]);
 
-  const result = await doImport(app, 'replace', exportResult.data, 10);
+  const result = await doImport(app, 'replace', exportResult.data, 11);
   assertEquals(result.status, 200);
   assertEquals(result.body.imported.users, 2);
   assertEquals(result.body.imported.apiKeys, 2);
@@ -1098,7 +1128,7 @@ test('v10 export/import round-trips users and per-key user_id', async () => {
   assertEquals(restoredKey?.userId, USER_BOB.id);
 });
 
-test('v10 import rejects api_keys whose user_id does not appear in the payload', async () => {
+test('v11 import rejects api_keys whose user_id does not appear in the payload', async () => {
   const { app, repo } = setup();
   await repo.users.save(SEED_ADMIN);
 
@@ -1110,13 +1140,13 @@ test('v10 import rejects api_keys whose user_id does not appear in the payload',
     searchUsage: [],
     performanceIncluded: false,
     searchConfig: DEFAULT_SEARCH_CONFIG,
-  }, 10);
+  }, 11);
 
   assertEquals(result.status, 400);
   assertEquals(result.body.error, 'invalid apiKeys at index 0: user_id 99 does not match any user in the payload');
 });
 
-test('v10 import rejects malformed users (bad username, bad password_hash)', async () => {
+test('v11 import rejects malformed users (bad username, bad password_hash)', async () => {
   const { app } = setup();
 
   const badUsername = await doImport(app, 'replace', {
@@ -1127,7 +1157,7 @@ test('v10 import rejects malformed users (bad username, bad password_hash)', asy
     searchUsage: [],
     performanceIncluded: false,
     searchConfig: DEFAULT_SEARCH_CONFIG,
-  }, 10);
+  }, 11);
   assertEquals(badUsername.status, 400);
   assertEquals(String(badUsername.body.error).startsWith('invalid users at index 0:'), true);
 
@@ -1139,7 +1169,7 @@ test('v10 import rejects malformed users (bad username, bad password_hash)', asy
     searchUsage: [],
     performanceIncluded: false,
     searchConfig: DEFAULT_SEARCH_CONFIG,
-  }, 10);
+  }, 11);
   assertEquals(badHash.status, 400);
   assertEquals(String(badHash.body.error).includes('passwordHash'), true);
 });
@@ -1161,7 +1191,7 @@ test('import rejects a pre-accounts v3 export instead of coercing its legacy api
   }, 3);
 
   assertEquals(result.status, 400);
-  assertEquals(String(result.body.error).includes('version must be 10'), true);
+  assertEquals(String(result.body.error).includes('version must be 11'), true);
   // Rejected at the version gate, before touching any data.
   assertEquals(await repo.apiKeys.list(), [KEY_A]);
   assertEquals((await repo.users.list()).map(u => u.id), [SEED_ADMIN.id]);
@@ -1182,7 +1212,7 @@ test('replace-mode import clears sessions before writing users', async () => {
     searchUsage: [],
     performanceIncluded: false,
     searchConfig: DEFAULT_SEARCH_CONFIG,
-  }, 10);
+  }, 11);
 
   assertEquals(result.status, 200);
   // No public listAll on sessions; create a fresh session and check the
@@ -1191,7 +1221,7 @@ test('replace-mode import clears sessions before writing users', async () => {
   assertEquals(await repo.sessions.deleteByUserId(USER_BOB.id), 0);
 });
 
-test('v10 import rejects users[i].upstreamIds === undefined', async () => {
+test('v11 import rejects users[i].upstreamIds === undefined', async () => {
   const { app } = setup();
   const result = await doImport(app, 'replace', {
     users: [SEED_ADMIN, { ...USER_BOB, upstreamIds: undefined }],
@@ -1201,12 +1231,12 @@ test('v10 import rejects users[i].upstreamIds === undefined', async () => {
     searchUsage: [],
     performanceIncluded: false,
     searchConfig: DEFAULT_SEARCH_CONFIG,
-  }, 10);
+  }, 11);
   assertEquals(result.status, 400);
   expect(result.body.error).toMatch(/upstreamIds/);
 });
 
-test('v10 import rejects users[i].deletedAt of non-string non-null type', async () => {
+test('v11 import rejects users[i].deletedAt of non-string non-null type', async () => {
   const { app } = setup();
   const result = await doImport(app, 'replace', {
     users: [SEED_ADMIN, { ...USER_BOB, deletedAt: 42 }],
@@ -1216,12 +1246,12 @@ test('v10 import rejects users[i].deletedAt of non-string non-null type', async
     searchUsage: [],
     performanceIncluded: false,
     searchConfig: DEFAULT_SEARCH_CONFIG,
-  }, 10);
+  }, 11);
   assertEquals(result.status, 400);
   expect(result.body.error).toMatch(/deletedAt/);
 });
 
-test('v10 replace import refuses payload missing user 1', async () => {
+test('v11 replace import refuses payload missing user 1', async () => {
   const { app } = setup();
   const result = await doImport(app, 'replace', {
     users: [USER_BOB],
@@ -1231,12 +1261,12 @@ test('v10 replace import refuses payload missing user 1', async () => {
     searchUsage: [],
     performanceIncluded: false,
     searchConfig: DEFAULT_SEARCH_CONFIG,
-  }, 10);
+  }, 11);
   assertEquals(result.status, 400);
   expect(result.body.error).toMatch(/user 1/);
 });
 
-test('a full v10 export re-imports verbatim — the export→import round trip is closed', async () => {
+test('a full v11 export re-imports verbatim — the export→import round trip is closed', async () => {
   const { app, repo } = setup();
   await repo.users.save(SEED_ADMIN);
   await repo.users.save(USER_BOB);
@@ -1262,12 +1292,12 @@ test('a full v10 export re-imports verbatim — the export→import round trip i
   await repo.searchConfig.save(config);
 
   const exported = await doExport(app, true);
-  assertEquals(exported.version, 10);
+  assertEquals(exported.version, 11);
 
   // Replace-import the export's own `data`, verbatim. If the export emits any
   // shape the import parser rejects, this 400s — the round trip is the
   // invariant, so this test fails the moment the two sides drift.
-  const result = await doImport(app, 'replace', exported.data, 10);
+  const result = await doImport(app, 'replace', exported.data, 11);
   assertEquals(result.status, 200);
   assertEquals(result.body.imported, { users: 2, apiKeys: 2, upstreams: 4, proxies: 0, usage: 2, searchUsage: 2, performance: 2 });
 
@@ -1301,7 +1331,7 @@ test('any data bearing a historical version is rejected on the version gate, bef
   for (const version of [1, 2, 3, 4, 5, 6, 7, 8, 9]) {
     const result = await doImport(app, 'replace', wellFormed, version);
     assertEquals(result.status, 400);
-    assertEquals(String(result.body.error).includes('version must be 10'), true);
+    assertEquals(String(result.body.error).includes('version must be 11'), true);
   }
 
   // Nothing was touched — the version gate runs before any delete or write.
@@ -1392,7 +1422,7 @@ test('replace-mode import surfaces a purgeAll failure', async () => {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
-      mode: 'replace', version: 10, data: latestImportData({
+      mode: 'replace', version: 11, data: latestImportData({
         apiKeys: [{ ...KEY_A, dumpRetentionSeconds: 3600 }],
       }),
     }),
@@ -1410,7 +1440,7 @@ test('merge-mode retention transition surfaces a purgeAll failure', async () =>
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
-      mode: 'merge', version: 10, data: latestImportData({
+      mode: 'merge', version: 11, data: latestImportData({
         apiKeys: [{ ...KEY_A, dumpRetentionSeconds: null }],
       }),
     }),
diff --git a/packages/gateway/src/control-plane/performance/routes_test.ts b/packages/gateway/src/control-plane/performance/routes_test.ts
index f266834e8..22f671935 100644
--- a/packages/gateway/src/control-plane/performance/routes_test.ts
+++ b/packages/gateway/src/control-plane/performance/routes_test.ts
@@ -58,6 +58,7 @@ test('/api/performance/overview scopes to actor\'s keys in self-by-key mode', as
     userId: 1,
     name: 'Other key',
     key: 'raw_other_key',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-04-30T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
@@ -123,6 +124,7 @@ test('/api/performance/overview all-by-user view aggregates over every key', asy
     userId: 1,
     name: 'Admin owned',
     key: 'raw_admin_owned',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-04-30T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
@@ -164,6 +166,7 @@ test('/api/performance/overview keeps API-key data self-scoped in all-by-user vi
     userId: 1,
     name: 'Admin owned',
     key: 'raw_admin_owned',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-04-30T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
@@ -226,6 +229,7 @@ test('/api/performance/overview all-by-user userRows split rows per user', async
     userId: 1,
     name: 'Admin owned',
     key: 'raw_admin_owned',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-04-30T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
@@ -269,6 +273,7 @@ test('/api/performance/overview series stays per-model under all-by-user view',
     userId: 1,
     name: 'Admin owned',
     key: 'raw_admin_owned',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-04-30T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
@@ -497,6 +502,7 @@ test('/api/performance/overview self-by-key surfaces soft-deleted keys metadata
     userId: apiKey.userId,
     name: 'Fresh',
     key: 'raw_fresh_key',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-04-30T11:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
diff --git a/packages/gateway/src/control-plane/schemas.ts b/packages/gateway/src/control-plane/schemas.ts
index 20462ff69..1deabe056 100644
--- a/packages/gateway/src/control-plane/schemas.ts
+++ b/packages/gateway/src/control-plane/schemas.ts
@@ -657,7 +657,7 @@ export const updateAliasBody = aliasBodyCore.superRefine(aliasBodyRulesRefinemen
 // --- data transfer ---
 
 export const importBody = z.object({
-  version: z.literal(10, { error: 'version must be 10 — older export formats are not supported; re-export from the current deployment' }),
+  version: z.literal(11, { error: 'version must be 11 — older export formats are not supported; re-export from the current deployment' }),
   mode: z.enum(['merge', 'replace'], { error: "mode must be 'merge' or 'replace'" }),
   data: z.unknown().optional(),
 });
diff --git a/packages/gateway/src/control-plane/search-usage/routes_test.ts b/packages/gateway/src/control-plane/search-usage/routes_test.ts
index 482478958..6015004cd 100644
--- a/packages/gateway/src/control-plane/search-usage/routes_test.ts
+++ b/packages/gateway/src/control-plane/search-usage/routes_test.ts
@@ -9,6 +9,7 @@ const seedSearchUsage = async (repo: import('../../repo/memory.ts').InMemoryRepo
     userId: 1,
     name: 'Other key',
     key: 'raw_other_key',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-03-15T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
diff --git a/packages/gateway/src/control-plane/telemetry-view_test.ts b/packages/gateway/src/control-plane/telemetry-view_test.ts
index e0de31a09..14bf84920 100644
--- a/packages/gateway/src/control-plane/telemetry-view_test.ts
+++ b/packages/gateway/src/control-plane/telemetry-view_test.ts
@@ -9,6 +9,7 @@ import { assertEquals } from '@floway-dev/test-utils';
 const stubKey = (overrides: Partial<ApiKey> & Pick<ApiKey, 'id' | 'userId'>): ApiKey => ({
   name: `key ${overrides.id}`,
   key: `raw_${overrides.id}`,
+  serverSecret: '00'.repeat(32),
   createdAt: '2026-04-30T00:00:00.000Z',
   upstreamIds: null,
   deletedAt: null,
diff --git a/packages/gateway/src/control-plane/token-usage/routes_test.ts b/packages/gateway/src/control-plane/token-usage/routes_test.ts
index fd7814de9..b10686194 100644
--- a/packages/gateway/src/control-plane/token-usage/routes_test.ts
+++ b/packages/gateway/src/control-plane/token-usage/routes_test.ts
@@ -55,6 +55,7 @@ test('/api/token-usage self-by-key surfaces soft-deleted keys metadata to their
     userId: apiKey.userId,
     name: 'Fresh',
     key: 'raw_fresh_key',
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-04-30T11:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
diff --git a/packages/gateway/src/control-plane/users/routes.ts b/packages/gateway/src/control-plane/users/routes.ts
index 9c01215ec..5375667ad 100644
--- a/packages/gateway/src/control-plane/users/routes.ts
+++ b/packages/gateway/src/control-plane/users/routes.ts
@@ -6,6 +6,7 @@ import { getRepo } from '../../repo/index.ts';
 import type { ApiKey, User } from '../../repo/types.ts';
 import { generateApiKeyToken } from '../../shared/api-key-tokens.ts';
 import { hashPassword, verifyPassword } from '../../shared/passwords.ts';
+import { generateServerSecret } from '../../shared/server-secret.ts';
 import type { changeOwnPasswordBody, createUserBody, updateUserBody } from '../schemas.ts';
 
 const validateUpstreamIdsExist = async (ids: readonly string[] | null): Promise<string | null> => {
@@ -53,6 +54,7 @@ export const createUser = async (c: CtxWithJson<typeof createUserBody>) => {
     userId: user.id,
     name: 'Default',
     key: generateApiKeyToken(),
+    serverSecret: generateServerSecret(),
     createdAt: new Date().toISOString(),
     upstreamIds: null,
     deletedAt: null,
diff --git a/packages/gateway/src/control-plane/users/routes_test.ts b/packages/gateway/src/control-plane/users/routes_test.ts
index 2f92a6852..e29655d7d 100644
--- a/packages/gateway/src/control-plane/users/routes_test.ts
+++ b/packages/gateway/src/control-plane/users/routes_test.ts
@@ -39,6 +39,7 @@ test('POST /api/users creates the user and provisions a Default key', async () =
   const stored = await repo.apiKeys.listByUserId(body.user.id);
   assertEquals(stored.length, 1);
   assertEquals(stored[0].name, 'Default');
+  assertEquals(/^[0-9a-f]{64}$/.test(stored[0].serverSecret), true);
 });
 
 test('POST /api/users rejects duplicate username + unknown upstream id', async () => {
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/affinity/egress.ts b/packages/gateway/src/data-plane/chat/chat-completions/affinity/egress.ts
new file mode 100644
index 000000000..bdad374b5
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/chat-completions/affinity/egress.ts
@@ -0,0 +1,118 @@
+import type { AffinityEgressOptions } from '../../shared/affinity/index.ts';
+import { chatCompletionsErrorPayloadMessage, type ChatCompletionsStreamEvent } from '@floway-dev/protocols/chat-completions';
+import { eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
+
+interface ChoiceState {
+  opaque?: string;
+  finished: boolean;
+}
+
+type StreamingChoice = ChatCompletionsStreamEvent['choices'][number];
+const REQUIRED_CHUNK_KEYS = new Set(['id', 'object', 'created', 'model', 'choices']);
+
+const eventWithChoices = (
+  event: ChatCompletionsStreamEvent,
+  choices: StreamingChoice[],
+  includeOriginalFields: boolean,
+): ChatCompletionsStreamEvent => {
+  const { id, object, created, model, choices: _choices, ...optional } = event;
+  return {
+    id,
+    object,
+    created,
+    model,
+    choices,
+    ...(includeOriginalFields ? optional : {}),
+  };
+};
+
+const hasOptionalChunkFields = (event: ChatCompletionsStreamEvent): boolean =>
+  Object.keys(event).some(key => !REQUIRED_CHUNK_KEYS.has(key));
+
+export const wrapChatCompletionsAffinityEgress = async function* (
+  frames: AsyncIterable<ProtocolFrame<ChatCompletionsStreamEvent>>,
+  options: AffinityEgressOptions,
+): AsyncGenerator<ProtocolFrame<ChatCompletionsStreamEvent>> {
+  // One choice is one logical assistant element, so its carrier frame before
+  // finish_reason (or DONE when finish_reason is absent) is both the turn
+  // prefix and final opaque snapshot.
+  const choices = new Map<number, ChoiceState>();
+  let lastEvent: ChatCompletionsStreamEvent | undefined;
+  let failed = false;
+
+  for await (const frame of frames) {
+    if (frame.type !== 'event') {
+      if (frame.type === 'done' && !failed) {
+        if (choices.size === 0 || lastEvent === undefined) {
+          throw new Error('Chat Completions stream ended without an assistant choice');
+        }
+        const unfinished = [...choices.entries()].filter(([, state]) => !state.finished);
+        if (unfinished.length > 0) {
+          const wrappedChoices = await Promise.all(unfinished.map(async ([index, state]) => {
+            state.finished = true;
+            return {
+              index,
+              delta: { reasoning_opaque: await options.codec.wrap(state.opaque, options.affinity, 'chat-completions.reasoning_opaque') },
+              finish_reason: null,
+            } satisfies StreamingChoice;
+          }));
+          yield eventFrame(eventWithChoices(lastEvent, wrappedChoices, false));
+        }
+      }
+      yield frame;
+      continue;
+    }
+
+    if (chatCompletionsErrorPayloadMessage(frame.event) !== null) {
+      failed = true;
+      yield frame;
+      continue;
+    }
+    lastEvent = frame.event;
+
+    const visibleChoices: StreamingChoice[] = [];
+    const finishingChoices: Array<{
+      index: number;
+      finishReason: NonNullable<StreamingChoice['finish_reason']>;
+      state: ChoiceState;
+    }> = [];
+
+    for (const choice of frame.event.choices) {
+      const { index, delta: sourceDelta, finish_reason: finishReason, ...choiceExtras } = choice;
+      const state = choices.get(index) ?? { finished: false };
+      if (state.finished) throw new Error(`Chat Completions choice ${index} emitted data after its finish_reason`);
+      choices.set(index, state);
+
+      const { reasoning_opaque: opaque, ...delta } = sourceDelta;
+      if (typeof opaque === 'string') state.opaque = opaque;
+      const hasVisibleProjection = Object.keys(delta).length > 0 || Object.keys(choiceExtras).length > 0;
+
+      if (finishReason === null) {
+        if (hasVisibleProjection) visibleChoices.push({ index, ...choiceExtras, delta, finish_reason: null } as StreamingChoice);
+        continue;
+      }
+
+      if (hasVisibleProjection) visibleChoices.push({ index, ...choiceExtras, delta, finish_reason: null } as StreamingChoice);
+      finishingChoices.push({ index, finishReason, state });
+    }
+
+    if (visibleChoices.length > 0 || frame.event.choices.length === 0 || hasOptionalChunkFields(frame.event)) {
+      yield eventFrame(eventWithChoices(frame.event, visibleChoices, true));
+    }
+
+    if (finishingChoices.length === 0) continue;
+
+    const wrappedChoices = await Promise.all(finishingChoices.map(async ({ index, state }) => ({
+      index,
+      delta: { reasoning_opaque: await options.codec.wrap(state.opaque, options.affinity, 'chat-completions.reasoning_opaque') },
+      finish_reason: null,
+    })));
+    yield eventFrame(eventWithChoices(frame.event, wrappedChoices, false));
+
+    const finishedChoices = finishingChoices.map(({ index, finishReason, state }) => {
+      state.finished = true;
+      return { index, delta: {}, finish_reason: finishReason };
+    });
+    yield eventFrame(eventWithChoices(frame.event, finishedChoices, false));
+  }
+};
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/affinity/egress_test.ts b/packages/gateway/src/data-plane/chat/chat-completions/affinity/egress_test.ts
new file mode 100644
index 000000000..ff60cf5d6
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/chat-completions/affinity/egress_test.ts
@@ -0,0 +1,207 @@
+import { describe, expect, test } from 'vitest';
+
+import { wrapChatCompletionsAffinityEgress } from './egress.ts';
+import type { AffinityCodec, AffinityTarget } from '../../shared/affinity/index.ts';
+import { reassembleChatCompletionsEvents, type ChatCompletionsStreamEvent } from '@floway-dev/protocols/chat-completions';
+import { doneFrame, eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
+
+const affinity: AffinityTarget = {
+  upstreamId: 'up-a',
+  modelId: 'model-a',
+};
+
+type AffinityEgressCodec = Pick<AffinityCodec, 'wrap'>;
+
+const chunk = (
+  choices: ChatCompletionsStreamEvent['choices'],
+): ChatCompletionsStreamEvent => ({
+  id: 'chatcmpl_1',
+  object: 'chat.completion.chunk',
+  created: 1,
+  model: 'model-a',
+  choices,
+});
+
+const frames = async function* (values: ProtocolFrame<ChatCompletionsStreamEvent>[]) {
+  yield* values;
+};
+
+const withChoiceExtra = (event: ChatCompletionsStreamEvent, name: string, value: unknown): ChatCompletionsStreamEvent => {
+  Object.assign(event.choices[0], { [name]: value });
+  return event;
+};
+
+const withChunkExtra = (event: ChatCompletionsStreamEvent, name: string, value: unknown): ChatCompletionsStreamEvent => {
+  Object.assign(event, { [name]: value });
+  return event;
+};
+
+class DelayedCodec implements AffinityEgressCodec {
+  readonly calls: Array<{ value: string | undefined; resolve: (value: string) => void }> = [];
+
+  wrap(value: string | undefined): Promise<string> {
+    return new Promise(resolve => this.calls.push({ value, resolve }));
+  }
+}
+
+const immediateCodec: AffinityEgressCodec = {
+  wrap: async value => `wrapped:${value ?? 'synthetic'}`,
+};
+
+describe('Chat Completions affinity egress', () => {
+  test('forwards visible final data before wrapping the last opaque snapshot', async () => {
+    const codec = new DelayedCodec();
+    const output = wrapChatCompletionsAffinityEgress(frames([
+      eventFrame(chunk([{ index: 0, delta: { reasoning_opaque: 'first' }, finish_reason: null }])),
+      eventFrame(chunk([{
+        index: 0,
+        delta: { content: 'visible', reasoning_text: 'thinking', reasoning_opaque: 'latest' },
+        finish_reason: 'stop',
+      }])),
+      doneFrame(),
+    ]), { codec, affinity })[Symbol.asyncIterator]();
+
+    const visible = await output.next();
+    expect(visible.value).toEqual(eventFrame(chunk([{
+      index: 0,
+      delta: { content: 'visible', reasoning_text: 'thinking' },
+      finish_reason: null,
+    }])));
+    expect(codec.calls).toHaveLength(0);
+
+    const wrappedPending = output.next();
+    await Promise.resolve();
+    expect(codec.calls.map(call => call.value)).toEqual(['latest']);
+    codec.calls[0].resolve('wrapped-latest');
+    expect((await wrappedPending).value).toEqual(eventFrame(chunk([{
+      index: 0,
+      delta: { reasoning_opaque: 'wrapped-latest' },
+      finish_reason: null,
+    }])));
+
+    expect((await output.next()).value).toEqual(eventFrame(chunk([{
+      index: 0,
+      delta: {},
+      finish_reason: 'stop',
+    }])));
+    expect((await output.next()).value).toEqual(doneFrame());
+  });
+
+  test('wraps or synthesizes a carrier independently for every finishing choice', async () => {
+    const output: ProtocolFrame<ChatCompletionsStreamEvent>[] = [];
+    for await (const frame of wrapChatCompletionsAffinityEgress(frames([
+      eventFrame(chunk([
+        { index: 0, delta: { reasoning_opaque: 'opaque' }, finish_reason: 'stop' },
+        { index: 1, delta: {}, finish_reason: 'length' },
+      ])),
+      doneFrame(),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toEqual(eventFrame(chunk([
+      { index: 0, delta: { reasoning_opaque: 'wrapped:opaque' }, finish_reason: null },
+      { index: 1, delta: { reasoning_opaque: 'wrapped:synthetic' }, finish_reason: null },
+    ])));
+    expect(output[1]).toEqual(eventFrame(chunk([
+      { index: 0, delta: {}, finish_reason: 'stop' },
+      { index: 1, delta: {}, finish_reason: 'length' },
+    ])));
+  });
+
+  test('flushes a carrier before DONE when an upstream omits finish_reason', async () => {
+    const output: ProtocolFrame<ChatCompletionsStreamEvent>[] = [];
+    for await (const frame of wrapChatCompletionsAffinityEgress(frames([
+      eventFrame(chunk([{ index: 0, delta: { content: 'visible' }, finish_reason: null }])),
+      doneFrame(),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toEqual([
+      eventFrame(chunk([{ index: 0, delta: { content: 'visible' }, finish_reason: null }])),
+      eventFrame(chunk([{ index: 0, delta: { reasoning_opaque: 'wrapped:synthetic' }, finish_reason: null }])),
+      doneFrame(),
+    ]);
+  });
+
+  test('rejects a successful stream that ends without an assistant choice', async () => {
+    const collect = async () => {
+      const output: ProtocolFrame<ChatCompletionsStreamEvent>[] = [];
+      for await (const frame of wrapChatCompletionsAffinityEgress(
+        frames([doneFrame()]),
+        { codec: immediateCodec, affinity },
+      )) output.push(frame);
+      return output;
+    };
+
+    await expect(collect()).rejects.toThrow('Chat Completions stream ended without an assistant choice');
+  });
+
+  test('emits choice extras once on the visible projection before carrier encryption', async () => {
+    const codec = new DelayedCodec();
+    const output = wrapChatCompletionsAffinityEgress(frames([
+      eventFrame(withChoiceExtra(chunk([{
+        index: 0,
+        delta: { content: 'visible', reasoning_opaque: 'opaque' },
+        finish_reason: 'stop',
+      }]), 'logprobs', { content: [] })),
+      doneFrame(),
+    ]), { codec, affinity })[Symbol.asyncIterator]();
+
+    expect((await output.next()).value).toEqual(eventFrame(withChoiceExtra(chunk([{
+      index: 0,
+      delta: { content: 'visible' },
+      finish_reason: null,
+    }]), 'logprobs', { content: [] })));
+    expect(codec.calls).toHaveLength(0);
+
+    const carrier = output.next();
+    await Promise.resolve();
+    codec.calls[0].resolve('wrapped-opaque');
+    expect(JSON.stringify((await carrier).value)).not.toContain('logprobs');
+    expect(JSON.stringify((await output.next()).value)).not.toContain('logprobs');
+  });
+
+  test('does not drop extras from an opaque-only nonterminal choice', async () => {
+    const output: ProtocolFrame<ChatCompletionsStreamEvent>[] = [];
+    for await (const frame of wrapChatCompletionsAffinityEgress(frames([
+      eventFrame(withChoiceExtra(chunk([{ index: 0, delta: { reasoning_opaque: 'opaque' }, finish_reason: null }]), 'logprobs', null)),
+      eventFrame(chunk([{ index: 0, delta: {}, finish_reason: 'stop' }])),
+      doneFrame(),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toEqual(eventFrame(withChoiceExtra(chunk([{ index: 0, delta: {}, finish_reason: null }]), 'logprobs', null)));
+    expect(JSON.stringify(output.slice(1))).not.toContain('logprobs');
+  });
+
+  test('emits final chunk extras once across split frames and non-stream reassembly', async () => {
+    const output: ProtocolFrame<ChatCompletionsStreamEvent>[] = [];
+    for await (const frame of wrapChatCompletionsAffinityEgress(frames([
+      eventFrame(withChunkExtra(chunk([{
+        index: 0,
+        delta: { content: 'answer', reasoning_opaque: 'opaque' },
+        finish_reason: 'stop',
+      }]), 'vendor_text', 'x')),
+      doneFrame(),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(JSON.stringify(output).match(/vendor_text/g)).toHaveLength(1);
+    const chunks = async function* () {
+      for (const frame of output) if (frame.type === 'event') yield frame.event;
+    };
+    expect(await reassembleChatCompletionsEvents(chunks())).toMatchObject({ vendor_text: 'x' });
+  });
+
+  test('preserves chunk extras from an opaque-only nonterminal event', async () => {
+    const output: ProtocolFrame<ChatCompletionsStreamEvent>[] = [];
+    for await (const frame of wrapChatCompletionsAffinityEgress(frames([
+      eventFrame(withChunkExtra(
+        chunk([{ index: 0, delta: { reasoning_opaque: 'opaque' }, finish_reason: null }]),
+        'vendor_scalar',
+        7,
+      )),
+      eventFrame(chunk([{ index: 0, delta: {}, finish_reason: 'stop' }])),
+      doneFrame(),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({ event: { choices: [], vendor_scalar: 7 } });
+    expect(JSON.stringify(output.slice(1))).not.toContain('vendor_scalar');
+  });
+});
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/affinity/ingress.ts b/packages/gateway/src/data-plane/chat/chat-completions/affinity/ingress.ts
new file mode 100644
index 000000000..22e8f28a2
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/chat-completions/affinity/ingress.ts
@@ -0,0 +1,27 @@
+import { type AffinityCodec, blobForExactCandidate, preferredAffinityEvidence, type DecodedAffinityBlob, type PreparedAffinityPayload } from '../../shared/affinity/index.ts';
+import type { ChatCompletionsPayload } from '@floway-dev/protocols/chat-completions';
+
+export const prepareChatCompletionsAffinity = async (
+  payload: ChatCompletionsPayload,
+  codec: AffinityCodec,
+): Promise<PreparedAffinityPayload<ChatCompletionsPayload>> => {
+  const decoded = new Map<number, DecodedAffinityBlob>();
+  for (const [index, message] of payload.messages.entries()) {
+    if (message.role !== 'assistant' || typeof message.reasoning_opaque !== 'string') continue;
+    decoded.set(index, await codec.unwrap(message.reasoning_opaque, 'chat-completions.reasoning_opaque'));
+  }
+
+  return {
+    routingEvidence: preferredAffinityEvidence(decoded.values()),
+    payloadForCandidate: candidate => {
+      const candidatePayload = structuredClone(payload);
+      for (const [index, blob] of decoded) {
+        const message = candidatePayload.messages[index];
+        const selected = blobForExactCandidate(blob, candidate);
+        if (selected.present) message.reasoning_opaque = selected.value;
+        else delete message.reasoning_opaque;
+      }
+      return candidatePayload;
+    },
+  };
+};
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/affinity/ingress_test.ts b/packages/gateway/src/data-plane/chat/chat-completions/affinity/ingress_test.ts
new file mode 100644
index 000000000..573c53f24
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/chat-completions/affinity/ingress_test.ts
@@ -0,0 +1,36 @@
+import { expect, test } from 'vitest';
+
+import { prepareChatCompletionsAffinity } from './ingress.ts';
+import { AffinityCodec, type AffinityTarget } from '../../shared/affinity/index.ts';
+import type { ModelCandidate } from '@floway-dev/provider';
+import { stubModelCandidate } from '@floway-dev/test-utils';
+
+const codec = new AffinityCodec('22'.repeat(32));
+
+const candidate = (upstream: string): ModelCandidate => {
+  const base = stubModelCandidate();
+  return stubModelCandidate({
+    provider: { ...base.provider, upstream },
+    model: { id: 'model' },
+  });
+};
+
+const targetFor = (value: ModelCandidate): AffinityTarget => ({
+  upstreamId: value.provider.upstream,
+  modelId: value.model.id,
+  ...(value.rules !== undefined ? { rules: value.rules } : {}),
+});
+
+test('restores owned opaque state only for its exact candidate', async () => {
+  const candidateA = candidate('upstream-a');
+  const candidateB = candidate('upstream-b');
+  const carrier = await codec.wrap('upstream-signature', targetFor(candidateA), 'chat-completions.reasoning_opaque');
+  const prepared = await prepareChatCompletionsAffinity({
+    model: 'model',
+    messages: [{ role: 'assistant', content: 'answer', reasoning_opaque: carrier }],
+  }, codec);
+
+  expect(prepared.routingEvidence).toEqual([{ target: targetFor(candidateA), mode: 'prefer' }]);
+  expect(prepared.payloadForCandidate(candidateA).messages[0]).toMatchObject({ reasoning_opaque: 'upstream-signature' });
+  expect(prepared.payloadForCandidate(candidateB).messages[0]).not.toHaveProperty('reasoning_opaque');
+});
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/attempt.ts b/packages/gateway/src/data-plane/chat/chat-completions/attempt.ts
index 4d072bf6c..074d0b74c 100644
--- a/packages/gateway/src/data-plane/chat/chat-completions/attempt.ts
+++ b/packages/gateway/src/data-plane/chat/chat-completions/attempt.ts
@@ -4,18 +4,14 @@ import { applyRulesToUpstreamChatCompletions } from '../../model-aliases/apply-r
 import { providerStreamResultToExecuteResult, buildUpstreamCallOptions, chatTargetPicker } from '../../shared/telemetry/attempt-helpers.ts';
 import { messagesAttempt } from '../messages/attempt.ts';
 import { responsesAttempt } from '../responses/attempt.ts';
-import { rewriteStoredItemsInSourceForCandidate } from '../responses/items/rewrite.ts';
-import type { StatefulResponsesStore } from '../responses/items/store.ts';
-import { tryCatchChatServeFailure } from '../shared/errors.ts';
 import { createExternalImageLoader } from '../shared/external-image-loader.ts';
 import type { ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import { traverseTranslation } from '../shared/translate-traverse.ts';
 import { runInterceptors } from '@floway-dev/interceptor';
-import type { ChatCompletionsMessage, ChatCompletionsPayload, ChatCompletionsStreamEvent } from '@floway-dev/protocols/chat-completions';
+import type { ChatCompletionsPayload, ChatCompletionsStreamEvent } from '@floway-dev/protocols/chat-completions';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
 import { type ModelCandidate, type ExecuteResult, providerModelOf } from '@floway-dev/provider';
 import { translateChatCompletionsViaMessages, translateChatCompletionsViaResponses } from '@floway-dev/translate';
-import { chatCompletionsViaResponsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
 // `/v1/chat/completions` generate prefers a native Chat Completions target,
 // then the translated Messages path, then the translated Responses path.
@@ -31,13 +27,11 @@ export interface ChatCompletionsAttemptArgs {
 export const chatCompletionsAttempt = {
   generate: async (args: ChatCompletionsAttemptArgs): Promise<ExecuteResult<ProtocolFrame<ChatCompletionsStreamEvent>>> => {
     const { payload: sourcePayload, ctx, candidate, headers: sourceHeaders } = args;
-    const payload = { ...structuredClone(sourcePayload), model: candidate.model.id };
+    const payload = { ...sourcePayload, model: candidate.model.id };
     const headers = new Headers(sourceHeaders);
     const targetApi = chatCompletionsTarget.pick(candidate.model.endpoints);
-    const rewritten = await rewriteOrRenderChatCompletionsFailure(payload, ctx.store, candidate);
-    if (rewritten.failure) return rewritten.failure;
     const invocation: ChatCompletionsInvocation = {
-      payload: rewritten.payload,
+      payload,
       candidate,
       targetApi,
       headers,
@@ -80,37 +74,3 @@ export const chatCompletionsAttempt = {
     });
   },
 };
-
-// Chat Completions carries stored Responses reasoning ids on
-// `assistant.reasoning_items`; the translate-package view exposes them as
-// Responses items so the shared rewrite pass works here too.
-const rewriteOrRenderChatCompletionsFailure = async (
-  payload: ChatCompletionsPayload,
-  store: StatefulResponsesStore,
-  candidate: ModelCandidate,
-): Promise<{ payload: ChatCompletionsPayload; failure?: undefined } | { payload?: undefined; failure: ExecuteResult<ProtocolFrame<ChatCompletionsStreamEvent>> & { type: 'api-error' } }> => {
-  try {
-    const rewrittenMessages = await rewriteStoredItemsInSourceForCandidate(
-      payload.messages as readonly ChatCompletionsMessage[],
-      chatCompletionsViaResponsesItemsView,
-      store,
-      candidate,
-    );
-    return { payload: { ...payload, messages: rewrittenMessages as ChatCompletionsMessage[] } };
-  } catch (error) {
-    const failure = tryCatchChatServeFailure(error);
-    if (failure === null) throw error;
-    if (failure.kind !== 'item-not-found') throw error;
-    return {
-      failure: {
-        type: 'api-error',
-        source: 'gateway',
-        status: 400,
-        headers: new Headers({ 'content-type': 'application/json' }),
-        body: new TextEncoder().encode(JSON.stringify({
-          error: { type: 'invalid_request_error', message: `Item with id '${failure.itemId}' not found.` },
-        })),
-      },
-    };
-  }
-};
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/http.ts b/packages/gateway/src/data-plane/chat/chat-completions/http.ts
index 32d7651dd..cd436a583 100644
--- a/packages/gateway/src/data-plane/chat/chat-completions/http.ts
+++ b/packages/gateway/src/data-plane/chat/chat-completions/http.ts
@@ -4,7 +4,6 @@ import { chatCompletionsServe } from './serve.ts';
 import type { AuthedContext } from '../../../middleware/auth.ts';
 import { backgroundSchedulerFromContext } from '../../../runtime/background.ts';
 import { inboundHeadersForUpstream } from '../../shared/inbound-headers.ts';
-import { createNonResponsesSourceStore } from '../responses/items/store.ts';
 import { createChatGatewayCtxFromHono, createGatewayCtxFromHono, finalizeGatewayResponse, type ChatGatewayCtx, type GatewayCtx } from '../shared/gateway-ctx.ts';
 import { readRequestBody, takeRequestBody, type RequestBody } from '../shared/request-body.ts';
 import { providerModelsUnavailableResponse } from '../shared/upstream-models-error.ts';
@@ -54,7 +53,7 @@ export const chatCompletionsHttp = {
       // slots — the value lives in this http-entry closure for the duration of
       // the request.
       const includeUsageChunk = payload.stream_options?.include_usage === true;
-      ctx = createChatGatewayCtxFromHono(c, { wantsStream, requestBody: takeRequestBody(requestBody), model: payload.model, backgroundScheduler: backgroundSchedulerFromContext(c) }, createNonResponsesSourceStore);
+      ctx = createChatGatewayCtxFromHono(c, { wantsStream, requestBody: takeRequestBody(requestBody), model: payload.model, backgroundScheduler: backgroundSchedulerFromContext(c) });
       const result = await chatCompletionsServe.generate({ payload, ctx, headers: inboundHeadersForUpstream(c) });
       const { response } = await respondChatCompletions(c, result, wantsStream, includeUsageChunk, ctx);
       return finalizeGatewayResponse(ctx, response);
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/http_test.ts b/packages/gateway/src/data-plane/chat/chat-completions/http_test.ts
index 11ae8bbc5..3b388a81f 100644
--- a/packages/gateway/src/data-plane/chat/chat-completions/http_test.ts
+++ b/packages/gateway/src/data-plane/chat/chat-completions/http_test.ts
@@ -42,6 +42,7 @@ const buildApiKey = (overrides: Partial<ApiKey> = {}): ApiKey => ({
   userId: 1,
   name: 'http_test',
   key: 'sk-http-test',
+  serverSecret: '00'.repeat(32),
   createdAt: '2026-01-01T00:00:00.000Z',
   upstreamIds: null,
   deletedAt: null,
@@ -156,6 +157,70 @@ test('POST /v1/chat/completions returns a single JSON body when stream is omitte
   assertEquals(body.choices[0].message.content, 'hi');
 });
 
+test('client-carried opaque state restores the exact preferred candidate on the next turn', async () => {
+  installRepo();
+  const observedBodies: Array<{ messages?: Array<{ reasoning_opaque?: string }> }> = [];
+  const callA = vi.fn(async (_model: unknown, body: unknown): Promise<ProviderStreamResult<ChatCompletionsStreamEvent>> => {
+    observedBodies.push(body as { messages?: Array<{ reasoning_opaque?: string }> });
+    const turn = observedBodies.length;
+    return {
+      ok: true,
+      events: makeProtocolFrames([
+        {
+          id: `chatcmpl_affinity_${turn}`,
+          object: 'chat.completion.chunk',
+          created: 0,
+          model: 'test-model',
+          choices: [{ index: 0, delta: { content: `turn ${turn}`, ...(turn === 1 ? { reasoning_opaque: 'opaque-a' } : {}) }, finish_reason: null }],
+        },
+        {
+          id: `chatcmpl_affinity_${turn}`,
+          object: 'chat.completion.chunk',
+          created: 0,
+          model: 'test-model',
+          choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+        },
+      ]),
+      modelKey: 'a',
+      headers: new Headers(),
+    };
+  });
+  const callB = vi.fn(async (): Promise<ProviderStreamResult<ChatCompletionsStreamEvent>> => {
+    throw new Error('affinity should have reordered candidate A before B');
+  });
+  const candidateA = makeCandidate({ upstream: 'up-a', callChatCompletions: callA });
+  const candidateB = makeCandidate({ upstream: 'up-b', callChatCompletions: callB });
+  queueCandidates([candidateA, candidateB]);
+
+  const first = await makeApp().request('/v1/chat/completions', {
+    method: 'POST',
+    headers: new Headers({ 'content-type': 'application/json' }),
+    body: JSON.stringify({ model: 'test-model', messages: [{ role: 'user', content: 'first' }] }),
+  });
+  const firstBody = await first.json() as { choices: Array<{ message: { content: string; reasoning_opaque: string } }> };
+  const assistant = firstBody.choices[0].message;
+  assert(assistant.reasoning_opaque !== 'opaque-a');
+
+  queueCandidates([candidateB, candidateA]);
+  const second = await makeApp().request('/v1/chat/completions', {
+    method: 'POST',
+    headers: new Headers({ 'content-type': 'application/json' }),
+    body: JSON.stringify({
+      model: 'test-model',
+      messages: [
+        { role: 'user', content: 'first' },
+        assistant,
+        { role: 'user', content: 'continue' },
+      ],
+    }),
+  });
+
+  assertEquals(second.status, 200);
+  assertEquals(callB.mock.calls.length, 0);
+  assertEquals(callA.mock.calls.length, 2);
+  assertEquals(observedBodies[1].messages?.[1].reasoning_opaque, 'opaque-a');
+});
+
 test('POST /v1/chat/completions omits the usage-only chunk unless stream_options.include_usage is set', async () => {
   installRepo();
   const callChatCompletions = vi.fn(async (): Promise<ProviderStreamResult<ChatCompletionsStreamEvent>> => ({
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/respond.ts b/packages/gateway/src/data-plane/chat/chat-completions/respond.ts
index c30a26392..64eafba1a 100644
--- a/packages/gateway/src/data-plane/chat/chat-completions/respond.ts
+++ b/packages/gateway/src/data-plane/chat/chat-completions/respond.ts
@@ -1,9 +1,11 @@
 import type { Context } from 'hono';
 import { streamSSE } from 'hono/streaming';
 
+import { wrapChatCompletionsAffinityEgress } from './affinity/egress.ts';
 import { tokenUsageFromChatCompletionsUsage } from './usage.ts';
 import { recordFailedRequest } from '../../shared/telemetry/performance.ts';
 import { settle } from '../../shared/telemetry/settle.ts';
+import { affinityEgressOptions } from '../shared/affinity/index.ts';
 import type { GatewayCtx } from '../shared/gateway-ctx.ts';
 import { SourceStreamState, eventResultMetadata, forwardUpstreamHeaders, mergeForwardedUpstreamHeaders, plainResultToResponse } from '../shared/respond.ts';
 import { type StreamCompletion, writeSSEFrames } from '../shared/stream/sse.ts';
@@ -40,7 +42,8 @@ export const respondChatCompletions = async (
   }
 
   const state = new SourceStreamState();
-  const frames = observeChatCompletionsFrames(result.events, state, wantsStream, ctx);
+  const observed = observeChatCompletionsFrames(result.events, state, wantsStream, ctx);
+  const frames = wrapChatCompletionsAffinityEgress(observed, affinityEgressOptions(ctx));
 
   if (!wantsStream) {
     try {
diff --git a/packages/gateway/src/data-plane/chat/chat-completions/serve.ts b/packages/gateway/src/data-plane/chat/chat-completions/serve.ts
index c2f7b2ba7..57439162c 100644
--- a/packages/gateway/src/data-plane/chat/chat-completions/serve.ts
+++ b/packages/gateway/src/data-plane/chat/chat-completions/serve.ts
@@ -1,14 +1,14 @@
+import { prepareChatCompletionsAffinity } from './affinity/ingress.ts';
 import { chatCompletionsAttempt, chatCompletionsTarget } from './attempt.ts';
 import { renderChatCompletionsFailure } from './errors.ts';
 import { enumerateModelCandidates } from '../../providers/registry.ts';
 import { iterateCandidates } from '../../shared/iterate-candidates.ts';
-import { classifyResponsesItemAffinity } from '../responses/items/affinity.ts';
+import { routeCandidatesByAffinity } from '../shared/affinity/index.ts';
 import { noViableCandidateFailure } from '../shared/errors.ts';
 import type { ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import type { ChatCompletionsPayload, ChatCompletionsStreamEvent } from '@floway-dev/protocols/chat-completions';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
 import type { ExecuteResult } from '@floway-dev/provider';
-import { chatCompletionsViaResponsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
 export interface ChatCompletionsServeGenerateArgs {
   readonly payload: ChatCompletionsPayload;
@@ -19,6 +19,7 @@ export interface ChatCompletionsServeGenerateArgs {
 export const chatCompletionsServe = {
   generate: async (args: ChatCompletionsServeGenerateArgs): Promise<ExecuteResult<ProtocolFrame<ChatCompletionsStreamEvent>>> => {
     const { payload, ctx, headers } = args;
+    const prepared = await prepareChatCompletionsAffinity(payload, ctx.affinity.codec);
     const { candidates: enumerated, sawModel, failedUpstreams } = await enumerateModelCandidates({
       upstreamIds: ctx.upstreamIds,
       model: payload.model,
@@ -27,12 +28,7 @@ export const chatCompletionsServe = {
       runtimeLocation: ctx.runtimeLocation,
     });
     const viable = enumerated.filter(c => chatCompletionsTarget.canServe(c.model.endpoints));
-    const decision = await classifyResponsesItemAffinity({
-      sourceItems: payload.messages,
-      view: chatCompletionsViaResponsesItemsView,
-      store: ctx.store,
-      candidates: viable,
-    });
+    const decision = routeCandidatesByAffinity(viable, prepared.routingEvidence);
     if (decision.kind === 'failure') return renderChatCompletionsFailure(decision.failure);
     if (decision.candidates.length === 0) return renderChatCompletionsFailure(noViableCandidateFailure(sawModel, payload.model, failedUpstreams));
 
@@ -49,7 +45,11 @@ export const chatCompletionsServe = {
       'chatCompletionsServe.generate',
       ctx,
       'chat',
-      candidate => chatCompletionsAttempt.generate({ payload, ctx, candidate, headers }),
+      async candidate => {
+        const result = await chatCompletionsAttempt.generate({ payload: prepared.payloadForCandidate(candidate), ctx, candidate, headers });
+        if (result.type === 'events') ctx.affinity.select(candidate);
+        return result;
+      },
     );
   },
 };
diff --git a/packages/gateway/src/data-plane/chat/gemini/affinity/egress.ts b/packages/gateway/src/data-plane/chat/gemini/affinity/egress.ts
new file mode 100644
index 000000000..f9dd393d5
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/gemini/affinity/egress.ts
@@ -0,0 +1,398 @@
+import type { AffinityEgressOptions } from '../../shared/affinity/index.ts';
+import { captureExtras, eventFrame, type ProtocolFrame, USAGE_BILLING } from '@floway-dev/protocols/common';
+import type { GeminiCandidate, GeminiPart, GeminiResult, GeminiStreamEvent } from '@floway-dev/protocols/gemini';
+
+interface CandidateState {
+  anchored: boolean;
+}
+
+const hasPartContent = (part: GeminiPart): boolean => {
+  const { text, thought: _thought, thoughtSignature: _signature, ...data } = part;
+  return (typeof text === 'string' && text.length > 0) || Object.keys(data).length > 0;
+};
+
+const sameLogicalElement = (left: GeminiPart, right: GeminiPart): boolean => {
+  if (left.text !== undefined || right.text !== undefined) {
+    return left.text !== undefined && right.text !== undefined && (left.thought === true) === (right.thought === true);
+  }
+  if (left.functionCall !== undefined || right.functionCall !== undefined) {
+    if (left.functionCall === undefined || right.functionCall === undefined) return false;
+    if (left.functionCall.id !== undefined && right.functionCall.id !== undefined) {
+      return left.functionCall.id === right.functionCall.id;
+    }
+    // Name/shape cannot distinguish a continuation from two adjacent complete
+    // id-less calls, so ambiguous or asymmetric-ID calls remain separate.
+    return false;
+  }
+  return false;
+};
+
+const logicalElementGroups = (parts: readonly GeminiPart[]): number[][] => {
+  const groups: number[][] = [];
+  let indexes: number[] = [];
+  let previousContent: GeminiPart | undefined;
+  const flush = () => {
+    if (indexes.length > 0) groups.push(indexes);
+    indexes = [];
+    previousContent = undefined;
+  };
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index];
+    if (!hasPartContent(part)) {
+      if (part.thoughtSignature !== undefined) indexes.push(index);
+      continue;
+    }
+    if (previousContent !== undefined && !sameLogicalElement(previousContent, part)) flush();
+    indexes.push(index);
+    previousContent = part;
+  }
+  flush();
+  return groups;
+};
+
+const firstElementIndexes = (parts: readonly GeminiPart[]): number[] =>
+  logicalElementGroups(parts).find(indexes => indexes.some(index => hasPartContent(parts[index]))) ?? [];
+
+const firstContentIndexOfLastElement = (parts: readonly GeminiPart[]): number | undefined =>
+  logicalElementGroups(parts)
+    .findLast(indexes => indexes.some(index => hasPartContent(parts[index])))
+    ?.find(index => hasPartContent(parts[index]));
+
+const firstContentPart = (parts: readonly GeminiPart[]): GeminiPart | undefined =>
+  parts.find(hasPartContent);
+
+const KNOWN_EVENT_KEYS = new Set(['candidates', 'usageMetadata', 'modelVersion', 'responseId']);
+const KNOWN_CANDIDATE_KEYS = new Set(['index', 'content', 'finishReason']);
+
+const mergeEventMetadata = (
+  earlier: GeminiResult,
+  later: GeminiResult,
+  target: GeminiResult,
+): void => {
+  const extras: Record<string, unknown> = {};
+  captureExtras(earlier as unknown as Record<string, unknown>, KNOWN_EVENT_KEYS, extras);
+  captureExtras(later as unknown as Record<string, unknown>, KNOWN_EVENT_KEYS, extras);
+  const usageMetadata = later.usageMetadata ?? earlier.usageMetadata;
+  const modelVersion = later.modelVersion ?? earlier.modelVersion;
+  const responseId = later.responseId ?? earlier.responseId;
+  for (const key of Object.keys(target)) if (key !== 'candidates') delete (target as Record<string, unknown>)[key];
+  Object.assign(target, {
+    ...(usageMetadata !== undefined ? { usageMetadata } : {}),
+    ...(modelVersion !== undefined ? { modelVersion } : {}),
+    ...(responseId !== undefined ? { responseId } : {}),
+    ...extras,
+  });
+};
+
+const clearEventMetadata = (event: GeminiResult): void => {
+  for (const key of Object.keys(event)) if (key !== 'candidates') delete (event as Record<string, unknown>)[key];
+};
+
+// Gemini pays one upstream event of TTFT/inter-event latency. Within one event
+// repeated snapshots collapse to one signature on the element's first
+// content-bearing Part; across events the window can move a late signature
+// back only onto the immediately preceding buffered chunk.
+// Repeating synthetic then natural signatures is unsafe: Vercel and Google ADK
+// retain the metadata captured when a streamed function call starts, while
+// LangChain Python concatenates same-index strings.
+// A sliding window holds only the newest same-element event until a signature
+// or boundary arrives; older visible events keep flowing without a signature.
+// https://github.com/vercel/ai/blob/2c080eae3da9294d992cae5df22c2d7e1d38b571/packages/google/src/google-language-model.ts#L638-L668
+// https://github.com/vercel/ai/blob/2c080eae3da9294d992cae5df22c2d7e1d38b571/packages/google/src/google-language-model.ts#L946-L962
+// https://github.com/google/adk-js/blob/ca2209b68c2fee3c84ea7d90e050ca2fe9951193/core/src/utils/streaming_utils.ts#L201-L215
+// https://github.com/langchain-ai/langchain/blob/7bf8fe22163e5dadce365169e2df6b91233de9c4/libs/core/langchain_core/utils/_merge.py#L6-L70
+// Signature-only Parts are also rejected from Go Chat history:
+// https://github.com/googleapis/go-genai/blob/dc282483e1a68eaeb64faa9fa9877dd4a7ad1887/chats.go#L49-L75
+// This deliberately favors direct GenAI Chat compatibility by moving an
+// immediate signature-only trailer onto content. Google ADK text aggregation
+// drops signature metadata when it combines text chunks, and a natural
+// function signature arriving more than one continuation after the first
+// chunk still cannot repair first-chunk-wins clients without buffering the
+// whole logical element.
+// https://github.com/google/adk-js/blob/ca2209b68c2fee3c84ea7d90e050ca2fe9951193/core/src/utils/streaming_utils.ts#L227-L250
+
+const removeRelocatedSignatureParts = (
+  candidate: GeminiCandidate,
+  relocated: ReadonlySet<GeminiPart>,
+  removedCandidates?: WeakSet<GeminiCandidate>,
+): void => {
+  candidate.content.parts = candidate.content.parts.filter(part =>
+    !relocated.has(part) || hasPartContent(part) || part.thoughtSignature !== undefined);
+  if (candidate.content.parts.length === 0) removedCandidates?.add(candidate);
+};
+
+const normalizeElementSignature = (parts: GeminiPart[], indexes: readonly number[]): void => {
+  const signatures = indexes.flatMap(index => {
+    const signature = parts[index].thoughtSignature;
+    return signature === undefined ? [] : [signature];
+  });
+  if (signatures.length === 0) return;
+  const targetIndex = indexes.find(index => hasPartContent(parts[index])) ?? indexes.at(-1);
+  if (targetIndex === undefined) throw new Error('Gemini signature group has no target Part');
+  for (const index of indexes) delete parts[index].thoughtSignature;
+  parts[targetIndex].thoughtSignature = signatures[signatures.length - 1];
+};
+
+const normalizeElementSignatures = (candidate: GeminiCandidate): void => {
+  const parts = candidate.content.parts;
+  const signatureParts = new Set(parts.filter(part => part.thoughtSignature !== undefined));
+  for (const indexes of logicalElementGroups(parts)) normalizeElementSignature(parts, indexes);
+  removeRelocatedSignatureParts(candidate, signatureParts);
+};
+
+const mergeCandidateExtras = (
+  earlier: GeminiCandidate,
+  later: GeminiCandidate,
+  target: GeminiCandidate,
+): void => {
+  const extras: Record<string, unknown> = {};
+  captureExtras(earlier as unknown as Record<string, unknown>, KNOWN_CANDIDATE_KEYS, extras);
+  captureExtras(later as unknown as Record<string, unknown>, KNOWN_CANDIDATE_KEYS, extras);
+  for (const key of Object.keys(target)) {
+    if (!KNOWN_CANDIDATE_KEYS.has(key)) delete (target as unknown as Record<string, unknown>)[key];
+  }
+  Object.assign(target, extras);
+};
+
+const transferCandidateMetadata = (current: GeminiCandidate, next: GeminiCandidate): void => {
+  mergeCandidateExtras(current, next, current);
+  if (next.content.role !== undefined) current.content.role = next.content.role;
+  if (next.finishReason !== undefined) current.finishReason = next.finishReason;
+};
+
+const transferCandidateMetadataForward = (current: GeminiCandidate, next: GeminiCandidate): void => {
+  mergeCandidateExtras(current, next, next);
+  if (next.content.role === undefined && current.content.role !== undefined) next.content.role = current.content.role;
+};
+
+const relocateSignatureOnlyForward = (
+  current: GeminiCandidate,
+  next: GeminiCandidate | undefined,
+  removedCandidates: WeakSet<GeminiCandidate>,
+): void => {
+  if (
+    next === undefined
+    || current.finishReason !== undefined
+    || current.content.parts.some(hasPartContent)
+  ) return;
+  const relocated = new Set(current.content.parts.filter(part => part.thoughtSignature !== undefined));
+  const signature = relocated.values().next().value?.thoughtSignature;
+  const targetIndex = firstElementIndexes(next.content.parts).find(index => hasPartContent(next.content.parts[index]));
+  if (signature === undefined || targetIndex === undefined) return;
+  if (next.content.parts[targetIndex].thoughtSignature === undefined) {
+    next.content.parts[targetIndex].thoughtSignature = signature;
+  }
+  for (const part of relocated) delete part.thoughtSignature;
+  removeRelocatedSignatureParts(current, relocated, removedCandidates);
+  if (current.content.parts.length === 0) transferCandidateMetadataForward(current, next);
+};
+
+const relocateSignatureOnlyBackward = (
+  current: GeminiCandidate,
+  next: GeminiCandidate | undefined,
+  removedCandidates: WeakSet<GeminiCandidate>,
+): void => {
+  if (
+    next === undefined
+    || current.finishReason !== undefined
+    || next.content.parts.some(hasPartContent)
+  ) return;
+  const targetIndex = firstContentIndexOfLastElement(current.content.parts);
+  if (targetIndex === undefined) return;
+  const signatureOnly = next.content.parts.find(part => part.thoughtSignature !== undefined);
+  if (signatureOnly?.thoughtSignature === undefined) return;
+
+  current.content.parts[targetIndex] = {
+    ...current.content.parts[targetIndex],
+    thoughtSignature: signatureOnly.thoughtSignature,
+  };
+  delete signatureOnly.thoughtSignature;
+  removeRelocatedSignatureParts(next, new Set([signatureOnly]), removedCandidates);
+  if (next.content.parts.length === 0) {
+    transferCandidateMetadata(current, next);
+    delete next.finishReason;
+  }
+};
+
+const relocateContinuationSignature = (
+  current: GeminiCandidate,
+  next: GeminiCandidate | undefined,
+): void => {
+  if (next === undefined || current.finishReason !== undefined) return;
+  const targetIndex = firstContentIndexOfLastElement(current.content.parts);
+  const nextPart = firstContentPart(next.content.parts);
+  if (
+    targetIndex === undefined
+    || nextPart?.thoughtSignature === undefined
+    || !sameLogicalElement(current.content.parts[targetIndex], nextPart)
+  ) return;
+  current.content.parts[targetIndex] = {
+    ...current.content.parts[targetIndex],
+    thoughtSignature: nextPart.thoughtSignature,
+  };
+  delete nextPart.thoughtSignature;
+};
+
+const wrapEvent = async (
+  current: GeminiResult,
+  next: GeminiResult | undefined,
+  states: Map<number, CandidateState>,
+  suppressed: WeakSet<object>,
+  options: AffinityEgressOptions,
+  allowSynthetic: boolean,
+): Promise<GeminiResult> => {
+  const currentHadCandidates = (current.candidates?.length ?? 0) > 0;
+  const nextHadCandidates = (next?.candidates?.length ?? 0) > 0;
+  const removedCandidates = new WeakSet<GeminiCandidate>();
+
+  for (const candidate of current.candidates ?? []) {
+    const state = states.get(candidate.index) ?? { anchored: false };
+    states.set(candidate.index, state);
+
+    const nextCandidate = next?.candidates?.find(nextCandidate => nextCandidate.index === candidate.index);
+    normalizeElementSignatures(candidate);
+    if (nextCandidate !== undefined) normalizeElementSignatures(nextCandidate);
+    relocateSignatureOnlyForward(candidate, nextCandidate, removedCandidates);
+    relocateSignatureOnlyBackward(candidate, nextCandidate, removedCandidates);
+    relocateContinuationSignature(candidate, nextCandidate);
+    const firstIndexes = firstElementIndexes(candidate.content.parts);
+    const firstHasNatural = firstIndexes.some(index => candidate.content.parts[index].thoughtSignature !== undefined);
+    const signatureOnlyNatural = firstIndexes.length === 0
+      && candidate.content.parts.some(part => part.thoughtSignature !== undefined);
+    const firstContentIndex = firstIndexes.find(index => hasPartContent(candidate.content.parts[index]));
+    const lastFirstContentIndex = firstIndexes.findLast(index => hasPartContent(candidate.content.parts[index]));
+    const firstContent = lastFirstContentIndex === undefined ? undefined : candidate.content.parts[lastFirstContentIndex];
+    const nextContent = nextCandidate === undefined ? undefined : firstContentPart(nextCandidate.content.parts);
+    const continuesInNextEvent = firstContent !== undefined
+      && nextContent !== undefined
+      && sameLogicalElement(firstContent, nextContent);
+    const startsAnotherElementInCurrentEvent = lastFirstContentIndex !== undefined
+      && candidate.content.parts.slice(lastFirstContentIndex + 1).some(hasPartContent);
+    const firstElementClosed = startsAnotherElementInCurrentEvent
+      || candidate.finishReason !== undefined
+      || (next !== undefined && nextCandidate === undefined)
+      || (nextCandidate !== undefined && nextContent === undefined && !removedCandidates.has(nextCandidate))
+      || (nextCandidate !== undefined && nextContent !== undefined && !continuesInNextEvent)
+      || (next === undefined && allowSynthetic);
+
+    for (const part of candidate.content.parts) {
+      if (part.thoughtSignature === undefined) continue;
+      part.thoughtSignature = await options.codec.wrap(part.thoughtSignature, options.affinity, 'gemini.part.thoughtSignature');
+    }
+
+    if (!state.anchored) {
+      if (firstHasNatural || signatureOnlyNatural) {
+        state.anchored = true;
+      } else if (firstContentIndex !== undefined && firstElementClosed) {
+        candidate.content.parts[firstContentIndex] = {
+          ...candidate.content.parts[firstContentIndex],
+          thoughtSignature: await options.codec.wrap(undefined, options.affinity, 'gemini.part.thoughtSignature'),
+        };
+        state.anchored = true;
+      } else if (candidate.finishReason !== undefined) {
+        candidate.content.parts.push({
+          thoughtSignature: await options.codec.wrap(
+            undefined,
+            { ...options.affinity, syntheticItem: true },
+            'gemini.part.thoughtSignature',
+          ),
+        });
+        state.anchored = true;
+      }
+    }
+
+  }
+
+  if (next?.candidates !== undefined) {
+    next.candidates = next.candidates.filter(candidate => !removedCandidates.has(candidate));
+  }
+  if (current.candidates !== undefined) {
+    current.candidates = current.candidates.filter(candidate => !removedCandidates.has(candidate));
+  }
+  const currentEmptied = currentHadCandidates && current.candidates?.length === 0;
+  const nextEmptied = nextHadCandidates && next?.candidates?.length === 0;
+  if (currentEmptied && next !== undefined && !nextEmptied) {
+    mergeEventMetadata(current, next, next);
+    clearEventMetadata(current);
+    suppressed.add(current);
+  } else if (nextEmptied && next !== undefined && !currentEmptied) {
+    mergeEventMetadata(current, next, current);
+    clearEventMetadata(next);
+    suppressed.add(next);
+  }
+  return current;
+};
+
+const cloneGeminiEvent = (event: GeminiResult): GeminiResult => {
+  const cloned = structuredClone(event);
+  const billing = event.usageMetadata?.[USAGE_BILLING];
+  if (billing === undefined) return cloned;
+  if (cloned.usageMetadata === undefined) {
+    throw new Error('Gemini usage billing metadata lost its usage container during affinity cloning');
+  }
+  cloned.usageMetadata[USAGE_BILLING] = structuredClone(billing);
+  return cloned;
+};
+
+export const wrapGeminiAffinityEgress = async function* (
+  frames: AsyncIterable<ProtocolFrame<GeminiStreamEvent>>,
+  options: AffinityEgressOptions,
+): AsyncGenerator<ProtocolFrame<GeminiStreamEvent>> {
+  const states = new Map<number, CandidateState>();
+  const suppressed = new WeakSet<object>();
+  let pending: GeminiResult | undefined;
+  const iterator = frames[Symbol.asyncIterator]();
+  let sourceCompleted = false;
+
+  try {
+    while (true) {
+      let result: IteratorResult<ProtocolFrame<GeminiStreamEvent>>;
+      try {
+        result = await iterator.next();
+      } catch (error) {
+        if (pending !== undefined) {
+          const wrapped = await wrapEvent(pending, undefined, states, suppressed, options, false);
+          if (!suppressed.has(wrapped)) yield eventFrame(wrapped);
+          pending = undefined;
+        }
+        throw error;
+      }
+      if (result.done) {
+        sourceCompleted = true;
+        break;
+      }
+      const frame = result.value;
+      if (frame.type !== 'event') {
+        if (pending !== undefined) {
+          const wrapped = await wrapEvent(pending, undefined, states, suppressed, options, frame.type === 'done');
+          if (!suppressed.has(wrapped)) yield eventFrame(wrapped);
+          pending = undefined;
+        }
+        yield frame;
+        continue;
+      }
+      if ('error' in frame.event) {
+        if (pending !== undefined) {
+          const wrapped = await wrapEvent(pending, undefined, states, suppressed, options, false);
+          if (!suppressed.has(wrapped)) yield eventFrame(wrapped);
+        }
+        yield frame;
+        return;
+      }
+
+      const next = cloneGeminiEvent(frame.event);
+      if (pending !== undefined) {
+        const wrapped = await wrapEvent(pending, next, states, suppressed, options, true);
+        if (!suppressed.has(wrapped)) yield eventFrame(wrapped);
+      }
+      pending = next;
+    }
+  } finally {
+    if (!sourceCompleted) await iterator.return?.();
+  }
+
+  if (pending !== undefined) {
+    const wrapped = await wrapEvent(pending, undefined, states, suppressed, options, false);
+    if (!suppressed.has(wrapped)) yield eventFrame(wrapped);
+  }
+};
diff --git a/packages/gateway/src/data-plane/chat/gemini/affinity/egress_test.ts b/packages/gateway/src/data-plane/chat/gemini/affinity/egress_test.ts
new file mode 100644
index 000000000..8b61ed456
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/gemini/affinity/egress_test.ts
@@ -0,0 +1,522 @@
+import { describe, expect, test, vi } from 'vitest';
+
+import { wrapGeminiAffinityEgress } from './egress.ts';
+import type { AffinityCodec, AffinityTarget } from '../../shared/affinity/index.ts';
+import { eventFrame, type ProtocolFrame, USAGE_BILLING } from '@floway-dev/protocols/common';
+import type { GeminiCandidate, GeminiStreamEvent } from '@floway-dev/protocols/gemini';
+
+const affinity: AffinityTarget = {
+  upstreamId: 'up-a',
+  modelId: 'model-a',
+};
+
+type AffinityEgressCodec = Pick<AffinityCodec, 'wrap'>;
+
+const frames = async function* (values: ProtocolFrame<GeminiStreamEvent>[]) {
+  yield* values;
+};
+
+const withCandidateExtra = (candidate: GeminiCandidate, key: string, value: unknown): GeminiCandidate =>
+  Object.assign(candidate, { [key]: value });
+
+class DelayedCodec implements AffinityEgressCodec {
+  readonly calls: Array<{ value: string | undefined; resolve: (value: string) => void }> = [];
+
+  wrap(value: string | undefined): Promise<string> {
+    return new Promise(resolve => this.calls.push({ value, resolve }));
+  }
+}
+
+const immediateCodec: AffinityEgressCodec = {
+  wrap: async value => `wrapped:${value ?? 'synthetic'}`,
+};
+
+describe('Gemini affinity egress', () => {
+  test('buffers one event and wraps a natural signature on its content-bearing part', async () => {
+    const codec = new DelayedCodec();
+    const output = wrapGeminiAffinityEgress(frames([eventFrame({
+      candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ text: 'visible', thoughtSignature: 'opaque' }] },
+        finishReason: 'STOP',
+      }],
+      usageMetadata: { totalTokenCount: 2 },
+    })]), { codec, affinity })[Symbol.asyncIterator]();
+
+    const pending = output.next();
+    await vi.waitFor(() => expect(codec.calls.map(call => call.value)).toEqual(['opaque']));
+    codec.calls[0].resolve('wrapped-opaque');
+    expect((await pending).value).toEqual(eventFrame({
+      candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ text: 'visible', thoughtSignature: 'wrapped-opaque' }] },
+        finishReason: 'STOP',
+      }],
+      usageMetadata: { totalTokenCount: 2 },
+    }));
+  });
+
+  test('attaches synthetic affinity to the first content-bearing part of every candidate', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([eventFrame({
+      candidates: [
+        { index: 0, content: { role: 'model', parts: [{ text: 'a' }] }, finishReason: 'STOP' },
+        { index: 1, content: { role: 'model', parts: [{ functionCall: { name: 'tool', args: {} } }] }, finishReason: 'MAX_TOKENS' },
+      ],
+    })]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toEqual([eventFrame({
+      candidates: [
+        { index: 0, content: { role: 'model', parts: [{ text: 'a', thoughtSignature: 'wrapped:synthetic' }] }, finishReason: 'STOP' },
+        {
+          index: 1,
+          content: { role: 'model', parts: [{ functionCall: { name: 'tool', args: {} }, thoughtSignature: 'wrapped:synthetic' }] },
+          finishReason: 'MAX_TOKENS',
+        },
+      ],
+    })]);
+  });
+
+  test('moves an immediate signature-only trailer onto the buffered content event', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'visible' }] } }] }),
+      eventFrame({
+        candidates: [{ index: 0, content: { role: 'model', parts: [{ thoughtSignature: 'natural' }] }, finishReason: 'STOP' }],
+        usageMetadata: { totalTokenCount: 2 },
+      }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toEqual(eventFrame({
+      candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ text: 'visible', thoughtSignature: 'wrapped:natural' }] },
+        finishReason: 'STOP',
+      }],
+      usageMetadata: { totalTokenCount: 2 },
+    }));
+    expect(output).toHaveLength(1);
+  });
+
+  test.each([
+    { text: '', thoughtSignature: 'natural' },
+    { thought: true, thoughtSignature: 'natural' },
+  ])('treats an empty signature trailer as metadata rather than visible content', async trailer => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'visible' }] } }] }),
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [trailer] }, finishReason: 'STOP' }] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ text: 'visible', thoughtSignature: 'wrapped:natural' }] }, finishReason: 'STOP' }] },
+    });
+    expect(output).toHaveLength(1);
+  });
+
+  test('moves an immediate continuation signature onto the buffered function-call event', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ functionCall: { id: 'call', name: 'tool', args: { a: 1 } } }] } }] }),
+      eventFrame({
+        candidates: [{
+          index: 0,
+          content: { role: 'model', parts: [{ functionCall: { id: 'call', name: 'tool', args: { b: 2 } }, thoughtSignature: 'natural' }] },
+          finishReason: 'STOP',
+        }],
+      }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ thoughtSignature: 'wrapped:natural' }] } }] },
+    });
+    expect(output[1]).not.toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: expect.anything() }] } }] } });
+  });
+
+  test('slides one-event lookahead until a later natural signature closes the same element', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'a' }] } }] }),
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'b' }] } }] }),
+      eventFrame({
+        candidates: [{
+          index: 0,
+          content: { role: 'model', parts: [{ text: 'c', thoughtSignature: 'natural' }] },
+          finishReason: 'STOP',
+        }],
+      }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).not.toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: expect.anything() }] } }] } });
+    expect(output[1]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ text: 'b', thoughtSignature: 'wrapped:natural' }] } }] },
+    });
+    expect(output[2]).not.toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: expect.anything() }] } }] } });
+  });
+
+  test('slides one-event lookahead to finish before synthesizing without a natural signature', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'a' }] } }] }),
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'b' }] } }] }),
+      eventFrame({
+        candidates: [{
+          index: 0,
+          content: { role: 'model', parts: [{ text: 'c' }] },
+          finishReason: 'STOP',
+        }],
+      }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).not.toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: expect.anything() }] } }] } });
+    expect(output[1]).not.toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: expect.anything() }] } }] } });
+    expect(output[2]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ text: 'c', thoughtSignature: 'wrapped:synthetic' }] }, finishReason: 'STOP' }] },
+    });
+  });
+
+  test.each([
+    [
+      { text: 'a', thoughtSignature: 'old' },
+      { text: 'b', thoughtSignature: 'latest' },
+    ],
+    [
+      { functionCall: { id: 'call', name: 'tool', args: { a: 1 } }, thoughtSignature: 'old' },
+      { functionCall: { id: 'call', name: 'tool', args: { b: 2 } }, thoughtSignature: 'latest' },
+    ],
+    [
+      { text: 'a', thoughtSignature: 'old' },
+      { thoughtSignature: 'latest' },
+    ],
+  ])('keeps one latest signature for repeated snapshots in the same event', async (first, second) => {
+    const parts = [first, second];
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([eventFrame({
+      candidates: [{ index: 0, content: { role: 'model', parts }, finishReason: 'STOP' }],
+    })]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    const signatures = JSON.stringify(output).match(/wrapped:(?:old|latest)/g);
+    expect(signatures).toEqual(['wrapped:latest']);
+  });
+
+  test('normalizes signatures independently for every logical element in one event', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([eventFrame({
+      candidates: [{
+        index: 0,
+        content: {
+          role: 'model',
+          parts: [
+            { text: 'answer' },
+            { functionCall: { id: 'call', name: 'tool', args: { a: 1 } }, thoughtSignature: 'function-old' },
+            { functionCall: { id: 'call', name: 'tool', args: { b: 2 } }, thoughtSignature: 'function-latest' },
+            { text: 'explanation', thought: true, thoughtSignature: 'text-old' },
+            { text: 'continued', thought: true, thoughtSignature: 'text-latest' },
+          ],
+        },
+        finishReason: 'STOP',
+      }],
+    })]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    const event = output[0].type === 'event' && !('error' in output[0].event) ? output[0].event : undefined;
+    expect(event?.candidates?.[0].content.parts).toEqual([
+      { text: 'answer', thoughtSignature: 'wrapped:synthetic' },
+      { functionCall: { id: 'call', name: 'tool', args: { a: 1 } }, thoughtSignature: 'wrapped:function-latest' },
+      { functionCall: { id: 'call', name: 'tool', args: { b: 2 } } },
+      { text: 'explanation', thought: true, thoughtSignature: 'wrapped:text-latest' },
+      { text: 'continued', thought: true },
+    ]);
+  });
+
+  test('places the latest signature on the first Part of a repeated function-call element', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([eventFrame({
+      candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [
+          { functionCall: { id: 'call', name: 'tool', args: { a: 1 } }, thoughtSignature: 'old' },
+          { functionCall: { id: 'call', name: 'tool', args: { b: 2 } }, thoughtSignature: 'latest' },
+        ] },
+        finishReason: 'STOP',
+      }],
+    })]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    const event = output[0].type === 'event' && !('error' in output[0].event) ? output[0].event : undefined;
+    const parts = event?.candidates?.[0].content.parts;
+    expect(parts?.[0]).toMatchObject({ thoughtSignature: 'wrapped:latest' });
+    expect(parts?.[1]).not.toHaveProperty('thoughtSignature');
+  });
+
+  test('moves the latest replacement from a signature-only lookahead', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'visible' }] } }] }),
+      eventFrame({ candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ thoughtSignature: 'old' }, { thoughtSignature: 'latest' }] },
+        finishReason: 'STOP',
+      }] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ thoughtSignature: 'wrapped:latest' }] }, finishReason: 'STOP' }] },
+    });
+    expect(JSON.stringify(output).match(/wrapped:(?:old|latest)/g)).toEqual(['wrapped:latest']);
+  });
+
+  test.each([
+    { text: 'answer' },
+    { functionCall: { id: 'call', name: 'tool', args: {} } },
+  ])('moves a leading signature-only event forward onto the first content Part', async contentPart => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ thoughtSignature: 'natural' }] } }] }),
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [contentPart] }, finishReason: 'STOP' }] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toHaveLength(1);
+    expect(output[0]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ thoughtSignature: 'wrapped:natural' }] }, finishReason: 'STOP' }] },
+    });
+  });
+
+  test('moves event metadata forward when suppressing a leading signature event', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({
+        candidates: [withCandidateExtra(
+          { index: 0, content: { role: 'model', parts: [{ thoughtSignature: 'natural' }] } },
+          'vendor_text',
+          'early-',
+        )],
+        modelVersion: 'model-v1',
+      }),
+      eventFrame({
+        candidates: [withCandidateExtra(
+          { index: 0, content: { role: 'model', parts: [{ text: 'answer' }] }, finishReason: 'STOP' },
+          'vendor_text',
+          'late',
+        )],
+        responseId: 'response-1',
+      }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toHaveLength(1);
+    expect(output[0]).toMatchObject({
+      event: {
+        modelVersion: 'model-v1',
+        responseId: 'response-1',
+        candidates: [{
+          vendor_text: 'early-late',
+          content: { parts: [{ text: 'answer', thoughtSignature: 'wrapped:natural' }] },
+        }],
+      },
+    });
+  });
+
+  test('merges candidate extension metadata backward from a suppressed trailer', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [withCandidateExtra(
+        { index: 0, content: { role: 'model', parts: [{ text: 'answer' }] } },
+        'vendor_text',
+        'early-',
+      )] }),
+      eventFrame({ candidates: [withCandidateExtra(
+        { index: 0, content: { role: 'model', parts: [{ thoughtSignature: 'natural' }] }, finishReason: 'STOP' },
+        'vendor_text',
+        'late',
+      )] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toHaveLength(1);
+    expect(output[0]).toMatchObject({ event: { candidates: [{ vendor_text: 'early-late' }] } });
+  });
+
+  test('keeps a leading signature with the different element that follows it', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'answer' }] } }] }),
+      eventFrame({ candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [
+          { thoughtSignature: 'natural' },
+          { functionCall: { id: 'call', name: 'tool', args: {} } },
+        ] },
+        finishReason: 'STOP',
+      }] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ text: 'answer', thoughtSignature: 'wrapped:synthetic' }] } }] },
+    });
+    expect(output[1]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ functionCall: { id: 'call' }, thoughtSignature: 'wrapped:natural' }] } }] },
+    });
+  });
+
+  test('preserves a native empty candidate as an element boundary', async () => {
+    const empty = withCandidateExtra(
+      { index: 0, content: { role: 'model', parts: [] } },
+      'vendor_empty',
+      true,
+    );
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'first' }] } }] }),
+      eventFrame({ candidates: [empty] }),
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'second' }] }, finishReason: 'STOP' }] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toHaveLength(3);
+    expect(output[0]).toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: 'wrapped:synthetic' }] } }] } });
+    expect(output[1]).toMatchObject({ event: { candidates: [{ vendor_empty: true, content: { parts: [] } }] } });
+    expect(output[2]).not.toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: expect.anything() }] } }] } });
+  });
+
+  test('preserves native empty Parts when adding a standalone fallback carrier', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([eventFrame({
+      candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ text: '' }, { thought: true }] },
+        finishReason: 'STOP',
+      }],
+    })]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({ event: { candidates: [{ content: { parts: [
+      { text: '' },
+      { thought: true },
+      { thoughtSignature: 'wrapped:synthetic' },
+    ] } }] } });
+  });
+
+  test('keeps a natural signature-only finishing candidate as its anchor', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([eventFrame({
+      candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ thoughtSignature: 'old' }, { thoughtSignature: 'latest' }] },
+        finishReason: 'STOP',
+      }],
+    })]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toEqual([eventFrame({
+      candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ thoughtSignature: 'wrapped:latest' }] },
+        finishReason: 'STOP',
+      }],
+    })]);
+  });
+
+  test('preserves the role when folding a signature-only terminal candidate', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { parts: [{ text: 'visible' }] } }] }),
+      eventFrame({
+        candidates: [{
+          index: 0,
+          content: { role: 'model', parts: [{ thoughtSignature: 'natural' }] },
+          finishReason: 'STOP',
+        }],
+      }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toEqual(eventFrame({
+      candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ text: 'visible', thoughtSignature: 'wrapped:natural' }] },
+        finishReason: 'STOP',
+      }],
+    }));
+  });
+
+  test('treats an absent candidate as a boundary before an interleaved candidate', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'a' }] } }] }),
+      eventFrame({ candidates: [{ index: 1, content: { role: 'model', parts: [{ text: 'b' }] } }] }),
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'c', thoughtSignature: 'natural' }] }, finishReason: 'STOP' }] }),
+      eventFrame({ candidates: [{ index: 1, content: { role: 'model', parts: [{ text: 'd' }] }, finishReason: 'STOP' }] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({ event: { candidates: [{ index: 0, content: { parts: [{ thoughtSignature: 'wrapped:synthetic' }] } }] } });
+    expect(output[1]).toMatchObject({ event: { candidates: [{ index: 1, content: { parts: [{ thoughtSignature: 'wrapped:synthetic' }] } }] } });
+    expect(output[2]).toMatchObject({ event: { candidates: [{ index: 0, content: { parts: [{ thoughtSignature: 'wrapped:natural' }] } }] } });
+  });
+
+  test('does not merge adjacent complete same-name function calls without IDs', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ functionCall: { name: 'tool', args: { a: 1 } } }] } }] }),
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ functionCall: { name: 'tool', args: { b: 2 } }, thoughtSignature: 'natural' }] }, finishReason: 'STOP' }] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: 'wrapped:synthetic' }] } }] } });
+    expect(output[1]).toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: 'wrapped:natural' }] } }] } });
+  });
+
+  test('does not merge a same-name function call when only the earlier call has an ID', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ functionCall: { id: 'first', name: 'tool', args: { a: 1 } } }] },
+      }] }),
+      eventFrame({ candidates: [{
+        index: 0,
+        content: { role: 'model', parts: [{ functionCall: { name: 'tool', args: { b: 2 } }, thoughtSignature: 'natural' }] },
+        finishReason: 'STOP',
+      }] }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: 'wrapped:synthetic' }] } }] } });
+    expect(output[1]).toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: 'wrapped:natural' }] } }] } });
+  });
+
+  test('synthesizes on the buffered first element when the lookahead starts a different element', async () => {
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([
+      eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'answer' }] } }] }),
+      eventFrame({
+        candidates: [{
+          index: 0,
+          content: { role: 'model', parts: [{ functionCall: { name: 'tool', args: {} } }] },
+          finishReason: 'STOP',
+        }],
+      }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toMatchObject({
+      event: { candidates: [{ content: { parts: [{ text: 'answer', thoughtSignature: 'wrapped:synthetic' }] } }] },
+    });
+    expect(output[1]).not.toMatchObject({ event: { candidates: [{ content: { parts: [{ thoughtSignature: expect.anything() }] } }] } });
+  });
+
+  test('preserves usage billing metadata through the event clone', async () => {
+    const billing = { cacheWriteTokenCount: 3, serviceTier: 'priority' };
+    const output: ProtocolFrame<GeminiStreamEvent>[] = [];
+    for await (const frame of wrapGeminiAffinityEgress(frames([eventFrame({
+      candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'answer' }] }, finishReason: 'STOP' }],
+      usageMetadata: { totalTokenCount: 4, [USAGE_BILLING]: billing },
+    })]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    const event = output[0].type === 'event' && !('error' in output[0].event) ? output[0].event : undefined;
+    expect(event?.usageMetadata?.[USAGE_BILLING]).toEqual(billing);
+    expect(event?.usageMetadata?.[USAGE_BILLING]).not.toBe(billing);
+  });
+
+  test('flushes pending visible content before propagating an iterator failure', async () => {
+    const source = async function* (): AsyncGenerator<ProtocolFrame<GeminiStreamEvent>> {
+      yield eventFrame({ candidates: [{ index: 0, content: { role: 'model', parts: [{ text: 'visible' }] } }] });
+      throw new Error('upstream failed');
+    };
+    const iterator = wrapGeminiAffinityEgress(source(), { codec: immediateCodec, affinity })[Symbol.asyncIterator]();
+
+    await expect(iterator.next()).resolves.toMatchObject({
+      value: { event: { candidates: [{ content: { parts: [{ text: 'visible' }] } }] } },
+    });
+    await expect(iterator.next()).rejects.toThrow('upstream failed');
+  });
+});
diff --git a/packages/gateway/src/data-plane/chat/gemini/affinity/ingress.ts b/packages/gateway/src/data-plane/chat/gemini/affinity/ingress.ts
new file mode 100644
index 000000000..bd6e3e956
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/gemini/affinity/ingress.ts
@@ -0,0 +1,63 @@
+import { type AffinityCodec, blobForExactCandidate, preferredAffinityEvidence, type DecodedAffinityBlob, type PreparedAffinityPayload } from '../../shared/affinity/index.ts';
+import type { GeminiPart, GeminiPayload } from '@floway-dev/protocols/gemini';
+
+interface GeminiBlobLocation {
+  readonly contentIndex: number;
+  readonly partIndex: number;
+  readonly decoded: DecodedAffinityBlob;
+}
+
+const visiblePart = (part: GeminiPart): boolean => {
+  const { text, thought: _thought, thoughtSignature: _signature, ...data } = part;
+  return (typeof text === 'string' && text.length > 0) || Object.keys(data).length > 0;
+};
+
+export const prepareGeminiAffinity = async (
+  payload: GeminiPayload,
+  codec: AffinityCodec,
+): Promise<PreparedAffinityPayload<GeminiPayload>> => {
+  const locations: GeminiBlobLocation[] = [];
+  for (const [contentIndex, content] of (payload.contents ?? []).entries()) {
+    if (content.role !== 'model') continue;
+    for (const [partIndex, part] of content.parts.entries()) {
+      if (typeof part.thoughtSignature !== 'string') continue;
+      locations.push({ contentIndex, partIndex, decoded: await codec.unwrap(part.thoughtSignature, 'gemini.part.thoughtSignature') });
+    }
+  }
+
+  return {
+    routingEvidence: preferredAffinityEvidence(locations.map(location => location.decoded)),
+    payloadForCandidate: candidate => {
+      const candidatePayload = structuredClone(payload);
+      if (candidatePayload.contents === undefined) return candidatePayload;
+      const byContent = Map.groupBy(locations, location => location.contentIndex);
+      const emptiedByAffinity = new Set<number>();
+      for (const [contentIndex, contentLocations] of byContent) {
+        const content = candidatePayload.contents[contentIndex];
+        const replacements = new Map<number, GeminiPart | null>();
+        for (const location of contentLocations) {
+          const part = content.parts[location.partIndex];
+          const selected = blobForExactCandidate(location.decoded, candidate);
+          if (location.decoded.kind === 'foreign') continue;
+          const affinity = location.decoded.envelope.affinity;
+          if (affinity.syntheticItem === true) {
+            replacements.set(location.partIndex, null);
+          } else if (selected.present) {
+            replacements.set(location.partIndex, { ...part, thoughtSignature: selected.value });
+          } else {
+            const replacement = { ...part };
+            delete replacement.thoughtSignature;
+            replacements.set(location.partIndex, visiblePart(replacement) ? replacement : null);
+          }
+        }
+        content.parts = content.parts.flatMap((part, partIndex) => {
+          const replacement = replacements.get(partIndex);
+          return replacement === undefined ? [part] : replacement === null ? [] : [replacement];
+        });
+        if (content.parts.length === 0) emptiedByAffinity.add(contentIndex);
+      }
+      candidatePayload.contents = candidatePayload.contents.filter((_content, contentIndex) => !emptiedByAffinity.has(contentIndex));
+      return candidatePayload;
+    },
+  };
+};
diff --git a/packages/gateway/src/data-plane/chat/gemini/affinity/ingress_test.ts b/packages/gateway/src/data-plane/chat/gemini/affinity/ingress_test.ts
new file mode 100644
index 000000000..f04d61269
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/gemini/affinity/ingress_test.ts
@@ -0,0 +1,64 @@
+import { expect, test } from 'vitest';
+
+import { prepareGeminiAffinity } from './ingress.ts';
+import { AffinityCodec, type AffinityTarget } from '../../shared/affinity/index.ts';
+import type { ModelCandidate } from '@floway-dev/provider';
+import { stubModelCandidate } from '@floway-dev/test-utils';
+
+const codec = new AffinityCodec('22'.repeat(32));
+
+const candidate = (upstream: string): ModelCandidate => {
+  const base = stubModelCandidate();
+  return stubModelCandidate({
+    provider: { ...base.provider, upstream },
+    model: { id: 'model' },
+  });
+};
+
+const targetFor = (value: ModelCandidate): AffinityTarget => ({
+  upstreamId: value.provider.upstream,
+  modelId: value.model.id,
+  ...(value.rules !== undefined ? { rules: value.rules } : {}),
+});
+
+const candidateA = candidate('upstream-a');
+const candidateB = candidate('upstream-b');
+
+test('removes a synthetic signature-only part and preserves foreign signatures', async () => {
+  const synthetic = await codec.wrap(undefined, targetFor(candidateA), 'gemini.part.thoughtSignature');
+  const prepared = await prepareGeminiAffinity({
+    contents: [{
+      role: 'model',
+      parts: [
+        { text: 'answer' },
+        { thoughtSignature: synthetic },
+        { text: 'foreign', thoughtSignature: 'not-floway' },
+      ],
+    }],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateA).contents?.[0].parts).toEqual([
+    { text: 'answer' },
+    { text: 'foreign', thoughtSignature: 'not-floway' },
+  ]);
+});
+
+test.each([
+  { text: '' },
+  { thought: true },
+])('removes metadata-only remnants after stripping an incompatible owned signature', async metadata => {
+  const owned = await codec.wrap('natural', targetFor(candidateA), 'gemini.part.thoughtSignature');
+  const prepared = await prepareGeminiAffinity({
+    contents: [{ role: 'model', parts: [{ ...metadata, thoughtSignature: owned }] }],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateB).contents).toEqual([]);
+});
+
+test('preserves unrelated empty model contents', async () => {
+  const prepared = await prepareGeminiAffinity({
+    contents: [{ role: 'model', parts: [] }],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateA).contents).toEqual([{ role: 'model', parts: [] }]);
+});
diff --git a/packages/gateway/src/data-plane/chat/gemini/http.ts b/packages/gateway/src/data-plane/chat/gemini/http.ts
index 64437f7ae..2fd73ce04 100644
--- a/packages/gateway/src/data-plane/chat/gemini/http.ts
+++ b/packages/gateway/src/data-plane/chat/gemini/http.ts
@@ -4,7 +4,6 @@ import { geminiServe } from './serve.ts';
 import type { AuthedContext } from '../../../middleware/auth.ts';
 import { backgroundSchedulerFromContext } from '../../../runtime/background.ts';
 import { inboundHeadersForUpstream } from '../../shared/inbound-headers.ts';
-import { createNonResponsesSourceStore } from '../responses/items/store.ts';
 import { createChatGatewayCtxFromHono, finalizeGatewayResponse, type ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import { readRequestBody, takeRequestBody, type RequestBody } from '../shared/request-body.ts';
 import type { GeminiContent, GeminiPayload } from '@floway-dev/protocols/gemini';
@@ -103,7 +102,7 @@ const runGeminiGenerate = async (c: AuthedContext, model: string, wantsStream: b
   const payload = parseGeminiBodyBytes(requestBody, body => body as GeminiPayload);
   if (payload instanceof Response) return payload;
 
-  const ctx = createChatGatewayCtxFromHono(c, { wantsStream, requestBody: takeRequestBody(requestBody), model, backgroundScheduler: backgroundSchedulerFromContext(c) }, createNonResponsesSourceStore);
+  const ctx = createChatGatewayCtxFromHono(c, { wantsStream, requestBody: takeRequestBody(requestBody), model, backgroundScheduler: backgroundSchedulerFromContext(c) });
   try {
     const result = await geminiServe.generate({ payload, ctx, model, headers: inboundHeadersForUpstream(c) });
     const { response } = await respondGemini(c, result, wantsStream, ctx);
@@ -118,7 +117,7 @@ const runGeminiCountTokens = async (c: AuthedContext, model: string): Promise<Re
   const payload = parseGeminiBodyBytes(requestBody, parseGeminiCountTokensPayload);
   if (payload instanceof Response) return payload;
 
-  const ctx = createChatGatewayCtxFromHono(c, { wantsStream: false, requestBody: takeRequestBody(requestBody), model, backgroundScheduler: backgroundSchedulerFromContext(c) }, createNonResponsesSourceStore);
+  const ctx = createChatGatewayCtxFromHono(c, { wantsStream: false, requestBody: takeRequestBody(requestBody), model, backgroundScheduler: backgroundSchedulerFromContext(c) });
   try {
     const result = await geminiServe.countTokens({ payload, ctx, model, headers: inboundHeadersForUpstream(c) });
     const { response } = await respondGemini(c, result, false, ctx);
diff --git a/packages/gateway/src/data-plane/chat/gemini/http_test.ts b/packages/gateway/src/data-plane/chat/gemini/http_test.ts
index 4b25ae47d..bb638c4fb 100644
--- a/packages/gateway/src/data-plane/chat/gemini/http_test.ts
+++ b/packages/gateway/src/data-plane/chat/gemini/http_test.ts
@@ -43,6 +43,7 @@ const buildApiKey = (overrides: Partial<ApiKey> = {}): ApiKey => ({
   userId: 1,
   name: 'http_test',
   key: 'sk-http-test',
+  serverSecret: '00'.repeat(32),
   createdAt: '2026-01-01T00:00:00.000Z',
   upstreamIds: null,
   deletedAt: null,
diff --git a/packages/gateway/src/data-plane/chat/gemini/respond.ts b/packages/gateway/src/data-plane/chat/gemini/respond.ts
index 6c760f8db..dc3099fdf 100644
--- a/packages/gateway/src/data-plane/chat/gemini/respond.ts
+++ b/packages/gateway/src/data-plane/chat/gemini/respond.ts
@@ -1,10 +1,12 @@
 import type { Context } from 'hono';
 import { streamSSE } from 'hono/streaming';
 
+import { wrapGeminiAffinityEgress } from './affinity/egress.ts';
 import { geminiStatusForHttpStatus } from './errors.ts';
 import { tokenUsageFromGeminiUsageMetadata } from './usage.ts';
 import { recordFailedRequest } from '../../shared/telemetry/performance.ts';
 import { settle } from '../../shared/telemetry/settle.ts';
+import { affinityEgressOptions } from '../shared/affinity/index.ts';
 import type { GatewayCtx } from '../shared/gateway-ctx.ts';
 import { SourceStreamState, eventResultMetadata, forwardUpstreamHeaders, mergeForwardedUpstreamHeaders, plainResultToResponse } from '../shared/respond.ts';
 import { type StreamCompletion, writeSSEFrames } from '../shared/stream/sse.ts';
@@ -45,7 +47,8 @@ export const respondGemini = async (
   }
 
   const state = new SourceStreamState();
-  const frames = observeGeminiFrames(result.events, state, wantsStream, ctx);
+  const observed = observeGeminiFrames(result.events, state, wantsStream, ctx);
+  const frames = wrapGeminiAffinityEgress(observed, affinityEgressOptions(ctx));
 
   if (!wantsStream) {
     try {
diff --git a/packages/gateway/src/data-plane/chat/gemini/serve.ts b/packages/gateway/src/data-plane/chat/gemini/serve.ts
index deecf1750..8e3641aa6 100644
--- a/packages/gateway/src/data-plane/chat/gemini/serve.ts
+++ b/packages/gateway/src/data-plane/chat/gemini/serve.ts
@@ -1,14 +1,14 @@
+import { prepareGeminiAffinity } from './affinity/ingress.ts';
 import { geminiAttempt, geminiCountTokensTarget, geminiGenerateTarget } from './attempt.ts';
 import { renderGeminiFailure } from './errors.ts';
 import { enumerateModelCandidates } from '../../providers/registry.ts';
 import { iterateCandidates } from '../../shared/iterate-candidates.ts';
-import { classifyResponsesItemAffinity } from '../responses/items/affinity.ts';
+import { routeCandidatesByAffinity } from '../shared/affinity/index.ts';
 import { noViableCandidateFailure } from '../shared/errors.ts';
 import type { ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
 import type { GeminiPayload, GeminiStreamEvent } from '@floway-dev/protocols/gemini';
 import type { ExecuteResult, PlainResult } from '@floway-dev/provider';
-import { geminiViaResponsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
 export interface GeminiServeGenerateArgs {
   readonly payload: GeminiPayload;
@@ -30,6 +30,7 @@ export interface GeminiServeCountTokensArgs {
 export const geminiServe = {
   generate: async (args: GeminiServeGenerateArgs): Promise<ExecuteResult<ProtocolFrame<GeminiStreamEvent>>> => {
     const { payload, ctx, model, headers } = args;
+    const prepared = await prepareGeminiAffinity(payload, ctx.affinity.codec);
     const { candidates: enumerated, sawModel, failedUpstreams } = await enumerateModelCandidates({
       upstreamIds: ctx.upstreamIds,
       model,
@@ -38,12 +39,7 @@ export const geminiServe = {
       runtimeLocation: ctx.runtimeLocation,
     });
     const viable = enumerated.filter(c => geminiGenerateTarget.canServe(c.model.endpoints));
-    const decision = await classifyResponsesItemAffinity({
-      sourceItems: payload.contents ?? [],
-      view: geminiViaResponsesItemsView,
-      store: ctx.store,
-      candidates: viable,
-    });
+    const decision = routeCandidatesByAffinity(viable, prepared.routingEvidence);
     if (decision.kind === 'failure') return renderGeminiFailure(decision.failure, 'generate');
     if (decision.candidates.length === 0) return renderGeminiFailure(noViableCandidateFailure(sawModel, model, failedUpstreams), 'generate');
 
@@ -53,20 +49,24 @@ export const geminiServe = {
     // transient 5xx/429/network failures. When the list is exhausted, the
     // most recent failure is forwarded verbatim so the client still sees
     // real upstream telemetry rather than a synthetic envelope. The
-    // Gemini URL-path model id is already in `model`; downstream dispatch
-    // keys off `candidate.model.id`, so no payload rewrite is needed here
-    // even for alias-origin candidates.
+    // Gemini carries its model in the URL, so affinity preparation owns the
+    // candidate payload while dispatch reads the canonical candidate model.
     return await iterateCandidates(
       decision.candidates,
       'geminiServe.generate',
       ctx,
       'chat',
-      candidate => geminiAttempt.generate({ payload, ctx, candidate, headers }),
+      async candidate => {
+        const result = await geminiAttempt.generate({ payload: prepared.payloadForCandidate(candidate), ctx, candidate, headers });
+        if (result.type === 'events') ctx.affinity.select(candidate);
+        return result;
+      },
     );
   },
 
   countTokens: async (args: GeminiServeCountTokensArgs): Promise<ExecuteResult<ProtocolFrame<GeminiStreamEvent>> | PlainResult> => {
     const { payload, ctx, model, headers } = args;
+    const prepared = await prepareGeminiAffinity(payload, ctx.affinity.codec);
     const { candidates: enumerated, sawModel, failedUpstreams } = await enumerateModelCandidates({
       upstreamIds: ctx.upstreamIds,
       model,
@@ -75,12 +75,7 @@ export const geminiServe = {
       runtimeLocation: ctx.runtimeLocation,
     });
     const viable = enumerated.filter(c => geminiCountTokensTarget.canServe(c.model.endpoints));
-    const decision = await classifyResponsesItemAffinity({
-      sourceItems: payload.contents ?? [],
-      view: geminiViaResponsesItemsView,
-      store: ctx.store,
-      candidates: viable,
-    });
+    const decision = routeCandidatesByAffinity(viable, prepared.routingEvidence);
     if (decision.kind === 'failure') return renderGeminiFailure(decision.failure, 'countTokens');
     if (decision.candidates.length === 0) return renderGeminiFailure(noViableCandidateFailure(sawModel, model, failedUpstreams), 'countTokens');
 
@@ -89,7 +84,7 @@ export const geminiServe = {
       'geminiServe.countTokens',
       ctx,
       'chat',
-      candidate => geminiAttempt.countTokens({ payload, ctx, candidate, headers }),
+      candidate => geminiAttempt.countTokens({ payload: prepared.payloadForCandidate(candidate), ctx, candidate, headers }),
     );
   },
 };
diff --git a/packages/gateway/src/data-plane/chat/messages/affinity/egress.ts b/packages/gateway/src/data-plane/chat/messages/affinity/egress.ts
new file mode 100644
index 000000000..39cfb98a5
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/messages/affinity/egress.ts
@@ -0,0 +1,141 @@
+import type { AffinityEgressOptions } from '../../shared/affinity/index.ts';
+import { eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
+import type { MessagesStreamEvent } from '@floway-dev/protocols/messages';
+
+interface OpenBlock {
+  readonly type: string;
+  readonly first: boolean;
+  signatureEvent?: SignatureDeltaEvent;
+}
+
+type ContentBlockDeltaEvent = Extract<MessagesStreamEvent, { type: 'content_block_delta' }>;
+type SignatureDeltaEvent = ContentBlockDeltaEvent & {
+  readonly delta: Extract<ContentBlockDeltaEvent['delta'], { type: 'signature_delta' }>;
+};
+
+const isSignatureDeltaEvent = (event: MessagesStreamEvent): event is SignatureDeltaEvent =>
+  event.type === 'content_block_delta' && event.delta.type === 'signature_delta';
+
+export const wrapMessagesAffinityEgress = async function* (
+  frames: AsyncIterable<ProtocolFrame<MessagesStreamEvent>>,
+  options: AffinityEgressOptions,
+): AsyncGenerator<ProtocolFrame<MessagesStreamEvent>> {
+  // Messages exposes real block boundaries. A first block that cannot carry a
+  // signature is shifted behind one redacted prefix; thinking stays visible
+  // while only its latest signature waits for content_block_stop.
+  const openBlocks = new Map<number, OpenBlock>();
+  let syntheticPrefixEmitted = false;
+  let firstBlockSeen = false;
+  let indexOffset = 0;
+
+  const syntheticEvents = async (): Promise<MessagesStreamEvent[]> => {
+    if (syntheticPrefixEmitted) return [];
+    syntheticPrefixEmitted = true;
+    return [
+      {
+        type: 'content_block_start',
+        index: 0,
+        content_block: {
+          type: 'redacted_thinking',
+          data: await options.codec.wrap(undefined, options.affinity, 'messages.redacted_thinking.data'),
+        },
+      },
+      { type: 'content_block_stop', index: 0 },
+    ];
+  };
+
+  for await (const frame of frames) {
+    if (frame.type !== 'event') {
+      yield frame;
+      continue;
+    }
+
+    const event = frame.event;
+    if (event.type === 'content_block_start') {
+      if (openBlocks.has(event.index)) throw new Error(`Messages content block ${event.index} started twice`);
+      const first = !firstBlockSeen;
+      firstBlockSeen = true;
+      openBlocks.set(event.index, { type: event.content_block.type, first });
+
+      if (first && event.content_block.type !== 'thinking' && event.content_block.type !== 'redacted_thinking') {
+        for (const synthetic of await syntheticEvents()) yield eventFrame(synthetic);
+        indexOffset = 1;
+      }
+
+      const index = event.index + indexOffset;
+      if (event.content_block.type !== 'redacted_thinking') {
+        yield eventFrame({ ...event, index });
+        continue;
+      }
+
+      yield eventFrame({
+        ...event,
+        index,
+        content_block: {
+          ...event.content_block,
+          data: await options.codec.wrap(event.content_block.data, options.affinity, 'messages.redacted_thinking.data'),
+        },
+      });
+      continue;
+    }
+
+    if (isSignatureDeltaEvent(event)) {
+      const block = openBlocks.get(event.index);
+      if (block?.type !== 'thinking') throw new Error(`Messages signature_delta targeted non-thinking block ${event.index}`);
+      block.signatureEvent = event;
+      continue;
+    }
+
+    if (event.type === 'content_block_stop') {
+      const block = openBlocks.get(event.index);
+      if (block === undefined) throw new Error(`Messages content block ${event.index} stopped before it started`);
+      if (block.signatureEvent !== undefined || (block.first && block.type === 'thinking')) {
+        let signature: string;
+        if (block.signatureEvent !== undefined) {
+          signature = await options.codec.wrap(block.signatureEvent.delta.signature, options.affinity, 'messages.thinking.signature');
+        } else signature = await options.codec.wrap(undefined, options.affinity, 'messages.thinking.signature');
+        if (block.signatureEvent === undefined) {
+          yield eventFrame({
+            type: 'content_block_delta',
+            index: event.index + indexOffset,
+            delta: { type: 'signature_delta', signature },
+          });
+        } else {
+          const { index: _index, delta, ...eventExtras } = block.signatureEvent;
+          const { signature: _signature, ...deltaExtras } = delta;
+          yield eventFrame({
+            ...eventExtras,
+            type: 'content_block_delta',
+            index: event.index + indexOffset,
+            delta: { ...deltaExtras, type: 'signature_delta', signature },
+          });
+        }
+      }
+      openBlocks.delete(event.index);
+      yield eventFrame({ ...event, index: event.index + indexOffset });
+      continue;
+    }
+
+    if (event.type === 'content_block_delta') {
+      yield eventFrame({ ...event, index: event.index + indexOffset });
+      continue;
+    }
+
+    if (event.type === 'message_delta' && event.delta.stop_reason != null) {
+      if (openBlocks.size > 0) throw new Error('Messages terminal message_delta arrived with an open content block');
+      if (!firstBlockSeen) for (const synthetic of await syntheticEvents()) yield eventFrame(synthetic);
+      yield frame;
+      continue;
+    }
+
+    if (event.type === 'message_stop') {
+      if (openBlocks.size > 0) throw new Error('Messages message_stop arrived with an open content block');
+      if (!firstBlockSeen) for (const synthetic of await syntheticEvents()) yield eventFrame(synthetic);
+      yield frame;
+      return;
+    }
+
+    yield frame;
+    if (event.type === 'error') return;
+  }
+};
diff --git a/packages/gateway/src/data-plane/chat/messages/affinity/egress_test.ts b/packages/gateway/src/data-plane/chat/messages/affinity/egress_test.ts
new file mode 100644
index 000000000..a733d198f
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/messages/affinity/egress_test.ts
@@ -0,0 +1,166 @@
+import { describe, expect, test, vi } from 'vitest';
+
+import { wrapMessagesAffinityEgress } from './egress.ts';
+import type { AffinityCodec, AffinityTarget } from '../../shared/affinity/index.ts';
+import { eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
+import type { MessagesStreamEvent } from '@floway-dev/protocols/messages';
+
+const affinity: AffinityTarget = {
+  upstreamId: 'up-a',
+  modelId: 'model-a',
+};
+
+type AffinityEgressCodec = Pick<AffinityCodec, 'wrap'>;
+
+const frames = async function* (values: ProtocolFrame<MessagesStreamEvent>[]) {
+  yield* values;
+};
+
+class DelayedCodec implements AffinityEgressCodec {
+  readonly calls: Array<{ value: string | undefined; resolve: (value: string) => void }> = [];
+
+  wrap(value: string | undefined): Promise<string> {
+    return new Promise(resolve => this.calls.push({ value, resolve }));
+  }
+}
+
+const immediateCodec: AffinityEgressCodec = {
+  wrap: async value => `wrapped:${value ?? 'synthetic'}`,
+};
+
+describe('Messages affinity egress', () => {
+  test('streams readable thinking and wraps the latest signature snapshot at block stop', async () => {
+    const codec = new DelayedCodec();
+    const output = wrapMessagesAffinityEgress(frames([
+      eventFrame({ type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '' } }),
+      eventFrame({ type: 'content_block_delta', index: 0, delta: { type: 'thinking_delta', thinking: 'visible' } }),
+      eventFrame({ type: 'content_block_delta', index: 0, delta: { type: 'signature_delta', signature: 'first' } }),
+      eventFrame({ type: 'content_block_delta', index: 0, delta: { type: 'signature_delta', signature: 'latest' } }),
+      eventFrame({ type: 'content_block_stop', index: 0 }),
+      eventFrame({ type: 'message_delta', delta: { stop_reason: 'end_turn' } }),
+      eventFrame({ type: 'message_stop' }),
+    ]), { codec, affinity })[Symbol.asyncIterator]();
+
+    expect((await output.next()).value).toMatchObject({ event: { type: 'content_block_start' } });
+    expect((await output.next()).value).toEqual(eventFrame({
+      type: 'content_block_delta',
+      index: 0,
+      delta: { type: 'thinking_delta', thinking: 'visible' },
+    }));
+    expect(codec.calls).toHaveLength(0);
+
+    const signaturePending = output.next();
+    await vi.waitFor(() => expect(codec.calls.map(call => call.value)).toEqual(['latest']));
+    codec.calls[0].resolve('wrapped-latest');
+    expect((await signaturePending).value).toEqual(eventFrame({
+      type: 'content_block_delta',
+      index: 0,
+      delta: { type: 'signature_delta', signature: 'wrapped-latest' },
+    }));
+    expect((await output.next()).value).toEqual(eventFrame({ type: 'content_block_stop', index: 0 }));
+    expect((await output.next()).value).toMatchObject({ event: { type: 'message_delta' } });
+  });
+
+  test('retains extension fields from the latest natural signature event', async () => {
+    const signature = {
+      type: 'content_block_delta',
+      index: 0,
+      delta: { type: 'signature_delta', signature: 'natural', vendor_delta: 'delta-extra' },
+      vendor_event: 'event-extra',
+    } as unknown as MessagesStreamEvent;
+    const output: ProtocolFrame<MessagesStreamEvent>[] = [];
+    for await (const frame of wrapMessagesAffinityEgress(frames([
+      eventFrame({ type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '' } }),
+      eventFrame(signature),
+      eventFrame({ type: 'content_block_stop', index: 0 }),
+      eventFrame({ type: 'message_stop' }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[1]).toMatchObject({
+      event: {
+        type: 'content_block_delta',
+        index: 0,
+        vendor_event: 'event-extra',
+        delta: {
+          type: 'signature_delta',
+          signature: 'wrapped:natural',
+          vendor_delta: 'delta-extra',
+        },
+      },
+    });
+  });
+
+  test('wraps redacted data inline and does not inject another carrier', async () => {
+    const output: ProtocolFrame<MessagesStreamEvent>[] = [];
+    for await (const frame of wrapMessagesAffinityEgress(frames([
+      eventFrame({ type: 'content_block_start', index: 2, content_block: { type: 'redacted_thinking', data: 'opaque' } }),
+      eventFrame({ type: 'content_block_stop', index: 2 }),
+      eventFrame({ type: 'message_delta', delta: { stop_reason: 'end_turn' } }),
+      eventFrame({ type: 'message_stop' }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output[0]).toEqual(eventFrame({
+      type: 'content_block_start',
+      index: 2,
+      content_block: { type: 'redacted_thinking', data: 'wrapped:opaque' },
+    }));
+    expect(output.filter(frame => frame.type === 'event' && frame.event.type === 'content_block_start')).toHaveLength(1);
+  });
+
+  test('prefixes a synthetic redacted block before a first text block and shifts its index', async () => {
+    const output: ProtocolFrame<MessagesStreamEvent>[] = [];
+    for await (const frame of wrapMessagesAffinityEgress(frames([
+      eventFrame({ type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }),
+      eventFrame({ type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: 'answer' } }),
+      eventFrame({ type: 'content_block_stop', index: 0 }),
+      eventFrame({ type: 'message_delta', delta: { stop_reason: 'end_turn' } }),
+      eventFrame({ type: 'message_stop' }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output.slice(0, 5)).toEqual([
+      eventFrame({
+        type: 'content_block_start',
+        index: 0,
+        content_block: { type: 'redacted_thinking', data: 'wrapped:synthetic' },
+      }),
+      eventFrame({ type: 'content_block_stop', index: 0 }),
+      eventFrame({ type: 'content_block_start', index: 1, content_block: { type: 'text', text: '' } }),
+      eventFrame({ type: 'content_block_delta', index: 1, delta: { type: 'text_delta', text: 'answer' } }),
+      eventFrame({ type: 'content_block_stop', index: 1 }),
+    ]);
+  });
+
+  test('adds an originless signature to a first thinking block without a natural signature', async () => {
+    const output: ProtocolFrame<MessagesStreamEvent>[] = [];
+    for await (const frame of wrapMessagesAffinityEgress(frames([
+      eventFrame({ type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '' } }),
+      eventFrame({ type: 'content_block_delta', index: 0, delta: { type: 'thinking_delta', thinking: 'visible' } }),
+      eventFrame({ type: 'content_block_stop', index: 0 }),
+      eventFrame({ type: 'message_delta', delta: { stop_reason: 'end_turn' } }),
+      eventFrame({ type: 'message_stop' }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output.slice(0, 4)).toEqual([
+      eventFrame({ type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '' } }),
+      eventFrame({ type: 'content_block_delta', index: 0, delta: { type: 'thinking_delta', thinking: 'visible' } }),
+      eventFrame({ type: 'content_block_delta', index: 0, delta: { type: 'signature_delta', signature: 'wrapped:synthetic' } }),
+      eventFrame({ type: 'content_block_stop', index: 0 }),
+    ]);
+  });
+
+  test('emits one prefix for an empty message with both terminal events', async () => {
+    const output: ProtocolFrame<MessagesStreamEvent>[] = [];
+    for await (const frame of wrapMessagesAffinityEgress(frames([
+      eventFrame({ type: 'message_delta', delta: { stop_reason: 'end_turn' } }),
+      eventFrame({ type: 'message_stop' }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output.filter(frame => frame.type === 'event' && frame.event.type === 'content_block_start')).toHaveLength(1);
+    expect(output.map(frame => frame.type === 'event' ? frame.event.type : frame.type)).toEqual([
+      'content_block_start',
+      'content_block_stop',
+      'message_delta',
+      'message_stop',
+    ]);
+  });
+});
diff --git a/packages/gateway/src/data-plane/chat/messages/affinity/ingress.ts b/packages/gateway/src/data-plane/chat/messages/affinity/ingress.ts
new file mode 100644
index 000000000..74daad45a
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/messages/affinity/ingress.ts
@@ -0,0 +1,63 @@
+import { type AffinityCodec, blobForExactCandidate, preferredAffinityEvidence, type DecodedAffinityBlob, type PreparedAffinityPayload } from '../../shared/affinity/index.ts';
+import type { MessagesAssistantContentBlock, MessagesPayload } from '@floway-dev/protocols/messages';
+
+interface MessagesBlobLocation {
+  readonly messageIndex: number;
+  readonly blockIndex: number;
+  readonly kind: 'thinking' | 'redacted_thinking';
+  readonly decoded: DecodedAffinityBlob;
+}
+
+export const prepareMessagesAffinity = async (
+  payload: MessagesPayload,
+  codec: AffinityCodec,
+): Promise<PreparedAffinityPayload<MessagesPayload>> => {
+  const locations: MessagesBlobLocation[] = [];
+  for (const [messageIndex, message] of payload.messages.entries()) {
+    if (message.role !== 'assistant' || !Array.isArray(message.content)) continue;
+    for (const [blockIndex, block] of message.content.entries()) {
+      if (block.type === 'thinking' && typeof block.signature === 'string') {
+        locations.push({ messageIndex, blockIndex, kind: block.type, decoded: await codec.unwrap(block.signature, 'messages.thinking.signature') });
+      } else if (block.type === 'redacted_thinking') {
+        locations.push({ messageIndex, blockIndex, kind: block.type, decoded: await codec.unwrap(block.data, 'messages.redacted_thinking.data') });
+      }
+    }
+  }
+
+  return {
+    routingEvidence: preferredAffinityEvidence(locations.map(location => location.decoded)),
+    payloadForCandidate: candidate => {
+      const candidatePayload = structuredClone(payload);
+      const byMessage = Map.groupBy(locations, location => location.messageIndex);
+      const emptiedByAffinity = new Set<number>();
+      for (const [messageIndex, messageLocations] of byMessage) {
+        const message = candidatePayload.messages[messageIndex];
+        if (message.role !== 'assistant' || !Array.isArray(message.content)) {
+          throw new Error('Messages affinity location no longer points to assistant block content');
+        }
+        const replacements = new Map<number, MessagesAssistantContentBlock | null>();
+        for (const location of messageLocations) {
+          const block = message.content[location.blockIndex];
+          const selected = blobForExactCandidate(location.decoded, candidate);
+          if (location.kind === 'thinking') {
+            if (block.type !== 'thinking') throw new Error('Messages affinity thinking location changed type');
+            const replacement = { ...block };
+            if (selected.present) replacement.signature = selected.value;
+            else delete replacement.signature;
+            replacements.set(location.blockIndex, replacement);
+          } else {
+            if (block.type !== 'redacted_thinking') throw new Error('Messages affinity redacted location changed type');
+            replacements.set(location.blockIndex, selected.present ? { ...block, data: selected.value } : null);
+          }
+        }
+        message.content = message.content.flatMap((block, blockIndex) => {
+          const replacement = replacements.get(blockIndex);
+          return replacement === undefined ? [block] : replacement === null ? [] : [replacement];
+        });
+        if (message.content.length === 0) emptiedByAffinity.add(messageIndex);
+      }
+      candidatePayload.messages = candidatePayload.messages.filter((_message, messageIndex) => !emptiedByAffinity.has(messageIndex));
+      return candidatePayload;
+    },
+  };
+};
diff --git a/packages/gateway/src/data-plane/chat/messages/affinity/ingress_test.ts b/packages/gateway/src/data-plane/chat/messages/affinity/ingress_test.ts
new file mode 100644
index 000000000..b21acf191
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/messages/affinity/ingress_test.ts
@@ -0,0 +1,81 @@
+import { expect, test } from 'vitest';
+
+import { prepareMessagesAffinity } from './ingress.ts';
+import { AffinityCodec, type AffinityTarget } from '../../shared/affinity/index.ts';
+import type { ModelCandidate } from '@floway-dev/provider';
+import { stubModelCandidate } from '@floway-dev/test-utils';
+
+const codec = new AffinityCodec('22'.repeat(32));
+
+const candidate = (upstream: string): ModelCandidate => {
+  const base = stubModelCandidate();
+  return stubModelCandidate({
+    provider: { ...base.provider, upstream },
+    model: { id: 'model' },
+  });
+};
+
+const targetFor = (value: ModelCandidate): AffinityTarget => ({
+  upstreamId: value.provider.upstream,
+  modelId: value.model.id,
+  ...(value.rules !== undefined ? { rules: value.rules } : {}),
+});
+
+test('removes synthetic blocks and strips incompatible signatures without hiding thinking', async () => {
+  const candidateA = candidate('upstream-a');
+  const candidateB = candidate('upstream-b');
+  const signature = await codec.wrap('signature', targetFor(candidateA), 'messages.thinking.signature');
+  const synthetic = await codec.wrap(undefined, targetFor(candidateA), 'messages.redacted_thinking.data');
+  const prepared = await prepareMessagesAffinity({
+    model: 'model',
+    max_tokens: 100,
+    messages: [{
+      role: 'assistant',
+      content: [
+        { type: 'thinking', thinking: 'visible reasoning', signature },
+        { type: 'redacted_thinking', data: synthetic },
+        { type: 'text', text: 'answer' },
+      ],
+    }],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateA).messages[0]).toEqual({
+    role: 'assistant',
+    content: [
+      { type: 'thinking', thinking: 'visible reasoning', signature: 'signature' },
+      { type: 'text', text: 'answer' },
+    ],
+  });
+  expect(prepared.payloadForCandidate(candidateB).messages[0]).toEqual({
+    role: 'assistant',
+    content: [
+      { type: 'thinking', thinking: 'visible reasoning' },
+      { type: 'text', text: 'answer' },
+    ],
+  });
+});
+
+test('removes assistant messages emptied by affinity block stripping', async () => {
+  const candidateA = candidate('upstream-a');
+  const candidateB = candidate('upstream-b');
+  const synthetic = await codec.wrap(undefined, targetFor(candidateA), 'messages.redacted_thinking.data');
+  const natural = await codec.wrap('natural', targetFor(candidateA), 'messages.redacted_thinking.data');
+
+  const syntheticPrepared = await prepareMessagesAffinity({
+    model: 'model',
+    max_tokens: 100,
+    messages: [{ role: 'assistant', content: [{ type: 'redacted_thinking', data: synthetic }] }],
+  }, codec);
+  expect(syntheticPrepared.payloadForCandidate(candidateA).messages).toEqual([]);
+  expect(syntheticPrepared.payloadForCandidate(candidateB).messages).toEqual([]);
+
+  const naturalPrepared = await prepareMessagesAffinity({
+    model: 'model',
+    max_tokens: 100,
+    messages: [{ role: 'assistant', content: [{ type: 'redacted_thinking', data: natural }] }],
+  }, codec);
+  expect(naturalPrepared.payloadForCandidate(candidateA).messages).toEqual([
+    { role: 'assistant', content: [{ type: 'redacted_thinking', data: 'natural' }] },
+  ]);
+  expect(naturalPrepared.payloadForCandidate(candidateB).messages).toEqual([]);
+});
diff --git a/packages/gateway/src/data-plane/chat/messages/attempt.ts b/packages/gateway/src/data-plane/chat/messages/attempt.ts
index 26bf05e6a..6565a0557 100644
--- a/packages/gateway/src/data-plane/chat/messages/attempt.ts
+++ b/packages/gateway/src/data-plane/chat/messages/attempt.ts
@@ -4,19 +4,15 @@ import { applyRulesToUpstreamMessages } from '../../model-aliases/apply-rules.ts
 import { providerStreamResultToExecuteResult, buildUpstreamCallOptions, chatTargetPicker } from '../../shared/telemetry/attempt-helpers.ts';
 import { chatCompletionsAttempt } from '../chat-completions/attempt.ts';
 import { responsesAttempt } from '../responses/attempt.ts';
-import { rewriteStoredItemsInSourceForCandidate } from '../responses/items/rewrite.ts';
-import type { StatefulResponsesStore } from '../responses/items/store.ts';
-import { tryCatchChatServeFailure } from '../shared/errors.ts';
 import type { ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import { plainResultFromResponse } from '../shared/respond.ts';
 import { traverseTranslation } from '../shared/translate-traverse.ts';
 import { runInterceptors } from '@floway-dev/interceptor';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
-import type { MessagesMessage, MessagesPayload, MessagesStreamEvent } from '@floway-dev/protocols/messages';
+import type { MessagesPayload, MessagesStreamEvent } from '@floway-dev/protocols/messages';
 import type { ModelCandidate, ExecuteResult, PlainResult } from '@floway-dev/provider';
 import { providerModelOf } from '@floway-dev/provider';
 import { translateMessagesViaChatCompletions, translateMessagesViaResponses } from '@floway-dev/translate';
-import { messagesViaResponsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
 // `/v1/messages` generate prefers a native Messages target, then the
 // translated Responses path, then the translated Chat Completions path.
@@ -36,14 +32,11 @@ export interface MessagesAttemptArgs {
 export const messagesAttempt = {
   generate: async (args: MessagesAttemptArgs): Promise<ExecuteResult<ProtocolFrame<MessagesStreamEvent>>> => {
     const { payload: sourcePayload, ctx, candidate, headers: sourceHeaders } = args;
-    const payload = { ...structuredClone(sourcePayload), model: candidate.model.id };
+    const payload = { ...sourcePayload, model: candidate.model.id };
     const headers = new Headers(sourceHeaders);
-    const { store } = ctx;
     const targetApi = messagesGenerateTarget.pick(candidate.model.endpoints);
-    const rewritten = await rewriteOrRenderMessagesFailure(payload, store, candidate);
-    if (rewritten.failure) return rewritten.failure;
     const invocation: MessagesInvocation = {
-      payload: rewritten.payload,
+      payload,
       candidate,
       targetApi,
       headers,
@@ -84,21 +77,14 @@ export const messagesAttempt = {
 
   countTokens: async (args: MessagesAttemptArgs): Promise<PlainResult> => {
     const { payload: sourcePayload, ctx, candidate, headers: sourceHeaders } = args;
-    const payload = { ...structuredClone(sourcePayload), model: candidate.model.id };
+    const payload = { ...sourcePayload, model: candidate.model.id };
     const headers = new Headers(sourceHeaders);
-    const { store } = ctx;
     // `pick` here is contractually total — serve filtered with
     // `messagesCountTokensTarget.canServe`, so a non-messages candidate is
     // a contract breach.
     const targetApi = messagesCountTokensTarget.pick(candidate.model.endpoints);
-    const rewritten = await rewriteOrRenderMessagesFailure(payload, store, candidate);
-    if (rewritten.failure) {
-      // count_tokens has no streaming envelope; surface the rewrite-time
-      // failure as a synthetic PlainResult carrying the same body.
-      return { type: 'plain', status: rewritten.failure.status, headers: rewritten.failure.headers, body: rewritten.failure.body };
-    }
     const invocation: MessagesInvocation = {
-      payload: rewritten.payload,
+      payload,
       candidate,
       targetApi,
       headers,
@@ -117,41 +103,3 @@ export const messagesAttempt = {
     return await plainResultFromResponse(response, candidate.provider.upstream);
   },
 };
-
-// Rewrites stored Responses item carriers (assistant thinking blocks whose
-// signature packs a gateway-stored reasoning id) to the upstream-owned id
-// the chosen candidate's wire requires. The failure path translates a
-// missing-item lookup into a 400 invalid_request_error so a caller that
-// referenced an item the gateway no longer has gets a useful error envelope
-// rather than a generic 500.
-const rewriteOrRenderMessagesFailure = async (
-  payload: MessagesPayload,
-  store: StatefulResponsesStore,
-  candidate: ModelCandidate,
-): Promise<{ payload: MessagesPayload; failure?: undefined } | { payload?: undefined; failure: ExecuteResult<ProtocolFrame<MessagesStreamEvent>> & { type: 'api-error' } }> => {
-  try {
-    const rewrittenMessages = await rewriteStoredItemsInSourceForCandidate(
-      payload.messages as readonly MessagesMessage[],
-      messagesViaResponsesItemsView,
-      store,
-      candidate,
-    );
-    return { payload: { ...payload, messages: rewrittenMessages as MessagesMessage[] } };
-  } catch (error) {
-    const failure = tryCatchChatServeFailure(error);
-    if (failure === null) throw error;
-    if (failure.kind !== 'item-not-found') throw error;
-    return {
-      failure: {
-        type: 'api-error',
-        source: 'gateway',
-        status: 400,
-        headers: new Headers({ 'content-type': 'application/json' }),
-        body: new TextEncoder().encode(JSON.stringify({
-          type: 'error',
-          error: { type: 'invalid_request_error', message: `Item with id '${failure.itemId}' not found.` },
-        })),
-      },
-    };
-  }
-};
diff --git a/packages/gateway/src/data-plane/chat/messages/http.ts b/packages/gateway/src/data-plane/chat/messages/http.ts
index 18a7e55bb..577f570a8 100644
--- a/packages/gateway/src/data-plane/chat/messages/http.ts
+++ b/packages/gateway/src/data-plane/chat/messages/http.ts
@@ -4,7 +4,6 @@ import { messagesServe } from './serve.ts';
 import type { AuthedContext } from '../../../middleware/auth.ts';
 import { backgroundSchedulerFromContext } from '../../../runtime/background.ts';
 import { inboundHeadersForUpstream } from '../../shared/inbound-headers.ts';
-import { createNonResponsesSourceStore } from '../responses/items/store.ts';
 import { createChatGatewayCtxFromHono, createGatewayCtxFromHono, finalizeGatewayResponse, type ChatGatewayCtx, type GatewayCtx } from '../shared/gateway-ctx.ts';
 import { readRequestBody, takeRequestBody, type RequestBody } from '../shared/request-body.ts';
 import { providerModelsUnavailableResponse } from '../shared/upstream-models-error.ts';
@@ -74,7 +73,7 @@ export const messagesHttp = {
       if (rejected) return rejected;
 
       const wantsStream = payload.stream === true;
-      ctx = createChatGatewayCtxFromHono(c, { wantsStream, requestBody: takeRequestBody(requestBody), model: payload.model, backgroundScheduler: backgroundSchedulerFromContext(c) }, createNonResponsesSourceStore);
+      ctx = createChatGatewayCtxFromHono(c, { wantsStream, requestBody: takeRequestBody(requestBody), model: payload.model, backgroundScheduler: backgroundSchedulerFromContext(c) });
       const result = await messagesServe.generate({ payload, ctx, headers: inboundHeadersForUpstream(c) });
       const { response } = await respondMessages(c, result, wantsStream, ctx);
       return finalizeGatewayResponse(ctx, response);
@@ -91,7 +90,7 @@ export const messagesHttp = {
       const rejected = rejectBodyBetaResponse(payload);
       if (rejected) return rejected;
 
-      ctx = createChatGatewayCtxFromHono(c, { wantsStream: false, requestBody: takeRequestBody(requestBody), model: payload.model, backgroundScheduler: backgroundSchedulerFromContext(c) }, createNonResponsesSourceStore);
+      ctx = createChatGatewayCtxFromHono(c, { wantsStream: false, requestBody: takeRequestBody(requestBody), model: payload.model, backgroundScheduler: backgroundSchedulerFromContext(c) });
       const result = await messagesServe.countTokens({ payload, ctx, headers: inboundHeadersForUpstream(c) });
       const { response } = await respondMessages(c, result, false, ctx);
       return finalizeGatewayResponse(ctx, response);
diff --git a/packages/gateway/src/data-plane/chat/messages/http_test.ts b/packages/gateway/src/data-plane/chat/messages/http_test.ts
index 43aad592d..3aeccdc20 100644
--- a/packages/gateway/src/data-plane/chat/messages/http_test.ts
+++ b/packages/gateway/src/data-plane/chat/messages/http_test.ts
@@ -42,6 +42,7 @@ const buildApiKey = (overrides: Partial<ApiKey> = {}): ApiKey => ({
   userId: 1,
   name: 'http_test',
   key: 'sk-http-test',
+  serverSecret: '00'.repeat(32),
   createdAt: '2026-01-01T00:00:00.000Z',
   upstreamIds: null,
   deletedAt: null,
diff --git a/packages/gateway/src/data-plane/chat/messages/respond.ts b/packages/gateway/src/data-plane/chat/messages/respond.ts
index c0b8f3884..aa6b62876 100644
--- a/packages/gateway/src/data-plane/chat/messages/respond.ts
+++ b/packages/gateway/src/data-plane/chat/messages/respond.ts
@@ -1,9 +1,11 @@
 import type { Context } from 'hono';
 import { streamSSE } from 'hono/streaming';
 
+import { wrapMessagesAffinityEgress } from './affinity/egress.ts';
 import { recordFailedRequest } from '../../shared/telemetry/performance.ts';
 import { settle } from '../../shared/telemetry/settle.ts';
 import { tokenUsage } from '../../shared/telemetry/usage.ts';
+import { affinityEgressOptions } from '../shared/affinity/index.ts';
 import type { GatewayCtx } from '../shared/gateway-ctx.ts';
 import { SourceStreamState, eventResultMetadata, forwardUpstreamHeaders, mergeForwardedUpstreamHeaders, plainResultToResponse } from '../shared/respond.ts';
 import { type StreamCompletion, writeSSEFrames } from '../shared/stream/sse.ts';
@@ -47,7 +49,8 @@ export const respondMessages = async (
 
   const state = new SourceStreamState();
   const usageState = createMessagesStreamUsageState();
-  const frames = observeMessagesFrames(result.events, state, usageState, wantsStream, ctx);
+  const observed = observeMessagesFrames(result.events, state, usageState, wantsStream, ctx);
+  const frames = wrapMessagesAffinityEgress(observed, affinityEgressOptions(ctx));
 
   if (!wantsStream) {
     try {
diff --git a/packages/gateway/src/data-plane/chat/messages/serve.ts b/packages/gateway/src/data-plane/chat/messages/serve.ts
index 3fd085569..dd386d217 100644
--- a/packages/gateway/src/data-plane/chat/messages/serve.ts
+++ b/packages/gateway/src/data-plane/chat/messages/serve.ts
@@ -1,14 +1,14 @@
+import { prepareMessagesAffinity } from './affinity/ingress.ts';
 import { messagesAttempt, messagesGenerateTarget, messagesCountTokensTarget } from './attempt.ts';
 import { renderMessagesFailure } from './errors.ts';
 import { enumerateModelCandidates } from '../../providers/registry.ts';
 import { iterateCandidates } from '../../shared/iterate-candidates.ts';
-import { classifyResponsesItemAffinity } from '../responses/items/affinity.ts';
+import { routeCandidatesByAffinity } from '../shared/affinity/index.ts';
 import { noViableCandidateFailure } from '../shared/errors.ts';
 import type { ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
 import type { MessagesPayload, MessagesStreamEvent } from '@floway-dev/protocols/messages';
 import type { ExecuteResult, PlainResult } from '@floway-dev/provider';
-import { messagesViaResponsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
 export interface MessagesServeGenerateArgs {
   readonly payload: MessagesPayload;
@@ -25,6 +25,7 @@ export interface MessagesServeCountTokensArgs {
 export const messagesServe = {
   generate: async (args: MessagesServeGenerateArgs): Promise<ExecuteResult<ProtocolFrame<MessagesStreamEvent>>> => {
     const { payload, ctx, headers } = args;
+    const prepared = await prepareMessagesAffinity(payload, ctx.affinity.codec);
     const { candidates: enumerated, sawModel, failedUpstreams } = await enumerateModelCandidates({
       upstreamIds: ctx.upstreamIds,
       model: payload.model,
@@ -33,12 +34,7 @@ export const messagesServe = {
       runtimeLocation: ctx.runtimeLocation,
     });
     const viable = enumerated.filter(c => messagesGenerateTarget.canServe(c.model.endpoints));
-    const decision = await classifyResponsesItemAffinity({
-      sourceItems: payload.messages,
-      view: messagesViaResponsesItemsView,
-      store: ctx.store,
-      candidates: viable,
-    });
+    const decision = routeCandidatesByAffinity(viable, prepared.routingEvidence);
     if (decision.kind === 'failure') return renderMessagesFailure(decision.failure, 'generate');
     if (decision.candidates.length === 0) return renderMessagesFailure(noViableCandidateFailure(sawModel, payload.model, failedUpstreams), 'generate');
 
@@ -53,12 +49,17 @@ export const messagesServe = {
       'messagesServe.generate',
       ctx,
       'chat',
-      candidate => messagesAttempt.generate({ payload, ctx, candidate, headers }),
+      async candidate => {
+        const result = await messagesAttempt.generate({ payload: prepared.payloadForCandidate(candidate), ctx, candidate, headers });
+        if (result.type === 'events') ctx.affinity.select(candidate);
+        return result;
+      },
     );
   },
 
   countTokens: async (args: MessagesServeCountTokensArgs): Promise<ExecuteResult<ProtocolFrame<MessagesStreamEvent>> | PlainResult> => {
     const { payload, ctx, headers } = args;
+    const prepared = await prepareMessagesAffinity(payload, ctx.affinity.codec);
     const { candidates: enumerated, sawModel, failedUpstreams } = await enumerateModelCandidates({
       upstreamIds: ctx.upstreamIds,
       model: payload.model,
@@ -67,12 +68,7 @@ export const messagesServe = {
       runtimeLocation: ctx.runtimeLocation,
     });
     const viable = enumerated.filter(c => messagesCountTokensTarget.canServe(c.model.endpoints));
-    const decision = await classifyResponsesItemAffinity({
-      sourceItems: payload.messages,
-      view: messagesViaResponsesItemsView,
-      store: ctx.store,
-      candidates: viable,
-    });
+    const decision = routeCandidatesByAffinity(viable, prepared.routingEvidence);
     if (decision.kind === 'failure') return renderMessagesFailure(decision.failure, 'countTokens');
     if (decision.candidates.length === 0) return renderMessagesFailure(noViableCandidateFailure(sawModel, payload.model, failedUpstreams), 'countTokens');
 
@@ -81,7 +77,7 @@ export const messagesServe = {
       'messagesServe.countTokens',
       ctx,
       'chat',
-      candidate => messagesAttempt.countTokens({ payload, ctx, candidate, headers }),
+      candidate => messagesAttempt.countTokens({ payload: prepared.payloadForCandidate(candidate), ctx, candidate, headers }),
     );
   },
 };
diff --git a/packages/gateway/src/data-plane/chat/responses/affinity/egress.ts b/packages/gateway/src/data-plane/chat/responses/affinity/egress.ts
new file mode 100644
index 000000000..3eac7de83
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/responses/affinity/egress.ts
@@ -0,0 +1,397 @@
+import type { AffinityEgressOptions, AffinityTarget } from '../../shared/affinity/index.ts';
+import { canonicalResponsesItemType, createTemporaryResponsesItemId, hashResponsesItemBinding } from '../items/format.ts';
+import { eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
+import type { ResponsesOutputItem, ResponsesOutputReasoning, ResponsesResult, ResponsesStreamEvent } from '@floway-dev/protocols/responses';
+
+const carrierDomain = (itemType: string, slot: string): string =>
+  `responses.${canonicalResponsesItemType(itemType)}.${slot}`;
+
+const itemAffinity = (base: AffinityTarget, item: ResponsesOutputItem): AffinityTarget => ({
+  ...base,
+  ...('id' in item && typeof item.id === 'string' ? { upstreamItemId: item.id } : {}),
+});
+
+const opaqueSlots = (item: ResponsesOutputItem): Array<{ key: string; value: string }> => {
+  const slots: Array<{ key: string; value: string }> = [];
+  const record = item as unknown as Record<string, unknown>;
+  if (typeof record.encrypted_content === 'string') {
+    slots.push({ key: 'encrypted_content', value: record.encrypted_content });
+  }
+  if (item.type === 'program' && typeof item.fingerprint === 'string') {
+    slots.push({ key: 'fingerprint', value: item.fingerprint });
+  }
+  if (item.type === 'agent_message' && Array.isArray(record.content)) {
+    record.content.forEach((part, index) => {
+      if (!part || typeof part !== 'object') return;
+      const content = part as Record<string, unknown>;
+      if (content.type === 'encrypted_content' && typeof content.encrypted_content === 'string') {
+        slots.push({ key: `content.${index}.encrypted_content`, value: content.encrypted_content });
+      }
+    });
+  }
+  return slots;
+};
+
+const replaceOpaqueSlots = (
+  item: ResponsesOutputItem,
+  replacements: ReadonlyMap<string, string>,
+): ResponsesOutputItem => {
+  const record = item as unknown as Record<string, unknown>;
+  const topLevel = Object.fromEntries([...replacements].filter(([key]) => !key.startsWith('content.')));
+  const content = Array.isArray(record.content)
+    ? record.content.map((part, index) => {
+        const replacement = replacements.get(`content.${index}.encrypted_content`);
+        return replacement === undefined || !part || typeof part !== 'object'
+          ? part
+          : { ...(part as Record<string, unknown>), encrypted_content: replacement };
+      })
+    : undefined;
+  return {
+    ...item,
+    ...topLevel,
+    ...(content !== undefined ? { content } : {}),
+  } as ResponsesOutputItem;
+};
+
+const wrapNaturalResponsesAffinity = async function* (
+  frames: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>,
+  options: AffinityEgressOptions,
+): AsyncGenerator<ProtocolFrame<ResponsesStreamEvent>> {
+  const wrapped = new Map<string, Promise<string>>();
+
+  const wrapItem = async (item: ResponsesOutputItem, outputIndex: number): Promise<ResponsesOutputItem> => {
+    const slots = opaqueSlots(item);
+    if (slots.length === 0) return item;
+    const target = itemAffinity(options.affinity, item);
+    const itemId = 'id' in item && typeof item.id === 'string' ? item.id : '';
+    const replacements = new Map<string, string>();
+    await Promise.all(slots.map(async slot => {
+      const cacheKey = `${outputIndex}\0${itemId}\0${slot.key}\0${slot.value}`;
+      let replacement = wrapped.get(cacheKey);
+      if (replacement === undefined) {
+        replacement = options.codec.wrap(slot.value, target, carrierDomain(item.type, slot.key));
+        wrapped.set(cacheKey, replacement);
+      }
+      replacements.set(slot.key, await replacement);
+    }));
+    return replaceOpaqueSlots(item, replacements);
+  };
+
+  const wrapResult = async (response: ResponsesResult): Promise<ResponsesResult> => ({
+    ...response,
+    output: await Promise.all(response.output.map(async (item, index) => await wrapItem(item, index))),
+  });
+
+  for await (const frame of frames) {
+    if (frame.type !== 'event') {
+      yield frame;
+      continue;
+    }
+
+    const event = frame.event;
+    if (event.type === 'response.output_item.added' || event.type === 'response.output_item.done') {
+      yield eventFrame({ ...event, item: await wrapItem(event.item, event.output_index) });
+      continue;
+    }
+    if (
+      event.type === 'response.created'
+      || event.type === 'response.in_progress'
+      || event.type === 'response.completed'
+      || event.type === 'response.incomplete'
+      || event.type === 'response.failed'
+    ) {
+      yield eventFrame({ ...event, response: await wrapResult(event.response) });
+      if (event.type === 'response.completed' || event.type === 'response.incomplete' || event.type === 'response.failed') return;
+      continue;
+    }
+
+    yield frame;
+    if (event.type === 'error') return;
+  }
+};
+
+const canCarryAffinity = (item: ResponsesOutputItem): boolean =>
+  ['reasoning', 'compaction', 'compaction_summary', 'context_compaction', 'agent_message', 'program'].includes(item.type);
+
+const requiresBoundCarrier = (item: ResponsesOutputItem): boolean =>
+  item.type === 'program_output' && opaqueSlots(item).length === 0;
+
+const addSequenceOffset = <T extends ResponsesStreamEvent>(event: T, offset: number): T =>
+  event.sequence_number === undefined ? event : { ...event, sequence_number: event.sequence_number + offset };
+
+const addOutputIndexOffset = <T extends ResponsesStreamEvent>(event: T, offset: number): T =>
+  offset === 0 || !('output_index' in event)
+    ? event
+    : { ...event, output_index: event.output_index + offset } as T;
+
+interface InsertedCarrier {
+  readonly outputIndex: number;
+  readonly added: ResponsesOutputReasoning;
+  readonly expectsBoundItem: boolean;
+  completed?: ResponsesOutputReasoning;
+  boundItem?: NonNullable<AffinityTarget['boundItem']>;
+}
+
+const wrapResponsesCarrierLifecycle = async function* (
+  frames: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>,
+  options: AffinityEgressOptions,
+): AsyncGenerator<ProtocolFrame<ResponsesStreamEvent>> {
+  // Natural opaque fields are wrapped independently above. This outer state
+  // machine gives output index zero a carrier: augment a carrier-capable item
+  // at close, or open a reasoning prefix immediately and complete it with the
+  // canonical bound item at that item's close. Visible content is never held
+  // back while the binding waits for its final ID and content hash.
+  const syntheticItemCarriers = new Map<string, Promise<string>>();
+  let firstItem: { readonly outputIndex: number; readonly canCarry: boolean } | undefined;
+  const insertedItems = new Map<number, InsertedCarrier>();
+  const insertedItemIndexes: number[] = [];
+  let sequenceOffset = 0;
+
+  const outputIndexOffset = (originalOutputIndex: number): number => {
+    let low = 0;
+    let high = insertedItemIndexes.length;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if (insertedItemIndexes[middle] <= originalOutputIndex) low = middle + 1;
+      else high = middle;
+    }
+    return low;
+  };
+
+  const startCarrierBefore = (
+    originalOutputIndex: number,
+    sequenceNumber: number | undefined,
+    expectsBoundItem = true,
+  ): ResponsesStreamEvent[] => {
+    const existing = insertedItems.get(originalOutputIndex);
+    if (existing !== undefined) return [];
+    const added: ResponsesOutputReasoning = {
+      type: 'reasoning',
+      id: createTemporaryResponsesItemId('reasoning'),
+      summary: [],
+    };
+    const insertionPoint = outputIndexOffset(originalOutputIndex);
+    const shiftedOutputIndex = originalOutputIndex + insertionPoint;
+    insertedItemIndexes.splice(insertionPoint, 0, originalOutputIndex);
+    insertedItems.set(originalOutputIndex, { outputIndex: shiftedOutputIndex, added, expectsBoundItem });
+    const shiftedSequence = sequenceNumber === undefined ? undefined : sequenceNumber + sequenceOffset;
+    sequenceOffset += 1;
+    return [
+      {
+        type: 'response.output_item.added',
+        output_index: shiftedOutputIndex,
+        item: added,
+        ...(shiftedSequence !== undefined ? { sequence_number: shiftedSequence } : {}),
+      },
+    ];
+  };
+
+  const completeCarrierBefore = async (
+    item: ResponsesOutputItem | undefined,
+    originalOutputIndex: number,
+    sequenceNumber: number | undefined,
+  ): Promise<ResponsesStreamEvent[]> => {
+    const inserted = insertedItems.get(originalOutputIndex);
+    if (inserted === undefined) throw new Error(`Responses affinity carrier ${originalOutputIndex} completed before it started`);
+    if (inserted.expectsBoundItem && item === undefined) {
+      throw new Error(`Responses output item ${originalOutputIndex} disappeared before its affinity carrier closed`);
+    }
+    const upstreamItemId = item !== undefined && 'id' in item && typeof item.id === 'string' ? item.id : undefined;
+    const boundItem = item !== undefined
+      ? {
+          type: item.type,
+          ...(upstreamItemId !== undefined ? { upstreamItemId } : {}),
+          contentHash: await hashResponsesItemBinding(item),
+        }
+      : undefined;
+    if (inserted.completed !== undefined) {
+      if (
+        inserted.boundItem?.type !== boundItem?.type
+        || inserted.boundItem?.upstreamItemId !== boundItem?.upstreamItemId
+        || inserted.boundItem?.contentHash !== boundItem?.contentHash
+      ) throw new Error(`Responses output item ${originalOutputIndex} changed after its affinity binding closed`);
+      return [];
+    }
+    const target: AffinityTarget = {
+      ...options.affinity,
+      syntheticItem: true,
+      ...(boundItem !== undefined ? { boundItem } : {}),
+    };
+    const completed: ResponsesOutputReasoning = {
+      ...inserted.added,
+      encrypted_content: await options.codec.wrap(undefined, target, carrierDomain('reasoning', 'encrypted_content')),
+    };
+    inserted.completed = completed;
+    inserted.boundItem = boundItem;
+    const shiftedSequence = sequenceNumber === undefined ? undefined : sequenceNumber + sequenceOffset;
+    sequenceOffset += 1;
+    return [{
+      type: 'response.output_item.done',
+      output_index: inserted.outputIndex,
+      item: completed,
+      ...(shiftedSequence !== undefined ? { sequence_number: shiftedSequence } : {}),
+    }];
+  };
+
+  const ensureItemCarrier = async (item: ResponsesOutputItem, outputIndex: number): Promise<ResponsesOutputItem> => {
+    if (opaqueSlots(item).length > 0) return item;
+    if (!canCarryAffinity(item)) throw new Error(`Responses item type ${item.type} cannot carry affinity`);
+    const target = itemAffinity(options.affinity, item);
+    const itemId = 'id' in item && typeof item.id === 'string' ? item.id : '';
+    if (item.type === 'program') {
+      const slot = 'fingerprint';
+      const cacheKey = `${outputIndex}\0${itemId}\0${slot}`;
+      let fingerprint = syntheticItemCarriers.get(cacheKey);
+      if (fingerprint === undefined) {
+        fingerprint = options.codec.wrap(undefined, target, carrierDomain(item.type, slot));
+        syntheticItemCarriers.set(cacheKey, fingerprint);
+      }
+      return { ...item, fingerprint: await fingerprint };
+    }
+    if (item.type === 'agent_message') {
+      const slot = `content.${item.content.length}.encrypted_content`;
+      const cacheKey = `${outputIndex}\0${itemId}\0${slot}`;
+      let encrypted = syntheticItemCarriers.get(cacheKey);
+      if (encrypted === undefined) {
+        encrypted = options.codec.wrap(undefined, target, carrierDomain(item.type, slot));
+        syntheticItemCarriers.set(cacheKey, encrypted);
+      }
+      return { ...item, content: [...item.content, { type: 'encrypted_content', encrypted_content: await encrypted }] };
+    }
+
+    const cacheKey = `${outputIndex}\0${itemId}\0encrypted_content`;
+    let encrypted = syntheticItemCarriers.get(cacheKey);
+    if (encrypted === undefined) {
+      encrypted = options.codec.wrap(undefined, target, carrierDomain(item.type, 'encrypted_content'));
+      syntheticItemCarriers.set(cacheKey, encrypted);
+    }
+    return { ...item, encrypted_content: await encrypted } as ResponsesOutputItem;
+  };
+
+  const rewriteResponse = async (response: ResponsesResult, synthesizeMissing: boolean): Promise<ResponsesResult> => {
+    let output = synthesizeMissing
+      ? await Promise.all(response.output.map(async (item, index) => {
+          const firstNeedsCarrier = firstItem?.canCarry
+            && index === firstItem.outputIndex
+            && !insertedItems.has(index);
+          return firstNeedsCarrier || (item.type === 'program' && opaqueSlots(item).length === 0)
+            ? await ensureItemCarrier(item, index)
+            : item;
+        }))
+      : response.output;
+    const interleaved: ResponsesOutputItem[] = [];
+    for (let index = 0; index <= output.length; index += 1) {
+      const inserted = insertedItems.get(index);
+      if (inserted !== undefined) interleaved.push(inserted.completed ?? inserted.added);
+      if (output[index] !== undefined) interleaved.push(output[index]);
+    }
+    output = interleaved;
+    return { ...response, output };
+  };
+
+  const shifted = (event: ResponsesStreamEvent): ResponsesStreamEvent =>
+    addSequenceOffset(
+      addOutputIndexOffset(event, 'output_index' in event ? outputIndexOffset(event.output_index) : 0),
+      sequenceOffset,
+    );
+
+  const discoverSnapshotCarriers = (
+    response: ResponsesResult,
+    sequenceNumber: number | undefined,
+  ): ResponsesStreamEvent[] => {
+    const events: ResponsesStreamEvent[] = [];
+    if (firstItem === undefined && response.output[0] !== undefined) {
+      const first = response.output[0];
+      firstItem = { outputIndex: 0, canCarry: canCarryAffinity(first) };
+      if (!firstItem.canCarry) events.push(...startCarrierBefore(0, sequenceNumber));
+    }
+    for (const [outputIndex, item] of response.output.entries()) {
+      if (requiresBoundCarrier(item)) events.push(...startCarrierBefore(outputIndex, sequenceNumber));
+    }
+    return events;
+  };
+
+  for await (const frame of frames) {
+    if (frame.type !== 'event') {
+      yield frame;
+      continue;
+    }
+
+    const event = frame.event;
+    if (event.type === 'response.output_item.added') {
+      if (firstItem === undefined) {
+        firstItem = { outputIndex: event.output_index, canCarry: canCarryAffinity(event.item) };
+        if (!firstItem.canCarry) {
+          for (const inserted of startCarrierBefore(event.output_index, event.sequence_number)) yield eventFrame(inserted);
+        }
+      } else if (requiresBoundCarrier(event.item)) {
+        for (const inserted of startCarrierBefore(event.output_index, event.sequence_number)) yield eventFrame(inserted);
+      }
+      yield eventFrame(shifted(event));
+      continue;
+    }
+
+    if (event.type === 'response.output_item.done') {
+      if (requiresBoundCarrier(event.item) && !insertedItems.has(event.output_index)) {
+        for (const inserted of startCarrierBefore(event.output_index, event.sequence_number)) yield eventFrame(inserted);
+      }
+      if (insertedItems.has(event.output_index)) {
+        for (const inserted of await completeCarrierBefore(event.item, event.output_index, event.sequence_number)) yield eventFrame(inserted);
+      }
+      const item = (firstItem?.canCarry
+        && event.output_index === firstItem.outputIndex
+        && !insertedItems.has(event.output_index))
+        || (event.item.type === 'program' && opaqueSlots(event.item).length === 0)
+        ? await ensureItemCarrier(event.item, event.output_index)
+        : event.item;
+      yield eventFrame(shifted({ ...event, item }));
+      continue;
+    }
+
+    if (event.type === 'response.completed' || event.type === 'response.incomplete') {
+      if (firstItem === undefined) {
+        const first = event.response.output[0];
+        if (first !== undefined && canCarryAffinity(first)) {
+          firstItem = { outputIndex: 0, canCarry: true };
+        } else {
+          for (const inserted of startCarrierBefore(0, event.sequence_number, first !== undefined)) yield eventFrame(inserted);
+          firstItem = first === undefined ? undefined : { outputIndex: 0, canCarry: false };
+        }
+      }
+      for (const [outputIndex, item] of event.response.output.entries()) {
+        if (requiresBoundCarrier(item) && !insertedItems.has(outputIndex)) {
+          for (const inserted of startCarrierBefore(outputIndex, event.sequence_number)) yield eventFrame(inserted);
+        }
+      }
+      for (const outputIndex of insertedItems.keys()) {
+        const item = event.response.output[outputIndex];
+        for (const completed of await completeCarrierBefore(item, outputIndex, event.sequence_number)) yield eventFrame(completed);
+      }
+      const response = await rewriteResponse(event.response, true);
+      yield eventFrame(addSequenceOffset({ ...event, response }, sequenceOffset));
+      return;
+    }
+
+    if (event.type === 'response.created' || event.type === 'response.in_progress') {
+      for (const inserted of discoverSnapshotCarriers(event.response, event.sequence_number)) yield eventFrame(inserted);
+      const response = await rewriteResponse(event.response, false);
+      yield eventFrame(addSequenceOffset({ ...event, response }, sequenceOffset));
+      continue;
+    }
+
+    if (event.type === 'response.failed') {
+      const response = await rewriteResponse(event.response, false);
+      yield eventFrame(addSequenceOffset({ ...event, response }, sequenceOffset));
+      return;
+    }
+
+    yield eventFrame(shifted(event));
+    if (event.type === 'error') return;
+  }
+};
+
+export const wrapResponsesAffinityEgress = (
+  frames: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>,
+  options: AffinityEgressOptions,
+): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> =>
+  wrapResponsesCarrierLifecycle(wrapNaturalResponsesAffinity(frames, options), options);
diff --git a/packages/gateway/src/data-plane/chat/responses/affinity/egress_test.ts b/packages/gateway/src/data-plane/chat/responses/affinity/egress_test.ts
new file mode 100644
index 000000000..cc204cee3
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/responses/affinity/egress_test.ts
@@ -0,0 +1,412 @@
+import { describe, expect, test, vi } from 'vitest';
+
+import { wrapResponsesAffinityEgress } from './egress.ts';
+import type { AffinityCodec, AffinityTarget } from '../../shared/affinity/index.ts';
+import { hashResponsesItemBinding } from '../items/format.ts';
+import { eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
+import type { ResponsesOutputItem, ResponsesOutputReasoning, ResponsesResult, ResponsesStreamEvent } from '@floway-dev/protocols/responses';
+
+const affinity: AffinityTarget = {
+  upstreamId: 'up-a',
+  modelId: 'model-a',
+};
+
+type AffinityEgressCodec = Pick<AffinityCodec, 'wrap'>;
+
+const frames = async function* (values: ProtocolFrame<ResponsesStreamEvent>[]) {
+  yield* values;
+};
+
+class DelayedCodec implements AffinityEgressCodec {
+  readonly calls: Array<{ value: string | undefined; resolve: (value: string) => void }> = [];
+
+  wrap(value: string | undefined): Promise<string> {
+    return new Promise(resolve => this.calls.push({ value, resolve }));
+  }
+}
+
+const immediateCodec: AffinityEgressCodec = {
+  wrap: async value => `wrapped:${value ?? 'synthetic'}`,
+};
+
+const response = (output: ResponsesResult['output'], status: ResponsesResult['status'] = 'completed'): ResponsesResult => ({
+  id: 'resp_1',
+  object: 'response',
+  model: 'model-a',
+  output,
+  status,
+  error: null,
+  incomplete_details: null,
+});
+
+describe('Responses affinity egress', () => {
+  test('passes reasoning summary deltas before wrapping and reuses one exact replacement', async () => {
+    const codec = new DelayedCodec();
+    const item: ResponsesOutputReasoning = {
+      type: 'reasoning',
+      id: 'rs_1',
+      summary: [{ type: 'summary_text', text: 'visible' }],
+      encrypted_content: 'opaque',
+    };
+    const output = wrapResponsesAffinityEgress(frames([
+      eventFrame({
+        type: 'response.reasoning_summary_text.delta',
+        item_id: 'rs_1',
+        output_index: 0,
+        summary_index: 0,
+        delta: 'visible',
+      }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item }),
+      eventFrame({ type: 'response.completed', response: response([item]) }),
+    ]), { codec, affinity })[Symbol.asyncIterator]();
+
+    expect((await output.next()).value).toMatchObject({
+      event: { type: 'response.reasoning_summary_text.delta', delta: 'visible' },
+    });
+    expect(codec.calls).toHaveLength(0);
+
+    const donePending = output.next();
+    await vi.waitFor(() => expect(codec.calls.map(call => call.value)).toEqual(['opaque']));
+    codec.calls[0].resolve('wrapped-opaque');
+    expect((await donePending).value).toMatchObject({
+      event: { item: { encrypted_content: 'wrapped-opaque' } },
+    });
+
+    expect((await output.next()).value).toMatchObject({
+      event: { response: { output: [{ encrypted_content: 'wrapped-opaque' }] } },
+    });
+    expect(codec.calls).toHaveLength(1);
+  });
+
+  test('caches replacements across added, done, and terminal snapshots', async () => {
+    const calls: Array<string | undefined> = [];
+    const codec: AffinityEgressCodec = {
+      wrap: async value => {
+        calls.push(value);
+        return `wrapped:${value}`;
+      },
+    };
+    const item: ResponsesOutputReasoning = { type: 'reasoning', id: 'rs_1', summary: [], encrypted_content: 'opaque' };
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.output_item.added', output_index: 0, item }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item }),
+      eventFrame({ type: 'response.completed', response: response([item]) }),
+    ]), { codec, affinity })) output.push(frame);
+
+    expect(calls).toEqual(['opaque']);
+    expect(output).toHaveLength(3);
+    for (const frame of output) expect(JSON.stringify(frame)).toContain('wrapped:opaque');
+  });
+
+  test('injects one synthetic reasoning lifecycle before a carrier-free terminal response', async () => {
+    const message = {
+      type: 'message' as const,
+      id: 'msg_1',
+      role: 'assistant' as const,
+      status: 'completed',
+      content: [{ type: 'output_text' as const, text: 'answer' }],
+    };
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.completed', response: response([message]) }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output.map(frame => frame.type === 'event' ? frame.event.type : frame.type)).toEqual([
+      'response.output_item.added',
+      'response.output_item.done',
+      'response.completed',
+    ]);
+    const added = output[0];
+    const done = output[1];
+    if (added.type !== 'event' || added.event.type !== 'response.output_item.added') throw new Error('Expected added event');
+    if (done.type !== 'event' || done.event.type !== 'response.output_item.done') throw new Error('Expected done event');
+    expect(added.event.item).not.toHaveProperty('encrypted_content');
+    expect(done.event.item).toMatchObject({
+      type: 'reasoning',
+      summary: [],
+      encrypted_content: 'wrapped:synthetic',
+    });
+    expect(output[2]).toMatchObject({ event: { response: { output: [done.event.item, message] } } });
+  });
+
+  test('does not synthesize affinity for a failed response', async () => {
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.failed', response: response([], 'failed') }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toEqual([eventFrame({ type: 'response.failed', response: response([], 'failed') })]);
+  });
+
+  test('does not synthesize a missing program carrier in a failed snapshot', async () => {
+    const program = { type: 'program', id: 'prog_1', call_id: 'call_1', code: 'return 1' } as ResponsesOutputItem;
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.failed', response: response([program], 'failed') }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toEqual([eventFrame({ type: 'response.failed', response: response([program], 'failed') })]);
+  });
+
+  test('adds one synthetic carrier to a real first reasoning item at item close', async () => {
+    const reasoning: ResponsesOutputReasoning = { type: 'reasoning', id: 'rs_1', summary: [] };
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.output_item.added', output_index: 0, item: reasoning }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item: reasoning }),
+      eventFrame({ type: 'response.completed', response: response([reasoning]) }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toHaveLength(3);
+    expect(output[0]).not.toMatchObject({ event: { item: { encrypted_content: expect.anything() } } });
+    expect(output[1]).toMatchObject({ event: { item: { encrypted_content: 'wrapped:synthetic' } } });
+    expect(output[2]).toMatchObject({ event: { response: { output: [{ encrypted_content: 'wrapped:synthetic' }] } } });
+  });
+
+  test('keeps force policy out of the encrypted natural carrier', async () => {
+    const reasoning: ResponsesOutputReasoning = { type: 'reasoning', id: 'rs_1', summary: [], encrypted_content: 'opaque' };
+    const program = { type: 'program' as const, id: 'prog_1', call_id: 'call_1', code: 'return 1', fingerprint: 'fp' };
+    const calls: AffinityTarget[] = [];
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.completed', response: response([reasoning, program]) }),
+    ]), {
+      codec: {
+        wrap: async (_value, target) => {
+          calls.push(target);
+          return `wrapped:${target.syntheticItem === true ? 'synthetic' : 'natural'}`;
+        },
+      },
+      affinity,
+    })) output.push(frame);
+
+    expect(calls.map(call => call.syntheticItem === true)).toEqual([false, false]);
+    expect(output).toHaveLength(1);
+  });
+
+  test('waits for a program fingerprint before deciding whether it needs a prefix', async () => {
+    const added = { type: 'program', id: 'prog_1', call_id: 'call_1', code: 'return 1' } as ResponsesOutputItem;
+    const done = { ...added, fingerprint: 'fp' } as ResponsesOutputItem;
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.output_item.added', output_index: 0, item: added }),
+      eventFrame({ type: 'response.in_progress', response: response([added], 'in_progress') }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item: done }),
+      eventFrame({ type: 'response.completed', response: response([done]) }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toHaveLength(4);
+    expect(JSON.stringify(output)).not.toContain('"type":"reasoning"');
+    expect(output[1]).not.toMatchObject({ event: { response: { output: [{ fingerprint: expect.anything() }] } } });
+    expect(output[2]).toMatchObject({ event: { item: { type: 'program', fingerprint: 'wrapped:fp' } } });
+    expect(output[3]).toMatchObject({ event: { response: { output: [{ type: 'program', fingerprint: 'wrapped:fp' }] } } });
+  });
+
+  test('uses the program fingerprint slot for a synthetic carrier at close', async () => {
+    const program = { type: 'program', id: 'prog_1', call_id: 'call_1', code: 'return 1' } as ResponsesOutputItem;
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.output_item.added', output_index: 0, item: program }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item: program }),
+      eventFrame({ type: 'response.completed', response: response([program]) }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output).toHaveLength(3);
+    expect(JSON.stringify(output)).not.toContain('"type":"reasoning"');
+    expect(output[0]).not.toMatchObject({ event: { item: { fingerprint: expect.anything() } } });
+    expect(output[1]).toMatchObject({ event: { item: { fingerprint: 'wrapped:synthetic' } } });
+    expect(output[2]).toMatchObject({ event: { response: { output: [{ fingerprint: 'wrapped:synthetic' }] } } });
+  });
+
+  test('prefixes a non-carrier item and shifts output and sequence indexes', async () => {
+    const message = {
+      type: 'message' as const,
+      id: 'msg_1',
+      role: 'assistant' as const,
+      status: 'completed',
+      content: [{ type: 'output_text' as const, text: 'answer' }],
+    };
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.output_item.added', output_index: 0, item: message, sequence_number: 2 }),
+      eventFrame({ type: 'response.output_text.delta', item_id: 'msg_1', output_index: 0, content_index: 0, delta: 'answer', sequence_number: 3 }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item: message, sequence_number: 4 }),
+      eventFrame({ type: 'response.completed', response: response([message]), sequence_number: 5 }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    expect(output.map(frame => frame.type === 'event' ? [frame.event.type, frame.event.sequence_number] : [frame.type])).toEqual([
+      ['response.output_item.added', 2],
+      ['response.output_item.added', 3],
+      ['response.output_text.delta', 4],
+      ['response.output_item.done', 5],
+      ['response.output_item.done', 6],
+      ['response.completed', 7],
+    ]);
+    expect(output[1]).toMatchObject({ event: { output_index: 1 } });
+    expect(output[2]).toMatchObject({ event: { output_index: 1 } });
+    expect(output[3]).toMatchObject({ event: { output_index: 0, item: { encrypted_content: 'wrapped:synthetic' } } });
+    expect(output[4]).toMatchObject({ event: { output_index: 1 } });
+    expect(output[5]).toMatchObject({ event: { response: { output: [{ type: 'reasoning' }, message] } } });
+  });
+
+  test('keeps an earlier open item on its lifecycle index after a later insertion', async () => {
+    const message = {
+      type: 'message' as const,
+      id: 'msg_1',
+      role: 'assistant' as const,
+      status: 'completed',
+      content: [{ type: 'output_text' as const, text: 'answer' }],
+    };
+    const programOutput = { type: 'program_output' as const, id: 'prog_out_1', call_id: 'call_1', result: 'done', status: 'completed' as const };
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.output_item.added', output_index: 0, item: message, sequence_number: 0 }),
+      eventFrame({ type: 'response.output_item.added', output_index: 1, item: programOutput, sequence_number: 1 }),
+      eventFrame({ type: 'response.output_text.delta', item_id: 'msg_1', output_index: 0, content_index: 0, delta: 'answer', sequence_number: 2 }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item: message, sequence_number: 3 }),
+      eventFrame({ type: 'response.output_item.done', output_index: 1, item: programOutput, sequence_number: 4 }),
+      eventFrame({ type: 'response.completed', response: response([message, programOutput]), sequence_number: 5 }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    const delta = output.find(frame => frame.type === 'event' && frame.event.type === 'response.output_text.delta');
+    const messageDone = output.find(frame =>
+      frame.type === 'event'
+      && frame.event.type === 'response.output_item.done'
+      && frame.event.item.type === 'message');
+    expect(delta).toMatchObject({ event: { output_index: 1 } });
+    expect(messageDone).toMatchObject({ event: { output_index: 1 } });
+    expect(output.at(-1)).toMatchObject({
+      event: { response: { output: [{ type: 'reasoning' }, message, { type: 'reasoning' }, programOutput] } },
+    });
+  });
+
+  test('discovers the first prefix from an in-progress snapshot before item added', async () => {
+    const message = {
+      type: 'message' as const,
+      id: 'msg_1',
+      role: 'assistant' as const,
+      status: 'completed',
+      content: [{ type: 'output_text' as const, text: 'answer' }],
+    };
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.in_progress', response: response([message], 'in_progress'), sequence_number: 0 }),
+      eventFrame({ type: 'response.output_item.added', output_index: 0, item: message, sequence_number: 1 }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item: message, sequence_number: 2 }),
+      eventFrame({ type: 'response.completed', response: response([message]), sequence_number: 3 }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    const inProgress = output.find(frame => frame.type === 'event' && frame.event.type === 'response.in_progress');
+    const added = output.find(frame =>
+      frame.type === 'event'
+      && frame.event.type === 'response.output_item.added'
+      && frame.event.item.type === 'message');
+    expect(inProgress).toMatchObject({ event: { response: { output: [{ type: 'reasoning' }, message] } } });
+    expect(added).toMatchObject({ event: { output_index: 1, item: message } });
+  });
+
+  test('discovers a later bound prefix from an in-progress snapshot before item added', async () => {
+    const reasoning: ResponsesOutputReasoning = { type: 'reasoning', id: 'rs_1', summary: [], encrypted_content: 'opaque' };
+    const programOutput = { type: 'program_output' as const, id: 'prog_out_1', call_id: 'call_1', result: 'done', status: 'completed' as const };
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.in_progress', response: response([reasoning, programOutput], 'in_progress'), sequence_number: 0 }),
+      eventFrame({ type: 'response.output_item.added', output_index: 1, item: programOutput, sequence_number: 1 }),
+      eventFrame({ type: 'response.output_item.done', output_index: 1, item: programOutput, sequence_number: 2 }),
+      eventFrame({ type: 'response.completed', response: response([reasoning, programOutput]), sequence_number: 3 }),
+    ]), { codec: immediateCodec, affinity })) output.push(frame);
+
+    const inProgress = output.find(frame => frame.type === 'event' && frame.event.type === 'response.in_progress');
+    const added = output.find(frame =>
+      frame.type === 'event'
+      && frame.event.type === 'response.output_item.added'
+      && frame.event.item.type === 'program_output');
+    expect(inProgress).toMatchObject({
+      event: { response: { output: [{ type: 'reasoning' }, { type: 'reasoning' }, programOutput] } },
+    });
+    expect(added).toMatchObject({ event: { output_index: 2, item: programOutput } });
+  });
+
+  test('binds a prefixed item from its canonical done snapshot', async () => {
+    const addedItem = { type: 'program_output' as const, id: 'initial_upstream', call_id: 'call_1', result: '', status: 'incomplete' as const };
+    const doneItem = { type: 'program_output' as const, id: 'final_upstream', call_id: 'call_1', result: 'done', status: 'completed' as const };
+    const calls: AffinityTarget[] = [];
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.output_item.added', output_index: 0, item: addedItem }),
+      eventFrame({ type: 'response.output_item.done', output_index: 0, item: doneItem }),
+      eventFrame({ type: 'response.completed', response: response([doneItem]) }),
+    ]), {
+      codec: {
+        wrap: async (_value, target) => {
+          calls.push(target);
+          return 'wrapped';
+        },
+      },
+      affinity,
+    })) output.push(frame);
+
+    expect(calls).toContainEqual({
+      ...affinity,
+      syntheticItem: true,
+      boundItem: {
+        type: 'program_output',
+        upstreamItemId: 'final_upstream',
+        contentHash: await hashResponsesItemBinding(doneItem),
+      },
+    });
+    expect(output.map(frame => frame.type === 'event' ? frame.event.type : frame.type)).toEqual([
+      'response.output_item.added',
+      'response.output_item.added',
+      'response.output_item.done',
+      'response.output_item.done',
+      'response.completed',
+    ]);
+    expect(output[4]).toMatchObject({ event: { response: { output: [{ encrypted_content: 'wrapped' }, doneItem] } } });
+  });
+
+  test('binds a prefixed force item to its original upstream ID', async () => {
+    const programOutput = { type: 'program_output' as const, id: 'prog_out_upstream', call_id: 'call_1', result: 'done', status: 'completed' as const };
+    const calls: AffinityTarget[] = [];
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.completed', response: response([programOutput]) }),
+    ]), {
+      codec: {
+        wrap: async (_value, target) => {
+          calls.push(target);
+          return 'wrapped';
+        },
+      },
+      affinity,
+    })) output.push(frame);
+
+    expect(calls).toContainEqual({
+      ...affinity,
+      syntheticItem: true,
+      boundItem: {
+        type: 'program_output',
+        upstreamItemId: 'prog_out_upstream',
+        contentHash: await hashResponsesItemBinding(programOutput),
+      },
+    });
+    expect(output).toHaveLength(3);
+  });
+
+  test('wraps compaction_summary as a natural carrier without inserting a prefix', async () => {
+    const item = { type: 'compaction_summary', id: 'cmp_upstream', encrypted_content: 'opaque' } as unknown as ResponsesOutputItem;
+    const values: Array<string | undefined> = [];
+    const output: ProtocolFrame<ResponsesStreamEvent>[] = [];
+    for await (const frame of wrapResponsesAffinityEgress(frames([
+      eventFrame({ type: 'response.completed', response: response([item]) }),
+    ]), {
+      codec: { wrap: async value => { values.push(value); return 'wrapped'; } },
+      affinity,
+    })) output.push(frame);
+
+    expect(values).toEqual(['opaque']);
+    expect(output).toHaveLength(1);
+    expect(output[0]).toMatchObject({ event: { response: { output: [{ type: 'compaction_summary', encrypted_content: 'wrapped' }] } } });
+  });
+});
diff --git a/packages/gateway/src/data-plane/chat/responses/affinity/ingress.ts b/packages/gateway/src/data-plane/chat/responses/affinity/ingress.ts
new file mode 100644
index 000000000..5692c484e
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/responses/affinity/ingress.ts
@@ -0,0 +1,221 @@
+import { type AffinityCodec, blobForExactCandidate, blobForForcedCandidate, type AffinityEvidence, type AffinityTarget, type DecodedAffinityBlob, type PreparedAffinityPayload } from '../../shared/affinity/index.ts';
+import { canonicalResponsesItemType, createTemporaryResponsesItemId, hashResponsesItemBinding } from '../items/format.ts';
+import type { CanonicalResponsesPayload, ResponsesInputItem } from '@floway-dev/protocols/responses';
+import type { ModelCandidate } from '@floway-dev/provider';
+
+interface ResponsesBlobLocation {
+  readonly itemIndex: number;
+  readonly slot: string;
+  readonly contentIndex?: number;
+  readonly decoded: DecodedAffinityBlob;
+}
+
+const carrierDomain = (itemType: string, slot: string): string =>
+  `responses.${canonicalResponsesItemType(itemType)}.${slot}`;
+
+type OwnedResponsesBlobLocation = ResponsesBlobLocation & {
+  readonly decoded: Extract<DecodedAffinityBlob, { kind: 'owned' }>;
+};
+
+interface ValidatedBoundCarrier {
+  readonly decoded: Extract<DecodedAffinityBlob, { kind: 'owned' }>;
+  readonly boundItem: NonNullable<AffinityTarget['boundItem']>;
+}
+
+const isOwnedLocation = (location: ResponsesBlobLocation): location is OwnedResponsesBlobLocation =>
+  location.decoded.kind === 'owned';
+
+export class ResponsesAffinityInputError extends Error {
+  readonly param: string;
+
+  constructor(message: string, param: string) {
+    super(message);
+    this.name = 'ResponsesAffinityInputError';
+    this.param = param;
+  }
+}
+
+export interface PreparedResponsesAffinity extends PreparedAffinityPayload<CanonicalResponsesPayload> {
+  readonly itemIdMapForCandidate: (candidate: ModelCandidate) => ReadonlyMap<string, string>;
+}
+
+const itemInheritsForce = (item: ResponsesInputItem): boolean =>
+  ['compaction', 'compaction_summary', 'program', 'program_output'].includes(item.type);
+
+const blobRequiresForce = (item: ResponsesInputItem, decoded: DecodedAffinityBlob): boolean =>
+  item.type === 'context_compaction'
+    ? decoded.kind === 'owned' && decoded.value !== undefined
+    : itemInheritsForce(item);
+
+const routingEvidenceFrom = (
+  items: readonly ResponsesInputItem[],
+  locations: readonly ResponsesBlobLocation[],
+): AffinityEvidence[] => {
+  const locationsByItem = Map.groupBy(locations, location => location.itemIndex);
+  const evidence: AffinityEvidence[] = [];
+  let latestTarget: AffinityTarget | undefined;
+
+  for (const [itemIndex, item] of items.entries()) {
+    const itemLocations = locationsByItem.get(itemIndex) ?? [];
+    const owned = itemLocations.filter(isOwnedLocation);
+    for (const location of owned) {
+      latestTarget = location.decoded.envelope.affinity;
+      evidence.push({ target: latestTarget, mode: 'prefer' });
+      if (blobRequiresForce(item, location.decoded)) evidence.push({ target: latestTarget, mode: 'force' });
+    }
+    if (!itemInheritsForce(item) || itemLocations.length > 0) continue;
+    if (latestTarget !== undefined) evidence.push({ target: latestTarget, mode: 'force' });
+  }
+
+  return evidence;
+};
+
+const opaqueBlobLocations = async (
+  items: readonly ResponsesInputItem[],
+  codec: AffinityCodec,
+): Promise<ResponsesBlobLocation[]> => {
+  const locations: ResponsesBlobLocation[] = [];
+  for (const [itemIndex, item] of items.entries()) {
+    const topLevel = (item as { encrypted_content?: unknown }).encrypted_content;
+    if (typeof topLevel === 'string') {
+      locations.push({ itemIndex, slot: 'encrypted_content', decoded: await codec.unwrap(topLevel, carrierDomain(item.type, 'encrypted_content')) });
+    }
+    if (item.type === 'program' && typeof item.fingerprint === 'string') {
+      locations.push({ itemIndex, slot: 'fingerprint', decoded: await codec.unwrap(item.fingerprint, carrierDomain(item.type, 'fingerprint')) });
+    }
+    if (item.type !== 'agent_message') continue;
+    for (const [contentIndex, content] of item.content.entries()) {
+      if (content.type !== 'encrypted_content' || typeof content.encrypted_content !== 'string') continue;
+      locations.push({
+        itemIndex,
+        slot: `content.${contentIndex}.encrypted_content`,
+        contentIndex,
+        decoded: await codec.unwrap(content.encrypted_content, carrierDomain(item.type, `content.${contentIndex}.encrypted_content`)),
+      });
+    }
+  }
+  return locations;
+};
+
+export const prepareResponsesAffinity = async (
+  payload: CanonicalResponsesPayload,
+  codec: AffinityCodec,
+): Promise<PreparedResponsesAffinity> => {
+  const locations = await opaqueBlobLocations(payload.input, codec);
+  const boundItems = new Map<number, ValidatedBoundCarrier>();
+  for (const location of locations) {
+    if (!isOwnedLocation(location)) continue;
+    const affinity = location.decoded.envelope.affinity;
+    const bound = affinity.boundItem;
+    if (bound === undefined) continue;
+    const itemIndex = location.itemIndex + 1;
+    const item = payload.input[itemIndex];
+    if (
+      item === undefined
+      || item.type !== bound.type
+      || !('id' in item)
+      || typeof item.id !== 'string'
+      || await hashResponsesItemBinding(item) !== bound.contentHash
+    ) {
+      throw new ResponsesAffinityInputError(
+        `Affinity carrier does not match the Responses input item at index ${itemIndex}.`,
+        `input[${itemIndex}]`,
+      );
+    }
+    if (boundItems.has(itemIndex)) {
+      throw new ResponsesAffinityInputError(
+        `Multiple affinity carriers bind Responses input item at index ${itemIndex}.`,
+        `input[${itemIndex}]`,
+      );
+    }
+    boundItems.set(itemIndex, { decoded: location.decoded, boundItem: bound });
+  }
+
+  const preparedByCandidate = new WeakMap<ModelCandidate, {
+    readonly payload: CanonicalResponsesPayload;
+    readonly itemIdMap: ReadonlyMap<string, string>;
+  }>();
+  const prepareCandidate = (candidate: ModelCandidate) => {
+    const cached = preparedByCandidate.get(candidate);
+    if (cached !== undefined) return cached;
+    const itemIdMap = new Map<string, string>();
+    const setItemId = (item: ResponsesInputItem, id: string): void => {
+      const existingId = 'id' in item && typeof item.id === 'string' ? item.id : undefined;
+      if (existingId !== undefined && existingId !== id) itemIdMap.set(existingId, id);
+      (item as ResponsesInputItem & { id: string }).id = id;
+    };
+    const candidatePayload = structuredClone(payload);
+    for (const [itemIndex, carrier] of boundItems) {
+      const item = candidatePayload.input[itemIndex]!;
+      const selected = blobRequiresForce(item, carrier.decoded)
+        ? blobForForcedCandidate(carrier.decoded, candidate)
+        : blobForExactCandidate(carrier.decoded, candidate);
+      if (!selected.compatible) setItemId(item, createTemporaryResponsesItemId(item.type));
+      else if (carrier.boundItem.upstreamItemId !== undefined) setItemId(item, carrier.boundItem.upstreamItemId);
+      else delete (item as ResponsesInputItem & { id?: string }).id;
+    }
+    const byItem = Map.groupBy(locations, location => location.itemIndex);
+    const rewritten = candidatePayload.input.flatMap((item, itemIndex): ResponsesInputItem[] => {
+      const itemLocations = byItem.get(itemIndex);
+      if (itemLocations === undefined) return [item];
+      let removeItem = false;
+      const replacement = { ...item } as ResponsesInputItem & Record<string, unknown>;
+      const decisions = itemLocations.map(location => ({
+        location,
+        selected: blobRequiresForce(item, location.decoded)
+          ? blobForForcedCandidate(location.decoded, candidate)
+          : blobForExactCandidate(location.decoded, candidate),
+      }));
+      for (const { location, selected } of decisions) {
+        if (location.contentIndex !== undefined) continue;
+        if (selected.present) {
+          replacement[location.slot] = selected.value;
+        } else {
+          delete replacement[location.slot];
+          if (
+            location.decoded.kind === 'owned'
+            && location.decoded.value === undefined
+            && location.decoded.envelope.affinity.syntheticItem === true
+          ) removeItem = true;
+        }
+      }
+      const nested = new Map(decisions.flatMap(decision =>
+        decision.location.contentIndex === undefined ? [] : [[decision.location.contentIndex, decision] as const]));
+      const removedSyntheticNested = [...nested.values()].some(decision =>
+        decision.location.decoded.kind === 'owned'
+        && decision.location.decoded.value === undefined
+        && !decision.selected.present);
+      if (nested.size > 0) {
+        const agentMessage = replacement as Extract<ResponsesInputItem, { type: 'agent_message' }>;
+        agentMessage.content = agentMessage.content.flatMap((content, contentIndex) => {
+          const decision = nested.get(contentIndex);
+          if (decision === undefined) return [content];
+          return decision.selected.present ? [{ ...content, encrypted_content: decision.selected.value }] : [];
+        });
+      }
+      const compatibleOwned = decisions.find(decision => decision.selected.compatible && decision.location.decoded.kind === 'owned');
+      if (compatibleOwned?.location.decoded.kind === 'owned') {
+        const upstreamItemId = compatibleOwned.location.decoded.envelope.affinity.upstreamItemId;
+        if (upstreamItemId !== undefined) setItemId(replacement, upstreamItemId);
+        else delete replacement.id;
+      } else if (decisions.some(decision => decision.location.decoded.kind === 'owned') && 'id' in replacement && typeof replacement.id === 'string') {
+        setItemId(
+          replacement,
+          createTemporaryResponsesItemId(replacement.type),
+        );
+      }
+      if (removeItem) return [];
+      if (replacement.type === 'agent_message' && replacement.content.length === 0 && !removedSyntheticNested) return [];
+      return [replacement];
+    });
+    const prepared = { payload: { ...candidatePayload, input: rewritten }, itemIdMap };
+    preparedByCandidate.set(candidate, prepared);
+    return prepared;
+  };
+
+  return {
+    routingEvidence: routingEvidenceFrom(payload.input, locations),
+    payloadForCandidate: candidate => structuredClone(prepareCandidate(candidate).payload),
+    itemIdMapForCandidate: candidate => new Map(prepareCandidate(candidate).itemIdMap),
+  };
+};
diff --git a/packages/gateway/src/data-plane/chat/responses/affinity/ingress_test.ts b/packages/gateway/src/data-plane/chat/responses/affinity/ingress_test.ts
new file mode 100644
index 000000000..292e9f276
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/responses/affinity/ingress_test.ts
@@ -0,0 +1,323 @@
+import { expect, test } from 'vitest';
+
+import { prepareResponsesAffinity } from './ingress.ts';
+import { AffinityCodec, type AffinityTarget } from '../../shared/affinity/index.ts';
+import { hashResponsesItemBinding } from '../items/format.ts';
+import type { CanonicalResponsesPayload } from '@floway-dev/protocols/responses';
+import type { ModelCandidate } from '@floway-dev/provider';
+import { stubModelCandidate } from '@floway-dev/test-utils';
+
+const codec = new AffinityCodec('22'.repeat(32));
+const carrierDomain = (itemType: string, slot: string): string => `responses.${itemType}.${slot}`;
+
+const candidate = (upstream: string): ModelCandidate => {
+  const base = stubModelCandidate();
+  return stubModelCandidate({
+    provider: { ...base.provider, upstream },
+    model: { id: 'model' },
+  });
+};
+
+const targetFor = (value: ModelCandidate): AffinityTarget => ({
+  upstreamId: value.provider.upstream,
+  modelId: value.model.id,
+  ...(value.rules !== undefined ? { rules: value.rules } : {}),
+});
+
+const candidateA = candidate('upstream-a');
+const candidateB = candidate('upstream-b');
+
+test('restores the original upstream item id and drops owned state on fallback', async () => {
+  const carrier = await codec.wrap(
+    'encrypted',
+    { ...targetFor(candidateA), upstreamItemId: 'rs_upstream' },
+    carrierDomain('reasoning', 'encrypted_content'),
+  );
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [{ type: 'reasoning', id: 'rs_gateway', summary: [{ type: 'summary_text', text: 'visible' }], encrypted_content: carrier }],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateA).input).toEqual([
+    { type: 'reasoning', id: 'rs_upstream', summary: [{ type: 'summary_text', text: 'visible' }], encrypted_content: 'encrypted' },
+  ]);
+  const fallback = prepared.payloadForCandidate(candidateB).input;
+  expect(fallback).toHaveLength(1);
+  expect(fallback[0]).not.toHaveProperty('encrypted_content');
+  expect((fallback[0] as { id?: string }).id).toMatch(/^rs_tmp_/);
+});
+
+test('applies item-id provenance from nested encrypted content', async () => {
+  const carrier = await codec.wrap(
+    'nested-encrypted',
+    { ...targetFor(candidateA), upstreamItemId: 'amsg_upstream' },
+    carrierDomain('agent_message', 'content.1.encrypted_content'),
+  );
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [{
+      type: 'agent_message',
+      id: 'amsg_gateway',
+      author: 'a',
+      recipient: 'b',
+      content: [
+        { type: 'input_text', text: 'visible' },
+        { type: 'encrypted_content', encrypted_content: carrier },
+      ],
+    }],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateA).input[0]).toMatchObject({
+    id: 'amsg_upstream',
+    content: [{ type: 'input_text', text: 'visible' }, { type: 'encrypted_content', encrypted_content: 'nested-encrypted' }],
+  });
+  expect(prepared.payloadForCandidate(candidateB).input[0]).toMatchObject({
+    id: expect.stringMatching(/^amsg_tmp_/),
+    content: [{ type: 'input_text', text: 'visible' }],
+  });
+});
+
+test('preserves an originally empty agent message after removing its synthetic nested carrier', async () => {
+  const carrier = await codec.wrap(
+    undefined,
+    { ...targetFor(candidateA), upstreamItemId: 'amsg_upstream' },
+    carrierDomain('agent_message', 'content.0.encrypted_content'),
+  );
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [{
+      type: 'agent_message',
+      id: 'amsg_public',
+      author: 'a',
+      recipient: 'b',
+      content: [{ type: 'encrypted_content', encrypted_content: carrier }],
+    }],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateA).input).toEqual([{
+    type: 'agent_message',
+    id: 'amsg_upstream',
+    author: 'a',
+    recipient: 'b',
+    content: [],
+  }]);
+  expect(prepared.payloadForCandidate(candidateB).input[0]).toMatchObject({
+    id: expect.stringMatching(/^amsg_tmp_/),
+    content: [],
+  });
+});
+
+test('rewrites multiple nested encrypted blocks against their original indexes', async () => {
+  const first = await codec.wrap(
+    'first',
+    { ...targetFor(candidateA), upstreamItemId: 'amsg_upstream' },
+    carrierDomain('agent_message', 'content.0.encrypted_content'),
+  );
+  const second = await codec.wrap(
+    'second',
+    { ...targetFor(candidateA), upstreamItemId: 'amsg_upstream' },
+    carrierDomain('agent_message', 'content.1.encrypted_content'),
+  );
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [{
+      type: 'agent_message',
+      id: 'amsg_public',
+      author: 'a',
+      recipient: 'b',
+      content: [
+        { type: 'encrypted_content', encrypted_content: first },
+        { type: 'encrypted_content', encrypted_content: second },
+        { type: 'encrypted_content', encrypted_content: 'foreign' },
+        { type: 'input_text', text: 'visible' },
+      ],
+    }],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateB).input[0]).toMatchObject({
+    content: [
+      { type: 'encrypted_content', encrypted_content: 'foreign' },
+      { type: 'input_text', text: 'visible' },
+    ],
+  });
+});
+
+test('passes foreign blobs through unchanged for cascaded gateways', async () => {
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [{ type: 'reasoning', id: 'rs_foreign', summary: [], encrypted_content: 'foreign' }],
+  }, codec);
+
+  expect(prepared.routingEvidence).toEqual([]);
+  expect(prepared.payloadForCandidate(candidateA).input[0]).toMatchObject({ encrypted_content: 'foreign' });
+});
+
+test('derives force routing from blob-less program state following a preferred carrier', async () => {
+  const carrier = await codec.wrap(
+    undefined,
+    targetFor(candidateA),
+    carrierDomain('reasoning', 'encrypted_content'),
+  );
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [
+      { type: 'reasoning', id: 'rs_prefix', summary: [], encrypted_content: carrier },
+      { type: 'program_output', id: 'prog_out_1', call_id: 'call_1', result: 'done', status: 'completed' },
+    ],
+  }, codec);
+
+  expect(prepared.routingEvidence).toEqual([
+    { target: targetFor(candidateA), mode: 'prefer' },
+    { target: targetFor(candidateA), mode: 'force' },
+  ]);
+});
+
+test('does not inherit force through a foreign program blob', async () => {
+  const carrier = await codec.wrap(
+    undefined,
+    targetFor(candidateA),
+    carrierDomain('reasoning', 'encrypted_content'),
+  );
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [
+      { type: 'reasoning', id: 'rs_prefix', summary: [], encrypted_content: carrier },
+      { type: 'program', id: 'prog_1', call_id: 'call_1', code: 'return 1', fingerprint: 'foreign' },
+    ],
+  }, codec);
+
+  expect(prepared.routingEvidence).toEqual([{ target: targetFor(candidateA), mode: 'prefer' }]);
+  expect(prepared.payloadForCandidate(candidateA).input[1]).toMatchObject({ fingerprint: 'foreign' });
+});
+
+test('restores the bound ID of a force item carried by an adjacent synthetic prefix', async () => {
+  const item = { type: 'program_output' as const, id: 'prog_out_public', call_id: 'call_1', result: 'done', status: 'completed' as const };
+  const carrier = await codec.wrap(
+    undefined,
+    {
+      ...targetFor(candidateA),
+      syntheticItem: true,
+      boundItem: {
+        type: 'program_output',
+        upstreamItemId: 'prog_out_upstream',
+        contentHash: await hashResponsesItemBinding(item),
+      },
+    },
+    carrierDomain('reasoning', 'encrypted_content'),
+  );
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [
+      { type: 'reasoning', id: 'rs_prefix', summary: [], encrypted_content: carrier },
+      item,
+    ],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(candidateA).input).toEqual([
+    { type: 'program_output', id: 'prog_out_upstream', call_id: 'call_1', result: 'done', status: 'completed' },
+  ]);
+  expect((prepared.payloadForCandidate(candidateB).input[0] as { id: string }).id).toMatch(/^prog_out_tmp_/);
+  expect(prepared.payloadForCandidate({ ...candidateA, rules: {} }).input[0]).toMatchObject({ id: 'prog_out_upstream' });
+  expect(prepared.itemIdMapForCandidate(candidateA).get('prog_out_public')).toBe('prog_out_upstream');
+  expect(prepared.routingEvidence.map(item => item.mode)).toEqual(['prefer', 'force']);
+});
+
+test('restores a preferred bound item ID only for exact optional rules', async () => {
+  const aliasCandidate = { ...candidateA, rules: {} };
+  const item = { type: 'message' as const, id: 'msg_public', role: 'assistant' as const, content: 'answer' };
+  const carrier = await codec.wrap(
+    undefined,
+    {
+      ...targetFor(aliasCandidate),
+      syntheticItem: true,
+      boundItem: {
+        type: item.type,
+        upstreamItemId: 'msg_upstream',
+        contentHash: await hashResponsesItemBinding(item),
+      },
+    },
+    carrierDomain('reasoning', 'encrypted_content'),
+  );
+  const prepared = await prepareResponsesAffinity({
+    model: 'model',
+    input: [
+      { type: 'reasoning', id: 'rs_prefix', summary: [], encrypted_content: carrier },
+      item,
+    ],
+  }, codec);
+
+  expect(prepared.payloadForCandidate(aliasCandidate).input[0]).toMatchObject({ id: 'msg_upstream' });
+  expect(prepared.payloadForCandidate(candidateA).input[0]).toMatchObject({ id: expect.stringMatching(/^msg_tmp_/) });
+});
+
+test('rejects a bound carrier moved before a different same-type item', async () => {
+  const original = { type: 'program_output' as const, id: 'first_public', call_id: 'call_1', result: 'first', status: 'completed' as const };
+  const carrier = await codec.wrap(
+    undefined,
+    {
+      ...targetFor(candidateA),
+      syntheticItem: true,
+      boundItem: {
+        type: original.type,
+        upstreamItemId: 'first_upstream',
+        contentHash: await hashResponsesItemBinding(original),
+      },
+    },
+    carrierDomain('reasoning', 'encrypted_content'),
+  );
+
+  await expect(prepareResponsesAffinity({
+    model: 'model',
+    input: [
+      { type: 'reasoning', id: 'rs_prefix', summary: [], encrypted_content: carrier },
+      { type: 'program_output', id: 'second_public', call_id: 'call_2', result: 'second', status: 'completed' },
+    ],
+  }, codec)).rejects.toMatchObject({
+    name: 'ResponsesAffinityInputError',
+    message: 'Affinity carrier does not match the Responses input item at index 1.',
+    param: 'input[1]',
+  });
+});
+
+test('treats compaction_summary as force state and restores its upstream ID', async () => {
+  const carrier = await codec.wrap(
+    'opaque',
+    { ...targetFor(candidateA), upstreamItemId: 'cmp_upstream' },
+    carrierDomain('compaction_summary', 'encrypted_content'),
+  );
+  const item = { type: 'compaction_summary', id: 'cmp_public', encrypted_content: carrier } as unknown as CanonicalResponsesPayload['input'][number];
+  const prepared = await prepareResponsesAffinity({ model: 'model', input: [item] }, codec);
+  const aliasVariant = { ...candidateA, rules: {} };
+
+  expect(prepared.routingEvidence.map(evidence => evidence.mode)).toEqual(['prefer', 'force']);
+  expect(prepared.payloadForCandidate(candidateA).input[0]).toMatchObject({ id: 'cmp_upstream', encrypted_content: 'opaque' });
+  expect(prepared.payloadForCandidate(aliasVariant).input[0]).toMatchObject({ id: 'cmp_upstream', encrypted_content: 'opaque' });
+});
+
+test('keeps synthetic context compaction prefer-only while natural encrypted state forces', async () => {
+  const synthetic = await codec.wrap(
+    undefined,
+    { ...targetFor(candidateA), upstreamItemId: 'ctx_upstream' },
+    carrierDomain('context_compaction', 'encrypted_content'),
+  );
+  const syntheticItem = {
+    type: 'context_compaction',
+    id: 'ctx_public',
+    encrypted_content: synthetic,
+  } as unknown as CanonicalResponsesPayload['input'][number];
+  const syntheticPrepared = await prepareResponsesAffinity({ model: 'model', input: [syntheticItem] }, codec);
+  expect(syntheticPrepared.routingEvidence).toEqual([{ target: { ...targetFor(candidateA), upstreamItemId: 'ctx_upstream' }, mode: 'prefer' }]);
+
+  const natural = await codec.wrap(
+    'opaque',
+    { ...targetFor(candidateA), upstreamItemId: 'ctx_upstream' },
+    carrierDomain('context_compaction', 'encrypted_content'),
+  );
+  const naturalItem = { ...syntheticItem, encrypted_content: natural } as unknown as CanonicalResponsesPayload['input'][number];
+  const naturalPrepared = await prepareResponsesAffinity({ model: 'model', input: [naturalItem] }, codec);
+  expect(naturalPrepared.routingEvidence.map(evidence => evidence.mode)).toEqual(['prefer', 'force']);
+  expect(naturalPrepared.payloadForCandidate({ ...candidateA, rules: {} }).input[0]).toMatchObject({
+    id: 'ctx_upstream',
+    encrypted_content: 'opaque',
+  });
+});
diff --git a/packages/gateway/src/data-plane/chat/responses/affinity/roundtrip_test.ts b/packages/gateway/src/data-plane/chat/responses/affinity/roundtrip_test.ts
new file mode 100644
index 000000000..a7889dc39
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/responses/affinity/roundtrip_test.ts
@@ -0,0 +1,255 @@
+import { expect, test } from 'vitest';
+
+import { wrapResponsesAffinityEgress } from './egress.ts';
+import { prepareResponsesAffinity } from './ingress.ts';
+import { initRepo } from '../../../../repo/index.ts';
+import { InMemoryRepo } from '../../../../repo/memory.ts';
+import { AffinityCodec } from '../../shared/affinity/index.ts';
+import { ResponsesAttemptState } from '../attempt-state.ts';
+import { wrapResponsesClientOutput } from '../items/output.ts';
+import { createResponsesHttpStore } from '../items/store.ts';
+import { eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
+import type { ResponsesInputItem, ResponsesResult, ResponsesStreamEvent } from '@floway-dev/protocols/responses';
+import { stubModelCandidate } from '@floway-dev/test-utils';
+
+test('stored force items recover their original upstream IDs from adjacent client carriers', async () => {
+  initRepo(new InMemoryRepo());
+  const base = stubModelCandidate();
+  const candidate = stubModelCandidate({
+    provider: { ...base.provider, upstream: 'upstream-a' },
+    model: { id: 'model-a' },
+  });
+  const codec = new AffinityCodec('22'.repeat(32));
+  const programOutput = { type: 'program_output' as const, id: 'prog_out_upstream', call_id: 'call_1', result: 'done', status: 'completed' as const };
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model-a',
+    status: 'completed',
+    output: [programOutput],
+    error: null,
+    incomplete_details: null,
+  };
+  const source = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({
+      type: 'response.output_item.added',
+      output_index: 0,
+      item: { ...programOutput, id: 'prog_out_initial', result: '', status: 'incomplete' },
+    });
+    yield eventFrame({ type: 'response.output_item.done', output_index: 0, item: programOutput });
+    yield eventFrame({ type: 'response.completed', response });
+  };
+  const affinity = wrapResponsesAffinityEgress(source(), {
+    codec,
+    affinity: { upstreamId: candidate.provider.upstream, modelId: candidate.model.id },
+  });
+  const stored = wrapResponsesClientOutput(affinity, {
+    store: createResponsesHttpStore('key-a', true),
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  });
+
+  let clientResponse: ResponsesResult | undefined;
+  const lifecycleItemIds: string[] = [];
+  for await (const frame of stored) {
+    if (
+      frame.type === 'event'
+      && (frame.event.type === 'response.output_item.added' || frame.event.type === 'response.output_item.done')
+      && frame.event.item.type === 'program_output'
+    ) lifecycleItemIds.push(frame.event.item.id);
+    if (frame.type === 'event' && frame.event.type === 'response.completed') clientResponse = frame.event.response;
+  }
+  expect(clientResponse).toBeDefined();
+  if (clientResponse === undefined) throw new Error('Expected completed client response');
+  expect(new Set(lifecycleItemIds).size).toBe(1);
+  expect(clientResponse.output[1].id).not.toBe('prog_out_upstream');
+
+  const prepared = await prepareResponsesAffinity({ model: 'model-a', input: clientResponse.output as unknown as ResponsesInputItem[] }, codec);
+  expect(prepared.routingEvidence.map(evidence => evidence.mode)).toEqual(['prefer', 'force']);
+  expect(prepared.payloadForCandidate(candidate).input).toEqual([programOutput]);
+});
+
+test('an adjacent carrier restores an originally id-less item', async () => {
+  initRepo(new InMemoryRepo());
+  const base = stubModelCandidate();
+  const candidate = stubModelCandidate({
+    provider: { ...base.provider, upstream: 'upstream-a' },
+    model: { id: 'model-a' },
+  });
+  const codec = new AffinityCodec('22'.repeat(32));
+  const message = {
+    type: 'message' as const,
+    role: 'assistant' as const,
+    status: 'completed' as const,
+    content: [{ type: 'output_text' as const, text: 'answer' }],
+  };
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model-a',
+    status: 'completed',
+    output: [message],
+    error: null,
+    incomplete_details: null,
+  };
+  const source = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.completed', response });
+  };
+  const affinity = wrapResponsesAffinityEgress(source(), {
+    codec,
+    affinity: { upstreamId: candidate.provider.upstream, modelId: candidate.model.id },
+  });
+  const client = wrapResponsesClientOutput(affinity, {
+    store: createResponsesHttpStore('key-a', false),
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  });
+  let clientResponse: ResponsesResult | undefined;
+  for await (const frame of client) {
+    if (frame.type === 'event' && frame.event.type === 'response.completed') clientResponse = frame.event.response;
+  }
+  if (clientResponse === undefined) throw new Error('Expected completed client response');
+
+  const prepared = await prepareResponsesAffinity({ model: 'model-a', input: clientResponse.output as unknown as ResponsesInputItem[] }, codec);
+  expect(prepared.payloadForCandidate(candidate).input).toEqual([message]);
+});
+
+test('an adjacent carrier accepts Codex-normalized message history', async () => {
+  initRepo(new InMemoryRepo());
+  const base = stubModelCandidate();
+  const candidate = stubModelCandidate({
+    provider: { ...base.provider, upstream: 'upstream-a' },
+    model: { id: 'model-a' },
+  });
+  const codec = new AffinityCodec('22'.repeat(32));
+  const message = {
+    type: 'message' as const,
+    id: 'msg_upstream',
+    role: 'assistant' as const,
+    status: 'completed' as const,
+    content: [{ type: 'output_text' as const, text: 'answer', annotations: [], logprobs: [] }],
+  };
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model-a',
+    status: 'completed',
+    output: [message],
+    error: null,
+    incomplete_details: null,
+  };
+  const source = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.completed', response });
+  };
+  const withAffinity = wrapResponsesAffinityEgress(source(), {
+    codec,
+    affinity: { upstreamId: candidate.provider.upstream, modelId: candidate.model.id },
+  });
+  let clientResponse: ResponsesResult | undefined;
+  for await (const frame of wrapResponsesClientOutput(withAffinity, {
+    store: createResponsesHttpStore('key-a', false),
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  })) if (frame.type === 'event' && frame.event.type === 'response.completed') clientResponse = frame.event.response;
+  if (clientResponse === undefined) throw new Error('Expected completed client response');
+  const clientMessage = clientResponse.output[1] as unknown as Record<string, unknown>;
+  delete clientMessage.status;
+  const [outputText] = clientMessage.content as Array<Record<string, unknown>>;
+  outputText.type = 'input_text';
+  delete outputText.annotations;
+  delete outputText.logprobs;
+
+  const prepared = await prepareResponsesAffinity({ model: 'model-a', input: clientResponse.output as unknown as ResponsesInputItem[] }, codec);
+  expect(prepared.payloadForCandidate(candidate).input[0]).toMatchObject({
+    type: 'message',
+    id: 'msg_upstream',
+    content: [{ type: 'input_text', text: 'answer' }],
+  });
+});
+
+test('agent-message natural and synthetic nested carriers round-trip', async () => {
+  const base = stubModelCandidate();
+  const candidate = stubModelCandidate({
+    provider: { ...base.provider, upstream: 'upstream-a' },
+    model: { id: 'model-a' },
+  });
+  const codec = new AffinityCodec('22'.repeat(32));
+  const empty = { type: 'agent_message' as const, id: 'amsg_empty', author: 'a', recipient: 'b', content: [] };
+  const natural = {
+    type: 'agent_message' as const,
+    id: 'amsg_natural',
+    author: 'a',
+    recipient: 'b',
+    content: [{ type: 'encrypted_content' as const, encrypted_content: 'opaque' }],
+  };
+  const response = {
+    id: 'resp_upstream',
+    object: 'response' as const,
+    model: 'model-a',
+    status: 'completed' as const,
+    output: [empty, natural],
+    error: null,
+    incomplete_details: null,
+  } as unknown as ResponsesResult;
+  const source = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.completed', response });
+  };
+  let clientResponse: ResponsesResult | undefined;
+  for await (const frame of wrapResponsesAffinityEgress(source(), {
+    codec,
+    affinity: { upstreamId: candidate.provider.upstream, modelId: candidate.model.id },
+  })) if (frame.type === 'event' && frame.event.type === 'response.completed') clientResponse = frame.event.response;
+  if (clientResponse === undefined) throw new Error('Expected completed client response');
+
+  const prepared = await prepareResponsesAffinity({ model: 'model-a', input: clientResponse.output as unknown as ResponsesInputItem[] }, codec);
+  expect(prepared.payloadForCandidate(candidate).input).toEqual([empty, natural]);
+});
+
+test('compaction_summary carrier authenticates after a client canonicalizes its alias', async () => {
+  const base = stubModelCandidate();
+  const candidate = stubModelCandidate({
+    provider: { ...base.provider, upstream: 'upstream-a' },
+    model: { id: 'model-a' },
+  });
+  const codec = new AffinityCodec('22'.repeat(32));
+  const summary = {
+    type: 'compaction_summary',
+    id: 'cmp_upstream',
+    encrypted_content: 'opaque',
+  } as unknown as ResponsesResult['output'][number];
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model-a',
+    status: 'completed',
+    output: [summary],
+    error: null,
+    incomplete_details: null,
+  };
+  const source = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.completed', response });
+  };
+  let wrapped: string | undefined;
+  for await (const frame of wrapResponsesAffinityEgress(source(), {
+    codec,
+    affinity: { upstreamId: candidate.provider.upstream, modelId: candidate.model.id },
+  })) {
+    if (frame.type === 'event' && frame.event.type === 'response.completed') {
+      wrapped = (frame.event.response.output[0] as { encrypted_content?: string }).encrypted_content;
+    }
+  }
+  if (wrapped === undefined) throw new Error('Expected wrapped compaction summary');
+
+  const canonical = {
+    type: 'compaction',
+    id: 'cmp_public',
+    encrypted_content: wrapped,
+  } as unknown as ResponsesInputItem;
+  const prepared = await prepareResponsesAffinity({ model: 'model-a', input: [canonical] }, codec);
+  expect(prepared.routingEvidence.map(evidence => evidence.mode)).toEqual(['prefer', 'force']);
+  expect(prepared.payloadForCandidate(candidate).input[0]).toMatchObject({
+    type: 'compaction',
+    id: 'cmp_upstream',
+    encrypted_content: 'opaque',
+  });
+});
diff --git a/packages/gateway/src/data-plane/chat/responses/attempt-state.ts b/packages/gateway/src/data-plane/chat/responses/attempt-state.ts
new file mode 100644
index 000000000..62ec712ea
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/responses/attempt-state.ts
@@ -0,0 +1,19 @@
+export class ResponsesAttemptState {
+  readonly #privatePayloads = new Map<string, unknown>();
+
+  begin(privatePayloads: ReadonlyMap<string, unknown>, itemIdMap: ReadonlyMap<string, string>): void {
+    this.#privatePayloads.clear();
+    for (const [id, payload] of privatePayloads) {
+      this.#privatePayloads.set(itemIdMap.get(id) ?? id, structuredClone(payload));
+    }
+  }
+
+  setPrivatePayload(id: string, payload: unknown): void {
+    this.#privatePayloads.set(id, structuredClone(payload));
+  }
+
+  getPrivatePayload(id: string): unknown {
+    const payload = this.#privatePayloads.get(id);
+    return payload === undefined ? undefined : structuredClone(payload);
+  }
+}
diff --git a/packages/gateway/src/data-plane/chat/responses/attempt.ts b/packages/gateway/src/data-plane/chat/responses/attempt.ts
index d91d368c7..3befdb694 100644
--- a/packages/gateway/src/data-plane/chat/responses/attempt.ts
+++ b/packages/gateway/src/data-plane/chat/responses/attempt.ts
@@ -1,10 +1,10 @@
+import { prepareResponsesAffinity, type PreparedResponsesAffinity } from './affinity/ingress.ts';
+import { renderResponsesFailure } from './errors.ts';
 import { responsesInterceptors } from './interceptors/index.ts';
 import type { ResponsesAttemptResult, ResponsesInvocation } from './interceptors/types.ts';
-import { createStoredResponseId } from './items/format.ts';
 import { normalizeAssistantInputText } from './items/normalize-assistant-content.ts';
-import { drainAsync, syntheticEventsFromResult, wrapResponsesOutputForStorage } from './items/output.ts';
-import { rewriteResponsesPayloadForCandidate, type RewrittenResponsesPayload } from './items/rewrite.ts';
-import type { StatefulResponsesStore } from './items/store.ts';
+import { syntheticEventsFromResult } from './items/output.ts';
+import { hydrateResponsesPayload, type HydratedResponsesPayload } from './items/rewrite.ts';
 import { tokenUsageFromResponsesResult } from './usage.ts';
 import { applyRulesToUpstreamResponses } from '../../model-aliases/apply-rules.ts';
 import { providerStreamResultToExecuteResult, buildUpstreamCallOptions, telemetryModelIdentity, chatTargetPicker, upstreamPerformanceContext } from '../../shared/telemetry/attempt-helpers.ts';
@@ -27,14 +27,25 @@ import { translateResponsesViaChatCompletions, translateResponsesViaMessages } f
 // targets.
 export const responsesTarget = chatTargetPicker(['responses', 'messages', 'chat-completions']);
 
-export interface ResponsesAttemptInvokeArgs {
-  readonly payload: CanonicalResponsesPayload;
+interface ResponsesAttemptBaseArgs {
   readonly action: ResponsesAction;
   readonly ctx: ChatGatewayCtx;
   readonly candidate: ModelCandidate;
   readonly headers: Headers;
 }
 
+interface ResponsesSourcePreparation {
+  readonly affinity: PreparedResponsesAffinity;
+  readonly privatePayloads: ReadonlyMap<string, unknown>;
+}
+
+type ResponsesAttemptInput =
+  | { readonly payload: CanonicalResponsesPayload; readonly sourcePreparation?: never }
+  | { readonly payload?: never; readonly sourcePreparation: ResponsesSourcePreparation };
+
+export type ResponsesAttemptInvokeArgs = ResponsesAttemptBaseArgs & ResponsesAttemptInput;
+type ResponsesAttemptGenerateArgs = Omit<ResponsesAttemptBaseArgs, 'action'> & ResponsesAttemptInput;
+
 // Single entry point for both `action: 'generate'` and `action: 'compact'`.
 // Envelope-drain branches on the caller's intent (`action` passed by value),
 // not on `invocation.action`. Interceptors are free to mutate `ctx.action`
@@ -62,41 +73,50 @@ export interface ResponsesAttemptInvokeArgs {
 // the interceptor finally blocks), and stay independent of the shim's
 // presence.
 //
-// Snapshot persistence is owned end-to-end by `wrapResponsesOutputForStorage`,
-// which derives the snapshot mode by observing the output stream — `'replace'`
-// when any output item is a compaction (the three convergence cases:
-// native `/v1/responses/compact`, a `compaction_trigger` input on
-// `/v1/responses` reshaped by the upstream, and the server-side
-// `context_management` `compact_threshold` mode), `'append'` otherwise.
-// "Don't write" is expressed by the store itself: cross-protocol translation
-// stores (`createNonResponsesSourceStore`) and `store=false` HTTP turns ship
-// with an empty `snapshotWrites` configuration, so `commitSnapshot` is a
-// no-op at the store-write layer.
+// Responses state and client affinity both belong to the native source edge,
+// outside this candidate attempt. Keeping this function free of public-id
+// minting and persistence prevents translated inner Responses calls from
+// accidentally owning another protocol's client-visible state.
 export const responsesAttempt = {
   invoke: async (args: ResponsesAttemptInvokeArgs): Promise<ResponsesAttemptResult> => {
-    const { payload: sourcePayload, action, ctx, candidate, headers: sourceHeaders } = args;
-    const payload = { ...structuredClone(sourcePayload), model: candidate.model.id };
+    const { action, ctx, candidate, headers: sourceHeaders } = args;
     const headers = new Headers(sourceHeaders);
-    const { store } = ctx;
     const targetApi = responsesTarget.pick(candidate.model.endpoints);
     // Rewrite + privatePayload seed + assistant-content normalization all run
     // BEFORE the interceptor chain so source interceptors — most importantly
     // the web-search server-tool shim — see fully inline-expanded input items
-    // with their original wire ids, and `store.getPrivatePayload(id)` is
+    // with their original wire ids, and `responsesAttemptState.getPrivatePayload(id)` is
     // ready to hand back the persisted IR. The shim's `transformItems` runs
     // inside the chain body, before `run()`, so deferring rewrite/seed to
     // the inner closure would leave the shim looking at the pre-rewrite
     // wire shape against an empty privatePayload map.
-    const rewritten = await rewriteOrRenderFailure(payload, store, candidate);
-    if (!('payload' in rewritten)) return rewritten.failure;
-    store.beginAttempt(rewritten.privatePayloads);
+    let affinity: PreparedResponsesAffinity;
+    let privatePayloads: ReadonlyMap<string, unknown>;
+    if (args.sourcePreparation !== undefined) {
+      affinity = args.sourcePreparation.affinity;
+      privatePayloads = args.sourcePreparation.privatePayloads;
+    } else {
+      const payload = { ...structuredClone(args.payload), model: candidate.model.id };
+      let hydrated: HydratedResponsesPayload;
+      try {
+        hydrated = hydrateResponsesPayload(payload, ctx.store);
+      } catch (error) {
+        const failure = tryCatchChatServeFailure(error);
+        if (failure === null || failure.kind !== 'item-not-found') throw error;
+        return renderResponsesFailure(failure);
+      }
+      affinity = await prepareResponsesAffinity(hydrated.payload, ctx.affinity.codec);
+      privatePayloads = hydrated.privatePayloads;
+    }
     // Copilot compaction and Azure-native compaction both emit assistant
     // messages whose content blocks have `type: 'input_text'`, then refuse
     // the same items echoed back as input on the next turn. Normalising
     // here, after the rewrite has expanded any `item_reference` items
     // from the snapshot store, catches both the direct-echo and
     // store-replay paths in one place.
-    const normalized: CanonicalResponsesPayload = { ...rewritten.payload, input: normalizeAssistantInputText(rewritten.payload.input) };
+    const candidatePayload = { ...affinity.payloadForCandidate(candidate), model: candidate.model.id };
+    ctx.responsesAttemptState.begin(privatePayloads, affinity.itemIdMapForCandidate(candidate));
+    const normalized: CanonicalResponsesPayload = { ...candidatePayload, input: normalizeAssistantInputText(candidatePayload.input) };
 
     const invocation: ResponsesInvocation = {
       payload: normalized,
@@ -110,54 +130,17 @@ export const responsesAttempt = {
 
     if (chainResult.type !== 'events') return chainResult;
 
-    const responseId = createStoredResponseId();
     if (action === 'compact') {
-      // The caller entered through /v1/responses/compact (or serve.compact).
-      // Drain the chain's events — whether they came from a native /compact
-      // wire or from the responses-compact-shim's synthesized envelope —
-      // into a single result envelope so the http layer can JSON-encode it
-      // directly. Storage still runs over the synthesized event stream so
-      // the snapshot is committed under the same id the client will see —
-      // wrap detects the `compaction` output item and writes a `'replace'`
-      // snapshot.
       const upstreamCompacted = await collectResponsesProtocolEventsToResult(chainResult.events);
-      await drainAsync(wrapResponsesOutputForStorage(syntheticEventsFromResult(upstreamCompacted), {
-        store,
-        upstream: candidate.provider.upstream,
-        targetApi: 'responses',
-        responseId,
-      }));
       return {
         type: 'result',
-        result: { ...upstreamCompacted, id: responseId },
+        result: upstreamCompacted,
         modelIdentity: chainResult.modelIdentity,
         usage: tokenUsageFromResponsesResult(upstreamCompacted),
         performance: chainResult.performance,
       };
     }
-
-    // Persistence and id rewriting wrap the *outermost* stream — after every
-    // interceptor (including the server-tool shim) has emitted its final
-    // events. This is the only seam at which the gateway-owned response id
-    // is minted; whatever id any inner layer produced (the upstream's blob,
-    // the shim's internal `resp_shim_*` placeholder) is overwritten to a
-    // `resp_<crc>_<body>` before the client sees a frame, and the snapshot
-    // is committed under the same id so the next turn's
-    // `previous_response_id` lookup is guaranteed to hit.
-    return eventResult(
-      wrapResponsesOutputForStorage(chainResult.events, {
-        store,
-        upstream: candidate.provider.upstream,
-        targetApi,
-        responseId,
-      }),
-      chainResult.modelIdentity,
-      {
-        performance: chainResult.performance,
-        finalMetadata: chainResult.finalMetadata,
-        headers: chainResult.headers,
-      },
-    );
+    return chainResult;
   },
 
   // Narrowing wrapper for cross-protocol translation callers
@@ -166,7 +149,7 @@ export const responsesAttempt = {
   // want the ExecuteResult branch. The compact branch is a contract
   // violation here; an interceptor that pivoted generate→compact would
   // surface as a throw, not a silent shape mismatch.
-  generate: async (args: Omit<ResponsesAttemptInvokeArgs, 'action'>): Promise<ExecuteResult<ProtocolFrame<ResponsesStreamEvent>>> => {
+  generate: async (args: ResponsesAttemptGenerateArgs): Promise<ExecuteResult<ProtocolFrame<ResponsesStreamEvent>>> => {
     const result = await responsesAttempt.invoke({ ...args, action: 'generate' });
     if (result.type === 'result') {
       throw new Error('responsesAttempt.generate received a compact result; an interceptor pivoted generate→compact unexpectedly');
@@ -175,46 +158,6 @@ export const responsesAttempt = {
   },
 };
 
-type RewriteOutcome =
-  | RewrittenResponsesPayload
-  | { readonly failure: ExecuteResult<ProtocolFrame<ResponsesStreamEvent>> };
-
-const rewriteOrRenderFailure = async (
-  payload: CanonicalResponsesPayload,
-  store: StatefulResponsesStore,
-  candidate: ModelCandidate,
-): Promise<RewriteOutcome> => {
-  try {
-    return await rewriteResponsesPayloadForCandidate(payload, store, candidate);
-  } catch (error) {
-    const failure = tryCatchChatServeFailure(error);
-    if (failure === null) throw error;
-    // The full Responses failure renderer that also handles `model-missing`
-    // / `model-unsupported` / `routing-unavailable` lives in the serve
-    // layer and treats the `endpoint` distinction (`generate` vs
-    // `compact`); from inside an attempt, only `item-not-found` is
-    // reachable from rewrite — anything else is a bug. Re-throw the
-    // original error so the upstream stack/cause survives.
-    if (failure.kind !== 'item-not-found') throw error;
-    return {
-      failure: {
-        type: 'api-error',
-        source: 'gateway',
-        status: 404,
-        headers: new Headers({ 'content-type': 'application/json' }),
-        body: new TextEncoder().encode(JSON.stringify({
-          error: {
-            message: `Item with id '${failure.itemId}' not found.`,
-            type: 'invalid_request_error',
-            param: 'input',
-            code: null,
-          },
-        })),
-      },
-    };
-  }
-};
-
 const dispatchResponses = async (
   invocation: ResponsesInvocation,
   ctx: ChatGatewayCtx,
diff --git a/packages/gateway/src/data-plane/chat/responses/attempt_test.ts b/packages/gateway/src/data-plane/chat/responses/attempt_test.ts
index 45d71375a..4bc8eac69 100644
--- a/packages/gateway/src/data-plane/chat/responses/attempt_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/attempt_test.ts
@@ -1,7 +1,7 @@
 import { test, vi } from 'vitest';
 
 import { responsesAttempt } from './attempt.ts';
-import { createStoredResponsesItemId, isStoredResponseId } from './items/format.ts';
+import { createResponsesItemId, hashResponsesItemBinding } from './items/format.ts';
 import * as outputModule from './items/output.ts';
 import { createResponsesHttpStore } from './items/store.ts';
 import { initRepo } from '../../../repo/index.ts';
@@ -89,23 +89,17 @@ const installRepo = () => {
 const insertStoredItem = async (repo: InMemoryRepo, overrides: Partial<StoredResponsesItem> & Pick<StoredResponsesItem, 'id' | 'itemType'>): Promise<StoredResponsesItem> => {
   const row: StoredResponsesItem = {
     apiKeyId: API_KEY_ID,
-    upstreamId: null,
-    upstreamItemId: null,
-    origin: 'synthetic',
-    contentHash: null,
-    encryptedContentHash: null,
-    payload: null,
+    contentHash: `hash-${overrides.id}`,
+    payload: { item: { type: overrides.itemType, id: overrides.id } },
     createdAt: 1_000,
-    refreshedAt: 1_000,
     ...overrides,
   };
   await repo.responsesItems.insertMany([row]);
   return row;
 };
 
-test('generate native success wraps the upstream event stream once', async () => {
+test('generate native success leaves source-edge state ownership to the caller', async () => {
   installRepo();
-  const wrapSpy = vi.spyOn(outputModule, 'wrapResponsesOutputForStorage');
 
   const completedEvent: ResponsesStreamEvent = {
     type: 'response.completed',
@@ -122,7 +116,6 @@ test('generate native success wraps the upstream event stream once', async () =>
   const candidate = makeCandidate(callResponses);
   const store = createResponsesHttpStore(API_KEY_ID, true);
   const ctx = makeGatewayCtx(store);
-  const commitSpy = vi.spyOn(store, 'commitSnapshot').mockResolvedValue();
 
   const result = await responsesAttempt.generate({
     payload: makePayload(),
@@ -134,20 +127,10 @@ test('generate native success wraps the upstream event stream once', async () =>
   assertEquals(result.type, 'events');
   if (result.type !== 'events') throw new Error('unreachable');
 
-  // Drain so the wrapped pipeline runs and storage callbacks fire.
   const events = await collectEvents(result.events);
   assert(events.length >= 1, 'expected at least the response.completed event');
 
   assertEquals(callResponses.mock.calls.length, 1);
-  assertEquals(wrapSpy.mock.calls.length, 1);
-  const wrapArgs = wrapSpy.mock.calls[0][1];
-  assertEquals(wrapArgs.upstream, 'up_test');
-  assertEquals(wrapArgs.targetApi, 'responses');
-  // The upstream emitted no compaction-shape item, so wrap derived 'append'.
-  assertEquals(commitSpy.mock.calls.length, 1);
-  assertEquals(commitSpy.mock.calls[0][1], 'append');
-
-  wrapSpy.mockRestore();
 });
 
 test('generate applies role compatibility flags in target-chain order', async () => {
@@ -283,107 +266,9 @@ test('generate defers role promotion until after translation to Chat Completions
   ]);
 });
 
-test('generate derives snapshotMode=replace when the upstream emits a compaction output item', async () => {
-  // A direct `/v1/responses` generate carrying a `compaction_trigger` input
-  // (Codex's RemoteCompactionV2) — or a `context_management` `compact_threshold`
-  // turn that triggers server-side compaction — yields a compaction-shape
-  // output envelope on the wire. Wrap observes that output and derives a
-  // 'replace' snapshot regardless of how the request was framed.
-  installRepo();
-  const wrapSpy = vi.spyOn(outputModule, 'wrapResponsesOutputForStorage');
-
-  const compactionItem = {
-    type: 'compaction',
-    id: 'cmp_trigger',
-    encrypted_content: 'ENC',
-  };
-  const compactionResponse: ResponsesResult = {
-    ...makeResponsesResult(),
-    object: 'response.compaction',
-    output: [compactionItem] as unknown as ResponsesResult['output'],
-  };
-  const completedEvent: ResponsesStreamEvent = {
-    type: 'response.completed',
-    sequence_number: 0,
-    response: compactionResponse,
-  };
-  const callResponses = vi.fn(async (): Promise<ProviderResponsesResult> => ({
-    action: 'generate', ok: true,
-    events: makeProviderEvents([completedEvent]),
-    modelKey: 'test-model-key',
-    headers: new Headers(),
-  }));
-
-  const candidate = makeCandidate(callResponses);
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-  const commitSpy = vi.spyOn(store, 'commitSnapshot').mockResolvedValue();
-
-  const result = await responsesAttempt.generate({
-    payload: makePayload({
-      input: [
-        { type: 'message', role: 'user', content: 'kept message' },
-      ],
-    }),
-    ctx: makeGatewayCtx(store),
-    candidate,
-    headers: new Headers(),
-  });
-
-  assertEquals(result.type, 'events');
-  if (result.type !== 'events') throw new Error('unreachable');
-  await collectEvents(result.events);
-
-  assertEquals(wrapSpy.mock.calls.length, 1);
-  assertEquals(commitSpy.mock.calls.length, 1);
-  assertEquals(commitSpy.mock.calls[0][1], 'replace');
-
-  wrapSpy.mockRestore();
-});
-
-test('generate returns failure when rewrite throws item-not-found', async () => {
-  installRepo();
-  const callResponses = vi.fn(async (): Promise<ProviderResponsesResult> => {
-    throw new Error('callResponses should not be called when rewrite fails');
-  });
-  const candidate = makeCandidate(callResponses);
-
-  const missingId = createStoredResponsesItemId('message');
-  // Pre-seed the store cache with a row whose payload is unavailable so the
-  // rewrite cannot expand the reference.
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-  // Insert into the underlying repo so `loadInputItems` populates the cache.
-  // The store uses `getRepo()` lazily, so the repo installed via `installRepo`
-  // already feeds this lookup.
-  const repo = installRepo();
-  await insertStoredItem(repo, { id: missingId, itemType: 'message', payload: null });
-  await store.loadInputItems({
-    sourceItems: [{ type: 'item_reference' as const, id: missingId }],
-    view: {
-      visitAsResponsesItems: async (items, visit) => {
-        for (const item of items as readonly { id: string }[]) await visit({ type: 'item_reference', id: item.id });
-      },
-    },
-  });
-
-  const result = await responsesAttempt.generate({
-    payload: makePayload({ input: [{ type: 'item_reference', id: missingId }] }),
-    ctx: makeGatewayCtx(store),
-    candidate,
-    headers: new Headers(),
-  });
-
-  assertEquals(result.type, 'api-error');
-  if (result.type !== 'api-error') throw new Error('unreachable');
-  assertEquals(result.status, 404);
-  const body = JSON.parse(new TextDecoder().decode(result.body));
-  assertEquals(body.error.code, null);
-  assertEquals(body.error.message, `Item with id '${missingId}' not found.`);
-  assertEquals(callResponses.mock.calls.length, 0);
-});
-
 test('generate passes non-events provider result through unchanged', async () => {
   installRepo();
-  const wrapSpy = vi.spyOn(outputModule, 'wrapResponsesOutputForStorage');
+  const wrapSpy = vi.spyOn(outputModule, 'wrapResponsesClientOutput');
 
   const upstreamResponse = new Response(JSON.stringify({ error: { message: 'nope' } }), { status: 502, headers: new Headers({ 'content-type': 'application/json' }) });
   const callResponses = vi.fn(async (): Promise<ProviderResponsesResult> => ({
@@ -408,9 +293,8 @@ test('generate passes non-events provider result through unchanged', async () =>
   wrapSpy.mockRestore();
 });
 
-test('compact reshapes the trigger turn into a result and derives snapshotMode=replace from the synthesized envelope', async () => {
+test('compact returns the clean upstream result for source-edge affinity and storage', async () => {
   installRepo();
-  const wrapSpy = vi.spyOn(outputModule, 'wrapResponsesOutputForStorage');
 
   // Native /responses/compact returns a fully-shaped compaction envelope —
   // the `action: 'compact'` branch of `provider.callResponses` does the
@@ -438,7 +322,6 @@ test('compact reshapes the trigger turn into a result and derives snapshotMode=r
 
   const candidate = makeCandidate(callResponses);
   const store = createResponsesHttpStore(API_KEY_ID, true);
-  const commitSpy = vi.spyOn(store, 'commitSnapshot').mockResolvedValue();
   const result = await responsesAttempt.invoke({
     payload: makePayload({
       input: [
@@ -456,18 +339,7 @@ test('compact reshapes the trigger turn into a result and derives snapshotMode=r
   assertEquals(result.result.object, 'response.compaction');
   assertEquals(result.result.output.length, 1);
   assertEquals((result.result.output[0] as { id: string }).id, 'cmp_1');
-  // The compact result wears a Floway-minted response id, not the upstream's
-  // — same id wrap committed the snapshot under.
-  assert(isStoredResponseId(result.result.id));
-
-  // wrap-output-storage runs exactly once on the synthesized compaction
-  // events; the compaction item in the output drives commitSnapshot('replace').
-  assertEquals(wrapSpy.mock.calls.length, 1);
-  assertEquals(wrapSpy.mock.calls[0][1].targetApi, 'responses');
-  assertEquals(commitSpy.mock.calls.length, 1);
-  assertEquals(commitSpy.mock.calls[0][1], 'replace');
-
-  wrapSpy.mockRestore();
+  assertEquals(result.result.id, compactionResult.id);
 });
 
 // In-attempt test asserting the narrow header-inheritance contract: when an
@@ -546,10 +418,10 @@ test('generate seeds privatePayload before interceptors so the web-search shim r
   // placeholder.
   //
   // The wire shape we model here:
-  //   - row.id = stored gateway id (`ws_<crc>_<body>`) — wrapResponsesOutputForStorage
+  //   - row.id = stored gateway id (`ws_<crc>_<body>`) — wrapResponsesClientOutput
   //     emits this on the wire and clients echo it back as `wsc.id`.
-  //   - payload.item.id = the original `ws_gw_` wire id the shim synthesized
-  //     on turn 1; beginAttempt keys privatePayload by it after inline expansion.
+  //   - payload.item.id = the stored client-visible id; affinity restores the
+  //     original `ws_gw_` wire id before the shim sees the item.
   //   - payload.private = WebSearchCallPrivatePayload (v:1, functionCallItem, ir).
   //
   // This regression caught a prior ordering bug where rewrite + beginAttempt
@@ -557,19 +429,19 @@ test('generate seeds privatePayload before interceptors so the web-search shim r
   // so privatePayload was always empty when the shim looked it up, and
   // every echoed wsc collapsed to the placeholder.
   const repo = installRepo();
-  const storedId = createStoredResponsesItemId('web_search_call');
+  const storedId = createResponsesItemId('web_search_call');
   const wireId = 'ws_gw_72927da0b19d48aa874e9937';
+  const storedItem = {
+    type: 'web_search_call' as const,
+    id: storedId,
+    status: 'completed' as const,
+    action: { type: 'search' as const, query: 'deepseek v4', queries: ['deepseek v4'] },
+  };
   await insertStoredItem(repo, {
     id: storedId,
     itemType: 'web_search_call',
-    origin: 'synthetic',
     payload: {
-      item: {
-        type: 'web_search_call',
-        id: wireId,
-        status: 'completed',
-        action: { type: 'search', query: 'deepseek v4', queries: ['deepseek v4'] },
-      },
+      item: storedItem,
       private: {
         v: 1,
         functionCallItem: {
@@ -606,21 +478,28 @@ test('generate seeds privatePayload before interceptors so the web-search shim r
   const candidate = makeCandidate(callResponses, new Set(['responses-web-search-shim']));
 
   const store = createResponsesHttpStore(API_KEY_ID, true);
-  await store.loadInputItems({
-    sourceItems: [{ id: storedId } as unknown as { id: string }],
-    view: {
-      visitAsResponsesItems: async (items, visit) => {
-        for (const item of items as readonly { id: string }[]) {
-          await visit({ type: 'web_search_call', id: item.id } as unknown as never);
-        }
+  await store.loadInputItems([{ type: 'web_search_call', id: storedId }], []);
+  const ctx = makeGatewayCtx(store);
+  const carrier = await ctx.affinity.codec.wrap(
+    undefined,
+    {
+      upstreamId: candidate.provider.upstream,
+      modelId: candidate.model.id,
+      syntheticItem: true,
+      boundItem: {
+        type: storedItem.type,
+        upstreamItemId: wireId,
+        contentHash: await hashResponsesItemBinding(storedItem),
       },
     },
-  });
+    'responses.reasoning.encrypted_content',
+  );
 
   const result = await responsesAttempt.generate({
     payload: makePayload({
       input: [
         { type: 'message', role: 'user', content: 'follow-up' },
+        { type: 'reasoning', id: 'rs_affinity', summary: [], encrypted_content: carrier },
         {
           type: 'web_search_call',
           id: storedId,
@@ -630,7 +509,7 @@ test('generate seeds privatePayload before interceptors so the web-search shim r
       ],
       tools: [{ type: 'web_search' }],
     }),
-    ctx: makeGatewayCtx(store),
+    ctx,
     candidate,
     headers: new Headers(),
   });
diff --git a/packages/gateway/src/data-plane/chat/responses/errors.ts b/packages/gateway/src/data-plane/chat/responses/errors.ts
index 5574b53ca..4161c403e 100644
--- a/packages/gateway/src/data-plane/chat/responses/errors.ts
+++ b/packages/gateway/src/data-plane/chat/responses/errors.ts
@@ -3,7 +3,6 @@ import type { ChatServeFailure } from '../shared/errors.ts';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
 import type { ResponsesStreamEvent } from '@floway-dev/protocols/responses';
 import type { ExecuteResult, PerformanceTelemetryContext } from '@floway-dev/provider';
-import type { TranslatorInputError } from '@floway-dev/translate';
 
 // OpenAI error envelope. `param` / `code` reproduce OpenAI's native fields; a
 // stored-item miss must byte-match OpenAI's own "not found" body — stateless
@@ -25,15 +24,11 @@ const openAiErrorResult = (
   ...(performance ? { performance } : {}),
 });
 
-// Translator surfaced a caller-input violation. Render as a 400
-// invalid_request_error so the caller sees a protocol-shaped failure
-// instead of the internal-error 502 envelope. `param` falls back to
-// `input` (the Responses canonical input field name) when the translator
-// did not carry a more specific path. `performance` carries the throwing
-// candidate's telemetry attribution when the throw fired mid-attempt (see
-// AttemptState.telemetry).
-export const translatorInputErrorResult = (
-  error: TranslatorInputError,
+// Caller-input violations discovered by translation or the source affinity
+// membrane share the Responses 400 envelope. `performance` retains candidate
+// attribution when validation fires after attempt dispatch.
+export const responsesInputErrorResult = (
+  error: { readonly message: string; readonly param?: string },
   performance?: PerformanceTelemetryContext,
 ): ExecuteResult<ProtocolFrame<ResponsesStreamEvent>> =>
   openAiErrorResult(400, error.message, { param: error.param ?? 'input', code: null }, performance);
diff --git a/packages/gateway/src/data-plane/chat/responses/errors_test.ts b/packages/gateway/src/data-plane/chat/responses/errors_test.ts
index 048480020..9eb661052 100644
--- a/packages/gateway/src/data-plane/chat/responses/errors_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/errors_test.ts
@@ -1,16 +1,16 @@
 import { test } from 'vitest';
 
-import { translatorInputErrorResult } from './errors.ts';
+import { responsesInputErrorResult } from './errors.ts';
 import type { ApiErrorResult } from '@floway-dev/provider';
 import { assertEquals } from '@floway-dev/test-utils';
 import { TranslatorInputError } from '@floway-dev/translate';
 
-const apiErrorOf = (result: ReturnType<typeof translatorInputErrorResult>): ApiErrorResult => result as ApiErrorResult;
-const bodyOf = (result: ReturnType<typeof translatorInputErrorResult>): unknown =>
+const apiErrorOf = (result: ReturnType<typeof responsesInputErrorResult>): ApiErrorResult => result as ApiErrorResult;
+const bodyOf = (result: ReturnType<typeof responsesInputErrorResult>): unknown =>
   JSON.parse(new TextDecoder().decode(apiErrorOf(result).body));
 
-test('translatorInputErrorResult renders an OpenAI 400 invalid_request_error envelope with default `input` param', () => {
-  const result = translatorInputErrorResult(
+test('responsesInputErrorResult renders an OpenAI 400 invalid_request_error envelope with default `input` param', () => {
+  const result = responsesInputErrorResult(
     new TranslatorInputError("Invalid input item type 'image_generation_call'."),
   );
   const apiError = apiErrorOf(result);
@@ -28,8 +28,8 @@ test('translatorInputErrorResult renders an OpenAI 400 invalid_request_error env
   });
 });
 
-test('translatorInputErrorResult honors an explicit param from the translator', () => {
-  const result = translatorInputErrorResult(
+test('responsesInputErrorResult honors an explicit input param', () => {
+  const result = responsesInputErrorResult(
     new TranslatorInputError('content block not supported', { param: 'input[1].content[0]' }),
   );
 
diff --git a/packages/gateway/src/data-plane/chat/responses/http.ts b/packages/gateway/src/data-plane/chat/responses/http.ts
index 7a1ce03fa..db7e17af4 100644
--- a/packages/gateway/src/data-plane/chat/responses/http.ts
+++ b/packages/gateway/src/data-plane/chat/responses/http.ts
@@ -1,4 +1,5 @@
-import { translatorInputErrorResult } from './errors.ts';
+import { ResponsesAffinityInputError } from './affinity/ingress.ts';
+import { responsesInputErrorResult } from './errors.ts';
 import { createResponsesHttpStore } from './items/store.ts';
 import { respondResponses } from './respond.ts';
 import { PreviousResponseNotFoundError } from './serve-prep.ts';
@@ -46,7 +47,7 @@ const respondWithInternalError = async (c: AuthedContext, error: unknown, reques
   if (verbatim !== null) return verbatim;
   const effectiveCtx = ctx ?? createGatewayCtxFromHono(c, { wantsStream: false, requestBody: takeRequestBody(requestBody), backgroundScheduler: backgroundSchedulerFromContext(c) });
   const result = internalErrorResult(502, toInternalDebugError(error), effectiveCtx.attempt.telemetry);
-  const { response } = await respondResponses(c, result, false, effectiveCtx);
+  const response = await respondResponses(c, result, false, effectiveCtx);
   return finalizeGatewayResponse(effectiveCtx, response);
 };
 
@@ -59,9 +60,9 @@ const respondToThrow = async (c: AuthedContext, error: unknown, requestBody: Req
     ctx?.dump?.error('gateway');
     return ctx ? finalizeGatewayResponse(ctx, response) : response;
   }
-  if (error instanceof TranslatorInputError) {
+  if (error instanceof TranslatorInputError || error instanceof ResponsesAffinityInputError) {
     const effectiveCtx = ctx ?? createGatewayCtxFromHono(c, { wantsStream: false, requestBody: takeRequestBody(requestBody), backgroundScheduler: backgroundSchedulerFromContext(c) });
-    const { response } = await respondResponses(c, translatorInputErrorResult(error, effectiveCtx.attempt.telemetry), false, effectiveCtx);
+    const response = await respondResponses(c, responsesInputErrorResult(error, effectiveCtx.attempt.telemetry), false, effectiveCtx);
     return finalizeGatewayResponse(effectiveCtx, response);
   }
   return await respondWithInternalError(c, error, requestBody, ctx);
@@ -79,7 +80,7 @@ export const responsesHttp = {
       const wantsStream = payload.stream === true;
       ctx = createChatGatewayCtxFromHono(c, { wantsStream, requestBody: takeRequestBody(requestBody), model: payload.model, backgroundScheduler: backgroundSchedulerFromContext(c) }, apiKeyId => createResponsesHttpStore(apiKeyId, payload.store ?? undefined));
       const result = await responsesServe.generate({ payload, ctx, headers: inboundHeadersForUpstream(c) });
-      const { response } = await respondResponses(c, result, wantsStream, ctx);
+      const response = await respondResponses(c, result, wantsStream, ctx);
       return finalizeGatewayResponse(ctx, response);
     } catch (error) {
       return await respondToThrow(c, error, requestBody, ctx);
@@ -116,7 +117,7 @@ export const responsesHttp = {
         const compactResponse = Response.json(result.result);
         return finalizeGatewayResponse(ctx, compactResponse);
       }
-      const { response } = await respondResponses(c, result, false, ctx);
+      const response = await respondResponses(c, result, false, ctx);
       return finalizeGatewayResponse(ctx, response);
     } catch (error) {
       return await respondToThrow(c, error, requestBody, ctx);
diff --git a/packages/gateway/src/data-plane/chat/responses/http_test.ts b/packages/gateway/src/data-plane/chat/responses/http_test.ts
index ba2883f8c..18338fcf2 100644
--- a/packages/gateway/src/data-plane/chat/responses/http_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/http_test.ts
@@ -1,11 +1,12 @@
 import { Hono } from 'hono';
 import { test, vi } from 'vitest';
 
-import { createStoredResponsesItemId, isStoredResponseId } from './items/format.ts';
+import { createResponsesItemId, hashResponsesItemBinding, isResponsesResponseId } from './items/format.ts';
 import type { AuthVars } from '../../../middleware/auth.ts';
 import { initRepo } from '../../../repo/index.ts';
 import { InMemoryRepo } from '../../../repo/memory.ts';
-import type { ApiKey, StoredResponsesItem, User } from '../../../repo/types.ts';
+import type { ApiKey, User } from '../../../repo/types.ts';
+import { AffinityCodec } from '../shared/affinity/index.ts';
 import { type AliasRules, doneFrame, eventFrame, type ModelEndpoints, type ProtocolFrame } from '@floway-dev/protocols/common';
 import type { CanonicalResponsesPayload, ResponsesResult, ResponsesStreamEvent } from '@floway-dev/protocols/responses';
 import { type FlagId, type ModelCandidate, directFetcher, type ProviderResponsesResult, type ResponsesAction, type UpstreamCallOptions } from '@floway-dev/provider';
@@ -61,6 +62,7 @@ const buildApiKey = (overrides: Partial<ApiKey> = {}): ApiKey => ({
   userId: 1,
   name: 'http_test',
   key: 'sk-http-test',
+  serverSecret: '00'.repeat(32),
   createdAt: '2026-01-01T00:00:00.000Z',
   upstreamIds: null,
   deletedAt: null,
@@ -183,7 +185,7 @@ test('POST /v1/responses streams a successful SSE body', async () => {
   // Wrap layer mints its own response id; upstream's "resp_test" is discarded.
   const completedMatch = body.match(/"id":"(resp_[A-Za-z0-9_-]+)"/);
   assert(completedMatch !== null, 'expected a Floway-minted resp_ id in the SSE body');
-  assert(isStoredResponseId(completedMatch[1]));
+  assert(isResponsesResponseId(completedMatch[1]));
   assertEquals(callResponses.mock.calls.length, 1);
 });
 
@@ -220,7 +222,9 @@ test('POST /v1/responses canonicalizes and promotes an implicit system message',
   });
 
   assertEquals(response.status, 200);
-  await response.text();
+  const responseBody = await response.text();
+  const responseId = responseBody.match(/"id":"(resp_[A-Za-z0-9_-]+)"/)?.[1];
+  assert(responseId !== undefined && isResponsesResponseId(responseId), 'expected store:false to retain a Floway response id');
   assertEquals(observedBody?.input, [
     { type: 'message', role: 'developer', content: 'rules' },
     { type: 'message', role: 'user', content: 'hello' },
@@ -254,7 +258,7 @@ test('POST /v1/responses returns a single JSON body when stream is omitted', asy
   assertEquals(response.status, 200);
   assertEquals(response.headers.get('content-type')?.split(';')[0], 'application/json');
   const body = await response.json() as ResponsesResult;
-  assert(isStoredResponseId(body.id), `expected Floway-minted resp_ id, got ${body.id}`);
+  assert(isResponsesResponseId(body.id), `expected Floway-minted resp_ id, got ${body.id}`);
   assertEquals(body.status, 'completed');
 });
 
@@ -323,7 +327,7 @@ test('POST /v1/responses returns 502 when the response snapshot cannot be persis
 });
 
 test('POST /v1/responses/compact returns a non-streaming compaction envelope', async () => {
-  installRepo();
+  const repo = installRepo();
   const compactionItem = { type: 'compaction' as const, id: 'cmp_1', encrypted_content: 'ENC' };
   const compactionResult: ResponsesResult = {
     ...makeResponsesResult(),
@@ -342,14 +346,17 @@ test('POST /v1/responses/compact returns a non-streaming compaction envelope', a
     body: JSON.stringify({
       model: 'test-model',
       input: [{ type: 'message', role: 'user', content: 'kept' }],
+      store: false,
     }),
   });
 
   assertEquals(response.status, 200);
   assertEquals(response.headers.get('content-type')?.split(';')[0], 'application/json');
-  const body = await response.json() as { object: string; id: string };
+  const body = await response.json() as { object: string; id: string; output: Array<{ id: string }> };
   assertEquals(body.object, 'response.compaction');
-  assert(isStoredResponseId(body.id), `expected Floway-minted resp_ id, got ${body.id}`);
+  assert(isResponsesResponseId(body.id), `expected Floway-minted resp_ id, got ${body.id}`);
+  assertEquals(await repo.responsesSnapshots.lookup(API_KEY_ID, body.id), null);
+  assertEquals(await repo.responsesItems.lookupMany(API_KEY_ID, body.output.map(item => item.id)), []);
 });
 
 test('POST /v1/responses with an unresolvable previous_response_id renders the verbatim 400 envelope', async () => {
@@ -374,46 +381,73 @@ test('POST /v1/responses with an unresolvable previous_response_id renders the v
   assertEquals(body.error.code, 'previous_response_not_found');
 });
 
-test('POST /v1/responses renders a routing-unavailable 400 when a forcing item names an absent upstream', async () => {
+test('POST /v1/responses rejects a concrete item whose stored ID has another type', async () => {
   const repo = installRepo();
-  // A stored item pinned to `up_forcing` makes the input force-route to that
-  // upstream; queueing a candidate for a different upstream produces the
-  // routing-unavailable failure that the http entry must surface verbatim.
-  const id = createStoredResponsesItemId('compaction');
-  const row: StoredResponsesItem = {
+  const id = createResponsesItemId('reasoning');
+  await repo.responsesItems.insertMany([{
     id,
     apiKeyId: API_KEY_ID,
-    upstreamId: 'up_forcing',
-    upstreamItemId: 'raw_cmp',
-    itemType: 'compaction',
-    origin: 'upstream',
-    contentHash: null,
-    encryptedContentHash: null,
-    payload: { item: { type: 'compaction', id } },
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-  };
-  await repo.responsesItems.insertMany([row]);
-  queueResolution([makeCandidate({ upstream: 'up_b' })]);
+    itemType: 'reasoning',
+    payload: { item: { type: 'reasoning', id, summary: [] } },
+    contentHash: 'hash',
+    createdAt: 1,
+  }]);
+  queueResolution([makeCandidate()]);
 
   const response = await makeApp().request('/v1/responses', {
     method: 'POST',
     headers: new Headers({ 'content-type': 'application/json' }),
     body: JSON.stringify({
       model: 'test-model',
-      input: [{ type: 'item_reference', id }],
+      input: [{ type: 'message', id, role: 'user', content: 'client content' }],
     }),
   });
 
   assertEquals(response.status, 400);
-  const body = await response.json() as { error: { code: string } };
+  const body = await response.json() as { error: { message: string; code: string } };
+  assertEquals(body.error.message, `Stored Responses item '${id}' has type 'reasoning', incompatible with the requested item type 'message'.`);
   assertEquals(body.error.code, 'responses_item_routing_unavailable');
 });
 
-// Alias flow: the resolver returns a candidate whose upstream catalog id is
-// the target model id, plus the alias's rule overlay. The attempt stamps its
-// private clone with `candidate.model.id`, and the leaf wire call reads
-// `candidate.rules` to overlay the rules onto the target IR.
+test('POST /v1/responses renders an invalid bound affinity carrier as a 400 input error', async () => {
+  installRepo();
+  const candidate = makeCandidate();
+  queueResolution([candidate]);
+  const codec = new AffinityCodec(buildApiKey().serverSecret);
+  const original = { type: 'program_output' as const, id: 'first', call_id: 'call_1', result: 'first', status: 'completed' as const };
+  const carrier = await codec.wrap(undefined, {
+    upstreamId: candidate.provider.upstream,
+    modelId: candidate.model.id,
+    syntheticItem: true,
+    boundItem: {
+      type: original.type,
+      upstreamItemId: 'first_upstream',
+      contentHash: await hashResponsesItemBinding(original),
+    },
+  }, 'responses.reasoning.encrypted_content');
+
+  const response = await makeApp().request('/v1/responses', {
+    method: 'POST',
+    headers: new Headers({ 'content-type': 'application/json' }),
+    body: JSON.stringify({
+      model: 'test-model',
+      input: [
+        { type: 'reasoning', id: 'rs_prefix', summary: [], encrypted_content: carrier },
+        { type: 'program_output', id: 'second', call_id: 'call_2', result: 'second', status: 'completed' },
+      ],
+    }),
+  });
+
+  assertEquals(response.status, 400);
+  const body = await response.json() as { error: { message: string; type: string; param: string; code: null } };
+  assertEquals(body.error, {
+    message: 'Affinity carrier does not match the Responses input item at index 1.',
+    type: 'invalid_request_error',
+    param: 'input[1]',
+    code: null,
+  });
+});
+
 const queueCodexAutoReviewCandidate = (
   callResponses: (model: unknown, body: unknown, action: ResponsesAction, signal?: AbortSignal, opts?: UpstreamCallOptions) => Promise<ProviderResponsesResult>,
 ): void => {
diff --git a/packages/gateway/src/data-plane/chat/responses/interceptors/compact-shim.ts b/packages/gateway/src/data-plane/chat/responses/interceptors/compact-shim.ts
index 8f93faa9e..faecbdca0 100644
--- a/packages/gateway/src/data-plane/chat/responses/interceptors/compact-shim.ts
+++ b/packages/gateway/src/data-plane/chat/responses/interceptors/compact-shim.ts
@@ -322,15 +322,7 @@ const simulateCompaction = async (ctx: ResponsesInvocation, gatewayCtx: ChatGate
 
   const collected = await collectResponsesProtocolEventsToResult(upstreamResult.events);
   const summaryText = extractTextFromResult(collected);
-  // The minted compaction id is gateway-internal — the upstream never issued
-  // it. Register it as synthetic so `wrapResponsesOutputForStorage` stores
-  // the row with `upstreamId: null`, which keeps `classifyStoredResponsesAffinity`
-  // from treating a future echo of this compaction as a forcing reference that
-  // pins routing to whichever upstream happened to run the summarization turn.
-  // (For non-responses targets the targetApi check already suppresses
-  // ownership; this also covers the responses-target + flag-on engagement.)
   const cmpId = `cmp_${crypto.randomUUID()}`;
-  gatewayCtx.store.addSyntheticItem(cmpId);
   const synthesized = buildCompactionEnvelope(cmpId, summaryText, collected);
 
   return {
@@ -339,10 +331,6 @@ const simulateCompaction = async (ctx: ResponsesInvocation, gatewayCtx: ChatGate
   };
 };
 
-// True when the payload carries a `compaction_trigger` input item — Codex
-// CLI's RemoteCompactionV2 path that semantically requests compaction
-// through `action: 'generate'`. Exported so callers outside the shim
-// (attempt.ts's snapshot-mode derivation) can ask the same question.
 export const containsCompactionTrigger = (input: readonly ResponsesInputItem[]): boolean =>
   input.some(item => item.type === 'compaction_trigger');
 
diff --git a/packages/gateway/src/data-plane/chat/responses/interceptors/compact-shim_test.ts b/packages/gateway/src/data-plane/chat/responses/interceptors/compact-shim_test.ts
index b03e51f5a..8d72622b6 100644
--- a/packages/gateway/src/data-plane/chat/responses/interceptors/compact-shim_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/interceptors/compact-shim_test.ts
@@ -230,25 +230,6 @@ test('compact + flag on: synthesized encrypted_content decodes to a user message
   assertEquals(decoded[0].content[0].text, `${SUMMARY_PREFIX}\nTHE SUMMARY`);
 });
 
-test('compact + flag on: synthesized compaction id is registered as synthetic so storage drops upstream affinity', async () => {
-  // The minted `cmp_<uuid>` is gateway-internal — no upstream issued it.
-  // wrapResponsesOutputForStorage keys upstreamOwned on
-  // `targetApi === 'responses' && !store.isSyntheticItem(upstreamId)`; without
-  // the synthetic registration, a flag-on engagement against a responses
-  // target would store the row with the originating upstreamId set, and
-  // classifyStoredResponsesAffinity would lock routing to that upstream
-  // on any later turn that echoes the compaction.
-  const inv = makeInvocation(
-    { input: [{ type: 'message', role: 'user', content: 'history' }] },
-    { action: 'compact' },
-  );
-  const result = await withResponsesCompactShim(inv, stubCtx, fakeUpstreamRun('summary'));
-  if (result.type !== 'events') throw new Error('expected events branch');
-  const collected = await collectResponsesProtocolEventsToResult(result.events);
-  const compactionItem = collected.output[0] as { type: string; id: string };
-  assertEquals(stubCtx.store.isSyntheticItem(compactionItem.id), true);
-});
-
 test('compact + flag on: upstream `output_text` SDK alias is dropped from the synthesized envelope', async () => {
   const inv = makeInvocation(
     { input: [{ type: 'message', role: 'user', content: 'history' }] },
diff --git a/packages/gateway/src/data-plane/chat/responses/interceptors/server-tool-shim.ts b/packages/gateway/src/data-plane/chat/responses/interceptors/server-tool-shim.ts
index 9d2c6e58d..afeee8fa2 100644
--- a/packages/gateway/src/data-plane/chat/responses/interceptors/server-tool-shim.ts
+++ b/packages/gateway/src/data-plane/chat/responses/interceptors/server-tool-shim.ts
@@ -3,7 +3,7 @@ import { jsonrepair } from 'jsonrepair';
 import type { ResponsesInterceptor, ResponsesInvocation } from './types.ts';
 import type { ChatGatewayCtx } from '../../shared/gateway-ctx.ts';
 import { truncatePreservingCodePoints } from '../../shared/text.ts';
-import type { StatefulResponsesStore } from '../items/store.ts';
+import type { ResponsesAttemptState } from '../attempt-state.ts';
 import type { InterceptorRun } from '@floway-dev/interceptor';
 import { eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
 import type {
@@ -56,7 +56,7 @@ export interface ServerToolTerminal {
   endEvents: ServerToolLifecycleEvent[];
   /**
    * Optional server-only blob registered on
-   * `request.statefulResponsesStore` under `slot.id` before
+   * request-local attempt state under `slot.id` before
    * the slot's wire item leaves materialize. The persistence layer stores it in
    * `payload.private`; the replay-side `transformItems` reads it back to
    * reconstruct the full IR.
@@ -828,7 +828,7 @@ const synthesizeTerminalEnvelope = (
 async function* materializeServerToolItems(
   dispatched: ReadonlyArray<{ slots: DispatchedServerToolSlot[] }>,
   merge: MergeState,
-  statefulResponsesStore: StatefulResponsesStore,
+  attemptState: ResponsesAttemptState,
 ): AsyncGenerator<ProtocolFrame<ResponsesStreamEvent>, void> {
   for (const d of dispatched) {
     for (const { slot, outputIndex } of d.slots) {
@@ -838,13 +838,10 @@ async function* materializeServerToolItems(
         yield stampServerToolEvent(merge, outputIndex, slot.id, step.value);
         step = await lifecycle.next();
       }
-      // The slot item is gateway-synthesized, not upstream-emitted; register
-      // its id so persistence stores it with no upstream identity even on a
-      // native Responses stream. The private payload (when the dispatcher
-      // produced one) registers under the same id so persistence captures it
-      // and the next loop turn's replay-side `transformItems` finds it by the
-      // accumulated output item's id.
-      statefulResponsesStore.addSyntheticItem(slot.id, step.value.privatePayload);
+      // Register private dispatcher state under the emitted item id so output
+      // persistence captures it and replay-side `transformItems` can restore
+      // it on the next loop turn.
+      attemptState.setPrivatePayload(slot.id, step.value.privatePayload);
       yield* serverToolEndFrames(merge, outputIndex, slot, step.value);
     }
   }
@@ -858,13 +855,13 @@ async function* runMultiTurnLoop(args: {
   demoteForcedServerToolChoiceAfterFirstTurn: boolean;
   turn1Iter: AsyncGenerator<ProtocolFrame<ResponsesStreamEvent>, TurnSummary>;
   dispatchers: ReadonlyMap<string, ServerToolDispatcher>;
-  statefulResponsesStore: StatefulResponsesStore;
+  attemptState: ResponsesAttemptState;
   canonicalInput: ResponsesInputItem[];
   active: readonly ActiveServerTool[];
   metadata: LatestUpstreamMetadata;
   resolveFinalMetadata: (m: EventResultMetadata) => void;
 }): AsyncGenerator<ProtocolFrame<ResponsesStreamEvent>> {
-  const { ctx, run, merge, loopState, demoteForcedServerToolChoiceAfterFirstTurn, turn1Iter, dispatchers, statefulResponsesStore, active, metadata, resolveFinalMetadata } = args;
+  const { ctx, run, merge, loopState, demoteForcedServerToolChoiceAfterFirstTurn, turn1Iter, dispatchers, attemptState, active, metadata, resolveFinalMetadata } = args;
   const baseInput = args.canonicalInput;
   let midStreamError: unknown = undefined;
   try {
@@ -875,12 +872,12 @@ async function* runMultiTurnLoop(args: {
       const executedShim = turn.dispatched.length > 0;
 
       if (turn.terminalStatus.kind === 'failed') {
-        if (executedShim) yield* materializeServerToolItems(turn.dispatched, merge, statefulResponsesStore);
+        if (executedShim) yield* materializeServerToolItems(turn.dispatched, merge, attemptState);
         yield synthesizeTerminalEnvelope(merge, { kind: 'failed', error: turn.terminalStatus.response.error }, active);
         return;
       }
       if (turn.terminalStatus.kind === 'incomplete') {
-        if (executedShim) yield* materializeServerToolItems(turn.dispatched, merge, statefulResponsesStore);
+        if (executedShim) yield* materializeServerToolItems(turn.dispatched, merge, attemptState);
         yield synthesizeTerminalEnvelope(merge, { kind: 'incomplete', incompleteDetails: turn.terminalStatus.response.incomplete_details }, active);
         return;
       }
@@ -896,7 +893,7 @@ async function* runMultiTurnLoop(args: {
         return;
       }
 
-      yield* materializeServerToolItems(turn.dispatched, merge, statefulResponsesStore);
+      yield* materializeServerToolItems(turn.dispatched, merge, attemptState);
       if (turn.sawClientToolCall) {
         yield synthesizeTerminalEnvelope(merge, { kind: 'completed' }, active);
         return;
@@ -1033,7 +1030,7 @@ export const withResponsesServerToolShim = (
       demoteForcedServerToolChoiceAfterFirstTurn,
       turn1Iter,
       dispatchers,
-      statefulResponsesStore: gatewayCtx.store,
+      attemptState: gatewayCtx.responsesAttemptState,
       canonicalInput,
       active,
       metadata,
diff --git a/packages/gateway/src/data-plane/chat/responses/interceptors/server-tool-shim_test.ts b/packages/gateway/src/data-plane/chat/responses/interceptors/server-tool-shim_test.ts
index fa73a88bb..23e29a1ee 100644
--- a/packages/gateway/src/data-plane/chat/responses/interceptors/server-tool-shim_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/interceptors/server-tool-shim_test.ts
@@ -636,7 +636,7 @@ test('shim drives one search then a final message in two upstream turns', async
   assertEquals(events[events.length - 1].type, 'response.completed');
 });
 
-test('synthesized web_search_call ids are registered as gateway-synthetic on the request', async () => {
+test('synthesized web_search_call ids retain request-private replay state', async () => {
   makeStubDeps();
   const shim = withResponsesWebSearchShim;
   const inv = makeInvocation();
@@ -648,20 +648,16 @@ test('synthesized web_search_call ids are registered as gateway-synthetic on the
 
   const { frames } = await runShimAndDrain(shim, inv, ctx, script.run);
 
-  // Every web_search_call the shim synthesizes carries a gateway-minted id no
-  // upstream issued; persistence relies on these being registered so it stores
-  // them with no upstream identity (non_affinity).
   const doneEvents = outputItemDoneEvents(frames);
   const wsCallDoneIds = doneEvents.filter(e => e.item.type === 'web_search_call').map(e => e.item.id!);
-  const store = ctx.store;
+  const attemptState = ctx.responsesAttemptState;
   assert(wsCallDoneIds.length > 0, 'expected a synthesized web_search_call');
   for (const id of wsCallDoneIds) {
     assert(id.startsWith('ws_gw_'));
-    assert(store.isSyntheticItem(id), `expected ${id} registered as synthetic`);
+    assert(attemptState.getPrivatePayload(id) !== undefined, `expected ${id} to retain private replay state`);
   }
-  // A genuine upstream item (the final message) is not registered.
   for (const e of doneEvents.filter(e => e.item.type === 'message')) {
-    assertFalse(store.isSyntheticItem(e.item.id!));
+    assertFalse(attemptState.getPrivatePayload(e.item.id!) !== undefined);
   }
 });
 
diff --git a/packages/gateway/src/data-plane/chat/responses/interceptors/server-tools/web-search.ts b/packages/gateway/src/data-plane/chat/responses/interceptors/server-tools/web-search.ts
index b3cdb3021..02be669fb 100644
--- a/packages/gateway/src/data-plane/chat/responses/interceptors/server-tools/web-search.ts
+++ b/packages/gateway/src/data-plane/chat/responses/interceptors/server-tools/web-search.ts
@@ -603,7 +603,7 @@ export const webSearchServerTool: ServerToolRegistration = async (invocation, ga
   return {
     type: 'active',
     baseToolName: SHIM_TOOL_NAME,
-    transformItems: (items, toolName) => transformInputItemsForWebSearch(items, toolName, id => gatewayCtx.store.getPrivatePayload(id)),
+    transformItems: (items, toolName) => transformInputItemsForWebSearch(items, toolName, id => gatewayCtx.responsesAttemptState.getPrivatePayload(id)),
     ...(hasHostedWebSearch
       ? {
           hosted: {
diff --git a/packages/gateway/src/data-plane/chat/responses/items/affinity.ts b/packages/gateway/src/data-plane/chat/responses/items/affinity.ts
deleted file mode 100644
index 60602bb85..000000000
--- a/packages/gateway/src/data-plane/chat/responses/items/affinity.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-import { isStoredResponsesItemId, responsesItemEncryptedContent, responsesItemId } from './format.ts';
-import type { StatefulResponsesStore } from './store.ts';
-import type { StoredResponsesItemMetadata } from '../../../../repo/types.ts';
-import type { ChatServeFailure } from '../../shared/errors.ts';
-import type { RoutingDecision } from '../../shared/routing.ts';
-import type { ResponsesInputItem } from '@floway-dev/protocols/responses';
-import type { ModelCandidate } from '@floway-dev/provider';
-import type { ResponsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
-
-type StoredResponsesAffinity = 'forcing' | 'portable' | 'downgradable' | 'non_affinity';
-
-interface ResolvedStoredResponsesItemRef {
-  type: string;
-  id?: string;
-  encryptedContent?: string;
-  row?: StoredResponsesItemMetadata;
-  affinity?: StoredResponsesAffinity;
-}
-
-const isUpstreamOwned = (row: StoredResponsesItemMetadata): row is StoredResponsesItemMetadata & { upstreamId: string } =>
-  row.upstreamId !== null;
-
-const classifyStoredResponsesAffinity = (row: StoredResponsesItemMetadata): StoredResponsesAffinity => {
-  if (!isUpstreamOwned(row)) return 'non_affinity';
-  // Direct Copilot probes show the opaque item id on each program variant is
-  // account-bound: same-account replay succeeds after token refresh, while
-  // cross-account replay fails with "item ID does not belong to this connection".
-  if (row.itemType === 'compaction' || row.itemType === 'program' || row.itemType === 'program_output') return 'forcing';
-  if (row.itemType === 'context_compaction' && row.encryptedContentHash !== null) return 'forcing';
-  if (row.itemType === 'reasoning') return 'downgradable';
-  return 'portable';
-};
-
-const collectForcingUpstreams = (
-  references: readonly ResolvedStoredResponsesItemRef[],
-): ReadonlySet<string> => {
-  const upstreams = new Set<string>();
-  for (const ref of references) {
-    if (ref.affinity !== 'forcing' || !ref.row?.upstreamId) continue;
-    upstreams.add(ref.row.upstreamId);
-  }
-  return upstreams;
-};
-
-const collectPreferredUpstreams = (
-  references: readonly ResolvedStoredResponsesItemRef[],
-): ReadonlySet<string> => {
-  const preferred = new Set<string>();
-  for (const ref of references) {
-    if (ref.affinity !== 'portable' && ref.affinity !== 'downgradable') continue;
-    if (!ref.row || !isUpstreamOwned(ref.row)) continue;
-    // Re-insert so the most-recently-referenced upstream lands last in
-    // insertion order; orderCandidatesByStoredResponsesAffinity reverses this
-    // set, sorting that upstream first.
-    preferred.delete(ref.row.upstreamId);
-    preferred.add(ref.row.upstreamId);
-  }
-  return preferred;
-};
-
-const collectStoredResponsesItemRefs = async <TSourceItems>(
-  sourceItems: TSourceItems,
-  view: Pick<ResponsesItemsView<TSourceItems>, 'visitAsResponsesItems'>,
-): Promise<ResolvedStoredResponsesItemRef[]> => {
-  const references: ResolvedStoredResponsesItemRef[] = [];
-
-  await view.visitAsResponsesItems(sourceItems, item => {
-    const id = responsesItemId(item);
-    const encryptedContent = responsesItemEncryptedContent(item);
-    // A reference is anything that could name a stored row — an id (a gateway
-    // id, or an `item_reference` asserting one) or an `encrypted_content` blob.
-    // Items that carry their own inline content with neither pass through.
-    if (id === null && encryptedContent === null) return;
-    if (item.type === 'item_reference') {
-      // `ResponsesItemReference` requires `id` at the protocol level, so an
-      // `item_reference` source item without one is a visitor bug.
-      if (id === null) throw new Error('item_reference without an id reached collectStoredResponsesItemRefs');
-      references.push({ type: 'item_reference', id });
-      return;
-    }
-    references.push({
-      type: item.type,
-      ...(id !== null ? { id } : {}),
-      ...(encryptedContent !== null ? { encryptedContent } : {}),
-    });
-  });
-
-  return references;
-};
-
-const orderCandidatesByStoredResponsesAffinity = <T extends ModelCandidate>(
-  candidates: readonly T[],
-  preferredUpstreamIds: ReadonlySet<string>,
-): readonly T[] => {
-  const preferred = [...preferredUpstreamIds].reverse();
-  if (preferred.length === 0) return candidates;
-
-  const order = new Map(preferred.map((upstreamId, index) => [upstreamId, index]));
-  const preferredCandidates = candidates
-    .filter(cand => order.has(cand.provider.upstream))
-    .toSorted((a, b) => order.get(a.provider.upstream)! - order.get(b.provider.upstream)!);
-  const remainingCandidates = candidates.filter(cand => !order.has(cand.provider.upstream));
-  return [...preferredCandidates, ...remainingCandidates];
-};
-
-export const classifyResponsesItemAffinity = async <TSourceItems, TCandidate extends ModelCandidate>(input: {
-  sourceItems: TSourceItems;
-  view: ResponsesItemsView<TSourceItems>;
-  store: StatefulResponsesStore;
-  candidates: readonly TCandidate[];
-  // Items the caller will stage as inputs after the affinity walk; passed
-  // here so `loadInputItems` can pre-load any stored row whose content hash
-  // matches one of them. Without this, a duplicate user message resent on
-  // a later turn cannot be reused — it would mint a fresh row each time.
-  inputItemsToStage?: readonly ResponsesInputItem[];
-}): Promise<RoutingDecision<TCandidate>> => {
-  const { sourceItems, view, store, candidates, inputItemsToStage } = input;
-  await store.loadInputItems({
-    sourceItems,
-    view,
-    inputItemsToStage,
-  });
-  const references = await collectStoredResponsesItemRefs(sourceItems, view);
-
-  const queryableIds = new Set(references.flatMap(ref => ref.id !== undefined && isStoredResponsesItemId(ref.id) ? [ref.id] : []));
-  const hashByContent = new Map(await Promise.all(
-    [...new Set(references.flatMap(ref => ref.encryptedContent !== undefined ? [ref.encryptedContent] : []))]
-      .map(async content => [content, await store.hashEncryptedContent(content)] as const),
-  ));
-
-  const failures: ChatServeFailure[] = [];
-  for (const ref of references) {
-    const row = (ref.id !== undefined ? store.getItemById(ref.id) : undefined)
-      ?? (ref.encryptedContent !== undefined
-        ? (() => {
-            const hashMatches = store.getItemsByEncryptedContentHash(hashByContent.get(ref.encryptedContent)!);
-            return hashMatches.find(r => ref.type === 'item_reference' || r.itemType === ref.type) ?? hashMatches[0];
-          })()
-        : undefined);
-    if (row === undefined) {
-      if (ref.type === 'item_reference') {
-        // collectStoredResponsesItemRefs guarantees item_reference rows carry an id.
-        if (ref.id === undefined) throw new Error('item_reference ref reached affinity walk without an id');
-        failures.push({ kind: 'item-not-found', itemId: ref.id });
-      } else if (ref.id !== undefined && queryableIds.has(ref.id)) {
-        failures.push({ kind: 'item-not-found', itemId: ref.id });
-      }
-      continue;
-    }
-
-    store.touchItem(row.id);
-    ref.row = row;
-    if (ref.type === 'item_reference' && !row.hasPayload) {
-      failures.push({ kind: 'item-not-found', itemId: row.id });
-      continue;
-    }
-    if (ref.type !== 'item_reference' && ref.type !== row.itemType) {
-      failures.push({
-        kind: 'routing-unavailable',
-        message: `Stored Responses item '${row.id}' has type '${row.itemType}', incompatible with the requested item type '${ref.type}'.`,
-      });
-      continue;
-    }
-    ref.affinity = classifyStoredResponsesAffinity(row);
-    if (ref.affinity === 'forcing' && !isUpstreamOwned(row)) {
-      failures.push({ kind: 'item-not-found', itemId: row.id });
-    }
-  }
-
-  if (failures.length > 0) return { kind: 'failure', failure: failures[0] };
-
-  const forcingUpstreamList = [...collectForcingUpstreams(references)];
-
-  if (forcingUpstreamList.length > 1) {
-    return {
-      kind: 'failure',
-      failure: {
-        kind: 'routing-unavailable',
-        message: `Stored Responses items in this request require multiple incompatible upstreams: ${forcingUpstreamList.map(id => `'${id}'`).join(', ')}.`,
-      },
-    };
-  }
-
-  if (forcingUpstreamList.length === 1) {
-    const [upstreamId] = forcingUpstreamList;
-    const matching = candidates.filter(cand => cand.provider.upstream === upstreamId);
-    if (matching.length === 0) {
-      return {
-        kind: 'failure',
-        failure: {
-          kind: 'routing-unavailable',
-          message: `Stored Responses items in this request require upstream '${upstreamId}', which is not available for the selected model.`,
-        },
-      };
-    }
-    return { kind: 'success', candidates: matching };
-  }
-
-  const preferredUpstreamIds = collectPreferredUpstreams(references);
-  return { kind: 'success', candidates: orderCandidatesByStoredResponsesAffinity(candidates, preferredUpstreamIds) };
-};
diff --git a/packages/gateway/src/data-plane/chat/responses/items/affinity_test.ts b/packages/gateway/src/data-plane/chat/responses/items/affinity_test.ts
deleted file mode 100644
index 21805b662..000000000
--- a/packages/gateway/src/data-plane/chat/responses/items/affinity_test.ts
+++ /dev/null
@@ -1,318 +0,0 @@
-import { test } from 'vitest';
-
-import { classifyResponsesItemAffinity } from './affinity.ts';
-import { createStoredResponsesItemId, hashResponsesItemEncryptedContent } from './format.ts';
-import { createNonResponsesSourceStore } from './store.ts';
-import { initRepo } from '../../../../repo/index.ts';
-import { InMemoryRepo } from '../../../../repo/memory.ts';
-import type { StoredResponsesItem } from '../../../../repo/types.ts';
-import type { ResponsesInputItem } from '@floway-dev/protocols/responses';
-import type { ModelCandidate } from '@floway-dev/provider';
-import { directFetcher } from '@floway-dev/provider';
-import { stubInternalModel, stubProvider, stubProviderModel, assertEquals } from '@floway-dev/test-utils';
-import { responsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
-
-const API_KEY_ID = 'key_affinity_test';
-
-const candidate = (upstream: string): ModelCandidate => {
-  const modelProvider = stubProvider({
-    getProvidedModels: () => Promise.resolve([stubProviderModel()]),
-  });
-  return {
-    provider: {
-      upstream,
-      kind: 'custom',
-      name: upstream,
-      disabledPublicModelIds: [],
-      modelPrefix: null,
-      instance: modelProvider,
-    },
-    model: stubInternalModel({}, upstream),
-    fetcher: directFetcher,
-  };
-};
-
-const insertRows = async (rows: readonly StoredResponsesItem[]) => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  await repo.responsesItems.insertMany(rows);
-  return repo;
-};
-
-const storedRow = (
-  overrides: Omit<Partial<StoredResponsesItem>, 'payload'> & Pick<StoredResponsesItem, 'id' | 'itemType'> & { payload?: unknown | null },
-): StoredResponsesItem => {
-  const { payload, ...rest } = overrides;
-  return {
-    apiKeyId: API_KEY_ID,
-    upstreamId: null,
-    upstreamItemId: null,
-    origin: overrides.origin ?? (overrides.upstreamId === undefined || overrides.upstreamId === null ? 'synthetic' : 'upstream'),
-    contentHash: null,
-    encryptedContentHash: null,
-    payload: payload === undefined || payload === null
-      ? null
-      : typeof payload === 'object' && Object.hasOwn(payload, 'item')
-        ? payload as StoredResponsesItem['payload']
-        : { item: payload },
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-    ...rest,
-  };
-};
-
-const classifyItems = async (
-  sourceItems: readonly ResponsesInputItem[],
-  candidates: readonly ModelCandidate[],
-) => {
-  const store = createNonResponsesSourceStore(API_KEY_ID);
-  return await classifyResponsesItemAffinity({
-    sourceItems,
-    view: responsesItemsView,
-    store,
-    candidates,
-  });
-};
-
-const storedMessageId = (_label: string): string => createStoredResponsesItemId('message');
-const storedReasoningId = (_label: string): string => createStoredResponsesItemId('reasoning');
-const storedCompactionId = (_label: string): string => createStoredResponsesItemId('compaction');
-const storedProgramId = (_label: string): string => createStoredResponsesItemId('program');
-const storedProgramOutputId = (_label: string): string => createStoredResponsesItemId('program_output');
-
-test('missing stored item_reference returns item-not-found failure', async () => {
-  await insertRows([]);
-  const id = storedMessageId('missing');
-
-  const result = await classifyItems([{ type: 'item_reference', id }], [candidate('up_a')]);
-
-  assertEquals(result.kind, 'failure');
-  if (result.kind === 'failure') {
-    assertEquals(result.failure.kind, 'item-not-found');
-    if (result.failure.kind === 'item-not-found') assertEquals(result.failure.itemId, id);
-  }
-});
-
-test('invalid stored item_reference ids are not looked up as stored rows', async () => {
-  const id = 'msg_AAAAAA_0xVvS8c_KjD1sBkZk5qbdA';
-  await insertRows([
-    storedRow({ id, itemType: 'message', upstreamId: 'up_a', upstreamItemId: 'raw_msg_a' }),
-  ]);
-
-  const result = await classifyItems([{ type: 'item_reference', id }], [candidate('up_a')]);
-
-  assertEquals(result.kind, 'failure');
-  if (result.kind === 'failure') assertEquals(result.failure.kind, 'item-not-found');
-});
-
-test('metadata-only item_reference without upstream affinity rejects instead of routing', async () => {
-  const id = storedMessageId('metadata-only-reference');
-  await insertRows([
-    storedRow({ id, itemType: 'message', upstreamId: null, upstreamItemId: null, payload: null }),
-  ]);
-
-  const result = await classifyItems([{ type: 'item_reference', id }], [candidate('up_a')]);
-
-  assertEquals(result.kind, 'failure');
-  if (result.kind === 'failure') assertEquals(result.failure.kind, 'item-not-found');
-});
-
-test('metadata-only item_reference with upstream affinity but no upstream item id rejects as not found', async () => {
-  const id = storedMessageId('metadata-only-origin-reference');
-  await insertRows([
-    storedRow({ id, itemType: 'message', upstreamId: 'up_a', upstreamItemId: null, payload: null }),
-  ]);
-
-  const result = await classifyItems([{ type: 'item_reference', id }], [candidate('up_a')]);
-
-  assertEquals(result.kind, 'failure');
-  if (result.kind === 'failure') assertEquals(result.failure.kind, 'item-not-found');
-});
-
-test('empty references pass through all candidates unchanged', async () => {
-  await insertRows([]);
-
-  const result = await classifyItems([], [candidate('up_a'), candidate('up_b')]);
-
-  assertEquals(result.kind, 'success');
-  if (result.kind === 'success') assertEquals(result.candidates.map(c => c.provider.upstream), ['up_a', 'up_b']);
-});
-
-test('non-affinity items (no id, no encrypted_content) pass through candidates unchanged', async () => {
-  await insertRows([]);
-  const items: ResponsesInputItem[] = [{ type: 'message', role: 'user', content: 'hello' }];
-
-  const result = await classifyItems(items, [candidate('up_a'), candidate('up_b')]);
-
-  assertEquals(result.kind, 'success');
-  if (result.kind === 'success') assertEquals(result.candidates.map(c => c.provider.upstream), ['up_a', 'up_b']);
-});
-
-test('duplicate stored ids dedupe preferred upstreams by last occurrence', async () => {
-  const first = storedReasoningId('first');
-  const second = storedReasoningId('second');
-  await insertRows([
-    storedRow({ id: first, itemType: 'reasoning', upstreamId: 'up_a', upstreamItemId: 'raw_rs_a' }),
-    storedRow({ id: second, itemType: 'reasoning', upstreamId: 'up_b', upstreamItemId: 'raw_rs_b' }),
-  ]);
-
-  const result = await classifyItems([
-    { type: 'reasoning', id: first, summary: [{ type: 'summary_text', text: 'first-old' }] },
-    { type: 'reasoning', id: second, summary: [{ type: 'summary_text', text: 'second' }] },
-    { type: 'reasoning', id: first, summary: [{ type: 'summary_text', text: 'first-new' }] },
-  ], [candidate('up_b'), candidate('up_a')]);
-
-  // up_a appears last so it should be sorted first; up_b second
-  assertEquals(result.kind, 'success');
-  if (result.kind === 'success') assertEquals(result.candidates.map(c => c.provider.upstream), ['up_a', 'up_b']);
-});
-
-test('mixed portable upstreams are ordered by reverse last occurrence before remaining candidates', async () => {
-  const first = storedReasoningId('first');
-  const second = storedReasoningId('second');
-  await insertRows([
-    storedRow({ id: first, itemType: 'reasoning', upstreamId: 'up_a', upstreamItemId: 'raw_rs_a' }),
-    storedRow({ id: second, itemType: 'reasoning', upstreamId: 'up_b', upstreamItemId: 'raw_rs_b' }),
-  ]);
-
-  const result = await classifyItems([
-    { type: 'reasoning', id: first, summary: [{ type: 'summary_text', text: 'first' }] },
-    { type: 'reasoning', id: second, summary: [{ type: 'summary_text', text: 'second' }] },
-  ], [candidate('up_c'), candidate('up_a'), candidate('up_b')]);
-
-  assertEquals(result.kind, 'success');
-  if (result.kind === 'success') assertEquals(result.candidates.map(c => c.provider.upstream), ['up_b', 'up_a', 'up_c']);
-});
-
-test.each([
-  { type: 'program' as const, id: storedProgramId, item: (id: string) => ({ type: 'program' as const, id, call_id: 'call_prog', code: 'return 1', fingerprint: 'opaque' }) },
-  { type: 'program_output' as const, id: storedProgramOutputId, item: (id: string) => ({ type: 'program_output' as const, id, call_id: 'call_prog', result: '1', status: 'completed' as const }) },
-])('$type item forces affinity to its producing upstream', async ({ type, id: createId, item: createItem }) => {
-  const id = createId('account-bound');
-  const item = createItem(id);
-  await insertRows([
-    storedRow({ id, itemType: type, upstreamId: 'up_a', upstreamItemId: `raw_${type}`, payload: item }),
-  ]);
-
-  const result = await classifyItems([item], [candidate('up_b'), candidate('up_a')]);
-
-  assertEquals(result.kind, 'success');
-  if (result.kind === 'success') assertEquals(result.candidates.map(c => c.provider.upstream), ['up_a']);
-});
-
-test('conflicting compaction forcing upstreams reject the request', async () => {
-  const first = storedCompactionId('first');
-  const second = storedCompactionId('second');
-  await insertRows([
-    storedRow({ id: first, itemType: 'compaction', upstreamId: 'up_a', upstreamItemId: 'raw_cmp_a' }),
-    storedRow({ id: second, itemType: 'compaction', upstreamId: 'up_b', upstreamItemId: 'raw_cmp_b' }),
-  ]);
-
-  const result = await classifyItems([
-    { type: 'compaction', id: first },
-    { type: 'compaction', id: second },
-  ] as ResponsesInputItem[], [candidate('up_a'), candidate('up_b')]);
-
-  assertEquals(result.kind, 'failure');
-  if (result.kind === 'failure') assertEquals(result.failure.kind, 'routing-unavailable');
-});
-
-test('row item type must match source item type', async () => {
-  const reasoningId = storedReasoningId('wrong-type');
-  await insertRows([
-    storedRow({ id: reasoningId, itemType: 'reasoning', upstreamId: 'up_a', upstreamItemId: 'raw_rs_a' }),
-  ]);
-
-  const result = await classifyItems([
-    { type: 'message', id: reasoningId, role: 'assistant', content: 'visible message' },
-  ] as ResponsesInputItem[], [candidate('up_a')]);
-
-  assertEquals(result.kind, 'failure');
-  if (result.kind === 'failure') assertEquals(result.failure.kind, 'routing-unavailable');
-});
-
-test('metadata-only item_reference rejects even with an upstream item id', async () => {
-  const id = storedMessageId('metadata-only-reference-with-upstream-item-id');
-  await insertRows([
-    storedRow({ id, itemType: 'message', upstreamId: 'up_a', upstreamItemId: 'raw_msg_a', payload: null }),
-  ]);
-
-  const result = await classifyItems([{ type: 'item_reference', id }], [candidate('up_a')]);
-
-  assertEquals(result.kind, 'failure');
-  if (result.kind === 'failure') {
-    assertEquals(result.failure.kind, 'item-not-found');
-    if (result.failure.kind === 'item-not-found') assertEquals(result.failure.itemId, id);
-  }
-});
-
-test('forcing upstream with no matching candidate rejects as routing-unavailable', async () => {
-  const id = storedCompactionId('forcing-no-candidate');
-  await insertRows([
-    storedRow({ id, itemType: 'compaction', upstreamId: 'up_a', upstreamItemId: 'raw_cmp_a' }),
-  ]);
-
-  const result = await classifyItems([
-    { type: 'compaction', id } as ResponsesInputItem,
-  ], [candidate('up_b')]);
-
-  assertEquals(result.kind, 'failure');
-  if (result.kind === 'failure') assertEquals(result.failure.kind, 'routing-unavailable');
-});
-
-test('id-less reasoning is matched by encrypted_content hash and prefers its owning upstream', async () => {
-  const enc = 'enc-reasoning-blob';
-  const hash = await hashResponsesItemEncryptedContent(enc);
-  await insertRows([
-    storedRow({ id: storedReasoningId('owned'), itemType: 'reasoning', upstreamId: 'up_a', upstreamItemId: 'raw_rs_a', encryptedContentHash: hash, payload: null }),
-  ]);
-
-  const items = [{ type: 'reasoning', summary: [], encrypted_content: enc }] as unknown as ResponsesInputItem[];
-  const result = await classifyItems(items, [candidate('up_b'), candidate('up_a')]);
-
-  assertEquals(result.kind, 'success');
-  if (result.kind === 'success') assertEquals(result.candidates.map(c => c.provider.upstream), ['up_a', 'up_b']);
-});
-
-test('id-less encrypted_content duplicate hash keeps the freshest stored row for affinity', async () => {
-  const enc = 'duplicate-enc';
-  const hash = await hashResponsesItemEncryptedContent(enc);
-  await insertRows([
-    storedRow({ id: storedReasoningId('old'), itemType: 'reasoning', upstreamId: 'up_old', upstreamItemId: 'raw_old', encryptedContentHash: hash, payload: null, createdAt: 1_000, refreshedAt: 1_000 }),
-    storedRow({ id: storedReasoningId('new'), itemType: 'reasoning', upstreamId: 'up_new', upstreamItemId: 'raw_new', encryptedContentHash: hash, payload: null, createdAt: 2_000, refreshedAt: 2_000 }),
-  ]);
-
-  const items = [{ type: 'reasoning', summary: [], encrypted_content: enc }] as unknown as ResponsesInputItem[];
-  const result = await classifyItems(items, [candidate('up_old'), candidate('up_new')]);
-
-  assertEquals(result.kind, 'success');
-  if (result.kind === 'success') assertEquals(result.candidates.map(c => c.provider.upstream), ['up_new', 'up_old']);
-});
-
-test('id-less compaction is matched by encrypted_content hash and forces its owning upstream', async () => {
-  const enc = 'enc-compaction-blob';
-  const hash = await hashResponsesItemEncryptedContent(enc);
-  await insertRows([
-    storedRow({ id: storedCompactionId('owned'), itemType: 'compaction', upstreamId: 'up_a', upstreamItemId: 'raw_cmp_a', encryptedContentHash: hash, payload: null }),
-  ]);
-
-  const items = [{ type: 'compaction', encrypted_content: enc }] as unknown as ResponsesInputItem[];
-
-  const resultWithOwner = await classifyItems(items, [candidate('up_b'), candidate('up_a')]);
-  assertEquals(resultWithOwner.kind, 'success');
-  if (resultWithOwner.kind === 'success') assertEquals(resultWithOwner.candidates.map(c => c.provider.upstream), ['up_a']);
-
-  const resultWithoutOwner = await classifyItems(items, [candidate('up_b')]);
-  assertEquals(resultWithoutOwner.kind, 'failure');
-  if (resultWithoutOwner.kind === 'failure') assertEquals(resultWithoutOwner.failure.kind, 'routing-unavailable');
-});
-
-test('id-less encrypted_content with no stored match is a benign passthrough with all candidates', async () => {
-  await insertRows([]);
-  const items = [{ type: 'reasoning', summary: [], encrypted_content: 'never-stored' }] as unknown as ResponsesInputItem[];
-
-  const result = await classifyItems(items, [candidate('up_a'), candidate('up_b')]);
-
-  assertEquals(result.kind, 'success');
-  if (result.kind === 'success') assertEquals(result.candidates.map(c => c.provider.upstream), ['up_a', 'up_b']);
-});
diff --git a/packages/gateway/src/data-plane/chat/responses/items/format.ts b/packages/gateway/src/data-plane/chat/responses/items/format.ts
index e24021b04..74d0e0673 100644
--- a/packages/gateway/src/data-plane/chat/responses/items/format.ts
+++ b/packages/gateway/src/data-plane/chat/responses/items/format.ts
@@ -46,7 +46,7 @@ const itemTypePrefixes = {
   // `compaction_summary` is the Codex-side wire alias for `compaction` (the
   // protocol declares them as one variant via `#[serde(alias = ...)]`); both
   // mint the same `cmp_` prefix so a row written under either spelling
-  // round-trips through `isStoredResponsesItemId`.
+  // round-trips through `isResponsesItemId`.
   compaction_summary: 'cmp',
   image_generation_call: 'ig',
   code_interpreter_call: 'ci',
@@ -63,42 +63,54 @@ const itemTypePrefixes = {
 } as const satisfies Record<StorableResponsesItemType, string>;
 
 const knownPrefixes = new Set<string>(Object.values(itemTypePrefixes));
-const storedIdPattern = /^(.+)_([A-Za-z0-9_-]{6})_([A-Za-z0-9_-]{22})$/;
+const responsesIdPattern = /^(.+)_([A-Za-z0-9_-]{6})_([A-Za-z0-9_-]{22})$/;
 
-// Stored ids are `<prefix>_<crc32(body)>_<body>` where `body` is 16 random
+// Client item ids are `<prefix>_<crc32(body)>_<body>` where `body` is 16 random
 // bytes encoded as base64url (22 chars). The body is content-free on purpose:
 // uniqueness comes from `crypto.getRandomValues`, and the crc32 prefix lets
-// `isStoredResponsesItemId` reject typos and accidental upstream collisions
+// `isResponsesItemId` reject typos and accidental upstream collisions
 // without re-hashing the original item.
-export const createStoredResponsesItemId = (itemType: string): string => {
+export const createResponsesItemId = (itemType: string): string => {
   const body = randomBody();
   return `${prefixForItemType(itemType)}_${crc32Checksum(body)}_${body}`;
 };
 
-export const isStoredResponsesItemId = (value: string): boolean =>
-  isValidStoredId(value, prefix => knownPrefixes.has(prefix));
+export const isResponsesItemId = (value: string): boolean =>
+  isValidResponsesId(value, prefix => knownPrefixes.has(prefix));
 
-// Codex and other stateless Responses clients echo reasoning and compaction
-// items back with their `encrypted_content` blob but no gateway id (the id is
-// stripped client-side). The blob is signed against the producing upstream
-// account, so we key such items by its hash to recover the owning upstream for
-// affinity routing.
 export const responsesItemId = (item: { id?: unknown }): string | null => {
   const id = item.id;
   return typeof id === 'string' && id.length > 0 ? id : null;
 };
 
-export const responsesItemEncryptedContent = (item: ResponsesInputItem): string | null => {
-  const value = (item as { encrypted_content?: unknown }).encrypted_content;
-  return typeof value === 'string' && value.length > 0 ? value : null;
-};
-
-export const hashResponsesItemEncryptedContent = async (encryptedContent: string): Promise<string> =>
-  await sha256Hex(encryptedContent);
+export const canonicalResponsesItemType = (itemType: string): string =>
+  itemType === 'compaction_summary' ? 'compaction' : itemType;
 
 export const hashResponsesItemContent = async (item: ResponsesInputItem): Promise<string> =>
   await sha256Hex(JSON.stringify(sortJson(item)));
 
+export const hashResponsesItemBinding = async (item: ResponsesInputItem | ResponsesOutputItem): Promise<string> => {
+  const content = { ...item } as Record<string, unknown>;
+  content.type = canonicalResponsesItemType(item.type);
+  delete content.id;
+  if (item.type === 'message' || item.type === 'function_call') delete content.status;
+  if (item.type === 'message' && Array.isArray(content.content)) {
+    content.content = content.content.map(block => {
+      if (
+        !block
+        || typeof block !== 'object'
+        || !['input_text', 'output_text'].includes(String((block as { type?: unknown }).type))
+      ) return block;
+      const normalized = { ...(block as Record<string, unknown>) };
+      if (normalized.type === 'input_text') normalized.type = 'output_text';
+      if (Array.isArray(normalized.annotations) && normalized.annotations.length === 0) delete normalized.annotations;
+      if (Array.isArray(normalized.logprobs) && normalized.logprobs.length === 0) delete normalized.logprobs;
+      return normalized;
+    });
+  }
+  return await sha256Hex(JSON.stringify(sortJson(content)));
+};
+
 export const createTemporaryResponsesItemId = (itemType: string): string => `${prefixForItemType(itemType)}_tmp_${randomBody()}`;
 
 // Gateway-owned response envelope id. A response from this gateway is not
@@ -109,19 +121,19 @@ export const createTemporaryResponsesItemId = (itemType: string): string => `${p
 // wrap (the snapshot store key, the SSE/WS frames the client sees) carries
 // this id.
 const responseEnvelopePrefix = 'resp';
-export const createStoredResponseId = (): string => {
+export const createResponsesResponseId = (): string => {
   const body = randomBody();
   return `${responseEnvelopePrefix}_${crc32Checksum(body)}_${body}`;
 };
 
-export const isStoredResponseId = (value: string): boolean =>
-  isValidStoredId(value, prefix => prefix === responseEnvelopePrefix);
+export const isResponsesResponseId = (value: string): boolean =>
+  isValidResponsesId(value, prefix => prefix === responseEnvelopePrefix);
 
 // Validates that `value` matches `<prefix>_<crc6>_<body22>`, the prefix
 // predicate accepts the prefix, and the crc32 of `body` matches the
 // checksum.
-const isValidStoredId = (value: string, isPrefixValid: (prefix: string) => boolean): boolean => {
-  const match = storedIdPattern.exec(value);
+const isValidResponsesId = (value: string, isPrefixValid: (prefix: string) => boolean): boolean => {
+  const match = responsesIdPattern.exec(value);
   if (match === null) return false;
   const [, prefix, checksum, body] = match;
   return isPrefixValid(prefix) && crc32Checksum(body) === checksum;
@@ -160,7 +172,7 @@ const sortJson = (value: unknown): unknown => {
   return Object.fromEntries(
     Object.entries(value as Record<string, unknown>)
       .filter(([, entry]) => entry !== undefined)
-      .toSorted(([a], [b]) => a.localeCompare(b))
+      .toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
       .map(([key, entry]) => [key, sortJson(entry)]),
   );
 };
diff --git a/packages/gateway/src/data-plane/chat/responses/items/format_test.ts b/packages/gateway/src/data-plane/chat/responses/items/format_test.ts
index 32757e1e9..a8fc5caf2 100644
--- a/packages/gateway/src/data-plane/chat/responses/items/format_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/items/format_test.ts
@@ -1,10 +1,11 @@
 import { test } from 'vitest';
 
 import {
-  createStoredResponsesItemId,
+  createResponsesItemId,
   createTemporaryResponsesItemId,
+  hashResponsesItemBinding,
   hashResponsesItemContent,
-  isStoredResponsesItemId,
+  isResponsesItemId,
 } from './format.ts';
 import { assert, assertFalse, assertThrows } from '@floway-dev/test-utils';
 
@@ -45,28 +46,28 @@ const explicitPrefixes = [
 ] as const;
 
 test('accepts the design-spec examples (CRC32 over only the body segment)', () => {
-  assert(isStoredResponsesItemId('msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA'));
-  assert(isStoredResponsesItemId('rs_mFBDiA_Lh1uXb7nD_bQb4I1CUYH2w'));
-  assert(isStoredResponsesItemId('ws_WGRXTA_sVlhxg6BAV0BUzj0KkWSqA'));
+  assert(isResponsesItemId('msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA'));
+  assert(isResponsesItemId('rs_mFBDiA_Lh1uXb7nD_bQb4I1CUYH2w'));
+  assert(isResponsesItemId('ws_WGRXTA_sVlhxg6BAV0BUzj0KkWSqA'));
 });
 
 test('rejects malformed public ids before SQL lookup', () => {
-  assertFalse(isStoredResponsesItemId('msg_AAAAAA_0xVvS8c_KjD1sBkZk5qbdA'));
-  assertFalse(isStoredResponsesItemId('itm_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA'));
-  assertFalse(isStoredResponsesItemId('msg_z1mVjw_short'));
-  assertFalse(isStoredResponsesItemId('msg_z1mVjw_0xVvS8c.KjD1sBkZk5qbdA'));
+  assertFalse(isResponsesItemId('msg_AAAAAA_0xVvS8c_KjD1sBkZk5qbdA'));
+  assertFalse(isResponsesItemId('itm_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA'));
+  assertFalse(isResponsesItemId('msg_z1mVjw_short'));
+  assertFalse(isResponsesItemId('msg_z1mVjw_0xVvS8c.KjD1sBkZk5qbdA'));
 });
 
-test('generates a valid stored id for every explicit supported item type', () => {
+test('generates a valid client id for every explicit supported item type', () => {
   for (const [itemType, prefix] of explicitPrefixes) {
-    const id = createStoredResponsesItemId(itemType);
-    assert(isStoredResponsesItemId(id), `expected ${id} to be a valid stored id`);
+    const id = createResponsesItemId(itemType);
+    assert(isResponsesItemId(id), `expected ${id} to be a valid Responses item id`);
     assert(id.startsWith(`${prefix}_`), `expected ${id} to use prefix ${prefix}`);
   }
 });
 
 test.each(['unknown_item', '__proto__', 'constructor', 'toString'])('throws for unknown item type %s instead of using a generic fallback prefix', itemType => {
-  assertThrows(() => createStoredResponsesItemId(itemType), TypeError, 'Unknown Responses item type');
+  assertThrows(() => createResponsesItemId(itemType), TypeError, 'Unknown Responses item type');
   assertThrows(() => createTemporaryResponsesItemId(itemType), TypeError, 'Unknown Responses item type');
 });
 
@@ -76,24 +77,24 @@ test.each(['unknown_item', '__proto__', 'constructor', 'toString'])('throws for
 // minted for it. The throw here is the regression test: it pins the invariant
 // that nobody adds a prefix back without also re-introducing a use case.
 test('rejects compaction_trigger — a control signal that should never be stored', () => {
-  assertThrows(() => createStoredResponsesItemId('compaction_trigger'), TypeError, 'Unknown Responses item type');
+  assertThrows(() => createResponsesItemId('compaction_trigger'), TypeError, 'Unknown Responses item type');
   assertThrows(() => createTemporaryResponsesItemId('compaction_trigger'), TypeError, 'Unknown Responses item type');
 });
 
-test('successive stored ids for the same item type collide-free under random body', () => {
+test('successive client ids for the same item type collide-free under random body', () => {
   const seen = new Set<string>();
   for (let i = 0; i < 1024; i += 1) {
-    const id = createStoredResponsesItemId('message');
+    const id = createResponsesItemId('message');
     assertFalse(seen.has(id), `random body collided after ${i} draws`);
     seen.add(id);
-    assert(isStoredResponsesItemId(id));
+    assert(isResponsesItemId(id));
   }
 });
 
-test('temporary ids use the item prefix without becoming stored ids', () => {
+test('temporary ids use the item prefix without becoming client ids', () => {
   const temporary = createTemporaryResponsesItemId('reasoning');
   assert(/^rs_tmp_[A-Za-z0-9_-]{22}$/.test(temporary), temporary);
-  assertFalse(isStoredResponsesItemId(temporary));
+  assertFalse(isResponsesItemId(temporary));
 });
 
 test('input content hashing includes the item id', async () => {
@@ -102,3 +103,30 @@ test('input content hashing includes the item id', async () => {
 
   assertFalse(first === second);
 });
+
+test('affinity item binding ignores only the replaceable item id', async () => {
+  const first = await hashResponsesItemBinding({ type: 'program_output', id: 'first', call_id: 'call', result: 'same', status: 'completed' });
+  const same = await hashResponsesItemBinding({ status: 'completed', result: 'same', call_id: 'call', id: 'second', type: 'program_output' });
+  const different = await hashResponsesItemBinding({ type: 'program_output', id: 'first', call_id: 'other', result: 'same', status: 'completed' });
+
+  assert(first === same);
+  assertFalse(first === different);
+});
+
+test('affinity item binding normalizes Codex output-only message defaults', async () => {
+  const output = {
+    type: 'message' as const,
+    id: 'msg_upstream',
+    role: 'assistant' as const,
+    status: 'completed' as const,
+    content: [{ type: 'output_text' as const, text: 'answer', annotations: [], logprobs: [] }],
+  };
+  const history = {
+    type: 'message' as const,
+    id: 'msg_public',
+    role: 'assistant' as const,
+    content: [{ type: 'input_text' as const, text: 'answer' }],
+  };
+
+  assert(await hashResponsesItemBinding(output) === await hashResponsesItemBinding(history));
+});
diff --git a/packages/gateway/src/data-plane/chat/responses/items/hash-cache.ts b/packages/gateway/src/data-plane/chat/responses/items/hash-cache.ts
deleted file mode 100644
index 62727de72..000000000
--- a/packages/gateway/src/data-plane/chat/responses/items/hash-cache.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { hashResponsesItemContent, hashResponsesItemEncryptedContent } from './format.ts';
-import type { ResponsesInputItem } from '@floway-dev/protocols/responses';
-
-export interface ResponsesItemHashFunctions {
-  readonly content: (item: ResponsesInputItem) => Promise<string>;
-  readonly encryptedContent: (encryptedContent: string) => Promise<string>;
-}
-
-const defaultHashFunctions: ResponsesItemHashFunctions = {
-  content: hashResponsesItemContent,
-  encryptedContent: hashResponsesItemEncryptedContent,
-};
-
-export class ResponsesItemHashCache {
-  // Serve prep hashes and stages the same source-item objects before attempts
-  // can clone or mutate them. Keep identity caching on that turn-local store
-  // boundary; values created inside an attempt intentionally miss this cache.
-  private contentByItem = new WeakMap<ResponsesInputItem, Promise<string>>();
-  private readonly encryptedByValue = new Map<string, Promise<string>>();
-
-  constructor(private readonly functions: ResponsesItemHashFunctions = defaultHashFunctions) {}
-
-  content(item: ResponsesInputItem): Promise<string> {
-    const cached = this.contentByItem.get(item);
-    if (cached !== undefined) return cached;
-    const hash = this.functions.content(item);
-    this.contentByItem.set(item, hash);
-    return hash;
-  }
-
-  encryptedContent(value: string): Promise<string> {
-    const cached = this.encryptedByValue.get(value);
-    if (cached !== undefined) return cached;
-    const hash = this.functions.encryptedContent(value);
-    this.encryptedByValue.set(value, hash);
-    return hash;
-  }
-
-  clear(): void {
-    this.contentByItem = new WeakMap();
-    this.encryptedByValue.clear();
-  }
-}
diff --git a/packages/gateway/src/data-plane/chat/responses/items/hash-cache_test.ts b/packages/gateway/src/data-plane/chat/responses/items/hash-cache_test.ts
deleted file mode 100644
index 85da6a0f3..000000000
--- a/packages/gateway/src/data-plane/chat/responses/items/hash-cache_test.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { test } from 'vitest';
-
-import { ResponsesItemHashCache } from './hash-cache.ts';
-import type { ResponsesInputItem } from '@floway-dev/protocols/responses';
-import { assert, assertEquals } from '@floway-dev/test-utils';
-
-test('content hashes are cached by item identity', async () => {
-  let calls = 0;
-  const cache = new ResponsesItemHashCache({
-    content: async () => `content-${++calls}`,
-    encryptedContent: async () => 'unused',
-  });
-  const item: ResponsesInputItem = { type: 'message', role: 'user', content: 'hello' };
-
-  const first = cache.content(item);
-  const second = cache.content(item);
-  assert(first === second);
-  assertEquals(await first, 'content-1');
-  assertEquals(await cache.content(structuredClone(item)), 'content-2');
-  assertEquals(calls, 2);
-});
-
-test('encrypted content hashes are cached by string value', async () => {
-  let calls = 0;
-  const cache = new ResponsesItemHashCache({
-    content: async () => 'unused',
-    encryptedContent: async () => `encrypted-${++calls}`,
-  });
-
-  const first = cache.encryptedContent('opaque-content');
-  const second = cache.encryptedContent(`opaque-${'content'}`);
-  assert(first === second);
-  assertEquals(await first, 'encrypted-1');
-  assertEquals(calls, 1);
-});
-
-test('clear starts a new hash lifetime', async () => {
-  let contentCalls = 0;
-  let encryptedCalls = 0;
-  const cache = new ResponsesItemHashCache({
-    content: async () => `content-${++contentCalls}`,
-    encryptedContent: async () => `encrypted-${++encryptedCalls}`,
-  });
-  const item: ResponsesInputItem = { type: 'message', role: 'user', content: 'hello' };
-
-  assertEquals(await cache.content(item), 'content-1');
-  assertEquals(await cache.encryptedContent('opaque'), 'encrypted-1');
-  cache.clear();
-  assertEquals(await cache.content(item), 'content-2');
-  assertEquals(await cache.encryptedContent('opaque'), 'encrypted-2');
-});
diff --git a/packages/gateway/src/data-plane/chat/responses/items/output.ts b/packages/gateway/src/data-plane/chat/responses/items/output.ts
index cbc06b7a1..a4723774e 100644
--- a/packages/gateway/src/data-plane/chat/responses/items/output.ts
+++ b/packages/gateway/src/data-plane/chat/responses/items/output.ts
@@ -1,22 +1,19 @@
-import { createStoredResponsesItemId, responsesItemEncryptedContent, responsesItemId } from './format.ts';
+import { canonicalResponsesItemType, createResponsesItemId, hashResponsesItemBinding, responsesItemId } from './format.ts';
 import type { StatefulResponsesStore } from './store.ts';
 import type { StoredResponsesItem } from '../../../../repo/types.ts';
+import type { ResponsesAttemptState } from '../attempt-state.ts';
 import { doneFrame, eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
 import { responsesResultToEvents, type ResponsesInputItem, type ResponsesResult, type ResponsesStreamEvent } from '@floway-dev/protocols/responses';
-import type { ChatTargetApi } from '@floway-dev/provider';
 
-// Wraps a Responses event stream to mint gateway-owned stored ids for every
-// output item and persist the matching rows. Runs inside `responsesAttempt`
-// after any cross-protocol translation, so the stream is always
-// Responses-shaped by the time it arrives here.
+// Mints gateway-owned ids and presents finalized client items to the configured
+// state store when it has a write target. Translated inner Responses attempts
+// never enter this membrane.
 //
-// Items are committed at their `done` frame and the snapshot is committed
-// at the terminal `response.completed` / `response.incomplete` frame.
-// Both writes are protocol state, not best-effort telemetry: their failures
-// propagate so the client never receives `done` / a successful terminal frame
-// for ids that cannot be referenced on its next turn. Streaming clients may
-// already have seen the item's `added` frame and deltas, but without `done`
-// they must treat that partial item as failed.
+// Complete items are staged at their `done` frame. The whole output batch and
+// its snapshot commit together before the terminal `response.completed` /
+// `response.incomplete` frame is yielded. These writes are protocol state, not
+// best-effort telemetry: a failure propagates before the client sees a
+// successful terminal response whose ids could not be referenced next turn.
 //
 // Wrap is also the single source of truth for the response envelope id the
 // client sees. The caller mints a `resp_<crc>_<body>` once and passes it
@@ -38,68 +35,85 @@ import type { ChatTargetApi } from '@floway-dev/provider';
 // a `compaction_trigger` input on `/v1/responses` (Codex's RemoteCompactionV2),
 // and the server-side `context_management` `compact_threshold` mode — without
 // each path needing its own gateway-side detector.
-export const wrapResponsesOutputForStorage = async function* (
+export const wrapResponsesClientOutput = async function* (
   frames: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>,
   args: {
     readonly store: StatefulResponsesStore;
-    readonly upstream: string;
-    readonly targetApi: ChatTargetApi;
+    readonly attemptState: ResponsesAttemptState;
     readonly responseId: string;
   },
 ): AsyncGenerator<ProtocolFrame<ResponsesStreamEvent>> {
-  const { store, upstream, targetApi, responseId } = args;
-  const upstreamToStored = new Map<string, string>();
-
-  const idMapper = (upstreamId: string, itemType: string): string => {
-    let storedId = upstreamToStored.get(upstreamId);
-    if (storedId === undefined) {
-      storedId = createStoredResponsesItemId(itemType);
-      upstreamToStored.set(upstreamId, storedId);
+  const { store, attemptState, responseId } = args;
+  const upstreamToClient = new Map<string, string>();
+  const outputIndexToClient = new Map<number, string>();
+  const finalizedItems = new Map<number, { readonly itemType: string; readonly contentHash: string }>();
+
+  const clientIdForUpstreamId = (upstreamId: string, itemType: string): string => {
+    let clientId = upstreamToClient.get(upstreamId);
+    if (clientId === undefined) {
+      clientId = createResponsesItemId(itemType);
+      upstreamToClient.set(upstreamId, clientId);
     }
-    return storedId;
+    return clientId;
   };
 
-  const onItemFinalized = async (originalItem: ResponsesInputItem, newId: string): Promise<void> => {
-    const upstreamId = responsesItemId(originalItem);
-    if (upstreamId === null) {
-      throw new Error(`Cannot persist Responses item without an upstream id (newId=${newId}, type=${originalItem.type})`);
+  const clientIdForOutput = (upstreamId: string | null, itemType: string, outputIndex: number): string => {
+    let clientId = outputIndexToClient.get(outputIndex);
+    if (clientId === undefined) {
+      clientId = upstreamId === null ? createResponsesItemId(itemType) : clientIdForUpstreamId(upstreamId, itemType);
+      outputIndexToClient.set(outputIndex, clientId);
+    } else if (upstreamId !== null) {
+      upstreamToClient.set(upstreamId, clientId);
+    }
+    return clientId;
+  };
+
+  const matchesFinalizedItem = async (outputIndex: number, item: ResponsesInputItem): Promise<boolean> => {
+    const finalized = finalizedItems.get(outputIndex);
+    if (finalized === undefined) return false;
+    const contentHash = await hashResponsesItemBinding(item);
+    if (finalized.itemType !== canonicalResponsesItemType(item.type) || finalized.contentHash !== contentHash) {
+      throw new Error(`Responses output item ${outputIndex} changed after output_item.done`);
     }
-    // A native Responses upstream owns its items — except those a source
-    // interceptor synthesized this request, whose gateway-minted ids the
-    // upstream never issued. Those persist with no upstream identity so they
-    // stay non_affinity.
-    const upstreamOwned = targetApi === 'responses' && !store.isSyntheticItem(upstreamId);
-    const encryptedContent = responsesItemEncryptedContent(originalItem);
+    return true;
+  };
+
+  const stageFinalizedItem = async (originalItem: ResponsesInputItem, newId: string, outputIndex: number): Promise<void> => {
+    if (!store.writesState) return;
+    const upstreamId = responsesItemId(originalItem);
     // Interceptors register per-item server-only payloads under the wire id.
     // Attaching it lets a later turn restore the real success/failure state
     // even when the client stripped fields from the echoed wire item.
-    const privatePayload = store.getPrivatePayload(upstreamId);
-    const persistedPayload = privatePayload !== undefined ? { item: originalItem, private: privatePayload } : { item: originalItem };
+    const privatePayload = upstreamId === null ? undefined : attemptState.getPrivatePayload(upstreamId);
+    const clientItem = { ...originalItem, id: newId } as ResponsesInputItem;
+    const persistedPayload = privatePayload !== undefined ? { item: clientItem, private: privatePayload } : { item: clientItem };
     const now = Date.now();
     const row: StoredResponsesItem = {
       id: newId,
       apiKeyId: store.apiKeyId,
-      upstreamId: upstreamOwned ? upstream : null,
-      upstreamItemId: upstreamOwned ? upstreamId : null,
-      itemType: originalItem.type,
-      origin: upstreamOwned ? 'upstream' : 'synthetic',
-      payload: store.shouldStorePayload ? persistedPayload : null,
-      contentHash: await store.hashItemContent(originalItem),
-      encryptedContentHash: encryptedContent === null ? null : await store.hashEncryptedContent(encryptedContent),
+      itemType: canonicalResponsesItemType(originalItem.type),
+      payload: persistedPayload,
+      contentHash: await store.hashItemContent(clientItem),
       createdAt: now,
-      refreshedAt: now,
     };
-    store.stageOutputItem(row);
-    await store.commitOutputItems();
+    store.stageOutputItem(row, outputIndex);
   };
 
-  // `seenItemTypes` records item type for every upstream id we have mapped
-  // via an item-bearing frame. Delta events carry only `item_id` with no
-  // type, so we look the type up before re-invoking idMapper.
+  // Fallback for an out-of-order delta that references an upstream id before
+  // its output-index lifecycle is available.
   const seenItemTypes = new Map<string, string>();
-  const finalized = new Set<string>();
   let sawCompactionItem = false;
 
+  const rewriteEnvelopeIds = (response: ResponsesResult): ResponsesResult => ({
+    ...response,
+    id: responseId,
+    output: response.output.map((item, outputIndex) => {
+      const upstreamId = responsesItemId(item);
+      if (upstreamId !== null) seenItemTypes.set(upstreamId, item.type);
+      return { ...item, id: clientIdForOutput(upstreamId, item.type, outputIndex) };
+    }),
+  });
+
   for await (const frame of frames) {
     if (frame.type !== 'event') {
       yield frame;
@@ -113,28 +127,29 @@ export const wrapResponsesOutputForStorage = async function* (
     // (`response.output_item.*`, delta events) do not carry `response.id`
     // and are handled below.
     if (event.type === 'response.created' || event.type === 'response.in_progress') {
-      yield eventFrame({ ...event, response: { ...event.response, id: responseId } });
+      yield eventFrame({ ...event, response: rewriteEnvelopeIds(event.response) });
       continue;
     }
 
     if (event.type === 'response.output_item.added') {
       const upstreamId = responsesItemId(event.item);
-      if (upstreamId === null) { yield frame; continue; }
-      seenItemTypes.set(upstreamId, event.item.type);
-      const newId = idMapper(upstreamId, event.item.type);
+      if (upstreamId !== null) seenItemTypes.set(upstreamId, event.item.type);
+      const newId = clientIdForOutput(upstreamId, event.item.type, event.output_index);
       yield eventFrame({ ...event, item: { ...event.item, id: newId } });
       continue;
     }
 
     if (event.type === 'response.output_item.done') {
       const upstreamId = responsesItemId(event.item);
-      if (upstreamId === null) { yield frame; continue; }
-      seenItemTypes.set(upstreamId, event.item.type);
-      const newId = idMapper(upstreamId, event.item.type);
+      if (upstreamId !== null) seenItemTypes.set(upstreamId, event.item.type);
+      const newId = clientIdForOutput(upstreamId, event.item.type, event.output_index);
       if (isCompactionItemType(event.item.type)) sawCompactionItem = true;
-      if (!finalized.has(upstreamId)) {
-        finalized.add(upstreamId);
-        await onItemFinalized(event.item as unknown as ResponsesInputItem, newId);
+      if (!await matchesFinalizedItem(event.output_index, event.item as unknown as ResponsesInputItem)) {
+        finalizedItems.set(event.output_index, {
+          itemType: canonicalResponsesItemType(event.item.type),
+          contentHash: await hashResponsesItemBinding(event.item),
+        });
+        await stageFinalizedItem(event.item as unknown as ResponsesInputItem, newId, event.output_index);
       }
       yield eventFrame({ ...event, item: { ...event.item, id: newId } });
       continue;
@@ -142,15 +157,13 @@ export const wrapResponsesOutputForStorage = async function* (
 
     if (event.type === 'response.completed' || event.type === 'response.incomplete') {
       const output: ResponsesInputItem[] = [];
-      for (const item of event.response.output) {
+      for (const [outputIndex, item] of event.response.output.entries()) {
         if (isCompactionItemType(item.type)) sawCompactionItem = true;
         const upstreamId = responsesItemId(item);
-        if (upstreamId === null) { output.push(item as unknown as ResponsesInputItem); continue; }
-        seenItemTypes.set(upstreamId, item.type);
-        const newId = idMapper(upstreamId, item.type);
-        if (!finalized.has(upstreamId)) {
-          finalized.add(upstreamId);
-          await onItemFinalized(item as unknown as ResponsesInputItem, newId);
+        if (upstreamId !== null) seenItemTypes.set(upstreamId, item.type);
+        const newId = clientIdForOutput(upstreamId, item.type, outputIndex);
+        if (!await matchesFinalizedItem(outputIndex, item as unknown as ResponsesInputItem)) {
+          await stageFinalizedItem(item as unknown as ResponsesInputItem, newId, outputIndex);
         }
         output.push({ ...(item as unknown as ResponsesInputItem), id: newId });
       }
@@ -163,13 +176,13 @@ export const wrapResponsesOutputForStorage = async function* (
       // generator another tick, so any post-yield work would be lost.
       // The downstream HTTP entry has nothing to observe pre-snapshot —
       // ordering matches a synchronous emit.
-      await store.commitSnapshot(responseId, sawCompactionItem ? 'replace' : 'append');
+      if (store.writesState) await store.commitSnapshot(responseId, sawCompactionItem ? 'replace' : 'append');
       yield rewritten;
       return;
     }
 
     if (event.type === 'response.failed') {
-      yield eventFrame({ ...event, response: { ...event.response, id: responseId } });
+      yield eventFrame({ ...event, response: rewriteEnvelopeIds(event.response) });
       return;
     }
     if (event.type === 'error') {
@@ -177,11 +190,17 @@ export const wrapResponsesOutputForStorage = async function* (
       return;
     }
 
-    const refId = (event as { item_id?: unknown }).item_id;
-    if (typeof refId === 'string') {
+    if ('item_id' in event) {
+      const refId = event.item_id;
+      const lifecycleItemId = outputIndexToClient.get(event.output_index);
+      if (lifecycleItemId !== undefined) {
+        upstreamToClient.set(refId, lifecycleItemId);
+        yield eventFrame({ ...event, item_id: lifecycleItemId } as ResponsesStreamEvent);
+        continue;
+      }
       const knownType = seenItemTypes.get(refId);
       if (knownType === undefined) { yield frame; continue; }
-      const newId = idMapper(refId, knownType);
+      const newId = clientIdForUpstreamId(refId, knownType);
       yield eventFrame({ ...event, item_id: newId } as ResponsesStreamEvent);
       continue;
     }
@@ -191,7 +210,7 @@ export const wrapResponsesOutputForStorage = async function* (
 
 // `compaction` and `compaction_summary` are the same wire variant — Codex's
 // protocol declares the latter as a serde alias for the former (see
-// https://github.com/openai/codex/blob/main/codex-rs/protocol/src/models.rs).
+// https://github.com/openai/codex/blob/9e552e9d15ba52bed7077d5357f3e18e330f8f38/codex-rs/protocol/src/models.rs#L1135-L1148).
 // An output stream carrying either is a self-contained compaction envelope
 // and replaces the conversation history.
 const isCompactionItemType = (type: string): boolean =>
@@ -200,13 +219,9 @@ const isCompactionItemType = (type: string): boolean =>
 // Expands a non-streaming compact result into the same frame sequence a live
 // upstream would emit: every output item as bare added/done pairs (no inner
 // content delta events) via `responsesResultToEvents` with genericOutputItems,
-// terminated by a done sentinel frame. Lets `wrapResponsesOutputForStorage`
+// terminated by a done sentinel frame. Lets `wrapResponsesClientOutput`
 // consume the result without a real provider call.
 export const syntheticEventsFromResult = async function* (result: ResponsesResult): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
   yield* responsesResultToEvents(result, { genericOutputItems: true });
   yield doneFrame();
 };
-
-export const drainAsync = async (events: AsyncIterable<unknown>): Promise<void> => {
-  for await (const _ of events);
-};
diff --git a/packages/gateway/src/data-plane/chat/responses/items/output_test.ts b/packages/gateway/src/data-plane/chat/responses/items/output_test.ts
index d7d14df8b..34123309e 100644
--- a/packages/gateway/src/data-plane/chat/responses/items/output_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/items/output_test.ts
@@ -1,664 +1,339 @@
-import { test, vi } from 'vitest';
+import { expect, test, vi } from 'vitest';
 
-import { isStoredResponsesItemId } from './format.ts';
-import { drainAsync, syntheticEventsFromResult, wrapResponsesOutputForStorage } from './output.ts';
-import { createResponsesHttpStore, LayeredStatefulResponsesStore, RepoStatefulResponsesBacking, type StatefulResponsesBacking, type StatefulResponsesStore } from './store.ts';
+import { isResponsesItemId } from './format.ts';
+import { wrapResponsesClientOutput } from './output.ts';
+import { createResponsesHttpStore } from './store.ts';
 import { initRepo } from '../../../../repo/index.ts';
 import { InMemoryRepo } from '../../../../repo/memory.ts';
-import type { ResponsesItemsRepo, StoredResponsesItem, StoredResponsesItemMetadata, StoredResponsesItemPayloadRecord } from '../../../../repo/types.ts';
-import { eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
-import type { ResponsesOutputItem, ResponsesResult, ResponsesStreamEvent } from '@floway-dev/protocols/responses';
-import { assert, assertEquals, assertRejects } from '@floway-dev/test-utils';
-
-const apiKeyId = 'key_output_new';
-
-const makeStore = (overrides: { store?: boolean; syntheticItemIds?: Iterable<string>; privatePayloads?: Iterable<readonly [string, unknown]> } = {}) => {
-  const store = createResponsesHttpStore(apiKeyId, overrides.store);
-  if (overrides.syntheticItemIds) {
-    for (const id of overrides.syntheticItemIds) {
-      const privatePayload = overrides.privatePayloads
-        ? [...overrides.privatePayloads].find(([k]) => k === id)?.[1]
-        : undefined;
-      store.addSyntheticItem(id, privatePayload);
-    }
-  }
-  return store;
-};
-
-const messageItem = (id: string, text: string): Extract<ResponsesOutputItem, { type: 'message' }> => ({
-  type: 'message',
-  id,
-  role: 'assistant',
-  status: 'completed',
-  content: [{ type: 'output_text', text }],
-});
-
-const response = (output: ResponsesOutputItem[], status: ResponsesResult['status'] = 'completed'): ResponsesResult => ({
-  id: 'resp_test',
-  object: 'response',
-  model: 'gpt-test',
-  status,
-  output,
-  output_text: '',
-  error: status === 'failed' ? { message: 'failed', code: 'server_error' } : null,
-  incomplete_details: null,
-});
-
-const framesFrom = async function* (events: readonly ResponsesStreamEvent[]) {
-  for (const event of events) yield eventFrame(event);
-};
-
-const TEST_RESPONSE_ID = 'resp_test123';
-
-const wrap = (
-  frames: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>,
-  overrides: Parameters<typeof makeStore>[0] = {},
-  extra: { targetApi?: 'responses' | 'messages' | 'chat-completions'; responseId?: string } = {},
-) => {
-  const store = makeStore(overrides);
-  return {
-    events: wrapResponsesOutputForStorage(frames, {
-      store,
-      upstream: 'up_native',
-      targetApi: extra.targetApi ?? 'responses',
-      responseId: extra.responseId ?? TEST_RESPONSE_ID,
-    }),
-    store,
-  };
-};
-
-const wrapWithStore = (
-  frames: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>,
-  store: StatefulResponsesStore,
-  extra: { targetApi?: 'responses' | 'messages' | 'chat-completions'; upstream?: string; responseId?: string } = {},
-) => wrapResponsesOutputForStorage(frames, {
-  store,
-  upstream: extra.upstream ?? 'up_native',
-  targetApi: extra.targetApi ?? 'responses',
-  responseId: extra.responseId ?? TEST_RESPONSE_ID,
-});
-
-const collectEvents = async (events: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>): Promise<ResponsesStreamEvent[]> => {
-  const collected: ResponsesStreamEvent[] = [];
-  for await (const item of events) {
-    if (item.type === 'event') collected.push(item.event);
-  }
-  return collected;
-};
-
-const eventAt = <TType extends ResponsesStreamEvent['type']>(
-  events: readonly ResponsesStreamEvent[],
-  type: TType,
-): Extract<ResponsesStreamEvent, { type: TType }> => {
-  const event = events.find((candidate): candidate is Extract<ResponsesStreamEvent, { type: TType }> => candidate.type === type);
-  assert(event, `expected ${type}`);
-  return event;
-};
-
-type IteratorResultPromise = Promise<IteratorResult<ProtocolFrame<ResponsesStreamEvent>>>;
-
-const promiseStateAfterMicrotasks = async (promise: IteratorResultPromise): Promise<'pending' | 'fulfilled' | 'rejected'> => {
-  let state: 'pending' | 'fulfilled' | 'rejected' = 'pending';
-  promise.then(
-    () => { state = 'fulfilled'; },
-    () => { state = 'rejected'; },
-  );
-  for (let i = 0; i < 10; i += 1) {
-    await Promise.resolve();
-    if (state !== 'pending') return state;
-  }
-  return state;
-};
-
-const waitForInsertCall = async (repo: ControlledResponsesItemsRepo): Promise<void> => {
-  for (let i = 0; i < 50; i += 1) {
-    if (repo.calls.length > 0) return;
-    await new Promise(resolve => setTimeout(resolve, 0));
-  }
-  throw new Error('timed out waiting for insertMany');
+import { ResponsesAttemptState } from '../attempt-state.ts';
+import { doneFrame, eventFrame, type ProtocolFrame } from '@floway-dev/protocols/common';
+import type { ResponsesResult, ResponsesStreamEvent } from '@floway-dev/protocols/responses';
+
+const frames = async function* (response: ResponsesResult): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+  const item = response.output[0];
+  yield eventFrame({ type: 'response.output_item.added', output_index: 0, item });
+  yield eventFrame({ type: 'response.output_item.done', output_index: 0, item });
+  yield eventFrame({ type: 'response.completed', response });
+  yield doneFrame();
 };
 
-class ControlledResponsesItemsRepo implements ResponsesItemsRepo {
-  calls: StoredResponsesItem[][] = [];
-  resolveInsert: (() => void) | undefined;
-  rejectInsert: ((error: unknown) => void) | undefined;
-
-  lookupMany(): Promise<StoredResponsesItemMetadata[]> { return Promise.resolve([]); }
-  lookupManyByEncryptedContentHash(): Promise<StoredResponsesItemMetadata[]> { return Promise.resolve([]); }
-  lookupManyByContentHash(): Promise<StoredResponsesItemMetadata[]> { return Promise.resolve([]); }
-  lookupPayloads(): Promise<StoredResponsesItemPayloadRecord[]> { return Promise.resolve([]); }
-
-  insertMany(items: readonly StoredResponsesItem[]): Promise<void> {
-    this.calls.push(items.map(item => structuredClone(item)));
-    return new Promise((resolve, reject) => {
-      this.resolveInsert = resolve;
-      this.rejectInsert = reject;
-    });
-  }
-
-  fillPayloads(): Promise<number> { return Promise.resolve(0); }
-  refreshMany(): Promise<number> { return Promise.resolve(0); }
-  clearPayloadOlderThan(): Promise<number> { return Promise.resolve(0); }
-  deleteOlderThan(): Promise<number> { return Promise.resolve(0); }
-  deleteAll(): Promise<void> { return Promise.resolve(); }
-}
-
-test('rewrites output item ids consistently across added, child, done, and terminal', async () => {
+test('client output rewrites ids and persists the exact complete item before terminal', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const original = messageItem('raw_msg_native', 'hello');
-
-  const { events } = wrap(framesFrom([
-    { type: 'response.output_item.added', output_index: 0, item: { ...original, content: [] } },
-    { type: 'response.output_text.delta', output_index: 0, content_index: 0, item_id: original.id!, delta: 'hello' },
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: response([original]) },
-  ]));
-
-  const collected = await collectEvents(events);
-  const storedId = eventAt(collected, 'response.output_item.done').item.id!;
-  assert(isStoredResponsesItemId(storedId));
-  assert(storedId.startsWith('msg_'));
-  assertEquals(eventAt(collected, 'response.output_item.added').item.id, storedId);
-  assertEquals(eventAt(collected, 'response.output_text.delta').item_id, storedId);
-  assertEquals(eventAt(collected, 'response.completed').response.output[0].id, storedId);
-
-  const [row] = await repo.responsesItems.lookupMany(apiKeyId, [storedId]);
-  const [payload] = await repo.responsesItems.lookupPayloads(apiKeyId, [storedId]);
-  assertEquals(row.upstreamId, 'up_native');
-  assertEquals(row.upstreamItemId, original.id);
-  assertEquals(payload.payload, { item: original });
-});
-
-test('rewrites and persists programmatic tool output items without changing their payload', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const program: Extract<ResponsesOutputItem, { type: 'program' }> = {
-    type: 'program',
-    id: 'program_native_1',
-    call_id: 'program_call_1',
-    code: 'await exec("hello")',
-    fingerprint: 'opaque-fingerprint',
-  };
-  const programOutput: Extract<ResponsesOutputItem, { type: 'program_output' }> = {
-    type: 'program_output',
-    id: 'program_output_native_1',
-    call_id: 'program_call_1',
-    result: 'hello',
+  const store = createResponsesHttpStore('key-a', true);
+  const result: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model',
     status: 'completed',
+    output: [{ type: 'reasoning', id: 'rs_upstream', summary: [], encrypted_content: 'wrapped-affinity' }],
+    error: null,
+    incomplete_details: null,
   };
-  const additionalTools: Extract<ResponsesOutputItem, { type: 'additional_tools' }> = {
-    type: 'additional_tools',
-    id: 'additional_tools_native_1',
-    role: 'developer',
-    tools: [{ type: 'custom', name: 'exec', format: { type: 'text' } }],
-  };
-
-  const { events } = wrap(framesFrom([
-    { type: 'response.completed', response: response([additionalTools, program, programOutput]) },
-  ]));
-
-  const completed = eventAt(await collectEvents(events), 'response.completed');
-  const [storedAdditionalTools, storedProgram, storedProgramOutput] = completed.response.output;
-  assert(storedAdditionalTools.id?.startsWith('at_'));
-  assert(storedProgram.id?.startsWith('prog_'));
-  assert(storedProgramOutput.id?.startsWith('prog_out_'));
-  assertEquals(storedAdditionalTools, { ...additionalTools, id: storedAdditionalTools.id });
-  assertEquals(storedProgram, { ...program, id: storedProgram.id });
-  assertEquals(storedProgramOutput, { ...programOutput, id: storedProgramOutput.id });
-
-  const payloads = await repo.responsesItems.lookupPayloads(apiKeyId, completed.response.output.map(item => item.id!));
-  assertEquals(payloads.map(record => record.payload.item), [additionalTools, program, programOutput]);
-});
-
-test('persists each row before yielding the item-done frame', async () => {
-  const repo = new InMemoryRepo();
-  const controlled = new ControlledResponsesItemsRepo();
-  repo.responsesItems = controlled;
-  initRepo(repo);
-  const original = messageItem('raw_msg_native', 'hello');
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-  const iterator = wrapWithStore(framesFrom([
-    { type: 'response.output_item.added', output_index: 0, item: { ...original, content: [] } },
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: response([original]) },
-  ]), store)[Symbol.asyncIterator]();
-
-  const addedFrame = await iterator.next();
-  assertEquals((addedFrame.value as ProtocolFrame<ResponsesStreamEvent>).type, 'event');
-  assertEquals(controlled.calls.length, 0);
-
-  // done is held until the row insert resolves; the client that has seen
-  // `done` finds the row on its next turn.
-  const doneFrame = iterator.next();
-  assertEquals(await promiseStateAfterMicrotasks(doneFrame), 'pending');
-  await waitForInsertCall(controlled);
-  assertEquals(controlled.calls.length, 1);
-  controlled.resolveInsert?.();
-  assertEquals(((await doneFrame).value as ProtocolFrame<ResponsesStreamEvent>).type, 'event');
-});
-
-test('insert failure rejects before yielding the item-done frame', async () => {
-  const repo = new InMemoryRepo();
-  const controlled = new ControlledResponsesItemsRepo();
-  repo.responsesItems = controlled;
-  initRepo(repo);
-  const original = messageItem('raw_msg_native', 'hello');
-  const iterator = wrapWithStore(framesFrom([
-    { type: 'response.output_item.added', output_index: 0, item: { ...original, content: [] } },
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: response([original]) },
-  ]), createResponsesHttpStore(apiKeyId, undefined))[Symbol.asyncIterator]();
-
-  assertEquals(((await iterator.next()).value as ProtocolFrame<ResponsesStreamEvent>).type, 'event');
-
-  const doneFrame = iterator.next();
-  assertEquals(await promiseStateAfterMicrotasks(doneFrame), 'pending');
-  await waitForInsertCall(controlled);
-  controlled.rejectInsert?.(new Error('insert failed'));
-  await assertRejects(() => doneFrame, Error, 'insert failed');
-});
-
-test('does not insert rows for failed streams without observed items', async () => {
-  const repo = new InMemoryRepo();
-  const controlled = new ControlledResponsesItemsRepo();
-  repo.responsesItems = controlled;
-  initRepo(repo);
-
-  const { events } = wrap(framesFrom([
-    { type: 'response.failed', response: response([], 'failed') },
-  ]));
 
-  const collected = await collectEvents(events);
-  assertEquals(collected.at(-1)?.type, 'response.failed');
-  assertEquals(controlled.calls.length, 0);
-});
-
-test('store false creates metadata rows with null payload', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const original = messageItem('raw_msg_native', 'hello');
-
-  const { events } = wrap(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: response([original]) },
-  ]), { store: false });
-
-  const collected = await collectEvents(events);
-  const storedId = eventAt(collected, 'response.output_item.done').item.id!;
-  const [row] = await repo.responsesItems.lookupMany(apiKeyId, [storedId]);
-  assertEquals(row.hasPayload, false);
-  assertEquals(row.upstreamItemId, original.id);
-});
-
-test('terminal output items missing done frames are stored and rewritten', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const original = messageItem('raw_terminal_only', 'late');
-
-  const { events } = wrap(framesFrom([
-    { type: 'response.completed', response: response([original]) },
-  ]));
-
-  const collected = await collectEvents(events);
-  const storedId = eventAt(collected, 'response.completed').response.output[0].id!;
-  assert(isStoredResponsesItemId(storedId));
-  const [payload] = await repo.responsesItems.lookupPayloads(apiKeyId, [storedId]);
-  assertEquals(payload.payload, { item: original });
-});
-
-test('two distinct upstream items receive distinct stored ids', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const first = messageItem('raw_msg_1', 'first');
-  const second = messageItem('raw_msg_2', 'second');
-
-  const { events } = wrap(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: first },
-    { type: 'response.output_item.done', output_index: 1, item: second },
-    { type: 'response.completed', response: response([first, second]) },
-  ]));
+  const events: ResponsesStreamEvent[] = [];
+  for await (const frame of wrapResponsesClientOutput(frames(result), {
+    store,
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  })) {
+    if (frame.type === 'event') events.push(frame.event);
+  }
 
-  const collected = await collectEvents(events);
-  const done = collected.filter((event): event is Extract<ResponsesStreamEvent, { type: 'response.output_item.done' }> => event.type === 'response.output_item.done');
-  assert(done[0].item.id !== done[1].item.id);
-  assert(isStoredResponsesItemId(done[0].item.id!));
-  assert(isStoredResponsesItemId(done[1].item.id!));
-  const rows = await repo.responsesItems.lookupMany(apiKeyId, [done[0].item.id!, done[1].item.id!]);
-  assertEquals(rows.length, 2);
-  assertEquals(rows[0].upstreamItemId, 'raw_msg_1');
-  assertEquals(rows[1].upstreamItemId, 'raw_msg_2');
+  const terminal = events.at(-1);
+  expect(terminal?.type).toBe('response.completed');
+  if (terminal?.type !== 'response.completed') throw new Error('Expected terminal response');
+  const publicItem = terminal.response.output[0];
+  expect(publicItem.id).not.toBe('rs_upstream');
+  const rows = await repo.responsesItems.lookupMany('key-a', [publicItem.id!]);
+  expect(rows[0].payload.item).toEqual(publicItem);
+  expect(rows[0].payload.item).toMatchObject({ encrypted_content: 'wrapped-affinity' });
+  expect(await repo.responsesSnapshots.lookup('key-a', 'resp_public')).not.toBeNull();
 });
 
-test('via-translation synthesized items do not claim upstream ownership', async () => {
+test('client output uses one item id across lifecycle snapshots without committing a failed snapshot', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const original = messageItem('msg_0', 'translated');
+  const store = createResponsesHttpStore('key-a', true);
+  const item = { type: 'reasoning' as const, id: 'rs_upstream', summary: [], encrypted_content: 'wrapped-affinity' };
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model',
+    status: 'failed',
+    output: [item],
+    error: { code: 'failed', message: 'failed' },
+    incomplete_details: null,
+  };
+  const input = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.created', response: { ...response, status: 'in_progress', error: null } });
+    yield eventFrame({ type: 'response.output_item.added', output_index: 0, item });
+    yield eventFrame({ type: 'response.output_item.done', output_index: 0, item });
+    yield eventFrame({ type: 'response.failed', response });
+  };
 
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: response([original]) },
-  ]), store, { targetApi: 'messages' });
+  const events: ResponsesStreamEvent[] = [];
+  for await (const frame of wrapResponsesClientOutput(input(), {
+    store,
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  })) {
+    if (frame.type === 'event') events.push(frame.event);
+  }
 
-  const collected = await collectEvents(events);
-  const storedId = eventAt(collected, 'response.output_item.done').item.id!;
-  const [row] = await repo.responsesItems.lookupMany(apiKeyId, [storedId]);
-  assertEquals(row.upstreamId, null);
-  assertEquals(row.upstreamItemId, null);
+  const ids = events.flatMap(event => {
+    if (event.type === 'response.output_item.added' || event.type === 'response.output_item.done') return [event.item.id];
+    if ('response' in event) return event.response.output.map(output => output.id);
+    return [];
+  });
+  expect(new Set(ids).size).toBe(1);
+  expect(await repo.responsesItems.lookupMany('key-a', ids.filter((id): id is string => typeof id === 'string'))).toEqual([]);
+  expect(await repo.responsesSnapshots.lookup('key-a', 'resp_public')).toBeNull();
 });
 
-test('gateway-synthesized items do not claim upstream ownership on a native stream', async () => {
+test('client output batches hundreds of finalized items at the successful terminal boundary', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const synthetic: Extract<ResponsesOutputItem, { type: 'web_search_call' }> = {
-    type: 'web_search_call',
-    id: 'ws_gw_synthetic00000000000',
+  const insertItems = vi.spyOn(repo.responsesItems, 'insertMany');
+  const store = createResponsesHttpStore('key-a', true);
+  const items = Array.from({ length: 240 }, (_, index) => ({
+    type: 'reasoning' as const,
+    id: `rs_upstream_${index}`,
+    summary: [{ type: 'summary_text' as const, text: `summary ${index}` }],
+  }));
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model',
     status: 'completed',
-    action: { type: 'search', query: 'q', queries: ['q'] },
-    results: [],
+    output: items,
+    error: null,
+    incomplete_details: null,
   };
+  const input = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    for (const [outputIndex, item] of items.entries()) {
+      yield eventFrame({ type: 'response.output_item.done', output_index: outputIndex, item });
+    }
+    yield eventFrame({ type: 'response.completed', response });
+  };
+  const iterator = wrapResponsesClientOutput(input(), {
+    store,
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  })[Symbol.asyncIterator]();
+
+  for (const item of items) {
+    const next = await iterator.next();
+    expect(next.value?.type === 'event' && next.value.event.type).toBe('response.output_item.done');
+    if (next.value?.type !== 'event' || next.value.event.type !== 'response.output_item.done') {
+      throw new Error('Expected finalized output item');
+    }
+    expect(next.value.event.item.id).not.toBe(item.id);
+  }
+  expect(insertItems).not.toHaveBeenCalled();
 
-  const { events } = wrap(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: synthetic },
-    { type: 'response.completed', response: response([synthetic]) },
-  ]), { syntheticItemIds: [synthetic.id] });
-
-  const collected = await collectEvents(events);
-  const storedId = eventAt(collected, 'response.output_item.done').item.id!;
-  const [row] = await repo.responsesItems.lookupMany(apiKeyId, [storedId]);
-  assertEquals(row.upstreamId, null);
-  assertEquals(row.upstreamItemId, null);
-  assertEquals(row.itemType, 'web_search_call');
+  const terminal = await iterator.next();
+  expect(terminal.value?.type === 'event' && terminal.value.event.type).toBe('response.completed');
+  expect(insertItems).toHaveBeenCalledTimes(1);
+  expect(insertItems.mock.calls[0][0]).toHaveLength(items.length);
+  expect((await repo.responsesSnapshots.lookup('key-a', 'resp_public'))?.itemIds).toHaveLength(items.length);
 });
 
-test('private payload registered on the request is attached to the persisted row', async () => {
+test('client output mints and persists one lifecycle id for an id-less item', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const synthetic: Extract<ResponsesOutputItem, { type: 'web_search_call' }> = {
-    type: 'web_search_call',
-    id: 'ws_gw_priv00000000000000000',
+  const store = createResponsesHttpStore('key-a', true);
+  const item = {
+    type: 'message' as const,
+    role: 'assistant' as const,
+    status: 'completed' as const,
+    content: [{ type: 'output_text' as const, text: 'answer' }],
+  };
+  const result: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model',
     status: 'completed',
-    action: { type: 'search', query: 'q', queries: ['q'] },
-    results: [{ type: 'text_result', url: 'u', title: 't', snippet: 'public-wire' }],
+    output: [item],
+    error: null,
+    incomplete_details: null,
   };
-  const privateBlob = { v: 1, functionCallItem: { type: 'function_call', call_id: 'call_orig_xyz', name: 'web_search', arguments: '{"search_query":[{"q":"q"}]}', status: 'completed' }, ir: { action: synthetic.action, results: [{ type: 'text_result', url: 'u', title: 't', snippet: 'server-only body' }] } };
-
-  const { events } = wrap(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: synthetic },
-    { type: 'response.completed', response: response([synthetic]) },
-  ]), { syntheticItemIds: [synthetic.id], privatePayloads: [[synthetic.id, privateBlob]] });
-
-  const collected = await collectEvents(events);
-  const storedId = eventAt(collected, 'response.output_item.done').item.id!;
-  const [payload] = await repo.responsesItems.lookupPayloads(apiKeyId, [storedId]);
-  assertEquals(payload.payload.private, privateBlob);
-});
-
-// --- snapshot-mode derivation tests ---
-//
-// Wrap derives the snapshot mode by observing the output stream: a
-// `compaction` or its `compaction_summary` wire alias surfaces `'replace'`,
-// any other shape surfaces `'append'`. The mode is asserted directly on
-// `store.commitSnapshot` rather than via repo state because the store
-// configuration ('append' vs 'replace') flows into the snapshot's itemIds
-// shape — itemIds is a downstream consequence we don't need to re-test here.
-
-const spyCommitSnapshot = (store: ReturnType<typeof createResponsesHttpStore>) =>
-  vi.spyOn(store, 'commitSnapshot').mockResolvedValue();
-
-test('derives snapshotMode=append when no compaction item appears in output', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const original = messageItem('raw_msg_append', 'hi');
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-  const commitSpy = spyCommitSnapshot(store);
 
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: { ...response([original]), id: 'resp_upstream_ignored' } },
-  ]), store, { responseId: 'resp_append' });
-
-  await collectEvents(events);
-  assertEquals(commitSpy.mock.calls.length, 1);
-  assertEquals(commitSpy.mock.calls[0][0], 'resp_append');
-  assertEquals(commitSpy.mock.calls[0][1], 'append');
-});
-
-test('derives snapshotMode=replace from a streamed compaction output item', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  // `compaction` is an input-shaped item type the protocol's `ResponsesOutputItem`
-  // union does not declare; cast through the assertion so the event payload
-  // mirrors what a real upstream emits on the wire.
-  const compactionItem = {
-    type: 'compaction',
-    id: 'cmp_streamed',
-    encrypted_content: 'ENC',
-  } as unknown as ResponsesOutputItem;
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-  const commitSpy = spyCommitSnapshot(store);
-
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: compactionItem },
-    { type: 'response.completed', response: { ...response([compactionItem]), object: 'response.compaction' } },
-  ]), store, { responseId: 'resp_replace_streamed' });
-
-  await collectEvents(events);
-  assertEquals(commitSpy.mock.calls.length, 1);
-  assertEquals(commitSpy.mock.calls[0][1], 'replace');
-});
-
-test('derives snapshotMode=replace from a streamed compaction_summary alias item', async () => {
-  // Codex's protocol pins `compaction_summary` as a serde alias for
-  // `compaction` (https://github.com/openai/codex/blob/main/codex-rs/protocol/src/models.rs);
-  // wrap treats either literal as a compaction-shape envelope.
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const summaryItem = {
-    type: 'compaction_summary',
-    id: 'cmp_summary',
-    encrypted_content: 'ENC',
-  } as unknown as ResponsesOutputItem;
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-  const commitSpy = spyCommitSnapshot(store);
-
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: summaryItem },
-    { type: 'response.completed', response: { ...response([summaryItem]), object: 'response.compaction' } },
-  ]), store, { responseId: 'resp_replace_summary' });
-
-  await collectEvents(events);
-  assertEquals(commitSpy.mock.calls.length, 1);
-  assertEquals(commitSpy.mock.calls[0][1], 'replace');
-});
-
-test('derives snapshotMode=replace when the compaction item only appears in the terminal envelope', async () => {
-  // The non-streaming compact path runs through `syntheticEventsFromResult`,
-  // which emits the compaction item via generic `output_item.added`/`done`
-  // pairs. A fully non-streaming upstream that surfaces the item only in
-  // `response.completed.output[]` — without any preceding `output_item.done`
-  // — must still trigger `'replace'`. This covers that terminal-envelope-only
-  // case.
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const compactionItem = {
-    type: 'compaction',
-    id: 'cmp_terminal_only',
-    encrypted_content: 'ENC',
-  } as unknown as ResponsesOutputItem;
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-  const commitSpy = spyCommitSnapshot(store);
-
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.completed', response: { ...response([compactionItem]), object: 'response.compaction' } },
-  ]), store, { responseId: 'resp_replace_terminal' });
-
-  await collectEvents(events);
-  assertEquals(commitSpy.mock.calls.length, 1);
-  assertEquals(commitSpy.mock.calls[0][1], 'replace');
+  const events: ResponsesStreamEvent[] = [];
+  for await (const frame of wrapResponsesClientOutput(frames(result), {
+    store,
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  })) if (frame.type === 'event') events.push(frame.event);
+
+  const itemIds = events.flatMap(event => {
+    if (event.type === 'response.output_item.added' || event.type === 'response.output_item.done') return [event.item.id];
+    if (event.type === 'response.completed') return event.response.output.map(output => output.id);
+    return [];
+  });
+  expect(new Set(itemIds).size).toBe(1);
+  const [clientId] = itemIds;
+  expect(typeof clientId === 'string' && isResponsesItemId(clientId)).toBe(true);
+  expect(await repo.responsesItems.lookupMany('key-a', [clientId!])).toHaveLength(1);
+  expect((await repo.responsesSnapshots.lookup('key-a', 'resp_public'))?.itemIds).toContain(clientId);
 });
 
-test('snapshot is committed under the gateway-minted id', async () => {
+test('client output binds a later delta item_id to an id-less lifecycle', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const original = messageItem('raw_msg_snap', 'hi');
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: { ...response([original]), id: 'resp_upstream_ignored' } },
-  ]), store, { responseId: 'resp_snap_id' });
+  const store = createResponsesHttpStore('key-a', true);
+  const item = {
+    type: 'message' as const,
+    role: 'assistant' as const,
+    status: 'completed' as const,
+    content: [{ type: 'output_text' as const, text: 'answer' }],
+  };
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model',
+    status: 'completed',
+    output: [item],
+    error: null,
+    incomplete_details: null,
+  };
+  const input = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.output_item.added', output_index: 0, item });
+    yield eventFrame({ type: 'response.output_text.delta', item_id: 'msg_late_upstream', output_index: 0, content_index: 0, delta: 'answer' });
+    yield eventFrame({ type: 'response.output_item.done', output_index: 0, item });
+    yield eventFrame({ type: 'response.completed', response });
+  };
 
-  await collectEvents(events);
-  const snapshot = await repo.responsesSnapshots.lookup(apiKeyId, 'resp_snap_id');
-  assert(snapshot !== null, 'expected snapshot to be written under Floway-minted id');
-  assertEquals(snapshot.id, 'resp_snap_id');
+  const events: ResponsesStreamEvent[] = [];
+  for await (const frame of wrapResponsesClientOutput(input(), {
+    store,
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  })) if (frame.type === 'event') events.push(frame.event);
+
+  const added = events.find(event => event.type === 'response.output_item.added');
+  const delta = events.find(event => event.type === 'response.output_text.delta');
+  expect(added?.type).toBe('response.output_item.added');
+  expect(delta?.type).toBe('response.output_text.delta');
+  if (added?.type !== 'response.output_item.added' || delta?.type !== 'response.output_text.delta') {
+    throw new Error('Expected added and delta events');
+  }
+  expect(isResponsesItemId(added.item.id!)).toBe(true);
+  expect(delta.item_id).toBe(added.item.id);
 });
 
-test('no snapshot is written when the store has no snapshotWrites configured', async () => {
-  // Cross-protocol stores (`createNonResponsesSourceStore`) ship with an
-  // empty `snapshotWrites` configuration; commitSnapshot is then a no-op
-  // at the store-write layer, so the wrap layer's unconditional call has
-  // no externally observable effect.
+test('client output rejects terminal item drift after output_item.done', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const repoBacking = new RepoStatefulResponsesBacking(() => repo);
-  const noSnapshotStore = new LayeredStatefulResponsesStore({
-    apiKeyId,
-    reads: [repoBacking],
-    itemWrites: [{ backing: repoBacking, durable: true }],
-    snapshotWrites: [],
-    stageInputs: false,
-  });
-  const original = messageItem('raw_msg_no_snap', 'hi');
-
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: { ...response([original]), id: 'resp_upstream_ignored' } },
-  ]), noSnapshotStore, { responseId: 'resp_no_snap' });
+  const store = createResponsesHttpStore('key-a', true);
+  const doneItem = { type: 'reasoning' as const, id: 'rs_upstream', summary: [{ type: 'summary_text' as const, text: 'old' }] };
+  const terminalItem = { ...doneItem, summary: [{ type: 'summary_text' as const, text: 'new' }] };
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model',
+    status: 'completed',
+    output: [terminalItem],
+    error: null,
+    incomplete_details: null,
+  };
+  const input = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.output_item.added', output_index: 0, item: doneItem });
+    yield eventFrame({ type: 'response.output_item.done', output_index: 0, item: doneItem });
+    yield eventFrame({ type: 'response.completed', response });
+  };
+  const collect = async () => {
+    for await (const _frame of wrapResponsesClientOutput(input(), {
+      store,
+      attemptState: new ResponsesAttemptState(),
+      responseId: 'resp_public',
+    })) void _frame;
+  };
 
-  await collectEvents(events);
-  const snapshot = await repo.responsesSnapshots.lookup(apiKeyId, 'resp_no_snap');
-  assertEquals(snapshot, null);
+  await expect(collect()).rejects.toThrow('Responses output item 0 changed after output_item.done');
+  expect(await repo.responsesSnapshots.lookup('key-a', 'resp_public')).toBeNull();
 });
 
-test('snapshot commit failure rejects before yielding the terminal frame', async () => {
+test('client output rejects repeated output_item.done drift', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const original = messageItem('raw_msg_snap_err', 'hi');
-  const repoBacking = new RepoStatefulResponsesBacking(() => repo);
-  const faultyBacking: StatefulResponsesBacking = {
-    lookupItems: args => repoBacking.lookupItems(args),
-    lookupPayloads: (aid, ids) => repoBacking.lookupPayloads(aid, ids),
-    insertItems: items => repoBacking.insertItems(items),
-    fillPayloads: items => repoBacking.fillPayloads(items),
-    refreshItems: (aid, ids, at) => repoBacking.refreshItems(aid, ids, at),
-    lookupSnapshot: async () => null,
-    insertSnapshot: async () => { throw new Error('snapshot write failed'); },
-    refreshSnapshot: async () => {},
+  const store = createResponsesHttpStore('key-a', true);
+  const first = { type: 'reasoning' as const, id: 'rs_upstream', summary: [{ type: 'summary_text' as const, text: 'old' }] };
+  const changed = { ...first, summary: [{ type: 'summary_text' as const, text: 'new' }] };
+  const input = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.output_item.added', output_index: 0, item: first });
+    yield eventFrame({ type: 'response.output_item.done', output_index: 0, item: first });
+    yield eventFrame({ type: 'response.output_item.done', output_index: 0, item: changed });
+  };
+  const collect = async () => {
+    for await (const _frame of wrapResponsesClientOutput(input(), {
+      store,
+      attemptState: new ResponsesAttemptState(),
+      responseId: 'resp_public',
+    })) void _frame;
   };
 
-  const faultyStore = new LayeredStatefulResponsesStore({
-    apiKeyId,
-    reads: [repoBacking],
-    itemWrites: [{ backing: repoBacking, durable: true }],
-    snapshotWrites: [{ backing: faultyBacking, durable: false }],
-    stageInputs: true,
-  });
-
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: { ...response([original]), id: 'resp_snap_fail' } },
-  ]), faultyStore);
-
-  await assertRejects(() => collectEvents(events), Error, 'snapshot write failed');
-  assertEquals(await repo.responsesSnapshots.lookup(apiKeyId, TEST_RESPONSE_ID), null);
+  await expect(collect()).rejects.toThrow('Responses output item 0 changed after output_item.done');
 });
 
-test('in-stream commit: row is visible immediately after done frame', async () => {
+test('snapshot output IDs follow output_index rather than done arrival order', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const original = messageItem('raw_msg_in_stream', 'hi');
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-
-  const iterator = wrapWithStore(framesFrom([
-    { type: 'response.output_item.done', output_index: 0, item: original },
-    { type: 'response.completed', response: response([original]) },
-  ]), store)[Symbol.asyncIterator]();
-
-  const doneFrame = await iterator.next();
-  assert(doneFrame.value?.type === 'event');
-  const storedId = (doneFrame.value.event as Extract<ResponsesStreamEvent, { type: 'response.output_item.done' }>).item.id!;
+  const store = createResponsesHttpStore('key-a', true);
+  const first = { type: 'reasoning' as const, id: 'rs_first', summary: [] };
+  const second = { type: 'reasoning' as const, id: 'rs_second', summary: [] };
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
+    object: 'response',
+    model: 'model',
+    status: 'completed',
+    output: [first, second],
+    error: null,
+    incomplete_details: null,
+  };
+  const input = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.output_item.done', output_index: 1, item: second });
+    yield eventFrame({ type: 'response.output_item.done', output_index: 0, item: first });
+    yield eventFrame({ type: 'response.completed', response });
+  };
+  let terminal: ResponsesResult | undefined;
+  for await (const frame of wrapResponsesClientOutput(input(), {
+    store,
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  })) if (frame.type === 'event' && frame.event.type === 'response.completed') terminal = frame.event.response;
+  if (terminal === undefined) throw new Error('Expected terminal response');
 
-  // Row should be committed before the done frame was yielded
-  const rows = await repo.responsesItems.lookupMany(apiKeyId, [storedId]);
-  assertEquals(rows.length, 1, 'row should be visible immediately after done frame');
+  expect((await repo.responsesSnapshots.lookup('key-a', 'resp_public'))?.itemIds).toEqual(
+    terminal.output.map(item => item.id),
+  );
 });
 
-test('end-of-stream items in terminal frame are stored and rewritten', async () => {
+test('finalized item validation accepts the compaction_summary alias', async () => {
   const repo = new InMemoryRepo();
   initRepo(repo);
-  const original = messageItem('raw_terminal_eoi', 'eos');
-  const store = createResponsesHttpStore(apiKeyId, undefined);
-
-  const events = wrapWithStore(framesFrom([
-    { type: 'response.completed', response: response([original]) },
-  ]), store);
-
-  const collected = await collectEvents(events);
-  const storedId = eventAt(collected, 'response.completed').response.output[0].id!;
-  assert(isStoredResponsesItemId(storedId));
-  const [row] = await repo.responsesItems.lookupMany(apiKeyId, [storedId]);
-  const [payload] = await repo.responsesItems.lookupPayloads(apiKeyId, [storedId]);
-  assertEquals(row.hasPayload, true);
-  assertEquals(payload.payload, { item: original });
-});
-
-// --- syntheticEventsFromResult / drainAsync ---
-
-test('syntheticEventsFromResult emits the same frame sequence as emitToResponsesCompact', async () => {
-  const item = messageItem('compact_msg_01', 'hello');
-  const result: ResponsesResult = {
-    id: 'resp_compact_test',
+  const store = createResponsesHttpStore('key-a', true);
+  const summary = { type: 'compaction_summary', id: 'cmp_upstream', encrypted_content: 'opaque' } as unknown as ResponsesResult['output'][number];
+  const canonical = { ...summary, type: 'compaction' } as unknown as ResponsesResult['output'][number];
+  const response: ResponsesResult = {
+    id: 'resp_upstream',
     object: 'response',
-    model: 'gpt-test',
+    model: 'model',
     status: 'completed',
-    output: [item],
-    output_text: 'hello',
+    output: [canonical],
     error: null,
     incomplete_details: null,
   };
-
-  const frames: ProtocolFrame<ResponsesStreamEvent>[] = [];
-  for await (const frame of syntheticEventsFromResult(result)) frames.push(frame);
-
-  // responsesResultToEvents with genericOutputItems produces:
-  //   response.created, response.in_progress,
-  //   response.output_item.added, response.output_item.done (generic pair),
-  //   response.completed
-  // then a done sentinel frame.
-  const eventTypes = frames.filter(f => f.type === 'event').map(f => (f as { event: ResponsesStreamEvent }).event.type);
-  assertEquals(eventTypes, [
-    'response.created',
-    'response.in_progress',
-    'response.output_item.added',
-    'response.output_item.done',
-    'response.completed',
-  ]);
-  assertEquals(frames.at(-1)?.type, 'done');
-});
-
-test('drainAsync iterates to completion and returns void', async () => {
-  let count = 0;
-  const iter = async function* () {
-    count += 1;
-    yield 'a';
-    count += 1;
-    yield 'b';
-    count += 1;
+  const input = async function* (): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> {
+    yield eventFrame({ type: 'response.output_item.done', output_index: 0, item: summary });
+    yield eventFrame({ type: 'response.completed', response });
   };
-  const result = await drainAsync(iter());
-  assertEquals(result, undefined);
-  assertEquals(count, 3);
+  const events: ResponsesStreamEvent[] = [];
+  for await (const frame of wrapResponsesClientOutput(input(), {
+    store,
+    attemptState: new ResponsesAttemptState(),
+    responseId: 'resp_public',
+  })) if (frame.type === 'event') events.push(frame.event);
+
+  expect(events.at(-1)?.type).toBe('response.completed');
 });
diff --git a/packages/gateway/src/data-plane/chat/responses/items/rewrite.ts b/packages/gateway/src/data-plane/chat/responses/items/rewrite.ts
index 0e644a78d..50f0f99e1 100644
--- a/packages/gateway/src/data-plane/chat/responses/items/rewrite.ts
+++ b/packages/gateway/src/data-plane/chat/responses/items/rewrite.ts
@@ -1,178 +1,50 @@
-import { createTemporaryResponsesItemId, responsesItemEncryptedContent, responsesItemId } from './format.ts';
+import { canonicalResponsesItemType, isResponsesItemId, responsesItemId } from './format.ts';
 import type { StatefulResponsesStore } from './store.ts';
-import type { StoredResponsesItemMetadata, StoredResponsesItemPayload } from '../../../../repo/types.ts';
 import { throwChatServeFailure } from '../../shared/errors.ts';
 import type { CanonicalResponsesPayload, ResponsesInputItem } from '@floway-dev/protocols/responses';
-import type { ModelCandidate } from '@floway-dev/provider';
-import type { ResponsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
-const isUpstreamOwned = (row: StoredResponsesItemMetadata): row is StoredResponsesItemMetadata & { upstreamId: string } =>
-  row.upstreamId !== null;
-
-const itemWithId = (item: ResponsesInputItem, id: string): ResponsesInputItem => ({
-  ...item,
-  id,
-} as ResponsesInputItem);
-
-// Codex stores output items in an input-shaped history model: message/function
-// status and output-text annotations/logprobs are absent, while reasoning keeps
-// an optional content carrier. Restore the server defaults only for the durable
-// content-hash comparison; the normalized object is used only when that hash
-// proves it is exactly the persisted canonical payload. Each candidate already
-// owns a deep-cloned source payload, so canonicalization copies only the item
-// and content blocks whose defaults actually change.
-// https://github.com/openai/codex/blob/c888e8e75a9f0e90ce7d5517f8b9540832cbbf76/codex-rs/protocol/src/models.rs#L843-L858
-// https://github.com/openai/codex/blob/c888e8e75a9f0e90ce7d5517f8b9540832cbbf76/codex-rs/protocol/src/models.rs#L933-L1012
-const canonicalStoredEcho = (item: ResponsesInputItem, row: StoredResponsesItemMetadata): ResponsesInputItem => {
-  const canonical = { ...item } as ResponsesInputItem & Record<string, unknown>;
-  if (row.upstreamItemId !== null) canonical.id = row.upstreamItemId;
-  if (canonical.type === 'reasoning' && canonical.content == null) canonical.content = [];
-  if ((canonical.type === 'function_call' || canonical.type === 'message') && canonical.status === undefined) {
-    canonical.status = 'completed';
-  }
-  if (canonical.type === 'message' && Array.isArray(canonical.content)) {
-    let changed = false;
-    const content = canonical.content.map(block => {
-      if (block.type !== 'output_text') return block;
-      if (Object.hasOwn(block, 'annotations') && Object.hasOwn(block, 'logprobs')) return block;
-      changed = true;
-      return {
-        ...block,
-        ...(!Object.hasOwn(block, 'annotations') ? { annotations: [] } : {}),
-        ...(!Object.hasOwn(block, 'logprobs') ? { logprobs: [] } : {}),
-      };
-    });
-    if (changed) canonical.content = content;
-  }
-  return canonical;
-};
-
-interface ResolvedItem {
+interface HydratedItem {
   readonly item: ResponsesInputItem;
-  readonly row?: StoredResponsesItemMetadata;
-  canonical?: ResponsesInputItem;
+  readonly privatePayload?: unknown;
 }
 
-const resolveStoredRow = (
-  item: ResponsesInputItem,
-  store: StatefulResponsesStore,
-  hashByEncryptedContent: ReadonlyMap<string, string>,
-): StoredResponsesItemMetadata | undefined => {
+const hydrateItem = (item: ResponsesInputItem, store: StatefulResponsesStore | undefined): HydratedItem => {
   const id = responsesItemId(item);
-  const encryptedContent = responsesItemEncryptedContent(item);
-  return (id !== null ? store.getItemById(id) : undefined)
-    ?? (encryptedContent !== null ? store.getItemsByEncryptedContentHash(hashByEncryptedContent.get(encryptedContent)!).find(
-      row => item.type === 'item_reference' || row.itemType === item.type,
-    ) ?? store.getItemsByEncryptedContentHash(hashByEncryptedContent.get(encryptedContent)!)[0] : undefined);
-};
-
-const shouldHydrate = async (
-  resolved: ResolvedItem,
-  candidate: ModelCandidate,
-  store: StatefulResponsesStore,
-): Promise<boolean> => {
-  const { item, row } = resolved;
-  if (!row?.hasPayload) return false;
-  if (isUpstreamOwned(row) && row.itemType === 'reasoning' && row.upstreamId !== candidate.provider.upstream) return false;
-  if (item.type === 'item_reference') return true;
-  if (row.origin === 'synthetic') return true;
-  const canonical = canonicalStoredEcho(item, row);
-  if (row.contentHash !== null && await store.hashItemContent(canonical) === row.contentHash) {
-    resolved.canonical = canonical;
-    return false;
-  }
-  return true;
-};
-
-const rewriteItemForCandidate = (
-  resolved: ResolvedItem,
-  payload: StoredResponsesItemPayload | undefined,
-  candidate: ModelCandidate,
-): ResponsesInputItem | null => {
-  const { item, row } = resolved;
-  if (row === undefined) {
-    if (item.type === 'item_reference') throwChatServeFailure({ kind: 'item-not-found', itemId: item.id });
-    return item;
-  }
-  if (item.type === 'item_reference' && !row.hasPayload) {
-    throwChatServeFailure({ kind: 'item-not-found', itemId: row.id });
-  }
-  if (isUpstreamOwned(row) && row.itemType === 'reasoning' && row.upstreamId !== candidate.provider.upstream) return null;
-  if (item.type === 'item_reference' && payload === undefined) {
-    throwChatServeFailure({ kind: 'item-not-found', itemId: row.id });
-  }
-  const replacement = resolved.canonical
-    ?? (payload === undefined ? item : structuredClone(payload.item) as ResponsesInputItem);
-  if (!isUpstreamOwned(row)) return replacement;
-  if (row.upstreamId === candidate.provider.upstream && row.upstreamItemId !== null) {
-    return itemWithId(replacement, row.upstreamItemId);
-  }
-  if (responsesItemId(replacement) !== null) return itemWithId(replacement, createTemporaryResponsesItemId(row.itemType));
-  return replacement;
-};
-
-const collectEncryptedContents = async (
-  items: Iterable<ResponsesInputItem>,
-  store: StatefulResponsesStore,
-): Promise<Map<string, string>> => {
-  const encryptedContents = new Set<string>();
-  for (const item of items) {
-    const encryptedContent = responsesItemEncryptedContent(item);
-    if (encryptedContent !== null) encryptedContents.add(encryptedContent);
-  }
-  return new Map(await Promise.all([...encryptedContents].map(async value => [value, await store.hashEncryptedContent(value)] as const)));
-};
-
-const rewriteResponsesItemListForCandidate = async (
-  items: readonly ResponsesInputItem[],
-  store: StatefulResponsesStore,
-  candidate: ModelCandidate,
-): Promise<{ readonly items: Array<ResponsesInputItem | null>; readonly privatePayloads: ReadonlyMap<string, unknown> }> => {
-  const hashByEncryptedContent = await collectEncryptedContents(items, store);
-  const resolved = items.map(item => ({ item, row: resolveStoredRow(item, store, hashByEncryptedContent) }));
-  const rowsToHydrate: StoredResponsesItemMetadata[] = [];
-  for (const item of resolved) {
-    if (await shouldHydrate(item, candidate, store) && item.row !== undefined) rowsToHydrate.push(item.row);
+  if (id === null || !isResponsesItemId(id)) return { item };
+  const stored = store?.getItemById(id);
+  if (stored === undefined) {
+    if (item.type === 'item_reference') throwChatServeFailure({ kind: 'item-not-found', itemId: id });
+    return { item };
+  }
+  if (item.type !== 'item_reference' && canonicalResponsesItemType(item.type) !== canonicalResponsesItemType(stored.itemType)) {
+    throwChatServeFailure({
+      kind: 'routing-unavailable',
+      message: `Stored Responses item '${stored.id}' has type '${stored.itemType}', incompatible with the requested item type '${item.type}'.`,
+    });
   }
-  const payloads = await store.loadItemPayloads(rowsToHydrate);
-  const privatePayloads = new Map<string, unknown>();
-  const rewritten = resolved.map(item => {
-    const payload = item.row === undefined ? undefined : payloads.get(item.row.id);
-    const result = rewriteItemForCandidate(item, payload, candidate);
-    const wireId = result === null ? null : responsesItemId(result);
-    if (wireId !== null && payload?.private !== undefined) privatePayloads.set(wireId, structuredClone(payload.private));
-    return result;
-  });
-  // The outbound objects no longer need hashes from their source inputs. Drop
-  // those values before the upstream wait; output persistence starts a fresh
-  // cache through the same turn-local store.
-  store.clearItemHashes();
-  return { items: rewritten, privatePayloads };
+  return {
+    item: structuredClone(stored.payload.item) as ResponsesInputItem,
+    ...(stored.payload.private !== undefined ? { privatePayload: structuredClone(stored.payload.private) } : {}),
+  };
 };
 
-export interface RewrittenResponsesPayload {
+export interface HydratedResponsesPayload {
   readonly payload: CanonicalResponsesPayload;
   readonly privatePayloads: ReadonlyMap<string, unknown>;
 }
 
-export const rewriteResponsesPayloadForCandidate = async (
+export const hydrateResponsesPayload = (
   payload: CanonicalResponsesPayload,
-  store: StatefulResponsesStore,
-  candidate: ModelCandidate,
-): Promise<RewrittenResponsesPayload> => {
-  const rewritten = await rewriteResponsesItemListForCandidate(payload.input, store, candidate);
-  return { payload: { ...payload, input: rewritten.items.filter(item => item !== null) }, privatePayloads: rewritten.privatePayloads };
-};
-
-export const rewriteStoredItemsInSourceForCandidate = async <TSourceItems>(
-  sourceItems: TSourceItems,
-  view: ResponsesItemsView<TSourceItems>,
-  store: StatefulResponsesStore,
-  candidate: ModelCandidate,
-): Promise<TSourceItems> => {
-  const visited: ResponsesInputItem[] = [];
-  await view.visitAsResponsesItems(sourceItems, item => { visited.push(item); });
-  const rewritten = await rewriteResponsesItemListForCandidate(visited, store, candidate);
-  let index = 0;
-  return (await view.mapAsResponsesItems(sourceItems, () => rewritten.items[index++])) as TSourceItems;
+  store: StatefulResponsesStore | undefined,
+): HydratedResponsesPayload => {
+  const hydrated = payload.input.map(item => hydrateItem(item, store));
+  const privatePayloads = new Map<string, unknown>();
+  for (const entry of hydrated) {
+    const id = responsesItemId(entry.item);
+    if (id !== null && entry.privatePayload !== undefined) privatePayloads.set(id, entry.privatePayload);
+  }
+  return {
+    payload: { ...payload, input: hydrated.map(entry => entry.item) },
+    privatePayloads,
+  };
 };
diff --git a/packages/gateway/src/data-plane/chat/responses/items/rewrite_test.ts b/packages/gateway/src/data-plane/chat/responses/items/rewrite_test.ts
index 81b6517b3..e9160fdb8 100644
--- a/packages/gateway/src/data-plane/chat/responses/items/rewrite_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/items/rewrite_test.ts
@@ -1,380 +1,65 @@
-import { test, vi } from 'vitest';
+import { describe, expect, test } from 'vitest';
 
-import { classifyResponsesItemAffinity } from './affinity.ts';
-import { createStoredResponsesItemId, hashResponsesItemContent, hashResponsesItemEncryptedContent, isStoredResponsesItemId } from './format.ts';
-import { rewriteResponsesPayloadForCandidate } from './rewrite.ts';
-import { createNonResponsesSourceStore } from './store.ts';
+import { createResponsesItemId } from './format.ts';
+import { hydrateResponsesPayload } from './rewrite.ts';
+import { createResponsesHttpStore } from './store.ts';
 import { initRepo } from '../../../../repo/index.ts';
 import { InMemoryRepo } from '../../../../repo/memory.ts';
 import type { StoredResponsesItem } from '../../../../repo/types.ts';
-import type { CanonicalResponsesPayload, ResponsesInputItem } from '@floway-dev/protocols/responses';
-import type { ModelCandidate } from '@floway-dev/provider';
-import { directFetcher } from '@floway-dev/provider';
-import { stubProvider, stubInternalModel, stubProviderModel, assert, assertEquals, assertFalse } from '@floway-dev/test-utils';
-import { responsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
-const API_KEY_ID = 'key_rewrite_test';
-
-const candidate = (upstream: string): ModelCandidate => {
-  const modelProvider = stubProvider({
-    getProvidedModels: () => Promise.resolve([stubProviderModel()]),
-  });
-  return {
-    provider: {
-      upstream,
-      kind: 'custom',
-      name: upstream,
-      disabledPublicModelIds: [],
-      modelPrefix: null,
-      instance: modelProvider,
-    },
-    model: stubInternalModel({}, upstream),
-    fetcher: directFetcher,
-  };
-};
-
-const insertRows = async (rows: readonly StoredResponsesItem[]) => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  await repo.responsesItems.insertMany(rows);
-  return repo;
-};
-
-const storedRow = (
-  overrides: Omit<Partial<StoredResponsesItem>, 'payload'> & Pick<StoredResponsesItem, 'id' | 'itemType'> & { payload?: unknown | null },
-): StoredResponsesItem => {
-  const { payload, ...rest } = overrides;
-  return {
-    apiKeyId: API_KEY_ID,
-    upstreamId: null,
-    upstreamItemId: null,
-    origin: overrides.origin ?? (overrides.upstreamId === undefined || overrides.upstreamId === null ? 'synthetic' : 'upstream'),
-    contentHash: null,
-    encryptedContentHash: null,
-    payload: payload === undefined || payload === null
-      ? null
-      : typeof payload === 'object' && Object.hasOwn(payload, 'item')
-        ? payload as StoredResponsesItem['payload']
-        : { item: payload },
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-    ...rest,
-  };
-};
-
-const storedMessageId = (_label: string): string => createStoredResponsesItemId('message');
-const storedReasoningId = (_label: string): string => createStoredResponsesItemId('reasoning');
-const storedCompactionId = (_label: string): string => createStoredResponsesItemId('compaction');
-
-const makePayload = (input: ResponsesInputItem[]): CanonicalResponsesPayload => ({
-  model: 'test-model',
-  input,
-});
-
-const rewrite = async (
-  input: ResponsesInputItem[],
-  cand: ModelCandidate,
-): Promise<ResponsesInputItem[]> => {
-  const store = createNonResponsesSourceStore(API_KEY_ID);
-  await store.loadInputItems({ sourceItems: input, view: responsesItemsView });
-  // Simulate the affinity classification that populates the store cache.
-  await classifyResponsesItemAffinity({ sourceItems: input, view: responsesItemsView, store, candidates: [cand] });
-  const result = await rewriteResponsesPayloadForCandidate(makePayload(input), store, cand);
-  return result.payload.input as ResponsesInputItem[];
-};
-
-// Case 1: no matching row → item is kept as-is
-test('item with no stored row is kept as-is', async () => {
-  await insertRows([]);
-  const item: ResponsesInputItem = { type: 'message', role: 'user', content: 'hello' };
-  const rewritten = await rewrite([item], candidate('up_a'));
-  assertEquals(rewritten, [item]);
-});
-
-// Case 2: item_reference + row.payload === null → throw item-not-found
-test('item_reference with null payload throws item-not-found', async () => {
-  const id = storedMessageId('no-payload-ref');
-  await insertRows([
-    storedRow({ id, itemType: 'message', upstreamId: 'up_a', upstreamItemId: 'raw_msg_a', payload: null }),
-  ]);
-
-  let threw = false;
-  try {
-    await rewrite([{ type: 'item_reference', id }], candidate('up_a'));
-  } catch {
-    threw = true;
-  }
-  assert(threw, 'should have thrown item-not-found');
-});
-
-// Case 3: synthetic row (no upstream) → inline-expand from stored payload
-test('synthetic row without upstream owner is inline-expanded to any provider', async () => {
-  const id = storedReasoningId('synthetic');
-  await insertRows([
-    storedRow({
+describe('Responses stored-item hydration', () => {
+  test('replaces a public item reference with its complete client-wire payload and private state', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const id = createResponsesItemId('reasoning');
+    const row: StoredResponsesItem = {
       id,
+      apiKeyId: 'key-a',
       itemType: 'reasoning',
-      upstreamId: null,
-      upstreamItemId: null,
-      payload: { type: 'reasoning', id: 'rs_synthetic_origin', summary: [{ type: 'summary_text', text: 'trace' }] },
-    }),
-  ]);
-
-  const input: ResponsesInputItem[] = [{ type: 'reasoning', id, summary: [{ type: 'summary_text', text: 'stale' }] }];
-  const rewritten = await rewrite(input, candidate('up_b'));
-
-  assert(rewritten.length === 1, 'synthetic reasoning must survive routing to a non-owning provider');
-  assert(rewritten[0].type === 'reasoning');
-  assertEquals((rewritten[0] as { summary?: { text: string }[] }).summary?.[0]?.text, 'trace');
-});
-
-// Case 4: owned reasoning + wrong upstream → drop (return null, item is skipped)
-test('owned reasoning is dropped when routing to a different upstream', async () => {
-  const id = storedReasoningId('owned-reasoning');
-  await insertRows([
-    storedRow({ id, itemType: 'reasoning', upstreamId: 'up_a', upstreamItemId: 'raw_rs_a' }),
-  ]);
-
-  const input: ResponsesInputItem[] = [{ type: 'reasoning', id, summary: [{ type: 'summary_text', text: 'trace' }] }];
-  const rewritten = await rewrite(input, candidate('up_b'));
-
-  assertEquals(rewritten, []);
-});
-
-// Case 5: same upstream + has upstreamItemId → substitute upstream's original id
-test('matching upstream rewrites to upstream_item_id', async () => {
-  const id = storedMessageId('origin');
-  await insertRows([
-    storedRow({ id, itemType: 'message', upstreamId: 'up_a', upstreamItemId: 'raw_msg_a' }),
-  ]);
-
-  const input: ResponsesInputItem[] = [{ type: 'message', id, role: 'assistant', content: 'stale' }];
-  const rewritten = await rewrite(input, candidate('up_a'));
-
-  assertEquals(rewritten, [{ type: 'message', id: 'raw_msg_a', role: 'assistant', content: 'stale' }]);
-});
-
-test('canonical projected echo rewrites from metadata without loading its payload', async () => {
-  const id = storedMessageId('metadata-fast-path');
-  const canonical = {
-    type: 'message',
-    id: 'raw_msg_a',
-    role: 'assistant',
-    status: 'completed',
-    content: [{ type: 'output_text', text: 'hello', annotations: [], logprobs: [] }],
-  } as unknown as ResponsesInputItem;
-  const repo = await insertRows([storedRow({
-    id,
-    itemType: 'message',
-    upstreamId: 'up_a',
-    upstreamItemId: 'raw_msg_a',
-    contentHash: await hashResponsesItemContent(canonical),
-    payload: canonical,
-  })]);
-  const loadPayloads = vi.spyOn(repo.responsesItems, 'lookupPayloads');
-  const input: ResponsesInputItem[] = [{
-    type: 'message',
-    id,
-    role: 'assistant',
-    content: [{ type: 'output_text', text: 'hello' }],
-  }];
-
-  const rewritten = await rewrite(input, candidate('up_a'));
-
-  assertEquals(loadPayloads.mock.calls, []);
-  assertEquals(rewritten, [canonical]);
-});
-
-test('canonical projected echo shares unchanged attempt-owned content blocks', async () => {
-  const id = storedMessageId('metadata-structural-sharing');
-  const inputImage = { type: 'input_image', image_url: 'data:image/png;base64,AA==' } as const;
-  const outputText = { type: 'output_text', text: 'hello' } as const;
-  const canonical = {
-    type: 'message',
-    id: 'raw_msg_a',
-    role: 'assistant',
-    status: 'completed',
-    content: [{ ...outputText, annotations: [], logprobs: [] }, inputImage],
-  } as unknown as ResponsesInputItem;
-  await insertRows([storedRow({
-    id,
-    itemType: 'message',
-    upstreamId: 'up_a',
-    upstreamItemId: 'raw_msg_a',
-    contentHash: await hashResponsesItemContent(canonical),
-    payload: canonical,
-  })]);
-  const input = [{
-    type: 'message',
-    id,
-    role: 'assistant',
-    content: [outputText, inputImage],
-  }] as unknown as ResponsesInputItem[];
-
-  const [rewritten] = await rewrite(input, candidate('up_a'));
-  assert(rewritten.type === 'message' && Array.isArray(rewritten.content));
-
-  assert(rewritten.content[0] !== outputText, 'the block receiving defaults must be copied');
-  assert(rewritten.content[1] === inputImage, 'unchanged attempt-owned blocks should be shared');
-  assertEquals(input[0], {
-    type: 'message',
-    id,
-    role: 'assistant',
-    content: [outputText, inputImage],
-  });
-});
-
-// Case 6: cross-upstream owned → mint tmp id
-test('non-matching portable owned item gets a temporary id without leaking raw upstream ids', async () => {
-  const id = storedMessageId('portable');
-  await insertRows([
-    storedRow({ id, itemType: 'message', upstreamId: 'up_a', upstreamItemId: 'raw_msg_a' }),
-  ]);
-
-  const input: ResponsesInputItem[] = [{ type: 'message', id, role: 'assistant', content: 'portable body' }];
-  const rewritten = await rewrite(input, candidate('up_b'));
-  const [item] = rewritten;
-
-  assert(item.type === 'message');
-  assert(typeof item.id === 'string');
-  assert(item.id.startsWith('msg_tmp_'), item.id);
-  assertFalse(isStoredResponsesItemId(item.id));
-  assert(item.id !== id);
-  assert(item.id !== 'raw_msg_a');
-});
-
-test('stored payload replaces stale caller content before provider id rewrite', async () => {
-  const id = storedMessageId('canonical');
-  await insertRows([
-    storedRow({
-      id,
-      itemType: 'message',
-      upstreamId: 'up_a',
-      upstreamItemId: 'raw_msg_a',
-      payload: {
-        type: 'message',
-        id,
-        role: 'assistant',
-        content: [{ type: 'output_text', text: 'canonical content' }],
-      },
-    }),
-  ]);
-
-  const input: ResponsesInputItem[] = [{ type: 'message', id, role: 'assistant', content: 'stale caller content' }];
-  const rewritten = await rewrite(input, candidate('up_a'));
-
-  assertEquals(rewritten, [{
-    type: 'message',
-    id: 'raw_msg_a',
-    role: 'assistant',
-    content: [{ type: 'output_text', text: 'canonical content' }],
-  }]);
-});
-
-test('matching upstream expands item_reference and rewrites to upstream item id', async () => {
-  const id = storedMessageId('origin-reference');
-  await insertRows([
-    storedRow({
-      id,
-      itemType: 'message',
-      upstreamId: 'up_a',
-      upstreamItemId: 'raw_msg_a',
       payload: {
-        type: 'message',
-        id,
-        role: 'assistant',
-        content: [{ type: 'output_text', text: 'stored content' }],
+        item: { type: 'reasoning', id, summary: [], encrypted_content: 'wrapped' },
+        private: { replay: true },
       },
-    }),
-  ]);
-
-  const input: ResponsesInputItem[] = [{ type: 'item_reference', id }];
-  const rewritten = await rewrite(input, candidate('up_a'));
+      contentHash: 'hash',
+      createdAt: 1_000,
+    };
+    await repo.responsesItems.insertMany([row]);
+    const store = createResponsesHttpStore('key-a', true);
+    const payload = { model: 'model', input: [{ type: 'item_reference' as const, id: row.id }] };
+    await store.loadInputItems(payload.input, payload.input);
+
+    const rewritten = hydrateResponsesPayload(payload, store);
+
+    expect(rewritten.payload.input).toEqual([row.payload.item]);
+    expect(rewritten.privatePayloads.get(row.id)).toEqual({ replay: true });
+  });
 
-  assertEquals(rewritten, [{
-    type: 'message',
-    id: 'raw_msg_a',
-    role: 'assistant',
-    content: [{ type: 'output_text', text: 'stored content' }],
-  }]);
-});
+  test('rejects a missing gateway item reference', () => {
+    initRepo(new InMemoryRepo());
+    const store = createResponsesHttpStore('key-a', true);
+    expect(() => hydrateResponsesPayload({
+      model: 'model',
+      input: [{ type: 'item_reference', id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA' }],
+    }, store)).toThrow();
+  });
 
-test('non-matching upstream expands item_reference and mints a temporary id', async () => {
-  const id = storedMessageId('cross-upstream-reference');
-  await insertRows([
-    storedRow({
+  test('accepts compaction after a client canonicalizes the compaction_summary alias', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const id = createResponsesItemId('compaction');
+    const row: StoredResponsesItem = {
       id,
-      itemType: 'message',
-      upstreamId: 'up_a',
-      upstreamItemId: 'raw_msg_a',
-      payload: {
-        type: 'message',
-        id,
-        role: 'assistant',
-        content: [{ type: 'output_text', text: 'stored content' }],
-      },
-    }),
-  ]);
-
-  const input: ResponsesInputItem[] = [{ type: 'item_reference', id }];
-  const rewritten = await rewrite(input, candidate('up_b'));
-
-  assertEquals(rewritten.length, 1);
-  const [item] = rewritten;
-  assert(item.type === 'message');
-  assert(typeof item.id === 'string');
-  assert(item.id.startsWith('msg_tmp_'), item.id);
-  assertEquals(item.role, 'assistant');
-  assertEquals(item.content, [{ type: 'output_text', text: 'stored content' }]);
-});
-
-test('id-less reasoning matched by encrypted_content routes to owner and stamps upstream id', async () => {
-  const enc = 'enc-reasoning-blob';
-  const hash = await hashResponsesItemEncryptedContent(enc);
-  await insertRows([
-    storedRow({ id: storedReasoningId('owned'), itemType: 'reasoning', upstreamId: 'up_a', upstreamItemId: 'raw_rs_a', encryptedContentHash: hash, payload: null }),
-  ]);
-
-  const input = [{ type: 'reasoning', summary: [], encrypted_content: enc }] as unknown as ResponsesInputItem[];
-
-  // Routed to the owner: stamped with upstream's own item id.
-  const rewrittenOwner = await rewrite(input, candidate('up_a'));
-  assertEquals(rewrittenOwner, [{ type: 'reasoning', summary: [], encrypted_content: enc, id: 'raw_rs_a' }]);
-
-  // Routed elsewhere: reasoning is owned, dropped when upstream doesn't match.
-  const rewrittenOther = await rewrite(input, candidate('up_b'));
-  assertEquals(rewrittenOther, []);
-});
-
-test('id-less encrypted_content with no stored match is a benign passthrough', async () => {
-  await insertRows([]);
-  const input = [{ type: 'reasoning', summary: [], encrypted_content: 'never-stored' }] as unknown as ResponsesInputItem[];
-  const rewritten = await rewrite(input, candidate('up_a'));
-
-  assertEquals(rewritten, input);
-});
-
-test('id-less encrypted_content duplicate hash uses freshest stored row for rewrite', async () => {
-  const enc = 'duplicate-enc';
-  const hash = await hashResponsesItemEncryptedContent(enc);
-  await insertRows([
-    storedRow({ id: storedReasoningId('old'), itemType: 'reasoning', upstreamId: 'up_old', upstreamItemId: 'raw_old', encryptedContentHash: hash, payload: null, createdAt: 1_000, refreshedAt: 1_000 }),
-    storedRow({ id: storedReasoningId('new'), itemType: 'reasoning', upstreamId: 'up_new', upstreamItemId: 'raw_new', encryptedContentHash: hash, payload: null, createdAt: 2_000, refreshedAt: 2_000 }),
-  ]);
-
-  const input = [{ type: 'reasoning', summary: [], encrypted_content: enc }] as unknown as ResponsesInputItem[];
-  const rewritten = await rewrite(input, candidate('up_new'));
-  assertEquals(rewritten, [{ type: 'reasoning', summary: [], encrypted_content: enc, id: 'raw_new' }]);
-});
-
-test('id-less compaction is matched by encrypted_content hash and stamps upstream item id', async () => {
-  const enc = 'enc-compaction-blob';
-  const hash = await hashResponsesItemEncryptedContent(enc);
-  await insertRows([
-    storedRow({ id: storedCompactionId('owned'), itemType: 'compaction', upstreamId: 'up_a', upstreamItemId: 'raw_cmp_a', encryptedContentHash: hash, payload: null }),
-  ]);
-
-  const input = [{ type: 'compaction', encrypted_content: enc }] as unknown as ResponsesInputItem[];
-  const rewritten = await rewrite(input, candidate('up_a'));
-  assertEquals(rewritten, [{ type: 'compaction', encrypted_content: enc, id: 'raw_cmp_a' }]);
+      apiKeyId: 'key-a',
+      itemType: 'compaction_summary',
+      payload: { item: { type: 'compaction_summary', id, encrypted_content: 'wrapped' } },
+      contentHash: 'hash',
+      createdAt: 1_000,
+    };
+    await repo.responsesItems.insertMany([row]);
+    const store = createResponsesHttpStore('key-a', true);
+    const input = [{ type: 'compaction', id, encrypted_content: 'wrapped' }] as unknown as Parameters<typeof hydrateResponsesPayload>[0]['input'];
+    await store.loadInputItems(input, input);
+
+    expect(hydrateResponsesPayload({ model: 'model', input }, store).payload.input).toEqual([row.payload.item]);
+  });
 });
diff --git a/packages/gateway/src/data-plane/chat/responses/items/store.ts b/packages/gateway/src/data-plane/chat/responses/items/store.ts
index ae2e6f7be..e614f0e2c 100644
--- a/packages/gateway/src/data-plane/chat/responses/items/store.ts
+++ b/packages/gateway/src/data-plane/chat/responses/items/store.ts
@@ -1,252 +1,109 @@
-import { createStoredResponsesItemId, isStoredResponsesItemId, responsesItemEncryptedContent, responsesItemId } from './format.ts';
-import { ResponsesItemHashCache } from './hash-cache.ts';
+import { canonicalResponsesItemType, createResponsesItemId, hashResponsesItemContent, isResponsesItemId, responsesItemId } from './format.ts';
 import { getRepo } from '../../../../repo/index.ts';
-import {
-  cloneStoredResponsesItem,
-  cloneStoredResponsesItemMetadata,
-  cloneStoredResponsesSnapshot,
-  compareResponsesItemsByFreshness as compareItemsByFreshness,
-  responsesItemStoreKey as scopedKey,
-  storedResponsesItemMetadata,
-} from '../../../../repo/responses-clone.ts';
-import type { Repo, StoredResponsesItem, StoredResponsesItemMetadata, StoredResponsesItemPayload, StoredResponsesItemPayloadRecord, StoredResponsesSnapshot } from '../../../../repo/types.ts';
+import { cloneStoredResponsesItem, cloneStoredResponsesSnapshot, compareResponsesItemsByFreshness, scopedResponsesKey } from '../../../../repo/responses-clone.ts';
+import type { Repo, StoredResponsesItem, StoredResponsesSnapshot } from '../../../../repo/types.ts';
 import type { ResponsesInputItem } from '@floway-dev/protocols/responses';
-import type { ResponsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
 export interface StatefulResponsesItemLookup {
-  readonly apiKeyId: string | null;
+  readonly apiKeyId: string;
   readonly ids: readonly string[];
   readonly contentHashes: readonly string[];
-  readonly encryptedContentHashes: readonly string[];
-}
-
-export interface StatefulResponsesItemLookupResult {
-  readonly metadata: StoredResponsesItemMetadata;
-  readonly durable: boolean;
 }
 
 export interface StatefulResponsesBacking {
-  lookupItems(query: StatefulResponsesItemLookup): Promise<StatefulResponsesItemLookupResult[]>;
-  lookupPayloads(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemPayloadRecord[]>;
-  insertItems(items: readonly StoredResponsesItem[], options: { readonly durable: boolean }): Promise<void>;
-  fillPayloads(items: readonly StoredResponsesItem[], options: { readonly durable: boolean }): Promise<void>;
-  markDurable?(apiKeyId: string | null, id: string): void;
-  refreshItems(apiKeyId: string | null, ids: readonly string[], refreshedAt: number): Promise<void>;
-  lookupSnapshot(apiKeyId: string | null, id: string): Promise<StoredResponsesSnapshot | null>;
+  lookupItems(query: StatefulResponsesItemLookup): Promise<StoredResponsesItem[]>;
+  insertItems(items: readonly StoredResponsesItem[]): Promise<void>;
+  refreshItems(items: readonly StoredResponsesItem[], createdAt: number): Promise<void>;
+  lookupSnapshot(apiKeyId: string, id: string): Promise<StoredResponsesSnapshot | null>;
   insertSnapshot(snapshot: StoredResponsesSnapshot): Promise<void>;
-  refreshSnapshot(apiKeyId: string | null, id: string, refreshedAt: number): Promise<void>;
-}
-
-export interface StatefulResponsesWriteTarget {
-  readonly backing: StatefulResponsesBacking;
-  readonly durable: boolean;
 }
 
 export interface LayeredStatefulResponsesStoreOptions {
-  readonly apiKeyId: string | null;
+  readonly apiKeyId: string;
   readonly reads: readonly StatefulResponsesBacking[];
-  readonly itemWrites: readonly StatefulResponsesWriteTarget[];
-  readonly snapshotWrites: readonly StatefulResponsesWriteTarget[];
+  readonly writes: readonly StatefulResponsesBacking[];
   readonly stageInputs: boolean;
-  // Gates durable payload persistence. When false, output item rows reach durable
-  // backings with null payload (metadata-only) and snapshot writes are skipped.
-  // In-memory backings keep full payloads regardless — see StatefulResponsesStore.
-  readonly shouldStorePayload?: boolean;
 }
 
-// How a Responses turn should commit its snapshot:
-//   - 'append'  : conversation continuation — previous snapshot + this turn's
-//                 input + this turn's output. Default for a normal generate.
-//   - 'replace' : the turn's output IS the new conversation — drop prior
-//                 history and the stitched-in input. Used when the output is
-//                 a self-contained compaction envelope so referencing this
-//                 response via `previous_response_id` replays only the
-//                 retained messages + the encrypted compaction blob, not the
-//                 original full history.
-//
-// The mode is derived inside `wrapResponsesOutputForStorage` by observing the
-// output stream, so callers do not pass it. Skipping the snapshot entirely is
-// expressed at the store layer via an empty `snapshotWrites` configuration
-// (see `createNonResponsesSourceStore` and the `store=false` branch of
-// `createResponsesHttpStore`).
 export type ResponsesSnapshotMode = 'append' | 'replace';
 
 export interface StatefulResponsesStore {
-  readonly apiKeyId: string | null;
-  // Gates *durable* payload persistence specifically. When false (HTTP store=false),
-  // durable item rows are written metadata-only (null payload) and no snapshot is
-  // committed. WS session-scoped in-memory writes always retain full payloads
-  // regardless of this flag — they live for the WS lifetime only and never reach
-  // durable storage.
-  readonly shouldStorePayload: boolean;
+  readonly apiKeyId: string;
+  readonly writesState: boolean;
   loadSnapshot(id: string): Promise<StoredResponsesSnapshot | null>;
-  loadInputItems<TSourceItems>(options: {
-    readonly sourceItems: TSourceItems;
-    readonly view: Pick<ResponsesItemsView<TSourceItems>, 'visitAsResponsesItems'>;
-    readonly inputItemsToStage?: readonly ResponsesInputItem[];
-  }): Promise<void>;
-  getItemById(id: string): StoredResponsesItemMetadata | undefined;
-  getItemsByEncryptedContentHash(hash: string): StoredResponsesItemMetadata[];
+  loadInputItems(sourceItems: readonly ResponsesInputItem[], inputItemsToStage: readonly ResponsesInputItem[]): Promise<void>;
+  getItemById(id: string): StoredResponsesItem | undefined;
   hashItemContent(item: ResponsesInputItem): Promise<string>;
-  hashEncryptedContent(encryptedContent: string): Promise<string>;
-  clearItemHashes(): void;
-  loadItemPayloads(items: readonly StoredResponsesItemMetadata[]): Promise<ReadonlyMap<string, StoredResponsesItemPayload>>;
-  touchItem(id: string): void;
   stageInputItems(items: readonly ResponsesInputItem[]): Promise<void>;
-  beginAttempt(privatePayloads: ReadonlyMap<string, unknown>): void;
-  addSyntheticItem(id: string, privatePayload?: unknown): void;
-  isSyntheticItem(id: string): boolean;
-  getPrivatePayload(id: string): unknown;
-  stageOutputItem(row: StoredResponsesItem): void;
-  commitOutputItems(): Promise<void>;
+  stageOutputItem(row: StoredResponsesItem, outputIndex: number): void;
   commitSnapshot(responseId: string, mode: ResponsesSnapshotMode): Promise<void>;
-  refreshTouchedItems(): Promise<void>;
 }
 
 export class LayeredStatefulResponsesStore implements StatefulResponsesStore {
-  private readonly loadedItemsById = new Map<string, StoredResponsesItemMetadata>();
-  private readonly loadedItemsByContentHash = new Map<string, StoredResponsesItemMetadata[]>();
-  private readonly loadedItemsByEncryptedContentHash = new Map<string, StoredResponsesItemMetadata[]>();
-  private readonly payloadSourcesById = new Map<string, StatefulResponsesBacking>();
-  private readonly stagedPayloadsById = new Map<string, StoredResponsesItemPayload>();
-  private readonly privatePayload = new Map<string, unknown>();
-  private readonly syntheticItemIds = new Set<string>();
-  private readonly snapshotsById = new Map<string, StoredResponsesSnapshot>();
+  private readonly loadedItems = new Map<string, StoredResponsesItem>();
+  private readonly loadedByContentHash = new Map<string, StoredResponsesItem[]>();
   private readonly stagedInputItems = new Map<string, StoredResponsesItem>();
   private readonly stagedInputItemIds: string[] = [];
-  private previousSnapshotItemIds: string[] = [];
   private readonly stagedOutputItems = new Map<string, StoredResponsesItem>();
-  private readonly stagedOutputItemIds: string[] = [];
+  private readonly stagedOutputItemIds = new Map<number, string>();
+  private previousSnapshotItemIds: string[] = [];
   private readonly committedItemIds = new Set<string>();
-  private readonly payloadUpgradeIds = new Set<string>();
-  private readonly committedSnapshotIds = new Set<string>();
-  private readonly touchedItemIds = new Set<string>();
-  private readonly refreshedItemIds = new Set<string>();
-  private readonly durableItemIds = new Set<string>();
-
-  constructor(
-    private readonly options: LayeredStatefulResponsesStoreOptions,
-    private readonly hashes = new ResponsesItemHashCache(),
-  ) {}
-
-  get apiKeyId(): string | null {
-    return this.options.apiKeyId;
-  }
 
-  get shouldStorePayload(): boolean {
-    return this.options.shouldStorePayload !== false;
-  }
+  constructor(private readonly options: LayeredStatefulResponsesStoreOptions) {}
 
-  hashItemContent(item: ResponsesInputItem): Promise<string> {
-    return this.hashes.content(item);
+  get apiKeyId(): string {
+    return this.options.apiKeyId;
   }
 
-  hashEncryptedContent(encryptedContent: string): Promise<string> {
-    return this.hashes.encryptedContent(encryptedContent);
+  get writesState(): boolean {
+    return this.options.writes.length > 0;
   }
 
-  clearItemHashes(): void {
-    this.hashes.clear();
+  hashItemContent(item: ResponsesInputItem): Promise<string> {
+    return hashResponsesItemContent(item);
   }
 
   async loadSnapshot(id: string): Promise<StoredResponsesSnapshot | null> {
-    const cached = this.snapshotsById.get(id);
-    if (cached) {
-      this.previousSnapshotItemIds = [...cached.itemIds];
-      return cloneStoredResponsesSnapshot(cached);
-    }
-
     for (const backing of this.options.reads) {
-      const snapshot = await backing.lookupSnapshot(this.options.apiKeyId, id);
+      const snapshot = await backing.lookupSnapshot(this.apiKeyId, id);
       if (snapshot === null) continue;
-      await this.loadItems({ ids: snapshot.itemIds, contentHashes: [], encryptedContentHashes: [] });
-      if (!snapshot.itemIds.every(itemId => {
-        const row = this.loadedItemsById.get(itemId);
-        return row !== undefined && isReplayableSnapshotMetadata(row);
-      })) continue;
-      this.rememberSnapshot(snapshot);
+      await this.loadItems({ ids: snapshot.itemIds, contentHashes: [] });
+      if (!snapshot.itemIds.every(itemId => this.loadedItems.has(itemId))) continue;
+      if (this.options.writes.length > 0) {
+        const createdAt = Date.now();
+        const items = snapshot.itemIds.map(itemId => this.loadedItems.get(itemId)!);
+        await this.commitItems(items);
+        await Promise.all(this.options.writes.map(async write => {
+          await write.refreshItems(items, createdAt);
+          await write.insertSnapshot({ ...snapshot, createdAt });
+        }));
+        for (const item of items) item.createdAt = createdAt;
+        snapshot.createdAt = createdAt;
+      }
       this.previousSnapshotItemIds = [...snapshot.itemIds];
-      for (const itemId of snapshot.itemIds) this.touchedItemIds.add(itemId);
-      await Promise.all(this.options.snapshotWrites.map(write => write.backing.refreshSnapshot(this.options.apiKeyId, id, Date.now())));
       return cloneStoredResponsesSnapshot(snapshot);
     }
     return null;
   }
 
-  async loadInputItems<TSourceItems>(options: {
-    readonly sourceItems: TSourceItems;
-    readonly view: Pick<ResponsesItemsView<TSourceItems>, 'visitAsResponsesItems'>;
-    readonly inputItemsToStage?: readonly ResponsesInputItem[];
-  }): Promise<void> {
+  async loadInputItems(sourceItems: readonly ResponsesInputItem[], inputItemsToStage: readonly ResponsesInputItem[]): Promise<void> {
     const ids = new Set<string>();
-    const encryptedContents = new Set<string>();
-    await options.view.visitAsResponsesItems(options.sourceItems, item => {
+    for (const item of sourceItems) {
       const id = responsesItemId(item);
-      if (id !== null && isStoredResponsesItemId(id)) ids.add(id);
-      const encryptedContent = responsesItemEncryptedContent(item);
-      if (encryptedContent !== null) encryptedContents.add(encryptedContent);
-    });
-
+      if (id !== null && isResponsesItemId(id)) ids.add(id);
+    }
     const contentHashes = new Set<string>();
-    for (const item of options.inputItemsToStage ?? []) {
+    for (const item of inputItemsToStage) {
       const id = responsesItemId(item);
-      // A gateway-owned id is authoritative: affinity rejects it when the row
-      // is absent, while staging reuses or repairs that exact row. A content
-      // lookup cannot change either outcome.
-      if (id !== null && isStoredResponsesItemId(id)) continue;
+      if (id !== null && isResponsesItemId(id)) continue;
       contentHashes.add(await this.hashItemContent(item));
     }
-
-    const encryptedContentHashes = new Set<string>();
-    for (const encryptedContent of encryptedContents) encryptedContentHashes.add(await this.hashEncryptedContent(encryptedContent));
-
-    await this.loadItems({
-      ids: [...ids],
-      contentHashes: [...contentHashes],
-      encryptedContentHashes: [...encryptedContentHashes],
-    });
-  }
-
-  getItemById(id: string): StoredResponsesItemMetadata | undefined {
-    const row = this.loadedItemsById.get(id) ?? this.stagedInputItems.get(id) ?? this.stagedOutputItems.get(id);
-    if (row) this.touchItem(row.id);
-    return row ? cloneStoredResponsesItemMetadata('hasPayload' in row ? row : storedResponsesItemMetadata(row)) : undefined;
-  }
-
-  getItemsByEncryptedContentHash(hash: string): StoredResponsesItemMetadata[] {
-    return (this.loadedItemsByEncryptedContentHash.get(hash) ?? []).map(cloneStoredResponsesItemMetadata);
-  }
-
-  async loadItemPayloads(items: readonly StoredResponsesItemMetadata[]): Promise<ReadonlyMap<string, StoredResponsesItemPayload>> {
-    const payloads = new Map<string, StoredResponsesItemPayload>();
-    const groups = new Map<StatefulResponsesBacking, StoredResponsesItemMetadata[]>();
-    for (const item of items) {
-      if (!item.hasPayload || payloads.has(item.id)) continue;
-      const staged = this.stagedPayloadsById.get(item.id);
-      if (staged !== undefined) {
-        payloads.set(item.id, staged);
-        continue;
-      }
-      const source = this.payloadSourcesById.get(item.id);
-      if (source === undefined) throw new Error(`Stored Responses payload source missing for id=${item.id}`);
-      const rows = groups.get(source) ?? [];
-      rows.push(item);
-      groups.set(source, rows);
-    }
-    for (const [source, metadata] of groups) {
-      const records = await source.lookupPayloads(this.options.apiKeyId, metadata.map(item => item.id));
-      const byId = new Map(records.map(record => [record.id, record.payload]));
-      for (const item of metadata) {
-        const payload = byId.get(item.id);
-        if (payload === undefined) throw new Error(`Stored Responses payload disappeared during hydration for id=${item.id}`);
-        payloads.set(item.id, payload);
-      }
-    }
-    return payloads;
+    await this.loadItems({ ids: [...ids], contentHashes: [...contentHashes] });
   }
 
-  touchItem(id: string): void {
-    this.touchedItemIds.add(id);
+  getItemById(id: string): StoredResponsesItem | undefined {
+    const row = this.loadedItems.get(id) ?? this.stagedInputItems.get(id) ?? this.stagedOutputItems.get(id);
+    return row === undefined ? undefined : cloneStoredResponsesItem(row);
   }
 
   async stageInputItems(items: readonly ResponsesInputItem[]): Promise<void> {
@@ -254,90 +111,52 @@ export class LayeredStatefulResponsesStore implements StatefulResponsesStore {
     for (const item of items) await this.stageInputItem(item);
   }
 
-  beginAttempt(privatePayloads: ReadonlyMap<string, unknown>): void {
-    this.stagedOutputItems.clear();
-    this.stagedOutputItemIds.length = 0;
-    this.privatePayload.clear();
-    this.syntheticItemIds.clear();
-    for (const [wireId, payload] of privatePayloads) this.privatePayload.set(wireId, payload);
-  }
-
-  addSyntheticItem(id: string, privatePayload?: unknown): void {
-    this.syntheticItemIds.add(id);
-    if (privatePayload !== undefined) this.privatePayload.set(id, privatePayload);
-  }
-
-  isSyntheticItem(id: string): boolean {
-    return this.syntheticItemIds.has(id);
-  }
-
-  getPrivatePayload(id: string): unknown {
-    return this.privatePayload.get(id);
-  }
-
-  stageOutputItem(row: StoredResponsesItem): void {
+  stageOutputItem(row: StoredResponsesItem, outputIndex: number): void {
     const cloned = cloneStoredResponsesItem(row);
     this.stagedOutputItems.set(cloned.id, cloned);
-    this.stagedOutputItemIds.push(cloned.id);
+    this.stagedOutputItemIds.set(outputIndex, cloned.id);
     this.rememberItem(cloned);
   }
 
-  async commitOutputItems(): Promise<void> {
-    await this.commitItems([...this.stagedOutputItems.values()]);
-  }
-
   async commitSnapshot(responseId: string, mode: ResponsesSnapshotMode): Promise<void> {
-    if (this.options.snapshotWrites.length === 0 || this.committedSnapshotIds.has(responseId)) return;
-    await this.commitItems([...this.stagedInputItems.values(), ...this.stagedOutputItems.values()]);
+    if (this.options.writes.length === 0) return;
+    const outputItemIds = [...this.stagedOutputItemIds.entries()]
+      .toSorted(([left], [right]) => left - right)
+      .map(([, id]) => id);
     const itemIds = mode === 'replace'
-      ? [...this.stagedOutputItemIds]
-      : [...this.previousSnapshotItemIds, ...this.stagedInputItemIds, ...this.stagedOutputItemIds];
+      ? outputItemIds
+      : [...this.previousSnapshotItemIds, ...this.stagedInputItemIds, ...outputItemIds];
     if (itemIds.length === 0) return;
-
-    this.assertReplayableSnapshotItems(itemIds);
-    const now = Date.now();
+    const uniqueRows = [...new Set(itemIds)].map(id => {
+      const row = this.loadedItems.get(id);
+      if (row === undefined) throw new Error(`Responses snapshot item disappeared before commit: ${id}`);
+      return row;
+    });
+    await this.commitItems(uniqueRows);
+    const createdAt = Date.now();
+    await Promise.all(this.options.writes.map(write => write.refreshItems(uniqueRows, createdAt)));
+    for (const row of uniqueRows) row.createdAt = createdAt;
     const snapshot: StoredResponsesSnapshot = {
       id: responseId,
-      apiKeyId: this.options.apiKeyId,
+      apiKeyId: this.apiKeyId,
       itemIds,
-      createdAt: now,
-      refreshedAt: now,
+      createdAt,
     };
-    await Promise.all(this.options.snapshotWrites
-      .filter(write => !write.durable || itemIds.every(id => this.durableItemIds.has(id)))
-      .map(write => write.backing.insertSnapshot(snapshot)));
-    this.rememberSnapshot(snapshot);
-    this.committedSnapshotIds.add(responseId);
+    await Promise.all(this.options.writes.map(write => write.insertSnapshot(snapshot)));
   }
 
-  private async loadItems(query: { ids: readonly string[]; contentHashes: readonly string[]; encryptedContentHashes: readonly string[] }): Promise<void> {
-    let ids = query.ids.filter(id => !this.loadedItemsById.has(id));
-    const contentHashes = [...new Set(query.contentHashes)];
-    const encryptedContentHashes = [...new Set(query.encryptedContentHashes)];
-
+  private async loadItems(query: { ids: readonly string[]; contentHashes: readonly string[] }): Promise<void> {
+    let ids = query.ids.filter(id => !this.loadedItems.has(id));
     for (const backing of this.options.reads) {
-      if (ids.length === 0 && contentHashes.length === 0 && encryptedContentHashes.length === 0) return;
-      const results = await backing.lookupItems({
-        apiKeyId: this.options.apiKeyId,
-        ids,
-        contentHashes,
-        encryptedContentHashes,
-      });
-      for (const result of results) this.rememberItem(result.metadata, { durable: result.durable, source: backing });
-      ids = ids.filter(id => !this.loadedItemsById.has(id));
+      if (ids.length === 0 && query.contentHashes.length === 0) return;
+      const results = await backing.lookupItems({ apiKeyId: this.apiKeyId, ids, contentHashes: query.contentHashes });
+      for (const item of results) this.rememberItem(item);
+      ids = ids.filter(id => !this.loadedItems.has(id));
     }
   }
 
   private async stageInputItem(item: ResponsesInputItem): Promise<void> {
-    // `compaction_trigger` is a per-request control signal, not content:
-    // payload-free, idless, never persisted in codex's own rollout/history,
-    // and never re-sent on subsequent turns. The output of such a turn is a
-    // self-contained `compaction` envelope which wrap detects and commits as
-    // snapshot mode 'replace', so this row would have no reader. Skipping it
-    // also keeps `createStoredResponsesItemId` from minting a prefix for a
-    // type that never needs one.
     if (item.type === 'compaction_trigger') return;
-
     if (item.type === 'item_reference') {
       const row = this.getItemById(item.id);
       if (row === undefined) throw new Error(`Cannot stage unresolved Responses item_reference id=${item.id}`);
@@ -345,386 +164,154 @@ export class LayeredStatefulResponsesStore implements StatefulResponsesStore {
       return;
     }
 
-    const storedId = responsesItemId(item);
-    if (storedId !== null && isStoredResponsesItemId(storedId)) {
-      const row = this.getItemById(storedId);
+    const id = responsesItemId(item);
+    if (id !== null && isResponsesItemId(id)) {
+      const row = this.getItemById(id);
       if (row !== undefined) {
-        if (row.hasPayload) {
-          this.stagedInputItemIds.push(row.id);
-          return;
-        }
-        await this.stagePayloadUpgrade(row, item, responsesItemEncryptedContent(item));
-        return;
-      }
-    }
-
-    const encryptedContent = responsesItemEncryptedContent(item);
-    if (encryptedContent !== null) {
-      const row = this.getItemsByEncryptedContentHash(await this.hashEncryptedContent(encryptedContent))
-        .find(candidate => candidate.itemType === item.type);
-      if (row !== undefined) {
-        this.touchItem(row.id);
-        if (row.hasPayload) {
-          this.stagedInputItemIds.push(row.id);
-          return;
-        }
-        await this.stagePayloadUpgrade(row, item, encryptedContent);
+        this.stagedInputItemIds.push(row.id);
         return;
       }
     }
 
     const contentHash = await this.hashItemContent(item);
-    const existing = this.reusableItemByContentHash(contentHash);
-    if (existing) {
-      this.touchItem(existing.id);
+    const existing = this.loadedByContentHash.get(contentHash)?.[0];
+    if (existing !== undefined) {
       this.stagedInputItemIds.push(existing.id);
       return;
     }
 
-    const now = Date.now();
     const row: StoredResponsesItem = {
-      id: createStoredResponsesItemId(item.type),
-      apiKeyId: this.options.apiKeyId,
-      upstreamId: null,
-      upstreamItemId: null,
-      itemType: item.type,
-      origin: 'input',
+      id: createResponsesItemId(item.type),
+      apiKeyId: this.apiKeyId,
+      itemType: canonicalResponsesItemType(item.type),
       payload: { item: structuredClone(item) },
       contentHash,
-      encryptedContentHash: encryptedContent === null ? null : await this.hashEncryptedContent(encryptedContent),
-      createdAt: now,
-      refreshedAt: now,
+      createdAt: Date.now(),
     };
     this.stagedInputItems.set(row.id, row);
     this.stagedInputItemIds.push(row.id);
-    this.rememberItem(row, { durable: this.durableItemIds.has(row.id) });
+    this.rememberItem(row);
   }
 
-  private async stagePayloadUpgrade(row: StoredResponsesItemMetadata, item: ResponsesInputItem, encryptedContent: string | null): Promise<void> {
-    const now = Date.now();
-    const { hasPayload: _hasPayload, ...metadata } = row;
-    const upgraded: StoredResponsesItem = {
-      ...metadata,
-      payload: { item: structuredClone(item) },
-      contentHash: await this.hashItemContent(item),
-      encryptedContentHash: encryptedContent === null ? row.encryptedContentHash : await this.hashEncryptedContent(encryptedContent),
-      createdAt: now,
-      refreshedAt: now,
-    };
-    this.stagedInputItems.set(upgraded.id, upgraded);
-    this.payloadUpgradeIds.add(upgraded.id);
-    this.stagedInputItemIds.push(upgraded.id);
-    this.rememberItem(upgraded);
-  }
-
-  private reusableItemByContentHash(hash: string): StoredResponsesItemMetadata | undefined {
-    const staged = [...this.stagedInputItems.values(), ...this.stagedOutputItems.values()].find(row => row.contentHash === hash);
-    if (staged) return storedResponsesItemMetadata(staged);
-    return this.loadedItemsByContentHash.get(hash)?.find(row => row.hasPayload);
-  }
-
-  private rememberItem(
-    row: StoredResponsesItem | StoredResponsesItemMetadata,
-    options: { readonly durable?: boolean; readonly source?: StatefulResponsesBacking } = {},
-  ): void {
-    const metadata = cloneStoredResponsesItemMetadata('hasPayload' in row ? row : storedResponsesItemMetadata(row));
-    this.loadedItemsById.set(metadata.id, metadata);
-    // Full rows are already owned by this store: input/repair rows clone the
-    // caller item when constructed, and stageOutputItem clones its row before
-    // reaching here. Share that internal payload between the staging indexes;
-    // candidate rewrite clones the hydrated item before downstream mutation.
-    if (!('hasPayload' in row) && row.payload !== null) this.stagedPayloadsById.set(row.id, row.payload);
-    if (metadata.hasPayload && options.source !== undefined) this.payloadSourcesById.set(metadata.id, options.source);
-    if (options.durable === true) this.durableItemIds.add(metadata.id);
-    if (metadata.contentHash !== null) pushByHash(this.loadedItemsByContentHash, metadata.contentHash, metadata);
-    if (metadata.encryptedContentHash !== null) pushByHash(this.loadedItemsByEncryptedContentHash, metadata.encryptedContentHash, metadata);
-  }
-
-  private rememberSnapshot(snapshot: StoredResponsesSnapshot): void {
-    this.snapshotsById.set(snapshot.id, cloneStoredResponsesSnapshot(snapshot));
-  }
-
-  private assertReplayableSnapshotItems(itemIds: readonly string[]): void {
-    const seen = new Set<string>();
-    for (const id of itemIds) {
-      if (seen.has(id)) continue;
-      seen.add(id);
-      const row = this.loadedItemsById.get(id)
-        ?? (this.stagedInputItems.has(id) ? storedResponsesItemMetadata(this.stagedInputItems.get(id)!) : undefined)
-        ?? (this.stagedOutputItems.has(id) ? storedResponsesItemMetadata(this.stagedOutputItems.get(id)!) : undefined);
-      if (row === undefined || !isReplayableSnapshotMetadata(row)) {
-        throw new Error(`Cannot persist Responses snapshot with non-replayable item id=${id}`);
+  private rememberItem(row: StoredResponsesItem): void {
+    const cloned = cloneStoredResponsesItem(row);
+    this.loadedItems.set(cloned.id, cloned);
+    if (cloned.contentHash !== null) {
+      const byHash = this.loadedByContentHash.get(cloned.contentHash) ?? [];
+      if (!byHash.some(existing => existing.id === cloned.id)) {
+        byHash.push(cloned);
+        byHash.sort(compareResponsesItemsByFreshness);
+        this.loadedByContentHash.set(cloned.contentHash, byHash);
       }
     }
   }
 
   private async commitItems(rows: readonly StoredResponsesItem[]): Promise<void> {
     const pending = rows.filter(row => !this.committedItemIds.has(row.id));
-    if (pending.length > 0) {
-      await Promise.all(this.options.itemWrites.map(async write => {
-        const writable = write.durable ? pending.filter(row => this.needsDurableWrite(row)) : pending;
-        const payloadUpgrades = writable.filter(row => this.payloadUpgradeIds.has(row.id) && (!write.durable || this.durableItemIds.has(row.id)));
-        const inserts = writable.filter(row => !this.payloadUpgradeIds.has(row.id) || (write.durable && !this.durableItemIds.has(row.id)));
-        const operations: Promise<unknown>[] = [];
-        if (inserts.length > 0) operations.push(write.backing.insertItems(inserts, { durable: write.durable }));
-        if (payloadUpgrades.length > 0) operations.push(write.backing.fillPayloads(payloadUpgrades, { durable: write.durable }));
-        await Promise.all(operations);
-        if (write.durable) {
-          for (const row of writable) this.markDurable(row.apiKeyId, row.id);
-        }
-      }));
-      for (const row of pending) this.committedItemIds.add(row.id);
-    }
-    await this.refreshTouchedItems();
-  }
-
-  private needsDurableWrite(row: StoredResponsesItem): boolean {
-    return this.isDurableWriteEligible(row)
-      && (!this.durableItemIds.has(row.id) || this.payloadUpgradeIds.has(row.id));
-  }
-
-  private isDurableWriteEligible(row: StoredResponsesItem): boolean {
-    return this.durableItemIds.has(row.id)
-      || this.stagedInputItems.has(row.id)
-      || this.stagedOutputItems.has(row.id)
-      || this.payloadUpgradeIds.has(row.id);
-  }
-
-  private markDurable(apiKeyId: string | null, id: string): void {
-    this.durableItemIds.add(id);
-    for (const write of this.options.itemWrites) {
-      if (!write.durable) write.backing.markDurable?.(apiKeyId, id);
-    }
-  }
-
-  async refreshTouchedItems(): Promise<void> {
-    const ids = [...this.touchedItemIds].filter(id => !this.refreshedItemIds.has(id));
-    if (ids.length === 0) return;
-    const refreshedAt = Date.now();
-    await Promise.all(this.options.itemWrites.map(write => {
-      const writableIds = write.durable ? ids.filter(id => this.durableItemIds.has(id)) : ids;
-      return write.backing.refreshItems(this.options.apiKeyId, writableIds, refreshedAt);
-    }));
-    for (const id of ids) this.refreshedItemIds.add(id);
+    if (pending.length === 0) return;
+    await Promise.all(this.options.writes.map(async write => await write.insertItems(pending)));
+    for (const row of pending) this.committedItemIds.add(row.id);
   }
 }
 
 export class RepoStatefulResponsesBacking implements StatefulResponsesBacking {
   constructor(private readonly getRepo: () => Repo) {}
 
-  private get repo(): Repo {
-    return this.getRepo();
-  }
-
-  async lookupItems(query: StatefulResponsesItemLookup): Promise<StatefulResponsesItemLookupResult[]> {
-    const [byId, byContentHash, byEncryptedContentHash] = await Promise.all([
-      this.repo.responsesItems.lookupMany(query.apiKeyId, query.ids),
-      this.repo.responsesItems.lookupManyByContentHash(query.apiKeyId, query.contentHashes),
-      this.repo.responsesItems.lookupManyByEncryptedContentHash(query.apiKeyId, query.encryptedContentHashes),
+  async lookupItems(query: StatefulResponsesItemLookup): Promise<StoredResponsesItem[]> {
+    const [byId, byContentHash] = await Promise.all([
+      this.getRepo().responsesItems.lookupMany(query.apiKeyId, query.ids),
+      this.getRepo().responsesItems.lookupManyByContentHash(query.apiKeyId, query.contentHashes),
     ]);
-    const rowsByKey = new Map<string, StoredResponsesItemMetadata>();
-    for (const row of [...byId, ...byContentHash, ...byEncryptedContentHash]) {
-      rowsByKey.set(scopedKey(row.apiKeyId, row.id), cloneStoredResponsesItemMetadata(row));
-    }
-    return [...rowsByKey.values()].map(metadata => ({ metadata, durable: true }));
-  }
-
-  async lookupPayloads(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemPayloadRecord[]> {
-    return await this.repo.responsesItems.lookupPayloads(apiKeyId, ids);
+    const rows = new Map<string, StoredResponsesItem>();
+    for (const row of [...byId, ...byContentHash]) rows.set(scopedResponsesKey(row.apiKeyId, row.id), row);
+    return [...rows.values()];
   }
 
   async insertItems(items: readonly StoredResponsesItem[]): Promise<void> {
-    await this.repo.responsesItems.insertMany(items);
+    await this.getRepo().responsesItems.insertMany(items);
   }
 
-  async fillPayloads(items: readonly StoredResponsesItem[]): Promise<void> {
-    await this.repo.responsesItems.fillPayloads(items);
+  async refreshItems(items: readonly StoredResponsesItem[], createdAt: number): Promise<void> {
+    await this.getRepo().responsesItems.refreshMany(items, createdAt);
   }
 
-  async refreshItems(apiKeyId: string | null, ids: readonly string[], refreshedAt: number): Promise<void> {
-    await this.repo.responsesItems.refreshMany(apiKeyId, ids, refreshedAt);
-  }
-
-  async lookupSnapshot(apiKeyId: string | null, id: string): Promise<StoredResponsesSnapshot | null> {
-    return await this.repo.responsesSnapshots.lookup(apiKeyId, id);
+  async lookupSnapshot(apiKeyId: string, id: string): Promise<StoredResponsesSnapshot | null> {
+    return await this.getRepo().responsesSnapshots.lookup(apiKeyId, id);
   }
 
   async insertSnapshot(snapshot: StoredResponsesSnapshot): Promise<void> {
-    await this.repo.responsesSnapshots.insert(snapshot);
-  }
-
-  async refreshSnapshot(apiKeyId: string | null, id: string, refreshedAt: number): Promise<void> {
-    await this.repo.responsesSnapshots.refresh(apiKeyId, id, refreshedAt);
+    await this.getRepo().responsesSnapshots.insert(snapshot);
   }
 }
 
 export class MemoryStatefulResponsesBacking implements StatefulResponsesBacking {
-  private readonly items = new Map<string, { row: StoredResponsesItem; durable: boolean }>();
+  private readonly items = new Map<string, StoredResponsesItem>();
   private readonly snapshots = new Map<string, StoredResponsesSnapshot>();
 
-  lookupItems(query: StatefulResponsesItemLookup): Promise<StatefulResponsesItemLookupResult[]> {
+  lookupItems(query: StatefulResponsesItemLookup): Promise<StoredResponsesItem[]> {
     const ids = new Set(query.ids);
-    const contentHashes = new Set(query.contentHashes);
-    const encryptedContentHashes = new Set(query.encryptedContentHashes);
+    const hashes = new Set(query.contentHashes);
     return Promise.resolve([...this.items.values()]
-      .filter(({ row }) =>
-        row.apiKeyId === query.apiKeyId
-        && (
-          ids.has(row.id)
-          || (row.contentHash !== null && contentHashes.has(row.contentHash))
-          || (row.encryptedContentHash !== null && encryptedContentHashes.has(row.encryptedContentHash))
-        ))
-      .map(({ row, durable }) => ({ metadata: storedResponsesItemMetadata(row), durable }))
-      .toSorted((a, b) => compareItemsByFreshness(a.metadata, b.metadata)));
-  }
-
-  lookupPayloads(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemPayloadRecord[]> {
-    const records: StoredResponsesItemPayloadRecord[] = [];
-    for (const id of new Set(ids)) {
-      const row = this.items.get(scopedKey(apiKeyId, id))?.row;
-      if (row !== undefined && row.payload !== null) records.push({ id, payload: structuredClone(row.payload) });
-    }
-    return Promise.resolve(records);
+      .filter(row => row.apiKeyId === query.apiKeyId && (ids.has(row.id) || (row.contentHash !== null && hashes.has(row.contentHash))))
+      .map(cloneStoredResponsesItem)
+      .toSorted(compareResponsesItemsByFreshness));
   }
 
-  insertItems(items: readonly StoredResponsesItem[], options: { readonly durable: boolean }): Promise<void> {
+  insertItems(items: readonly StoredResponsesItem[]): Promise<void> {
     for (const item of items) {
-      const key = scopedKey(item.apiKeyId, item.id);
-      const existing = this.items.get(key);
-      if (existing) {
-        if (options.durable) existing.durable = true;
-        continue;
-      }
-      this.items.set(key, { row: cloneStoredResponsesItem(item), durable: options.durable });
+      const key = scopedResponsesKey(item.apiKeyId, item.id);
+      if (this.items.has(key)) continue;
+      this.items.set(key, cloneStoredResponsesItem(item));
     }
     return Promise.resolve();
   }
 
-  fillPayloads(items: readonly StoredResponsesItem[], options: { readonly durable: boolean }): Promise<void> {
-    for (const item of items) {
-      if (item.payload === null) continue;
-      const existing = this.items.get(scopedKey(item.apiKeyId, item.id));
-      if (existing?.row.payload !== null) continue;
-      existing.row = {
-        ...existing.row,
-        payload: structuredClone(item.payload),
-        contentHash: item.contentHash,
-        encryptedContentHash: item.encryptedContentHash,
-        createdAt: item.createdAt,
-        refreshedAt: Math.max(existing.row.refreshedAt, item.refreshedAt),
-      };
-      if (options.durable) existing.durable = true;
-    }
-    return Promise.resolve();
-  }
-
-  markDurable(apiKeyId: string | null, id: string): void {
-    const existing = this.items.get(scopedKey(apiKeyId, id));
-    if (existing) existing.durable = true;
-  }
-
-  refreshItems(apiKeyId: string | null, ids: readonly string[], refreshedAt: number): Promise<void> {
-    for (const id of new Set(ids)) {
-      const existing = this.items.get(scopedKey(apiKeyId, id));
-      if (existing && existing.row.refreshedAt < refreshedAt) {
-        existing.row = { ...existing.row, refreshedAt };
-      }
+  refreshItems(items: readonly StoredResponsesItem[], createdAt: number): Promise<void> {
+    const existing = items.map(item => this.items.get(scopedResponsesKey(item.apiKeyId, item.id)));
+    const missingIndex = existing.findIndex(item => item === undefined);
+    if (missingIndex !== -1) {
+      return Promise.reject(new Error(`Responses item disappeared before lifetime refresh: ${items[missingIndex].id}`));
     }
+    for (const item of existing) item!.createdAt = createdAt;
     return Promise.resolve();
   }
 
-  lookupSnapshot(apiKeyId: string | null, id: string): Promise<StoredResponsesSnapshot | null> {
-    const snapshot = this.snapshots.get(scopedKey(apiKeyId, id));
-    return Promise.resolve(snapshot ? cloneStoredResponsesSnapshot(snapshot) : null);
+  lookupSnapshot(apiKeyId: string, id: string): Promise<StoredResponsesSnapshot | null> {
+    const snapshot = this.snapshots.get(scopedResponsesKey(apiKeyId, id));
+    return Promise.resolve(snapshot === undefined ? null : cloneStoredResponsesSnapshot(snapshot));
   }
 
   insertSnapshot(snapshot: StoredResponsesSnapshot): Promise<void> {
-    const key = scopedKey(snapshot.apiKeyId, snapshot.id);
-    this.snapshots.set(key, cloneStoredResponsesSnapshot(snapshot));
-    return Promise.resolve();
-  }
-
-  refreshSnapshot(apiKeyId: string | null, id: string, refreshedAt: number): Promise<void> {
-    const key = scopedKey(apiKeyId, id);
-    const snapshot = this.snapshots.get(key);
-    if (snapshot && snapshot.refreshedAt < refreshedAt) {
-      this.snapshots.set(key, { ...snapshot, refreshedAt });
-    }
+    this.snapshots.set(scopedResponsesKey(snapshot.apiKeyId, snapshot.id), cloneStoredResponsesSnapshot(snapshot));
     return Promise.resolve();
   }
 }
 
-// For Messages/Chat/Gemini HTTP entries — reads for affinity, writes result item metadata,
-// no snapshot writes, no user-controlled store flag.
-export const createNonResponsesSourceStore = (apiKeyId: string | null): StatefulResponsesStore =>
-  new LayeredStatefulResponsesStore({
-    apiKeyId,
-    reads: [new RepoStatefulResponsesBacking(getRepo)],
-    itemWrites: [{ backing: new RepoStatefulResponsesBacking(getRepo), durable: true }],
-    snapshotWrites: [],
-    stageInputs: false,
-  });
-
-// For Responses HTTP entry — honors the user-supplied store=true/false.
-export const createResponsesHttpStore = (apiKeyId: string | null, store: boolean | undefined): StatefulResponsesStore =>
-  new LayeredStatefulResponsesStore({
+export const createResponsesHttpStore = (apiKeyId: string, store: boolean | undefined): StatefulResponsesStore => {
+  const backing = new RepoStatefulResponsesBacking(getRepo);
+  const writes = store === false ? [] : [backing];
+  return new LayeredStatefulResponsesStore({
     apiKeyId,
-    reads: [new RepoStatefulResponsesBacking(getRepo)],
-    itemWrites: [{ backing: new RepoStatefulResponsesBacking(getRepo), durable: true }],
-    snapshotWrites: store === false ? [] : [{ backing: new RepoStatefulResponsesBacking(getRepo), durable: true }],
+    reads: [backing],
+    writes,
     stageInputs: store !== false,
-    shouldStorePayload: store !== false,
   });
+};
 
-// For Responses WebSocket entry — session-scoped layered store.
-//
-// `store=false` on a WS message disables the durable backing for that turn but
-// still records full items and snapshots in the session-scoped in-memory layer,
-// so subsequent messages on the same socket can resolve `previous_response_id`
-// against them. The session's lifetime bounds the data — nothing persists beyond
-// the socket. `store=true` (or omitted) layers durable repo writes on top of the
-// in-memory layer, so the turn is also addressable from later sessions.
-//
-// The session owns only the pair of backings that persist across turns; the
-// per-turn `apiKeyId` is passed into `createStore` by the caller (which sources
-// it from `ctx.apiKeyId`), keeping apiKeyId ownership on the ctx.
 export const createResponsesWsSession = (): {
-  createStore(apiKeyId: string | null, store: boolean | undefined): StatefulResponsesStore;
+  createStore(apiKeyId: string, store: boolean | undefined): StatefulResponsesStore;
 } => {
-  const localBacking = new MemoryStatefulResponsesBacking();
-  const repoBacking = new RepoStatefulResponsesBacking(getRepo);
+  const local = new MemoryStatefulResponsesBacking();
+  const durable = new RepoStatefulResponsesBacking(getRepo);
   return {
-    createStore(apiKeyId: string | null, store: boolean | undefined): StatefulResponsesStore {
-      const localWrite = { backing: localBacking, durable: false };
-      if (store === false) {
-        return new LayeredStatefulResponsesStore({
-          apiKeyId,
-          reads: [localBacking, repoBacking],
-          itemWrites: [localWrite],
-          snapshotWrites: [localWrite],
-          stageInputs: true,
-        });
-      }
-      const repoWrite = { backing: repoBacking, durable: true };
+    createStore(apiKeyId: string, store: boolean | undefined): StatefulResponsesStore {
+      const writes = store === false ? [local] : [local, durable];
       return new LayeredStatefulResponsesStore({
         apiKeyId,
-        reads: [localBacking, repoBacking],
-        itemWrites: [localWrite, repoWrite],
-        snapshotWrites: [localWrite, repoWrite],
+        reads: [local, durable],
+        writes,
         stageInputs: true,
       });
     },
   };
 };
-
-const pushByHash = (target: Map<string, StoredResponsesItemMetadata[]>, hash: string, row: StoredResponsesItemMetadata): void => {
-  const rows = target.get(hash) ?? [];
-  if (!rows.some(existing => existing.id === row.id && existing.apiKeyId === row.apiKeyId)) {
-    rows.push(row);
-    rows.sort(compareItemsByFreshness);
-  }
-  target.set(hash, rows);
-};
-
-const isReplayableSnapshotMetadata = (row: StoredResponsesItemMetadata): boolean =>
-  row.hasPayload || (row.upstreamId !== null && row.upstreamItemId !== null);
diff --git a/packages/gateway/src/data-plane/chat/responses/items/store_identity_test.ts b/packages/gateway/src/data-plane/chat/responses/items/store_identity_test.ts
deleted file mode 100644
index 1714026f4..000000000
--- a/packages/gateway/src/data-plane/chat/responses/items/store_identity_test.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import { test } from 'vitest';
-
-import { createStoredResponsesItemId } from './format.ts';
-import { createResponsesHttpStore, type StatefulResponsesStore } from './store.ts';
-import { initRepo } from '../../../../repo/index.ts';
-import { InMemoryRepo } from '../../../../repo/memory.ts';
-import type { StoredResponsesItem } from '../../../../repo/types.ts';
-import type { ResponsesInputItem } from '@floway-dev/protocols/responses';
-import { assert, assertEquals, assertExists } from '@floway-dev/test-utils';
-import { responsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
-
-const API_KEY_ID = 'key_responses_item_identity';
-
-const loadAndStage = async (store: StatefulResponsesStore, input: readonly ResponsesInputItem[]): Promise<void> => {
-  await store.loadInputItems({
-    sourceItems: input,
-    view: responsesItemsView,
-    inputItemsToStage: input,
-  });
-  await store.stageInputItems(input);
-};
-
-test('changed input payload with a stable client id persists as a distinct input row', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const first: ResponsesInputItem = { type: 'message', id: 'client_message_1', role: 'user', content: 'first' };
-  const second: ResponsesInputItem = { type: 'message', id: 'client_message_1', role: 'user', content: 'second' };
-
-  const firstStore = createResponsesHttpStore(API_KEY_ID, true);
-  await loadAndStage(firstStore, [first]);
-  await firstStore.commitSnapshot('resp_first', 'append');
-
-  const secondStore = createResponsesHttpStore(API_KEY_ID, true);
-  await loadAndStage(secondStore, [second]);
-  await secondStore.commitSnapshot('resp_second', 'append');
-
-  const firstSnapshot = await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_first');
-  const secondSnapshot = await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_second');
-  assertExists(firstSnapshot);
-  assertExists(secondSnapshot);
-  assertEquals(firstSnapshot.itemIds.length, 1);
-  assertEquals(secondSnapshot.itemIds.length, 1);
-  assert(firstSnapshot.itemIds[0] !== secondSnapshot.itemIds[0]);
-  const rows = await repo.responsesItems.lookupMany(API_KEY_ID, [firstSnapshot.itemIds[0]!, secondSnapshot.itemIds[0]!]);
-  const payloads = await repo.responsesItems.lookupPayloads(API_KEY_ID, [firstSnapshot.itemIds[0]!, secondSnapshot.itemIds[0]!]);
-  assertEquals(rows.map(row => row.origin), ['input', 'input']);
-  assertEquals(payloads.map(record => record.payload.item), [first, second]);
-});
-
-test('metadata-only durable item accepts a full payload repair', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const item: StoredResponsesItem = {
-    id: createStoredResponsesItemId('message'),
-    apiKeyId: API_KEY_ID,
-    upstreamId: 'up_responses',
-    upstreamItemId: 'raw_message_1',
-    itemType: 'message',
-    origin: 'upstream',
-    payload: null,
-    contentHash: null,
-    encryptedContentHash: null,
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-  };
-  await repo.responsesItems.insertMany([item]);
-  const input: ResponsesInputItem = { type: 'message', id: item.id, role: 'assistant', content: 'repaired' };
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-
-  await loadAndStage(store, [input]);
-  await store.commitSnapshot('resp_repaired', 'append');
-
-  const [repaired] = await repo.responsesItems.lookupMany(API_KEY_ID, [item.id]);
-  const [payload] = await repo.responsesItems.lookupPayloads(API_KEY_ID, [item.id]);
-  assertExists(repaired);
-  assertEquals(repaired.origin, 'upstream');
-  assertEquals(payload.payload.item, input);
-  const snapshot = await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_repaired');
-  assertExists(snapshot);
-  assertEquals(snapshot.itemIds, [item.id]);
-});
diff --git a/packages/gateway/src/data-plane/chat/responses/items/store_test.ts b/packages/gateway/src/data-plane/chat/responses/items/store_test.ts
index 1e5a2b221..538524b64 100644
--- a/packages/gateway/src/data-plane/chat/responses/items/store_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/items/store_test.ts
@@ -1,307 +1,180 @@
-import { test, vi } from 'vitest';
+import { describe, expect, test } from 'vitest';
 
-import { createStoredResponsesItemId } from './format.ts';
-import { createNonResponsesSourceStore, createResponsesHttpStore } from './store.ts';
+import { createResponsesHttpStore, createResponsesWsSession } from './store.ts';
 import { initRepo } from '../../../../repo/index.ts';
 import { InMemoryRepo } from '../../../../repo/memory.ts';
-import type { StoredResponsesItem } from '../../../../repo/types.ts';
-import type { ResponsesInputItem } from '@floway-dev/protocols/responses';
-import { assert, assertEquals, assertExists } from '@floway-dev/test-utils';
-import { responsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
-
-const API_KEY_ID = 'key_stateful_store';
-
-const storedRow = (overrides: Partial<StoredResponsesItem> & Pick<StoredResponsesItem, 'id' | 'itemType'>): StoredResponsesItem => ({
-  apiKeyId: API_KEY_ID,
-  upstreamId: null,
-  upstreamItemId: null,
-  origin: 'upstream',
-  payload: { item: { type: overrides.itemType, id: overrides.id } },
-  contentHash: null,
-  encryptedContentHash: null,
-  createdAt: 1_000,
-  refreshedAt: 1_000,
-  ...overrides,
-});
-
-test('stages programmatic tool items with their documented id prefixes and preserves every field', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const input: ResponsesInputItem[] = [
-    {
-      type: 'additional_tools',
-      role: 'developer',
-      tools: [{ type: 'custom', name: 'exec', format: { type: 'text' } }],
-    },
-    {
-      type: 'program',
-      id: 'program_input_1',
-      call_id: 'program_call_1',
-      code: 'await exec("hello")',
-      fingerprint: 'opaque-fingerprint',
-    },
-    {
-      type: 'program_output',
-      id: 'program_output_input_1',
-      call_id: 'program_call_1',
-      result: 'hello',
-      status: 'completed',
-    },
-  ];
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-
-  await store.stageInputItems(input);
-  await store.commitSnapshot('resp_programmatic', 'append');
-
-  const snapshot = await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_programmatic');
-  assertExists(snapshot);
-  assertEquals(snapshot.itemIds.length, 3);
-  assert(snapshot.itemIds[0].startsWith('at_'));
-  assert(snapshot.itemIds[1].startsWith('prog_'));
-  assert(snapshot.itemIds[2].startsWith('prog_out_'));
-  const payloads = await repo.responsesItems.lookupPayloads(API_KEY_ID, snapshot.itemIds);
-  assertEquals(payloads.map(record => record.payload.item), input);
-});
-
-test('stages agent and context-compaction items with stable prefixes and preserves every field', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const input: ResponsesInputItem[] = [
-    { type: 'agent_message', author: '/root/a', recipient: '/root', content: [{ type: 'input_text', text: 'done' }] },
-    { type: 'multi_agent_call', action: 'spawn_agent', arguments: '{}', call_id: 'call_1' },
-    { type: 'multi_agent_call_output', action: 'spawn_agent', call_id: 'call_1', output: [] },
-    { type: 'context_compaction', encrypted_content: 'opaque' },
-  ];
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-
-  await store.stageInputItems(input);
-  await store.commitSnapshot('resp_agents', 'append');
-
-  const snapshot = await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_agents');
-  assertExists(snapshot);
-  assertEquals(snapshot.itemIds.map(id => id.slice(0, id.indexOf('_'))), ['amsg', 'mac', 'maco', 'cmp']);
-  const payloads = await repo.responsesItems.lookupPayloads(API_KEY_ID, snapshot.itemIds);
-  assertEquals(payloads.map(record => record.payload.item), input);
-});
-
-test('staged input payload ownership is isolated from later caller mutation', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const input: ResponsesInputItem[] = [{
-    type: 'message',
-    role: 'user',
-    content: [{ type: 'input_text', text: 'before' }],
-  }];
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-
-  await store.stageInputItems(input);
-  (input[0] as { content: Array<{ text: string }> }).content[0]!.text = 'after';
-  await store.commitSnapshot('resp_input_owner', 'append');
-
-  const snapshot = await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_input_owner');
-  assertExists(snapshot);
-  const [payload] = await repo.responsesItems.lookupPayloads(API_KEY_ID, snapshot.itemIds);
-  assertExists(payload);
-  assertEquals((payload.payload.item as { content: Array<{ text: string }> }).content[0]!.text, 'before');
-});
-
-test('staged output payload ownership is isolated from later caller mutation', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const output = storedRow({
-    id: createStoredResponsesItemId('message'),
-    itemType: 'message',
-    origin: 'upstream',
-    payload: {
-      item: { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'before' }] },
-    },
+import { ResponsesAttemptState } from '../attempt-state.ts';
+
+describe('StatefulResponsesStore', () => {
+  test('HTTP store=false performs no state writes', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const store = createResponsesHttpStore('key-a', false);
+    expect(store.writesState).toBe(false);
+
+    await store.stageInputItems([{ type: 'message', role: 'user', content: 'hello' }]);
+    await store.commitSnapshot('resp_none', 'append');
+    expect(await repo.responsesSnapshots.lookup('key-a', 'resp_none')).toBeNull();
   });
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-
-  store.beginAttempt(new Map());
-  store.stageOutputItem(output);
-  ((output.payload!.item as { content: Array<{ text: string }> }).content[0]!).text = 'after';
-  await store.commitOutputItems();
-
-  const [payload] = await repo.responsesItems.lookupPayloads(API_KEY_ID, [output.id]);
-  assertExists(payload);
-  assertEquals((payload.payload.item as { content: Array<{ text: string }> }).content[0]!.text, 'before');
-});
-
-test('content-hash preload skips items already addressed by a stored id', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const lookupByContentHash = vi.spyOn(repo.responsesItems, 'lookupManyByContentHash');
-  const storedId = createStoredResponsesItemId('message');
-  const input: ResponsesInputItem[] = [
-    { type: 'message', id: storedId, role: 'assistant', content: 'stored' },
-    { type: 'message', id: 'client-message', role: 'user', content: 'new' },
-  ];
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-
-  await store.loadInputItems({ sourceItems: input, view: responsesItemsView, inputItemsToStage: input });
-
-  assertEquals(lookupByContentHash.mock.calls.length, 1);
-  assertEquals(lookupByContentHash.mock.calls[0][1].length, 1);
-});
 
-test('snapshots with non-replayable metadata-only rows load as missing', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const missingPayload = storedRow({
-    id: createStoredResponsesItemId('message'),
-    itemType: 'message',
-    origin: 'input',
-    payload: null,
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-  });
-  await repo.responsesItems.insertMany([missingPayload]);
-  await repo.responsesSnapshots.insert({
-    id: 'resp_expired',
-    apiKeyId: API_KEY_ID,
-    itemIds: [missingPayload.id],
-    createdAt: 1_000,
-    refreshedAt: 1_000,
+  test('HTTP default stores complete input and output snapshots', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const store = createResponsesHttpStore('key-a', undefined);
+    await store.stageInputItems([{ type: 'message', role: 'user', content: 'hello' }]);
+    const output = {
+      id: 'msg_public',
+      apiKeyId: 'key-a',
+      itemType: 'message',
+      payload: { item: { type: 'message', id: 'msg_public', role: 'assistant', content: [] } },
+      contentHash: 'output-hash',
+      createdAt: 1_000,
+    };
+    store.stageOutputItem(output, 0);
+    await store.commitSnapshot('resp_saved', 'append');
+
+    const snapshot = await repo.responsesSnapshots.lookup('key-a', 'resp_saved');
+    expect(snapshot?.itemIds).toHaveLength(2);
+    const [storedOutput] = await repo.responsesItems.lookupMany('key-a', [output.id]);
+    expect(storedOutput).toMatchObject({ ...output, createdAt: snapshot?.createdAt });
   });
 
-  const store = createResponsesHttpStore(API_KEY_ID, undefined);
-
-  assertEquals(await store.loadSnapshot('resp_expired'), null);
-});
-
-test('snapshots with upstream-owned metadata-only rows remain replayable', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const upstreamOwned = storedRow({
-    id: createStoredResponsesItemId('reasoning'),
-    itemType: 'reasoning',
-    upstreamId: 'up_a',
-    upstreamItemId: 'raw_rs_a',
-    payload: null,
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-  });
-  await repo.responsesItems.insertMany([upstreamOwned]);
-  await repo.responsesSnapshots.insert({
-    id: 'resp_metadata',
-    apiKeyId: API_KEY_ID,
-    itemIds: [upstreamOwned.id],
-    createdAt: 1_000,
-    refreshedAt: 1_000,
+  test('replace snapshots persist only their output state', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const store = createResponsesHttpStore('key-a', true);
+    const input = { type: 'message' as const, role: 'user' as const, content: 'discarded history' };
+    await store.stageInputItems([input]);
+    const output = {
+      id: 'cmp_public',
+      apiKeyId: 'key-a',
+      itemType: 'compaction',
+      payload: { item: { type: 'compaction', id: 'cmp_public', encrypted_content: 'opaque' } },
+      contentHash: 'output-hash',
+      createdAt: 1_000,
+    };
+    store.stageOutputItem(output, 0);
+    await store.commitSnapshot('resp_compact', 'replace');
+
+    expect(await repo.responsesItems.lookupManyByContentHash('key-a', [await store.hashItemContent(input)])).toEqual([]);
+    expect((await repo.responsesSnapshots.lookup('key-a', 'resp_compact'))?.itemIds).toEqual([output.id]);
   });
 
-  const store = createResponsesHttpStore(API_KEY_ID, undefined);
-  const snapshot = await store.loadSnapshot('resp_metadata');
-
-  assertExists(snapshot);
-  assertEquals(snapshot.itemIds, [upstreamOwned.id]);
-});
-
-test('createNonResponsesSourceStore reads items for affinity but does not write snapshots', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const item = storedRow({
-    id: createStoredResponsesItemId('message'),
-    itemType: 'message',
-    upstreamId: 'up_a',
-    upstreamItemId: 'raw_msg_a',
-    createdAt: 1_000,
-    refreshedAt: 1_000,
+  test('stages compaction_summary metadata under its canonical item type', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const store = createResponsesHttpStore('key-a', true);
+    const item = { type: 'compaction_summary', id: 'cmp_client', encrypted_content: 'opaque' } as unknown as Parameters<typeof store.stageInputItems>[0][number];
+    await store.stageInputItems([item]);
+    await store.commitSnapshot('resp_summary', 'append');
+
+    const snapshot = await repo.responsesSnapshots.lookup('key-a', 'resp_summary');
+    expect(snapshot).not.toBeNull();
+    const rows = await repo.responsesItems.lookupMany('key-a', snapshot?.itemIds ?? []);
+    expect(rows[0].itemType).toBe('compaction');
   });
-  await repo.responsesItems.insertMany([item]);
-
-  const store = createNonResponsesSourceStore(API_KEY_ID);
-
-  // Items are still readable for affinity lookups.
-  const input = [{ type: 'message', id: item.id, role: 'assistant', content: [] }] as unknown as ResponsesInputItem[];
-  await store.loadInputItems({ sourceItems: input, view: responsesItemsView });
-  assertExists(store.getItemById(item.id));
 
-  // commitSnapshot is a no-op when snapshotWrites is empty.
-  const outputItem: StoredResponsesItem = {
-    ...item,
-    id: createStoredResponsesItemId('message'),
-    origin: 'upstream',
-    payload: { item: { type: 'message', id: 'out_1', role: 'assistant', content: [] } },
-  };
-  store.beginAttempt(new Map());
-  store.stageOutputItem(outputItem);
-  await store.commitOutputItems();
-  await store.commitSnapshot('resp_new', 'append');
-
-  // No snapshot was written because snapshotWrites is empty for non-Responses sources.
-  assertEquals(await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_new'), null);
-});
-
-test('createResponsesHttpStore with store=false does not write snapshots', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-
-  const store = createResponsesHttpStore(API_KEY_ID, false);
-  const outputItem: StoredResponsesItem = storedRow({
-    id: createStoredResponsesItemId('message'),
-    itemType: 'message',
-    origin: 'upstream',
+  test('append snapshots refresh the lifetime of every referenced item', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const item = {
+      id: 'msg_old',
+      apiKeyId: 'key-a',
+      itemType: 'message',
+      payload: { item: { type: 'message', id: 'msg_old', role: 'assistant', content: [] } },
+      contentHash: 'old-hash',
+      createdAt: 1,
+    };
+    await repo.responsesItems.insertMany([item]);
+    await repo.responsesSnapshots.insert({ id: 'resp_old', apiKeyId: 'key-a', itemIds: [item.id], createdAt: 1 });
+    const store = createResponsesHttpStore('key-a', true);
+    expect(await store.loadSnapshot('resp_old')).not.toBeNull();
+    await repo.responsesItems.deleteOlderThan(2);
+    await repo.responsesSnapshots.deleteOlderThan(2);
+    expect(await repo.responsesItems.lookupMany('key-a', [item.id])).toHaveLength(1);
+    expect(await repo.responsesSnapshots.lookup('key-a', 'resp_old')).not.toBeNull();
+    await store.commitSnapshot('resp_new', 'append');
+
+    const [refreshed] = await repo.responsesItems.lookupMany('key-a', [item.id]);
+    expect(refreshed.createdAt).toBeGreaterThan(1);
+    expect((await repo.responsesSnapshots.lookup('key-a', 'resp_new'))?.itemIds).toEqual([item.id]);
+    await repo.responsesItems.deleteOlderThan(2);
+    expect(await repo.responsesItems.lookupMany('key-a', [item.id])).toHaveLength(1);
   });
-  store.beginAttempt(new Map());
-  store.stageOutputItem(outputItem);
-  await store.commitOutputItems();
-  await store.commitSnapshot('resp_no_store', 'append');
-
-  assertEquals(await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_no_store'), null);
-});
 
-test('createResponsesHttpStore with store=true writes snapshots', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-  const outputItem: StoredResponsesItem = storedRow({
-    id: createStoredResponsesItemId('message'),
-    itemType: 'message',
-    origin: 'upstream',
-    upstreamId: 'up_snap',
-    upstreamItemId: 'raw_snap',
-    payload: { item: { type: 'message', id: 'snap_1', role: 'assistant', content: [] } },
+  test('append snapshots refresh direct-id and content-hash input reuse', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const store = createResponsesHttpStore('key-a', true);
+    const directInput = { type: 'message' as const, id: 'msg_direct', role: 'user' as const, content: 'direct' };
+    const hashedInput = { type: 'message' as const, role: 'user' as const, content: 'hashed' };
+    const directRow = {
+      id: directInput.id,
+      apiKeyId: 'key-a',
+      itemType: 'message',
+      payload: { item: directInput },
+      contentHash: await store.hashItemContent(directInput),
+      createdAt: 1,
+    };
+    const hashedRow = {
+      id: 'msg_hashed',
+      apiKeyId: 'key-a',
+      itemType: 'message',
+      payload: { item: hashedInput },
+      contentHash: await store.hashItemContent(hashedInput),
+      createdAt: 1,
+    };
+    await repo.responsesItems.insertMany([directRow, hashedRow]);
+    await store.loadInputItems([directInput, hashedInput], [directInput, hashedInput]);
+    await store.stageInputItems([directInput, hashedInput]);
+    await store.commitSnapshot('resp_reused', 'append');
+
+    const refreshed = await repo.responsesItems.lookupMany('key-a', [directRow.id, hashedRow.id]);
+    expect(refreshed.every(row => row.createdAt > 1)).toBe(true);
+    expect((await repo.responsesSnapshots.lookup('key-a', 'resp_reused'))?.itemIds).toEqual([directRow.id, hashedRow.id]);
   });
-  store.beginAttempt(new Map());
-  store.stageOutputItem(outputItem);
-  await store.commitOutputItems();
-  await store.commitSnapshot('resp_with_store', 'append');
-
-  const snapshot = await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_with_store');
-  assertExists(snapshot);
-  assertEquals(snapshot.itemIds, [outputItem.id]);
-});
 
-test('committing a snapshot refreshes durable history without rewriting it', async () => {
-  const repo = new InMemoryRepo();
-  initRepo(repo);
-  const itemId = createStoredResponsesItemId('message');
-  const inputItem: ResponsesInputItem = { type: 'message', id: itemId, role: 'assistant', content: [] };
-  const item = storedRow({
-    id: itemId,
-    itemType: 'message',
-    upstreamId: 'up_history',
-    upstreamItemId: 'raw_history',
-    payload: { item: inputItem },
+  test('WebSocket store=false retains socket-local state only', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const session = createResponsesWsSession();
+    const first = session.createStore('key-a', false);
+    expect(first.writesState).toBe(true);
+    await first.stageInputItems([{ type: 'message', role: 'user', content: 'hello' }]);
+    await first.commitSnapshot('resp_local', 'append');
+
+    expect(await repo.responsesSnapshots.lookup('key-a', 'resp_local')).toBeNull();
+    expect(await session.createStore('key-a', false).loadSnapshot('resp_local')).not.toBeNull();
   });
-  await repo.responsesItems.insertMany([item]);
-  const insertMany = vi.spyOn(repo.responsesItems, 'insertMany');
-  const refreshMany = vi.spyOn(repo.responsesItems, 'refreshMany');
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-  const input = [inputItem];
 
-  await store.loadInputItems({ sourceItems: input, view: responsesItemsView });
-  await store.stageInputItems(input);
-  await store.commitSnapshot('resp_history', 'append');
+  test('WebSocket store=true promotes every item referenced by a prior local snapshot', async () => {
+    const repo = new InMemoryRepo();
+    initRepo(repo);
+    const session = createResponsesWsSession();
+    const local = session.createStore('key-a', false);
+    await local.stageInputItems([{ type: 'message', role: 'user', content: 'local' }]);
+    await local.commitSnapshot('resp_local', 'append');
+
+    const durable = session.createStore('key-a', true);
+    expect(await durable.loadSnapshot('resp_local')).not.toBeNull();
+    await durable.stageInputItems([{ type: 'message', role: 'user', content: 'durable' }]);
+    await durable.commitSnapshot('resp_durable', 'append');
+
+    const snapshot = await repo.responsesSnapshots.lookup('key-a', 'resp_durable');
+    expect(snapshot).not.toBeNull();
+    if (snapshot === null) throw new Error('Expected durable snapshot');
+    expect(await repo.responsesItems.lookupMany('key-a', snapshot.itemIds)).toHaveLength(snapshot.itemIds.length);
+  });
 
-  assertEquals(insertMany.mock.calls, []);
-  assertEquals(refreshMany.mock.calls.length, 1);
-  assertEquals(refreshMany.mock.calls[0]![0], API_KEY_ID);
-  assertEquals(refreshMany.mock.calls[0]![1], [item.id]);
-  const snapshot = await repo.responsesSnapshots.lookup(API_KEY_ID, 'resp_history');
-  assertExists(snapshot);
-  assertEquals(snapshot.itemIds, [item.id]);
+  test('attempt-private payload is request scoped', () => {
+    initRepo(new InMemoryRepo());
+    const state = new ResponsesAttemptState();
+    state.begin(new Map([['item', { first: true }]]), new Map([['item', 'item_upstream']]));
+    state.setPrivatePayload('second', { value: 2 });
+    expect(state.getPrivatePayload('item')).toBeUndefined();
+    expect(state.getPrivatePayload('item_upstream')).toEqual({ first: true });
+    expect(state.getPrivatePayload('second')).toEqual({ value: 2 });
+    state.begin(new Map(), new Map());
+    expect(state.getPrivatePayload('item_upstream')).toBeUndefined();
+  });
 });
diff --git a/packages/gateway/src/data-plane/chat/responses/respond.ts b/packages/gateway/src/data-plane/chat/responses/respond.ts
index d78d1c834..07349d0ae 100644
--- a/packages/gateway/src/data-plane/chat/responses/respond.ts
+++ b/packages/gateway/src/data-plane/chat/responses/respond.ts
@@ -1,10 +1,13 @@
 import type { Context } from 'hono';
 import { streamSSE } from 'hono/streaming';
 
+import { wrapResponsesAffinityEgress } from './affinity/egress.ts';
+import { createResponsesResponseId } from './items/format.ts';
+import { wrapResponsesClientOutput } from './items/output.ts';
 import { tokenUsageFromResponsesResult } from './usage.ts';
 import { recordFailedRequest } from '../../shared/telemetry/performance.ts';
 import { settle } from '../../shared/telemetry/settle.ts';
-import type { GatewayCtx } from '../shared/gateway-ctx.ts';
+import type { ChatGatewayCtx, GatewayCtx } from '../shared/gateway-ctx.ts';
 import { SourceStreamState, eventResultMetadata, forwardUpstreamHeaders, mergeForwardedUpstreamHeaders, plainResultToResponse } from '../shared/respond.ts';
 import { type StreamCompletion, writeSSEFrames } from '../shared/stream/sse.ts';
 import { type ProtocolFrame, sseCommentFrame, sseFrame } from '@floway-dev/protocols/common';
@@ -16,35 +19,35 @@ import { apiErrorToResponse } from '@floway-dev/provider';
 // Renders an upstream Responses result into the client HTTP/SSE response. An
 // error-typed result is a pre-stream failure and always answers as HTTP; an
 // events result drains to one JSON body (non-streaming) or is proxied frame by
-// frame (streaming). `success` reports whether a non-streaming body was
-// produced, so the orchestrator knows whether to flush stored items.
+// frame (streaming).
 export const respondResponses = async (
   c: Context,
   result: ExecuteResult<ProtocolFrame<ResponsesStreamEvent>> | PlainResult,
   wantsStream: boolean,
   ctx: GatewayCtx,
-): Promise<{ success: boolean; response: Response }> => {
+): Promise<Response> => {
   if (result.type === 'api-error') {
     recordFailedRequest(ctx, result.performance);
     ctx.dump?.error(result.source, result.upstream);
-    return { success: false, response: apiErrorToResponse(result) };
+    return apiErrorToResponse(result);
   }
 
   if (result.type === 'internal-error') {
     recordFailedRequest(ctx, result.performance);
     ctx.dump?.failed(result.error.message);
-    return { success: false, response: internalResponsesErrorResponse(result.status, result.error) };
+    return internalResponsesErrorResponse(result.status, result.error);
   }
 
   if (result.type === 'plain') {
     if (result.status >= 400) {
       ctx.dump?.error(result.upstream !== undefined ? 'upstream' : 'gateway', result.upstream);
     }
-    return { success: true, response: plainResultToResponse(result) };
+    return plainResultToResponse(result);
   }
 
   const state = new SourceStreamState();
-  const frames = observeResponsesFrames(result.events, state, wantsStream, ctx);
+  const observed = observeResponsesFrames(result.events, state, wantsStream, ctx);
+  const frames = nativeResponsesOutput(observed, ctx);
 
   if (!wantsStream) {
     try {
@@ -53,11 +56,11 @@ export const respondResponses = async (
       const usage = tokenUsageFromResponsesResult(response);
       ctx.dump?.success(metadata.modelIdentity, usage);
       settle(ctx, metadata.performance, metadata.modelIdentity, usage, state.failed || response.status === 'failed');
-      return { success: true, response: Response.json(response, { headers: mergeForwardedUpstreamHeaders(undefined, result.headers) }) };
+      return Response.json(response, { headers: mergeForwardedUpstreamHeaders(undefined, result.headers) });
     } catch (error) {
       recordFailedRequest(ctx, result.performance);
       ctx.dump?.failed(error);
-      return { success: false, response: internalResponsesErrorResponse(502, toInternalDebugError(error)) };
+      return internalResponsesErrorResponse(502, toInternalDebugError(error));
     }
   }
 
@@ -81,7 +84,25 @@ export const respondResponses = async (
     }
   });
 
-  return { success: true, response };
+  return response;
+};
+
+const nativeResponsesOutput = (
+  frames: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>,
+  ctx: GatewayCtx,
+): AsyncIterable<ProtocolFrame<ResponsesStreamEvent>> => {
+  if (!('affinity' in ctx) || !('store' in ctx)) throw new Error('Responses event result reached responder without chat context');
+  const chatCtx = ctx as ChatGatewayCtx;
+  if (chatCtx.store === undefined) throw new Error('Native Responses responder requires a state store');
+  const withAffinity = wrapResponsesAffinityEgress(frames, {
+    codec: chatCtx.affinity.codec,
+    affinity: chatCtx.affinity.selectedTarget(),
+  });
+  return wrapResponsesClientOutput(withAffinity, {
+    store: chatCtx.store,
+    attemptState: chatCtx.responsesAttemptState,
+    responseId: createResponsesResponseId(),
+  });
 };
 
 // --- error rendering ---
diff --git a/packages/gateway/src/data-plane/chat/responses/serve-prep.ts b/packages/gateway/src/data-plane/chat/responses/serve-prep.ts
index f0dcfa1dd..2a09dca8a 100644
--- a/packages/gateway/src/data-plane/chat/responses/serve-prep.ts
+++ b/packages/gateway/src/data-plane/chat/responses/serve-prep.ts
@@ -1,14 +1,15 @@
+import { prepareResponsesAffinity, type PreparedResponsesAffinity } from './affinity/ingress.ts';
 import { responsesTarget } from './attempt.ts';
 import { renderResponsesFailure } from './errors.ts';
-import { classifyResponsesItemAffinity } from './items/affinity.ts';
+import { hydrateResponsesPayload } from './items/rewrite.ts';
 import type { StatefulResponsesStore } from './items/store.ts';
 import { enumerateModelCandidates } from '../../providers/registry.ts';
-import { noViableCandidateFailure } from '../shared/errors.ts';
+import { routeCandidatesByAffinity } from '../shared/affinity/index.ts';
+import { noViableCandidateFailure, tryCatchChatServeFailure } from '../shared/errors.ts';
 import type { ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
 import type { CanonicalResponsesPayload, ResponsesStreamEvent } from '@floway-dev/protocols/responses';
 import type { ModelCandidate, ExecuteResult } from '@floway-dev/provider';
-import { responsesItemsView } from '@floway-dev/translate/via-responses/responses-items';
 
 // Thrown when a request names a `previous_response_id` that the store cannot
 // resolve. The HTTP/WS entry layer catches this and renders the OpenAI-shaped
@@ -59,7 +60,12 @@ export const expandPreviousResponseId = async (
 
 export type ResponsesServePlan =
   | { readonly kind: 'failure'; readonly result: ExecuteResult<ProtocolFrame<ResponsesStreamEvent>> }
-  | { readonly kind: 'ready'; readonly prepared: CanonicalResponsesPayload; readonly candidates: readonly ModelCandidate[] };
+  | {
+    readonly kind: 'ready';
+    readonly affinity: PreparedResponsesAffinity;
+    readonly privatePayloads: ReadonlyMap<string, unknown>;
+    readonly candidates: readonly ModelCandidate[];
+  };
 
 // Runs the shared serve-side prep both `responsesServe.generate` and
 // `responsesServe.compact` need before dispatching to `responsesAttempt`:
@@ -74,7 +80,8 @@ export const prepareResponsesServePlan = async (args: {
   readonly ctx: ChatGatewayCtx;
 }): Promise<ResponsesServePlan> => {
   const { payload, ctx } = args;
-  const { store } = ctx;
+  const store = ctx.store;
+  if (store === undefined) throw new Error('Native Responses serve requires a state store');
   const prepared = await expandPreviousResponseId(payload, store);
   const { candidates, sawModel, failedUpstreams } = await enumerateModelCandidates({
     upstreamIds: ctx.upstreamIds,
@@ -84,17 +91,17 @@ export const prepareResponsesServePlan = async (args: {
     runtimeLocation: ctx.runtimeLocation,
   });
   const viable = candidates.filter(c => responsesTarget.canServe(c.model.endpoints));
-  const decision = await classifyResponsesItemAffinity({
-    sourceItems: prepared.input,
-    view: responsesItemsView,
-    store,
-    candidates: viable,
-    // Hash-preload covers any user item carried directly on this turn — once
-    // `expandPreviousResponseId` has run, those are the items after the
-    // snapshot's item_reference prefix, which IS `payload.input` (verbatim,
-    // pre-expansion).
-    inputItemsToStage: payload.input,
-  });
+  await store.loadInputItems(prepared.input, payload.input);
+  let hydrated: ReturnType<typeof hydrateResponsesPayload>;
+  try {
+    hydrated = hydrateResponsesPayload(prepared, store);
+  } catch (error) {
+    const failure = tryCatchChatServeFailure(error);
+    if (failure === null) throw error;
+    return { kind: 'failure', result: renderResponsesFailure(failure) };
+  }
+  const affinity = await prepareResponsesAffinity(hydrated.payload, ctx.affinity.codec);
+  const decision = routeCandidatesByAffinity(viable, affinity.routingEvidence);
   if (decision.kind === 'failure') return { kind: 'failure', result: renderResponsesFailure(decision.failure) };
   // Stage the user-supplied input from the original payload — not the
   // expansion's `item_reference` prefix — so the next-turn snapshot picks
@@ -102,7 +109,6 @@ export const prepareResponsesServePlan = async (args: {
   // Runs after the affinity walk so any `item_reference` in user-supplied
   // input has its target row loaded.
   await store.stageInputItems(payload.input);
-  await store.refreshTouchedItems();
 
   if (decision.candidates.length === 0) {
     return {
@@ -110,5 +116,5 @@ export const prepareResponsesServePlan = async (args: {
       result: renderResponsesFailure(noViableCandidateFailure(sawModel, prepared.model, failedUpstreams)),
     };
   }
-  return { kind: 'ready', prepared, candidates: decision.candidates };
+  return { kind: 'ready', affinity, privatePayloads: hydrated.privatePayloads, candidates: decision.candidates };
 };
diff --git a/packages/gateway/src/data-plane/chat/responses/serve.ts b/packages/gateway/src/data-plane/chat/responses/serve.ts
index 94bb1daff..071a558d7 100644
--- a/packages/gateway/src/data-plane/chat/responses/serve.ts
+++ b/packages/gateway/src/data-plane/chat/responses/serve.ts
@@ -1,26 +1,24 @@
+import { wrapResponsesAffinityEgress } from './affinity/egress.ts';
 import { responsesAttempt } from './attempt.ts';
 import type { ResponsesAttemptResult } from './interceptors/types.ts';
+import { createResponsesResponseId } from './items/format.ts';
+import { syntheticEventsFromResult, wrapResponsesClientOutput } from './items/output.ts';
 import { prepareResponsesServePlan } from './serve-prep.ts';
+import { tokenUsageFromResponsesResult } from './usage.ts';
 import { iterateCandidates } from '../../shared/iterate-candidates.ts';
 import type { ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
-import type { CanonicalResponsesPayload, ResponsesStreamEvent } from '@floway-dev/protocols/responses';
+import { collectResponsesProtocolEventsToResult, type CanonicalResponsesPayload, type ResponsesStreamEvent } from '@floway-dev/protocols/responses';
 import type { ExecuteResult } from '@floway-dev/provider';
 
-export interface ResponsesServeGenerateArgs {
-  readonly payload: CanonicalResponsesPayload;
-  readonly ctx: ChatGatewayCtx;
-  readonly headers: Headers;
-}
-
-export interface ResponsesServeCompactArgs {
+interface ResponsesServeArgs {
   readonly payload: CanonicalResponsesPayload;
   readonly ctx: ChatGatewayCtx;
   readonly headers: Headers;
 }
 
 export const responsesServe = {
-  generate: async (args: ResponsesServeGenerateArgs): Promise<ExecuteResult<ProtocolFrame<ResponsesStreamEvent>>> => {
+  generate: async (args: ResponsesServeArgs): Promise<ExecuteResult<ProtocolFrame<ResponsesStreamEvent>>> => {
     const { payload, ctx, headers } = args;
     const plan = await prepareResponsesServePlan({ payload, ctx });
     if (plan.kind === 'failure') return plan.result;
@@ -30,17 +28,29 @@ export const responsesServe = {
     // candidate can serve. The last failure surfaces verbatim on exhaustion.
     // Each attempt stamps its private prepared-payload clone with the
     // candidate's canonical model id.
-    return await iterateCandidates(
+    const result = await iterateCandidates(
       plan.candidates,
       'responsesServe.generate',
       ctx,
       'chat',
-      candidate => responsesAttempt.generate({ payload: plan.prepared, ctx, candidate, headers }),
+      async candidate => {
+        const result = await responsesAttempt.generate({
+          sourcePreparation: { affinity: plan.affinity, privatePayloads: plan.privatePayloads },
+          ctx,
+          candidate,
+          headers,
+        });
+        if (result.type === 'events') ctx.affinity.select(candidate);
+        return result;
+      },
     );
+    return result;
   },
 
-  compact: async (args: ResponsesServeCompactArgs): Promise<ResponsesAttemptResult> => {
+  compact: async (args: ResponsesServeArgs): Promise<ResponsesAttemptResult> => {
     const { payload, ctx, headers } = args;
+    const store = ctx.store;
+    if (store === undefined) throw new Error('Native Responses compact requires a state store');
     // Compact accepts `previous_response_id` (the official endpoint documents
     // it). When present serve-prep expands it the same way generate does so
     // the candidate rewrite can restore the stored history before dispatch.
@@ -51,12 +61,39 @@ export const responsesServe = {
     // re-tags the result as compact on the way out.
     const plan = await prepareResponsesServePlan({ payload, ctx });
     if (plan.kind === 'failure') return plan.result;
-    return await iterateCandidates(
+    const result = await iterateCandidates(
       plan.candidates,
       'responsesServe.compact',
       ctx,
       'chat',
-      candidate => responsesAttempt.invoke({ payload: plan.prepared, action: 'compact', ctx, candidate, headers }),
+      async candidate => {
+        const result = await responsesAttempt.invoke({
+          sourcePreparation: { affinity: plan.affinity, privatePayloads: plan.privatePayloads },
+          action: 'compact',
+          ctx,
+          candidate,
+          headers,
+        });
+        if (result.type === 'result') ctx.affinity.select(candidate);
+        return result;
+      },
     );
+    if (result.type !== 'result') return result;
+
+    const withAffinity = wrapResponsesAffinityEgress(syntheticEventsFromResult(result.result), {
+      codec: ctx.affinity.codec,
+      affinity: ctx.affinity.selectedTarget(),
+    });
+    const stored = wrapResponsesClientOutput(withAffinity, {
+      store,
+      attemptState: ctx.responsesAttemptState,
+      responseId: createResponsesResponseId(),
+    });
+    const clientResult = await collectResponsesProtocolEventsToResult(stored);
+    return {
+      ...result,
+      result: clientResult,
+      usage: tokenUsageFromResponsesResult(clientResult),
+    };
   },
 };
diff --git a/packages/gateway/src/data-plane/chat/responses/serve_test.ts b/packages/gateway/src/data-plane/chat/responses/serve_test.ts
index 3015124b4..d0741e031 100644
--- a/packages/gateway/src/data-plane/chat/responses/serve_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/serve_test.ts
@@ -1,6 +1,6 @@
 import { afterEach, test, vi } from 'vitest';
 
-import { createStoredResponsesItemId } from './items/format.ts';
+import { createResponsesItemId } from './items/format.ts';
 import { createResponsesHttpStore, MemoryStatefulResponsesBacking, LayeredStatefulResponsesStore } from './items/store.ts';
 import { initRepo } from '../../../repo/index.ts';
 import { InMemoryRepo } from '../../../repo/memory.ts';
@@ -339,71 +339,6 @@ test('generate filters out candidates whose endpoints do not satisfy the respons
   assertEquals(callResponses.mock.calls.length, 0);
 });
 
-test('generate renders routing-unavailable as a 400 when a forcing item names an absent upstream', async () => {
-  const repo = installRepo();
-  const id = createStoredResponsesItemId('compaction');
-  const row: StoredResponsesItem = {
-    id,
-    apiKeyId: API_KEY_ID,
-    upstreamId: 'up_forcing',
-    upstreamItemId: 'raw_cmp',
-    itemType: 'compaction',
-    origin: 'upstream',
-    contentHash: null,
-    encryptedContentHash: null,
-    payload: { item: { type: 'compaction', id } },
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-  };
-  await repo.responsesItems.insertMany([row]);
-
-  queueResolution([makeCandidate({ upstream: 'up_b' })]);
-
-  const result = await responsesServe.generate({
-    payload: makePayload({ input: [{ type: 'item_reference', id }] }),
-    ctx: makeGatewayCtx(),
-    headers: new Headers(),
-  });
-
-  assertEquals(result.type, 'api-error');
-  if (result.type !== 'api-error') throw new Error('unreachable');
-  assertEquals(result.status, 400);
-  const body = JSON.parse(new TextDecoder().decode(result.body));
-  assertEquals(body.error.code, 'responses_item_routing_unavailable');
-});
-
-test('compact renders routing-unavailable when no candidate exposes the responses endpoint', async () => {
-  const repo = installRepo();
-  const id = createStoredResponsesItemId('compaction');
-  await repo.responsesItems.insertMany([{
-    id,
-    apiKeyId: API_KEY_ID,
-    upstreamId: 'up_forcing',
-    upstreamItemId: 'raw_cmp',
-    itemType: 'compaction',
-    origin: 'upstream',
-    contentHash: null,
-    encryptedContentHash: null,
-    payload: { item: { type: 'compaction', id } },
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-  }]);
-
-  queueResolution([makeCandidate({ upstream: 'up_b' })]);
-
-  const result = await responsesServe.compact({
-    payload: makePayload({ input: [{ type: 'item_reference', id }] }),
-    ctx: makeGatewayCtx(),
-    headers: new Headers(),
-  });
-
-  assertEquals(result.type, 'api-error');
-  if (result.type !== 'api-error') throw new Error('unreachable');
-  assertEquals(result.status, 400);
-  const body = JSON.parse(new TextDecoder().decode(result.body));
-  assertEquals(body.error.code, 'responses_item_routing_unavailable');
-});
-
 test('compact renders model-missing as a 404 when no candidates are available', async () => {
   installRepo();
   queueResolution([]);
@@ -446,26 +381,20 @@ test('compact renders model-unsupported as a 400 when the only candidate\'s endp
 
 test('expandPreviousResponseId prepends snapshot items and strips the previous_response_id field', async () => {
   const repo = installRepo();
-  const previousMessageId = createStoredResponsesItemId('message');
+  const previousMessageId = createResponsesItemId('message');
   await repo.responsesItems.insertMany([{
     id: previousMessageId,
     apiKeyId: API_KEY_ID,
-    upstreamId: null,
-    upstreamItemId: null,
     itemType: 'message',
-    origin: 'input',
-    contentHash: null,
-    encryptedContentHash: null,
+    contentHash: 'previous-message-hash',
     payload: { item: { type: 'message', id: previousMessageId, role: 'user', content: 'first turn' } },
     createdAt: 1_000,
-    refreshedAt: 1_000,
   }]);
   const snapshot: StoredResponsesSnapshot = {
     id: 'resp_prev',
     apiKeyId: API_KEY_ID,
     itemIds: [previousMessageId],
     createdAt: 1_000,
-    refreshedAt: 1_000,
   };
   await repo.responsesSnapshots.insert(snapshot);
 
@@ -489,40 +418,32 @@ test('expandPreviousResponseId prepends snapshot items and strips the previous_r
 // that lives nowhere else.
 const memoryStore = async (snapshots: readonly StoredResponsesSnapshot[], items: readonly StoredResponsesItem[]) => {
   const backing = new MemoryStatefulResponsesBacking();
-  for (const item of items) await backing.insertItems([item], { durable: true });
+  for (const item of items) await backing.insertItems([item]);
   for (const snapshot of snapshots) await backing.insertSnapshot(snapshot);
   return new LayeredStatefulResponsesStore({
     apiKeyId: API_KEY_ID,
     reads: [backing],
-    itemWrites: [{ backing, durable: true }],
-    snapshotWrites: [{ backing, durable: true }],
+    writes: [backing],
     stageInputs: true,
-    shouldStorePayload: true,
   });
 };
 
 test('expandPreviousResponseId resolves snapshots from a non-repo-backed store', async () => {
   installRepo(); // affinity lookups in the wider flow still need a repo, but here the helper only touches the store.
-  const id = createStoredResponsesItemId('message');
+  const id = createResponsesItemId('message');
   const item: StoredResponsesItem = {
     id,
     apiKeyId: API_KEY_ID,
-    upstreamId: null,
-    upstreamItemId: null,
     itemType: 'message',
-    origin: 'input',
-    contentHash: null,
-    encryptedContentHash: null,
+    contentHash: 'memory-message-hash',
     payload: { item: { type: 'message', id, role: 'user', content: 'remembered' } },
     createdAt: 1_000,
-    refreshedAt: 1_000,
   };
   const snapshot: StoredResponsesSnapshot = {
     id: 'resp_mem',
     apiKeyId: API_KEY_ID,
     itemIds: [id],
     createdAt: 1_000,
-    refreshedAt: 1_000,
   };
   const store = await memoryStore([snapshot], [item]);
 
@@ -617,133 +538,6 @@ test('generate falls through translate-out to chat-completions target', async ()
   assertEquals(callChatCompletions.mock.calls.length, 1);
 });
 
-test('generate reuses an existing input row when a later turn echoes the same user message', async () => {
-  const repo = installRepo();
-  let turn = 0;
-  const callResponses = vi.fn(async (): Promise<ProviderResponsesResult> => {
-    turn += 1;
-    return {
-      action: 'generate', ok: true,
-      events: makeProtocolFrames([{
-        type: 'response.completed',
-        sequence_number: 0,
-        response: makeResponsesResult(`resp_turn_${turn}`),
-      }]),
-      modelKey: 'test-model-key',
-      headers: new Headers(),
-    };
-  });
-  const store = createResponsesHttpStore(API_KEY_ID, true);
-  const payload = makePayload({ input: [{ type: 'message', role: 'user', content: 'hello' }] });
-
-  queueResolution([makeCandidate({ callResponses })]);
-  const turn1 = await responsesServe.generate({ payload, ctx: makeGatewayCtx(store), headers: new Headers() });
-  if (turn1.type !== 'events') throw new Error('turn 1: expected events');
-  const turn1Events = await collectEvents(turn1.events);
-
-  queueResolution([makeCandidate({ callResponses })]);
-  const turn2 = await responsesServe.generate({ payload, ctx: makeGatewayCtx(store), headers: new Headers() });
-  if (turn2.type !== 'events') throw new Error('turn 2: expected events');
-  const turn2Events = await collectEvents(turn2.events);
-
-  // Both snapshots' first item id is the staged user message; a working
-  // content-hash preload makes turn 2 reuse turn 1's row instead of minting
-  // a fresh one. Look up by the Floway-minted response id wrap puts on
-  // each terminal event — the upstream's `resp_turn_N` id is discarded.
-  const turn1ResponseId = (turn1Events.find(e => e.type === 'response.completed') as Extract<ResponsesStreamEvent, { type: 'response.completed' }>).response.id;
-  const turn2ResponseId = (turn2Events.find(e => e.type === 'response.completed') as Extract<ResponsesStreamEvent, { type: 'response.completed' }>).response.id;
-  const snap1 = await repo.responsesSnapshots.lookup(API_KEY_ID, turn1ResponseId);
-  const snap2 = await repo.responsesSnapshots.lookup(API_KEY_ID, turn2ResponseId);
-  if (snap1 === null || snap2 === null) throw new Error('expected both snapshots to be persisted');
-  const turn1InputId = snap1.itemIds[0];
-  const turn2InputId = snap2.itemIds[0];
-  if (turn1InputId === undefined || turn2InputId === undefined) throw new Error('expected each snapshot to start with a staged input item');
-  assertEquals(turn2InputId, turn1InputId);
-});
-
-test('generate treats compaction_trigger-bearing input as compaction: snapshot replaces prior history with the compaction output alone, trigger reaches the wire but never stores a row', async () => {
-  const repo = installRepo();
-
-  // Seed a prior conversation: one user message + a snapshot pointing at it.
-  // The compacting turn references that snapshot via previous_response_id, so
-  // generate without the trigger would normally append [prior items + this
-  // turn's input + output] into the new snapshot. The trigger flips that to
-  // 'replace' so the new snapshot only carries the compaction blob — the
-  // whole point of compaction is to drop the prior history.
-  const priorMessageId = createStoredResponsesItemId('message');
-  await repo.responsesItems.insertMany([{
-    id: priorMessageId,
-    apiKeyId: API_KEY_ID,
-    upstreamId: null,
-    upstreamItemId: null,
-    itemType: 'message',
-    origin: 'input',
-    contentHash: null,
-    encryptedContentHash: null,
-    payload: { item: { type: 'message', id: priorMessageId, role: 'user', content: 'old turn' } },
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-  }]);
-  await repo.responsesSnapshots.insert({
-    id: 'resp_before_compact',
-    apiKeyId: API_KEY_ID,
-    itemIds: [priorMessageId],
-    createdAt: 1_000,
-    refreshedAt: 1_000,
-  });
-
-  let receivedInput: unknown = null;
-  const callResponses = vi.fn(async (_model: unknown, body: unknown): Promise<ProviderResponsesResult> => {
-    receivedInput = (body as { input: unknown }).input;
-    return {
-      action: 'generate', ok: true,
-      events: makeProtocolFrames([{
-        type: 'response.completed',
-        sequence_number: 0,
-        response: {
-          ...makeResponsesResult(),
-          output: [{ type: 'compaction', id: 'upstream_cmp_id', encrypted_content: 'ENC' }] as unknown as ResponsesResult['output'],
-        },
-      }]),
-      modelKey: 'test-model-key',
-      headers: new Headers(),
-    };
-  });
-  queueResolution([makeCandidate({ upstream: 'up_a', callResponses })]);
-
-  const result = await responsesServe.generate({
-    payload: makePayload({
-      previous_response_id: 'resp_before_compact',
-      input: [{ type: 'compaction_trigger' }],
-    }),
-    ctx: makeGatewayCtx(),
-    headers: new Headers(),
-  });
-
-  if (result.type !== 'events') throw new Error('expected events');
-  const events = await collectEvents(result.events);
-  const completed = events.find(e => e.type === 'response.completed') as Extract<ResponsesStreamEvent, { type: 'response.completed' }>;
-  const responseId = completed.response.id;
-
-  // 'replace' semantics: only the new compaction row, no item_reference to
-  // priorMessageId and no row for the trigger. (The test would also throw
-  // outright at `stageInputItem` if the trigger early-return regressed,
-  // since createStoredResponsesItemId('compaction_trigger') has no prefix.)
-  const snap = await repo.responsesSnapshots.lookup(API_KEY_ID, responseId);
-  if (snap === null) throw new Error('expected snapshot to be persisted');
-  assertEquals(snap.itemIds.length, 1);
-  const onlyItemId = snap.itemIds[0];
-  if (onlyItemId === undefined) throw new Error('unreachable');
-  assertEquals(onlyItemId.startsWith('cmp_'), true);
-
-  // The trigger still reaches the upstream — the gateway only intercepts at
-  // the storage seam, not on the wire. The stored message is expanded first
-  // and the trigger remains last.
-  if (!Array.isArray(receivedInput)) throw new Error('expected the wire input to be an array');
-  assertEquals(receivedInput[0], { type: 'message', id: priorMessageId, role: 'user', content: 'old turn' });
-  assertEquals((receivedInput.at(-1) as { type?: unknown })?.type, 'compaction_trigger');
-});
-
 test('alias resolution swaps the inbound model id for the target and overlays rules onto the Responses IR', async () => {
   installRepo();
   const capturedBodies: ResponsesPayload[] = [];
diff --git a/packages/gateway/src/data-plane/chat/responses/websocket.ts b/packages/gateway/src/data-plane/chat/responses/websocket.ts
index b22ba1e3b..e3309efa4 100644
--- a/packages/gateway/src/data-plane/chat/responses/websocket.ts
+++ b/packages/gateway/src/data-plane/chat/responses/websocket.ts
@@ -1,5 +1,9 @@
 import type { Context } from 'hono';
 
+import { wrapResponsesAffinityEgress } from './affinity/egress.ts';
+import { ResponsesAffinityInputError } from './affinity/ingress.ts';
+import { createResponsesResponseId } from './items/format.ts';
+import { wrapResponsesClientOutput } from './items/output.ts';
 import { createResponsesWsSession } from './items/store.ts';
 import { PreviousResponseNotFoundError } from './serve-prep.ts';
 import { responsesServe } from './serve.ts';
@@ -10,14 +14,14 @@ import { backgroundSchedulerFromContext } from '../../../runtime/background.ts';
 import { inboundHeadersForUpstream } from '../../shared/inbound-headers.ts';
 import { recordFailedRequest } from '../../shared/telemetry/performance.ts';
 import { settle } from '../../shared/telemetry/settle.ts';
-import { createChatGatewayCtxFromHono, type ChatGatewayCtx, type GatewayCtx } from '../shared/gateway-ctx.ts';
+import { createChatGatewayCtxFromHono, type ChatGatewayCtx } from '../shared/gateway-ctx.ts';
 import { takeRequestBody } from '../shared/request-body.ts';
 import { SourceStreamState, eventResultMetadata } from '../shared/respond.ts';
 import { DOWNSTREAM_KEEP_ALIVE_INTERVAL_MS, type StreamCompletion } from '../shared/stream/sse.ts';
 import type { BackgroundScheduler } from '@floway-dev/platform';
 import type { ProtocolFrame } from '@floway-dev/protocols/common';
 import { RESPONSES_MISSING_TERMINAL_MESSAGE } from '@floway-dev/protocols/responses';
-import { isResponsesTerminalEvent, type CanonicalResponsesPayload, type ResponsesRequestPayload, type ResponsesResult, type ResponsesStreamEvent } from '@floway-dev/protocols/responses';
+import { isResponsesTerminalEvent, type CanonicalResponsesPayload, type ResponsesRequestPayload, type ResponsesStreamEvent } from '@floway-dev/protocols/responses';
 import type { ExecuteResult } from '@floway-dev/provider';
 import { toInternalDebugError } from '@floway-dev/provider';
 import { TranslatorInputError } from '@floway-dev/translate';
@@ -266,7 +270,7 @@ const handleClientMessage = async (
     await respondResponsesWebSocket({ socket, eventId, signal, isClosed, result, ctx });
   } catch (error) {
     if (signal.aborted || isClosed()) return;
-    if (error instanceof TranslatorInputError) {
+    if (error instanceof TranslatorInputError || error instanceof ResponsesAffinityInputError) {
       sendError(socket, 400, {
         type: 'invalid_request_error',
         code: 'invalid_request_error',
@@ -331,7 +335,7 @@ const respondResponsesWebSocket = async (input: {
   readonly signal: AbortSignal;
   readonly isClosed: () => boolean;
   readonly result: ExecuteResult<ProtocolFrame<ResponsesStreamEvent>>;
-  readonly ctx: GatewayCtx;
+  readonly ctx: ChatGatewayCtx;
 }): Promise<void> => {
   const { socket, eventId, signal, isClosed, result, ctx } = input;
   if (result.type === 'api-error') {
@@ -353,8 +357,20 @@ const respondResponsesWebSocket = async (input: {
   const state = new SourceStreamState();
   let completion: StreamCompletion = 'error';
   try {
+    const store = ctx.store;
+    if (store === undefined) throw new Error('Responses WebSocket turn requires a state store');
     let terminalEvent: ResponsesStreamEvent | undefined;
-    const iterator = result.events[Symbol.asyncIterator]();
+    const observed = observeResponsesWebSocketFrames(result.events, state, ctx);
+    const withAffinity = wrapResponsesAffinityEgress(observed, {
+      codec: ctx.affinity.codec,
+      affinity: ctx.affinity.selectedTarget(),
+    });
+    const output = wrapResponsesClientOutput(withAffinity, {
+      store,
+      attemptState: ctx.responsesAttemptState,
+      responseId: createResponsesResponseId(),
+    });
+    const iterator = output[Symbol.asyncIterator]();
     let pendingNext = pendingWsFrameResult(iterator.next());
     let completed = false;
     let stoppedByDownstream = false;
@@ -388,15 +404,9 @@ const respondResponsesWebSocket = async (input: {
 
         const frame = next.result.value;
         pendingNext = pendingWsFrameResult(iterator.next());
-        // Capture every frame (events + the `done` sentinel) so the
-        // dashboard can reassemble the turn identically to the HTTP path.
-        ctx.dump?.frame(frame);
         if (frame.type !== 'event') continue;
 
         const event = frame.event;
-        const failed = event.type === 'error' || event.type === 'response.failed';
-        if (failed) state.failed = true;
-        state.rememberUsage('response' in event ? tokenUsageFromResponsesResult((event as { response: ResponsesResult }).response) : null);
 
         // The wrapped terminal event arrives only after its item and snapshot
         // writes have committed. Flush it immediately, then drain the remainder
@@ -410,7 +420,6 @@ const respondResponsesWebSocket = async (input: {
             completion = 'cancel';
             continue;
           }
-          if (!failed) state.completed = true;
           terminalEvent = event;
           continue;
         }
@@ -422,7 +431,7 @@ const respondResponsesWebSocket = async (input: {
       }
     } finally {
       if (!completed) {
-        const stopped = iterator.return?.();
+        const stopped = iterator.return?.(undefined);
         if (stoppedByDownstream) stopped?.catch(() => {});
         else await stopped;
       }
@@ -454,6 +463,24 @@ const respondResponsesWebSocket = async (input: {
   }
 };
 
+const observeResponsesWebSocketFrames = async function* (
+  frames: AsyncIterable<ProtocolFrame<ResponsesStreamEvent>>,
+  state: SourceStreamState,
+  ctx: ChatGatewayCtx,
+): AsyncGenerator<ProtocolFrame<ResponsesStreamEvent>> {
+  for await (const frame of frames) {
+    ctx.dump?.frame(frame);
+    if (frame.type === 'event') {
+      const event = frame.event;
+      const failed = event.type === 'error' || event.type === 'response.failed';
+      if (failed) state.failed = true;
+      if ('response' in event) state.rememberUsage(tokenUsageFromResponsesResult(event.response));
+      if (isResponsesTerminalEvent(event) && !failed) state.completed = true;
+    }
+    yield frame;
+  }
+};
+
 type WsFrameRaceResult =
   | { type: 'frame'; result: IteratorResult<ProtocolFrame<ResponsesStreamEvent>> }
   | { type: 'next-error'; error: unknown }
diff --git a/packages/gateway/src/data-plane/chat/responses/websocket_test.ts b/packages/gateway/src/data-plane/chat/responses/websocket_test.ts
index ca8ec3aff..90fa2240d 100644
--- a/packages/gateway/src/data-plane/chat/responses/websocket_test.ts
+++ b/packages/gateway/src/data-plane/chat/responses/websocket_test.ts
@@ -1,13 +1,14 @@
 import type { ExecutionContext } from 'hono';
 import { test, vi } from 'vitest';
 
-import { hashResponsesItemContent, isStoredResponseId } from './items/format.ts';
+import { hashResponsesItemBinding, hashResponsesItemContent, isResponsesItemId, isResponsesResponseId } from './items/format.ts';
 import { responsesServe } from './serve.ts';
 import { app } from '../../../app.ts';
 import { initDumpBroker, initDumpStore } from '../../../dump/registry.ts';
 import { installDumpStubs } from '../../../dump/test-fixtures.ts';
 import { copilotModels, flushAsyncWork, setupAppTest, sseResponsesResponse } from '../../../test-helpers.ts';
 import { FakeTime } from '../../../test-time.ts';
+import { AffinityCodec } from '../shared/affinity/index.ts';
 import { DOWNSTREAM_KEEP_ALIVE_INTERVAL_MS } from '../shared/stream/sse.ts';
 import { assert, assertEquals, assertExists, assertStringIncludes, jsonResponse, withMockedFetch } from '@floway-dev/test-utils';
 
@@ -253,7 +254,7 @@ test('Responses WebSocket forwards stream events, echoes event_id, and sends res
       assertExists(completed);
       const flowayResponseId = (completed.response as { id?: unknown } | undefined)?.id;
       assertEquals(typeof flowayResponseId, 'string');
-      assert(isStoredResponseId(flowayResponseId as string), 'expected Floway-minted resp_ id, not the upstream blob');
+      assert(isResponsesResponseId(flowayResponseId as string), 'expected Floway-minted resp_ id, not the upstream blob');
       assertEquals(messages.at(-1), {
         type: 'response.done',
         event_id: 'evt_1',
@@ -508,6 +509,7 @@ test('Responses WebSocket keepalive during an in-flight request does not drop th
           }
 
           assert(hasMessageType(messages, 'ping'), 'expected a ping while the upstream response stream is idle');
+          const completed = waitForMessages(client, received => received.some(message => message.type === 'response.done'));
 
           const response = {
             id: 'resp_ws_keepalive',
@@ -524,9 +526,7 @@ test('Responses WebSocket keepalive during an in-flight request does not drop th
           upstreamController.enqueue(encoder.encode('data: [DONE]\n\n'));
           upstreamController.close();
 
-          for (let i = 0; i < 20 && !hasMessageType(messages, 'response.done'); i++) {
-            await waitForMicrotasks();
-          }
+          await completed;
 
           const types = messages.map(message => message.type);
           assert(types.indexOf('ping') < types.indexOf('response.created'), 'expected the delayed upstream frame after the ping');
@@ -628,6 +628,49 @@ test('Responses WebSocket returns invalid_request_error for malformed client mes
   });
 });
 
+test('Responses WebSocket renders an invalid bound affinity carrier as a 400 input error', async () => {
+  const { apiKey } = await setupAppTest();
+  const original = { type: 'program_output' as const, id: 'first', call_id: 'call_1', result: 'first', status: 'completed' as const };
+  const carrier = await new AffinityCodec(apiKey.serverSecret).wrap(undefined, {
+    upstreamId: 'copilot',
+    modelId: 'gpt-direct-responses',
+    syntheticItem: true,
+    boundItem: {
+      type: original.type,
+      upstreamItemId: 'first_upstream',
+      contentHash: await hashResponsesItemBinding(original),
+    },
+  }, 'responses.reasoning.encrypted_content');
+
+  await withSuccessfulResponsesUpstream(async () => await withWorkerWebSocketRuntime(async () => {
+    const client = await connectResponsesWebSocket(apiKey.key);
+    const received = waitForMessages(client, messages => messages.some(message => message.type === 'error'));
+    client.send(JSON.stringify({
+      type: 'response.create',
+      event_id: 'evt_affinity',
+      response: {
+        model: 'gpt-direct-responses',
+        input: [
+          { type: 'reasoning', id: 'rs_prefix', summary: [], encrypted_content: carrier },
+          { type: 'program_output', id: 'second', call_id: 'call_2', result: 'second', status: 'completed' },
+        ],
+      },
+    }));
+
+    assertEquals(await received, [{
+      type: 'error',
+      event_id: 'evt_affinity',
+      status_code: 400,
+      error: {
+        type: 'invalid_request_error',
+        code: 'invalid_request_error',
+        message: 'Affinity carrier does not match the Responses input item at index 1.',
+        param: 'input[1]',
+      },
+    }]);
+  }));
+});
+
 test('Responses WebSocket forwards HTTP failures with status_code, error.code, and event_id', async () => {
   const { apiKey } = await setupAppTest();
   await withMockedFetch(
@@ -759,9 +802,11 @@ test('Responses WebSocket store:false keeps session snapshots without durable re
       const firstMessages = await firstDone;
       const firstResponseId = responseDoneId(firstMessages);
 
+      assert(isResponsesResponseId(firstResponseId), 'expected a Floway response id');
       assertEquals(await repo.responsesSnapshots.lookup(apiKey.id, firstResponseId), null);
       const firstOutput = firstMessages.find(message => message.type === 'response.output_item.done') as { item?: { id?: string } } | undefined;
       assertExists(firstOutput?.item?.id);
+      assert(isResponsesItemId(firstOutput.item.id), 'expected a Floway output item id');
       assertEquals(await repo.responsesItems.lookupMany(apiKey.id, [firstOutput.item.id]), []);
       assertEquals(
         await repo.responsesItems.lookupManyByContentHash(apiKey.id, [await hashResponsesItemContent({ type: 'message', role: 'user', content: 'first question' })]),
@@ -961,6 +1006,12 @@ test('Responses WebSocket session-level store: second message resolves prior ite
         ['message', 'user', 'turn two input'],
       ]);
 
+      const restored = await repo.responsesSnapshots.lookup(apiKey.id, firstResponseId);
+      assertExists(restored);
+      assertEquals((await repo.responsesItems.lookupMany(apiKey.id, restored.itemIds)).length, restored.itemIds.length);
+      await repo.responsesSnapshots.deleteAll();
+      await repo.responsesItems.deleteAll();
+
       // A fresh WS session for the same api key has its own empty cache; with
       // the repo wiped, the snapshot is unreachable.
       const sessionB = await connectResponsesWebSocket(apiKey.key);
diff --git a/packages/gateway/src/data-plane/chat/shared/affinity/candidate_test.ts b/packages/gateway/src/data-plane/chat/shared/affinity/candidate_test.ts
new file mode 100644
index 000000000..ddcccec99
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/shared/affinity/candidate_test.ts
@@ -0,0 +1,111 @@
+import { describe, expect, test } from 'vitest';
+
+import { routeCandidatesByAffinity } from './index.ts';
+import type { AffinityEvidence, AffinityTarget } from './index.ts';
+import type { AliasRules } from '@floway-dev/protocols/common';
+import { stubModelCandidate } from '@floway-dev/test-utils';
+
+const candidate = (upstream: string, model: string, rules?: AliasRules) => {
+  const base = stubModelCandidate();
+  const value = stubModelCandidate({
+    provider: { ...base.provider, upstream },
+    model: { id: model },
+  });
+  return rules === undefined ? value : { ...value, rules };
+};
+
+const targetFor = (value: ReturnType<typeof candidate>): AffinityTarget => ({
+  upstreamId: value.provider.upstream,
+  modelId: value.model.id,
+  ...(value.rules !== undefined ? { rules: value.rules } : {}),
+});
+
+const evidence = (value: ReturnType<typeof candidate>, mode: AffinityEvidence['mode'] = 'prefer'): AffinityEvidence => ({
+  target: targetFor(value),
+  mode,
+});
+
+describe('client-carried affinity candidate routing', () => {
+  test('orders preference by exact optional alias rules', () => {
+    const direct = candidate('up-a', 'model-a');
+    const alias = candidate('up-a', 'model-a', {});
+
+    expect(routeCandidatesByAffinity([alias, direct], [evidence(direct)])).toEqual({
+      kind: 'success',
+      candidates: [direct, alias],
+    });
+    expect(routeCandidatesByAffinity([direct, alias], [evidence(alias)])).toEqual({
+      kind: 'success',
+      candidates: [alias, direct],
+    });
+  });
+
+  test('moves the latest available preferred target to the front', () => {
+    const first = candidate('up-a', 'model');
+    const second = candidate('up-b', 'model');
+    const decision = routeCandidatesByAffinity(
+      [first, second],
+      [evidence(first), evidence(second)],
+    );
+
+    expect(decision.kind).toBe('success');
+    if (decision.kind !== 'success') throw new Error('Expected successful routing');
+    expect(decision.candidates).toEqual([second, first]);
+  });
+
+  test('keeps normal order when a preferred target is unavailable', () => {
+    const first = candidate('up-a', 'model');
+    const second = candidate('up-b', 'model');
+    const unavailable = candidate('up-c', 'model');
+
+    expect(routeCandidatesByAffinity([first, second], [evidence(unavailable)])).toEqual({
+      kind: 'success',
+      candidates: [first, second],
+    });
+  });
+
+  test('uses the latest preferred target that remains available', () => {
+    const first = candidate('up-a', 'model');
+    const second = candidate('up-b', 'model');
+    const unavailable = candidate('up-c', 'model');
+
+    expect(routeCandidatesByAffinity([second, first], [evidence(first), evidence(unavailable)])).toEqual({
+      kind: 'success',
+      candidates: [first, second],
+    });
+  });
+
+  test('force matches upstream and model without narrowing alias rules', () => {
+    const direct = candidate('up-a', 'model');
+    const alias = candidate('up-a', 'model', {});
+
+    expect(routeCandidatesByAffinity([direct, alias], [evidence(alias, 'force')])).toEqual({
+      kind: 'success',
+      candidates: [direct, alias],
+    });
+  });
+
+  test('exact preference still orders rule variants inside a shared force target', () => {
+    const direct = candidate('up-a', 'model');
+    const alias = candidate('up-a', 'model', {});
+
+    expect(routeCandidatesByAffinity(
+      [direct, alias],
+      [evidence(direct, 'force'), evidence(alias, 'force'), evidence(alias)],
+    )).toEqual({
+      kind: 'success',
+      candidates: [alias, direct],
+    });
+  });
+
+  test('fails unavailable and conflicting force affinity', () => {
+    const first = candidate('up-a', 'model');
+    const second = candidate('up-b', 'model');
+
+    expect(routeCandidatesByAffinity([first], [evidence(second, 'force')])).toMatchObject({ kind: 'failure' });
+    expect(routeCandidatesByAffinity([first, second], [
+      evidence(first, 'force'),
+      evidence(second, 'force'),
+    ])).toMatchObject({ kind: 'failure' });
+  });
+});
diff --git a/packages/gateway/src/data-plane/chat/shared/affinity/codec_test.ts b/packages/gateway/src/data-plane/chat/shared/affinity/codec_test.ts
new file mode 100644
index 000000000..fb06e2785
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/shared/affinity/codec_test.ts
@@ -0,0 +1,110 @@
+import { describe, expect, test } from 'vitest';
+
+import { AffinityCodec } from './index.ts';
+import type { AffinityTarget } from './index.ts';
+
+const SECRET = '00'.repeat(32);
+const OTHER_SECRET = '11'.repeat(32);
+const DOMAIN = 'test.carrier';
+const affinity: AffinityTarget = {
+  upstreamId: 'upstream-a',
+  modelId: 'model-a',
+};
+
+describe('AffinityCodec', () => {
+  test.each([
+    ['raw', 'not base64!'],
+    ['base64', btoa('upstream opaque bytes')],
+    ['base64url', '--__'],
+    ['empty raw', ''],
+  ])('round-trips %s input', async (_label, original) => {
+    const codec = new AffinityCodec(SECRET);
+    const wrapped = await codec.wrap(original, affinity, DOMAIN);
+    const decoded = await codec.unwrap(wrapped, DOMAIN);
+
+    expect(decoded).toEqual({
+      kind: 'owned',
+      value: original,
+      envelope: {
+        version: 1,
+        origin: _label === 'base64' ? 'base64' : _label === 'base64url' ? 'base64url' : 'raw',
+        affinity,
+      },
+    });
+  });
+
+  test('uses no origin for a synthetic carrier', async () => {
+    const codec = new AffinityCodec(SECRET);
+    const wrapped = await codec.wrap(undefined, affinity, DOMAIN);
+
+    expect(await codec.unwrap(wrapped, DOMAIN)).toEqual({
+      kind: 'owned',
+      envelope: { version: 1, affinity },
+    });
+  });
+
+  test('does not base64-encode canonical base64 bytes a second time', async () => {
+    const codec = new AffinityCodec(SECRET);
+    const originalBytes = crypto.getRandomValues(new Uint8Array(48));
+    const original = btoa(String.fromCharCode(...originalBytes));
+    const wrapped = await codec.wrap(original, affinity, DOMAIN);
+    const framedBytes = Uint8Array.from(atob(wrapped), char => char.charCodeAt(0));
+
+    expect(framedBytes.subarray(0, originalBytes.length)).toEqual(originalBytes);
+  });
+
+  test.each(['\ud800', '\udfff', `a\ud800${String.fromCodePoint(0x1f600)}\udfffz`])(
+    'round-trips raw UTF-16 code units exactly',
+    async original => {
+      const codec = new AffinityCodec(SECRET);
+      const wrapped = await codec.wrap(original, affinity, DOMAIN);
+      expect(await codec.unwrap(wrapped, DOMAIN)).toMatchObject({ kind: 'owned', value: original });
+    },
+  );
+
+  test('preserves a foreign value byte-for-byte on authentication failure', async () => {
+    const wrapped = await new AffinityCodec(SECRET).wrap('opaque', affinity, DOMAIN);
+
+    expect(await new AffinityCodec(OTHER_SECRET).unwrap(wrapped, DOMAIN)).toEqual({ kind: 'foreign', value: wrapped });
+  });
+
+  test('preserves malformed and tampered values as foreign', async () => {
+    const codec = new AffinityCodec(SECRET);
+    const wrapped = await codec.wrap('opaque', affinity, DOMAIN);
+    const bytes = Uint8Array.from(atob(wrapped), char => char.charCodeAt(0));
+    bytes[bytes.length - 3] ^= 1;
+    const tampered = btoa(String.fromCharCode(...bytes));
+
+    expect(await codec.unwrap('not-an-envelope', DOMAIN)).toEqual({ kind: 'foreign', value: 'not-an-envelope' });
+    expect(await codec.unwrap(tampered, DOMAIN)).toEqual({ kind: 'foreign', value: tampered });
+  });
+
+  test('unwraps nested gateway carriers one layer at a time', async () => {
+    const innerCodec = new AffinityCodec(OTHER_SECRET);
+    const outerCodec = new AffinityCodec(SECRET);
+    const inner = await innerCodec.wrap('upstream', affinity, DOMAIN);
+    const outer = await outerCodec.wrap(inner, { ...affinity, upstreamId: 'inner-gateway' }, DOMAIN);
+
+    const outerDecoded = await outerCodec.unwrap(outer, DOMAIN);
+    expect(outerDecoded.kind).toBe('owned');
+    if (outerDecoded.kind !== 'owned') throw new Error('Expected owned outer carrier');
+    expect(outerDecoded.value).toBe(inner);
+    expect(await innerCodec.unwrap(outerDecoded.value!, DOMAIN)).toMatchObject({ kind: 'owned', value: 'upstream' });
+  });
+
+  test('authenticates the carrier domain and original bytes', async () => {
+    const codec = new AffinityCodec(SECRET);
+    const wrapped = await codec.wrap('opaque', affinity, DOMAIN);
+    expect(await codec.unwrap(wrapped, 'other.carrier')).toEqual({ kind: 'foreign', value: wrapped });
+
+    const bytes = Uint8Array.from(atob(wrapped), char => char.charCodeAt(0));
+    bytes[0] ^= 1;
+    const transplanted = btoa(String.fromCharCode(...bytes));
+    expect(await codec.unwrap(transplanted, DOMAIN)).toEqual({ kind: 'foreign', value: transplanted });
+  });
+
+  test('rejects malformed secrets', () => {
+    expect(() => new AffinityCodec('00')).toThrow(TypeError);
+    expect(() => new AffinityCodec('AA'.repeat(32))).toThrow(TypeError);
+  });
+});
diff --git a/packages/gateway/src/data-plane/chat/shared/affinity/index.ts b/packages/gateway/src/data-plane/chat/shared/affinity/index.ts
new file mode 100644
index 000000000..bb864a903
--- /dev/null
+++ b/packages/gateway/src/data-plane/chat/shared/affinity/index.ts
@@ -0,0 +1,402 @@
+import { isEqual } from 'es-toolkit';
+
+import { serverSecretBytes } from '../../../../shared/server-secret.ts';
+import type { ChatGatewayCtx, GatewayCtx } from '../gateway-ctx.ts';
+import type { RoutingDecision } from '../routing.ts';
+import type { AliasRules } from '@floway-dev/protocols/common';
+import type { ModelCandidate } from '@floway-dev/provider';
+
+type AffinityOrigin = 'raw' | 'base64' | 'base64url';
+
+export interface AffinityTarget {
+  upstreamId: string;
+  modelId: string;
+  rules?: AliasRules;
+  upstreamItemId?: string;
+  syntheticItem?: true;
+  boundItem?: { type: string; upstreamItemId?: string; contentHash: string };
+}
+
+export interface AffinityEvidence {
+  readonly target: AffinityTarget;
+  readonly mode: 'prefer' | 'force';
+}
+
+interface AffinityEnvelope {
+  version: 1;
+  origin?: AffinityOrigin;
+  affinity: AffinityTarget;
+}
+
+export type DecodedAffinityBlob =
+  | { kind: 'foreign'; value: string }
+  | { kind: 'owned'; value?: string; envelope: AffinityEnvelope };
+
+export interface PreparedAffinityPayload<T> {
+  readonly routingEvidence: readonly AffinityEvidence[];
+  readonly payloadForCandidate: (candidate: ModelCandidate) => T;
+}
+
+const IV_BYTES = 12;
+const LENGTH_MARKER_BYTES = 2;
+const MAX_UINT16 = 0xffff;
+const textEncoder = new TextEncoder();
+const fatalTextDecoder = new TextDecoder('utf-8', { fatal: true });
+
+const bytesToBase64 = (bytes: Uint8Array): string => {
+  let binary = '';
+  for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+  }
+  return btoa(binary);
+};
+
+const base64ToBytes = (value: string): Uint8Array => {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+};
+
+const bytesToBase64url = (bytes: Uint8Array): string =>
+  bytesToBase64(bytes).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+
+const base64urlToBytes = (value: string): Uint8Array => {
+  const standard = value.replaceAll('-', '+').replaceAll('_', '/');
+  const padding = (4 - standard.length % 4) % 4;
+  return base64ToBytes(`${standard}${'='.repeat(padding)}`);
+};
+
+const decodeCanonicalBase64 = (value: string): Uint8Array | null => {
+  try {
+    const bytes = base64ToBytes(value);
+    return bytesToBase64(bytes) === value ? bytes : null;
+  } catch {
+    return null;
+  }
+};
+
+const decodeCanonicalBase64url = (value: string): Uint8Array | null => {
+  try {
+    const bytes = base64urlToBytes(value);
+    return bytesToBase64url(bytes) === value ? bytes : null;
+  } catch {
+    return null;
+  }
+};
+
+const rawStringToBytes = (value: string): Uint8Array => {
+  const bytes = new Uint8Array(value.length * 2);
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    bytes[index * 2] = codeUnit >>> 8;
+    bytes[index * 2 + 1] = codeUnit & 0xff;
+  }
+  return bytes;
+};
+
+const rawStringFromBytes = (bytes: Uint8Array): string => {
+  if (bytes.length % 2 !== 0) throw new TypeError('Raw affinity value has an odd byte length');
+  let value = '';
+  for (let offset = 0; offset < bytes.length; offset += 2) {
+    value += String.fromCharCode((bytes[offset] << 8) | bytes[offset + 1]);
+  }
+  return value;
+};
+
+const decodeOriginal = (value: string): { bytes: Uint8Array; origin: AffinityOrigin } => {
+  if (value.length > 0) {
+    const base64 = decodeCanonicalBase64(value);
+    if (base64 !== null) return { bytes: base64, origin: 'base64' };
+    const base64url = decodeCanonicalBase64url(value);
+    if (base64url !== null) return { bytes: base64url, origin: 'base64url' };
+  }
+  return { bytes: rawStringToBytes(value), origin: 'raw' };
+};
+
+const encodeOriginal = (bytes: Uint8Array, origin: AffinityOrigin): string => {
+  switch (origin) {
+  case 'base64': return bytesToBase64(bytes);
+  case 'base64url': return bytesToBase64url(bytes);
+  case 'raw': return rawStringFromBytes(bytes);
+  }
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const parseEnvelope = (value: unknown): AffinityEnvelope | null => {
+  if (!isRecord(value) || value.version !== 1 || !isRecord(value.affinity)) return null;
+  const origin = value.origin;
+  if (origin !== undefined && origin !== 'raw' && origin !== 'base64' && origin !== 'base64url') return null;
+
+  const affinity = value.affinity;
+  if (
+    typeof affinity.upstreamId !== 'string'
+    || typeof affinity.modelId !== 'string'
+    || (affinity.upstreamItemId !== undefined && typeof affinity.upstreamItemId !== 'string')
+    || (affinity.syntheticItem !== undefined && affinity.syntheticItem !== true)
+    || (affinity.boundItem !== undefined && (
+      !isRecord(affinity.boundItem)
+      || typeof affinity.boundItem.type !== 'string'
+      || (affinity.boundItem.upstreamItemId !== undefined && typeof affinity.boundItem.upstreamItemId !== 'string')
+      || typeof affinity.boundItem.contentHash !== 'string'
+      || !/^[0-9a-f]{64}$/.test(affinity.boundItem.contentHash)
+    ))
+    || (affinity.rules !== undefined && !isRecord(affinity.rules))
+  ) return null;
+
+  const parsedAffinity: AffinityTarget = {
+    upstreamId: affinity.upstreamId,
+    modelId: affinity.modelId,
+    ...(affinity.rules !== undefined ? { rules: affinity.rules as AliasRules } : {}),
+    ...(affinity.upstreamItemId !== undefined ? { upstreamItemId: affinity.upstreamItemId } : {}),
+    ...(affinity.syntheticItem === true ? { syntheticItem: true } : {}),
+    ...(affinity.boundItem !== undefined
+      ? {
+          boundItem: {
+            type: affinity.boundItem.type as string,
+            ...(affinity.boundItem.upstreamItemId !== undefined
+              ? { upstreamItemId: affinity.boundItem.upstreamItemId as string }
+              : {}),
+            contentHash: affinity.boundItem.contentHash as string,
+          },
+        }
+      : {}),
+  };
+  return {
+    version: 1,
+    ...(origin !== undefined ? { origin } : {}),
+    affinity: parsedAffinity,
+  };
+};
+
+const concatBytes = (...parts: readonly Uint8Array[]): Uint8Array => {
+  const result = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+};
+
+const uint16be = (length: number): Uint8Array =>
+  new Uint8Array([length >>> 8, length & 0xff]);
+
+const readTrailingUint16be = (bytes: Uint8Array): number =>
+  (bytes[bytes.length - 2] << 8) | bytes[bytes.length - 1];
+
+const ownedBuffer = (bytes: Uint8Array): ArrayBuffer => new Uint8Array(bytes).buffer;
+
+const deriveAffinityKey = async (serverSecret: Uint8Array): Promise<CryptoKey> => {
+  const root = await crypto.subtle.importKey(
+    'raw',
+    ownedBuffer(serverSecret),
+    'HKDF',
+    false,
+    ['deriveKey'],
+  );
+  return await crypto.subtle.deriveKey(
+    {
+      name: 'HKDF',
+      hash: 'SHA-256',
+      salt: ownedBuffer(textEncoder.encode('Floway server secret v1')),
+      info: ownedBuffer(textEncoder.encode('client-carried affinity v1')),
+    },
+    root,
+    { name: 'AES-GCM', length: 256 },
+    false,
+    ['encrypt', 'decrypt'],
+  );
+};
+
+const authenticatedCarrierData = (domain: string, original: Uint8Array): Uint8Array => {
+  const domainBytes = textEncoder.encode(domain);
+  if (domainBytes.length > MAX_UINT16) throw new RangeError('Affinity carrier domain exceeds the 2-byte length marker');
+  return concatBytes(uint16be(domainBytes.length), domainBytes, original);
+};
+
+export class AffinityCodec {
+  readonly #key: Promise<CryptoKey>;
+
+  constructor(serverSecret: string) {
+    this.#key = deriveAffinityKey(serverSecretBytes(serverSecret));
+  }
+
+  async wrap(value: string | undefined, affinity: AffinityTarget, domain: string): Promise<string> {
+    const original = value === undefined ? undefined : decodeOriginal(value);
+    const originalBytes = original?.bytes ?? new Uint8Array();
+    const envelope: AffinityEnvelope = {
+      version: 1,
+      ...(original !== undefined ? { origin: original.origin } : {}),
+      affinity,
+    };
+    const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+    const ciphertext = new Uint8Array(await crypto.subtle.encrypt(
+      { name: 'AES-GCM', iv, additionalData: ownedBuffer(authenticatedCarrierData(domain, originalBytes)) },
+      await this.#key,
+      textEncoder.encode(JSON.stringify(envelope)),
+    ));
+    const encrypted = concatBytes(iv, ciphertext);
+    if (encrypted.length > MAX_UINT16) throw new RangeError('Encrypted affinity envelope exceeds the 2-byte length marker');
+    const framed = concatBytes(originalBytes, encrypted, uint16be(encrypted.length));
+    return original?.origin === 'base64url' ? bytesToBase64url(framed) : bytesToBase64(framed);
+  }
+
+  async unwrap(value: string, domain: string): Promise<DecodedAffinityBlob> {
+    const framed = decodeCanonicalBase64(value) ?? decodeCanonicalBase64url(value);
+    if (framed === null || framed.length < LENGTH_MARKER_BYTES + IV_BYTES + 16) return { kind: 'foreign', value };
+
+    const encryptedLength = readTrailingUint16be(framed);
+    const originalLength = framed.length - LENGTH_MARKER_BYTES - encryptedLength;
+    if (encryptedLength < IV_BYTES + 16 || originalLength < 0) return { kind: 'foreign', value };
+
+    const encrypted = framed.subarray(originalLength, framed.length - LENGTH_MARKER_BYTES);
+    const original = framed.subarray(0, originalLength);
+    const iv = encrypted.subarray(0, IV_BYTES);
+    const ciphertext = encrypted.subarray(IV_BYTES);
+    const key = await this.#key;
+    const additionalData = ownedBuffer(authenticatedCarrierData(domain, original));
+    try {
+      const plaintext = await crypto.subtle.decrypt(
+        { name: 'AES-GCM', iv: ownedBuffer(iv), additionalData },
+        key,
+        ownedBuffer(ciphertext),
+      );
+      const envelope = parseEnvelope(JSON.parse(fatalTextDecoder.decode(plaintext)) as unknown);
+      if (envelope === null) return { kind: 'foreign', value };
+      if (envelope.origin === undefined) {
+        return original.length === 0
+          ? { kind: 'owned', envelope }
+          : { kind: 'foreign', value };
+      }
+      return { kind: 'owned', value: encodeOriginal(original, envelope.origin), envelope };
+    } catch {
+      return { kind: 'foreign', value };
+    }
+  }
+}
+
+export interface AffinityEgressOptions {
+  readonly codec: Pick<AffinityCodec, 'wrap'>;
+  readonly affinity: AffinityTarget;
+}
+
+const sameForcedTarget = (left: AffinityTarget, right: AffinityTarget): boolean =>
+  left.upstreamId === right.upstreamId && left.modelId === right.modelId;
+
+const affinityTargetForCandidate = (candidate: ModelCandidate): AffinityTarget => ({
+  upstreamId: candidate.provider.upstream,
+  modelId: candidate.model.id,
+  ...(candidate.rules !== undefined ? { rules: candidate.rules } : {}),
+});
+
+const candidateMatchesExactTarget = (candidate: ModelCandidate, affinity: AffinityTarget): boolean =>
+  candidate.provider.upstream === affinity.upstreamId
+  && candidate.model.id === affinity.modelId
+  && isEqual(candidate.rules, affinity.rules);
+
+const candidateMatchesForcedTarget = (candidate: ModelCandidate, affinity: AffinityTarget): boolean =>
+  candidate.provider.upstream === affinity.upstreamId && candidate.model.id === affinity.modelId;
+
+const reorderByLatestAvailablePreference = <T extends ModelCandidate>(
+  candidates: readonly T[],
+  evidence: readonly AffinityEvidence[],
+): readonly T[] => {
+  for (let index = evidence.length - 1; index >= 0; index -= 1) {
+    if (evidence[index].mode !== 'prefer') continue;
+    const preferred = evidence[index].target;
+    const matching = candidates.filter(candidate => candidateMatchesExactTarget(candidate, preferred));
+    if (matching.length === 0) continue;
+    return [
+      ...matching,
+      ...candidates.filter(candidate => !candidateMatchesExactTarget(candidate, preferred)),
+    ];
+  }
+  return candidates;
+};
+
+export const routeCandidatesByAffinity = <T extends ModelCandidate>(
+  candidates: readonly T[],
+  evidence: readonly AffinityEvidence[],
+): RoutingDecision<T> => {
+  const forcing: AffinityTarget[] = [];
+  for (const item of evidence) {
+    if (item.mode === 'force' && !forcing.some(existing => sameForcedTarget(existing, item.target))) forcing.push(item.target);
+  }
+  if (forcing.length > 1) {
+    return {
+      kind: 'failure',
+      failure: {
+        kind: 'routing-unavailable',
+        message: `Client-carried state requires multiple incompatible targets: ${forcing.map(target => `'${target.upstreamId}/${target.modelId}'`).join(', ')}.`,
+      },
+    };
+  }
+
+  const narrowed = forcing.length === 0
+    ? candidates
+    : candidates.filter(candidate => candidateMatchesForcedTarget(candidate, forcing[0]));
+  if (forcing.length === 1 && narrowed.length === 0) {
+    return {
+      kind: 'failure',
+      failure: {
+        kind: 'routing-unavailable',
+        message: `Client-carried state requires unavailable target '${forcing[0].upstreamId}/${forcing[0].modelId}'.`,
+      },
+    };
+  }
+
+  return { kind: 'success', candidates: reorderByLatestAvailablePreference(narrowed, evidence) as readonly T[] };
+};
+
+type CandidateBlob =
+  | { readonly present: false; readonly compatible: boolean }
+  | { readonly present: true; readonly compatible: false; readonly value: string }
+  | { readonly present: true; readonly compatible: true; readonly value: string };
+
+const blobForCompatibility = (decoded: DecodedAffinityBlob, compatible: boolean): CandidateBlob => {
+  if (decoded.kind === 'foreign') return { present: true, compatible: false, value: decoded.value };
+  if (!compatible || decoded.value === undefined) return { present: false, compatible };
+  return { present: true, compatible: true, value: decoded.value };
+};
+
+export const blobForExactCandidate = (decoded: DecodedAffinityBlob, candidate: ModelCandidate): CandidateBlob =>
+  blobForCompatibility(
+    decoded,
+    decoded.kind === 'owned' && candidateMatchesExactTarget(candidate, decoded.envelope.affinity),
+  );
+
+export const blobForForcedCandidate = (decoded: DecodedAffinityBlob, candidate: ModelCandidate): CandidateBlob =>
+  blobForCompatibility(
+    decoded,
+    decoded.kind === 'owned' && candidateMatchesForcedTarget(candidate, decoded.envelope.affinity),
+  );
+
+export const preferredAffinityEvidence = (decoded: Iterable<DecodedAffinityBlob>): AffinityEvidence[] =>
+  [...decoded].flatMap(blob => blob.kind === 'owned' ? [{ target: blob.envelope.affinity, mode: 'prefer' }] : []);
+
+export class AffinityRequestContext {
+  readonly codec: AffinityCodec;
+  #selectedCandidate: ModelCandidate | undefined;
+
+  constructor(secret: string) {
+    this.codec = new AffinityCodec(secret);
+  }
+
+  select(candidate: ModelCandidate): void {
+    this.#selectedCandidate = candidate;
+  }
+
+  selectedTarget(): AffinityTarget {
+    if (this.#selectedCandidate === undefined) throw new Error('Affinity target requested before a candidate was selected');
+    return affinityTargetForCandidate(this.#selectedCandidate);
+  }
+}
+
+export const affinityEgressOptions = (ctx: GatewayCtx): AffinityEgressOptions => {
+  if (!('affinity' in ctx)) throw new Error('Chat event result reached responder without affinity context');
+  const chatCtx = ctx as ChatGatewayCtx;
+  return { codec: chatCtx.affinity.codec, affinity: chatCtx.affinity.selectedTarget() };
+};
diff --git a/packages/gateway/src/data-plane/chat/shared/gateway-ctx.ts b/packages/gateway/src/data-plane/chat/shared/gateway-ctx.ts
index 7e9f29349..468055cf6 100644
--- a/packages/gateway/src/data-plane/chat/shared/gateway-ctx.ts
+++ b/packages/gateway/src/data-plane/chat/shared/gateway-ctx.ts
@@ -1,7 +1,9 @@
+import { AffinityRequestContext } from './affinity/index.ts';
 import type { RequestBody } from './request-body.ts';
 import { type DumpAccumulator, openDumpAccumulator } from '../../../dump/accumulator.ts';
 import { apiKeyFromContext, type AuthedContext, effectiveUpstreamIdsFromContext } from '../../../middleware/auth.ts';
 import { getRuntimeLocation } from '../../../runtime/runtime-info.ts';
+import { ResponsesAttemptState } from '../responses/attempt-state.ts';
 import type { StatefulResponsesStore } from '../responses/items/store.ts';
 import type { BackgroundScheduler } from '@floway-dev/platform';
 import type { PerformanceTelemetryContext } from '@floway-dev/provider';
@@ -48,13 +50,16 @@ export interface GatewayCtx {
   readonly responseHeaders: Headers;
 }
 
-// Chat-protocol ctx — `GatewayCtx` plus the request-scoped stored-items
-// store. Every chat HTTP/WS entry constructs this via
+// Chat-protocol ctx adds the affinity membrane and the Responses invocation
+// state used by native Responses requests or an inner translated Responses
+// call. Every chat HTTP/WS entry constructs this via
 // `createChatGatewayCtxFromHono` and threads it through serve → narrow →
 // attempt. Passthrough endpoints (embeddings / images / completions) have
 // no stored-items concept and stay on plain `GatewayCtx`.
 export interface ChatGatewayCtx extends GatewayCtx {
-  readonly store: StatefulResponsesStore;
+  readonly affinity: AffinityRequestContext;
+  readonly responsesAttemptState: ResponsesAttemptState;
+  readonly store?: StatefulResponsesStore;
 }
 
 export interface CreateGatewayCtxOptions {
@@ -118,18 +123,20 @@ export const finalizeGatewayResponse = (ctx: GatewayCtx, response: Response): Re
   return ctx.dump?.finalize(response) ?? response;
 };
 
-// Chat-protocol counterpart of `createGatewayCtxFromHono`. Calls the base
-// factory, then attaches the stored-items store the caller chose for this
-// protocol. The factory receives `ctx.apiKeyId` so every entry threads the
-// same authoritative id into its store — messages / gemini / chat-completions
-// pass `createNonResponsesSourceStore`; responses HTTP passes
-// `apiKeyId => createResponsesHttpStore(apiKeyId, payload.store)`; responses
-// WS passes `apiKeyId => session.createStore(apiKeyId, payload.store)`.
+// Chat-protocol counterpart of `createGatewayCtxFromHono`. The factory
+// receives the authoritative API-key id. Non-Responses sources leave the store
+// absent even when translation enters a Responses attempt. Native Responses
+// HTTP and WebSocket entries supply their transport-specific store factories.
 export const createChatGatewayCtxFromHono = (
   c: AuthedContext,
   opts: CreateGatewayCtxOptions,
-  storeFactory: (apiKeyId: string) => StatefulResponsesStore,
+  storeFactory?: (apiKeyId: string) => StatefulResponsesStore,
 ): ChatGatewayCtx => {
   const base = createGatewayCtxFromHono(c, opts);
-  return { ...base, store: storeFactory(base.apiKeyId) };
+  return {
+    ...base,
+    affinity: new AffinityRequestContext(apiKeyFromContext(c).serverSecret),
+    responsesAttemptState: new ResponsesAttemptState(),
+    ...(storeFactory !== undefined ? { store: storeFactory(base.apiKeyId) } : {}),
+  };
 };
diff --git a/packages/gateway/src/data-plane/chat/shared/gateway-ctx_test.ts b/packages/gateway/src/data-plane/chat/shared/gateway-ctx_test.ts
index b6362a53c..a33d505ac 100644
--- a/packages/gateway/src/data-plane/chat/shared/gateway-ctx_test.ts
+++ b/packages/gateway/src/data-plane/chat/shared/gateway-ctx_test.ts
@@ -16,6 +16,7 @@ const buildApiKey = (overrides: Partial<ApiKey> = {}): ApiKey => ({
   userId: 1,
   name: 'test',
   key: 'sk-test',
+  serverSecret: '00'.repeat(32),
   createdAt: '2026-01-01T00:00:00.000Z',
   upstreamIds: null,
   deletedAt: null,
diff --git a/packages/gateway/src/data-plane/codex/routes_websocket_test.ts b/packages/gateway/src/data-plane/codex/routes_websocket_test.ts
index a185889c6..a2e314f27 100644
--- a/packages/gateway/src/data-plane/codex/routes_websocket_test.ts
+++ b/packages/gateway/src/data-plane/codex/routes_websocket_test.ts
@@ -3,7 +3,7 @@ import { expect, it } from 'vitest';
 
 import { app as gatewayApp } from '../../app.ts';
 import { copilotModels, setupAppTest, sseResponsesResponse } from '../../test-helpers.ts';
-import { isStoredResponseId } from '../chat/responses/items/format.ts';
+import { isResponsesResponseId } from '../chat/responses/items/format.ts';
 import { jsonResponse, withMockedFetch } from '@floway-dev/test-utils';
 
 type WorkerResponseInit = ResponseInit & { readonly webSocket?: WebSocket };
@@ -175,7 +175,7 @@ it('chains previous_response_id on the Codex Responses WebSocket', async () => {
         response: { model: 'gpt-direct-responses', input: 'codex first', store: false },
       }));
       const firstResponseId = responseDoneId(await firstDone);
-      expect(isStoredResponseId(firstResponseId)).toBe(true);
+      expect(isResponsesResponseId(firstResponseId)).toBe(true);
 
       const secondDone = waitForMessages(client, messages => messages.some(message => message.type === 'response.done'));
       client.send(JSON.stringify({
@@ -188,7 +188,7 @@ it('chains previous_response_id on the Codex Responses WebSocket', async () => {
         },
       }));
       const secondResponseId = responseDoneId(await secondDone);
-      expect(isStoredResponseId(secondResponseId)).toBe(true);
+      expect(isResponsesResponseId(secondResponseId)).toBe(true);
     }),
   );
 
diff --git a/packages/gateway/src/repo/api-keys_test.ts b/packages/gateway/src/repo/api-keys_test.ts
index 498111043..be279d0ff 100644
--- a/packages/gateway/src/repo/api-keys_test.ts
+++ b/packages/gateway/src/repo/api-keys_test.ts
@@ -1,10 +1,11 @@
+import initSqlJs from 'sql.js';
 import { test } from 'vitest';
 
 import { InMemoryRepo } from './memory.ts';
 import { SqlRepo } from './sql.ts';
-import { createSqliteTestDb } from './test-sqlite.ts';
+import { createSqliteTestDb, migrationSqlByFilename } from './test-sqlite.ts';
 import type { ApiKey, Repo } from './types.ts';
-import { assertEquals } from '@floway-dev/test-utils';
+import { assertEquals, assertThrows } from '@floway-dev/test-utils';
 
 const REPO_BACKENDS: Array<readonly [string, () => Promise<Repo>]> = [
   ['memory', async () => new InMemoryRepo()],
@@ -16,6 +17,7 @@ const baseKey = (overrides: Partial<ApiKey> = {}): ApiKey => ({
   userId: 1,
   name: 'Dump key',
   key: 'raw_dump_key',
+  serverSecret: '00'.repeat(32),
   createdAt: '2026-06-19T00:00:00.000Z',
   upstreamIds: null,
   deletedAt: null,
@@ -62,4 +64,63 @@ for (const [backend, makeRepo] of REPO_BACKENDS) {
     const byUser = await repo.apiKeys.listByUserId(1);
     assertEquals(byUser.find(k => k.id === 'key_dump')?.dumpRetentionSeconds, 86_400);
   });
+
+  test(`[${backend}] api keys repo round-trips serverSecret`, async () => {
+    const repo = await makeRepo();
+    const secret = 'ab'.repeat(32);
+    await repo.apiKeys.save(baseKey({ serverSecret: secret }));
+    assertEquals((await repo.apiKeys.findByRawKey('raw_dump_key'))?.serverSecret, secret);
+
+  });
 }
+
+test('migration 0057 backfills distinct server secrets and enforces their canonical form', async () => {
+  const SQL = await initSqlJs();
+  const db = new SQL.Database();
+  try {
+    for (const [filename, sql] of migrationSqlByFilename) {
+      if (filename === '0057_api_key_server_secret.sql') break;
+      db.run(sql);
+    }
+    db.run(`
+      INSERT INTO api_keys (id, user_id, name, key, created_at, upstream_ids, deleted_at, dump_retention_seconds)
+      VALUES
+        ('key_a', 1, 'A', 'raw_a', '2026-01-01T00:00:00.000Z', NULL, NULL, NULL),
+        ('key_b', 1, 'B', 'raw_b', '2026-01-02T00:00:00.000Z', '["up_a"]', NULL, 3600)
+    `);
+
+    const migration = migrationSqlByFilename.find(([filename]) => filename === '0057_api_key_server_secret.sql');
+    if (migration === undefined) throw new Error('missing migration 0057_api_key_server_secret.sql');
+    db.run(migration[1]);
+
+    const [result] = db.exec('SELECT id, upstream_ids, dump_retention_seconds, server_secret FROM api_keys ORDER BY id');
+    if (result === undefined) throw new Error('migration 0057 returned no api_keys rows');
+    const rows = result.values.map(values => Object.fromEntries(result.columns.map((column, index) => [column, values[index]]))) as Array<{
+      id: string;
+      upstream_ids: string | null;
+      dump_retention_seconds: number | null;
+      server_secret: string;
+    }>;
+    assertEquals(rows.map(row => [row.id, row.upstream_ids, row.dump_retention_seconds]), [
+      ['key_a', null, null],
+      ['key_b', '["up_a"]', 3600],
+    ]);
+    assertEquals(rows.every(row => /^[0-9a-f]{64}$/.test(row.server_secret)), true);
+    assertEquals(rows[0]!.server_secret === rows[1]!.server_secret, false);
+
+    assertThrows(
+      () => db.run(`INSERT INTO api_keys (id, user_id, name, key, server_secret, created_at)
+        VALUES ('bad', 1, 'Bad', 'raw_bad', '${'AB'.repeat(32)}', '2026-01-03T00:00:00.000Z')`),
+      Error,
+      'CHECK constraint failed',
+    );
+    assertThrows(
+      () => db.run(`INSERT INTO api_keys (id, user_id, name, key, server_secret, created_at)
+        VALUES ('duplicate', 1, 'Duplicate', 'raw_duplicate', '${rows[0]!.server_secret}', '2026-01-03T00:00:00.000Z')`),
+      Error,
+      'UNIQUE constraint failed: api_keys.server_secret',
+    );
+  } finally {
+    db.close();
+  }
+});
diff --git a/packages/gateway/src/repo/memory.ts b/packages/gateway/src/repo/memory.ts
index ca39ee0e9..5f2a29cb3 100644
--- a/packages/gateway/src/repo/memory.ts
+++ b/packages/gateway/src/repo/memory.ts
@@ -5,10 +5,8 @@ import {
   cloneStoredResponsesItem,
   cloneStoredResponsesSnapshot,
   compareResponsesItemsByFreshness,
-  responsesItemStoreKey,
-  storedResponsesItemMetadata,
+  scopedResponsesKey,
 } from './responses-clone.ts';
-import { RESPONSES_REFRESH_DEBOUNCE_MS } from './responses-payload.ts';
 import type {
   ApiKey,
   ApiKeyRepo,
@@ -36,8 +34,6 @@ import type {
   Session,
   SessionsRepo,
   StoredResponsesItem,
-  StoredResponsesItemMetadata,
-  StoredResponsesItemPayloadRecord,
   StoredResponsesSnapshot,
   UpstreamRepo,
   UsageRecord,
@@ -578,111 +574,57 @@ const cloneUpstreamRecord = (upstream: UpstreamRecord): UpstreamRecord => ({
 class MemoryResponsesItemsRepo implements ResponsesItemsRepo {
   private store = new Map<string, StoredResponsesItem>();
 
-  lookupMany(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemMetadata[]> {
+  lookupMany(apiKeyId: string, ids: readonly string[]): Promise<StoredResponsesItem[]> {
     return Promise.resolve(this.lookupManySync(apiKeyId, ids));
   }
 
-  lookupManyByEncryptedContentHash(apiKeyId: string | null, hashes: readonly string[]): Promise<StoredResponsesItemMetadata[]> {
+  lookupManyByContentHash(apiKeyId: string, hashes: readonly string[]): Promise<StoredResponsesItem[]> {
     const wanted = new Set(hashes);
     if (wanted.size === 0) return Promise.resolve([]);
-    const rows: StoredResponsesItemMetadata[] = [];
-    for (const row of this.store.values()) {
-      if (row.apiKeyId === apiKeyId && row.encryptedContentHash !== null && wanted.has(row.encryptedContentHash)) {
-        rows.push(storedResponsesItemMetadata(row));
-      }
-    }
-    return Promise.resolve(rows.toSorted(compareResponsesItemsByFreshness));
-  }
-
-  lookupManyByContentHash(apiKeyId: string | null, hashes: readonly string[]): Promise<StoredResponsesItemMetadata[]> {
-    const wanted = new Set(hashes);
-    if (wanted.size === 0) return Promise.resolve([]);
-    const rows: StoredResponsesItemMetadata[] = [];
+    const rows: StoredResponsesItem[] = [];
     for (const row of this.store.values()) {
       if (row.apiKeyId === apiKeyId && row.contentHash !== null && wanted.has(row.contentHash)) {
-        rows.push(storedResponsesItemMetadata(row));
+        rows.push(cloneStoredResponsesItem(row));
       }
     }
     return Promise.resolve(rows.toSorted(compareResponsesItemsByFreshness));
   }
 
-  lookupPayloads(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemPayloadRecord[]> {
-    const records: StoredResponsesItemPayloadRecord[] = [];
-    for (const metadata of this.lookupManySync(apiKeyId, ids)) {
-      const row = this.store.get(responsesItemStoreKey(apiKeyId, metadata.id));
-      if (row !== undefined && row.payload !== null) records.push({ id: row.id, payload: structuredClone(row.payload) });
-    }
-    return Promise.resolve(records);
-  }
-
-  private lookupManySync(apiKeyId: string | null, ids: readonly string[]): StoredResponsesItemMetadata[] {
-    const rows: StoredResponsesItemMetadata[] = [];
+  private lookupManySync(apiKeyId: string, ids: readonly string[]): StoredResponsesItem[] {
+    const rows: StoredResponsesItem[] = [];
     const seen = new Set<string>();
     for (const id of ids) {
       if (seen.has(id)) continue;
       seen.add(id);
-      const row = this.store.get(responsesItemStoreKey(apiKeyId, id));
-      if (row?.apiKeyId === apiKeyId) rows.push(storedResponsesItemMetadata(row));
+      const row = this.store.get(scopedResponsesKey(apiKeyId, id));
+      if (row !== undefined) rows.push(cloneStoredResponsesItem(row));
     }
     return rows;
   }
 
   insertMany(items: readonly StoredResponsesItem[]): Promise<void> {
     for (const item of items) {
-      const key = responsesItemStoreKey(item.apiKeyId, item.id);
+      const key = scopedResponsesKey(item.apiKeyId, item.id);
       if (this.store.has(key)) continue;
       this.store.set(key, cloneStoredResponsesItem(item));
     }
     return Promise.resolve();
   }
 
-  fillPayloads(items: readonly StoredResponsesItem[]): Promise<number> {
-    let changes = 0;
-    for (const item of items) {
-      if (item.payload === null) continue;
-      const existing = this.store.get(responsesItemStoreKey(item.apiKeyId, item.id));
-      // Row may be absent if a concurrent TTL prune removed it between load and persist;
-      // SQL's `UPDATE ... WHERE id = ?` is a no-op in the same case, so we mirror that.
-      if (existing === undefined) continue;
-      if (existing.payload !== null) continue;
-      existing.payload = structuredClone(item.payload);
-      existing.contentHash = item.contentHash;
-      existing.encryptedContentHash = item.encryptedContentHash;
-      existing.createdAt = item.createdAt;
-      existing.refreshedAt = Math.max(existing.refreshedAt, item.refreshedAt);
-      changes += 1;
-    }
-    return Promise.resolve(changes);
-  }
-
-  refreshMany(apiKeyId: string | null, ids: readonly string[], refreshedAt: number): Promise<number> {
-    let changes = 0;
-    const cutoff = refreshedAt - RESPONSES_REFRESH_DEBOUNCE_MS;
-    for (const id of new Set(ids)) {
-      const row = this.store.get(responsesItemStoreKey(apiKeyId, id));
-      if (row && row.refreshedAt < cutoff) {
-        row.refreshedAt = refreshedAt;
-        changes += 1;
-      }
-    }
-    return Promise.resolve(changes);
-  }
-
-  clearPayloadOlderThan(createdBefore: number): Promise<number> {
-    let changes = 0;
-    for (const row of this.store.values()) {
-      if (row.createdAt < createdBefore && row.payload !== null) {
-        row.payload = null;
-        changes += 1;
-      }
+  refreshMany(items: readonly StoredResponsesItem[], createdAt: number): Promise<void> {
+    const existing = items.map(item => this.store.get(scopedResponsesKey(item.apiKeyId, item.id)));
+    const missingIndex = existing.findIndex(item => item === undefined);
+    if (missingIndex !== -1) {
+      return Promise.reject(new Error(`Responses item disappeared before lifetime refresh: ${items[missingIndex].id}`));
     }
-    return Promise.resolve(changes);
+    for (const item of existing) item!.createdAt = createdAt;
+    return Promise.resolve();
   }
 
-  deleteOlderThan(refreshedBefore: number): Promise<number> {
+  deleteOlderThan(createdBefore: number): Promise<number> {
     let changes = 0;
     for (const [key, row] of this.store) {
-      if (row.refreshedAt < refreshedBefore) {
+      if (row.createdAt < createdBefore) {
         this.store.delete(key);
         changes += 1;
       }
@@ -699,27 +641,20 @@ class MemoryResponsesItemsRepo implements ResponsesItemsRepo {
 class MemoryResponsesSnapshotsRepo implements ResponsesSnapshotsRepo {
   private store = new Map<string, StoredResponsesSnapshot>();
 
-  lookup(apiKeyId: string | null, id: string): Promise<StoredResponsesSnapshot | null> {
-    const snapshot = this.store.get(responsesItemStoreKey(apiKeyId, id));
+  lookup(apiKeyId: string, id: string): Promise<StoredResponsesSnapshot | null> {
+    const snapshot = this.store.get(scopedResponsesKey(apiKeyId, id));
     return Promise.resolve(snapshot ? cloneStoredResponsesSnapshot(snapshot) : null);
   }
 
   insert(snapshot: StoredResponsesSnapshot): Promise<void> {
-    this.store.set(responsesItemStoreKey(snapshot.apiKeyId, snapshot.id), cloneStoredResponsesSnapshot(snapshot));
+    this.store.set(scopedResponsesKey(snapshot.apiKeyId, snapshot.id), cloneStoredResponsesSnapshot(snapshot));
     return Promise.resolve();
   }
 
-  refresh(apiKeyId: string | null, id: string, refreshedAt: number): Promise<boolean> {
-    const snapshot = this.store.get(responsesItemStoreKey(apiKeyId, id));
-    if (!snapshot || snapshot.refreshedAt >= refreshedAt - RESPONSES_REFRESH_DEBOUNCE_MS) return Promise.resolve(false);
-    snapshot.refreshedAt = refreshedAt;
-    return Promise.resolve(true);
-  }
-
-  deleteOlderThan(refreshedBefore: number): Promise<number> {
+  deleteOlderThan(createdBefore: number): Promise<number> {
     let changes = 0;
     for (const [key, snapshot] of this.store) {
-      if (snapshot.refreshedAt < refreshedBefore) {
+      if (snapshot.createdAt < createdBefore) {
         this.store.delete(key);
         changes += 1;
       }
diff --git a/packages/gateway/src/repo/responses-clone.ts b/packages/gateway/src/repo/responses-clone.ts
index f36d950f7..1f0d84867 100644
--- a/packages/gateway/src/repo/responses-clone.ts
+++ b/packages/gateway/src/repo/responses-clone.ts
@@ -1,27 +1,19 @@
-import type { StoredResponsesItem, StoredResponsesItemMetadata, StoredResponsesSnapshot } from './types.ts';
+import type { StoredResponsesItem, StoredResponsesSnapshot } from './types.ts';
 
 export const cloneStoredResponsesItem = (item: StoredResponsesItem): StoredResponsesItem => ({
   ...item,
-  payload: item.payload === null ? null : structuredClone(item.payload),
+  payload: structuredClone(item.payload),
 });
 
-export const storedResponsesItemMetadata = (item: StoredResponsesItem): StoredResponsesItemMetadata => {
-  const { payload, ...metadata } = item;
-  return { ...metadata, hasPayload: payload !== null };
-};
-
-export const cloneStoredResponsesItemMetadata = (item: StoredResponsesItemMetadata): StoredResponsesItemMetadata => ({ ...item });
-
 export const cloneStoredResponsesSnapshot = (snapshot: StoredResponsesSnapshot): StoredResponsesSnapshot => ({
   ...snapshot,
   itemIds: [...snapshot.itemIds],
 });
 
-export const responsesItemStoreKey = (apiKeyId: string | null, id: string): string =>
-  `${apiKeyId ?? ''}\0${id}`;
+export const scopedResponsesKey = (apiKeyId: string, id: string): string => `${apiKeyId}\0${id}`;
 
 export const compareResponsesItemsByFreshness = (
-  a: Pick<StoredResponsesItemMetadata, 'id' | 'createdAt' | 'refreshedAt'>,
-  b: Pick<StoredResponsesItemMetadata, 'id' | 'createdAt' | 'refreshedAt'>,
+  a: Pick<StoredResponsesItem, 'id' | 'createdAt'>,
+  b: Pick<StoredResponsesItem, 'id' | 'createdAt'>,
 ): number =>
-  b.refreshedAt - a.refreshedAt || b.createdAt - a.createdAt || a.id.localeCompare(b.id);
+  b.createdAt - a.createdAt || a.id.localeCompare(b.id);
diff --git a/packages/gateway/src/repo/responses-items_test.ts b/packages/gateway/src/repo/responses-items_test.ts
index 23e4e18ac..e125544c8 100644
--- a/packages/gateway/src/repo/responses-items_test.ts
+++ b/packages/gateway/src/repo/responses-items_test.ts
@@ -1,851 +1,487 @@
 import initSqlJs from 'sql.js';
-import { test, vi } from 'vitest';
+import { describe, expect, test, vi } from 'vitest';
 
 import { InMemoryRepo } from './memory.ts';
-import { storedResponsesItemMetadata } from './responses-clone.ts';
+import { serializeStoredResponsesPayload } from './responses-payload.ts';
 import { SqlRepo } from './sql.ts';
-import type { ResponsesItemsRepo, StoredResponsesItem } from './types.ts';
-import { initFileProvider, MemoryFileProvider, sha256Hex, type FileProvider, type SqlDatabase } from '@floway-dev/platform';
-import { assert, assertEquals, assertRejects } from '@floway-dev/test-utils';
-
-// `refreshMany` debounces writes within a 24h window, so refresh-related
-// assertions need timestamps that span more than a day to actually exercise
-// the update path. Scaling every numeric timestamp by DAY_MS keeps the
-// existing assertions ordering and arithmetic intact while making refresh
-// gaps comfortably exceed the debounce.
-const DAY_MS = 24 * 60 * 60 * 1000;
-
-// gzip flattens long runs of a single character almost to nothing; spill tests
-// need a body that resists compression so it actually crosses the inline
-// threshold.
-const incompressibleString = (approxBytes: number): string => {
-  const bytes = new Uint8Array(Math.ceil(approxBytes / 2));
-  crypto.getRandomValues(bytes);
-  let hex = '';
-  for (const byte of bytes) hex += byte.toString(16).padStart(2, '0');
-  return hex.slice(0, approxBytes);
-};
-
-const storedItem = (overrides: Partial<StoredResponsesItem> & Pick<StoredResponsesItem, 'id' | 'apiKeyId' | 'createdAt'>): StoredResponsesItem => ({
-  upstreamId: null,
-  upstreamItemId: null,
+import { createSqliteTestDb, migrationSqlByFilename } from './test-sqlite.ts';
+import type { Repo, StoredResponsesItem } from './types.ts';
+import { initFileProvider, MemoryFileProvider, type SqlDatabase, type SqlPreparedStatement } from '@floway-dev/platform';
+
+const factories: Array<[string, () => Promise<Repo>]> = [
+  ['memory', async () => new InMemoryRepo()],
+  ['sql', async () => new SqlRepo(await createSqliteTestDb())],
+];
+
+const storedItem = (id: string, apiKeyId: string, contentHash: string | null, createdAt: number): StoredResponsesItem => ({
+  id,
+  apiKeyId,
   itemType: 'message',
-  origin: 'upstream',
-  contentHash: null,
-  encryptedContentHash: null,
-  payload: { item: { id: overrides.id, type: 'message', content: [{ type: 'output_text', text: overrides.id }] } },
-  refreshedAt: overrides.createdAt,
-  ...overrides,
+  payload: { item: { type: 'message', id, role: 'assistant', content: [] } },
+  contentHash,
+  createdAt,
 });
 
-const createDeferred = <T>(): { promise: Promise<T>; resolve: (value: T) => void } => {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>(accept => { resolve = accept; });
-  return { promise, resolve };
+const spilledItem = (id: string, apiKeyId: string, createdAt: number): StoredResponsesItem => {
+  const bytes = new Uint8Array(128 * 1024);
+  crypto.getRandomValues(bytes.subarray(0, 64 * 1024));
+  crypto.getRandomValues(bytes.subarray(64 * 1024));
+  let content = '';
+  for (const byte of bytes) content += byte.toString(16).padStart(2, '0');
+  return {
+    ...storedItem(id, apiKeyId, `${id}-hash`, createdAt),
+    payload: { item: { type: 'message', id, role: 'assistant', content } },
+  };
 };
 
-class GatedReadFileProvider implements FileProvider {
-  private readonly bodies = new Map<string, Uint8Array>();
-  private readonly firstGet = createDeferred<void>();
-  private readonly release = createDeferred<void>();
-  private released = false;
-  getCalls = 0;
-
-  put(key: string, body: Uint8Array): Promise<void> {
-    this.bodies.set(key, body.slice());
-    return Promise.resolve();
-  }
-
-  async get(key: string): Promise<Uint8Array | null> {
-    this.getCalls++;
-    this.firstGet.resolve();
-    if (!this.released) await this.release.promise;
-    return this.bodies.get(key)?.slice() ?? null;
-  }
-
-  deletePrefix(prefix: string): Promise<void> {
-    for (const key of this.bodies.keys()) {
-      if (key.startsWith(prefix)) this.bodies.delete(key);
-    }
-    return Promise.resolve();
-  }
-
-  listKeys(prefix: string): Promise<string[]> {
-    return Promise.resolve([...this.bodies.keys()].filter(key => key.startsWith(prefix)));
-  }
+const sqlDatabaseWithBatch = (
+  base: SqlDatabase,
+  runBatch: (statements: SqlPreparedStatement[]) => Promise<Awaited<ReturnType<NonNullable<SqlDatabase['batch']>>>>,
+): SqlDatabase => ({
+  prepare: query => base.prepare(query),
+  exec: sql => base.exec(sql),
+  batch: runBatch,
+});
 
-  waitForFirstGet(): Promise<void> {
-    return this.firstGet.promise;
-  }
+class DeleteHookFileProvider extends MemoryFileProvider {
+  beforeDelete: ((key: string) => Promise<void>) | undefined;
 
-  releaseAll(): void {
-    this.released = true;
-    this.release.resolve();
+  override async deletePrefix(prefix: string): Promise<void> {
+    const beforeDelete = this.beforeDelete;
+    this.beforeDelete = undefined;
+    await beforeDelete?.(prefix);
+    await super.deletePrefix(prefix);
   }
 }
 
-const runWithCompressionBlocked = async <T>(run: () => Promise<T>): Promise<{ started: number; result: T }> => {
-  const NativeCompressionStream = globalThis.CompressionStream;
-  const release = createDeferred<void>();
-  let started = 0;
-
-  class GatedCompressionStream {
-    readonly readable: ReadableStream<Uint8Array>;
-    readonly writable: WritableStream<BufferSource>;
-
-    constructor(format: CompressionFormat) {
-      started++;
-      const native = new NativeCompressionStream(format);
-      const writer = native.writable.getWriter();
-      this.readable = native.readable;
-      this.writable = new WritableStream<BufferSource>({
-        async write(chunk) {
-          await release.promise;
-          await writer.write(chunk);
-        },
-        async close() { await writer.close(); },
-        async abort(reason) { await writer.abort(reason); },
-      });
-    }
-  }
+describe.each(factories)('%s Responses state repo', (_name, createRepo) => {
+  test('stores complete key-scoped items and looks them up by id and content hash', async () => {
+    initFileProvider(new MemoryFileProvider());
+    const repo = await createRepo();
+    const first = storedItem('msg_first', 'key-a', 'hash-a', 1_000);
+    const second = storedItem('msg_second', 'key-a', 'hash-b', 2_000);
+    const other = storedItem('msg_other', 'key-b', 'hash-a', 3_000);
+    const legacy = storedItem('msg_legacy', 'key-a', null, 4_000);
 
-  vi.stubGlobal('CompressionStream', GatedCompressionStream);
-  try {
-    const pending = run();
-    const startedBeforeRelease = started;
-    release.resolve();
-    return { started: startedBeforeRelease, result: await pending };
-  } finally {
-    vi.unstubAllGlobals();
-  }
-};
+    await repo.responsesItems.insertMany([first, second, other, legacy]);
 
-const exerciseResponsesItemsRepo = async (repo: ResponsesItemsRepo) => {
-  initFileProvider(new MemoryFileProvider());
-  const first = storedItem({
-    id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA',
-    apiKeyId: 'key_a',
-    upstreamId: 'up_azure',
-    upstreamItemId: 'upstream_msg_a',
-    itemType: 'message',
-    contentHash: 'content_hash_a',
-    createdAt: 1_000 * DAY_MS,
+    expect(await repo.responsesItems.lookupMany('key-a', [second.id, legacy.id, first.id])).toEqual([second, legacy, first]);
+    expect(await repo.responsesItems.lookupMany('key-b', [first.id])).toEqual([]);
+    expect(await repo.responsesItems.lookupManyByContentHash('key-a', ['hash-a'])).toEqual([first]);
   });
-  const second = storedItem({
-    id: 'rs_mFBDiA_Lh1uXb7nD_bQb4I1CUYH2w',
-    apiKeyId: 'key_a',
-    upstreamId: 'up_copilot',
-    upstreamItemId: 'opaque_reasoning_id',
-    itemType: 'reasoning',
-    payload: { item: { id: 'rs_mFBDiA_Lh1uXb7nD_bQb4I1CUYH2w', type: 'reasoning', summary: [] } },
-    createdAt: 2_000 * DAY_MS,
-  });
-  const adminScoped = storedItem({
-    id: 'ws_WGRXTA_sVlhxg6BAV0BUzj0KkWSqA',
-    apiKeyId: null,
-    itemType: 'web_search_call',
-    payload: { item: { id: 'ws_WGRXTA_sVlhxg6BAV0BUzj0KkWSqA', type: 'web_search_call', status: 'completed' } },
-    createdAt: 3_000 * DAY_MS,
-  });
-
-  await repo.insertMany([first, second, adminScoped]);
-
-  assertEquals(await repo.lookupMany('key_a', [second.id, adminScoped.id, first.id, 'missing']), [second, first].map(storedResponsesItemMetadata));
-  assertEquals(await repo.lookupMany(null, [first.id, adminScoped.id]), [storedResponsesItemMetadata(adminScoped)]);
-  assertEquals(await repo.lookupMany('key_b', [first.id, second.id, adminScoped.id]), []);
-  assertEquals(await repo.lookupMany('key_a', []), []);
-  assertEquals(await repo.lookupManyByContentHash('key_a', ['content_hash_a']), [storedResponsesItemMetadata(first)]);
-  assertEquals(await repo.lookupManyByContentHash('key_b', ['content_hash_a']), []);
-
-  assertEquals(await repo.refreshMany('key_a', [first.id, first.id, second.id, adminScoped.id, 'missing'], 4_000 * DAY_MS), 2);
-  assertEquals(
-    await repo.lookupMany('key_a', [first.id, second.id]),
-    [
-      { ...first, refreshedAt: 4_000 * DAY_MS },
-      { ...second, refreshedAt: 4_000 * DAY_MS },
-    ].map(storedResponsesItemMetadata),
-  );
-  // Smaller-than-stored refreshedAt: rejected for two overlapping reasons —
-  // the never-go-backwards guard, and (since 3_500*DAY < 4_000*DAY - debounce)
-  // the debounce. Both block, so this assertion holds regardless of which
-  // fires first. The dedicated debounce test below isolates the boundary.
-  assertEquals(await repo.refreshMany('key_a', [first.id], 3_500 * DAY_MS), 0);
-  assertEquals(await repo.refreshMany(null, [adminScoped.id], 5_000 * DAY_MS), 1);
-  const refreshedAdminScoped = { ...adminScoped, refreshedAt: 5_000 * DAY_MS };
-
-  assertEquals(await repo.clearPayloadOlderThan(500 * DAY_MS), 0);
-  assertEquals(await repo.clearPayloadOlderThan(2_500 * DAY_MS), 2);
-  assertEquals(
-    await repo.lookupMany('key_a', [first.id, second.id]),
-    [
-      { ...first, payload: null, refreshedAt: 4_000 * DAY_MS },
-      { ...second, payload: null, refreshedAt: 4_000 * DAY_MS },
-    ].map(storedResponsesItemMetadata),
-  );
-  assertEquals(await repo.lookupMany(null, [adminScoped.id]), [storedResponsesItemMetadata(refreshedAdminScoped)]);
-
-  assertEquals(await repo.deleteOlderThan(3_000 * DAY_MS), 0);
-  assertEquals(await repo.deleteOlderThan(4_500 * DAY_MS), 2);
-  assertEquals(await repo.lookupMany('key_a', [first.id, second.id]), []);
-  assertEquals(await repo.lookupMany(null, [adminScoped.id]), [storedResponsesItemMetadata(refreshedAdminScoped)]);
 
-  await repo.deleteAll();
-  assertEquals(await repo.lookupMany(null, [adminScoped.id]), []);
-};
-
-test('memory responses items repo inserts, looks up by scope, cleans payloads, deletes rows, and clears', async () => {
-  await exerciseResponsesItemsRepo(new InMemoryRepo().responsesItems);
-});
-
-const exerciseRefreshManyDebounce = async (repo: ResponsesItemsRepo) => {
-  initFileProvider(new MemoryFileProvider());
-  const base = Date.UTC(2026, 0, 1);
-  const item = storedItem({
-    id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA',
-    apiKeyId: 'key_a',
-    createdAt: base,
+  test('deletes complete items and snapshots by their refreshable retention timestamp', async () => {
+    initFileProvider(new MemoryFileProvider());
+    const repo = await createRepo();
+    const old = storedItem('msg_old', 'key-a', 'old', 1_000);
+    const fresh = storedItem('msg_fresh', 'key-a', 'fresh', 3_000);
+    await repo.responsesItems.insertMany([old, fresh]);
+    await repo.responsesSnapshots.insert({ id: 'resp_old', apiKeyId: 'key-a', itemIds: [old.id], createdAt: 1_000 });
+    await repo.responsesSnapshots.insert({ id: 'resp_fresh', apiKeyId: 'key-a', itemIds: [fresh.id], createdAt: 3_000 });
+
+    expect(await repo.responsesItems.deleteOlderThan(2_000)).toBe(1);
+    expect(await repo.responsesSnapshots.deleteOlderThan(2_000)).toBe(1);
+    expect(await repo.responsesItems.lookupMany('key-a', [old.id, fresh.id])).toEqual([fresh]);
+    expect(await repo.responsesSnapshots.lookup('key-a', 'resp_old')).toBeNull();
+    expect(await repo.responsesSnapshots.lookup('key-a', 'resp_fresh')).toEqual({
+      id: 'resp_fresh', apiKeyId: 'key-a', itemIds: [fresh.id], createdAt: 3_000,
+    });
   });
-  await repo.insertMany([item]);
-
-  // First touch lifts refreshed_at into the future, where it'll act as the
-  // anchor every subsequent attempt is measured against.
-  assertEquals(await repo.refreshMany('key_a', [item.id], base + 30 * DAY_MS), 1);
-
-  // Within the 24h debounce window the row shouldn't change.
-  assertEquals(await repo.refreshMany('key_a', [item.id], base + 30 * DAY_MS + 12 * 60 * 60 * 1000), 0);
-  assertEquals(await repo.refreshMany('key_a', [item.id], base + 31 * DAY_MS - 1), 0);
-  // Right at the window boundary the cutoff equals refreshed_at, still no
-  // update because the comparison is strictly less-than.
-  assertEquals(await repo.refreshMany('key_a', [item.id], base + 31 * DAY_MS), 0);
-  assertEquals((await repo.lookupMany('key_a', [item.id]))[0].refreshedAt, base + 30 * DAY_MS);
-
-  // Past the window the row advances.
-  assertEquals(await repo.refreshMany('key_a', [item.id], base + 31 * DAY_MS + 1), 1);
-  assertEquals((await repo.lookupMany('key_a', [item.id]))[0].refreshedAt, base + 31 * DAY_MS + 1);
-};
-
-test('memory responses items refreshMany debounces writes within 24h', async () => {
-  await exerciseRefreshManyDebounce(new InMemoryRepo().responsesItems);
-});
 
-test('SQL responses items refreshMany debounces writes within 24h', async () => {
-  await exerciseRefreshManyDebounce(new SqlRepo(new FakeResponsesItemsSqlDatabase()).responsesItems);
-});
+  test('rejects a lifetime refresh after its item disappeared', async () => {
+    initFileProvider(new MemoryFileProvider());
+    const repo = await createRepo();
+    const item = storedItem('msg_missing', 'key-a', 'missing', 1_000);
+    await repo.responsesItems.insertMany([item]);
+    await repo.responsesItems.deleteOlderThan(2_000);
 
-test('memory responses snapshots refresh debounces writes within 24h', async () => {
-  const repo = new InMemoryRepo().responsesSnapshots;
-  const base = Date.UTC(2026, 0, 1);
-  await repo.insert({
-    id: 'resp_dbnc',
-    apiKeyId: 'key_a',
-    itemIds: ['msg_a'],
-    createdAt: base,
-    refreshedAt: base,
+    await expect(repo.responsesItems.refreshMany([item], 3_000))
+      .rejects.toThrow('Responses item disappeared before lifetime refresh: msg_missing');
   });
 
-  assertEquals(await repo.refresh('key_a', 'resp_dbnc', base + 30 * DAY_MS), true);
-  assertEquals(await repo.refresh('key_a', 'resp_dbnc', base + 30 * DAY_MS + 12 * 60 * 60 * 1000), false);
-  assertEquals(await repo.refresh('key_a', 'resp_dbnc', base + 31 * DAY_MS), false);
-  assertEquals(await repo.refresh('key_a', 'resp_dbnc', base + 31 * DAY_MS + 1), true);
-  assertEquals((await repo.lookup('key_a', 'resp_dbnc'))?.refreshedAt, base + 31 * DAY_MS + 1);
-});
+  test('snapshot upsert refreshes its timestamp and item graph', async () => {
+    initFileProvider(new MemoryFileProvider());
+    const repo = await createRepo();
+    await repo.responsesSnapshots.insert({ id: 'resp_same', apiKeyId: 'key-a', itemIds: ['msg_old'], createdAt: 1_000 });
+    await repo.responsesSnapshots.insert({ id: 'resp_same', apiKeyId: 'key-a', itemIds: ['msg_new'], createdAt: 3_000 });
 
-test('memory responses items repo clones item JSON at the repo boundary', async () => {
-  const repo = new InMemoryRepo().responsesItems;
-  const item = storedItem({
-    id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA',
-    apiKeyId: 'key_a',
-    payload: { item: { nested: { values: ['original'] } } },
-    createdAt: 1_000,
+    expect(await repo.responsesSnapshots.lookup('key-a', 'resp_same')).toEqual({
+      id: 'resp_same', apiKeyId: 'key-a', itemIds: ['msg_new'], createdAt: 3_000,
+    });
   });
 
-  await repo.insertMany([item]);
-  (item.payload!.item as { nested: { values: string[] } }).nested.values.push('mutated-after-write');
-
-  const [metadata] = await repo.lookupMany('key_a', [item.id]);
-  const [read] = await repo.lookupPayloads('key_a', [item.id]);
-  assertEquals(metadata.hasPayload, true);
-  assertEquals(read.payload, { item: { nested: { values: ['original'] } } });
-  (read.payload.item as { nested: { values: string[] } }).nested.values.push('mutated-after-read');
-
-  assertEquals((await repo.lookupPayloads('key_a', [item.id]))[0].payload, { item: { nested: { values: ['original'] } } });
-});
-
-test('memory responses items repo scopes ids by api key and treats duplicate scoped writes as no-ops', async () => {
-  const repo = new InMemoryRepo().responsesItems;
-  const item = storedItem({ id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA', apiKeyId: 'key_a', createdAt: 1_000 });
-  await repo.insertMany([item]);
-  await repo.insertMany([
-    { ...item, apiKeyId: 'key_b' },
-    { ...item, payload: { item: { changed: true } }, createdAt: 2_000 },
-  ]);
-
-  // Same scope: the duplicate insert is a no-op; row reflects the first
-  // write. Stored ids use random bodies, so colliding writes only happen
-  // within one stream's mapper retries, which the wrap dedupes upstream.
-  assertEquals(await repo.lookupMany('key_a', [item.id]), [storedResponsesItemMetadata(item)]);
-  // Different scope: a parallel row is created.
-  assertEquals(await repo.lookupMany('key_b', [item.id]), [storedResponsesItemMetadata({ ...item, apiKeyId: 'key_b' })]);
-});
-
-const exerciseResponsesItemsRepoPayloadFill = async (repo: ResponsesItemsRepo) => {
-  initFileProvider(new MemoryFileProvider());
-  const metadata = storedItem({
-    id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA',
-    apiKeyId: 'key_a',
-    upstreamId: 'up_responses',
-    upstreamItemId: 'upstream_msg',
-    payload: null,
-    createdAt: 1_000,
+  test('refreshes spilled payload expiry without retaining the previous file', async () => {
+    const files = new MemoryFileProvider();
+    initFileProvider(files);
+    const repo = await createRepo();
+    const bytes = new Uint8Array(128 * 1024);
+    crypto.getRandomValues(bytes.subarray(0, 64 * 1024));
+    crypto.getRandomValues(bytes.subarray(64 * 1024));
+    let binary = '';
+    for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+      binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+    }
+    const item = {
+      ...storedItem('msg_large', 'key-a', 'large', 1_000),
+      payload: { item: { type: 'message', id: 'msg_large', role: 'assistant', content: btoa(binary) } },
+    };
+    await repo.responsesItems.insertMany([item]);
+    const before = await files.listKeys('responses-items/');
+    const put = vi.spyOn(files, 'put');
+    await repo.responsesItems.refreshMany([item], 1_000 + 10 * 60 * 1000);
+    if (_name === 'sql') expect(put).not.toHaveBeenCalled();
+    await repo.responsesItems.refreshMany([item], 1_000 + 2 * 60 * 60 * 1000);
+    const after = await files.listKeys('responses-items/');
+
+    if (_name === 'sql') {
+      expect(before).toHaveLength(1);
+      expect(after).toHaveLength(1);
+      expect(after[0]).not.toBe(before[0]);
+    } else {
+      expect(before).toEqual([]);
+      expect(after).toEqual([]);
+    }
+    expect((await repo.responsesItems.lookupMany('key-a', [item.id]))[0].createdAt).toBe(1_000 + 2 * 60 * 60 * 1000);
   });
-  const filled = {
-    ...metadata,
-    payload: { item: { type: 'message', id: metadata.id, role: 'user', content: 'captured later' } },
-    contentHash: 'content_hash_later',
-    encryptedContentHash: 'encrypted_content_hash_later',
-    createdAt: 2_000,
-    refreshedAt: 2_000,
-  } satisfies StoredResponsesItem;
-
-  await repo.insertMany([metadata]);
-
-  assertEquals(await repo.fillPayloads([filled]), 1);
-  assertEquals(await repo.lookupMany('key_a', [metadata.id]), [storedResponsesItemMetadata(filled)]);
-  assertEquals(await repo.fillPayloads([{ ...filled, payload: { item: { changed: true } }, createdAt: 3_000, refreshedAt: 3_000 }]), 0);
-  assertEquals(await repo.lookupMany('key_a', [metadata.id]), [storedResponsesItemMetadata(filled)]);
-};
-
-test('memory responses items repo fills metadata-only payloads once', async () => {
-  await exerciseResponsesItemsRepoPayloadFill(new InMemoryRepo().responsesItems);
 });
 
-test('SQL responses items repo inserts, looks up by scope, cleans payloads, deletes rows, and clears', async () => {
-  await exerciseResponsesItemsRepo(new SqlRepo(new FakeResponsesItemsSqlDatabase()).responsesItems);
+test('SQL refresh cleans a replacement spill when the row disappears before update', async () => {
+  const files = new MemoryFileProvider();
+  initFileProvider(files);
+  const base = await createSqliteTestDb();
+  let deleteBeforeBatch = false;
+  const db: SqlDatabase = {
+    prepare: query => base.prepare(query),
+    exec: sql => base.exec(sql),
+    batch: async statements => {
+      if (deleteBeforeBatch) {
+        deleteBeforeBatch = false;
+        await base.prepare('DELETE FROM responses_items WHERE id = ? AND api_key_id = ?')
+          .bind('msg_race', 'key-a')
+          .run();
+      }
+      const results = [];
+      for (const statement of statements) results.push(await statement.run());
+      return results;
+    },
+  };
+  const repo = new SqlRepo(db);
+  const bytes = new Uint8Array(128 * 1024);
+  crypto.getRandomValues(bytes.subarray(0, 64 * 1024));
+  crypto.getRandomValues(bytes.subarray(64 * 1024));
+  let content = '';
+  for (const byte of bytes) content += byte.toString(16).padStart(2, '0');
+  const item: StoredResponsesItem = {
+    ...storedItem('msg_race', 'key-a', 'race', 1_000),
+    payload: { item: { type: 'message', id: 'msg_race', role: 'assistant', content } },
+  };
+  await repo.responsesItems.insertMany([item]);
+  const originalFiles = await files.listKeys('responses-items/');
+  expect(originalFiles).toHaveLength(1);
+
+  deleteBeforeBatch = true;
+  await expect(repo.responsesItems.refreshMany([item], 1_000 + 2 * 60 * 60 * 1000))
+    .rejects.toThrow('Responses item disappeared before lifetime refresh: msg_race');
+
+  expect(await files.listKeys('responses-items/')).toEqual(originalFiles);
+  expect(await repo.responsesItems.lookupMany('key-a', [item.id])).toEqual([]);
 });
 
-test('SQL responses items repo rejects malformed stored payload_json', async () => {
-  const db = new FakeResponsesItemsSqlDatabase();
-  db.rows.push({
-    id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA',
-    api_key_id: 'key_a',
-    upstream_id: null,
-    upstream_item_id: null,
-    item_type: 'message',
-    origin: 'synthetic',
-    payload_json: '{bad json',
-    content_hash: null,
-    encrypted_content_hash: null,
-    created_at: 1_000,
-    refreshed_at: 1_000,
-  });
-
-  const repo = new SqlRepo(db).responsesItems;
-  const [metadata] = await repo.lookupMany('key_a', ['msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA']);
-  assertEquals(metadata.hasPayload, true);
-  await assertRejects(() => repo.lookupPayloads('key_a', [metadata.id]), Error, 'Malformed responses_items.payload_json JSON');
+test('SQL stale refresh cannot restore a superseded spill descriptor', async () => {
+  const files = new MemoryFileProvider();
+  initFileProvider(files);
+  const base = await createSqliteTestDb();
+  const item = spilledItem('msg_refresh_cas', 'key-a', 1_000);
+  await new SqlRepo(base).responsesItems.insertMany([item]);
+  let releaseStale: (() => void) | undefined;
+  const staleGate = new Promise<void>(resolve => { releaseStale = resolve; });
+  let markStaleStarted: (() => void) | undefined;
+  const staleStarted = new Promise<void>(resolve => { markStaleStarted = resolve; });
+  let batchNumber = 0;
+  const repo = new SqlRepo(sqlDatabaseWithBatch(base, async statements => {
+    batchNumber += 1;
+    if (batchNumber === 1) {
+      markStaleStarted?.();
+      await staleGate;
+    }
+    const results = [];
+    for (const statement of statements) results.push(await statement.run());
+    return results;
+  }));
+  const staleCreatedAt = 1_000 + 10 * 60 * 1000;
+  const currentCreatedAt = 1_000 + 2 * 60 * 60 * 1000;
+
+  const staleRefresh = repo.responsesItems.refreshMany([item], staleCreatedAt);
+  await staleStarted;
+  await repo.responsesItems.refreshMany([item], currentCreatedAt);
+  releaseStale?.();
+  await expect(staleRefresh).rejects.toThrow('Unexpected Responses item refresh count');
+
+  const [persisted] = await repo.responsesItems.lookupMany('key-a', [item.id]);
+  expect(persisted.createdAt).toBe(currentCreatedAt);
+  expect(persisted.payload).toEqual(item.payload);
+  expect(await files.listKeys('responses-items/')).toHaveLength(1);
 });
 
-test('SQL responses items repo scopes ids by api key and treats duplicate scoped writes as no-ops', async () => {
-  const repo = new SqlRepo(new FakeResponsesItemsSqlDatabase()).responsesItems;
-  const item = storedItem({ id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA', apiKeyId: 'key_a', createdAt: 1_000 });
-  await repo.insertMany([item]);
-  await repo.insertMany([
-    { ...item, apiKeyId: 'key_b' },
-    { ...item, payload: { item: { changed: true } }, createdAt: 2_000 },
-  ]);
-
-  assertEquals(await repo.lookupMany('key_a', [item.id]), [storedResponsesItemMetadata(item)]);
-  assertEquals(await repo.lookupMany('key_b', [item.id]), [storedResponsesItemMetadata({ ...item, apiKeyId: 'key_b' })]);
+test('SQL Responses item writes stay within D1 bind limits and use bounded statement counts', async () => {
+  initFileProvider(new MemoryFileProvider());
+  const base = await createSqliteTestDb();
+  const batchSizes: number[] = [];
+  let maxBindCount = 0;
+  const db: SqlDatabase = {
+    prepare: query => {
+      const statement = base.prepare(query);
+      return {
+        bind: (...values) => {
+          maxBindCount = Math.max(maxBindCount, values.length);
+          return statement.bind(...values);
+        },
+        first: <T>() => statement.first<T>(),
+        all: <T>() => statement.all<T>(),
+        run: () => statement.run(),
+      };
+    },
+    exec: sql => base.exec(sql),
+    batch: async statements => {
+      batchSizes.push(statements.length);
+      const results = [];
+      for (const statement of statements) results.push(await statement.run());
+      return results;
+    },
+  };
+  const repo = new SqlRepo(db);
+  const items = Array.from({ length: 240 }, (_, index) =>
+    storedItem(`msg_bulk_${index}`, 'key-a', `hash-${index}`, 1_000));
+
+  await repo.responsesItems.insertMany(items);
+  await repo.responsesItems.refreshMany(items, 2_000);
+
+  expect(batchSizes).toEqual([15, 10]);
+  expect(maxBindCount).toBeLessThanOrEqual(100);
+  expect(await repo.responsesItems.lookupMany('key-a', items.map(item => item.id))).toHaveLength(items.length);
 });
 
-test('SQL responses items repo fills metadata-only payloads once', async () => {
-  await exerciseResponsesItemsRepoPayloadFill(new SqlRepo(new FakeResponsesItemsSqlDatabase()).responsesItems);
+test('SQL insert cleans earlier spills when a later payload cannot be serialized', async () => {
+  const files = new MemoryFileProvider();
+  initFileProvider(files);
+  const repo = new SqlRepo(await createSqliteTestDb());
+  const circular: Record<string, unknown> = { type: 'message', id: 'msg_circular' };
+  circular.self = circular;
+  const invalid: StoredResponsesItem = {
+    ...storedItem('msg_circular', 'key-a', 'circular', 1_000),
+    payload: { item: circular },
+  };
+
+  await expect(repo.responsesItems.insertMany([spilledItem('msg_before_circular', 'key-a', 1_000), invalid]))
+    .rejects.toThrow();
+
+  expect(await files.listKeys('responses-items/')).toEqual([]);
 });
 
-test('SQL responses items repo chunks lookups exceeding the 100-parameter limit and unions the results', async () => {
-  const repo = new SqlRepo(new FakeResponsesItemsSqlDatabase()).responsesItems;
-  const items = Array.from({ length: 200 }, (_, i) =>
-    storedItem({ id: `msg_chunk_${i.toString().padStart(4, '0')}`, apiKeyId: 'key_a', encryptedContentHash: `enc_${i}`, createdAt: 1_000 + i }));
-  await repo.insertMany(items);
+test('SQL insert cleans generated spills when its batch fails', async () => {
+  const files = new MemoryFileProvider();
+  initFileProvider(files);
+  const base = await createSqliteTestDb();
+  const batchFailure = new Error('simulated insert batch failure');
+  const repo = new SqlRepo(sqlDatabaseWithBatch(base, () => Promise.reject(batchFailure)));
 
-  const byId = await repo.lookupMany('key_a', items.map(item => item.id));
-  assertEquals(byId.map(row => row.id), items.map(item => item.id));
+  await expect(repo.responsesItems.insertMany([spilledItem('msg_insert_failure', 'key-a', 1_000)]))
+    .rejects.toBe(batchFailure);
 
-  const byHash = await repo.lookupManyByEncryptedContentHash('key_a', items.map(item => item.encryptedContentHash!));
-  assertEquals(new Set(byHash.map(row => row.id)).size, 200);
+  expect(await files.listKeys('responses-items/')).toEqual([]);
 });
 
-test('SQL responses items repo hydrates one payload at a time across query chunks', async () => {
-  const db = new FakeResponsesItemsSqlDatabase();
-  const files = new GatedReadFileProvider();
+test('SQL refresh cleans earlier replacement spills when a later payload cannot be serialized', async () => {
+  const files = new MemoryFileProvider();
   initFileProvider(files);
-  const ids: string[] = [];
-  const encoder = new TextEncoder();
-  for (let index = 0; index < 91; index++) {
-    const id = `msg_codec_${index.toString().padStart(3, '0')}`;
-    const key = `codec/${id}.json`;
-    const body = encoder.encode(JSON.stringify({ item: { type: 'message', id, role: 'assistant', content: `payload ${index}` } }));
-    await files.put(key, body);
-    db.rows.push({
-      id,
-      api_key_id: 'key_a',
-      upstream_id: 'up_a',
-      upstream_item_id: `raw_${index}`,
-      item_type: 'message',
-      origin: 'upstream',
-      payload_json: JSON.stringify({ version: 1, storage: 'file', key, sha256: await sha256Hex(body), byteLength: body.byteLength }),
-      content_hash: null,
-      encrypted_content_hash: null,
-      created_at: index,
-      refreshed_at: index,
-    });
-    ids.push(id);
-  }
-  const repo = new SqlRepo(db).responsesItems;
-  const metadata = await repo.lookupMany('key_a', ids);
-  assertEquals(files.getCalls, 0);
-  const lookup = repo.lookupPayloads('key_a', ids);
-  await files.waitForFirstGet();
-  const startedBeforeRelease = files.getCalls;
-  files.releaseAll();
-  const payloads = await lookup;
-
-  assertEquals(startedBeforeRelease, 1);
-  assertEquals(metadata.map(row => row.id), ids);
-  assertEquals(payloads.map(row => row.id), ids);
+  const base = await createSqliteTestDb();
+  const repo = new SqlRepo(base);
+  const first = spilledItem('msg_refresh_before_circular', 'key-a', 1_000);
+  const second = spilledItem('msg_refresh_circular', 'key-a', 1_000);
+  await repo.responsesItems.insertMany([first, second]);
+  const originalFiles = await files.listKeys('responses-items/');
+  const circular: Record<string, unknown> = { type: 'message', id: second.id };
+  circular.self = circular;
+
+  await expect(repo.responsesItems.refreshMany([
+    first,
+    { ...second, payload: { item: circular } },
+  ], 1_000 + 2 * 60 * 60 * 1000)).rejects.toThrow();
+
+  expect((await files.listKeys('responses-items/')).toSorted()).toEqual(originalFiles.toSorted());
 });
 
-test('SQL responses items repo serializes one payload at a time within write batches', async () => {
-  initFileProvider(new MemoryFileProvider());
-  const db = new FakeResponsesItemsSqlDatabase();
-  const repo = new SqlRepo(db).responsesItems;
-  const inserts = Array.from({ length: 3 }, (_, index) => storedItem({
-    id: `msg_insert_${index}`,
-    apiKeyId: 'key_a',
-    createdAt: 1_000 + index,
-  }));
-
-  const insert = await runWithCompressionBlocked(async () => await repo.insertMany(inserts));
-
-  assertEquals(insert.started, 1);
-  assertEquals((await repo.lookupMany('key_a', inserts.map(item => item.id))).map(row => row.id), inserts.map(item => item.id));
-
-  const metadata = Array.from({ length: 3 }, (_, index) => storedItem({
-    id: `msg_fill_${index}`,
-    apiKeyId: 'key_a',
-    payload: null,
-    createdAt: 2_000 + index,
-  }));
-  await repo.insertMany(metadata);
-  const fills = metadata.map((item, index) => ({
-    ...item,
-    payload: { item: { type: 'message', id: item.id, role: 'assistant', content: `filled ${index}` } },
-  }));
-
-  const fill = await runWithCompressionBlocked(async () => await repo.fillPayloads(fills));
-
-  assertEquals(fill.started, 1);
-  assertEquals(fill.result, 3);
+test('SQL refresh cleans replacement spills and keeps originals when its batch fails', async () => {
+  const files = new MemoryFileProvider();
+  initFileProvider(files);
+  const base = await createSqliteTestDb();
+  const originalRepo = new SqlRepo(base);
+  const item = spilledItem('msg_refresh_failure', 'key-a', 1_000);
+  await originalRepo.responsesItems.insertMany([item]);
+  const originalFiles = await files.listKeys('responses-items/');
+  const batchFailure = new Error('simulated refresh batch failure');
+  const repo = new SqlRepo(sqlDatabaseWithBatch(base, () => Promise.reject(batchFailure)));
+
+  await expect(repo.responsesItems.refreshMany([item], 1_000 + 2 * 60 * 60 * 1000))
+    .rejects.toBe(batchFailure);
+
+  expect(await files.listKeys('responses-items/')).toEqual(originalFiles);
 });
 
-test('SQL responses items repo spills large payloads through the runtime file provider without storing backend identity', async () => {
-  const db = new FakeResponsesItemsSqlDatabase();
+test('SQL duplicate insert does not write an unreferenced replacement spill', async () => {
   const files = new MemoryFileProvider();
   initFileProvider(files);
-  const repo = new SqlRepo(db).responsesItems;
-  const payload = { item: { type: 'message', id: 'msg_large', content: incompressibleString(96 * 1024) } };
-  const item = storedItem({
-    id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA',
-    apiKeyId: 'key_a',
-    payload,
-    createdAt: Date.UTC(2026, 4, 28, 12),
-  });
-
-  await repo.insertMany([item]);
-
-  const descriptor = JSON.parse(db.rows[0].payload_json!) as Record<string, unknown>;
-  assertEquals(descriptor.storage, 'file');
-  assertEquals('provider' in descriptor, false);
-  assertEquals(typeof descriptor.key, 'string');
-  assertEquals((descriptor.key as string).startsWith('responses-items/v1/expires/2026/06/27/12/'), true);
-  assert((await files.get(descriptor.key as string)) !== null);
-  assertEquals(await repo.lookupMany('key_a', [item.id]), [storedResponsesItemMetadata(item)]);
-  assertEquals((await repo.lookupPayloads('key_a', [item.id]))[0].payload, payload);
+  const repo = new SqlRepo(await createSqliteTestDb());
+  const bytes = new Uint8Array(128 * 1024);
+  crypto.getRandomValues(bytes.subarray(0, 64 * 1024));
+  crypto.getRandomValues(bytes.subarray(64 * 1024));
+  let content = '';
+  for (const byte of bytes) content += byte.toString(16).padStart(2, '0');
+  const original: StoredResponsesItem = {
+    ...storedItem('msg_duplicate', 'key-a', 'duplicate', 1_000),
+    payload: { item: { type: 'message', id: 'msg_duplicate', role: 'assistant', content } },
+  };
+  await repo.responsesItems.insertMany([original]);
+  const originalFiles = await files.listKeys('responses-items/');
+  expect(originalFiles).toHaveLength(1);
+
+  const put = vi.spyOn(files, 'put');
+  await repo.responsesItems.insertMany([{ ...original, createdAt: 1_000 + 2 * 60 * 60 * 1000 }]);
+
+  expect(put).not.toHaveBeenCalled();
+  expect(await files.listKeys('responses-items/')).toEqual(originalFiles);
+  expect(await repo.responsesItems.lookupMany('key-a', [original.id])).toEqual([original]);
 });
 
-test('SQL responses items deleteAll removes spilled payload files alongside the rows', async () => {
-  const db = new FakeResponsesItemsSqlDatabase();
+test('SQL insert conflict cleans its spill when the winning row disappears', async () => {
   const files = new MemoryFileProvider();
   initFileProvider(files);
-  const repo = new SqlRepo(db).responsesItems;
-  const item = storedItem({
-    id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA',
-    apiKeyId: 'key_a',
-    payload: { item: { type: 'message', id: 'msg_large', content: incompressibleString(96 * 1024) } },
-    createdAt: Date.UTC(2026, 4, 28, 12),
-  });
-
-  await repo.insertMany([item]);
-  const descriptor = JSON.parse(db.rows[0].payload_json!) as { key: string };
-  assert((await files.get(descriptor.key)) !== null);
-
-  await repo.deleteAll();
-
-  assertEquals(db.rows.length, 0);
-  assertEquals(await files.get(descriptor.key), null);
+  const base = await createSqliteTestDb();
+  let injectConflict = true;
+  const db: SqlDatabase = {
+    prepare: query => base.prepare(query),
+    exec: sql => base.exec(sql),
+    batch: async statements => {
+      if (!injectConflict) throw new Error('unexpected second insert batch');
+      injectConflict = false;
+      const inlinePayload = JSON.stringify({
+        version: 1,
+        storage: 'inline',
+        payload: { item: { type: 'message', id: 'msg_insert_race', role: 'assistant', content: [] } },
+      });
+      const insertWinner = base.prepare(
+        'INSERT INTO responses_items (id, api_key_id, item_type, payload_json, content_hash, created_at) VALUES (?, ?, ?, ?, ?, ?)',
+      );
+      await insertWinner.bind('msg_insert_race', 'key-a', 'message', inlinePayload, 'race', 1_000).run();
+      await insertWinner.bind('msg_insert_survivor', 'key-a', 'message', inlinePayload, 'survivor', 1_000).run();
+      const results = [];
+      for (const statement of statements) results.push(await statement.run());
+      await base.prepare('DELETE FROM responses_items WHERE id = ? AND api_key_id = ?')
+        .bind('msg_insert_race', 'key-a')
+        .run();
+      return results;
+    },
+  };
+  const repo = new SqlRepo(db);
+  const item = spilledItem('msg_insert_race', 'key-a', 1_000 + 2 * 60 * 60 * 1000);
+  const survivor = spilledItem('msg_insert_survivor', 'key-a', 1_000 + 2 * 60 * 60 * 1000);
+
+  await expect(repo.responsesItems.insertMany([item, survivor]))
+    .rejects.toThrow('Responses item conflict disappeared before spill cleanup: msg_insert_race');
+  expect(await files.listKeys('responses-items/')).toEqual([]);
 });
 
-test('migration 0023 creates the responses_items table and cleanup indexes', async () => {
-  const SQL = await initSqlJs();
-  const db = new SQL.Database();
-  try {
-    applySqlJsFile(db, '0023_responses_items.sql');
-
-    const table = sqlJsRows<{ sql: string }>(db, "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'responses_items'")[0];
-    assert(table);
-    assertEquals(
-      table.sql,
-      `CREATE TABLE responses_items (
-  id TEXT NOT NULL,
-  api_key_id TEXT,
-  upstream_id TEXT,
-  upstream_item_id TEXT,
-  item_type TEXT NOT NULL,
-  payload_json TEXT,
-  encrypted_content_hash TEXT,
-  created_at INTEGER NOT NULL,
-  CHECK (length(id) > 0),
-  CHECK (length(item_type) > 0),
-  CHECK (upstream_id IS NOT NULL OR upstream_item_id IS NULL)
-)`,
-    );
-
-    assertEquals(
-      sqlJsRows<{ name: string }>(db, "SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'responses_items' ORDER BY name").map(row => row.name),
-      ['idx_responses_items_api_key_id', 'idx_responses_items_created_at', 'idx_responses_items_enc_hash', 'idx_responses_items_id_scope'],
-    );
-  } finally {
-    db.close();
-  }
+test('SQL conflict cleanup cannot delete a later winner\'s independently owned spill', async () => {
+  const files = new DeleteHookFileProvider();
+  initFileProvider(files);
+  const base = await createSqliteTestDb();
+  const item = spilledItem('msg_insert_owner_race', 'key-a', 1_000);
+  const winnerPayload = await serializeStoredResponsesPayload(
+    item.id,
+    item.apiKeyId,
+    item.createdAt,
+    item.payload,
+  );
+  const winnerFileKey = (JSON.parse(winnerPayload) as { key: string }).key;
+  const insertWinner = base.prepare(
+    'INSERT INTO responses_items (id, api_key_id, item_type, payload_json, content_hash, created_at) VALUES (?, ?, ?, ?, ?, ?)',
+  );
+  const db = sqlDatabaseWithBatch(base, async statements => {
+    await insertWinner
+      .bind(item.id, item.apiKeyId, item.itemType, winnerPayload, item.contentHash, item.createdAt)
+      .run();
+    const results = [];
+    for (const statement of statements) results.push(await statement.run());
+    await base.prepare('DELETE FROM responses_items WHERE id = ? AND api_key_id = ?')
+      .bind(item.id, item.apiKeyId)
+      .run();
+    return results;
+  });
+  files.beforeDelete = async loserFileKey => {
+    expect(loserFileKey).not.toBe(winnerFileKey);
+    await insertWinner
+      .bind(item.id, item.apiKeyId, item.itemType, winnerPayload, item.contentHash, item.createdAt)
+      .run();
+  };
+  const repo = new SqlRepo(db);
+
+  await expect(repo.responsesItems.insertMany([item]))
+    .rejects.toThrow(`Responses item conflict disappeared before spill cleanup: ${item.id}`);
+
+  expect(await files.listKeys('responses-items/')).toEqual([winnerFileKey]);
+  expect((await repo.responsesItems.lookupMany(item.apiKeyId, [item.id]))[0].payload).toEqual(item.payload);
 });
 
-test('migration 0025 adds responses item metadata and refresh index', async () => {
+test('migration 0058 preserves usable payloads and snapshots but drops legacy affinity columns', async () => {
   const SQL = await initSqlJs();
   const db = new SQL.Database();
   try {
-    applySqlJsFile(db, '0023_responses_items.sql');
-    db.run(`
-      INSERT INTO responses_items (id, upstream_id, upstream_item_id, item_type, created_at)
-      VALUES
-        ('msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA', NULL, NULL, 'message', 1),
-        ('rs_mFBDiA_Lh1uXb7nD_bQb4I1CUYH2w', 'up_a', 'raw_rs_a', 'reasoning', 2)
-    `);
-    applySqlJsFile(db, '0025_responses_item_metadata.sql');
-
-    assertEquals(
-      sqlJsRows<{ name: string }>(db, 'PRAGMA table_info(responses_items)').map(row => row.name).filter(name => name === 'origin' || name === 'refreshed_at'),
-      ['origin', 'refreshed_at'],
-    );
-    assertEquals(
-      sqlJsRows<{ id: string; origin: string; refreshed_at: number }>(db, 'SELECT id, origin, refreshed_at FROM responses_items ORDER BY created_at'),
-      [
-        { id: 'msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA', origin: 'synthetic', refreshed_at: 1 },
-        { id: 'rs_mFBDiA_Lh1uXb7nD_bQb4I1CUYH2w', origin: 'upstream', refreshed_at: 2 },
-      ],
-    );
-    assertEquals(
-      sqlJsRows<{ name: string }>(db, "SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'responses_items' ORDER BY name").map(row => row.name),
-      ['idx_responses_items_api_key_id', 'idx_responses_items_created_at', 'idx_responses_items_enc_hash', 'idx_responses_items_id_scope', 'idx_responses_items_refreshed_at'],
-    );
-    db.run("INSERT INTO responses_items (id, item_type, created_at) VALUES ('ws_WGRXTA_sVlhxg6BAV0BUzj0KkWSqA', 'web_search_call', 3)");
-    assertEquals(
-      sqlJsRows<{ origin: string; refreshed_at: number }>(db, "SELECT origin, refreshed_at FROM responses_items WHERE id = 'ws_WGRXTA_sVlhxg6BAV0BUzj0KkWSqA'")[0],
-      { origin: 'upstream', refreshed_at: 3 },
-    );
-    assert(
-      sqlJsRows<{ detail: string }>(db, 'EXPLAIN QUERY PLAN DELETE FROM responses_items WHERE refreshed_at < 10')
-        .some(row => row.detail.includes('idx_responses_items_refreshed_at')),
-    );
-    assert(
-      sqlJsRows<{ detail: string }>(db, 'EXPLAIN QUERY PLAN UPDATE responses_items SET payload_json = NULL WHERE payload_json IS NOT NULL AND created_at < 10')
-        .some(row => row.detail.includes('idx_responses_items_created_at')),
-    );
-    assert(
-      sqlJsRows<{ detail: string }>(
-        db,
-        "EXPLAIN QUERY PLAN SELECT id FROM responses_items WHERE COALESCE(api_key_id, '') = COALESCE('key_a', '') AND id IN ('msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA')",
-      ).some(row => row.detail.includes('idx_responses_items_id_scope')),
-    );
-    assert(
-      sqlJsRows<{ detail: string }>(
-        db,
-        "EXPLAIN QUERY PLAN UPDATE responses_items SET refreshed_at = 10 WHERE COALESCE(api_key_id, '') = COALESCE('key_a', '') AND id IN ('msg_z1mVjw_0xVvS8c_KjD1sBkZk5qbdA') AND refreshed_at < 10",
-      ).some(row => row.detail.includes('idx_responses_items_id_scope')),
-    );
-  } finally {
-    db.close();
-  }
-});
+    for (const [filename, sql] of migrationSqlByFilename) {
+      if (filename === '0058_responses_full_state.sql') break;
+      db.run(sql);
+    }
 
-test('migration 0026 adds Responses state snapshots and content hash index', async () => {
-  const SQL = await initSqlJs();
-  const db = new SQL.Database();
-  try {
-    applySqlJsFile(db, '0023_responses_items.sql');
-    applySqlJsFile(db, '0025_responses_item_metadata.sql');
-    applySqlJsFile(db, '0026_responses_state.sql');
-
-    assertEquals(
-      sqlJsRows<{ name: string }>(db, 'PRAGMA table_info(responses_items)').map(row => row.name).filter(name => name === 'content_hash'),
-      ['content_hash'],
-    );
-    assertEquals(
-      sqlJsRows<{ sql: string }>(db, "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'responses_snapshots'")[0].sql,
-      `CREATE TABLE responses_snapshots (
-  id TEXT NOT NULL,
-  api_key_id TEXT,
-  item_ids_json TEXT NOT NULL,
-  created_at INTEGER NOT NULL,
-  refreshed_at INTEGER NOT NULL,
-  CHECK (length(id) > 0),
-  CHECK (length(item_ids_json) > 0)
-)`,
-    );
-    assert(
-      sqlJsRows<{ detail: string }>(
-        db,
-        "EXPLAIN QUERY PLAN SELECT id FROM responses_items WHERE api_key_id IS 'key_a' AND content_hash IN ('hash_a') ORDER BY refreshed_at DESC, created_at DESC, id ASC",
-      ).some(row => row.detail.includes('idx_responses_items_content_hash')),
-    );
-    assert(
-      sqlJsRows<{ detail: string }>(
-        db,
-        "EXPLAIN QUERY PLAN SELECT id FROM responses_snapshots WHERE id = 'resp_a' AND COALESCE(api_key_id, '') = COALESCE('key_a', '')",
-      ).some(row => row.detail.includes('idx_responses_snapshots_id_scope')),
-    );
-    assert(
-      sqlJsRows<{ detail: string }>(db, 'EXPLAIN QUERY PLAN DELETE FROM responses_snapshots WHERE refreshed_at < 10')
-        .some(row => row.detail.includes('idx_responses_snapshots_refreshed_at')),
-    );
+    const gzipDescriptor = JSON.stringify({ version: 1, storage: 'inline', encoding: 'gzip', payload: 'H4sIAAAAAAAA' });
+    const fileDescriptor = JSON.stringify({ version: 1, storage: 'file', key: 'responses-items/v1/expires/x', sha256: 'abc', byteLength: 3 });
+    const legacyInline = JSON.stringify({ version: 1, storage: 'inline', payload: { item: { type: 'reasoning', id: 'rs_legacy' } } });
+    const summaryInline = JSON.stringify({ version: 1, storage: 'inline', payload: { item: { type: 'compaction_summary', id: 'cmp_summary' } } });
+    const insertItem = `INSERT INTO responses_items
+      (id, api_key_id, upstream_id, upstream_item_id, item_type, payload_json, content_hash, created_at, refreshed_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+    db.run(insertItem, ['msg_gzip', 'key-a', 'upstream-a', 'msg_upstream', 'message', gzipDescriptor, 'hash-a', 1_000, 9_000]);
+    db.run(insertItem, ['rs_file', 'key-a', 'upstream-a', 'rs_upstream', 'reasoning', fileDescriptor, null, 2_000, 10_000]);
+    db.run(insertItem, ['rs_legacy', 'key-a', 'upstream-a', 'rs_legacy_upstream', 'reasoning', legacyInline, null, 3_000, 11_000]);
+    db.run(insertItem, ['cmp_summary', 'key-a', 'upstream-a', 'cmp_upstream', 'compaction_summary', summaryInline, null, 3_500, 11_500]);
+    db.run(insertItem, ['msg_unscoped', null, null, null, 'message', gzipDescriptor, 'hash-u', 4_000, 12_000]);
+    db.run(insertItem, ['msg_metadata', 'key-a', 'upstream-a', 'msg_metadata_upstream', 'message', null, 'hash-m', 5_000, 13_000]);
+
+    const insertSnapshot = `INSERT INTO responses_snapshots
+      (id, api_key_id, item_ids_json, created_at, refreshed_at)
+      VALUES (?, ?, ?, ?, ?)`;
+    db.run(insertSnapshot, ['resp_valid', 'key-a', '["msg_gzip","rs_file","rs_legacy"]', 6_000, 12_000]);
+    db.run(insertSnapshot, ['resp_dangling', 'key-a', '["msg_gzip","msg_metadata"]', 7_000, 7_000]);
+    db.run(insertSnapshot, ['resp_malformed', 'key-a', '{', 8_000, 8_000]);
+    db.run(insertSnapshot, ['resp_unscoped', null, '["msg_unscoped"]', 9_000, 9_000]);
+
+    const migration = migrationSqlByFilename.find(([filename]) => filename === '0058_responses_full_state.sql');
+    if (migration === undefined) throw new Error('missing migration 0058_responses_full_state.sql');
+    db.run(migration[1]);
+
+    const itemResult = db.exec('SELECT id, item_type, payload_json, content_hash, created_at FROM responses_items ORDER BY created_at')[0];
+    expect(itemResult?.values).toEqual([
+      ['rs_file', 'reasoning', fileDescriptor, null, 2_000],
+      ['msg_gzip', 'message', gzipDescriptor, 'hash-a', 9_000],
+      ['rs_legacy', 'reasoning', legacyInline, null, 11_000],
+      ['cmp_summary', 'compaction', summaryInline, null, 11_500],
+    ]);
+    const snapshotResult = db.exec('SELECT id, api_key_id, item_ids_json, created_at FROM responses_snapshots')[0];
+    expect(snapshotResult?.values).toEqual([
+      ['resp_valid', 'key-a', '["msg_gzip","rs_file","rs_legacy"]', 2_000],
+    ]);
+    const columns = db.exec('PRAGMA table_info(responses_items)')[0]?.values.map(row => row[1]);
+    expect(columns).not.toContain('upstream_id');
+    expect(columns).not.toContain('upstream_item_id');
   } finally {
     db.close();
   }
 });
-
-type FakeResponsesItemRow = {
-  id: string;
-  api_key_id: string | null;
-  upstream_id: string | null;
-  upstream_item_id: string | null;
-  item_type: string;
-  origin: StoredResponsesItem['origin'];
-  payload_json: string | null;
-  content_hash: string | null;
-  encrypted_content_hash: string | null;
-  created_at: number;
-  refreshed_at: number;
-};
-
-class FakeResponsesItemsSqlPreparedStatement {
-  private binds: unknown[] = [];
-
-  constructor(private db: FakeResponsesItemsSqlDatabase, private query: string) {}
-
-  bind(...values: unknown[]): FakeResponsesItemsSqlPreparedStatement {
-    this.binds = values;
-    return this;
-  }
-
-  first(): Promise<null> {
-    throw new Error(`Unsupported first() query in responses items test: ${this.query}`);
-  }
-
-  all<T>(): Promise<{ results: T[]; success: true; meta: Record<string, unknown> }> {
-    if (this.query.includes('FROM responses_items')) {
-      return Promise.resolve({
-        results: this.db.lookup(this.query, this.binds) as T[],
-        success: true,
-        meta: {},
-      });
-    }
-
-    throw new Error(`Unsupported all() query in responses items test: ${this.query}`);
-  }
-
-  run(): Promise<{ results: never[]; success: true; meta: Record<string, unknown> }> {
-    if (this.query.startsWith('INSERT INTO responses_items')) {
-      this.db.insert(this.binds);
-      return Promise.resolve({ results: [], success: true, meta: { changes: 1 } });
-    }
-    if (this.query.startsWith('UPDATE responses_items SET refreshed_at = ?')) {
-      const changes = this.db.refresh(this.binds);
-      return Promise.resolve({ results: [], success: true, meta: { changes } });
-    }
-    if (this.query.includes('SET payload_json = ?, content_hash = ?, encrypted_content_hash = ?, created_at = ?, refreshed_at = ?')) {
-      const changes = this.db.fillPayload(this.binds);
-      return Promise.resolve({ results: [], success: true, meta: { changes } });
-    }
-    if (this.query.startsWith('UPDATE responses_items SET payload_json = NULL')) {
-      const changes = this.db.clearPayloadOlderThan(this.binds[0] as number);
-      return Promise.resolve({ results: [], success: true, meta: { changes } });
-    }
-    if (this.query.startsWith('DELETE FROM responses_items WHERE refreshed_at < ?')) {
-      const changes = this.db.deleteOlderThan(this.binds[0] as number);
-      return Promise.resolve({ results: [], success: true, meta: { changes } });
-    }
-    if (this.query === 'DELETE FROM responses_items') {
-      const changes = this.db.rows.length;
-      this.db.rows = [];
-      return Promise.resolve({ results: [], success: true, meta: { changes } });
-    }
-
-    throw new Error(`Unsupported run() query in responses items test: ${this.query}`);
-  }
-}
-
-class FakeResponsesItemsSqlDatabase implements SqlDatabase {
-  exec(): Promise<unknown> { return Promise.resolve(undefined); }
-
-  rows: FakeResponsesItemRow[] = [];
-
-  prepare(query: string): FakeResponsesItemsSqlPreparedStatement {
-    return new FakeResponsesItemsSqlPreparedStatement(this, query);
-  }
-
-  async batch(statements: FakeResponsesItemsSqlPreparedStatement[]): Promise<Array<{ results: never[]; success: true; meta: Record<string, unknown> }>> {
-    const results = [];
-    for (const statement of statements) results.push(await statement.run());
-    return results;
-  }
-
-  insert(binds: unknown[]): void {
-    const [id, apiKeyId, upstreamId, upstreamItemId, itemType, origin, payload, contentHash, encryptedContentHash, createdAt, refreshedAt] = binds as [
-      string,
-      string | null,
-      string | null,
-      string | null,
-      string,
-      StoredResponsesItem['origin'],
-      string | null,
-      string | null,
-      string | null,
-      number,
-      number,
-    ];
-    const existing = this.rows.find(row => row.id === id && row.api_key_id === apiKeyId);
-    if (existing) return;  // mirrors sql.ts `ON CONFLICT DO NOTHING`
-    this.rows.push({
-      id,
-      api_key_id: apiKeyId,
-      upstream_id: upstreamId,
-      upstream_item_id: upstreamItemId,
-      item_type: itemType,
-      origin,
-      payload_json: payload,
-      content_hash: contentHash,
-      encrypted_content_hash: encryptedContentHash,
-      created_at: createdAt,
-      refreshed_at: refreshedAt,
-    });
-  }
-
-  refresh(binds: unknown[]): number {
-    const [refreshedAt, apiKeyId, ...rest] = binds as [number, string | null, ...Array<string | number>];
-    const ids = new Set(rest.slice(0, -1) as string[]);
-    const maxExisting = rest.at(-1) as number;
-    let changes = 0;
-    for (const row of this.rows) {
-      if (row.api_key_id === apiKeyId && ids.has(row.id) && row.refreshed_at < maxExisting) {
-        row.refreshed_at = refreshedAt;
-        changes += 1;
-      }
-    }
-    return changes;
-  }
-
-  fillPayload(binds: unknown[]): number {
-    const [payload, contentHash, encryptedContentHash, createdAt, refreshedAt, apiKeyId, id] = binds as [
-      string,
-      string | null,
-      string | null,
-      number,
-      number,
-      string | null,
-      string,
-    ];
-    const row = this.rows.find(candidate => candidate.id === id && candidate.api_key_id === apiKeyId);
-    if (row?.payload_json !== null) return 0;
-    row.payload_json = payload;
-    row.content_hash = contentHash;
-    row.encrypted_content_hash = encryptedContentHash;
-    row.created_at = createdAt;
-    row.refreshed_at = refreshedAt;
-    return 1;
-  }
-
-  lookup(query: string, binds: unknown[]): unknown[] {
-    const [apiKeyId, ...keys] = binds as [string | null, ...string[]];
-    const wanted = new Set(keys);
-    let matches: FakeResponsesItemRow[];
-    if (query.includes('encrypted_content_hash IN')) {
-      matches = this.rows
-        .filter(row => row.api_key_id === apiKeyId && row.encrypted_content_hash !== null && wanted.has(row.encrypted_content_hash))
-        .map(row => ({ ...row }))
-        .toSorted(compareFakeResponsesItemsByFreshness);
-    } else if (query.includes('content_hash IN')) {
-      matches = this.rows
-        .filter(row => row.api_key_id === apiKeyId && row.content_hash !== null && wanted.has(row.content_hash))
-        .map(row => ({ ...row }))
-        .toSorted(compareFakeResponsesItemsByFreshness);
-    } else {
-      matches = this.rows.filter(row => wanted.has(row.id) && row.api_key_id === apiKeyId);
-      const order = new Map(keys.map((id, index) => [id, index]));
-      matches = matches.map(row => ({ ...row })).toSorted((a, b) => order.get(a.id)! - order.get(b.id)!);
-    }
-    if (query.startsWith('SELECT id, payload_json')) {
-      return matches.map(row => ({ id: row.id, payload_json: row.payload_json }));
-    }
-    return matches.map(({ payload_json: payloadJson, ...row }) => ({ ...row, has_payload: payloadJson === null ? 0 : 1 }));
-  }
-
-  clearPayloadOlderThan(createdBefore: number): number {
-    let changes = 0;
-    for (const row of this.rows) {
-      if (row.created_at < createdBefore && row.payload_json !== null) {
-        row.payload_json = null;
-        changes += 1;
-      }
-    }
-    return changes;
-  }
-
-  deleteOlderThan(createdBefore: number): number {
-    const previousLength = this.rows.length;
-    this.rows = this.rows.filter(row => row.refreshed_at >= createdBefore);
-    return previousLength - this.rows.length;
-  }
-}
-
-const compareFakeResponsesItemsByFreshness = (a: FakeResponsesItemRow, b: FakeResponsesItemRow): number =>
-  b.refreshed_at - a.refreshed_at || b.created_at - a.created_at || a.id.localeCompare(b.id);
-
-type SqlJsDatabase = {
-  run(sql: string): void;
-  exec(sql: string): Array<{ columns: string[]; values: unknown[][] }>;
-  close(): void;
-};
-
-const migrationSqlByPath = import.meta.glob('../../migrations/*.sql', { query: '?raw', import: 'default', eager: true }) as Record<string, string>;
-const migrationSqlByFilename = new Map(Object.entries(migrationSqlByPath).map(([path, sql]) => [path.slice(path.lastIndexOf('/') + 1), sql]));
-
-const applySqlJsFile = (db: SqlJsDatabase, filename: string): void => {
-  const sql = migrationSqlByFilename.get(filename);
-  if (!sql) throw new Error(`Missing migration SQL fixture: ${filename}`);
-  db.run(sql);
-};
-
-const sqlJsRows = <T>(db: SqlJsDatabase, sql: string): T[] => {
-  const [result] = db.exec(sql);
-  if (!result) return [];
-  return result.values.map(values => Object.fromEntries(result.columns.map((column, index) => [column, values[index] ?? null])) as T);
-};
diff --git a/packages/gateway/src/repo/responses-payload.ts b/packages/gateway/src/repo/responses-payload.ts
index cdce41c66..0d150b97a 100644
--- a/packages/gateway/src/repo/responses-payload.ts
+++ b/packages/gateway/src/repo/responses-payload.ts
@@ -1,13 +1,6 @@
 import type { StoredResponsesItemPayload } from './types.ts';
 import { getFileProvider, sha256Hex } from '@floway-dev/platform';
 
-// Two encodings coexist in this column:
-//   - legacy (no `encoding` field): inline `payload` is a plain object;
-//     file body is the raw payload JSON bytes
-//   - "gzip": inline `payload` is a base64 string of gzipped JSON bytes;
-//     file body is the gzipped JSON bytes
-// Writes always emit "gzip"; reads accept both so legacy rows stay
-// deserializable for the remainder of their TTL.
 type StoredResponsesPayloadJson =
   | {
     version: 1;
@@ -42,16 +35,9 @@ type StoredResponsesPayloadJson =
 // cap pushes large tool outputs out to the file provider where per-byte
 // storage is dramatically cheaper than D1.
 const INLINE_PAYLOAD_LIMIT_BYTES = 64 * 1024;
-// Read only by the scheduled cleanup (payload-file sweep + descriptor clear).
-// Lookups intentionally do NOT filter by this TTL: a row stays referenceable
-// until cleanup actually removes it, so expiry is driven by the sweeper alone.
-export const RESPONSES_ITEM_PAYLOAD_TTL_MS = 30 * 24 * 60 * 60 * 1000;
-// `refreshed_at` writes are debounced within this window. Long Responses
-// sessions touch every prior item every turn; without coalescing, per-request
-// UPDATE volume would scale with conversation history length. One UPDATE per
-// row per day shifts the row-retention sweep by at most one day relative to
-// the 180-day row TTL, well below the precision worth paying for.
-export const RESPONSES_REFRESH_DEBOUNCE_MS = 24 * 60 * 60 * 1000;
+// Shared refreshable horizon for item/snapshot deletion and spilled-file
+// expiry buckets. Snapshot commits refresh every referenced item's timestamp.
+export const RESPONSES_STATE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const HOUR_MS = 60 * 60 * 1000;
 
 // Root under which every stored-payload file lives, regardless of expiry hour.
@@ -63,12 +49,10 @@ const decoder = new TextDecoder();
 
 export const serializeStoredResponsesPayload = async (
   id: string,
-  apiKeyId: string | null,
+  apiKeyId: string,
   createdAt: number,
-  payload: StoredResponsesItemPayload | null,
-): Promise<string | null> => {
-  if (payload === null) return null;
-
+  payload: StoredResponsesItemPayload,
+): Promise<string> => {
   const rawBytes = encoder.encode(JSON.stringify(payload));
   const gzippedBytes = await gzipBytes(rawBytes);
 
@@ -86,9 +70,13 @@ export const serializeStoredResponsesPayload = async (
   // sha256/byteLength describe the file's actual bytes (gzipped) so file
   // integrity verification stays a plain hash-of-body check.
   const sha256 = await sha256Hex(gzippedBytes);
-  const expiresAt = createdAt + RESPONSES_ITEM_PAYLOAD_TTL_MS;
-  const apiKeyHashPrefix = (await sha256Hex(encoder.encode(apiKeyId ?? ''))).slice(0, 16);
-  const key = `${responsesItemsExpiryBucketPrefix(expiresAt)}${apiKeyHashPrefix}/${id}/${sha256}.gz`;
+  const expiresAt = createdAt + RESPONSES_STATE_TTL_MS;
+  const apiKeyHashPrefix = (await sha256Hex(encoder.encode(apiKeyId))).slice(0, 16);
+  // The digest keeps integrity/content identity visible, while the nonce gives
+  // each pre-SQL write exclusive cleanup ownership. A losing concurrent write
+  // can then delete its object without racing a later winner that stored the
+  // same item bytes under the same expiry bucket.
+  const key = `${responsesItemPayloadExpiryBucketPrefix(expiresAt)}${apiKeyHashPrefix}/${id}/${sha256}-${randomFileNonce()}.gz`;
   await getFileProvider().put(key, gzippedBytes);
   return JSON.stringify({
     version: 1,
@@ -102,15 +90,13 @@ export const serializeStoredResponsesPayload = async (
 
 export const parseStoredResponsesPayload = async (
   id: string,
-  raw: string | null,
-): Promise<StoredResponsesItemPayload | null> => {
-  if (raw === null) return null;
-
+  raw: string,
+): Promise<StoredResponsesItemPayload> => {
   const descriptor = parseDescriptor(id, raw);
   if (descriptor.storage === 'inline') {
     return 'encoding' in descriptor
-      ? clonePayload(parseInlinePayloadJson(id, await ungzipToString(base64ToBytes(descriptor.payload))))
-      : clonePayload(descriptor.payload);
+      ? parseInlinePayloadJson(id, await ungzipToString(base64ToBytes(descriptor.payload)))
+      : descriptor.payload;
   }
 
   const body = await getFileProvider().get(descriptor.key);
@@ -123,8 +109,12 @@ export const parseStoredResponsesPayload = async (
     throw new Error(`Stored Responses payload file hash mismatch for id=${id}`);
   }
 
-  const json = 'encoding' in descriptor ? await ungzipToString(body) : decoder.decode(body);
-  return clonePayload(parseInlinePayloadJson(id, json));
+  return parseInlinePayloadJson(id, 'encoding' in descriptor ? await ungzipToString(body) : decoder.decode(body));
+};
+
+export const storedResponsesPayloadFileKey = (id: string, raw: string): string | null => {
+  const descriptor = parseDescriptor(id, raw);
+  return descriptor.storage === 'file' ? descriptor.key : null;
 };
 
 const parseInlinePayloadJson = (id: string, json: string): StoredResponsesItemPayload => {
@@ -161,12 +151,8 @@ const parseDescriptor = (id: string, raw: string): StoredResponsesPayloadJson =>
     && Number.isSafeInteger(parsed.byteLength)
     && parsed.byteLength >= 0
   ) {
-    if (parsed.encoding === 'gzip') {
-      return { version: 1, storage: 'file', encoding: 'gzip', key: parsed.key, sha256: parsed.sha256, byteLength: parsed.byteLength };
-    }
-    if (parsed.encoding === undefined) {
-      return { version: 1, storage: 'file', key: parsed.key, sha256: parsed.sha256, byteLength: parsed.byteLength };
-    }
+    if (parsed.encoding === 'gzip') return { version: 1, storage: 'file', encoding: 'gzip', key: parsed.key, sha256: parsed.sha256, byteLength: parsed.byteLength };
+    if (parsed.encoding === undefined) return { version: 1, storage: 'file', key: parsed.key, sha256: parsed.sha256, byteLength: parsed.byteLength };
   }
   throw new Error(`Invalid responses_items.payload_json for id=${id} (storage=${typeof parsed.storage === 'string' ? parsed.storage : 'unknown'}, encoding=${typeof parsed.encoding === 'string' ? parsed.encoding : 'absent'})`);
 };
@@ -178,12 +164,6 @@ const assertPayloadObject = (id: string, value: unknown): StoredResponsesItemPay
   return payload;
 };
 
-const clonePayload = (payload: StoredResponsesItemPayload): StoredResponsesItemPayload => ({
-  ...payload,
-  item: structuredClone(payload.item),
-  ...(Object.hasOwn(payload, 'private') ? { private: structuredClone(payload.private) } : {}),
-});
-
 // Copying through `new Uint8Array(bytes)` gives Blob a concrete
 // ArrayBuffer-backed view regardless of the caller's ArrayBufferLike type
 // parameter; the cast-free form fails strict-mode BufferSource on slices and
@@ -209,6 +189,12 @@ const bytesToBase64 = (bytes: Uint8Array): string => {
   return btoa(binary);
 };
 
+const randomFileNonce = (): string => {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return bytesToBase64(bytes).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/u, '');
+};
+
 const base64ToBytes = (base64: string): Uint8Array => {
   const binary = atob(base64);
   const bytes = new Uint8Array(binary.length);
@@ -223,7 +209,7 @@ const base64ToBytes = (base64: string): Uint8Array => {
 // This is resilient to missed cron runs: a skipped hour is revisited on the
 // next run rather than leaking into R2.
 export const sweepExpiredResponsesItemPayloadFiles = async (now: number): Promise<void> => {
-  const currentHourPrefix = responsesItemsExpiryBucketPrefix(startOfUtcHour(now));
+  const currentHourPrefix = responsesItemPayloadExpiryBucketPrefix(startOfUtcHour(now));
   const provider = getFileProvider();
   const keys = await provider.listKeys(RESPONSES_ITEMS_FILE_ROOT);
   const expiredBuckets = new Set<string>();
@@ -242,7 +228,7 @@ export const deleteAllResponsesItemPayloadFiles = async (): Promise<void> => {
   await getFileProvider().deletePrefix(RESPONSES_ITEMS_FILE_ROOT);
 };
 
-const responsesItemsExpiryBucketPrefix = (hourTimestamp: number): string => {
+export const responsesItemPayloadExpiryBucketPrefix = (hourTimestamp: number): string => {
   const date = new Date(hourTimestamp);
   const yyyy = String(date.getUTCFullYear()).padStart(4, '0');
   const mm = String(date.getUTCMonth() + 1).padStart(2, '0');
diff --git a/packages/gateway/src/repo/responses-payload_test.ts b/packages/gateway/src/repo/responses-payload_test.ts
index 875c0ad1a..efcb75a49 100644
--- a/packages/gateway/src/repo/responses-payload_test.ts
+++ b/packages/gateway/src/repo/responses-payload_test.ts
@@ -18,7 +18,7 @@ const incompressibleString = (approxBytes: number): string => {
 test('the reserved private payload field round-trips through both inline and file storage', async () => {
   initFileProvider(new MemoryFileProvider());
 
-  const inline = await serializeStoredResponsesPayload('msg_inline', null, 0, {
+  const inline = await serializeStoredResponsesPayload('msg_inline', 'key-test', 0, {
     item: { type: 'web_search_call', id: 'ws_x' },
     private: { results: [{ url: 'https://example.test', title: 'kept' }] },
   });
@@ -29,7 +29,7 @@ test('the reserved private payload field round-trips through both inline and fil
 
   // A payload past the inline limit spills its body to the file provider; the
   // private slot must survive that path too.
-  const spilled = await serializeStoredResponsesPayload('msg_spilled', null, 0, {
+  const spilled = await serializeStoredResponsesPayload('msg_spilled', 'key-test', 0, {
     item: { type: 'message', id: 'msg_big', content: incompressibleString(96 * 1024) },
     private: { results: 'preserved' },
   });
@@ -37,29 +37,33 @@ test('the reserved private payload field round-trips through both inline and fil
   assertEquals(parsed?.private, { results: 'preserved' });
 });
 
-test('spilled payload file keys include the content hash to avoid overwrites', async () => {
+test('identical spilled payload writes get distinct owned keys that retain the content hash', async () => {
   const files = new MemoryFileProvider();
   initFileProvider(files);
   const createdAt = Date.UTC(2026, 4, 28, 12);
 
-  const firstContent = `a${incompressibleString(96 * 1024)}`;
-  const secondContent = `b${incompressibleString(96 * 1024)}`;
+  const content = incompressibleString(96 * 1024);
   const first = await serializeStoredResponsesPayload('msg_same_id', 'key_a', createdAt, {
-    item: { type: 'message', id: 'msg_big', content: firstContent },
+    item: { type: 'message', id: 'msg_big', content },
   });
   const second = await serializeStoredResponsesPayload('msg_same_id', 'key_a', createdAt, {
-    item: { type: 'message', id: 'msg_big', content: secondContent },
+    item: { type: 'message', id: 'msg_big', content },
   });
+  const firstDescriptor = JSON.parse(first) as { key: string; sha256: string };
+  const secondDescriptor = JSON.parse(second) as { key: string; sha256: string };
 
   assertEquals((await files.listKeys('responses-items/v1/expires/')).length, 2);
-  assertEquals((await parseStoredResponsesPayload('msg_same_id', first))?.item, { type: 'message', id: 'msg_big', content: firstContent });
-  assertEquals((await parseStoredResponsesPayload('msg_same_id', second))?.item, { type: 'message', id: 'msg_big', content: secondContent });
+  assert(firstDescriptor.key !== secondDescriptor.key);
+  assert(firstDescriptor.key.includes(firstDescriptor.sha256));
+  assert(secondDescriptor.key.includes(secondDescriptor.sha256));
+  assertEquals((await parseStoredResponsesPayload('msg_same_id', first))?.item, { type: 'message', id: 'msg_big', content });
+  assertEquals((await parseStoredResponsesPayload('msg_same_id', second))?.item, { type: 'message', id: 'msg_big', content });
 });
 
 test('inline payload round-trips through gzip+base64 and the descriptor advertises the encoding', async () => {
   initFileProvider(new MemoryFileProvider());
 
-  const serialized = await serializeStoredResponsesPayload('msg_round', null, 0, {
+  const serialized = await serializeStoredResponsesPayload('msg_round', 'key-test', 0, {
     item: { type: 'message', id: 'msg_round', content: 'hello world' },
   });
   assert(serialized !== null);
@@ -74,26 +78,22 @@ test('inline payload round-trips through gzip+base64 and the descriptor advertis
   });
 });
 
-test('legacy inline payload descriptors still parse without an encoding field', async () => {
+test('legacy inline payload descriptors remain readable after the state migration', async () => {
   initFileProvider(new MemoryFileProvider());
-
-  // Hand-rolled because rows written by builds older than this change carry no
-  // encoding field; the read path keeps deserializing them while their TTL
-  // elapses (we cannot reach back through the deploy lag and rewrite them).
-  const legacy = JSON.stringify({
+  const descriptor = JSON.stringify({
     version: 1,
     storage: 'inline',
     payload: { item: { type: 'message', id: 'msg_legacy', content: 'plain' } },
   });
-  assertEquals(await parseStoredResponsesPayload('msg_legacy', legacy), {
+
+  assertEquals(await parseStoredResponsesPayload('msg_legacy', descriptor), {
     item: { type: 'message', id: 'msg_legacy', content: 'plain' },
   });
 });
 
-test('legacy file payload descriptors verify their hash and parse the unencoded body', async () => {
+test('legacy file descriptors retain their uncompressed payload body', async () => {
   const files = new MemoryFileProvider();
   initFileProvider(files);
-
   const body = new TextEncoder().encode(JSON.stringify({ item: { type: 'message', id: 'msg_file_legacy', content: 'persisted' } }));
   const digest = await crypto.subtle.digest('SHA-256', body);
   const sha256 = Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
diff --git a/packages/gateway/src/repo/sql.ts b/packages/gateway/src/repo/sql.ts
index eb2187892..d3c2d24f9 100644
--- a/packages/gateway/src/repo/sql.ts
+++ b/packages/gateway/src/repo/sql.ts
@@ -1,7 +1,8 @@
 import { normalizeDisabledPublicModelIds } from './disabled-public-models.ts';
 import { normalizeFlagOverrides } from './flag-overrides.ts';
 import { normalizeProxyFallbackList } from './proxy-fallback-list.ts';
-import { deleteAllResponsesItemPayloadFiles, parseStoredResponsesPayload, RESPONSES_REFRESH_DEBOUNCE_MS, serializeStoredResponsesPayload } from './responses-payload.ts';
+import { scopedResponsesKey } from './responses-clone.ts';
+import { deleteAllResponsesItemPayloadFiles, parseStoredResponsesPayload, RESPONSES_STATE_TTL_MS, responsesItemPayloadExpiryBucketPrefix, serializeStoredResponsesPayload, storedResponsesPayloadFileKey } from './responses-payload.ts';
 import type {
   ApiKey,
   ApiKeyRepo,
@@ -29,8 +30,6 @@ import type {
   Session,
   SessionsRepo,
   StoredResponsesItem,
-  StoredResponsesItemMetadata,
-  StoredResponsesItemPayloadRecord,
   StoredResponsesSnapshot,
   UpstreamRepo,
   UsageRecord,
@@ -42,9 +41,10 @@ import { serializeStoredConfig, serializeStoredState } from './upstream-json.ts'
 import { parseUpstreamColor, parseUpstreamKind } from './upstream-parse.ts';
 import { usageDimensionRows } from './usage-dimensions.ts';
 import { bucketForTtftMs, bucketForTpotUs } from '../shared/performance-histogram.ts';
+import { parseServerSecret } from '../shared/server-secret.ts';
 import { generateSessionToken } from '../shared/session-tokens.ts';
 import { assertWebSearchProviderName } from '../shared/web-search-providers.ts';
-import type { SqlDatabase, SqlPreparedStatement, SqlResult } from '@floway-dev/platform';
+import { getFileProvider, type SqlDatabase, type SqlPreparedStatement, type SqlResult } from '@floway-dev/platform';
 import { canonicalPricingSelectorKey, parsePricingSelectorKey, type AliasSelection, type AliasTarget, type AnnouncedMetadata, type BillingDimension, type ModelKind, type PriceVector } from '@floway-dev/protocols/common';
 import type { ProviderModel, ProxyFallbackEntry, ModelPrefixConfig, PerformanceOperation, UpstreamRecord } from '@floway-dev/provider';
 import { normalizeModelPrefix } from '@floway-dev/provider';
@@ -68,6 +68,7 @@ interface ApiKeyRow {
   user_id: number;
   name: string;
   key: string;
+  server_secret: string;
   created_at: string;
   last_used_at: string | null;
   upstream_ids: string | null;
@@ -75,7 +76,7 @@ interface ApiKeyRow {
   dump_retention_seconds: number | null;
 }
 
-const API_KEY_COLUMNS = 'id, user_id, name, key, created_at, last_used_at, upstream_ids, deleted_at, dump_retention_seconds';
+const API_KEY_COLUMNS = 'id, user_id, name, key, server_secret, created_at, last_used_at, upstream_ids, deleted_at, dump_retention_seconds';
 
 const serializeUpstreamIds = (value: readonly string[] | null): string | null => (value === null ? null : JSON.stringify(value));
 
@@ -99,6 +100,7 @@ const toApiKey = (row: ApiKeyRow): ApiKey => ({
   userId: row.user_id,
   name: row.name,
   key: row.key,
+  serverSecret: parseServerSecret(row.server_secret, `api_keys.server_secret for id=${row.id}`),
   createdAt: row.created_at,
   lastUsedAt: row.last_used_at ?? undefined,
   upstreamIds: parseUpstreamIds(row.upstream_ids, `api_keys.id=${row.id}`),
@@ -158,11 +160,12 @@ class SqlApiKeyRepo implements ApiKeyRepo {
   async save(key: ApiKey): Promise<void> {
     await this.db
       .prepare(
-        `INSERT INTO api_keys (${API_KEY_COLUMNS}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `INSERT INTO api_keys (${API_KEY_COLUMNS}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT (id) DO UPDATE SET
            user_id = excluded.user_id,
            name = excluded.name,
            key = excluded.key,
+           server_secret = excluded.server_secret,
            last_used_at = excluded.last_used_at,
            upstream_ids = excluded.upstream_ids,
            deleted_at = excluded.deleted_at,
@@ -173,6 +176,7 @@ class SqlApiKeyRepo implements ApiKeyRepo {
         key.userId,
         key.name,
         key.key,
+        key.serverSecret,
         key.createdAt,
         key.lastUsedAt ?? null,
         serializeUpstreamIds(key.upstreamIds),
@@ -809,129 +813,297 @@ class SqlModelsCacheRepo implements ModelsCacheRepo {
   }
 }
 
-const RESPONSES_ITEM_WRITE_COLUMNS = 'id, api_key_id, upstream_id, upstream_item_id, item_type, origin, payload_json, content_hash, encrypted_content_hash, created_at, refreshed_at';
-const RESPONSES_ITEM_METADATA_COLUMNS = 'id, api_key_id, upstream_id, upstream_item_id, item_type, origin, payload_json IS NOT NULL AS has_payload, content_hash, encrypted_content_hash, created_at, refreshed_at';
-const RESPONSES_ITEM_ID_SCOPE_SQL = "COALESCE(api_key_id, '') = COALESCE(?, '')";
+const RESPONSES_ITEM_COLUMNS = 'id, api_key_id, item_type, payload_json, content_hash, created_at';
+// D1 permits 100 bound parameters per query. Descriptor reads reserve one
+// bind for api_key_id; inserts use six binds per item; refresh CASE updates
+// use four per item plus created_at and api_key_id.
+// https://developers.cloudflare.com/d1/platform/limits/#limits
+const RESPONSES_IN_QUERY_CHUNK_SIZE = 90;
+const RESPONSES_INSERT_CHUNK_SIZE = 16;
+const RESPONSES_REFRESH_CHUNK_SIZE = 24;
+
+interface ResponsesItemDescriptor {
+  id: string;
+  apiKeyId: string;
+  payloadJson: string;
+}
+
+interface ResponsesItemDescriptorRow {
+  id: string;
+  api_key_id: string;
+  payload_json: string;
+}
+
+interface PreparedResponsesPayloadWrite {
+  item: StoredResponsesItem;
+  payload: string;
+  generatedFileKey: string | null;
+  previousPayloadJson: string | null;
+  previousFileKey: string | null;
+}
+
+const uniqueResponsesItems = (items: readonly StoredResponsesItem[]): StoredResponsesItem[] => {
+  const unique = new Map<string, StoredResponsesItem>();
+  for (const item of items) {
+    const key = scopedResponsesKey(item.apiKeyId, item.id);
+    if (!unique.has(key)) unique.set(key, item);
+  }
+  return [...unique.values()];
+};
+
+const groupResponsesPayloadWrites = (writes: readonly PreparedResponsesPayloadWrite[]): Map<string, PreparedResponsesPayloadWrite[]> => {
+  const groups = new Map<string, PreparedResponsesPayloadWrite[]>();
+  for (const write of writes) {
+    const group = groups.get(write.item.apiKeyId) ?? [];
+    group.push(write);
+    groups.set(write.item.apiKeyId, group);
+  }
+  return groups;
+};
+
+const responsesErrorMessage = (error: unknown): string => error instanceof Error ? error.message : String(error);
 
 class SqlResponsesItemsRepo implements ResponsesItemsRepo {
   constructor(private db: SqlDatabase) {}
 
-  async lookupMany(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemMetadata[]> {
+  async lookupMany(apiKeyId: string, ids: readonly string[]): Promise<StoredResponsesItem[]> {
     const rows = await this.lookupByColumn(apiKeyId, 'id', ids);
     const order = new Map([...new Set(ids)].map((id, index) => [id, index]));
     return rows.toSorted((a, b) => order.get(a.id)! - order.get(b.id)!);
   }
 
-  async lookupManyByEncryptedContentHash(apiKeyId: string | null, hashes: readonly string[]): Promise<StoredResponsesItemMetadata[]> {
-    return await this.lookupByColumn(apiKeyId, 'encrypted_content_hash', hashes);
-  }
-
-  async lookupManyByContentHash(apiKeyId: string | null, hashes: readonly string[]): Promise<StoredResponsesItemMetadata[]> {
+  async lookupManyByContentHash(apiKeyId: string, hashes: readonly string[]): Promise<StoredResponsesItem[]> {
     return await this.lookupByColumn(apiKeyId, 'content_hash', hashes);
   }
 
-  // D1 caps bound parameters at 100 per query (node:sqlite's default cap is
-  // 32766, well above this). A single Responses request can echo back more
-  // stored items than D1's cap — long agentic sessions resubmit every prior
-  // reasoning/compaction item each turn — so chunk the IN-list well under
-  // the tightest backend (the `api_key_id` bind shares the budget) and union
-  // the results.
-  private async lookupByColumn(apiKeyId: string | null, column: 'id' | 'content_hash' | 'encrypted_content_hash', values: readonly string[]): Promise<StoredResponsesItemMetadata[]> {
+  // A single Responses request can echo back more stored items than one
+  // IN-list can hold, so chunk the list and union the results.
+  private async lookupByColumn(apiKeyId: string, column: 'id' | 'content_hash', values: readonly string[]): Promise<StoredResponsesItem[]> {
     const unique = [...new Set(values)];
     if (unique.length === 0) return [];
 
-    const CHUNK = 90;
     const chunks: string[][] = [];
-    for (let i = 0; i < unique.length; i += CHUNK) chunks.push(unique.slice(i, i + CHUNK));
+    for (let i = 0; i < unique.length; i += RESPONSES_IN_QUERY_CHUNK_SIZE) {
+      chunks.push(unique.slice(i, i + RESPONSES_IN_QUERY_CHUNK_SIZE));
+    }
 
     const perChunk = await Promise.all(chunks.map(async chunk => {
       const placeholders = chunk.map(() => '?').join(', ');
-      const orderSql = column === 'id' ? '' : ' ORDER BY refreshed_at DESC, created_at DESC, id ASC';
-      const scopeSql = column === 'id' ? RESPONSES_ITEM_ID_SCOPE_SQL : 'api_key_id IS ?';
+      const orderSql = column === 'id' ? '' : ' ORDER BY created_at DESC, id ASC';
       const { results } = await this.db
-        .prepare(`SELECT ${RESPONSES_ITEM_METADATA_COLUMNS} FROM responses_items WHERE ${scopeSql} AND ${column} IN (${placeholders})${orderSql}`)
+        .prepare(`SELECT ${RESPONSES_ITEM_COLUMNS} FROM responses_items WHERE api_key_id = ? AND ${column} IN (${placeholders})${orderSql}`)
         .bind(apiKeyId, ...chunk)
-        .all<ResponsesItemMetadataRow>();
+        .all<ResponsesItemRow>();
       return results;
     }));
-    return perChunk.flat().map(toStoredResponsesItemMetadata);
+    return await mapSequentially(perChunk.flat(), toStoredResponsesItem);
   }
 
-  async lookupPayloads(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemPayloadRecord[]> {
-    const unique = [...new Set(ids)];
-    const chunks: string[][] = [];
-    for (let index = 0; index < unique.length; index += 90) chunks.push(unique.slice(index, index + 90));
-    const perChunk = await Promise.all(chunks.map(async chunk => {
-      const placeholders = chunk.map(() => '?').join(', ');
-      const { results } = await this.db
-        .prepare(`SELECT id, payload_json FROM responses_items WHERE ${RESPONSES_ITEM_ID_SCOPE_SQL} AND id IN (${placeholders})`)
-        .bind(apiKeyId, ...chunk)
-        .all<{ id: string; payload_json: string | null }>();
-      return results;
-    }));
-    const rowsById = new Map(perChunk.flat().map(row => [row.id, row]));
-    const records: StoredResponsesItemPayloadRecord[] = [];
-    for (const id of unique) {
-      const payloadJson = rowsById.get(id)?.payload_json;
-      if (payloadJson === undefined || payloadJson === null) continue;
-      const payload = await parseStoredResponsesPayload(id, payloadJson);
-      if (payload !== null) records.push({ id, payload });
+  async insertMany(items: readonly StoredResponsesItem[]): Promise<void> {
+    const unique = uniqueResponsesItems(items);
+    const existing = await this.lookupDescriptors(unique);
+    const pending = unique.filter(item => !existing.has(scopedResponsesKey(item.apiKeyId, item.id)));
+    const writes: PreparedResponsesPayloadWrite[] = [];
+    try {
+      for (const item of pending) {
+        const payload = await serializeStoredResponsesPayload(item.id, item.apiKeyId, item.createdAt, item.payload);
+        writes.push({
+          item,
+          payload,
+          generatedFileKey: storedResponsesPayloadFileKey(item.id, payload),
+          previousPayloadJson: null,
+          previousFileKey: null,
+        });
+      }
+    } catch (error) {
+      await this.finishPayloadWrites(writes, error, 'insert');
     }
-    return records;
-  }
 
-  async insertMany(items: readonly StoredResponsesItem[]): Promise<void> {
-    const statements = await mapSequentially(items, async item => {
-      const payload = await serializeStoredResponsesPayload(item.id, item.apiKeyId, item.createdAt, item.payload);
-      return this.db
+    const statements: SqlPreparedStatement[] = [];
+    for (let index = 0; index < writes.length; index += RESPONSES_INSERT_CHUNK_SIZE) {
+      const chunk = writes.slice(index, index + RESPONSES_INSERT_CHUNK_SIZE);
+      const values = chunk.map(() => '(?, ?, ?, ?, ?, ?)').join(', ');
+      statements.push(this.db
         .prepare(
-          `INSERT INTO responses_items (${RESPONSES_ITEM_WRITE_COLUMNS}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-           ON CONFLICT (id, COALESCE(api_key_id, '')) DO NOTHING`,
+          `INSERT INTO responses_items (${RESPONSES_ITEM_COLUMNS}) VALUES ${values}
+           ON CONFLICT (id, api_key_id) DO NOTHING`,
         )
-        .bind(item.id, item.apiKeyId, item.upstreamId, item.upstreamItemId, item.itemType, item.origin, payload, item.contentHash, item.encryptedContentHash, item.createdAt, item.refreshedAt);
-    });
-    await runStatements(this.db, statements);
+        .bind(...chunk.flatMap(({ item, payload }) => [item.id, item.apiKeyId, item.itemType, payload, item.contentHash, item.createdAt])));
+    }
+    try {
+      await runStatements(this.db, statements);
+    } catch (error) {
+      await this.finishPayloadWrites(writes, error, 'insert');
+    }
+    await this.finishPayloadWrites(writes, null, 'insert');
   }
 
-  async fillPayloads(items: readonly StoredResponsesItem[]): Promise<number> {
-    const statements = await mapSequentially(items.filter(item => item.payload !== null), async item => {
-      const payload = await serializeStoredResponsesPayload(item.id, item.apiKeyId, item.createdAt, item.payload);
-      return this.db
-        .prepare(
-          `UPDATE responses_items
-           SET payload_json = ?, content_hash = ?, encrypted_content_hash = ?, created_at = ?, refreshed_at = ?
-           WHERE ${RESPONSES_ITEM_ID_SCOPE_SQL} AND id = ? AND payload_json IS NULL`,
-        )
-        .bind(payload, item.contentHash, item.encryptedContentHash, item.createdAt, item.refreshedAt, item.apiKeyId, item.id);
-    });
-    const results = await runStatements(this.db, statements);
-    return results.reduce((sum, result) => sum + (result.meta.changes ?? 0), 0);
-  }
+  async refreshMany(items: readonly StoredResponsesItem[], createdAt: number): Promise<void> {
+    const unique = uniqueResponsesItems(items);
+    const previous = await this.lookupDescriptors(unique);
+    const missingBeforeWrite = unique.find(item => !previous.has(scopedResponsesKey(item.apiKeyId, item.id)));
+    if (missingBeforeWrite !== undefined) {
+      throw new Error(`Responses item disappeared before lifetime refresh: ${missingBeforeWrite.id}`);
+    }
 
-  async refreshMany(apiKeyId: string | null, ids: readonly string[], refreshedAt: number): Promise<number> {
-    const unique = [...new Set(ids)];
-    if (unique.length === 0) return 0;
+    const targetFilePrefix = responsesItemPayloadExpiryBucketPrefix(createdAt + RESPONSES_STATE_TTL_MS);
+    const writes: PreparedResponsesPayloadWrite[] = [];
+    try {
+      for (const item of unique) {
+        const descriptor = previous.get(scopedResponsesKey(item.apiKeyId, item.id))!;
+        const previousFileKey = storedResponsesPayloadFileKey(item.id, descriptor.payloadJson);
+        const moveFile = previousFileKey !== null && !previousFileKey.startsWith(targetFilePrefix);
+        const payload = moveFile
+          ? await serializeStoredResponsesPayload(item.id, item.apiKeyId, createdAt, item.payload)
+          : descriptor.payloadJson;
+        writes.push({
+          item,
+          payload,
+          generatedFileKey: moveFile ? storedResponsesPayloadFileKey(item.id, payload) : null,
+          previousPayloadJson: descriptor.payloadJson,
+          previousFileKey,
+        });
+      }
+    } catch (error) {
+      await this.finishPayloadWrites(writes, error, 'refresh');
+    }
 
-    const CHUNK = 88;
-    const chunks: string[][] = [];
-    for (let i = 0; i < unique.length; i += CHUNK) chunks.push(unique.slice(i, i + CHUNK));
-    const results = await Promise.all(chunks.map(async chunk => {
-      const placeholders = chunk.map(() => '?').join(', ');
-      return await this.db
-        .prepare(`UPDATE responses_items SET refreshed_at = ? WHERE ${RESPONSES_ITEM_ID_SCOPE_SQL} AND id IN (${placeholders}) AND refreshed_at < ?`)
-        .bind(refreshedAt, apiKeyId, ...chunk, refreshedAt - RESPONSES_REFRESH_DEBOUNCE_MS)
-        .run();
-    }));
-    return results.reduce((sum, result) => sum + (result.meta.changes ?? 0), 0);
+    const statementChunks: Array<{ writes: PreparedResponsesPayloadWrite[]; statement: SqlPreparedStatement }> = [];
+    for (const [apiKeyId, group] of groupResponsesPayloadWrites(writes)) {
+      for (let index = 0; index < group.length; index += RESPONSES_REFRESH_CHUNK_SIZE) {
+        const chunk = group.slice(index, index + RESPONSES_REFRESH_CHUNK_SIZE);
+        const cases = chunk.map(() => 'WHEN ? THEN ?').join(' ');
+        const conditions = chunk.map(() => '(id = ? AND payload_json = ?)').join(' OR ');
+        statementChunks.push({
+          writes: chunk,
+          statement: this.db
+            .prepare(
+              `UPDATE responses_items
+               SET payload_json = CASE id ${cases} ELSE payload_json END,
+                   created_at = MAX(created_at, ?)
+               WHERE api_key_id = ? AND (${conditions})`,
+            )
+            .bind(
+              ...chunk.flatMap(({ item, payload }) => [item.id, payload]),
+              createdAt,
+              apiKeyId,
+              ...chunk.flatMap(({ item, previousPayloadJson }) => [item.id, previousPayloadJson]),
+            ),
+        });
+      }
+    }
+    let countError: Error | null = null;
+    try {
+      const results = await runStatements(this.db, statementChunks.map(chunk => chunk.statement));
+      const mismatch = statementChunks.find((chunk, index) => results[index]?.meta.changes !== chunk.writes.length);
+      if (mismatch !== undefined) {
+        countError = new Error(`Unexpected Responses item refresh count: expected ${mismatch.writes.length}`);
+      }
+    } catch (error) {
+      await this.finishPayloadWrites(writes, error, 'refresh');
+    }
+    await this.finishPayloadWrites(writes, countError, 'refresh', true);
   }
 
-  async clearPayloadOlderThan(createdBefore: number): Promise<number> {
-    const result = await this.db.prepare('UPDATE responses_items SET payload_json = NULL WHERE payload_json IS NOT NULL AND created_at < ?').bind(createdBefore).run();
-    return result.meta.changes ?? 0;
+  private async lookupDescriptors(items: readonly Pick<StoredResponsesItem, 'id' | 'apiKeyId'>[]): Promise<Map<string, ResponsesItemDescriptor>> {
+    const idsByApiKey = new Map<string, Set<string>>();
+    for (const item of items) {
+      const ids = idsByApiKey.get(item.apiKeyId) ?? new Set<string>();
+      ids.add(item.id);
+      idsByApiKey.set(item.apiKeyId, ids);
+    }
+
+    const queries: Promise<SqlResult<ResponsesItemDescriptorRow>>[] = [];
+    for (const [apiKeyId, idSet] of idsByApiKey) {
+      const ids = [...idSet];
+      for (let index = 0; index < ids.length; index += RESPONSES_IN_QUERY_CHUNK_SIZE) {
+        const chunk = ids.slice(index, index + RESPONSES_IN_QUERY_CHUNK_SIZE);
+        const placeholders = chunk.map(() => '?').join(', ');
+        queries.push(this.db
+          .prepare(`SELECT id, api_key_id, payload_json FROM responses_items WHERE api_key_id = ? AND id IN (${placeholders})`)
+          .bind(apiKeyId, ...chunk)
+          .all<ResponsesItemDescriptorRow>());
+      }
+    }
+    const results = await Promise.all(queries);
+    return new Map(results.flatMap(result => result.results.map(row => {
+      const descriptor: ResponsesItemDescriptor = {
+        id: row.id,
+        apiKeyId: row.api_key_id,
+        payloadJson: row.payload_json,
+      };
+      return [scopedResponsesKey(row.api_key_id, row.id), descriptor] as const;
+    })));
+  }
+
+  private async finishPayloadWrites(
+    writes: readonly PreparedResponsesPayloadWrite[],
+    failure: unknown | null,
+    operation: 'insert' | 'refresh',
+    preferMissing = false,
+  ): Promise<void> {
+    let persisted: Map<string, ResponsesItemDescriptor>;
+    try {
+      persisted = await this.lookupDescriptors(writes.map(write => write.item));
+    } catch (cleanupError) {
+      if (failure === null) throw cleanupError;
+      throw new AggregateError([failure, cleanupError], `${responsesErrorMessage(failure)}; Responses payload reconciliation failed`);
+    }
+
+    const retainedFileKeys = new Set<string>();
+    const cleanupErrors: unknown[] = [];
+    try {
+      for (const descriptor of persisted.values()) {
+        const fileKey = storedResponsesPayloadFileKey(descriptor.id, descriptor.payloadJson);
+        if (fileKey !== null) retainedFileKeys.add(fileKey);
+      }
+    } catch (cleanupError) {
+      cleanupErrors.push(cleanupError);
+    }
+
+    if (cleanupErrors.length === 0) {
+      const obsoleteFileKeys = new Set<string>();
+      for (const write of writes) {
+        const descriptor = persisted.get(scopedResponsesKey(write.item.apiKeyId, write.item.id));
+        if (write.generatedFileKey !== null && !retainedFileKeys.has(write.generatedFileKey)) {
+          obsoleteFileKeys.add(write.generatedFileKey);
+        }
+        if (
+          operation === 'refresh'
+          && descriptor !== undefined
+          && write.previousFileKey !== null
+          && !retainedFileKeys.has(write.previousFileKey)
+        ) {
+          obsoleteFileKeys.add(write.previousFileKey);
+        }
+      }
+      const cleanupResults = await Promise.allSettled(
+        [...obsoleteFileKeys].map(async key => await getFileProvider().deletePrefix(key)),
+      );
+      for (const result of cleanupResults) {
+        if (result.status === 'rejected') cleanupErrors.push(result.reason);
+      }
+    }
+
+    const missing = writes.find(write => !persisted.has(scopedResponsesKey(write.item.apiKeyId, write.item.id)));
+    const missingError = missing === undefined
+      ? null
+      : new Error(operation === 'insert'
+          ? `Responses item conflict disappeared before spill cleanup: ${missing.item.id}`
+          : `Responses item disappeared before lifetime refresh: ${missing.item.id}`);
+    const operationError = preferMissing ? missingError ?? failure : failure ?? missingError;
+    if (cleanupErrors.length > 0) {
+      if (operationError === null) throw new AggregateError(cleanupErrors, 'Responses payload cleanup failed');
+      throw new AggregateError(
+        [operationError, ...cleanupErrors],
+        `${responsesErrorMessage(operationError)}; Responses payload cleanup failed`,
+      );
+    }
+    if (operationError !== null) throw operationError;
   }
 
-  async deleteOlderThan(refreshedBefore: number): Promise<number> {
-    const result = await this.db.prepare('DELETE FROM responses_items WHERE refreshed_at < ?').bind(refreshedBefore).run();
+  async deleteOlderThan(createdBefore: number): Promise<number> {
+    const result = await this.db.prepare('DELETE FROM responses_items WHERE created_at < ?').bind(createdBefore).run();
     return result.meta.changes ?? 0;
   }
 
@@ -941,40 +1113,30 @@ class SqlResponsesItemsRepo implements ResponsesItemsRepo {
   }
 }
 
-interface ResponsesItemMetadataRow {
+interface ResponsesItemRow {
   id: string;
-  api_key_id: string | null;
-  upstream_id: string | null;
-  upstream_item_id: string | null;
+  api_key_id: string;
   item_type: string;
-  origin: StoredResponsesItem['origin'];
-  has_payload: number;
+  payload_json: string;
   content_hash: string | null;
-  encrypted_content_hash: string | null;
   created_at: number;
-  refreshed_at: number;
 }
 
-const toStoredResponsesItemMetadata = (row: ResponsesItemMetadataRow): StoredResponsesItemMetadata => ({
+const toStoredResponsesItem = async (row: ResponsesItemRow): Promise<StoredResponsesItem> => ({
   id: row.id,
   apiKeyId: row.api_key_id,
-  upstreamId: row.upstream_id,
-  upstreamItemId: row.upstream_item_id,
   itemType: row.item_type,
-  origin: row.origin,
-  hasPayload: row.has_payload !== 0,
+  payload: await parseStoredResponsesPayload(row.id, row.payload_json),
   contentHash: row.content_hash,
-  encryptedContentHash: row.encrypted_content_hash,
   createdAt: row.created_at,
-  refreshedAt: row.refreshed_at,
 });
 
 class SqlResponsesSnapshotsRepo implements ResponsesSnapshotsRepo {
   constructor(private db: SqlDatabase) {}
 
-  async lookup(apiKeyId: string | null, id: string): Promise<StoredResponsesSnapshot | null> {
+  async lookup(apiKeyId: string, id: string): Promise<StoredResponsesSnapshot | null> {
     const row = await this.db
-      .prepare('SELECT id, api_key_id, item_ids_json, created_at, refreshed_at FROM responses_snapshots WHERE id = ? AND COALESCE(api_key_id, \'\') = COALESCE(?, \'\')')
+      .prepare('SELECT id, api_key_id, item_ids_json, created_at FROM responses_snapshots WHERE id = ? AND api_key_id = ?')
       .bind(id, apiKeyId)
       .first<ResponsesSnapshotRow>();
     return row ? toStoredResponsesSnapshot(row) : null;
@@ -983,23 +1145,17 @@ class SqlResponsesSnapshotsRepo implements ResponsesSnapshotsRepo {
   async insert(snapshot: StoredResponsesSnapshot): Promise<void> {
     await this.db
       .prepare(
-        `INSERT INTO responses_snapshots (id, api_key_id, item_ids_json, created_at, refreshed_at) VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT (id, COALESCE(api_key_id, '')) DO UPDATE SET item_ids_json = excluded.item_ids_json, refreshed_at = excluded.refreshed_at`,
+        `INSERT INTO responses_snapshots (id, api_key_id, item_ids_json, created_at) VALUES (?, ?, ?, ?)
+         ON CONFLICT (id, api_key_id) DO UPDATE SET
+           item_ids_json = excluded.item_ids_json,
+           created_at = excluded.created_at`,
       )
-      .bind(snapshot.id, snapshot.apiKeyId, JSON.stringify(snapshot.itemIds), snapshot.createdAt, snapshot.refreshedAt)
+      .bind(snapshot.id, snapshot.apiKeyId, JSON.stringify(snapshot.itemIds), snapshot.createdAt)
       .run();
   }
 
-  async refresh(apiKeyId: string | null, id: string, refreshedAt: number): Promise<boolean> {
-    const result = await this.db
-      .prepare('UPDATE responses_snapshots SET refreshed_at = ? WHERE id = ? AND COALESCE(api_key_id, \'\') = COALESCE(?, \'\') AND refreshed_at < ?')
-      .bind(refreshedAt, id, apiKeyId, refreshedAt - RESPONSES_REFRESH_DEBOUNCE_MS)
-      .run();
-    return (result.meta.changes ?? 0) > 0;
-  }
-
-  async deleteOlderThan(refreshedBefore: number): Promise<number> {
-    const result = await this.db.prepare('DELETE FROM responses_snapshots WHERE refreshed_at < ?').bind(refreshedBefore).run();
+  async deleteOlderThan(createdBefore: number): Promise<number> {
+    const result = await this.db.prepare('DELETE FROM responses_snapshots WHERE created_at < ?').bind(createdBefore).run();
     return result.meta.changes ?? 0;
   }
 
@@ -1010,10 +1166,9 @@ class SqlResponsesSnapshotsRepo implements ResponsesSnapshotsRepo {
 
 interface ResponsesSnapshotRow {
   id: string;
-  api_key_id: string | null;
+  api_key_id: string;
   item_ids_json: string;
   created_at: number;
-  refreshed_at: number;
 }
 
 const toStoredResponsesSnapshot = (row: ResponsesSnapshotRow): StoredResponsesSnapshot => {
@@ -1026,7 +1181,6 @@ const toStoredResponsesSnapshot = (row: ResponsesSnapshotRow): StoredResponsesSn
     apiKeyId: row.api_key_id,
     itemIds: parsed,
     createdAt: row.created_at,
-    refreshedAt: row.refreshed_at,
   };
 };
 
diff --git a/packages/gateway/src/repo/types.ts b/packages/gateway/src/repo/types.ts
index f591b9ba7..513fac042 100644
--- a/packages/gateway/src/repo/types.ts
+++ b/packages/gateway/src/repo/types.ts
@@ -8,6 +8,9 @@ export interface ApiKey {
   userId: number;
   name: string;
   key: string;
+  // Hidden server-private key material attached to this API key. Normal CRUD
+  // never exposes it; admin data transfer preserves it across deployments.
+  serverSecret: string;
   createdAt: string;
   lastUsedAt?: string;
   // null = inherit global upstream order; array = whitelist + priority order.
@@ -346,25 +349,13 @@ export interface ModelAliasesRepo {
   deleteAll(): Promise<void>;
 }
 
-export interface StoredResponsesItemMetadata {
+export interface StoredResponsesItem {
   id: string;
-  apiKeyId: string | null;
-  upstreamId: string | null;
-  upstreamItemId: string | null;
+  apiKeyId: string;
   itemType: string;
-  origin: 'input' | 'upstream' | 'synthetic';
-  hasPayload: boolean;
+  payload: StoredResponsesItemPayload;
   contentHash: string | null;
-  // sha256 of the item's `encrypted_content`, when it carries one (reasoning /
-  // compaction). Lets a later turn that echoes the blob without a gateway id
-  // recover this row's owning upstream for affinity routing.
-  encryptedContentHash: string | null;
   createdAt: number;
-  refreshedAt: number;
-}
-
-export interface StoredResponsesItem extends Omit<StoredResponsesItemMetadata, 'hasPayload'> {
-  payload: StoredResponsesItemPayload | null;
 }
 
 export interface StoredResponsesItemPayload {
@@ -376,37 +367,26 @@ export interface StoredResponsesItemPayload {
   private?: unknown;
 }
 
-export interface StoredResponsesItemPayloadRecord {
-  id: string;
-  payload: StoredResponsesItemPayload;
-}
-
 export interface ResponsesItemsRepo {
-  lookupMany(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemMetadata[]>;
-  lookupManyByContentHash(apiKeyId: string | null, hashes: readonly string[]): Promise<StoredResponsesItemMetadata[]>;
-  lookupManyByEncryptedContentHash(apiKeyId: string | null, hashes: readonly string[]): Promise<StoredResponsesItemMetadata[]>;
-  lookupPayloads(apiKeyId: string | null, ids: readonly string[]): Promise<StoredResponsesItemPayloadRecord[]>;
+  lookupMany(apiKeyId: string, ids: readonly string[]): Promise<StoredResponsesItem[]>;
+  lookupManyByContentHash(apiKeyId: string, hashes: readonly string[]): Promise<StoredResponsesItem[]>;
   insertMany(items: readonly StoredResponsesItem[]): Promise<void>;
-  fillPayloads(items: readonly StoredResponsesItem[]): Promise<number>;
-  refreshMany(apiKeyId: string | null, ids: readonly string[], refreshedAt: number): Promise<number>;
-  clearPayloadOlderThan(createdBefore: number): Promise<number>;
-  deleteOlderThan(refreshedBefore: number): Promise<number>;
+  refreshMany(items: readonly StoredResponsesItem[], createdAt: number): Promise<void>;
+  deleteOlderThan(createdBefore: number): Promise<number>;
   deleteAll(): Promise<void>;
 }
 
 export interface StoredResponsesSnapshot {
   id: string;
-  apiKeyId: string | null;
+  apiKeyId: string;
   itemIds: string[];
   createdAt: number;
-  refreshedAt: number;
 }
 
 export interface ResponsesSnapshotsRepo {
-  lookup(apiKeyId: string | null, id: string): Promise<StoredResponsesSnapshot | null>;
+  lookup(apiKeyId: string, id: string): Promise<StoredResponsesSnapshot | null>;
   insert(snapshot: StoredResponsesSnapshot): Promise<void>;
-  refresh(apiKeyId: string | null, id: string, refreshedAt: number): Promise<boolean>;
-  deleteOlderThan(refreshedBefore: number): Promise<number>;
+  deleteOlderThan(createdBefore: number): Promise<number>;
   deleteAll(): Promise<void>;
 }
 
diff --git a/packages/gateway/src/scheduled.ts b/packages/gateway/src/scheduled.ts
index 8771aab22..64d708009 100644
--- a/packages/gateway/src/scheduled.ts
+++ b/packages/gateway/src/scheduled.ts
@@ -1,26 +1,23 @@
 import { getDumpStore } from './dump/registry.ts';
 import { getRepo } from './repo/index.ts';
-import { RESPONSES_ITEM_PAYLOAD_TTL_MS, startOfUtcHour, sweepExpiredResponsesItemPayloadFiles } from './repo/responses-payload.ts';
+import { RESPONSES_STATE_TTL_MS, startOfUtcHour, sweepExpiredResponsesItemPayloadFiles } from './repo/responses-payload.ts';
 import { getImageCacheStore } from '@floway-dev/platform';
 
-// Read only by this scheduled cleanup (deleteOlderThan). Lookups never filter
-// by it — a row stays referenceable until cleanup removes it.
-const RESPONSES_ITEM_ROW_TTL_MS = 180 * 24 * 60 * 60 * 1000;
-
-const runSweep = async (name: string, fn: () => Promise<unknown>): Promise<void> => {
+const runSweep = async (name: string, fn: () => Promise<unknown>): Promise<boolean> => {
   try {
     await fn();
+    return true;
   } catch (err) {
     console.error(`[scheduled] ${name} failed`, err);
+    return false;
   }
 };
 
 export const runScheduledMaintenance = async (): Promise<void> => {
   const now = startOfUtcHour(Date.now());
-  await runSweep('responsesItems.clearPayloadOlderThan', () => getRepo().responsesItems.clearPayloadOlderThan(now - RESPONSES_ITEM_PAYLOAD_TTL_MS));
-  await runSweep('responsesItems.sweepPayloadFiles', () => sweepExpiredResponsesItemPayloadFiles(now));
-  await runSweep('responsesSnapshots.deleteOlderThan', () => getRepo().responsesSnapshots.deleteOlderThan(now - RESPONSES_ITEM_ROW_TTL_MS));
-  await runSweep('responsesItems.deleteOlderThan', () => getRepo().responsesItems.deleteOlderThan(now - RESPONSES_ITEM_ROW_TTL_MS));
+  await runSweep('responsesSnapshots.deleteOlderThan', () => getRepo().responsesSnapshots.deleteOlderThan(now - RESPONSES_STATE_TTL_MS));
+  const itemsDeletionSucceeded = await runSweep('responsesItems.deleteOlderThan', () => getRepo().responsesItems.deleteOlderThan(now - RESPONSES_STATE_TTL_MS));
+  if (itemsDeletionSucceeded) await runSweep('responsesItems.sweepPayloadFiles', () => sweepExpiredResponsesItemPayloadFiles(now));
   await runSweep('imageCacheStore.sweepExpired', () => getImageCacheStore().sweepExpired(Date.now()));
   await runSweep('dumps.sweepExpired', () => sweepExpiredDumps());
 };
diff --git a/packages/gateway/src/scheduled_test.ts b/packages/gateway/src/scheduled_test.ts
index 905e8e4b4..f084c1bb4 100644
--- a/packages/gateway/src/scheduled_test.ts
+++ b/packages/gateway/src/scheduled_test.ts
@@ -1,10 +1,10 @@
-import { test } from 'vitest';
+import { test, vi } from 'vitest';
 
 import { initDumpBroker, initDumpStore } from './dump/registry.ts';
 import { installDumpStubs } from './dump/test-fixtures.ts';
 import { runScheduledMaintenance } from './scheduled.ts';
 import { setupAppTest } from './test-helpers.ts';
-import { initImageCacheStore } from '@floway-dev/platform';
+import { initFileProvider, initImageCacheStore, MemoryFileProvider } from '@floway-dev/platform';
 import { assertEquals } from '@floway-dev/test-utils';
 
 const noopImageCache = {
@@ -14,11 +14,6 @@ const noopImageCache = {
 };
 
 test('runScheduledMaintenance continues sweeping the next key when one key throws', async () => {
-  // Per-key isolation inside the dump sweep: a slow or broken per-key purge
-  // must not poison the sweep for sibling keys on the same tick. The stub's
-  // purgeExpired records the attempt before throwing, so we can distinguish
-  // "the inner try/catch worked and key B was visited" from "the outer
-  // runSweep wrapper swallowed the throw before key B got a turn".
   const { repo, apiKey: keyA } = await setupAppTest();
   await repo.apiKeys.save({ ...keyA, dumpRetentionSeconds: 3600 });
   const keyB = {
@@ -42,14 +37,8 @@ test('runScheduledMaintenance continues sweeping the next key when one key throw
     console.error = origError;
   }
 
-  // The sweep continued past key A's throw and reached key B — the only
-  // signal that proves the per-key try/catch did its job. The outer
-  // runSweep wrapper alone could not produce this: it sits outside the
-  // for-loop, so an uncaught per-key throw would abort the loop entirely.
   assertEquals(stubs.purgedExpired.some(c => c.keyId === keyA.id), true);
   assertEquals(stubs.purgedExpired.some(c => c.keyId === keyB.id), true);
-  // And the log line is the per-key one (with the key id as a positional
-  // argument), not the outer wrapper's single-name form.
   assertEquals(
     errors.some(args => args[0] === '[scheduled] dump sweep failed' && args[1] === keyA.id),
     true,
@@ -61,10 +50,6 @@ test('runScheduledMaintenance continues sweeping the next key when one key throw
 });
 
 test('runScheduledMaintenance keeps subsequent sweeps running when one top-level sweep throws', async () => {
-  // Top-level sweep isolation: a failure in (e.g.) image-cache sweepExpired
-  // must not drop the dump sweep on the same tick. We swap the image cache
-  // for one that throws, then confirm the dump sweep still ran by observing
-  // its side effect.
   const { repo, apiKey: keyA } = await setupAppTest();
   await repo.apiKeys.save({ ...keyA, dumpRetentionSeconds: 3600 });
 
@@ -75,7 +60,25 @@ test('runScheduledMaintenance keeps subsequent sweeps running when one top-level
   const stubs = installDumpStubs(initDumpStore, initDumpBroker);
 
   await runScheduledMaintenance();
-  // The dump sweep ran despite the image-cache failure — the stub recorded
-  // a purgeExpired call for the only retention-enabled key.
   assertEquals(stubs.purgedExpired.some(c => c.keyId === keyA.id), true);
 });
+
+test('runScheduledMaintenance keeps spilled payloads when item-row deletion fails', async () => {
+  const { repo } = await setupAppTest();
+  const files = new MemoryFileProvider();
+  initFileProvider(files);
+  initImageCacheStore(noopImageCache);
+  installDumpStubs(initDumpStore, initDumpBroker);
+  const key = 'responses-items/v1/expires/2000/01/01/00/key/item/payload.gz';
+  await files.put(key, new Uint8Array([1]));
+  const deletion = vi.spyOn(repo.responsesItems, 'deleteOlderThan').mockRejectedValue(new Error('item deletion failed'));
+  const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+  try {
+    await runScheduledMaintenance();
+  } finally {
+    deletion.mockRestore();
+    error.mockRestore();
+  }
+
+  assertEquals(await files.get(key), new Uint8Array([1]));
+});
diff --git a/packages/gateway/src/shared/server-secret.ts b/packages/gateway/src/shared/server-secret.ts
new file mode 100644
index 000000000..e6297d800
--- /dev/null
+++ b/packages/gateway/src/shared/server-secret.ts
@@ -0,0 +1,14 @@
+export const parseServerSecret = (value: unknown, field = 'serverSecret'): string => {
+  if (typeof value !== 'string' || !/^[0-9a-f]{64}$/.test(value)) {
+    throw new TypeError(`${field} must be exactly 64 lowercase hexadecimal characters`);
+  }
+  return value;
+};
+
+export const serverSecretBytes = (value: unknown, field = 'serverSecret'): Uint8Array => {
+  const secret = parseServerSecret(value, field);
+  return Uint8Array.from({ length: 32 }, (_, index) => Number.parseInt(secret.slice(index * 2, index * 2 + 2), 16));
+};
+
+export const generateServerSecret = (): string =>
+  Array.from(crypto.getRandomValues(new Uint8Array(32)), byte => byte.toString(16).padStart(2, '0')).join('');
diff --git a/packages/gateway/src/shared/server-secret_test.ts b/packages/gateway/src/shared/server-secret_test.ts
new file mode 100644
index 000000000..e8a387131
--- /dev/null
+++ b/packages/gateway/src/shared/server-secret_test.ts
@@ -0,0 +1,28 @@
+import { test } from 'vitest';
+
+import { generateServerSecret, parseServerSecret, serverSecretBytes } from './server-secret.ts';
+import { assertEquals, assertThrows } from '@floway-dev/test-utils';
+
+test('generateServerSecret creates independent 32-byte lowercase hexadecimal secrets', () => {
+  const first = generateServerSecret();
+  const second = generateServerSecret();
+  assertEquals(/^[0-9a-f]{64}$/.test(first), true);
+  assertEquals(/^[0-9a-f]{64}$/.test(second), true);
+  assertEquals(first === second, false);
+});
+
+test('parseServerSecret accepts only the canonical serialized form', () => {
+  const secret = 'ab'.repeat(32);
+  assertEquals(parseServerSecret(secret), secret);
+  for (const invalid of [undefined, 'ab'.repeat(31), 'AB'.repeat(32), `${'ab'.repeat(31)}zz`]) {
+    assertThrows(
+      () => parseServerSecret(invalid),
+      Error,
+      'must be exactly 64 lowercase hexadecimal characters',
+    );
+  }
+});
+
+test('serverSecretBytes decodes the canonical hexadecimal representation', () => {
+  assertEquals(serverSecretBytes(`00${'ff'.repeat(31)}`), new Uint8Array([0, ...Array<number>(31).fill(255)]));
+});
diff --git a/packages/gateway/src/test-helpers.ts b/packages/gateway/src/test-helpers.ts
index 03b70cda5..45a78dea3 100644
--- a/packages/gateway/src/test-helpers.ts
+++ b/packages/gateway/src/test-helpers.ts
@@ -141,6 +141,7 @@ export async function setupAppTest(options: SetupOptions = {}): Promise<AppTestC
     userId: 2,
     name: 'Primary key',
     key: `raw_${crypto.randomUUID().replace(/-/g, '')}`,
+    serverSecret: '00'.repeat(32),
     createdAt: '2026-03-15T00:00:00.000Z',
     upstreamIds: null,
     deletedAt: null,
diff --git a/packages/gateway/src/test-helpers/gateway-ctx.ts b/packages/gateway/src/test-helpers/gateway-ctx.ts
index 5c6d995b2..d4b8a7828 100644
--- a/packages/gateway/src/test-helpers/gateway-ctx.ts
+++ b/packages/gateway/src/test-helpers/gateway-ctx.ts
@@ -1,5 +1,8 @@
-import { createNonResponsesSourceStore } from '../data-plane/chat/responses/items/store.ts';
+import { ResponsesAttemptState } from '../data-plane/chat/responses/attempt-state.ts';
+import { createResponsesHttpStore, type StatefulResponsesStore } from '../data-plane/chat/responses/items/store.ts';
+import { AffinityRequestContext } from '../data-plane/chat/shared/affinity/index.ts';
 import type { ChatGatewayCtx, GatewayCtx } from '../data-plane/chat/shared/gateway-ctx.ts';
+import { stubModelCandidate } from '@floway-dev/test-utils';
 
 // Shared minimal GatewayCtx for tests that exercise serve / respond /
 // interceptor code in isolation. Defaults satisfy every required field; pass
@@ -19,14 +22,17 @@ export const mockGatewayCtx = (overrides: Partial<GatewayCtx> = {}): GatewayCtx
   ...overrides,
 });
 
-// Chat-protocol counterpart: adds the stored-items store bound to the
-// resolved apiKeyId (base default or override). Interceptor tests only
-// need the store to exist; overriding `.store` explicitly is supported
-// for tests that inspect its per-turn behaviour.
-export const mockChatGatewayCtx = (overrides: Partial<ChatGatewayCtx> = {}): ChatGatewayCtx => {
+// Chat-protocol counterpart: adds the affinity membrane and request-local
+// Responses invocation state. Tests that exercise durable Responses behavior
+// override `.store` explicitly.
+export const mockChatGatewayCtx = (overrides: Partial<ChatGatewayCtx> = {}): ChatGatewayCtx & { readonly store: StatefulResponsesStore } => {
   const base = mockGatewayCtx(overrides);
+  const affinity = overrides.affinity ?? new AffinityRequestContext('00'.repeat(32));
+  if (overrides.affinity === undefined) affinity.select(stubModelCandidate());
   return {
     ...base,
-    store: overrides.store ?? createNonResponsesSourceStore(base.apiKeyId),
+    affinity,
+    responsesAttemptState: overrides.responsesAttemptState ?? new ResponsesAttemptState(),
+    store: overrides.store ?? createResponsesHttpStore(base.apiKeyId, false),
   };
 };
diff --git a/packages/gateway/src/test-sqljs.d.ts b/packages/gateway/src/test-sqljs.d.ts
index 586a47843..d0fdd2870 100644
--- a/packages/gateway/src/test-sqljs.d.ts
+++ b/packages/gateway/src/test-sqljs.d.ts
@@ -1,7 +1,7 @@
 declare module 'sql.js' {
   export interface SqlJsDatabase {
-    run(sql: string): void;
-    exec(sql: string): Array<{ columns: string[]; values: unknown[][] }>;
+    run(sql: string, params?: unknown[]): void;
+    exec(sql: string, params?: unknown[]): Array<{ columns: string[]; values: unknown[][] }>;
     close(): void;
   }
 
diff --git a/packages/protocols/src/chat-completions/reassemble.ts b/packages/protocols/src/chat-completions/reassemble.ts
index d4bfe2267..83d65ce04 100644
--- a/packages/protocols/src/chat-completions/reassemble.ts
+++ b/packages/protocols/src/chat-completions/reassemble.ts
@@ -1,168 +1,138 @@
 import { chatCompletionsErrorPayloadMessage } from './index.ts';
-import type { ChatCompletionsStreamEvent, ChatCompletionsResult, ChatCompletionsReasoningItem, ChatCompletionsToolCall } from './index.ts';
+import type { ChatCompletionsChoiceNonStreaming, ChatCompletionsDelta, ChatCompletionsResult, ChatCompletionsStreamEvent, ChatCompletionsReasoningItem, ChatCompletionsToolCall } from './index.ts';
 import { captureExtras } from '../common/reassemble-extras.ts';
 
-// Field-fidelity contract: every field a Chat Completions upstream emits must
-// reach the non-streaming client untouched. The stream path achieves this for
-// free (`to-sse.ts` re-serialises each chunk via `JSON.stringify`), but
-// non-streaming clients receive a single result object reassembled here, so
-// any field this code does not explicitly carry over disappears.
-//
-// We split fields into two buckets:
-//  - "known" fields with streaming semantics (string concat, array merge by
-//    index) — handled by the typed accumulators below.
-//  - everything else — captured generically via {@link captureExtras} and
-//    replayed onto the assembled result.
-//
-// `reasoning_content` (the DeepSeek/Kimi dialect for reasoning text on Chat
-// Completions) is the concrete case that motivated the extras path; the goal
-// is that any future field — `audio_prompt_tokens`, `prompt_filter_results`,
-// `this_is_a_non_standard_field_of_reasoning` — survives by default without a
-// gateway code change.
-//
-// Stable scalar strings that the upstream repeats unchanged on every chunk —
-// OpenAI's `system_fingerprint` and `service_tier` are the canonical examples
-// — MUST be registered as known keys; otherwise the generic extras path
-// concatenates them into a duplicated mess (`fp_xfp_xfp_x…`).
-
+// Field-fidelity contract: every field an upstream emits must reach the
+// non-streaming result. Known streaming fields use their protocol semantics;
+// unknown fields fall through to captureExtras so future extensions survive.
 const KNOWN_DELTA_KEYS = new Set(['content', 'role', 'reasoning_text', 'reasoning_opaque', 'reasoning_items', 'tool_calls']);
 const KNOWN_CHOICE_KEYS = new Set(['index', 'delta', 'finish_reason']);
 const KNOWN_CHUNK_KEYS = new Set(['id', 'object', 'created', 'model', 'choices', 'usage', 'system_fingerprint', 'service_tier']);
 
+interface ToolCallAccumulator {
+  id: string;
+  name: string;
+  arguments: string;
+}
+
+interface ChoiceAccumulator {
+  readonly index: number;
+  content: string;
+  reasoningText: string;
+  reasoningOpaque?: string;
+  readonly reasoningItems: ChatCompletionsReasoningItem[];
+  finishReason: ChatCompletionsChoiceNonStreaming['finish_reason'];
+  readonly toolCalls: Map<number, ToolCallAccumulator>;
+  readonly choiceExtras: Record<string, unknown>;
+  readonly messageExtras: Record<string, unknown>;
+}
+
+const createChoiceAccumulator = (index: number): ChoiceAccumulator => ({
+  index,
+  content: '',
+  reasoningText: '',
+  reasoningItems: [],
+  finishReason: 'stop',
+  toolCalls: new Map(),
+  choiceExtras: {},
+  messageExtras: {},
+});
+
+const accumulateToolCalls = (choice: ChoiceAccumulator, value: ChatCompletionsDelta['tool_calls']): void => {
+  if (value === undefined) return;
+
+  for (const toolCall of value) {
+    const fn = toolCall.function;
+    const current = choice.toolCalls.get(toolCall.index) ?? { id: '', name: '', arguments: '' };
+    if (toolCall.id !== undefined) current.id = toolCall.id;
+    if (fn?.name !== undefined) current.name = fn.name;
+    if (fn?.arguments !== undefined) current.arguments += fn.arguments;
+    choice.toolCalls.set(toolCall.index, current);
+  }
+};
+
+const finalizedToolCalls = (choice: ChoiceAccumulator): ChatCompletionsToolCall[] =>
+  [...choice.toolCalls.entries()]
+    .toSorted(([left], [right]) => left - right)
+    .map(([, toolCall]) => ({
+      id: toolCall.id,
+      type: 'function',
+      function: { name: toolCall.name, arguments: toolCall.arguments },
+    }));
+
+const finalizeChoice = (choice: ChoiceAccumulator): ChatCompletionsChoiceNonStreaming => {
+  const toolCalls = finalizedToolCalls(choice);
+  return {
+    index: choice.index,
+    message: {
+      role: 'assistant',
+      content: choice.content || null,
+      ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+      ...(choice.reasoningText ? { reasoning_text: choice.reasoningText } : {}),
+      ...(choice.reasoningOpaque !== undefined ? { reasoning_opaque: choice.reasoningOpaque } : {}),
+      ...(choice.reasoningItems.length > 0 ? { reasoning_items: choice.reasoningItems } : {}),
+      ...choice.messageExtras,
+    },
+    finish_reason: choice.finishReason,
+    ...choice.choiceExtras,
+  } as ChatCompletionsChoiceNonStreaming;
+};
+
 export async function reassembleChatCompletionsEvents(chunks: AsyncIterable<ChatCompletionsStreamEvent>): Promise<ChatCompletionsResult> {
   let id = '';
   let model = '';
   let created = 0;
   let systemFingerprint: string | undefined;
   let serviceTier: ChatCompletionsResult['service_tier'];
-  let content = '';
-  let reasoningText = '';
-  let reasoningOpaque = '';
-  let hasReasoningOpaque = false;
-  const reasoningItems: ChatCompletionsReasoningItem[] = [];
-  let finishReason: ChatCompletionsResult['choices'][number]['finish_reason'] = 'stop';
   let lastUsage: ChatCompletionsResult['usage'] | undefined;
-
-  const toolCallsMap = new Map<number, { id: string; name: string; arguments: string }>();
-
+  const choices = new Map<number, ChoiceAccumulator>();
   const chunkExtras: Record<string, unknown> = {};
-  const choiceExtras: Record<string, unknown> = {};
-  const messageExtras: Record<string, unknown> = {};
 
   for await (const chunk of chunks) {
     const errorMessage = chatCompletionsErrorPayloadMessage(chunk);
-    if (errorMessage) {
-      throw new Error(`Upstream Chat Completions SSE error: ${errorMessage}`);
-    }
+    if (errorMessage) throw new Error(`Upstream Chat Completions SSE error: ${errorMessage}`);
 
     if (!id && chunk.id) {
-      id = chunk.id as string;
-      model = chunk.model as string;
-      created = chunk.created as number;
+      id = chunk.id;
+      model = chunk.model;
+      created = chunk.created;
     }
-
     if (!systemFingerprint && typeof chunk.system_fingerprint === 'string' && chunk.system_fingerprint) {
       systemFingerprint = chunk.system_fingerprint;
     }
     if (!serviceTier && typeof chunk.service_tier === 'string' && chunk.service_tier) {
       serviceTier = chunk.service_tier;
     }
-
-    if (chunk.usage) {
-      lastUsage = chunk.usage as ChatCompletionsResult['usage'];
-    }
-
+    if (chunk.usage) lastUsage = chunk.usage;
     captureExtras(chunk as unknown as Record<string, unknown>, KNOWN_CHUNK_KEYS, chunkExtras);
 
-    const choices = chunk.choices as unknown as Array<Record<string, unknown>> | undefined;
-    if (!choices) continue;
-
-    for (const choice of choices) {
-      captureExtras(choice, KNOWN_CHOICE_KEYS, choiceExtras);
-
-      const delta = choice.delta as Record<string, unknown> | undefined;
-      if (delta) {
-        captureExtras(delta, KNOWN_DELTA_KEYS, messageExtras);
-
-        if (typeof delta.content === 'string') {
-          content += delta.content;
-        }
-        if (typeof delta.reasoning_text === 'string') {
-          reasoningText += delta.reasoning_text;
-        }
-        if (typeof delta.reasoning_opaque === 'string') {
-          reasoningOpaque += delta.reasoning_opaque;
-          hasReasoningOpaque = true;
-        }
-        if (Array.isArray(delta.reasoning_items)) {
-          reasoningItems.push(...(delta.reasoning_items as ChatCompletionsReasoningItem[]));
-        }
-
-        if (Array.isArray(delta.tool_calls)) {
-          for (const toolCall of delta.tool_calls as Array<Record<string, unknown>>) {
-            const idx = toolCall.index as number;
-            const existing = toolCallsMap.get(idx);
-            if (!existing) {
-              toolCallsMap.set(idx, {
-                id: (toolCall.id as string) ?? '',
-                name: ((toolCall.function as Record<string, unknown>)?.name as string) ?? '',
-                arguments: ((toolCall.function as Record<string, unknown>)?.arguments as string) ?? '',
-              });
-            } else {
-              if (toolCall.id) existing.id = toolCall.id as string;
-              const fn = toolCall.function as Record<string, unknown> | undefined;
-              if (fn?.name) existing.name = fn.name as string;
-              if (fn?.arguments) {
-                existing.arguments += fn.arguments as string;
-              }
-            }
-          }
-        }
-      }
-
-      if (choice.finish_reason) {
-        finishReason = choice.finish_reason as ChatCompletionsResult['choices'][number]['finish_reason'];
+    for (const streamed of chunk.choices) {
+      const choice = choices.get(streamed.index) ?? createChoiceAccumulator(streamed.index);
+      choices.set(streamed.index, choice);
+      captureExtras(streamed as unknown as Record<string, unknown>, KNOWN_CHOICE_KEYS, choice.choiceExtras);
+
+      const delta = streamed.delta;
+      captureExtras(delta as unknown as Record<string, unknown>, KNOWN_DELTA_KEYS, choice.messageExtras);
+      if (typeof delta.content === 'string') choice.content += delta.content;
+      if (typeof delta.reasoning_text === 'string') choice.reasoningText += delta.reasoning_text;
+      if (typeof delta.reasoning_opaque === 'string') choice.reasoningOpaque = delta.reasoning_opaque;
+      if (Array.isArray(delta.reasoning_items)) {
+        choice.reasoningItems.push(...delta.reasoning_items);
       }
+      accumulateToolCalls(choice, delta.tool_calls);
+      if (streamed.finish_reason !== null) choice.finishReason = streamed.finish_reason;
     }
   }
 
-  const toolCalls: ChatCompletionsToolCall[] = [];
-  const sortedIndices = [...toolCallsMap.keys()].sort((a, b) => a - b);
-  for (const idx of sortedIndices) {
-    const toolCall = toolCallsMap.get(idx)!;
-    toolCalls.push({
-      id: toolCall.id,
-      type: 'function',
-      function: { name: toolCall.name, arguments: toolCall.arguments },
-    });
-  }
-
-  const message = {
-    role: 'assistant' as const,
-    content: content || null,
-    ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
-    ...(reasoningText && { reasoning_text: reasoningText }),
-    ...(hasReasoningOpaque ? { reasoning_opaque: reasoningOpaque } : {}),
-    ...(reasoningItems.length > 0 && { reasoning_items: reasoningItems }),
-    ...messageExtras,
-  };
-
   return {
     id,
     object: 'chat.completion',
     created,
     model,
-    choices: [
-      {
-        index: 0,
-        message,
-        finish_reason: finishReason,
-        ...choiceExtras,
-      },
-    ],
-    ...(systemFingerprint && { system_fingerprint: systemFingerprint }),
-    ...(serviceTier && { service_tier: serviceTier }),
-    ...(lastUsage && { usage: lastUsage }),
+    choices: [...choices.values()].toSorted((left, right) => left.index - right.index).map(finalizeChoice),
+    ...(systemFingerprint ? { system_fingerprint: systemFingerprint } : {}),
+    ...(serviceTier ? { service_tier: serviceTier } : {}),
+    ...(lastUsage ? { usage: lastUsage } : {}),
     ...chunkExtras,
   } as ChatCompletionsResult;
 }
diff --git a/packages/protocols/src/chat-completions/reassemble_test.ts b/packages/protocols/src/chat-completions/reassemble_test.ts
index 63ab06386..9799fea6a 100644
--- a/packages/protocols/src/chat-completions/reassemble_test.ts
+++ b/packages/protocols/src/chat-completions/reassemble_test.ts
@@ -141,7 +141,7 @@ test('reassembleChatCompletionsEvents reassembles tool calls', async () => {
   assertEquals(result.choices[0].message.tool_calls![0].function.arguments, '{"city":"Tokyo"}');
 });
 
-test('reassembleChatCompletionsEvents reassembles reasoning fields', async () => {
+test('reassembleChatCompletionsEvents concatenates reasoning text and keeps the latest opaque snapshot', async () => {
   const body = makeEvents([
     {
       data: {
@@ -155,7 +155,7 @@ test('reassembleChatCompletionsEvents reassembles reasoning fields', async () =>
             delta: {
               role: 'assistant',
               reasoning_text: 'think',
-              reasoning_opaque: 'enc',
+              reasoning_opaque: 'enc_old',
             },
             finish_reason: null,
           },
@@ -171,7 +171,7 @@ test('reassembleChatCompletionsEvents reassembles reasoning fields', async () =>
         choices: [
           {
             index: 0,
-            delta: { content: 'reply' },
+            delta: { content: 'reply', reasoning_text: ' more', reasoning_opaque: 'enc' },
             finish_reason: 'stop',
           },
         ],
@@ -182,11 +182,108 @@ test('reassembleChatCompletionsEvents reassembles reasoning fields', async () =>
 
   const result = await reassembleChatCompletionsEvents(body);
 
-  assertEquals(result.choices[0].message.reasoning_text, 'think');
+  assertEquals(result.choices[0].message.reasoning_text, 'think more');
   assertEquals(result.choices[0].message.reasoning_opaque, 'enc');
   assertEquals(result.choices[0].message.content, 'reply');
 });
 
+test('reassembleChatCompletionsEvents maintains independent state for every choice index', async () => {
+  const body = makeEvents([
+    {
+      data: {
+        id: 'cmpl_many',
+        object: 'chat.completion.chunk',
+        created: 4000,
+        model: 'gpt-many',
+        choices: [
+          {
+            index: 1,
+            delta: {
+              role: 'assistant',
+              content: 'second ',
+              reasoning_opaque: 'second-old',
+              vendor_trace: 'b1',
+              tool_calls: [{ index: 0, id: 'call_b', type: 'function', function: { name: 'beta', arguments: '{"b"' } }],
+            },
+            finish_reason: null,
+            content_filter_results: { hate: { filtered: false } },
+          },
+          {
+            index: 0,
+            delta: {
+              role: 'assistant',
+              content: 'first ',
+              reasoning_text: 'think ',
+              reasoning_opaque: 'first-old',
+              vendor_trace: 'a1',
+              reasoning_items: [{ type: 'reasoning', id: 'rs_a', summary: [] }],
+              tool_calls: [{ index: 1, id: 'call_a', type: 'function', function: { name: 'alpha', arguments: '{"a"' } }],
+            },
+            finish_reason: null,
+            content_filter_results: { sexual: { filtered: false } },
+          },
+        ],
+      },
+    },
+    {
+      data: {
+        id: 'cmpl_many',
+        object: 'chat.completion.chunk',
+        created: 4000,
+        model: 'gpt-many',
+        choices: [
+          {
+            index: 0,
+            delta: {
+              content: 'answer',
+              reasoning_text: 'again',
+              reasoning_opaque: 'first-final',
+              vendor_trace: 'a2',
+              tool_calls: [{ index: 1, function: { arguments: ':1}' } }],
+            },
+            finish_reason: 'tool_calls',
+          },
+          {
+            index: 1,
+            delta: {
+              content: 'answer',
+              reasoning_opaque: 'second-final',
+              vendor_trace: 'b2',
+              tool_calls: [{ index: 0, function: { arguments: ':2}' } }],
+            },
+            finish_reason: 'stop',
+          },
+        ],
+        usage: { prompt_tokens: 20, completion_tokens: 8, total_tokens: 28 },
+      },
+    },
+  ]);
+
+  const result = await reassembleChatCompletionsEvents(body) as ChatCompletionsResult & {
+    choices: Array<ChatCompletionsResult['choices'][number] & {
+      content_filter_results?: unknown;
+      message: ChatCompletionsResult['choices'][number]['message'] & { vendor_trace?: string };
+    }>;
+  };
+
+  assertEquals(result.choices.map(choice => choice.index), [0, 1]);
+  assertEquals(result.choices[0].message.content, 'first answer');
+  assertEquals(result.choices[0].message.reasoning_text, 'think again');
+  assertEquals(result.choices[0].message.reasoning_opaque, 'first-final');
+  assertEquals(result.choices[0].message.reasoning_items, [{ type: 'reasoning', id: 'rs_a', summary: [] }]);
+  assertEquals(result.choices[0].message.tool_calls, [{ id: 'call_a', type: 'function', function: { name: 'alpha', arguments: '{"a":1}' } }]);
+  assertEquals(result.choices[0].message.vendor_trace, 'a1a2');
+  assertEquals(result.choices[0].content_filter_results, { sexual: { filtered: false } });
+  assertEquals(result.choices[0].finish_reason, 'tool_calls');
+  assertEquals(result.choices[1].message.content, 'second answer');
+  assertEquals(result.choices[1].message.reasoning_opaque, 'second-final');
+  assertEquals(result.choices[1].message.tool_calls, [{ id: 'call_b', type: 'function', function: { name: 'beta', arguments: '{"b":2}' } }]);
+  assertEquals(result.choices[1].message.vendor_trace, 'b1b2');
+  assertEquals(result.choices[1].content_filter_results, { hate: { filtered: false } });
+  assertEquals(result.choices[1].finish_reason, 'stop');
+  assertEquals(result.usage, { prompt_tokens: 20, completion_tokens: 8, total_tokens: 28 });
+});
+
 test('reassembleChatCompletionsEvents appends reasoning_items deltas in order', async () => {
   const body = makeEvents([
     {
diff --git a/packages/protocols/src/messages/reassemble.ts b/packages/protocols/src/messages/reassemble.ts
index 05f0449d4..d4c6740c9 100644
--- a/packages/protocols/src/messages/reassemble.ts
+++ b/packages/protocols/src/messages/reassemble.ts
@@ -177,7 +177,7 @@ const applyBlockDelta = (block: MessagesBlockAccumulator | undefined, event: Ext
     return;
   case 'signature_delta':
     if (block.type !== 'thinking') return;
-    block.signature = `${block.signature ?? ''}${event.delta.signature ?? ''}`;
+    block.signature = event.delta.signature;
     return;
   }
 };
diff --git a/packages/protocols/src/messages/reassemble_test.ts b/packages/protocols/src/messages/reassemble_test.ts
index a1360e11f..82998038c 100644
--- a/packages/protocols/src/messages/reassemble_test.ts
+++ b/packages/protocols/src/messages/reassemble_test.ts
@@ -340,6 +340,14 @@ test('reassembleMessagesEvents reassembles thinking blocks', async () => {
         delta: { type: 'thinking_delta', thinking: 'let me think' },
       },
     },
+    {
+      event: 'content_block_delta',
+      data: {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'signature_delta', signature: 'sig_old' },
+      },
+    },
     {
       event: 'content_block_delta',
       data: {
diff --git a/packages/translate/src/gemini-via-chat-completions/events.ts b/packages/translate/src/gemini-via-chat-completions/events.ts
index 478b916d1..08cae52e1 100644
--- a/packages/translate/src/gemini-via-chat-completions/events.ts
+++ b/packages/translate/src/gemini-via-chat-completions/events.ts
@@ -1,4 +1,4 @@
-import { appendGeminiThoughtSignature, flushGeminiThoughtSignature, type GeminiThoughtSignatureState, parseStrictJsonObject, signGeminiPart } from '../shared/gemini-via/gemini.ts';
+import { flushGeminiThoughtSignature, type GeminiThoughtSignatureState, parseStrictJsonObject, setGeminiThoughtSignature, signGeminiPart } from '../shared/gemini-via/gemini.ts';
 import { chatCompletionsErrorPayloadMessage } from '@floway-dev/protocols/chat-completions';
 import type { ChatCompletionsStreamEvent, ChatCompletionsDelta } from '@floway-dev/protocols/chat-completions';
 import { billableServiceTier, eventFrame, splitCacheWriteTokens, splitInclusiveInputTokens, splitInclusiveOutputTokens, USAGE_BILLING, type ProtocolFrame } from '@floway-dev/protocols/common';
@@ -137,7 +137,7 @@ const buildCandidate = (choice: ChatCompletionsStreamChoice, state: ChatCompleti
   }
 
   if (typeof delta.reasoning_opaque === 'string') {
-    appendGeminiThoughtSignature(state, delta.reasoning_opaque);
+    setGeminiThoughtSignature(state, delta.reasoning_opaque);
   }
 
   if (typeof delta.content === 'string') {
diff --git a/packages/translate/src/gemini-via-chat-completions/events_test.ts b/packages/translate/src/gemini-via-chat-completions/events_test.ts
index d30d09f11..372bce1ef 100644
--- a/packages/translate/src/gemini-via-chat-completions/events_test.ts
+++ b/packages/translate/src/gemini-via-chat-completions/events_test.ts
@@ -74,6 +74,7 @@ test('translateToSourceEvents maps text chunks and stop finish without emitting
 test('translateToSourceEvents maps reasoning text and attaches opaque signature to next action', async () => {
   const frames = await collect([
     eventFrame(chunk({ role: 'assistant', reasoning_text: 'trace' })),
+    eventFrame(chunk({ reasoning_opaque: 'sig_old' })),
     eventFrame(chunk({ reasoning_opaque: 'sig_1' })),
     eventFrame(chunk({ content: 'answer' })),
     eventFrame(chunk({}, 'stop')),
diff --git a/packages/translate/src/gemini-via-chat-completions/request.ts b/packages/translate/src/gemini-via-chat-completions/request.ts
index 4a21a0d08..628c1b6e0 100644
--- a/packages/translate/src/gemini-via-chat-completions/request.ts
+++ b/packages/translate/src/gemini-via-chat-completions/request.ts
@@ -16,7 +16,7 @@ import { TranslatorInputError } from '../translator-input-error.ts';
 import type { ChatCompletionsPayload, ChatCompletionsContentPart, ChatCompletionsMessage, ChatCompletionsTool, ChatCompletionsToolCall } from '@floway-dev/protocols/chat-completions';
 import type { GeminiContent, GeminiPayload, GeminiGenerationConfig, GeminiPart } from '@floway-dev/protocols/gemini';
 
-const appendOpaque = (current: string | null, signature?: string): string | null => (typeof signature === 'string' ? `${current ?? ''}${signature}` : current);
+const latestOpaque = (current: string | null, signature?: string): string | null => (typeof signature === 'string' ? signature : current);
 
 const inlineDataToContentPart = (part: GeminiPart): ChatCompletionsContentPart | null => {
   const url = geminiInlineDataUrl(part);
@@ -56,7 +56,7 @@ const buildAssistantMessage = (content: GeminiContent, turnIndex: number, unmatc
   let reasoningOpaque: string | null = null;
 
   content.parts.forEach((part, partIndex) => {
-    reasoningOpaque = appendOpaque(reasoningOpaque, part.thoughtSignature);
+    reasoningOpaque = latestOpaque(reasoningOpaque, part.thoughtSignature);
 
     const kind = geminiPartKind(part);
     switch (kind) {
diff --git a/packages/translate/src/gemini-via-chat-completions/request_test.ts b/packages/translate/src/gemini-via-chat-completions/request_test.ts
index 5be6ab7af..1745dffe8 100644
--- a/packages/translate/src/gemini-via-chat-completions/request_test.ts
+++ b/packages/translate/src/gemini-via-chat-completions/request_test.ts
@@ -57,7 +57,7 @@ test('buildTargetRequest maps function calls, tool responses, and reasoning hist
     contents: [
       {
         role: 'model',
-        parts: [{ text: 'private trace', thought: true, thoughtSignature: 'sig_1' }, { text: 'I will call a tool.' }, { functionCall: { name: 'lookup', args: { query: 'docs' } } }],
+        parts: [{ text: 'private trace', thought: true, thoughtSignature: 'sig_old' }, { text: 'I will call a tool.', thoughtSignature: 'sig_1' }, { functionCall: { name: 'lookup', args: { query: 'docs' } } }],
       },
       {
         role: 'user',
diff --git a/packages/translate/src/gemini-via-messages/events.ts b/packages/translate/src/gemini-via-messages/events.ts
index 8e233099a..9ff8792f4 100644
--- a/packages/translate/src/gemini-via-messages/events.ts
+++ b/packages/translate/src/gemini-via-messages/events.ts
@@ -1,4 +1,4 @@
-import { appendGeminiThoughtSignature, flushGeminiThoughtSignature, type GeminiThoughtSignatureState, geminiCandidateEvent, parseStrictJsonObject, signGeminiPart } from '../shared/gemini-via/gemini.ts';
+import { flushGeminiThoughtSignature, type GeminiThoughtSignatureState, geminiCandidateEvent, parseStrictJsonObject, setGeminiThoughtSignature, signGeminiPart } from '../shared/gemini-via/gemini.ts';
 import { billableServiceTier, eventFrame, splitInclusiveInputTokens, USAGE_BILLING, type ProtocolFrame } from '@floway-dev/protocols/common';
 import type { GeminiFinishReason, GeminiStreamEvent, GeminiUsageMetadata } from '@floway-dev/protocols/gemini';
 import { mergeMessagesUsageSnapshot, messagesUsageSnapshot, splitMessagesCacheCreationTokens, type MessagesStreamEvent, type MessagesUsageSnapshot } from '@floway-dev/protocols/messages';
@@ -108,7 +108,7 @@ export const translateToSourceEvents = async function* (frames: AsyncIterable<Pr
       }
 
       if (event.content_block.type === 'redacted_thinking') {
-        appendGeminiThoughtSignature(state, event.content_block.data);
+        setGeminiThoughtSignature(state, event.content_block.data);
         break;
       }
 
@@ -137,7 +137,7 @@ export const translateToSourceEvents = async function* (frames: AsyncIterable<Pr
         }
         break;
       case 'signature_delta':
-        appendGeminiThoughtSignature(state, event.delta.signature);
+        setGeminiThoughtSignature(state, event.delta.signature);
         break;
       case 'text_delta':
         if (event.delta.text.length > 0) {
diff --git a/packages/translate/src/gemini-via-messages/events_test.ts b/packages/translate/src/gemini-via-messages/events_test.ts
index bd50de297..64af3f018 100644
--- a/packages/translate/src/gemini-via-messages/events_test.ts
+++ b/packages/translate/src/gemini-via-messages/events_test.ts
@@ -121,6 +121,11 @@ test('translateToSourceEvents maps thinking text and attaches signature to the n
       index: 0,
       delta: { type: 'thinking_delta', thinking: 'trace' },
     }),
+    eventFrame({
+      type: 'content_block_delta',
+      index: 0,
+      delta: { type: 'signature_delta', signature: 'sig_old' },
+    }),
     eventFrame({
       type: 'content_block_delta',
       index: 0,
diff --git a/packages/translate/src/messages-via-chat-completions/events.ts b/packages/translate/src/messages-via-chat-completions/events.ts
index 775b0fede..2e54d5926 100644
--- a/packages/translate/src/messages-via-chat-completions/events.ts
+++ b/packages/translate/src/messages-via-chat-completions/events.ts
@@ -143,7 +143,7 @@ const attachOpaqueToOpenThinkingBlock = (state: ChatCompletionsToMessagesStreamS
     return false;
   }
 
-  state.pendingThinkingSignature = (state.pendingThinkingSignature ?? '') + state.pendingReasoningOpaque;
+  state.pendingThinkingSignature = state.pendingReasoningOpaque;
   state.pendingReasoningOpaque = undefined;
   return true;
 };
@@ -232,12 +232,12 @@ const handleReasoningDelta = (delta: ChatCompletionsStreamDelta, state: ChatComp
   }
 
   if (state.openBlock === 'thinking') {
-    state.pendingThinkingSignature = (state.pendingThinkingSignature ?? '') + delta.reasoning_opaque;
+    state.pendingThinkingSignature = delta.reasoning_opaque;
     emitPendingReasoningAndDeferred(state, events);
     return;
   }
 
-  state.pendingReasoningOpaque = (state.pendingReasoningOpaque ?? '') + delta.reasoning_opaque;
+  state.pendingReasoningOpaque = delta.reasoning_opaque;
 };
 
 const emitToolCallsDelta = (toolCalls: ChatCompletionsStreamToolCalls, state: ChatCompletionsToMessagesStreamState, events: MessagesStreamEvent[]): void => {
diff --git a/packages/translate/src/messages-via-chat-completions/events_test.ts b/packages/translate/src/messages-via-chat-completions/events_test.ts
index c90d946d9..785ec93a6 100644
--- a/packages/translate/src/messages-via-chat-completions/events_test.ts
+++ b/packages/translate/src/messages-via-chat-completions/events_test.ts
@@ -28,7 +28,8 @@ const usageChunk = (): ChatCompletionsStreamEvent => ({
 test('translateChatCompletionsChunkToMessagesEvents emits opaque-only reasoning as redacted_thinking at finish', () => {
   const state = createChatCompletionsToMessagesStreamState();
   const events = [
-    ...translateChatCompletionsChunkToMessagesEvents(chunk({ role: 'assistant', reasoning_opaque: 'enc_only' }), state),
+    ...translateChatCompletionsChunkToMessagesEvents(chunk({ role: 'assistant', reasoning_opaque: 'enc_old' }), state),
+    ...translateChatCompletionsChunkToMessagesEvents(chunk({ reasoning_opaque: 'enc_only' }), state),
     ...translateChatCompletionsChunkToMessagesEvents(chunk({}, 'stop'), state),
   ];
 
@@ -131,8 +132,9 @@ test('translateChatCompletionsChunkToMessagesEvents keeps text and opaque in one
 test('translateChatCompletionsChunkToMessagesEvents emits early opaque after later thinking text', () => {
   const state = createChatCompletionsToMessagesStreamState();
   const events = [
-    ...translateChatCompletionsChunkToMessagesEvents(chunk({ role: 'assistant', reasoning_opaque: 'sig' }), state),
+    ...translateChatCompletionsChunkToMessagesEvents(chunk({ role: 'assistant', reasoning_opaque: 'old' }), state),
     ...translateChatCompletionsChunkToMessagesEvents(chunk({ reasoning_text: 'trace' }), state),
+    ...translateChatCompletionsChunkToMessagesEvents(chunk({ reasoning_opaque: 'sig' }), state),
     ...translateChatCompletionsChunkToMessagesEvents(chunk({}, 'stop'), state),
   ];
 
diff --git a/packages/translate/src/shared/gemini-via/gemini.ts b/packages/translate/src/shared/gemini-via/gemini.ts
index 0ff026a62..3cb8819e5 100644
--- a/packages/translate/src/shared/gemini-via/gemini.ts
+++ b/packages/translate/src/shared/gemini-via/gemini.ts
@@ -185,8 +185,8 @@ export interface GeminiThoughtSignatureState {
   pendingThoughtSignature?: string;
 }
 
-export const appendGeminiThoughtSignature = (state: GeminiThoughtSignatureState, signature: string): void => {
-  state.pendingThoughtSignature = `${state.pendingThoughtSignature ?? ''}${signature}`;
+export const setGeminiThoughtSignature = (state: GeminiThoughtSignatureState, signature: string): void => {
+  state.pendingThoughtSignature = signature;
 };
 
 export const signGeminiPart = (state: GeminiThoughtSignatureState, part: GeminiPart): GeminiPart => {