mixdog 0.9.51 → 0.9.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.51",
+  "version": "0.9.52",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -57,7 +57,9 @@
     "test:shipmode": "node --test scripts/ship-mode-test.mjs",
     "test:shellhardening": "node --test scripts/shell-hardening-test.mjs scripts/shell-failure-diagnostics-test.mjs",
     "test:placeholder": "node --test scripts/compacted-placeholder-scrub-test.mjs",
-    "test:providers": "node --test scripts/provider-toolcall-test.mjs",
+    "test:providers": "node --test scripts/provider-toolcall-test.mjs scripts/provider-contract-test.mjs",
+    "test:provider-admission": "node --test scripts/provider-admission-scheduler-test.mjs",
+    "test:resource-admission": "node --test scripts/resource-admission-test.mjs",
     "test:deferred-tools": "node --test scripts/deferred-tool-loading-test.mjs",
     "test:anthropic-oauth-race": "node --test scripts/anthropic-oauth-refresh-race-test.mjs",
     "test:grok-oauth-race": "node --test scripts/grok-oauth-refresh-race-test.mjs",
@@ -72,7 +74,7 @@
     "test:release-focused": "npm run test:release-assets && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && node --test scripts/tui-transcript-perf-test.mjs",
     "test:native-edit-wire": "node --test scripts/native-edit-wire-test.mjs",
     "test:patch-binary-cache": "node --test scripts/patch-binary-cache-test.mjs",
-    "test:session": "node --test scripts/session-orphan-sweep-test.mjs",
+    "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",

package/scripts/abort-recovery-test.mjs

@@ -20,13 +20,15 @@ function makeEngine({ abortSettles = false, recoveryMs = 30 } = {}) {
   const notices = [];
   const requeued = [];
   const discardedCompletionKeys = [];
+  const abortReasons = [];
   let drainCount = 0;
   let state = { items: [], queued: [], busy: false, commandBusy: false, spinner: null, thinking: null, lastTurn: null };
   const bag = {
     runtime: {
       id: null,
       consumePendingSessionReset: () => null,
-      abort: () => {
+      abort: (reason) => {
+        abortReasons.push(reason);
         if (abortSettles) bag.set({ busy: false, spinner: null, thinking: null, lastTurn: null });
         return true;
       },
@@ -70,9 +72,23 @@ function makeEngine({ abortSettles = false, recoveryMs = 30 } = {}) {
     getDrainCount: () => drainCount,
     getRequeued: () => requeued,
     getDiscardedCompletionKeys: () => discardedCompletionKeys,
+    getAbortReasons: () => abortReasons,
   };
 }
 
+test('Esc uses Claude-compatible user-cancel and queued interrupt reasons', () => {
+  const normal = makeEngine({ abortSettles: true });
+  normal.bag.set({ busy: true });
+  normal.api.abort();
+  assert.deepEqual(normal.getAbortReasons(), ['user-cancel']);
+
+  const queued = makeEngine({ abortSettles: true });
+  queued.bag.set({ busy: true });
+  queued.bag.pending.push({ kind: 'prompt', text: 'queued redirect' });
+  queued.api.abort();
+  assert.deepEqual(queued.getAbortReasons(), ['interrupt']);
+});
+
 test('starved abort → bounded recovery hard-releases busy and re-kicks drain', async () => {
   const { api, bag, getNotices, getDrainCount } = makeEngine({ abortSettles: false, recoveryMs: 25 });
   bag.set({ busy: true, spinner: { active: true } });

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

@@ -9,6 +9,7 @@ import {
     getSessionProgressSnapshot,
     markSessionAskStart,
     markSessionStreamDelta,
+    updateSessionStage,
 } from '../src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs';
 import {
     evaluateAgentWatchdogAbort,
@@ -26,6 +27,10 @@ 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 {
+    ProviderAdmissionScheduler,
+    wrapProviderAdmission,
+} from '../src/runtime/agent/orchestrator/providers/admission-scheduler.mjs';
 
 const policy = {
     firstTransportMs: 120_000,
@@ -62,6 +67,35 @@ test('independent first transport and semantic deadlines', async (t) => {
     assert.equal(snapshot().hasVisibleProgress, false);
 });
 
+test('genuinely queued scheduler request remains outside the real watchdog clock', async (t) => {
+    const id = `liveness-admission-${Date.now()}`;
+    t.after(() => _clearSessionRuntime(id));
+    const scheduler = new ProviderAdmissionScheduler({ concurrency: 1 });
+    let releaseFirst;
+    const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
+    const provider = wrapProviderAdmission({
+        async send(_messages, _model, _tools, opts) {
+            if (opts.block) return firstGate;
+            return 'queued-ok';
+        },
+    }, 'watchdog-integration', scheduler);
+    markSessionAskStart(id);
+    const entry = _getRuntimeEntry(id);
+    entry.askStartedAt = Date.now() - 900_000;
+    entry.lastProgressAt = entry.askStartedAt;
+    const first = provider.send([], 'm', [], { block: true });
+    const second = provider.send([], 'm', [], {
+        onStageChange: (stage) => updateSessionStage(id, stage),
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(entry.modelRequestStartedAt, null);
+    assert.equal(evaluateAgentWatchdogAbort(getSessionProgressSnapshot(id), Date.now(), policy), null);
+    releaseFirst('first');
+    await first;
+    assert.equal(await second, 'queued-ok');
+    assert.ok(entry.modelRequestStartedAt >= Date.now() - 100);
+});
+
 test('status labels distinguish transport, semantic, reasoning, text, tool, and true stall', async (t) => {
     const id = `liveness-status-${Date.now()}`;
     t.after(() => _clearSessionRuntime(id));
@@ -417,6 +451,32 @@ function wedgedOpenAiHttpResponse() {
     };
 }
 
+function firstEventThenWedgedOpenAiHttpResponse() {
+    const first = encoder.encode(
+        `event: response.created\ndata: ${JSON.stringify({
+            type: 'response.created',
+            response: { id: 'r1', model: 'gpt' },
+        })}\n\n`,
+    );
+    let emitted = false;
+    return {
+        ok: true,
+        status: 200,
+        headers: new Map(),
+        body: { getReader: () => ({
+            read: () => {
+                if (!emitted) {
+                    emitted = true;
+                    return Promise.resolve({ done: false, value: first });
+                }
+                return new Promise(() => {});
+            },
+            cancel: () => new Promise(() => {}),
+            releaseLock: () => {},
+        }) },
+    };
+}
+
 test('OAuth HTTP SSE actively rejects a wedged reader on external and semantic aborts', async () => {
     const keepAlive = setInterval(() => {}, 10);
     try {
@@ -429,7 +489,7 @@ test('OAuth HTTP SSE actively rejects a wedged reader on external and semantic a
         opts: {},
         externalSignal: external.signal,
         useModel: 'gpt',
-        fetchFn: async () => wedgedOpenAiHttpResponse(),
+        fetchFn: async () => firstEventThenWedgedOpenAiHttpResponse(),
     });
     setTimeout(() => external.abort(externalReason), 10);
     await assert.rejects(externalRun, (err) => err === externalReason);
@@ -439,7 +499,7 @@ test('OAuth HTTP SSE actively rejects a wedged reader on external and semantic a
         body: {},
         opts: { _semanticIdleTimeoutMs: 25 },
         useModel: 'gpt',
-        fetchFn: async () => wedgedOpenAiHttpResponse(),
+        fetchFn: async () => firstEventThenWedgedOpenAiHttpResponse(),
     });
     await assert.rejects(semanticRun, (err) => (
         err?.name === 'StreamStalledError'
@@ -451,6 +511,23 @@ test('OAuth HTTP SSE actively rejects a wedged reader on external and semantic a
     }
 });
 
+test('OAuth HTTP SSE enforces first server event independently of response headers', async () => {
+    const keepAlive = setInterval(() => {}, 10);
+    try {
+        const startedAt = Date.now();
+        await assert.rejects(sendViaHttpSse({
+            auth: { type: 'openai-direct', apiKey: 'test' },
+            body: {},
+            opts: { _firstServerEventTimeoutMs: 40, _semanticIdleTimeoutMs: 5 },
+            useModel: 'gpt',
+            fetchFn: async () => wedgedOpenAiHttpResponse(),
+        }), (err) => err?.code === 'EPROVIDERTIMEOUT' && err?.firstByteTimeout === true);
+        assert.ok(Date.now() - startedAt >= 30, 'semantic idle must not shorten the first-event deadline');
+    } finally {
+        clearInterval(keepAlive);
+    }
+});
+
 test('completion bundles report actual reasoning/text/tool kinds across compat, WS, and OAuth SSE', async () => {
     const output = [
         { type: 'reasoning', id: 'rs_1', encrypted_content: 'opaque', summary: [] },

package/scripts/anthropic-admission-retry-integration-test.mjs

@@ -0,0 +1,119 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { AnthropicProvider } from '../src/runtime/agent/orchestrator/providers/anthropic.mjs';
+import {
+    ProviderAdmissionScheduler,
+    wrapProviderAdmission,
+} from '../src/runtime/agent/orchestrator/providers/admission-scheduler.mjs';
+
+const encoder = new TextEncoder();
+
+function sseResponse(events, headers = new Map()) {
+    const bytes = encoder.encode(events.map((event) => (
+        `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`
+    )).join(''));
+    let sent = false;
+    return {
+        ok: true,
+        status: 200,
+        headers,
+        body: { getReader: () => ({
+            async read() {
+                if (sent) return { done: true };
+                sent = true;
+                return { done: false, value: bytes };
+            },
+            async cancel() {},
+            releaseLock() {},
+        }) },
+    };
+}
+
+test('real wrapped Anthropic retries report HTTP and SSE 429 before eventual success', async () => {
+    let now = 10_000;
+    const scheduled = [];
+    const scheduler = new ProviderAdmissionScheduler({
+        concurrency: 4,
+        now: () => now,
+        setTimer(fn, delay) {
+            const timer = { fn, delay };
+            scheduled.push(timer);
+            return timer;
+        },
+        clearTimer() {},
+    });
+
+    const provider = Object.create(AnthropicProvider.prototype);
+    provider.name = 'anthropic';
+    provider.config = { apiKey: 'fixture-key' };
+    provider.fastModeBetaHeaderLatched = false;
+    let attempts = 0;
+    provider.client = { messages: { create() {
+        attempts += 1;
+        return { async asResponse() {
+            if (attempts === 1) {
+                return {
+                    ok: false,
+                    status: 429,
+                    headers: new Map([['retry-after-ms', '7']]),
+                    async text() { return 'limited'; },
+                };
+            }
+            if (attempts === 2) {
+                return sseResponse([
+                    { type: 'error', error: { type: 'rate_limit_error', message: 'rate limit' } },
+                ], new Map([['retry-after-ms', '11']]));
+            }
+            return sseResponse([
+                { type: 'message_start', message: { model: 'claude', 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: 'ok' } },
+                { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 1 } },
+                { type: 'message_stop' },
+            ]);
+        } };
+    } } };
+
+    wrapProviderAdmission(provider, 'anthropic', scheduler);
+    const result = await provider.send([], 'claude-sonnet-4-5', [], {});
+    assert.equal(result.content, 'ok');
+    assert.equal(attempts, 3);
+
+    const lane = [...scheduler.lanes.values()][0];
+    assert.equal(lane.limit, 1, 'each internally recovered 429 adapts the lane');
+    assert.equal(lane.cooldownUntil, now + 11, 'full SSE Retry-After reaches admission');
+    assert.ok(scheduled.some((timer) => timer.delay === 7));
+});
+
+test('terminal Anthropic 429 is adapted once by admission, not provider retry notification', async () => {
+    const previous = process.env.CLAUDE_CODE_MAX_RETRIES;
+    process.env.CLAUDE_CODE_MAX_RETRIES = '0';
+    try {
+        const scheduler = new ProviderAdmissionScheduler({
+            concurrency: 4,
+            setTimer() { return { unref() {} }; },
+            clearTimer() {},
+        });
+        const provider = Object.create(AnthropicProvider.prototype);
+        provider.name = 'anthropic';
+        provider.config = { apiKey: 'fixture-key' };
+        provider.fastModeBetaHeaderLatched = false;
+        provider.client = { messages: { create() {
+            return { async asResponse() {
+                return {
+                    ok: false,
+                    status: 429,
+                    headers: new Map([['retry-after-ms', '20']]),
+                    async text() { return 'terminal'; },
+                };
+            } };
+        } } };
+        wrapProviderAdmission(provider, 'anthropic', scheduler);
+        await assert.rejects(provider.send([], 'claude-sonnet-4-5', [], {}), (err) => err?.status === 429);
+        assert.equal([...scheduler.lanes.values()][0]?.limit, 2);
+    } finally {
+        if (previous == null) delete process.env.CLAUDE_CODE_MAX_RETRIES;
+        else process.env.CLAUDE_CODE_MAX_RETRIES = previous;
+    }
+});