mixdog 0.9.50 → 0.9.52

package/scripts/mcp-grace-deferred-test.mjs

@@ -11,13 +11,14 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
     applyDeferredToolSurface,
+    rebuildDeferredToolSurfaceForProvider,
     refreshInitialDeferredMcpSurface,
     reconcileDeferredMcpToolCatalog,
 } from '../src/session-runtime/tool-catalog.mjs';
 
-function baseSession() {
+function baseSession(provider = 'anthropic-oauth') {
     return {
-        provider: 'legacy',
+        provider,
         tools: [{ name: 'read', description: 'read a file' }, { name: 'grep', description: 'search' }],
         messages: [{ role: 'system', content: 'BASE PROMPT' }],
     };
@@ -26,9 +27,9 @@ function baseSession() {
 // A freshly-created session: the create-time surface is baked WITHOUT any MCP
 // (server still mid-handshake at create). `shell` is a deferred (non-active)
 // standalone tool so BP1 carries a manifest block even before MCP arrives.
-function createdSession() {
-    const session = baseSession();
-    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }], { provider: 'legacy' });
+function createdSession(provider = 'anthropic-oauth') {
+    const session = baseSession(provider);
+    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }], { provider: session.provider });
     return session;
 }
 
@@ -93,7 +94,7 @@ test('recreated session (MCP already connected at create) seeds its manifest, no
     // surface at create time, so a cwd-change recreate seeds its BP1 directly and
     // never needs the first-turn refresh.
     const session = baseSession();
-    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }, mcpTool], { provider: 'legacy' });
+    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }, mcpTool], { provider: session.provider });
     assert.ok(systemContent(session).includes('mcp__unity__get_scene'), 'MCP in recreated BP1');
     assert.ok(session.deferredAnnouncedTools.includes('mcp__unity__get_scene'), 'recreated MCP pre-marked announced');
 
@@ -128,7 +129,7 @@ test('a second newly-connected MCP tool re-renders BP1 in place (both listed, st
 test('a resumed session (no fresh flag, prior baked BP1) is NOT refreshed on its next turn', () => {
     // A prior run baked BP1 with the MCP tool; resume reloads that transcript.
     const session = baseSession();
-    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }, mcpTool], { provider: 'legacy' });
+    applyDeferredToolSurface(session, 'full', [{ name: 'shell', description: 'run a command' }, mcpTool], { provider: session.provider });
     const before = systemContent(session);
     const announcedBefore = [...session.deferredAnnouncedTools];
     // Resume path never sets the per-session fresh flag.
@@ -139,11 +140,86 @@ test('a resumed session (no fresh flag, prior baked BP1) is NOT refreshed on its
     assert.deepEqual([...session.deferredAnnouncedTools], announcedBefore, 'announced set unchanged on resume');
 });
 
-test('a fresh session (flagged) is refreshed exactly once, then falls to the late path', () => {
-    const session = createdSession();
+test('fresh-session refresh state is isolated, one-shot, and survives provider switches without leaking', () => {
+    const refreshedSession = createdSession();
+    const noOpSession = createdSession();
+    refreshedSession.deferredInitialRefreshPending = true;
+    noOpSession.deferredInitialRefreshPending = true;
+
+    assert.equal(firstTurnGate(refreshedSession, [mcpTool]), 'refreshed', 'fresh session refreshes on its first turn');
+    assert.equal(refreshedSession.deferredInitialRefreshPending, false, 'fresh flag consumed (one-shot)');
+    assert.equal(noOpSession.deferredInitialRefreshPending, true, 'consuming one session does not consume another');
+    assert.ok(refreshedSession.deferredAnnouncedTools.includes('mcp__unity__get_scene'), 'first-turn MCP pre-announced');
+    assert.ok(!noOpSession.deferredAnnouncedTools.includes('mcp__unity__get_scene'), 'announced state does not leak between sessions');
+    assert.equal(firstTurnGate(refreshedSession, [mcpTool2]), 'late', 'second turn no longer refreshes');
+
+    rebuildDeferredToolSurfaceForProvider(noOpSession, 'xai');
+    noOpSession.provider = 'xai';
+    const beforeNoOp = systemContent(noOpSession);
+    assert.equal(beforeNoOp.includes('<available-deferred-tools>'), false, 'canonical switch removes native manifest state');
+    assert.equal(firstTurnGate(noOpSession, []), 'refresh-noop', 'canonical provider consumes an empty one-shot without a manifest refresh');
+    assert.equal(noOpSession.deferredInitialRefreshPending, false, 'no-op also consumes the fresh flag');
+    assert.equal(systemContent(noOpSession), beforeNoOp, 'canonical no-op leaves the initial manifest byte-identical');
+
+    rebuildDeferredToolSurfaceForProvider(noOpSession, 'anthropic-oauth');
+    noOpSession.provider = 'anthropic-oauth';
+    assert.equal(firstTurnGate(noOpSession, [mcpTool2]), 'late', 'switching back cannot resurrect first-turn refresh state');
+    assert.ok(!noOpSession.deferredAnnouncedTools.includes('mcp__unity__run_tests'), 'post-switch tool remains eligible for the late path');
+});
+
+test('legacy canonical snapshot gains a grace-connected MCP tool for the first turn and session lifetime', () => {
+    const session = createdSession('legacy');
     session.deferredInitialRefreshPending = true;
-    assert.equal(firstTurnGate(session, [mcpTool]), 'refreshed', 'fresh session refreshes on its first turn');
-    assert.equal(session.deferredInitialRefreshPending, false, 'fresh flag consumed (one-shot)');
-    assert.ok(session.deferredAnnouncedTools.includes('mcp__unity__get_scene'), 'first-turn MCP pre-announced');
-    assert.equal(firstTurnGate(session, [mcpTool2]), 'late', 'second turn no longer refreshes');
+    const before = systemContent(session);
+
+    assert.equal(firstTurnGate(session, [mcpTool]), 'refreshed', 'grace fold updates the canonical snapshot');
+    assert.ok(session.tools.some((tool) => tool.name === mcpTool.name), 'tool is provider-visible on the first turn');
+    assert.ok(session.deferredCallableTools.includes(mcpTool.name), 'tool is callable for the session');
+    assert.ok(session.deferredToolCatalog.some((tool) => tool.name === mcpTool.name), 'tool persists in the session catalog');
+    assert.equal(systemContent(session), before, 'canonical refresh does not introduce a native manifest');
+    assert.equal(systemContent(session).includes('<available-deferred-tools>'), false);
+
+    const toolsOnce = JSON.stringify(session.tools);
+    assert.equal(refreshInitialDeferredMcpSurface(session, [mcpTool]), false, 'repeated fold is a no-op');
+    assert.equal(JSON.stringify(session.tools), toolsOnce, 'repeated fold leaves the fixed surface byte-identical');
+    assert.equal(firstTurnGate(session, [mcpTool]), 'late', 'one-shot gate remains consumed');
+});
+
+test('legacy to Anthropic and back preserves grace MCP availability without manifest leakage or duplication', () => {
+    const session = createdSession('legacy');
+    assert.equal(refreshInitialDeferredMcpSurface(session, [mcpTool]), true);
+
+    rebuildDeferredToolSurfaceForProvider(session, 'anthropic-oauth');
+    session.provider = 'anthropic-oauth';
+    assert.ok(session.deferredToolCatalog.some((tool) => tool.name === mcpTool.name), 'native switch retains the MCP catalog entry');
+    assert.ok(systemContent(session).includes(mcpTool.name), 'native switch advertises the retained deferred tool');
+    assert.equal((systemContent(session).match(/<available-deferred-tools>/g) || []).length, 1, 'native switch creates one manifest');
+
+    rebuildDeferredToolSurfaceForProvider(session, 'legacy');
+    session.provider = 'legacy';
+    assert.ok(session.tools.some((tool) => tool.name === mcpTool.name), 'canonical switch restores the MCP tool to the active surface');
+    assert.ok(session.deferredCallableTools.includes(mcpTool.name), 'canonical switch keeps the MCP tool callable');
+    assert.equal(systemContent(session).includes('<available-deferred-tools>'), false, 'native manifest does not leak back to canonical');
+    assert.deepEqual(session.deferredAnnouncedTools, [], 'native announcement state does not leak back to canonical');
+
+    rebuildDeferredToolSurfaceForProvider(session, 'anthropic-oauth');
+    session.provider = 'anthropic-oauth';
+    assert.equal((systemContent(session).match(/<available-deferred-tools>/g) || []).length, 1, 'repeat switch still creates only one manifest');
+});
+
+test('canonical MCP arriving after the first-turn grace keeps the fixed snapshot and emits no late reminder', () => {
+    const session = createdSession('legacy');
+    session.deferredInitialRefreshPending = true;
+    assert.equal(firstTurnGate(session, []), 'refresh-noop');
+    const before = JSON.stringify(session.tools);
+    let enqueued = null;
+
+    const result = reconcileDeferredMcpToolCatalog(session, [mcpTool2], {
+        enqueue: (text) => { enqueued = text; return true; },
+    });
+    assert.equal(result, null, 'canonical reconciliation keeps the create/grace snapshot fixed');
+    assert.equal(JSON.stringify(session.tools), before, 'post-grace MCP does not churn the canonical surface');
+    assert.equal(session.deferredToolCatalog.some((tool) => tool.name === mcpTool2.name), false);
+    assert.equal(enqueued, null, 'canonical provider emits no native late reminder');
+    assert.equal(systemContent(session).includes('<available-deferred-tools>'), false);
 });

package/scripts/memory-pg-recovery-test.mjs

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict'
+import { EventEmitter } from 'node:events'
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+
+import {
+  installPoolErrorHandler,
+  isPgConnectionLossError,
+} from '../src/runtime/memory/lib/pg/adapter.mjs'
+import { startPg } from '../src/runtime/memory/lib/pg/process.mjs'
+
+test('checked-out pg clients always retain an error listener', () => {
+  const priorQuiet = process.env.MIXDOG_QUIET_MEMORY_LOG
+  process.env.MIXDOG_QUIET_MEMORY_LOG = '1'
+  try {
+    const pool = new EventEmitter()
+    const client = new EventEmitter()
+    installPoolErrorHandler(pool, 'test-pool')
+    pool.emit('connect', client)
+    pool.emit('connect', client)
+
+    assert.equal(client.listenerCount('error'), 1)
+    assert.doesNotThrow(() => {
+      client.emit('error', new Error('Connection terminated unexpectedly'))
+    })
+  } finally {
+    if (priorQuiet == null) delete process.env.MIXDOG_QUIET_MEMORY_LOG
+    else process.env.MIXDOG_QUIET_MEMORY_LOG = priorQuiet
+  }
+})
+
+test('postgres connection-loss classifier covers reset and server termination', () => {
+  assert.equal(isPgConnectionLossError(Object.assign(new Error('read ECONNRESET'), { code: 'ECONNRESET' })), true)
+  assert.equal(isPgConnectionLossError(new Error('Connection terminated unexpectedly')), true)
+  assert.equal(isPgConnectionLossError(Object.assign(new Error('admin shutdown'), { code: '57P01' })), true)
+  assert.equal(isPgConnectionLossError(new Error('duplicate key value violates unique constraint')), false)
+})
+
+test('startPg refuses a second start while postmaster.pid owner is alive but not ready', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-pg-recovery-'))
+  const runtimeDir = join(root, 'runtime')
+  const pgdataDir = join(root, 'pgdata')
+  mkdirSync(runtimeDir, { recursive: true })
+  mkdirSync(pgdataDir, { recursive: true })
+  writeFileSync(
+    join(pgdataDir, 'postmaster.pid'),
+    `${process.pid}\n${pgdataDir}\n${Math.floor(Date.now() / 1000)}\n55432\n\n127.0.0.1\n`,
+  )
+  try {
+    await assert.rejects(
+      startPg({ runtimeDir, pgdataDir, existingWaitMs: 20 }),
+      /is alive but not ready; refusing concurrent start/,
+    )
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})

package/scripts/openai-oauth-ws-1006-retry-test.mjs

@@ -1,9 +1,20 @@
 // Regression: OpenAI OAuth WS abnormal-close recovery before visible output.
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
 import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
 import { _acquireWithRetry, sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
-import { _sendFrame } from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
+import { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
+import {
+    _clearWebSocketPoolForTest,
+    _closeAllPooledSockets,
+    _resetOpenSocketDrainForTest,
+    _seedWebSocketEntryForTest,
+    _setOpenSocketForTest,
+    acquireWebSocket,
+    releaseWebSocket,
+    _sendFrame,
+} from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
 
 function close1006() {
     const err = new Error('WebSocket closed abnormally');
@@ -28,6 +39,65 @@ function wsArgs(overrides = {}) {
     };
 }
 
+class PoolSocket extends EventEmitter {
+    constructor() {
+        super();
+        this.readyState = 1;
+        this._socket = { ref() {}, unref() {} };
+    }
+    close() { this.readyState = 3; }
+    ping() { queueMicrotask(() => this.emit('pong')); }
+}
+
+function poolEntry(responseId) {
+    return {
+        socket: new PoolSocket(),
+        busy: true,
+        closing: false,
+        ephemeral: false,
+        lastResponseId: responseId,
+    };
+}
+
+test('pool release/acquire preserves latest compatible chain and auth/cache boundaries', async (t) => {
+    t.after(() => _clearWebSocketPoolForTest());
+    const poolKey = 'reused-session-id';
+    const authA = { account_id: 'account-a', access_token: 'token-a' };
+    const authB = { account_id: 'account-b', access_token: 'token-b' };
+    const oldest = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-a', entry: poolEntry('resp-old'),
+    });
+    const latest = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-a', entry: poolEntry('resp-latest'),
+    });
+    const otherAccount = _seedWebSocketEntryForTest({
+        poolKey, auth: authB, cacheKey: 'cache-a', entry: poolEntry('resp-account-b'),
+    });
+    const otherCache = _seedWebSocketEntryForTest({
+        poolKey, auth: authA, cacheKey: 'cache-b', entry: poolEntry('resp-cache-b'),
+    });
+
+    releaseWebSocket({ entry: oldest, poolKey, keep: true });
+    releaseWebSocket({ entry: otherAccount, poolKey, keep: true });
+    releaseWebSocket({ entry: otherCache, poolKey, keep: true });
+    releaseWebSocket({ entry: latest, poolKey, keep: true });
+
+    const first = await acquireWebSocket({
+        auth: authA, poolKey, cacheKey: 'cache-a', forceFresh: false,
+    });
+    assert.equal(first.entry, latest, 'latest completed compatible chain wins');
+    assert.equal(first.reused, true);
+    assert.equal(latest.busy, true, 'acquire reserves the selected entry');
+
+    const second = await acquireWebSocket({
+        auth: authA, poolKey, cacheKey: 'cache-a', forceFresh: false,
+    });
+    assert.equal(second.entry, oldest, 'reserved latest entry cannot be acquired concurrently');
+    assert.equal(second.entry.lastResponseId, 'resp-old');
+    assert.notEqual(second.entry, otherAccount);
+    assert.notEqual(second.entry, otherCache);
+});
+
 test('acquire timeout reconnects successfully with progress, not a terminal WS error', async () => {
     const oldWrite = process.stderr.write;
     const oldQuiet = process.env.MIXDOG_QUIET_PROVIDER_LOG;
@@ -169,9 +239,9 @@ test('pre-response 1006 opens a fresh WS and replays the same request', async ()
         stages.filter(({ stage }) => stage === 'reconnecting'),
         [{ stage: 'reconnecting', detail: {
             attempt: 1,
-            max: 4,
+            max: 5,
             classifier: 'ws_1006',
-            message: 'Reconnecting... 1/4',
+            message: 'Reconnecting... 1/5',
         } }],
     );
     assert.doesNotMatch(stderr, /mid-stream recovered|Reconnecting/);
@@ -203,6 +273,33 @@ test('successful iteration emits one compact send-spans row', async () => {
     assert.equal('body' in rows[0].payload, false);
 });
 
+test('normal handshake cannot return or reinsert a socket after pool drain', async () => {
+    let finishOpen;
+    const opened = new Promise((resolve) => { finishOpen = resolve; });
+    const closes = [];
+    const socket = new EventEmitter();
+    socket.readyState = 1;
+    socket.close = (code, reason) => closes.push([code, reason]);
+    socket.on = socket.on.bind(socket);
+    try {
+        _setOpenSocketForTest(() => opened);
+        const acquire = acquireWebSocket({
+            auth: { type: 'openai-direct', apiKey: 'test-key' },
+            poolKey: 'drain-race',
+            cacheKey: 'drain-race',
+            forceFresh: false,
+            externalSignal: null,
+        });
+        _closeAllPooledSockets('test-drain');
+        finishOpen({ socket, turnState: null });
+        await assert.rejects(acquire, /WS pool drained/);
+        assert.deepEqual(closes, [[1000, 'drain-complete']]);
+    } finally {
+        _clearWebSocketPoolForTest();
+        _resetOpenSocketDrainForTest();
+    }
+});
+
 test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async () => {
     const savedEnv = Object.fromEntries([
         'MIXDOG_OAI_TRANSPORT',
@@ -244,10 +341,11 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
         const result = await provider.send([], 'gpt-5.5', [], sendOpts);
         const stickyResult = await provider.send([], 'gpt-5.5', [], sendOpts);
 
-        assert.equal(streamAttempts, 5, 'all bounded ws_1006 attempts must run before fallback');
+        assert.equal(streamAttempts, 6, 'five bounded retries must run before fallback');
         assert.equal(httpCalls, 2);
         assert.equal(result.content, 'http-recovered');
         assert.equal(stickyResult.content, 'http-recovered');
+        assert.equal(provider._httpFallbackUntilByPoolKey.get(sendOpts.sessionId), Number.POSITIVE_INFINITY);
     } finally {
         for (const [name, value] of Object.entries(savedEnv)) {
             if (value == null) delete process.env[name];
@@ -256,6 +354,233 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
     }
 });
 
+test('handshake 403 spends the shared retry budget without auth refresh, then disables WS for the session', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_HTTP_FALLBACK',
+        'MIXDOG_OPENAI_OAUTH_WS_WARMUP',
+        'MIXDOG_AGENT_TRACE_DISABLE',
+    ].map((name) => [name, process.env[name]]));
+    Object.assign(process.env, {
+        MIXDOG_OAI_TRANSPORT: 'auto',
+        MIXDOG_OPENAI_HTTP_FALLBACK: '1',
+        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    try {
+        const provider = new OpenAIOAuthProvider({});
+        let authRefreshes = 0;
+        provider.ensureAuth = async ({ forceRefresh = false } = {}) => {
+            if (forceRefresh) authRefreshes += 1;
+            return { access_token: 'test-token' };
+        };
+        let acquires = 0;
+        let httpCalls = 0;
+        const sendOpts = {
+            sessionId: 'openai-oauth-ws-403-fallback-test',
+            _prebuiltBody: { model: 'gpt-5.5', input: [] },
+            _sendViaWebSocketFn: (args) => sendViaWebSocket({
+                ...args,
+                _acquireWithRetryFn: async ({ forceFresh }) => {
+                    assert.equal(forceFresh, acquires > 0);
+                    acquires += 1;
+                    throw Object.assign(new Error('Unexpected server response: 403'), { httpStatus: 403 });
+                },
+                _sleepFn: async () => {},
+            }),
+            _sendViaHttpSseFn: async () => {
+                httpCalls += 1;
+                return { content: 'http-recovered', toolCalls: [], usage: {} };
+            },
+        };
+
+        assert.equal((await provider.send([], 'gpt-5.5', [], sendOpts)).content, 'http-recovered');
+        assert.equal((await provider.send([], 'gpt-5.5', [], sendOpts)).content, 'http-recovered');
+        assert.equal(acquires, 6);
+        assert.equal(authRefreshes, 0);
+        assert.equal(httpCalls, 2);
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('handshake 426 falls back immediately without retry or auth refresh', async () => {
+    const provider = new OpenAIOAuthProvider({});
+    let authRefreshes = 0;
+    provider.ensureAuth = async ({ forceRefresh = false } = {}) => {
+        if (forceRefresh) authRefreshes += 1;
+        return { access_token: 'test-token' };
+    };
+    let wsCalls = 0;
+    let httpCalls = 0;
+    const result = await provider.send([], 'gpt-5.5', [], {
+        sessionId: 'openai-oauth-ws-426-fallback-test',
+        _prebuiltBody: { model: 'gpt-5.5', input: [] },
+        _sendViaWebSocketFn: async () => {
+            wsCalls += 1;
+            throw Object.assign(new Error('Upgrade Required'), { httpStatus: 426 });
+        },
+        _sendViaHttpSseFn: async () => {
+            httpCalls += 1;
+            return { content: 'http-426', toolCalls: [], usage: {} };
+        },
+    });
+    assert.equal(result.content, 'http-426');
+    assert.equal(wsCalls, 1);
+    assert.equal(httpCalls, 1);
+    assert.equal(authRefreshes, 0);
+});
+
+for (const path of ['handshake', 'pre-output-stream']) {
+    for (const terminalStatus of [401, 426]) {
+        test(`mixed ${path} failure surfaces later ${terminalStatus} to provider recovery`, async () => {
+            const provider = new OpenAIOAuthProvider({});
+            let authRefreshes = 0;
+            provider.ensureAuth = async ({ forceRefresh = false } = {}) => {
+                if (forceRefresh) authRefreshes += 1;
+                return { access_token: forceRefresh ? 'refreshed-token' : 'test-token' };
+            };
+            let wsDispatches = 0;
+            let httpCalls = 0;
+            const result = await provider.send([], 'gpt-5.5', [], {
+                sessionId: `mixed-${path}-${terminalStatus}`,
+                _prebuiltBody: { model: 'gpt-5.5', input: [] },
+                _sendViaWebSocketFn: (args) => {
+                    wsDispatches += 1;
+                    if (wsDispatches > 1) {
+                        return { content: 'ws-after-refresh', toolCalls: [], usage: {} };
+                    }
+                    let failures = 0;
+                    return sendViaWebSocket({
+                        ...args,
+                        _acquireWithRetryFn: async () => {
+                            if (path === 'handshake') {
+                                failures += 1;
+                                const status = failures === 1 ? 403 : terminalStatus;
+                                throw Object.assign(new Error(`handshake ${status}`), { httpStatus: status });
+                            }
+                            return { entry: entry(), reused: false };
+                        },
+                        _sendFrameFn: async () => {},
+                        _streamFn: async () => {
+                            failures += 1;
+                            if (failures === 1) throw close1006();
+                            throw Object.assign(new Error(`stream ${terminalStatus}`), { httpStatus: terminalStatus });
+                        },
+                        _sleepFn: async () => {},
+                    });
+                },
+                _sendViaHttpSseFn: async () => {
+                    httpCalls += 1;
+                    return { content: 'http-after-426', toolCalls: [], usage: {} };
+                },
+            });
+
+            assert.equal(result.content, terminalStatus === 401 ? 'ws-after-refresh' : 'http-after-426');
+            assert.equal(authRefreshes, terminalStatus === 401 ? 1 : 0);
+            assert.equal(wsDispatches, terminalStatus === 401 ? 2 : 1);
+            assert.equal(httpCalls, terminalStatus === 426 ? 1 : 0);
+        });
+    }
+}
+
+for (const fallbackOutcome of ['failure', 'abort']) {
+    test(`WS remains disabled when sticky HTTP fallback ends in ${fallbackOutcome}`, async () => {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        const controller = new AbortController();
+        let wsCalls = 0;
+        let httpCalls = 0;
+        const opts = {
+            sessionId: `sticky-before-http-${fallbackOutcome}`,
+            signal: controller.signal,
+            _prebuiltBody: { model: 'gpt-5.5', input: [] },
+            _sendViaWebSocketFn: async () => {
+                wsCalls += 1;
+                throw Object.assign(new Error('WS retries exhausted'), {
+                    retryClassifier: 'reset',
+                    wsRetriesExhausted: true,
+                });
+            },
+            _sendViaHttpSseFn: async () => {
+                httpCalls += 1;
+                if (httpCalls === 1) {
+                    const err = new Error(`fallback ${fallbackOutcome}`);
+                    if (fallbackOutcome === 'abort') controller.abort(err);
+                    throw err;
+                }
+                return { content: 'http-still-disabled', toolCalls: [], usage: {} };
+            },
+        };
+
+        await assert.rejects(
+            provider.send([], 'gpt-5.5', [], opts),
+            fallbackOutcome === 'abort'
+                ? (err) => err === controller.signal.reason && err.message === 'fallback abort'
+                : /WS retries exhausted/,
+        );
+        assert.equal(
+            provider._httpFallbackUntilByPoolKey.get(opts.sessionId),
+            Number.POSITIVE_INFINITY,
+        );
+        if (fallbackOutcome === 'abort') opts.signal = null;
+        assert.equal((await provider.send([], 'gpt-5.5', [], opts)).content, 'http-still-disabled');
+        assert.equal(wsCalls, 1);
+        assert.equal(httpCalls, 2);
+    });
+}
+
+for (const fallbackPath of ['primary', 'auth-retry']) {
+    for (const exposed of ['text', 'tool']) {
+        test(`HTTP ${fallbackPath} fallback failure after ${exposed} overrides stale WS error`, async () => {
+            const provider = new OpenAIOAuthProvider({});
+            let refreshes = 0;
+            provider.ensureAuth = async ({ forceRefresh = false } = {}) => {
+                if (forceRefresh) refreshes += 1;
+                return { access_token: forceRefresh ? 'refreshed-token' : 'test-token' };
+            };
+            let wsCalls = 0;
+            const stale = Object.assign(new Error(`stale ${fallbackPath} WS failure`), {
+                retryClassifier: 'reset',
+                wsRetriesExhausted: true,
+            });
+            const exposedFailure = Object.assign(new Error(`HTTP fallback failed after ${exposed}`), {
+                unsafeToRetry: true,
+                ...(exposed === 'text'
+                    ? { liveTextEmitted: true }
+                    : { emittedToolCall: true }),
+            });
+
+            await assert.rejects(
+                provider.send([], 'gpt-5.5', [], {
+                    sessionId: `http-${fallbackPath}-${exposed}-failure`,
+                    _prebuiltBody: { model: 'gpt-5.5', input: [] },
+                    _sendViaWebSocketFn: async () => {
+                        wsCalls += 1;
+                        if (fallbackPath === 'auth-retry' && wsCalls === 1) {
+                            throw Object.assign(new Error('refresh auth'), { httpStatus: 401 });
+                        }
+                        throw stale;
+                    },
+                    _sendViaHttpSseFn: async () => {
+                        throw exposedFailure;
+                    },
+                }),
+                (err) => err === exposedFailure
+                    && err.unsafeToRetry === true
+                    && (exposed === 'text'
+                        ? err.liveTextEmitted === true
+                        : err.emittedToolCall === true),
+            );
+            assert.equal(wsCalls, fallbackPath === 'auth-retry' ? 2 : 1);
+            assert.equal(refreshes, fallbackPath === 'auth-retry' ? 1 : 0);
+        });
+    }
+}
+
 test('sticky HTTP fallback is isolated by session and expired entries are cleaned', async () => {
     const savedEnv = Object.fromEntries([
         'MIXDOG_OAI_TRANSPORT',
@@ -425,3 +750,65 @@ test('post-emission 1006 refuses replay after text or tool output', async () =>
         assert.equal(acquires, 1, `${emitted} must prevent a replay`);
     }
 });
+
+test('partial reasoning or tool generation refuses WS replay', async () => {
+    for (const partial of ['emittedReasoning', 'startedToolCall']) {
+        let acquires = 0;
+        await assert.rejects(
+            sendViaWebSocket(wsArgs({
+                poolKey: `openai-oauth-ws-1006-${partial}-test`,
+                _acquireWithRetryFn: async () => {
+                    acquires += 1;
+                    return { entry: entry(), reused: false };
+                },
+                _streamFn: async ({ state }) => {
+                    state[partial] = true;
+                    throw close1006();
+                },
+            })),
+            (err) => err.wsCloseCode === 1006
+                && err.unsafeToRetry === true
+                && (partial === 'emittedReasoning'
+                    ? err.partialReasoningEmitted === true
+                    : err.partialToolCallStarted === true),
+        );
+        assert.equal(acquires, 1, `${partial} must prevent a replay`);
+    }
+});
+
+test('HTTP request transport retries match Codex count/backoff and exclude 429', async () => {
+    const delays = [];
+    let calls = 0;
+    await assert.rejects(
+        sendViaHttpSse({
+            auth: { access_token: 'test-token' },
+            body: { model: 'gpt-5.5', input: [] },
+            fetchFn: async () => {
+                calls += 1;
+                return new Response('busy', { status: 503 });
+            },
+            _sleepFn: async (ms) => { delays.push(ms); },
+        }),
+        /503/,
+    );
+    assert.equal(calls, 5, 'four retries plus the initial request');
+    assert.equal(delays.length, 4);
+    for (const [index, base] of [200, 400, 800, 1600].entries()) {
+        assert.ok(delays[index] >= base * 0.9 && delays[index] <= base * 1.1);
+    }
+
+    calls = 0;
+    await assert.rejects(
+        sendViaHttpSse({
+            auth: { access_token: 'test-token' },
+            body: { model: 'gpt-5.5', input: [] },
+            fetchFn: async () => {
+                calls += 1;
+                return new Response('limited', { status: 429 });
+            },
+            _sleepFn: async () => assert.fail('429 must not retry'),
+        }),
+        /429/,
+    );
+    assert.equal(calls, 1);
+});