mixdog 0.9.53 → 0.9.54

package/scripts/gemini-provider-test.mjs

@@ -427,7 +427,7 @@ test('Gemini function-response media is nested, referenced, and MIME-safe', () =
 });
 
 test('Gemini global cache accepts a fresh default-five-minute entry', () => {
-    assert.ok(GEMINI_GLOBAL_CACHE_MIN_LIVE_MS < 5 * 60_000);
+    assert.equal(GEMINI_GLOBAL_CACHE_MIN_LIVE_MS, 75_000);
     geminiGlobalCaches.clear();
     const now = Date.now();
     _setGeminiGlobalCache('k', {
@@ -437,6 +437,16 @@ test('Gemini global cache accepts a fresh default-five-minute entry', () => {
     assert.equal(_getGeminiGlobalCache('k', now)?.cacheName, 'cachedContents/fresh');
 });
 
+test('Gemini global cache rejects entries inside first-byte headroom', () => {
+    geminiGlobalCaches.clear();
+    const now = Date.now();
+    _setGeminiGlobalCache('near-expiry', {
+        cacheName: 'cachedContents/near-expiry',
+        cacheExpiresAt: now + 70_000,
+    });
+    assert.equal(_getGeminiGlobalCache('near-expiry', now), null);
+});
+
 test('Gemini cache identity includes toolConfig', () => {
     const base = {
         model: 'gemini-2.5-flash',
@@ -518,6 +528,47 @@ test('Gemini cachedContents creation carries toolConfig with the tool schema', a
     }
 });
 
+test('Gemini cachedContents creation retries transient failures within policy', async () => {
+    geminiGlobalCaches.clear();
+    let calls = 0;
+    const provider = new GeminiProvider(hermeticConfig({ fetchFn: async () => {
+        calls += 1;
+        if (calls === 1) {
+            return {
+                ok: false,
+                status: 503,
+                headers: new Headers({ 'Retry-After': '0' }),
+                async text() { return '{"error":{"message":"temporarily unavailable"}}'; },
+            };
+        }
+        return {
+            ok: true,
+            async json() {
+                return {
+                    name: 'cachedContents/retried',
+                    usageMetadata: { totalTokenCount: 3000 },
+                };
+            },
+        };
+    } }));
+    try {
+        const name = await provider._ensureGeminiCache({
+            apiKey: 'test-key',
+            model: 'gemini-2.5-flash',
+            systemInstruction: 'x'.repeat(9000),
+            contents: [
+                { role: 'user', parts: [{ text: 'prefix' }] },
+                { role: 'user', parts: [{ text: 'latest' }] },
+            ],
+            opts: { providerState: {}, iteration: 1 },
+        });
+        assert.equal(name, 'cachedContents/retried');
+        assert.equal(calls, 2);
+    } finally {
+        geminiGlobalCaches.clear();
+    }
+});
+
 test('Gemini constructor and send are network-hermetic through injected transports', async () => {
     let preconnectCalls = 0;
     let fetchCalls = 0;
@@ -849,6 +900,133 @@ test('Gemini REST EOF finalizes buffered leaked tools before classifying truncat
     assert.equal(classifyError(error), 'permanent');
 });
 
+test('Gemini REST malformed SSE is retryable corruption even before a later STOP', async () => {
+    const body = new ReadableStream({
+        start(controller) {
+            controller.enqueue(new TextEncoder().encode([
+                'data: {not-json}',
+                'data: {"candidates":[{"finishReason":"STOP"}]}',
+                '',
+            ].join('\n')));
+            controller.close();
+        },
+    });
+    const error = await consumeGeminiRestStreamResponse(
+        { body },
+        { label: 'REST corrupt SSE' },
+    ).then(() => null, (caught) => caught);
+    assert.equal(error.streamCorruption, true);
+    assert.equal(error.code, 'TRUNCATED_STREAM');
+    assert.equal(classifyError(error), 'transient');
+});
+
+test('Gemini REST already-aborted signal does not lock the response body', async () => {
+    const controller = new AbortController();
+    controller.abort(new Error('already closed'));
+    const body = new ReadableStream({ start() {} });
+    await assert.rejects(
+        consumeGeminiRestStreamResponse(
+            { body },
+            { label: 'REST pre-abort', signal: controller.signal },
+        ),
+        /already closed/,
+    );
+    assert.equal(body.locked, false);
+});
+
+test('Gemini SDK first-byte timeout cancels generation before rejecting', async () => {
+    let cancelled = false;
+    let returned = false;
+    const streamResult = {
+        stream: {
+            [Symbol.asyncIterator]() {
+                return {
+                    next() { return new Promise(() => {}); },
+                    async return() {
+                        await new Promise((resolve) => setTimeout(resolve, 10));
+                        returned = true;
+                        return { done: true };
+                    },
+                };
+            },
+        },
+    };
+    const error = await consumeGeminiSdkStream(streamResult, {
+        label: 'SDK timeout cancellation',
+        firstByteTimeoutMs: 5,
+        cancelGeneration: () => { cancelled = true; },
+    }).then(() => null, (caught) => caught);
+    assert.equal(error.code, 'EGEMINITIMEOUT');
+    assert.equal(cancelled, true);
+    assert.equal(returned, true);
+});
+
+test('Gemini SDK timeout is bounded when iterator return never settles', async () => {
+    let cancelled = false;
+    const startedAt = Date.now();
+    const streamResult = {
+        stream: {
+            [Symbol.asyncIterator]() {
+                return {
+                    next() { return new Promise(() => {}); },
+                    return() { return new Promise(() => {}); },
+                };
+            },
+        },
+        response: new Promise(() => {}),
+    };
+    const error = await consumeGeminiSdkStream(streamResult, {
+        label: 'SDK stuck cancellation',
+        firstByteTimeoutMs: 5,
+        cancellationGraceMs: 20,
+        cancelGeneration: () => { cancelled = true; },
+    }).then(() => null, (caught) => caught);
+    assert.equal(error.code, 'EGEMINITIMEOUT');
+    assert.equal(cancelled, true);
+    assert.ok(Date.now() - startedAt < 200, 'stuck iterator.return must not deadlock timeout rejection');
+});
+
+test('Gemini SDK parser errors are retryable stream corruption', async () => {
+    const parseFailure = Object.assign(
+        new Error('[GoogleGenerativeAI Error]: Error parsing JSON response: Unexpected end of JSON input'),
+        { name: 'GoogleGenerativeAIError' },
+    );
+    const streamResult = {
+        stream: {
+            [Symbol.asyncIterator]() {
+                return {
+                    async next() { throw parseFailure; },
+                    async return() { return { done: true }; },
+                };
+            },
+        },
+        response: Promise.reject(parseFailure),
+    };
+    const error = await consumeGeminiSdkStream(streamResult, {
+        label: 'SDK corrupt SSE',
+    }).then(() => null, (caught) => caught);
+    assert.equal(error.streamCorruption, true);
+    assert.equal(error.code, 'TRUNCATED_STREAM');
+    assert.equal(classifyError(error), 'transient');
+});
+
+test('Gemini native function call is retry-safe until provider dispatch', async () => {
+    const streamResult = {
+        stream: {
+            async *[Symbol.asyncIterator]() {
+                yield { candidates: [{ content: { parts: [{ functionCall: { name: 'read', args: {} } }] } }] };
+                throw Object.assign(new Error('socket reset'), { code: 'ECONNRESET' });
+            },
+        },
+    };
+    const error = await consumeGeminiSdkStream(streamResult, {
+        label: 'SDK pre-dispatch function call',
+    }).then(() => null, (caught) => caught);
+    assert.equal(error.emittedToolCall, undefined);
+    assert.equal(error.unsafeToRetry, undefined);
+    assert.equal(classifyError(error), 'transient');
+});
+
 test('Gemini SDK failure finalizes buffered leaked tools before retry-safety stamps', async () => {
     const streamResult = {
         stream: {
@@ -1051,3 +1229,220 @@ test('Gemini auth reload retries a status-coded 401 exactly once', async () => {
     assert.equal(reloads, 1);
     assert.equal(opts.providerState.gemini, undefined);
 });
+
+test('Gemini evicted cachedContent is invalidated and retried uncached', async () => {
+    geminiGlobalCaches.clear();
+    _setGeminiGlobalCache('evicted-key', {
+        cacheName: 'cachedContents/evicted',
+        cacheExpiresAt: Date.now() + 5 * 60_000,
+    });
+    let cacheChecks = 0;
+    let restCalls = 0;
+    let sdkCalls = 0;
+    const provider = new GeminiProvider(hermeticConfig({
+        fetchFn: async () => {
+            restCalls += 1;
+            return {
+                ok: false,
+                status: 404,
+                headers: new Headers(),
+                async text() {
+                    return JSON.stringify({ error: { message: 'Cached content not found', status: 'NOT_FOUND' } });
+                },
+            };
+        },
+        genAI: {
+            getGenerativeModel() {
+                return {
+                    async generateContentStream() {
+                        sdkCalls += 1;
+                        return sdkStream([{
+                            candidates: [{ content: { role: 'model', parts: [{ text: 'uncached ok' }] }, finishReason: 'STOP' }],
+                        }]);
+                    },
+                };
+            },
+        },
+    }));
+    provider._ensureGeminiCache = async ({ skipExplicitCache }) => {
+        cacheChecks += 1;
+        return skipExplicitCache ? null : 'cachedContents/evicted';
+    };
+    const opts = {
+        providerState: { gemini: { cacheName: 'cachedContents/evicted', cachePrefixContentCount: 0 } },
+    };
+    const result = await provider.send(
+        [{ role: 'user', content: 'hello' }],
+        'gemini-2.5-flash',
+        [],
+        opts,
+    );
+    assert.equal(result.content, 'uncached ok');
+    assert.equal(restCalls, 1);
+    assert.equal(sdkCalls, 1);
+    assert.equal(cacheChecks, 2);
+    assert.equal(opts.providerState.gemini, undefined);
+    assert.equal(geminiGlobalCaches.size, 0);
+});
+
+test('Gemini REST rate-limit response preserves Retry-After for request retry', async () => {
+    let calls = 0;
+    let firstCallAt = 0;
+    let secondCallAt = 0;
+    const provider = new GeminiProvider(hermeticConfig({
+        fetchFn: async () => {
+            calls += 1;
+            if (calls === 1) {
+                firstCallAt = Date.now();
+                return {
+                    ok: false,
+                    status: 429,
+                    headers: new Headers({ 'Retry-After': '0.05' }),
+                    async text() {
+                        return JSON.stringify({
+                            error: {
+                                status: 'RESOURCE_EXHAUSTED',
+                                message: 'resource exhausted; retry after the capacity window',
+                                details: [{
+                                    '@type': 'type.googleapis.com/google.rpc.RetryInfo',
+                                    retryDelay: '0s',
+                                }],
+                            },
+                        });
+                    },
+                };
+            }
+            secondCallAt = Date.now();
+            return {
+                ok: true,
+                body: new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(new TextEncoder().encode(
+                            'data: {"candidates":[{"content":{"role":"model","parts":[{"text":"retried"}]},"finishReason":"STOP"}]}\n',
+                        ));
+                        controller.close();
+                    },
+                }),
+            };
+        },
+    }));
+    provider._ensureGeminiCache = async () => 'cachedContents/live';
+    const result = await provider.send(
+        [{ role: 'user', content: 'hello' }],
+        'gemini-2.5-flash',
+        [],
+        { providerState: { gemini: { cachePrefixContentCount: 0 } } },
+    );
+    assert.equal(result.content, 'retried');
+    assert.equal(calls, 2);
+    assert.ok(secondCallAt - firstCallAt >= 40, 'Retry-After must set the retry delay');
+});
+
+test('Gemini structured RetryInfo outranks resource-exhausted permanence', async () => {
+    let calls = 0;
+    let firstCallAt = 0;
+    let secondCallAt = 0;
+    const provider = new GeminiProvider(hermeticConfig({
+        fetchFn: async () => {
+            calls += 1;
+            if (calls === 1) {
+                firstCallAt = Date.now();
+                return {
+                    ok: false,
+                    status: 429,
+                    headers: new Headers(),
+                    async text() {
+                        return JSON.stringify({
+                            error: {
+                                status: 'RESOURCE_EXHAUSTED',
+                                message: 'resource exhausted',
+                                details: [{
+                                    '@type': 'type.googleapis.com/google.rpc.RetryInfo',
+                                    retryDelay: '0.05s',
+                                }],
+                            },
+                        });
+                    },
+                };
+            }
+            secondCallAt = Date.now();
+            return {
+                ok: true,
+                body: new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(new TextEncoder().encode(
+                            'data: {"candidates":[{"content":{"role":"model","parts":[{"text":"retry-info"}]},"finishReason":"STOP"}]}\n',
+                        ));
+                        controller.close();
+                    },
+                }),
+            };
+        },
+    }));
+    provider._ensureGeminiCache = async () => 'cachedContents/live';
+    const result = await provider.send(
+        [{ role: 'user', content: 'hello' }],
+        'gemini-2.5-flash',
+        [],
+        { providerState: { gemini: { cachePrefixContentCount: 0 } } },
+    );
+    assert.equal(result.content, 'retry-info');
+    assert.equal(calls, 2);
+    assert.ok(secondCallAt - firstCallAt >= 40, 'RetryInfo.retryDelay must set the retry delay');
+});
+
+test('Gemini RESOURCE_EXHAUSTED without Retry-After remains permanent', async () => {
+    let calls = 0;
+    const provider = new GeminiProvider(hermeticConfig({
+        fetchFn: async () => {
+            calls += 1;
+            return {
+                ok: false,
+                status: 429,
+                headers: new Headers(),
+                async text() {
+                    return JSON.stringify({
+                        error: {
+                            status: 'RESOURCE_EXHAUSTED',
+                            message: 'capacity quota exhausted',
+                            details: [{ '@type': 'type.googleapis.com/google.rpc.QuotaFailure' }],
+                        },
+                    });
+                },
+            };
+        },
+    }));
+    provider._ensureGeminiCache = async () => 'cachedContents/live';
+    const error = await provider.send(
+        [{ role: 'user', content: 'hello' }],
+        'gemini-2.5-flash',
+        [],
+        { providerState: { gemini: { cachePrefixContentCount: 0 } } },
+    ).then(() => null, (caught) => caught);
+    assert.equal(calls, 1);
+    assert.equal(error.code, 'RESOURCE_EXHAUSTED');
+    assert.equal(error.geminiStatus, 'RESOURCE_EXHAUSTED');
+    assert.equal(error.details[0]['@type'], 'type.googleapis.com/google.rpc.QuotaFailure');
+    assert.equal(classifyError(error), 'permanent');
+});
+
+test('Gemini availability probe rejects an unresolved generation within its bound', async () => {
+    let receivedSignal = null;
+    const startedAt = Date.now();
+    const provider = new GeminiProvider(hermeticConfig({
+        genAI: {
+            getGenerativeModel() {
+                return {
+                    async generateContent(_input, options) {
+                        receivedSignal = options?.signal;
+                        return new Promise(() => {});
+                    },
+                };
+            },
+        },
+    }));
+    assert.equal(await provider.isAvailable(), false);
+    assert.equal(receivedSignal instanceof AbortSignal, true);
+    assert.equal(receivedSignal.aborted, true);
+    assert.ok(Date.now() - startedAt < 1_500, 'availability probe must be bounded');
+});

package/scripts/grok-oauth-refresh-race-test.mjs

@@ -26,12 +26,13 @@ after(() => {
     rmSync(root, { recursive: true, force: true });
 });
 
-function writeTokens(accessToken, refreshToken, expiresAt) {
+function writeTokens(accessToken, refreshToken, expiresAt, extra = {}) {
     writeJsonAtomicSync(tokenPath, {
         access_token: accessToken,
         refresh_token: refreshToken,
         expires_at: expiresAt,
         token_endpoint: 'https://auth.x.ai/oauth/token',
+        ...extra,
     }, { lock: true, fsyncDir: true, mode: 0o600, secret: true });
 }
 
@@ -196,3 +197,77 @@ writeFileSync(process.env.RESULT_PATH, JSON.stringify({
     assert.deepEqual(JSON.parse(readFileSync(resultPath, 'utf8')), { adopted: true, calls: 1 });
     assert.ok(statSync(tokenPath).size > 0);
 });
+
+test('refresh retries transient responses three times, preserves principal fields, and stops on invalid_client', async () => {
+    const resultPath = join(root, 'retry-policy-result');
+    writeTokens('fixture-retry-access', 'fixture-retry-refresh', Date.now() + 1_000, {
+        principal_type: 'user',
+        principal_id: 'principal-123',
+    });
+    const childSource = `
+const { writeFileSync } = await import('node:fs');
+const { GrokOAuthProvider } = await import(${JSON.stringify(moduleUrl)});
+const provider = new GrokOAuthProvider({preconnect:false});
+const bodies = [];
+let retryCalls = 0;
+globalThis.fetch = async (_url, init) => {
+  retryCalls += 1;
+  bodies.push(Object.fromEntries(init.body.entries()));
+  if (retryCalls === 1) {
+    return {ok:false,status:400,async text(){return JSON.stringify({error:'temporarily_unavailable'});}};
+  }
+  if (retryCalls === 2) {
+    return {ok:false,status:401,async text(){return '{}';}};
+  }
+  return {ok:true,status:200,async text(){return JSON.stringify({
+    access_token:'fixture-retry-new-access',
+    refresh_token:'fixture-retry-new-refresh',
+    expires_in:600
+  });}};
+};
+const refreshed = await provider.ensureAuth({forceRefresh:true});
+let terminalCalls = 0;
+globalThis.fetch = async () => {
+  terminalCalls += 1;
+  return {ok:false,status:400,async text(){return JSON.stringify({error:'invalid_client'});}};
+};
+let terminalCode = null;
+try {
+  await provider.ensureAuth({forceRefresh:true});
+} catch (error) {
+  terminalCode = error.oauthError;
+}
+writeFileSync(process.env.RESULT_PATH, JSON.stringify({
+  retryCalls,
+  bodies,
+  principalType: refreshed.principal_type,
+  principalId: refreshed.principal_id,
+  terminalCalls,
+  terminalCode
+}));
+`;
+    const child = spawn(process.execPath, ['--input-type=module', '--eval', childSource], {
+        env: {
+            ...process.env,
+            MIXDOG_DATA_DIR: root,
+            GROK_OAUTH_CREDENTIALS_PATH: tokenPath,
+            RESULT_PATH: resultPath,
+        },
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    await waitForExit(child, 'refresh retry policy child');
+    const result = JSON.parse(readFileSync(resultPath, 'utf8'));
+    assert.equal(result.retryCalls, 3);
+    assert.equal(result.terminalCalls, 1);
+    assert.equal(result.terminalCode, 'invalid_client');
+    assert.equal(result.principalType, 'user');
+    assert.equal(result.principalId, 'principal-123');
+    for (const body of result.bodies) {
+        assert.equal(body.principal_type, 'user');
+        assert.equal(body.principal_id, 'principal-123');
+        assert.equal(body.refresh_token, 'fixture-retry-refresh');
+    }
+    const persisted = JSON.parse(readFileSync(tokenPath, 'utf8'));
+    assert.equal(persisted.principal_type, 'user');
+    assert.equal(persisted.principal_id, 'principal-123');
+});

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

@@ -4,7 +4,10 @@ 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 { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
+import {
+    sendViaHttpSse,
+    _shouldUseOpenAIHttpFallback,
+} from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
 import { applyAskTerminalUsageTotals } from '../src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs';
 import {
     _clearWebSocketPoolForTest,
@@ -155,6 +158,83 @@ test('acquire timeout reconnects successfully with progress, not a terminal WS e
     }
 });
 
+test('OAuth WS-handshake HTTP 429 is terminal and cannot enter the HTTP fallback gate', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_HTTP_FALLBACK',
+        'MIXDOG_OPENAI_OAUTH_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_HTTP_FALLBACK: '1',
+        MIXDOG_OPENAI_OAUTH_WS_WARMUP: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    let acquires = 0;
+    let sleeps = 0;
+    let httpCalls = 0;
+    const provider = new OpenAIOAuthProvider({});
+    provider.ensureAuth = async () => ({ access_token: 'test-token' });
+    try {
+        await assert.rejects(
+            provider.send([], 'gpt-5.5', [], {
+                sessionId: 'openai-oauth-ws-429-test',
+                _prebuiltBody: { model: 'gpt-5.5', input: [] },
+                _sendViaWebSocketFn: async (args) => {
+                    try {
+                        return await sendViaWebSocket({
+                            ...args,
+                            _acquireWithRetryFn: async () => {
+                                acquires += 1;
+                                throw Object.assign(new Error('handshake rate limited'), { httpStatus: 429 });
+                            },
+                            _sleepFn: async () => { sleeps += 1; },
+                        });
+                    } catch (err) {
+                        // Force the provider's real exhausted-WS gate; the
+                        // OAuth predicate itself must still reject this 429.
+                        err.wsRetriesExhausted = true;
+                        throw err;
+                    }
+                },
+                _sendViaHttpSseFn: async () => {
+                    httpCalls += 1;
+                    return { content: 'must not fallback', toolCalls: [], usage: {} };
+                },
+            }),
+            (err) => err?.httpStatus === 429,
+        );
+        assert.equal(_shouldUseOpenAIHttpFallback({ httpStatus: 429, wsRetriesExhausted: true }), false);
+        assert.equal(acquires, 1, 'OAuth 429 must not consume the five-retry WS budget');
+        assert.equal(sleeps, 0, 'OAuth 429 must not schedule WS reconnect backoff');
+        assert.equal(httpCalls, 0, 'OAuth 429 must not enter HTTP/SSE fallback');
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('non-OAuth WS handshakes retain their existing 429 retry budget', async () => {
+    let acquires = 0;
+    await assert.rejects(
+        sendViaWebSocket(wsArgs({
+            traceProvider: 'xai',
+            _acquireWithRetryFn: async () => {
+                acquires += 1;
+                throw Object.assign(new Error('handshake rate limited'), { httpStatus: 429 });
+            },
+            _sleepFn: async () => {},
+        })),
+        (err) => err?.httpStatus === 429 && err?.wsRetriesExhausted === true,
+    );
+    assert.equal(acquires, 6, 'non-OAuth 429 preserves the five-retry WS budget');
+});
+
 for (const failure of ['callback error', 'callback timeout']) {
     test(`send ${failure} drops the socket and retries on a fresh one`, async () => {
         const acquires = [];

package/scripts/process-lifecycle-test.mjs

@@ -104,7 +104,7 @@ test('vanished evidence uses only old-process fields and both ledger files stay
   }
 });
 
-test('PID reuse is detected by process identity while uncertain live identity is preserved', async () => {
+test('PID reuse is detected once across a finish/rebegin while uncertain live identity is preserved', async () => {
   const root = tempRoot();
   let child;
   try {
@@ -126,7 +126,12 @@ test('PID reuse is detected by process identity while uncertain live identity is
       const name = readdirSync(paths.markerDir).find((entry) => entry.startsWith(`${child.pid}-`));
       if (name) {
         childMarker = join(paths.markerDir, name);
-        currentIdentity = JSON.parse(readFileSync(childMarker, 'utf8')).processIdentity;
+        try {
+          currentIdentity = JSON.parse(readFileSync(childMarker, 'utf8')).processIdentity;
+        } catch {
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          continue;
+        }
         if (currentIdentity?.kind === 'linux-start-ticks' || currentIdentity?.method === 'powershell') break;
       }
       await new Promise((resolve) => setTimeout(resolve, 50));
@@ -191,6 +196,12 @@ test('PID reuse is detected by process identity while uncertain live identity is
       processIdentity: currentIdentity,
     }));
     beginProcessLifecycle({ directory: root, configureReports: false });
+    assert.equal(finishProcessLifecycle('clean-shutdown', 0), true);
+    beginProcessLifecycle({ directory: root, configureReports: false });
+    const reapDeadline = Date.now() + 5000;
+    while (existsSync(reused) && Date.now() < reapDeadline) {
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
     finishProcessLifecycle('clean-shutdown', 0);
     assert.equal(entries(paths.ledger).filter((row) => row.reason === 'prior-process-vanished').length, 2);
     assert.equal(existsSync(reused), false);

package/scripts/provider-admission-scheduler-test.mjs

@@ -340,14 +340,14 @@ test('xAI legacy cache-lane knobs cannot create a secondary queue or timeout', a
     assert.deepEqual((await Promise.all([first, second])).map((item) => item.value), [0, 1]);
 });
 
-test('Anthropic providers retry request-local pre-output 429 responses', async () => {
+test('Anthropic OAuth subscription 429 fails fast while API-key 429 retries request-locally', async () => {
     const oauth = Object.create(AnthropicOAuthProvider.prototype);
     oauth.credentials = { accessToken: 'fixture', expiresAt: Date.now() + 60_000 };
     oauth.config = {};
     oauth.fastModeBetaHeaderLatched = false;
     oauth.ensureAuth = async () => oauth.credentials;
     let oauthAttempts = 0;
-    const oauthResult = await oauth.send([], 'claude-sonnet-4-5', [], {
+    await assert.rejects(oauth.send([], 'claude-sonnet-4-5', [], {
         _doRequestFn: async () => {
             oauthAttempts += 1;
             return {
@@ -364,9 +364,8 @@ test('Anthropic providers retry request-local pre-output 429 responses', async (
         _parseSSEFn: async () => ({
             content: 'oauth-ok', model: 'claude', toolCalls: [], usage: {},
         }),
-    });
-    assert.equal(oauthResult.content, 'oauth-ok');
-    assert.equal(oauthAttempts, 2);
+    }), (error) => error?.status === 429 && error?.retryAfterMs === 0);
+    assert.equal(oauthAttempts, 1);
 
     const direct = Object.create(AnthropicProvider.prototype);
     direct.name = 'anthropic';