mixdog 0.9.52 → 0.9.54

package/scripts/freevar-smoke.mjs

@@ -20,8 +20,11 @@ import { analyze } from 'eslint-scope';
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 // Plain .mjs source roots. src/tui is covered by smoke:tui on the BUILT
 // bundle (App.jsx is JSX — acorn can't parse it raw); vendor is third-party.
-const SCAN_ROOTS = ['src/runtime', 'src/standalone', 'src/shared', 'scripts'].map(p => join(ROOT, p));
-const SKIP_DIRS = new Set(['node_modules', 'dist', '.git']);
+const SCAN_ROOTS = ['src/runtime', 'src/session-runtime', 'src/standalone', 'src/shared', 'scripts'].map(p => join(ROOT, p));
+const ROOT_RUNTIME_FACADES = readdirSync(join(ROOT, 'src'), { withFileTypes: true })
+  .filter(entry => entry.isFile() && entry.name.endsWith('.mjs'))
+  .map(entry => join(ROOT, 'src', entry.name));
+const SKIP_DIRS = new Set(['node_modules', 'dist', 'vendor', '.git']);
 
 const KNOWN_GLOBALS = new Set([
   'Array', 'ArrayBuffer', 'Atomics', 'BigInt', 'BigInt64Array', 'BigUint64Array', 'Boolean',
@@ -61,9 +64,9 @@ function* walk(dir) {
 
 let failures = 0;
 let scanned = 0;
-for (const root of SCAN_ROOTS) {
+for (const root of [...SCAN_ROOTS, ...ROOT_RUNTIME_FACADES]) {
   let files;
-  try { files = [...walk(root)]; } catch { continue; }
+  try { files = statSync(root).isDirectory() ? [...walk(root)] : [root]; } catch { continue; }
   for (const file of files) {
     scanned++;
     const source = readFileSync(file, 'utf8');

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/lifecycle-api-test.mjs

@@ -1,6 +1,10 @@
 import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import test from 'node:test';
 
+import { createConfigLifecycle } from '../src/session-runtime/config-lifecycle.mjs';
 import { createLifecycleApi } from '../src/session-runtime/lifecycle-api.mjs';
 import {
   _clearWebSocketPoolForTest,
@@ -17,7 +21,7 @@ function socket() {
   };
 }
 
-function lifecycleFor(session) {
+function lifecycleFor(session, overrides = {}) {
   let current = session;
   return createLifecycleApi({
     getSession: () => current,
@@ -45,15 +49,14 @@ function lifecycleFor(session) {
     mcpClient: { disconnectAll: () => null },
     warmupTimers: {},
     prewarmTimers: {},
-    flushConfigSave: () => {},
-    flushBackendSave: () => {},
-    flushOutputStyleSave: () => {},
+    flushAllConfigSavesAsync: async () => {},
     withTeardownDeadline: (promise) => promise,
     closePatchRuntimeIfLoaded: () => null,
     invalidateContextStatusCache: () => {},
     invalidatePreSessionToolSurface: () => {},
     notificationListeners: { clear: () => {} },
     remoteStateListeners: { clear: () => {} },
+    ...overrides,
   });
 }
 
@@ -74,3 +77,61 @@ test('lifecycle drains the OpenAI WS pool only for process exit', async () => {
 
   assert.deepEqual(retainedSocket.closed, ['cli-exit']);
 });
+
+test('lifecycle barrier drains a direct updateSectionAsync with no queued lifecycle save', async () => {
+  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-lifecycle-config-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  const previousBackupRoot = process.env.MIXDOG_USER_DATA_BACKUP_ROOT;
+  process.env.MIXDOG_DATA_DIR = dataDir;
+  process.env.MIXDOG_USER_DATA_BACKUP_ROOT = join(dataDir, 'backups');
+  const sharedCfgMod = await import(`../src/runtime/shared/config.mjs?lifecycle-tail=${Date.now()}`);
+  const configLifecycle = createConfigLifecycle({
+    getConfig: () => ({}),
+    setConfig: () => {},
+    getSearchRoute: () => null,
+    setSearchRoute: () => {},
+    getConfigHasSecrets: () => false,
+    setConfigHasSecrets: () => {},
+    getRoute: () => ({}),
+    cfgMod: {
+      saveConfigAsync: async () => {},
+      patchSkillsDisabledAsync: async () => {},
+      getPluginData: () => dataDir,
+    },
+    sharedCfgMod,
+    setBackendAsync: async () => {},
+    setConfiguredShell: () => {},
+    normalizeSystemShellConfig: () => ({ command: '' }),
+    normalizeSearchRouteConfig: () => null,
+    outputStyleStatus: () => ({}),
+    LAZY_SECRET_PROVIDERS: new Set(),
+    clean: (value) => String(value || ''),
+    resolve: (value) => value,
+    STANDALONE_DATA_DIR: dataDir,
+  });
+
+  const events = [];
+  let directSettled = false;
+  try {
+    const directWrite = sharedCfgMod.updateSectionAsync('cycle3', () => ({ value: 'direct' }))
+      .finally(() => { directSettled = true; events.push('direct:settled'); });
+    assert.equal(directSettled, false);
+
+    const lifecycle = lifecycleFor(
+      { id: 'tail-drain', messages: [], liveTurnMessages: [] },
+      {
+        flushAllConfigSavesAsync: configLifecycle.flushAllConfigSavesAsync,
+        closePatchRuntimeIfLoaded: async () => { events.push('teardown:continued'); },
+      },
+    );
+    await lifecycle.close('engine-replace');
+    await directWrite;
+    assert.deepEqual(events, ['direct:settled', 'teardown:continued']);
+  } finally {
+    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    if (previousBackupRoot == null) delete process.env.MIXDOG_USER_DATA_BACKUP_ROOT;
+    else process.env.MIXDOG_USER_DATA_BACKUP_ROOT = previousBackupRoot;
+    rmSync(dataDir, { recursive: true, force: true });
+  }
+});

package/scripts/max-output-recovery-test.mjs

@@ -118,6 +118,37 @@ test('Gemini MAX_TOKENS ProviderIncompleteError enters the same bounded recovery
     assert.equal(provider.sent[1][1].content, 'gemini ');
 });
 
+test('Gemini MAX_TOKENS recovery derives missing prompt usage from total minus output', async () => {
+    const incomplete = Object.assign(new Error('Gemini response incomplete: finishReason=MAX_TOKENS'), {
+        code: 'PROVIDER_INCOMPLETE',
+        providerIncomplete: true,
+        finishReason: 'MAX_TOKENS',
+        partialContent: 'gemini ',
+        rawUsage: {
+            total_token_count: 20,
+            candidates_token_count: 4,
+            thoughts_token_count: 1,
+        },
+    });
+    const result = await run(queuedProvider([
+        incomplete,
+        {
+            content: 'complete',
+            stopReason: 'end_turn',
+            usage: { inputTokens: 1, outputTokens: 2, promptTokens: 1 },
+        },
+    ]), undefined, { onTextDelta: () => {} });
+
+    assert.deepEqual(
+        {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            promptTokens: result.usage.promptTokens,
+        },
+        { inputTokens: 16, outputTokens: 7, promptTokens: 16 },
+    );
+});
+
 test('Gemini MAX_TOKENS continuation preserves provider-scoped replay metadata', async () => {
     const providerMetadata = {
         gemini: { thoughtParts: [{ text: 'signed thought', thoughtSignature: 'sig-gemini' }] },