mixdog 0.9.53 → 0.9.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.53",
+  "version": "0.9.55",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -85,6 +85,7 @@
     "bench:corpus": "node scripts/routing-corpus.mjs",
     "bench:run": "node scripts/bench-run.mjs",
     "bench:recall": "node scripts/recall-bench.mjs",
+    "bench:tui-load": "node scripts/tui-runtime-load-bench.mjs",
     "audit:models": "node scripts/model-catalog-audit.mjs",
     "patch:replay": "node scripts/patch-replay.mjs",
     "build:tui": "node scripts/build-tui.mjs",

package/scripts/agent-model-liveness-test.mjs

@@ -27,6 +27,11 @@ import { parseSSEStream } from '../src/runtime/agent/orchestrator/providers/anth
 import { _streamResponse } from '../src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs';
 import { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
 import { shouldFallbackTransport } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
+import {
+    PROVIDER_MAX_BEFORE_WARN_MS,
+    PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
+    PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS,
+} from '../src/runtime/agent/orchestrator/stall-policy.mjs';
 import {
     ProviderAdmissionScheduler,
     wrapProviderAdmission,
@@ -39,6 +44,12 @@ const policy = {
     toolRunningMs: 600_000,
 };
 
+test('OpenAI HTTP and WS semantic idle defaults share the pre-watchdog ceiling', () => {
+    assert.equal(PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS, PROVIDER_MAX_BEFORE_WARN_MS);
+    assert.equal(PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS, PROVIDER_MAX_BEFORE_WARN_MS);
+    assert.ok(PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS < 300_000);
+});
+
 function seededSnapshot(id, elapsedMs) {
     markSessionAskStart(id);
     const entry = _getRuntimeEntry(id);
@@ -436,6 +447,63 @@ function openAiHttpResponse(events) {
     };
 }
 
+test('OAuth HTTP retries refresh requesting-stage liveness for every attempt', async (t) => {
+    const id = `liveness-oauth-http-retries-${Date.now()}`;
+    t.after(() => _clearSessionRuntime(id));
+    markSessionAskStart(id);
+    const entry = _getRuntimeEntry(id);
+    const stages = [];
+    const scheduler = new ProviderAdmissionScheduler({ concurrency: 1 });
+    let fetchCalls = 0;
+
+    const provider = wrapProviderAdmission({
+        async send(_messages, _model, _tools, opts) {
+            return sendViaHttpSse({
+                auth: { type: 'openai-direct', apiKey: 'test' },
+                body: {},
+                opts: {},
+                useModel: 'gpt',
+                onStageChange: opts?.onStageChange,
+                fetchFn: async () => {
+                    fetchCalls += 1;
+                    if (fetchCalls <= 4) throw new Error('transient request failure');
+                    return openAiHttpResponse([
+                        { type: 'response.completed', response: { id: 'r1', model: 'gpt', status: 'completed', output: [] } },
+                    ]);
+                },
+                _sleepFn: async () => {},
+            });
+        },
+    }, 'liveness-oauth-http-retries', scheduler);
+    await provider.send([], 'gpt', [], {
+        onStageChange: (stage, detail) => {
+            // Set a known stale value before the real ask-session liveness
+            // update. The post-send assertion therefore fails if this callback
+            // no longer refreshes lastProgressAt.
+            entry.lastProgressAt = 1;
+            updateSessionStage(id, stage);
+            stages.push({ stage, detail, lastProgressAt: entry.lastProgressAt });
+        },
+    });
+
+    assert.equal(fetchCalls, 5);
+    // Admission emits the first requesting signal, followed by one from each
+    // HTTP attempt. Keep the total explicit so stage-only consumers cannot
+    // silently dedupe the retry heartbeats.
+    const requestingStages = stages.filter(({ stage }) => stage === 'requesting');
+    assert.equal(stages.length, 7);
+    assert.deepEqual(requestingStages.map(({ stage }) => stage), Array(6).fill('requesting'));
+    assert.ok(requestingStages.every(({ lastProgressAt }) => lastProgressAt > 1));
+    assert.equal(requestingStages[0].detail, undefined);
+    assert.deepEqual(requestingStages.slice(1).map(({ detail }) => detail), [
+        { attempt: 1, maxAttempts: 5, retry: false },
+        { attempt: 2, maxAttempts: 5, retry: true },
+        { attempt: 3, maxAttempts: 5, retry: true },
+        { attempt: 4, maxAttempts: 5, retry: true },
+        { attempt: 5, maxAttempts: 5, retry: true },
+    ]);
+});
+
 function wedgedOpenAiHttpResponse() {
     return {
         ok: true,

package/scripts/anthropic-transport-policy-test.mjs

@@ -16,6 +16,26 @@ import {
 import { _midstreamSleepWithAbort, parseSSEStream } from '../src/runtime/agent/orchestrator/providers/anthropic-sse.mjs';
 import { AnthropicProvider } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
 import { AnthropicOAuthProvider } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
+import {
+    ANTHROPIC_CACHE_TTL_STABLE,
+    ANTHROPIC_CACHE_TTL_VOLATILE,
+    resolveAnthropicCacheTtls,
+} from '../src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs';
+
+test('Anthropic cache defaults keep system/tier3 stable and messages volatile', () => {
+    assert.deepEqual(resolveAnthropicCacheTtls(), {
+        tools: null,
+        system: ANTHROPIC_CACHE_TTL_STABLE,
+        tier3: ANTHROPIC_CACHE_TTL_STABLE,
+        messages: ANTHROPIC_CACHE_TTL_VOLATILE,
+    });
+    const descending = resolveAnthropicCacheTtls({
+        cacheStrategy: { system: '5m', tier3: '1h', messages: '1h' },
+    });
+    assert.equal(descending.system, ANTHROPIC_CACHE_TTL_VOLATILE);
+    assert.equal(descending.tier3, ANTHROPIC_CACHE_TTL_VOLATILE);
+    assert.equal(descending.messages, ANTHROPIC_CACHE_TTL_VOLATILE);
+});
 
 test('Anthropic transport classifier covers every 5xx, 529, and nested connection errno', () => {
     for (const status of [500, 501, 505, 529, 599]) {
@@ -110,6 +130,33 @@ test('permanent quota 429 is not retried by the generic rate-limit path', async
     assert.equal(classifyError(quota), 'permanent');
 });
 
+test('OAuth subscription 429 fails immediately without honoring Retry-After', 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;
+    oauth.scrubTokens = (text) => text;
+    let attempts = 0;
+    const limited = {
+        status: 429,
+        ok: false,
+        headers: new Map([['retry-after', '14400']]),
+        async text() { return 'subscription rate limit'; },
+    };
+    await assert.rejects(oauth.send([], 'claude-sonnet-4-6', [], {
+        _doRequestFn: async () => {
+            attempts += 1;
+            return {
+                response: limited,
+                controller: { abort() {} },
+                cancelHandler: null,
+            };
+        },
+    }), (err) => err?.status === 429 && err?.retryAfterMs === 14_400_000);
+    assert.equal(attempts, 1);
+});
+
 test('structured and nested permanent quota codes are terminal; rate-limit codes retry', async () => {
     const terminalCases = [
         Object.assign(new Error('generic 429'), { status: 429, code: 'insufficient_quota' }),
@@ -220,6 +267,191 @@ function successfulAnthropicResponse(content = 'fallback-ok') {
     };
 }
 
+function nonStreamingAnthropicMessage(content = 'replacement') {
+    return {
+        id: 'msg_fixture',
+        model: 'claude-sonnet-4-6',
+        content: [{ type: 'text', text: content }],
+        stop_reason: 'end_turn',
+        usage: { input_tokens: 2, output_tokens: 1 },
+    };
+}
+
+test('session plumbing fail-closes stream replacement and preserves unique output', { concurrency: false }, async (t) => {
+    const priorRetries = process.env.CLAUDE_CODE_MAX_RETRIES;
+    process.env.CLAUDE_CODE_MAX_RETRIES = '0';
+    try {
+        process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+        const { initProviders, getProvider } = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
+        await initProviders({ anthropic: { enabled: true, apiKey: 'fixture-key' } });
+        const provider = getProvider('anthropic');
+        const {
+            abortSessionTurn,
+            askSession,
+            createSession,
+            getSession,
+        } = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+
+        const makeDroppedResponse = () => {
+            const partial = new TextEncoder().encode([
+                { type: 'message_start', message: { model: 'claude-sonnet-4-6', usage: { input_tokens: 1 } } },
+                { type: 'content_block_start', index: 0, content_block: { type: 'text' } },
+                { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: 'partial' } },
+            ].map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));
+            let reads = 0;
+            return {
+                ok: true,
+                status: 200,
+                headers: new Map(),
+                body: { getReader: () => ({
+                    async read() {
+                        if (reads++ === 0) return { done: false, value: partial };
+                        throw Object.assign(new Error('body stream terminated'), { code: 'ECONNRESET' });
+                    },
+                    async cancel() {},
+                    releaseLock() {},
+                }) },
+            };
+        };
+        const createTestSession = () => createSession({
+            provider: 'anthropic',
+            model: 'claude-sonnet-4-6',
+            tools: [],
+            cwd: process.cwd(),
+            skipAgentRules: true,
+            skipSkills: true,
+            compaction: { auto: false },
+        });
+        const partialsInHistory = (session) => session.messages.filter((message) => (
+            message.role === 'assistant' && message.content === 'partial'
+        )).length;
+        const runCase = async ({ reset, restartFails = false, cancelRestart = false }) => {
+            const session = createTestSession();
+            let calls = 0;
+            let visible = '';
+            let markRestartEntered;
+            const restartEntered = new Promise((resolve) => { markRestartEntered = resolve; });
+            provider.client = { messages: { create(params, requestOptions = {}) {
+                calls += 1;
+                if (params.stream === false) {
+                    if (restartFails) throw new Error('non-streaming restart failed');
+                    if (cancelRestart) {
+                        markRestartEntered();
+                        return new Promise((_resolve, reject) => {
+                            const signal = requestOptions.signal;
+                            const rejectFromAbort = () => reject(
+                                signal?.reason instanceof Error
+                                    ? signal.reason
+                                    : new Error('non-streaming restart canceled'),
+                            );
+                            if (signal?.aborted) rejectFromAbort();
+                            else signal?.addEventListener('abort', rejectFromAbort, { once: true });
+                        });
+                    }
+                    return Promise.resolve(nonStreamingAnthropicMessage('replacement'));
+                }
+                return { asResponse: async () => makeDroppedResponse() };
+            } } };
+            const options = {
+                onTextDelta: (chunk) => { visible += chunk; },
+                ...(reset ? {
+                    onTextReset: async ({ chars }) => reset({
+                        chars,
+                        getVisible: () => visible,
+                        setVisible: (value) => { visible = value; },
+                    }),
+                } : {}),
+            };
+            const asking = askSession(
+                session.id,
+                'fixture prompt',
+                null,
+                null,
+                process.cwd(),
+                null,
+                options,
+            );
+            if (cancelRestart) {
+                await restartEntered;
+                assert.equal(abortSessionTurn(session.id, 'user-cancel'), true);
+            }
+            const outcome = await asking.then(
+                (result) => ({ result }),
+                (error) => ({ error }),
+            );
+            return {
+                ...outcome,
+                calls,
+                visible,
+                session: getSession(session.id),
+            };
+        };
+
+        for (const [name, reset] of [
+            ['absent acknowledgment', null],
+            ['false acknowledgment', async () => false],
+            ['throwing acknowledgment', async () => { throw new Error('reset failed'); }],
+        ]) {
+            await t.test(name, async () => {
+                const outcome = await runCase({ reset });
+                assert.match(outcome.error?.message || '', /body stream terminated/);
+                assert.equal(outcome.calls, 1, 'must not start non-streaming request');
+                assert.equal(outcome.visible, 'partial');
+                assert.equal(partialsInHistory(outcome.session), 1);
+            });
+        }
+
+        await t.test('late positive acknowledgment is awaited before one replacement', async () => {
+            const outcome = await runCase({
+                reset: async ({ chars, getVisible, setVisible }) => {
+                    await new Promise((resolve) => setTimeout(resolve, 15));
+                    setVisible(getVisible().slice(0, -chars));
+                    return true;
+                },
+            });
+            assert.equal(outcome.error, undefined);
+            assert.equal(outcome.calls, 2);
+            assert.equal(outcome.visible, '');
+            assert.equal(outcome.result.content, 'replacement');
+            assert.equal(outcome.session.messages.filter((message) => (
+                message.role === 'assistant' && message.content === 'replacement'
+            )).length, 1);
+            assert.equal(partialsInHistory(outcome.session), 0);
+        });
+
+        await t.test('failed restart restores one partial to interruption history', async () => {
+            const outcome = await runCase({
+                restartFails: true,
+                reset: async ({ chars, getVisible, setVisible }) => {
+                    setVisible(getVisible().slice(0, -chars));
+                    return true;
+                },
+            });
+            assert.match(outcome.error?.message || '', /non-streaming restart failed/);
+            assert.equal(outcome.calls, 2);
+            assert.equal(outcome.visible, '', 'acknowledged consumer keeps the tombstone');
+            assert.equal(partialsInHistory(outcome.session), 1, 'history restores exactly one exposed partial');
+        });
+
+        await t.test('cancellation during restart restores the partial before finalization', async () => {
+            const outcome = await runCase({
+                cancelRestart: true,
+                reset: async ({ chars, getVisible, setVisible }) => {
+                    setVisible(getVisible().slice(0, -chars));
+                    return true;
+                },
+            });
+            assert.equal(outcome.error?.name, 'SessionClosedError');
+            assert.equal(outcome.calls, 2);
+            assert.equal(outcome.visible, '', 'acknowledged consumer keeps the tombstone');
+            assert.equal(partialsInHistory(outcome.session), 1, 'cancel history preserves exactly one partial');
+        });
+    } finally {
+        if (priorRetries == null) delete process.env.CLAUDE_CODE_MAX_RETRIES;
+        else process.env.CLAUDE_CODE_MAX_RETRIES = priorRetries;
+    }
+});
+
 test('OAuth and API-key providers switch to the opt-in fallback after three 529s', async () => {
     const priorRetries = process.env.CLAUDE_CODE_MAX_RETRIES;
     process.env.CLAUDE_CODE_MAX_RETRIES = '2';
@@ -359,6 +591,34 @@ test('x-should-retry false vetoes retry before status defaults', async () => {
     }
 });
 
+test('Anthropic x-should-retry true overrides a normally terminal status only for Anthropic', async () => {
+    for (const provider of ['anthropic', 'gemini']) {
+        let attempts = 0;
+        const result = await withRetry(async () => {
+            attempts += 1;
+            if (attempts === 1) {
+                throw Object.assign(new Error('bad request with server override'), {
+                    status: 400,
+                    headers: new Map([['x-should-retry', 'true']]),
+                });
+            }
+            return 'recovered';
+        }, {
+            provider,
+            maxAttempts: 2,
+            backoffMs: [0],
+            retryJitterRatio: 0,
+        }).then((value) => value, (error) => error);
+        if (provider === 'anthropic') {
+            assert.equal(result, 'recovered');
+            assert.equal(attempts, 2);
+        } else {
+            assert.equal(result?.status, 400);
+            assert.equal(attempts, 1);
+        }
+    }
+});
+
 test('Retry-After is not capped or jittered and remains abortable', async () => {
     const ac = new AbortController();
     let observed;

package/scripts/desktop-session-bridge-test.mjs

@@ -4,6 +4,7 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, unl
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
 
 import {
   _normalizeSummaryIndex,
@@ -23,9 +24,55 @@ import {
   markSessionClosed,
   saveSession,
   saveSessionAsync,
+  saveSessionAsyncDeferred,
   setLiveSession,
 } from '../src/runtime/agent/orchestrator/session/store.mjs';
 
+test('deferred terminal save is registered for immediate exit drain', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-deferred-terminal-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = root;
+  try {
+    const session = {
+      id: 'deferred_terminal_exit',
+      owner: 'user',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      messages: [{ role: 'assistant', content: 'terminal state' }],
+    };
+    const pending = saveSessionAsyncDeferred(session);
+    drainSessionStore();
+    await pending;
+    assert.equal(loadSession(session.id)?.messages?.[0]?.content, 'terminal state');
+  } finally {
+    drainSessionStore();
+    if (previousDataDir == null) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('exit drain writes deferred terminal state after an older worker-pending save', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-deferred-order-'));
+  try {
+    const storeUrl = new URL('../src/runtime/agent/orchestrator/session/store.mjs', import.meta.url).href;
+    const output = execFileSync(process.execPath, ['--input-type=module', '-e', `
+      process.env.MIXDOG_DATA_DIR = ${JSON.stringify(root)};
+      const { saveSessionAsync, saveSessionAsyncDeferred, drainSessionStore, loadSession } = await import(${JSON.stringify(storeUrl)});
+      const base = { id: 'deferred_order_exit', owner: 'user', createdAt: Date.now(), updatedAt: Date.now() };
+      saveSessionAsync({ ...base, messages: [{ role: 'assistant', content: 'older worker snapshot' }], padding: 'x'.repeat(2_000_000) }).catch(() => {});
+      const terminal = saveSessionAsyncDeferred({ ...base, updatedAt: Date.now() + 1, messages: [{ role: 'assistant', content: 'newest terminal snapshot' }] });
+      drainSessionStore();
+      await Promise.allSettled([terminal]);
+      process.stdout.write(loadSession(base.id)?.messages?.[0]?.content || '');
+      process.exit(0);
+    `], { encoding: 'utf8' });
+    assert.equal(output, 'newest terminal snapshot');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('desktop classification is optional and round-trips through the existing summary index', () => {
   const task = _sessionSummary({
     id: 'lead_task',