mixdog 0.9.52 → 0.9.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.52",
+  "version": "0.9.54",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

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/bench-run.mjs

@@ -336,7 +336,7 @@ function averageCards(cards) {
 // ---- main ----
 const tasksPath = argValue('--tasks', null);
 if (!tasksPath) {
-  console.error('usage: --tasks <tasks.json> [--round N] [--runner mixdog] [--provider P] [--model M] [--effort E] [--fast] [--save round.json] [--json]');
+  console.error('usage: --tasks <tasks.json> [--round N] [--runner mixdog|codex|lead] [--provider P] [--model M] [--effort E] [--fast] [--save round.json] [--json]');
   process.exit(1);
 }
 if (!existsSync(resolve(tasksPath))) { console.error(`tasks file not found: ${tasksPath}`); process.exit(1); }
@@ -345,7 +345,7 @@ if (!Array.isArray(tasks) || !tasks.length) { console.error('tasks.json must be
 
 const runnerName = argValue('--runner', 'mixdog');
 const runner = RUNNERS[runnerName];
-if (!runner) { console.error(`unknown runner "${runnerName}" (mixdog|codex|claude)`); process.exit(1); }
+if (!runner) { console.error(`unknown runner "${runnerName}" (mixdog|codex|lead)`); process.exit(1); }
 const round = argValue('--round', '1');
 const savePath = argValue('--save', null);
 const jsonMode = hasFlag('--json');

package/scripts/compact-pressure-test.mjs

@@ -22,6 +22,8 @@ import { initialCompactionConfig } from '../src/runtime/agent/orchestrator/sessi
 import { resolveSessionCompactionPolicy } from '../src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs';
 import { sendWithRecovery } from '../src/runtime/agent/orchestrator/session/send-with-recovery.mjs';
 import { recallFastTrackCompactMessages } from '../src/runtime/agent/orchestrator/session/compact/engine.mjs';
+import { _combineUsageWithWarmup } from '../src/runtime/agent/orchestrator/providers/openai-ws-events.mjs';
+import { applyAskTerminalUsageTotals } from '../src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs';
 
 function policyFor(session) {
     return resolveWorkerCompactPolicy(session, []);
@@ -626,6 +628,108 @@ test('thinking-only continuation without assistant replay excludes provider outp
     }), false, 'unreplayed thinking output must not cause an early compact');
 });
 
+test('OpenAI OAuth WS warmup remains billed but does not double the main context footprint', async () => {
+    const main = {
+        inputTokens: 167_635,
+        outputTokens: 611,
+        cachedTokens: 160_000,
+        promptTokens: 167_635,
+        raw: {},
+    };
+    const usage = _combineUsageWithWarmup(main, main, { separateMainContext: true });
+    assert.equal(usage.inputTokens, 335_270, 'billing usage must retain warmup plus main input');
+    const { initProviders, getProvider } = await import('../src/runtime/agent/orchestrator/providers/registry.mjs');
+    const { createSession, askSession, getSession } = await import('../src/runtime/agent/orchestrator/session/manager.mjs');
+    await initProviders({ 'openai-oauth': { enabled: true } });
+    const provider = getProvider('openai-oauth');
+    const originalSend = provider.send;
+    const compactEvents = [];
+    provider.send = async () => ({ content: 'done', usage });
+    try {
+        const session = createSession({
+            provider: 'openai-oauth',
+            model: 'warmup-context-regression',
+            tools: [],
+            cwd: process.cwd(),
+            skipAgentRules: true,
+            skipSkills: true,
+            compaction: { auto: true },
+        });
+        session.contextWindow = 272_000;
+        session.rawContextWindow = 272_000;
+        await askSession(session.id, 'large OAuth WebSocket request', null, null, process.cwd(), null, {
+            onCompactEvent: event => compactEvents.push(event),
+        });
+
+        const persisted = getSession(session.id);
+        const policy = { ...policyFor(persisted), reserveTokens: 0 };
+        const messageTokens = estimateMessagesTokens(persisted.messages);
+        const pressure = resolveCompactionPressureTokens(messageTokens, policy, {
+            messages: persisted.messages,
+            sessionRef: persisted,
+        });
+        assert.equal(persisted.totalInputTokens, 335_270, 'incremental lifetime totals must retain warmup billing');
+        assert.equal(persisted.lastContextTokens, 167_635, 'incremental context snapshot must exclude warmup');
+        assert.equal(persisted.contextPressureBaselineTokens, 168_246, 'stored baseline must use main request usage');
+        assert.equal(pressure, 168_246, 'resolved pressure must use the stored baseline without transcript growth');
+        assert.equal(policy.triggerTokens, 258_400, 'fixture trigger must match the reported premature-compaction threshold');
+        assert.equal(shouldCompactForSession(messageTokens, policy, {
+            messages: persisted.messages,
+            sessionRef: persisted,
+            pressureTokens: pressure,
+        }), false, 'main-request pressure must not trigger compaction');
+        assert.equal(compactEvents.length, 0, 'warmup must not cause an auto-compaction');
+    } finally {
+        provider.send = originalSend;
+    }
+});
+
+test('warmup-only OpenAI OAuth WS usage stays billable but invalidates context usage', () => {
+    const warmup = { inputTokens: 167_635, outputTokens: 611, cachedTokens: 160_000, promptTokens: 167_635 };
+    const usage = _combineUsageWithWarmup(null, warmup, { separateMainContext: true });
+    const session = { provider: 'openai-oauth', contextPressureBaselineTokens: 99_000 };
+    assert.equal(usage.mainUsageAvailable, false);
+    assert.equal(recordProviderContextBaseline(session, [], usage), false);
+    assert.equal(session.contextPressureBaselineTokens, null, 'warmup-only usage must not remain a provider baseline');
+    applyAskTerminalUsageTotals(session, { usage, lastTurnUsage: usage });
+    assert.equal(session.totalInputTokens, 167_635, 'warmup-only usage remains billable');
+    assert.equal(session.lastContextTokens, null, 'warmup-only usage has no main-request context snapshot');
+});
+
+test('xAI warmup remains billable while main usage alone drives context pressure', () => {
+    const actual = { inputTokens: 20, outputTokens: 2, cachedTokens: 5, promptTokens: 20, raw: { provider: 'xai', cost_in_usd_ticks: 200 } };
+    const warmup = { inputTokens: 10, outputTokens: 1, cachedTokens: 3, promptTokens: 10, raw: { phase: 'warmup', cost_in_usd_ticks: 100 } };
+    const usage = _combineUsageWithWarmup(actual, warmup, { separateMainContext: true });
+    assert.deepEqual(usage, {
+        ...actual,
+        inputTokens: 30,
+        outputTokens: 3,
+        cachedTokens: 8,
+        promptTokens: 30,
+        warmupInputTokens: 10,
+        warmupCachedTokens: 3,
+        warmupOutputTokens: 1,
+        warmupPromptTokens: 10,
+        warmupCacheWriteTokens: 0,
+        raw: {
+            provider: 'xai',
+            cost_in_usd_ticks: 300,
+            warmup_usage: { phase: 'warmup', cost_in_usd_ticks: 100 },
+        },
+        mainInputTokens: 20,
+        mainOutputTokens: 2,
+        mainCachedTokens: 5,
+        mainPromptTokens: 20,
+        mainCacheWriteTokens: 0,
+        mainUsageAvailable: true,
+    });
+    const session = { provider: 'xai', contextPressureBaselineTokens: null };
+    assert.equal(recordProviderContextBaseline(session, [], usage), true);
+    applyAskTerminalUsageTotals(session, { usage, lastTurnUsage: usage });
+    assert.equal(session.totalInputTokens, 30, 'lifetime total includes xAI warmup');
+    assert.equal(session.lastContextTokens, 20, 'context snapshot excludes xAI warmup');
+});
+
 test('successful compact invalidates stale usage and cannot immediately compact again', () => {
     const session = { provider: 'openai', contextWindow: 100_000, compaction: {} };
     const policy = { ...policyFor(session), reserveTokens: 0 };