mixdog 0.9.145 → 0.9.147

package/src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -330,36 +330,34 @@ function _warmupContinuityTrace({
  * The request body may carry retained `reasoning` items
  * (opts.replayEncryptedReasoning; default ON for openai-oauth, kill switch
  * MIXDOG_OAI_DISABLE_REASONING_REPLAY=1).
- * Whether they actually go on the wire is decided PER SOCKET ENTRY, once, at
- * the first frame that entry sends, and stays sticky for its lifetime so the
- * append-only prefix bookkeeping (entry.lastRequestInput) never mixes
- * conventions:
  *
- *  - fresh entry + reasoning items present  → mid-session reconnect/recovery:
- *    KEEP them. This is the codex behavior on a broken delta chain — the full
- *    frame replays retained reasoning so the model does not re-reason the
- *    whole transcript (client.rs full-request path).
- *  - fresh entry + no reasoning items       → virgin session: nothing to
- *    replay; the chain locks to today's wire (subsequent frames strip).
- *  - entry with prior chain state (pooled reuse / completed warmup) → STRIP:
- *    re-sending an rs_* item a live server chain already saw is rejected as a
- *    duplicate.
+ * They stay in the LOGICAL request history, always. The reference client never
+ * removes reasoning from the history it chains on: its incremental-request
+ * check proves the new request extends the exact previous request + response,
+ * and only THEN does the delta builder drop those already-anchored items from
+ * the wire tail. An rs_* item is therefore never sent twice on a live chain,
+ * while a full frame — which carries no previous_response_id — still replays
+ * retained reasoning instead of making the model re-reason the transcript.
  *
- * `suppress` (rejection safety net) forces the strip convention for the rest
- * of the send. Returns the body unchanged when nothing needs stripping.
+ * Removing reasoning HERE, before the delta computation, broke that proof: the
+ * previous response's reasoning could no longer be matched against the request
+ * prefix, so every reasoning-model session fell back to full frames from its
+ * second call onward and lost previous_response_id with it.
+ *
+ * `suppress` is the rejection safety net only. Once the server rejects a
+ * replayed rs_* item as a duplicate, the retry drops reasoning for the rest of
+ * the send and the chain degrades to full frames, exactly as any broken chain
+ * does.
  */
 export function _applyReasoningReplayPolicy(entry, body, { suppress = false } = {}) {
     const input = Array.isArray(body?.input) ? body.input : null;
     if (!entry || !input) return body;
-    const hasReasoning = input.some((item) => item?.type === 'reasoning');
-    if (suppress) {
-        entry.replayReasoning = false;
-    } else if (entry.replayReasoning == null) {
-        entry.replayReasoning = hasReasoning
-            && entry.lastResponseId == null
-            && entry.lastRequestInput == null;
+    if (!suppress) {
+        entry.replayReasoning = true;
+        return body;
     }
-    if (!hasReasoning || entry.replayReasoning === true) return body;
+    entry.replayReasoning = false;
+    if (!input.some((item) => item?.type === 'reasoning')) return body;
     return { ...body, input: input.filter((item) => item?.type !== 'reasoning') };
 }
 
@@ -575,7 +573,16 @@ export async function sendViaWebSocket({
     // this carry-forward would not help and is therefore gated to xAI.
     let carryForwardCache = null;
     const useCodexWsClientMetadata = traceProvider === 'openai-oauth';
-    const codexMetadataContext = { poolKey, cacheKey, sendOpts };
+    // model + serviceTier feed the handshake routing hint. service_tier is on
+    // the body only when fast selected the priority tier, so the hint carries
+    // `model=` alone otherwise — the same shape the reference client sends.
+    const codexMetadataContext = {
+        poolKey,
+        cacheKey,
+        sendOpts,
+        model: useModel,
+        serviceTier: body?.service_tier || '',
+    };
     const codexHandshakeHeaders = useCodexWsClientMetadata
         ? _codexWsCompatibilityHeaders({ ...codexMetadataContext, handshake: true })
         : null;
@@ -853,10 +860,11 @@ export async function sendViaWebSocket({
                 // Codex startup prewarm contains stable instructions/tools but
                 // no live user/transcript input. Enforce that at the transport
                 // boundary as well as in the OAuth caller so a future caller
-                // cannot accidentally duplicate the transcript. WS-only fields
-                // are omitted exactly as in Codex's prewarm request.
+                // cannot accidentally duplicate the transcript. Keep the same
+                // request properties as the real turn; Codex changes only the
+                // input tail and adds generate:false.
                 const parityWarmupBody = { ...warmupBody, input: [], generate: false };
-                const warmupFrame = _buildResponseCreateFrame(parityWarmupBody, { omitTransportFields: true });
+                const warmupFrame = _buildResponseCreateFrame(parityWarmupBody);
                 const warmupMetadataContext = {
                     ...codexMetadataContext,
                     sendOpts: {
@@ -964,9 +972,28 @@ export async function sendViaWebSocket({
             // current call's header is identical and its first N input items
             // equal the previous call's N items (append-only history).
             try {
-                const { client_metadata: _cm, input: frameInput, ...frameHeader } = frame;
+                // previous_response_id is the per-call anchor: it changes on
+                // every delta frame by design, so including it made
+                // prev_match structurally false for the entire delta path and
+                // the probe could never report what it was built to report —
+                // whether OUR request prefix stayed stable across calls.
+                const {
+                    client_metadata: _cm,
+                    input: frameInput,
+                    previous_response_id: _prevAnchor,
+                    ...frameHeader
+                } = frame;
                 const headerHash = _hashText(JSON.stringify(frameHeader), 16);
-                const itemHashes = (Array.isArray(frameInput) ? frameInput : [])
+                // A delta frame carries only the tail, so hashing frame.input
+                // compares [C] against [A,B] and prev_match can never hold on
+                // the delta path. The question the probe exists to answer is
+                // whether the LOGICAL conversation stayed append-only, so hash
+                // the full request body input and fall back to the frame only
+                // when the body is unavailable.
+                const logicalInput = Array.isArray(requestBody?.input)
+                    ? requestBody.input
+                    : (Array.isArray(frameInput) ? frameInput : []);
+                const itemHashes = logicalInput
                     .map((item) => _hashText(JSON.stringify(item), 12));
                 framePrefixHash = headerHash;
                 framePrefixHeadHash = _hashText(itemHashes.join(','), 16);
@@ -1398,6 +1425,14 @@ export async function sendViaWebSocket({
                 ws_client_metadata_has_thread_id: wireFrameMetadataTrace.hasThreadId,
                 ws_client_metadata_has_turn_state: wireFrameHadTurnState,
                 ws_entry_turn_state_available: useCodexWsClientMetadata && !!entry.turnState,
+                // Fingerprint only. The token is a routing credential, so it is
+                // hashed like every other handshake secret; the length still
+                // distinguishes a real server token from a stub value, and the
+                // hash shows whether one session keeps a single pin or is
+                // re-issued (reconnect / turn rollover).
+                ws_entry_turn_state_fp: typeof entry.turnState === 'string' && entry.turnState
+                    ? `${createHash('sha256').update(entry.turnState).digest('hex').slice(0, 12)}:len${entry.turnState.length}`
+                    : null,
                 chain_delta_reason: mode === 'delta' ? null : deltaReason,
                 chain_stripped_response_items: strippedResponseItems,
                 chain_skipped_response_items: skippedResponseItems,

package/src/runtime/agent/orchestrator/providers/openai-oauth.mjs

@@ -666,11 +666,18 @@ export class OpenAIOAuthProvider {
             // the hot WS/cache path for temporary blips while still preventing
             // TUI-level hangs. Sticky HTTP fallback is only armed after this
             // bounded reconnect budget is exhausted.
-            // Codex startup-prewarm parity: build from the stable request
-            // properties (instructions/tools/etc.) but never send the live
-            // transcript/user input. The completed generate:false response is
-            // retained by the WS transport and anchors the first real request.
-            warmupBody: _envFlag('MIXDOG_OPENAI_OAUTH_WS_WARMUP', false)
+            // Startup prewarm, matching the reference client: build from the
+            // stable request properties (instructions/tools/etc.) but never
+            // send the live transcript/user input. The completed
+            // generate:false response is retained by the WS transport and
+            // anchors the first real request.
+            //
+            // ON by default. Without it every session's first call reports
+            // chain reason `no_anchor` — there is nothing to chain from — and
+            // pays a cold prefix; 973 of the recorded no_anchor rows are
+            // exactly that. Every prewarmed call on record (72/72) kept its
+            // chain continuous. MIXDOG_OPENAI_OAUTH_WS_WARMUP=0 disables it.
+            warmupBody: _envFlag('MIXDOG_OPENAI_OAUTH_WS_WARMUP', true)
                 ? { ...body, input: [], generate: false }
                 : null,
             _carriedWarmup: carriedWarmup,
@@ -806,7 +813,18 @@ export class OpenAIOAuthProvider {
             // session_id and pool-compatibility key match the first real send.
             const cacheKey = buildStableProviderPromptCacheKey('openai-oauth', opts);
             const [auth] = await Promise.all([this.ensureAuth(), _warmVersion()]);
-            const codexHeaders = _codexWsCompatibilityHeaders({ poolKey, cacheKey, sendOpts: opts, handshake: true });
+            const codexHeaders = _codexWsCompatibilityHeaders({
+                poolKey,
+                cacheKey,
+                sendOpts: opts,
+                model: opts.model,
+                // Same tier the request body will carry, so the prewarm
+                // handshake routes to the node the first real send wants.
+                serviceTier: opts.fast === true && codexModelSupportsServiceTier(opts.model, 'priority')
+                    ? 'priority'
+                    : '',
+                handshake: true,
+            });
             const _t0 = Date.now();
             const acquired = await _acquire({
                 auth,

package/src/runtime/agent/orchestrator/providers/openai-responses-payload.mjs

@@ -108,9 +108,12 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
     const wireMessage = (role, content) => (wireParity
         ? { type: 'message', role, content, internal_chat_message_metadata_passthrough: {} }
         : { role, content });
-    const pushReasoningItems = (message) => {
+    // `phase` replays each retained item on the side of the assistant text it
+    // was emitted on, so the rebuilt turn keeps the response's own item order.
+    const pushReasoningItems = (message, phase = 'before') => {
         if (!replayEncryptedReasoning || message?.role !== 'assistant' || !Array.isArray(message.reasoningItems)) return;
         for (const item of message.reasoningItems) {
+            if ((item?.afterText === true) !== (phase === 'after')) continue;
             // Collector shape contract: the WS/HTTP stream collectors store
             // retained items as {id, encrypted_content, summary} WITHOUT a
             // type tag (openai-ws-stream pushReasoningItem). Requiring
@@ -163,7 +166,7 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
             continue;
         }
         flushToolMedia();
-        pushReasoningItems(m);
+        pushReasoningItems(m, 'before');
         if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
             // Default path deliberately omits reasoning replay: openai-oauth
             // rejects an `rs_*` item repeated inside the same stateful
@@ -171,6 +174,7 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
             // converter option with stateless HTTP headers, where the complete
             // retained conversation is the only continuation source.
             if (m.content) out.push(wireMessage('assistant', normalizeContentForOpenAIResponses(m.content, { role: 'assistant' })));
+            pushReasoningItems(m, 'after');
             for (const tc of m.toolCalls) {
                 const nativeSearchCall = nativeToolSearchCallInput(tc);
                 if (nativeSearchCall) {
@@ -198,6 +202,7 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
             m.role === 'assistant' ? 'assistant' : 'user',
             normalizeContentForOpenAIResponses(m.content, { role: m.role }),
         ));
+        pushReasoningItems(m, 'after');
     }
     flushToolMedia();
     return out;
@@ -253,8 +258,27 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     // wire (the only remap; every other effort passes through). Default medium.
     // Kept inline (not a module const) so buildRequestBody stays self-contained.
     // Extract system/instructions
+    // The volatile environment block (session header, cwd, shell startup
+    // capabilities) is per-session BY DEFINITION, so leaving it inside
+    // `instructions` makes the cached prefix unique to a single session and
+    // nothing can ever be shared. Measured 2026-08-21 on 8 parallel bench
+    // sessions: the first 10,408 bytes of `instructions` were byte-identical
+    // and only these lines differed, yet all 8 sessions paid a full cold
+    // prefix (0 cached tokens on every first call). The reference client keeps
+    // instructions static and delivers the same information as a leading
+    // <environment_context> input item; mirror that split here. Anthropic and
+    // Gemini paths are untouched — they consume the env block as its own
+    // unmarked system block.
     const systemMsgs = messages.filter(m => m.role === 'system');
-    const instructions = systemMsgs.map(m => m.content).join('\n\n') || 'You are a helpful assistant.';
+    const environmentMsgs = systemMsgs.filter(m => m?.cacheTier === 'env');
+    const prefixSystemMsgs = environmentMsgs.length
+        ? systemMsgs.filter(m => m?.cacheTier !== 'env')
+        : systemMsgs;
+    const instructions = prefixSystemMsgs.map(m => m.content).join('\n\n') || 'You are a helpful assistant.';
+    const environmentText = environmentMsgs
+        .map(m => (typeof m.content === 'string' ? m.content : ''))
+        .filter(Boolean)
+        .join('\n\n---\n\n');
     const opts = sendOpts || {};
     const promptCacheProvider = opts.promptCacheProvider || 'openai-oauth';
     // Recovery-only encrypted-reasoning replay is DEFAULT ON for the OAuth
@@ -274,6 +298,20 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         nativeToolSearchProvider: promptCacheProvider,
         replayEncryptedReasoning,
     });
+    if (environmentText) {
+        // Leading input item, after the cached prefix instead of inside it.
+        // convertMessagesToResponsesInput skips every system message, so this
+        // is the only copy on the wire — the information reaches the model
+        // unchanged, just one position later.
+        input.unshift({
+            type: 'message',
+            role: 'user',
+            content: [{
+                type: 'input_text',
+                text: `<environment_context>\n${environmentText}\n</environment_context>`,
+            }],
+        });
+    }
     // Match the request body shape the OAuth backend expects so the
     // server-side auto-cache routes correctly. text.verbosity / include /
     // tool_choice / parallel_tool_calls are all inert without side effects

package/src/runtime/agent/orchestrator/providers/openai-ws-delta-parity.test.mjs

@@ -0,0 +1,190 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import {
+    _computeDelta,
+    _sansInput,
+    _stableStringify,
+} from './openai-ws-delta.mjs';
+import { _applyReasoningReplayPolicy } from './openai-oauth-ws.mjs';
+import { _captureTurnStateFromEvent } from './openai-ws-stream.mjs';
+import { _convertMessagesToResponsesInputForTest } from './openai-responses-payload.mjs';
+
+// A turn may reason, speak, then reason again before calling a tool. Replaying
+// every retained item in front of the text invents an order the response never
+// produced, and the next request's incremental check fails on the message item.
+test('a turn that reasons, speaks, then reasons again replays in that order', () => {
+    const beforeText = { id: 'rs-1', encrypted_content: 'e1', summary: [] };
+    const afterText = { id: 'rs-2', encrypted_content: 'e2', summary: [], afterText: true };
+    const input = _convertMessagesToResponsesInputForTest([
+        { role: 'user', content: 'task' },
+        {
+            role: 'assistant',
+            content: 'looking now',
+            reasoningItems: [beforeText, afterText],
+            toolCalls: [{ id: 'call-1', name: 'read', arguments: { path: 'a' } }],
+        },
+        { role: 'tool', toolCallId: 'call-1', content: 'contents' },
+    ], { replayEncryptedReasoning: true });
+
+    assert.deepEqual(input.map((item) => item.type ?? 'message'), [
+        'message',
+        'reasoning',
+        'message',
+        'reasoning',
+        'function_call',
+        'function_call_output',
+    ]);
+    assert.equal(input[1].id, 'rs-1');
+    assert.equal(input[3].id, 'rs-2');
+    // The ordering marker is bookkeeping, never a wire field.
+    assert.equal(input[3].afterText, undefined);
+});
+
+// A live chain's sticky-routing token can never be swapped mid-session: the
+// entry holds it write-once, whichever path first supplied it.
+test('a live turn-state token is never replaced by a later event token', () => {
+    const entry = {};
+    _captureTurnStateFromEvent(entry, {
+        type: 'response.created',
+        headers: { 'x-codex-turn-state': 'handshake-token' },
+    });
+    _captureTurnStateFromEvent(entry, {
+        type: 'response.created',
+        headers: { 'x-codex-turn-state': 'later-token' },
+    });
+    assert.equal(entry.turnState, 'handshake-token');
+});
+
+// The logical request history always carries retained reasoning — a pooled
+// entry with a live chain included. Only the duplicate-rejection retry drops it.
+test('reasoning stays in the logical history on every send', () => {
+    const reasoning = {
+        type: 'reasoning',
+        id: 'rs-1',
+        encrypted_content: 'encrypted',
+        summary: [],
+    };
+    const toolOutput = { type: 'function_call_output', call_id: 'call-1', output: 'ok' };
+    const body = { input: [reasoning, toolOutput] };
+    const entry = { lastResponseId: 'resp-1', lastRequestInput: [] };
+
+    const retained = _applyReasoningReplayPolicy(entry, body);
+    assert.equal(retained, body);
+    assert.equal(retained.input[0], reasoning);
+    assert.equal(entry.replayReasoning, true);
+
+    const suppressed = _applyReasoningReplayPolicy(entry, body, { suppress: true });
+    assert.equal(entry.replayReasoning, false);
+    assert.deepEqual(suppressed.input, [toolOutput]);
+});
+
+test('Codex delta parity falls back when a previous response item is absent', (t) => {
+    const priorTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+    t.after(() => {
+        if (priorTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = priorTransport;
+    });
+
+    const previousInput = [{
+        type: 'message',
+        role: 'user',
+        content: [{ type: 'input_text', text: 'task' }],
+    }];
+    const previousCall = {
+        type: 'function_call',
+        call_id: 'call-1',
+        name: 'read',
+        arguments: '{"path":"/app/input.txt"}',
+    };
+    const body = {
+        model: 'gpt-5.6-sol',
+        input: [
+            ...previousInput,
+            // The reasoning item from the previous response is missing here.
+            previousCall,
+            {
+                type: 'function_call_output',
+                call_id: 'call-1',
+                output: 'fixture',
+            },
+        ],
+    };
+    const entry = {
+        lastRequestSansInput: _stableStringify(_sansInput({
+            model: body.model,
+            input: previousInput,
+        })),
+        lastRequestInput: previousInput,
+        lastResponseId: 'resp-1',
+        lastResponseItems: [
+            {
+                type: 'reasoning',
+                id: 'rs-1',
+                encrypted_content: 'encrypted',
+            },
+            previousCall,
+        ],
+        turnState: 'sticky',
+    };
+
+    const delta = _computeDelta({ entry, body, traceProvider: 'openai-oauth' });
+    assert.equal(delta.mode, 'full');
+    assert.equal(delta.reason, 'response_output_mismatch:reasoning');
+    assert.equal(delta.frame.previous_response_id, undefined);
+    assert.deepEqual(delta.frame.input, body.input);
+});
+
+// Retained reasoning rides the logical history, and the delta builder is what
+// keeps it off the wire: it belongs to the anchored previous response, so the
+// frame carries only what is genuinely new. This is the whole reason the
+// history keeps the item instead of dropping it before the delta runs.
+test('the delta frame drops the anchored reasoning item from the wire tail', (t) => {
+    const priorTransport = process.env.MIXDOG_OAI_TRANSPORT;
+    process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
+    t.after(() => {
+        if (priorTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+        else process.env.MIXDOG_OAI_TRANSPORT = priorTransport;
+    });
+
+    const previousInput = [{
+        type: 'message',
+        role: 'user',
+        content: [{ type: 'input_text', text: 'task' }],
+    }];
+    const reasoning = { type: 'reasoning', id: 'rs-1', encrypted_content: 'encrypted' };
+    const previousCall = {
+        type: 'function_call',
+        call_id: 'call-1',
+        name: 'read',
+        arguments: '{"path":"/app/input.txt"}',
+    };
+    const toolOutput = {
+        type: 'function_call_output',
+        call_id: 'call-1',
+        output: 'fixture',
+    };
+    const body = {
+        model: 'gpt-5.6-sol',
+        input: [...previousInput, reasoning, previousCall, toolOutput],
+    };
+    const entry = {
+        lastRequestSansInput: _stableStringify(_sansInput({
+            model: body.model,
+            input: previousInput,
+        })),
+        lastRequestInput: previousInput,
+        lastResponseId: 'resp-1',
+        lastResponseItems: [reasoning, previousCall],
+        replayReasoning: true,
+        turnState: 'sticky',
+    };
+
+    const delta = _computeDelta({ entry, body, traceProvider: 'openai-oauth' });
+    assert.equal(delta.mode, 'delta');
+    assert.equal(delta.reason, null);
+    assert.equal(delta.frame.previous_response_id, 'resp-1');
+    assert.deepEqual(delta.frame.input, [toolOutput]);
+    assert.equal(delta.strippedResponseItems, 2);
+});

package/src/runtime/agent/orchestrator/providers/openai-ws-delta.mjs

@@ -146,16 +146,6 @@ function _stripRequestPrefix(curInput, prevInput) {
     return current.slice(previous.length);
 }
 
-function _isReplayLikeHead(item, responseItem) {
-    if (!item || !responseItem) return false;
-    const inputType = item.type || (item.role === 'assistant' ? 'message' : '');
-    const responseType = responseItem.type || '';
-    if (responseType === 'message') return inputType === 'message';
-    if (responseType === 'function_call') return inputType === 'function_call';
-    if (responseType === 'tool_search_call') return inputType === 'tool_search_call';
-    return inputType === responseType;
-}
-
 // The hash input follows the same per-item normalizations used by
 // _logicalResponseItemMatch, but is never emitted itself. This retains a
 // stable comparison fingerprint after history compaction without putting
@@ -222,32 +212,51 @@ export function _stripResponseItemsFromHead(items, responseItems) {
     const outputs = Array.isArray(responseItems) ? responseItems : [];
     let cursor = 0;
     let stripped = 0;
-    let skipped = 0;
     for (const output of outputs) {
-        if (cursor >= tail.length) break;
-        if (_logicalResponseItemMatch(tail[cursor], output)) {
-            cursor += 1;
-            stripped += 1;
-            continue;
-        }
-        if (_isReplayLikeHead(tail[cursor], output)) {
+        // The incremental request must extend the EXACT previous request plus
+        // its response: every item the previous response produced has to appear
+        // in the current prefix, in order, before anything new. Skipping a
+        // missing one builds a delta against a logical history the server never
+        // saw and can invalidate the cache chain while previous_response_id
+        // stays syntactically valid, so any gap forces a full-frame fallback.
+        // There is no per-item exception — reasoning included. Reasoning items
+        // are kept in the logical history precisely so this proof holds, and
+        // they leave the wire here, as part of the anchored prefix.
+        if (cursor >= tail.length) {
             return {
                 ok: false,
                 reason: `response_output_mismatch:${output?.type || 'unknown'}`,
                 tail,
                 stripped,
-                skipped,
+                skipped: 0,
                 responseOutputMismatch: _responseOutputMismatchDiagnostics(
-                    tail[cursor],
+                    undefined,
                     output,
                     tail.length,
                     outputs.length,
                 ),
             };
         }
-        skipped += 1;
+        if (_logicalResponseItemMatch(tail[cursor], output)) {
+            cursor += 1;
+            stripped += 1;
+            continue;
+        }
+        return {
+            ok: false,
+            reason: `response_output_mismatch:${output?.type || 'unknown'}`,
+            tail,
+            stripped,
+            skipped: 0,
+            responseOutputMismatch: _responseOutputMismatchDiagnostics(
+                tail[cursor],
+                output,
+                tail.length,
+                outputs.length,
+            ),
+        };
     }
-    return { ok: true, reason: null, tail: tail.slice(cursor), stripped, skipped };
+    return { ok: true, reason: null, tail: tail.slice(cursor), stripped, skipped: 0 };
 }
 
 // Official OpenAI Responses WebSocket guide: response.create WS frames mirror
@@ -303,12 +312,16 @@ export function _buildResponseCreateFrame(body, { previousResponseId = null, inp
 
 export function _computeDelta({ entry, body, traceProvider }) {
     // DEFAULT: full-frame sends. codex's delta path is only cache-safe with
-    // the x-codex-turn-state sticky-routing token, which the backend issues to
-    // codex but never to us (R11-R14 2026-07-03: zero turn-state events across
-    // 200+ calls despite UA/version/beta-features/client_metadata parity;
-    // delta measured 18-28% warm miss vs full-frame 0.0%). Without the sticky
-    // token, previous_response_id requests hop cache nodes and only the first
-    // prefix blocks hit. Re-enable delta explicitly via
+    // the x-codex-turn-state sticky-routing token. R11-R14 (2026-07-03)
+    // measured zero turn-state EVENTS across 200+ calls despite
+    // UA/version/beta-features/client_metadata parity, and delta at 18-28% warm
+    // miss vs full-frame 0.0%. The event channel is still silent, but the
+    // conclusion "the backend never issues it to us" was wrong: the token
+    // arrives on the handshake 101 response instead (2026-08-21 bench: 81 of 88
+    // calls carried it from iteration 1, before any response event existed), so
+    // the pool captures it at upgrade and the frame metadata replays it.
+    // Without the sticky token, previous_response_id requests hop cache nodes
+    // and only the first prefix blocks hit.
     // Delta gating flows through the single transport-policy switch
     // (MIXDOG_OAI_TRANSPORT: ws-full | ws-delta | http-sse). Default ws-delta
     // selects the refs-compatible safe delta; 'ws-full'/'http-sse' force full

package/src/runtime/agent/orchestrator/providers/openai-ws-headers.mjs

@@ -36,22 +36,9 @@ export function _envOn(name) {
     return ['1', 'true', 'yes', 'on'].includes(v);
 }
 
-// --- Opt-in Codex fingerprint/id parity knobs ------------------------------
-// All default OFF; unset envs leave the winning combo
-// (MIXDOG_OAI_CODEX_WIRE_PARITY=1 + ws-delta + underscore session_id) exactly
-// as-is. These add EXTRA parity dimensions for backend fingerprint probes.
-
-// The reference client sends dashed RFC-4122 UUIDs as session-id/thread-id;
-// we key those dashed handshake headers off the underscore cacheKey by
-// default. Opt in with MIXDOG_OAI_CODEX_WIRE_PARITY_UUID_IDS to reshape ONLY
-// the dashed pair (session-id/thread-id/x-client-request-id) into codex's UUID
-// format. The value is derived deterministically from the id so it stays
-// stable per cache key (prefix-cache continuity preserved), and the underscore
-// `session_id` header (the backend prefix-dedupe key) is left untouched.
-export function _codexUuidIdParity() {
-    const v = String(process.env.MIXDOG_OAI_CODEX_WIRE_PARITY_UUID_IDS || '').trim().toLowerCase();
-    return ['1', 'true', 'yes', 'on', 'uuid', 'dashed'].includes(v);
-}
+// Dashed handshake ids are derived deterministically from the cache key, so a
+// session keeps the same pair for its whole life and prefix-cache continuity
+// holds.
 
 export function _codexDashedId(value) {
     const h = createHash('sha256').update(String(value)).digest();
@@ -62,23 +49,9 @@ export function _codexDashedId(value) {
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
 }
 
-// Opt-in turn-state gate experiment bundle (MIXDOG_OAI_CODEX_TURN_STATE_GATE).
-// The debugger's working hypothesis for what gates x-codex-turn-state issuance
-// is a specific wire shape: Codex-shaped UUIDv7 session/thread ids + dashed-only
-// handshake headers (drop the underscore session_id) + NO duplicated
-// x-client-request-id + a parent-thread header (added in openai-oauth-ws.mjs).
-// This env ties those dimensions together as ONE experiment so operators can
-// A/B the whole gate shape without hand-composing four flags. Default OFF; it
-// leaves MIXDOG_OAI_CODEX_WIRE_PARITY_UUID_IDS / _SESSION_ID and every existing
-// flag intact and only reshapes the wire when explicitly enabled.
-export function _codexTurnStateGate() {
-    const v = String(process.env.MIXDOG_OAI_CODEX_TURN_STATE_GATE || '').trim().toLowerCase();
-    return ['1', 'true', 'yes', 'on'].includes(v);
-}
-
 // Same derivation as _codexDashedId but stamps the version-7 nibble so the
-// dashed pair reads as a Codex-shaped UUIDv7. Deterministic per id (prefix
-// cache continuity preserved); only used under the turn-state gate bundle.
+// dashed pair reads as a Codex-shaped UUIDv7, which is the shape the reference
+// client sends. Deterministic per id, so prefix-cache continuity holds.
 export function _codexDashedIdV7(value) {
     const h = createHash('sha256').update(String(value)).digest();
     const b = Buffer.from(h.subarray(0, 16));
@@ -88,24 +61,11 @@ export function _codexDashedIdV7(value) {
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
 }
 
-// codex advertises enabled beta features on the WS handshake; the backend
-// plausibly gates x-codex-turn-state issuance on that list (see the
-// x-codex-beta-features comment below). MIXDOG_CODEX_BETA_FEATURES replaces the
-// whole list; MIXDOG_OAI_CODEX_TURN_STATE_FEATURES is a safe ADD-ONLY opt-in
-// that appends turn-state-gating feature token(s) (comma-separated, de-duped)
-// without dropping the default `remote_compaction_v2`. Unset = default list.
+// Beta features advertised on the WS handshake. MIXDOG_CODEX_BETA_FEATURES
+// replaces the list when an operator needs to pin exactly what a known-good
+// client build reports; unset keeps the default.
 export function _codexBetaFeatures() {
-    const base = process.env.MIXDOG_CODEX_BETA_FEATURES || 'remote_compaction_v2';
-    const extra = String(process.env.MIXDOG_OAI_CODEX_TURN_STATE_FEATURES || '').trim();
-    if (!extra) return base;
-    const seen = new Set();
-    const out = [];
-    for (const tok of `${base},${extra}`.split(',').map((s) => s.trim()).filter(Boolean)) {
-        if (seen.has(tok)) continue;
-        seen.add(tok);
-        out.push(tok);
-    }
-    return out.join(',');
+    return process.env.MIXDOG_CODEX_BETA_FEATURES || 'remote_compaction_v2';
 }
 
 // --- Opt-in raw WS capture for wire byte-diff -------------------------------