mixdog 0.9.47 → 0.9.50

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

@@ -2,7 +2,8 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { OpenAIOAuthProvider } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
-import { sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
+import { _acquireWithRetry, sendViaWebSocket } from '../src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs';
+import { _sendFrame } from '../src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs';
 
 function close1006() {
     const err = new Error('WebSocket closed abnormally');
@@ -27,28 +28,153 @@ function wsArgs(overrides = {}) {
     };
 }
 
+test('acquire timeout reconnects successfully with progress, not a terminal WS error', async () => {
+    const oldWrite = process.stderr.write;
+    const oldQuiet = process.env.MIXDOG_QUIET_PROVIDER_LOG;
+    let stderr = '';
+    let attempts = 0;
+    const stages = [];
+    try {
+        delete process.env.MIXDOG_QUIET_PROVIDER_LOG;
+        process.stderr.write = (chunk) => {
+            stderr += String(chunk);
+            return true;
+        };
+        const result = await sendViaWebSocket(wsArgs({
+            onStageChange: (stage, detail) => stages.push({ stage, detail }),
+            _acquireWithRetryFn: (opts) => _acquireWithRetry({
+                ...opts,
+                maxAttempts: 2,
+                _sleepFn: async () => {},
+                _acquire: async () => {
+                    attempts += 1;
+                    if (attempts === 1) {
+                        throw Object.assign(new Error('OpenAI OAuth WS acquire timed out before open'), {
+                            code: 'EWSACQUIRETIMEOUT',
+                        });
+                    }
+                    return { entry: entry(), reused: false };
+                },
+            }),
+            _streamFn: async () => ({
+                content: 'recovered',
+                model: 'gpt-5.5',
+                toolCalls: [],
+                usage: {},
+                closeSocket: true,
+            }),
+        }));
+        assert.equal(result.content, 'recovered');
+        assert.equal(attempts, 2);
+        assert.deepEqual(
+            stages.filter(({ stage }) => stage === 'reconnecting'),
+            [{ stage: 'reconnecting', detail: {
+                attempt: 1,
+                max: 1,
+                classifier: 'acquire_timeout',
+                message: 'Reconnecting... 1/1',
+            } }],
+        );
+        assert.doesNotMatch(stderr, /Reconnecting/);
+        assert.doesNotMatch(stderr, /acquire timed out|handshake failed|terminal/i);
+    } finally {
+        process.stderr.write = oldWrite;
+        if (oldQuiet == null) delete process.env.MIXDOG_QUIET_PROVIDER_LOG;
+        else process.env.MIXDOG_QUIET_PROVIDER_LOG = oldQuiet;
+    }
+});
+
+for (const failure of ['callback error', 'callback timeout']) {
+    test(`send ${failure} drops the socket and retries on a fresh one`, async () => {
+        const acquires = [];
+        const sockets = [];
+        let acquireIndex = 0;
+        const result = await sendViaWebSocket(wsArgs({
+            _acquireWithRetryFn: async (opts) => {
+                acquires.push(opts.forceFresh);
+                const isFirst = acquireIndex++ === 0;
+                const socket = {
+                    readyState: 1,
+                    terminated: false,
+                    send(_payload, callback) {
+                        if (!isFirst) queueMicrotask(() => callback());
+                        else if (failure === 'callback error') {
+                            queueMicrotask(() => callback(new Error('write failed')));
+                        }
+                    },
+                    terminate() {
+                        this.terminated = true;
+                        this.readyState = 3;
+                    },
+                    close() {
+                        this.readyState = 3;
+                    },
+                };
+                sockets.push(socket);
+                return { entry: { socket }, reused: false };
+            },
+            _sendFrameFn: (wsEntry, frame, span) => _sendFrame(wsEntry, frame, span, 10),
+            _streamFn: async () => ({
+                content: 'recovered',
+                model: 'gpt-5.5',
+                toolCalls: [],
+                usage: {},
+                closeSocket: true,
+            }),
+        }));
+
+        assert.equal(result.content, 'recovered');
+        assert.deepEqual(acquires, [false, true]);
+        assert.equal(sockets[0].terminated, true);
+        assert.notEqual(sockets[1], sockets[0]);
+    });
+}
+
 test('pre-response 1006 opens a fresh WS and replays the same request', async () => {
     const acquires = [];
     const frames = [];
+    const stages = [];
+    let stderr = '';
+    const oldWrite = process.stderr.write;
     let streams = 0;
-    const result = await sendViaWebSocket(wsArgs({
-        _acquireWithRetryFn: async (opts) => {
-            acquires.push(opts.forceFresh);
-            return { entry: entry(), reused: false };
-        },
-        _sendFrameFn: async (_entry, frame) => { frames.push(frame); },
-        _streamFn: async () => {
-            streams += 1;
-            if (streams === 1) throw close1006();
-            return { content: 'recovered', model: 'gpt-5.5', toolCalls: [], usage: {}, closeSocket: true };
-        },
-    }));
+    let result;
+    try {
+        process.stderr.write = (chunk) => {
+            stderr += String(chunk);
+            return true;
+        };
+        result = await sendViaWebSocket(wsArgs({
+            onStageChange: (stage, detail) => stages.push({ stage, detail }),
+            _acquireWithRetryFn: async (opts) => {
+                acquires.push(opts.forceFresh);
+                return { entry: entry(), reused: false };
+            },
+            _sendFrameFn: async (_entry, frame) => { frames.push(frame); },
+            _streamFn: async () => {
+                streams += 1;
+                if (streams === 1) throw close1006();
+                return { content: 'recovered', model: 'gpt-5.5', toolCalls: [], usage: {}, closeSocket: true };
+            },
+        }));
+    } finally {
+        process.stderr.write = oldWrite;
+    }
 
     assert.equal(result.content, 'recovered');
     assert.deepEqual(acquires, [false, true], 'retry must acquire a fresh socket');
     assert.equal(frames.length, 2);
     assert.deepEqual(frames[1].input, frames[0].input, 'retry must replay the same input');
     assert.equal(result.__midstreamRetries, 1);
+    assert.deepEqual(
+        stages.filter(({ stage }) => stage === 'reconnecting'),
+        [{ stage: 'reconnecting', detail: {
+            attempt: 1,
+            max: 4,
+            classifier: 'ws_1006',
+            message: 'Reconnecting... 1/4',
+        } }],
+    );
+    assert.doesNotMatch(stderr, /mid-stream recovered|Reconnecting/);
 });
 
 test('successful iteration emits one compact send-spans row', async () => {
@@ -97,7 +223,7 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
         provider.ensureAuth = async () => ({ access_token: 'test-token' });
         let streamAttempts = 0;
         let httpCalls = 0;
-        const result = await provider.send([], 'gpt-5.5', [], {
+        const sendOpts = {
             sessionId: 'openai-oauth-ws-1006-fallback-test',
             _prebuiltBody: { model: 'gpt-5.5', input: [], prompt_cache_key: 'openai-oauth-ws-1006-fallback-test' },
             _sendViaWebSocketFn: (args) => sendViaWebSocket({
@@ -114,11 +240,14 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
                 httpCalls += 1;
                 return { content: 'http-recovered', toolCalls: [], usage: {} };
             },
-        });
+        };
+        const result = await provider.send([], 'gpt-5.5', [], sendOpts);
+        const stickyResult = await provider.send([], 'gpt-5.5', [], sendOpts);
 
         assert.equal(streamAttempts, 5, 'all bounded ws_1006 attempts must run before fallback');
-        assert.equal(httpCalls, 1);
+        assert.equal(httpCalls, 2);
         assert.equal(result.content, 'http-recovered');
+        assert.equal(stickyResult.content, 'http-recovered');
     } finally {
         for (const [name, value] of Object.entries(savedEnv)) {
             if (value == null) delete process.env[name];
@@ -127,6 +256,155 @@ test('exhausted pre-response 1006 retries reach the HTTP/SSE fallback', async ()
     }
 });
 
+test('sticky HTTP fallback is isolated by session and expired entries are cleaned', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_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_WS_WARMUP: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    try {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        const wsCalls = [];
+        const httpCalls = [];
+        let sessionAFailed = false;
+        const sendFor = (sessionId) => provider.send([], 'gpt-5.5', [], {
+            sessionId,
+            _prebuiltBody: { model: 'gpt-5.5', input: [], prompt_cache_key: sessionId },
+            _sendViaWebSocketFn: async () => {
+                wsCalls.push(sessionId);
+                if (sessionId === 'sticky-session-a' && !sessionAFailed) {
+                    sessionAFailed = true;
+                    throw Object.assign(new Error('ws retries exhausted'), {
+                        code: 'ECONNRESET',
+                        retryClassifier: 'reset',
+                        wsRetriesExhausted: true,
+                    });
+                }
+                return { content: `ws-${sessionId}`, toolCalls: [], usage: {} };
+            },
+            _sendViaHttpSseFn: async () => {
+                httpCalls.push(sessionId);
+                return { content: `http-${sessionId}`, toolCalls: [], usage: {} };
+            },
+        });
+
+        assert.equal((await sendFor('sticky-session-a')).content, 'http-sticky-session-a');
+        assert.equal((await sendFor('sticky-session-b')).content, 'ws-sticky-session-b');
+        assert.equal((await sendFor('sticky-session-a')).content, 'http-sticky-session-a');
+        assert.deepEqual(wsCalls, ['sticky-session-a', 'sticky-session-b']);
+        assert.deepEqual(httpCalls, ['sticky-session-a', 'sticky-session-a']);
+
+        provider._httpFallbackUntilByPoolKey.set('sticky-session-a', Date.now() - 1);
+        assert.equal((await sendFor('sticky-session-a')).content, 'ws-sticky-session-a');
+        assert.equal(provider._httpFallbackUntilByPoolKey.has('sticky-session-a'), false);
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('close 1000 after tool dispatch refuses WS replay and HTTP fallback', async () => {
+    const savedEnv = Object.fromEntries([
+        'MIXDOG_OAI_TRANSPORT',
+        'MIXDOG_OPENAI_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_WS_WARMUP: '0',
+        MIXDOG_AGENT_TRACE_DISABLE: '1',
+    });
+    try {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        let acquires = 0;
+        let httpCalls = 0;
+        await assert.rejects(
+            provider.send([], 'gpt-5.5', [], {
+                sessionId: 'openai-oauth-ws-1000-tool-test',
+                _prebuiltBody: { model: 'gpt-5.5', input: [], prompt_cache_key: 'openai-oauth-ws-1000-tool-test' },
+                _sendViaWebSocketFn: (args) => sendViaWebSocket({
+                    ...args,
+                    _acquireWithRetryFn: async () => {
+                        acquires += 1;
+                        return { entry: entry(), reused: false };
+                    },
+                    _sendFrameFn: async () => {},
+                    _streamFn: async ({ state }) => {
+                        state.sawResponseCreated = true;
+                        state.emittedToolCall = true;
+                        throw Object.assign(new Error('WebSocket closed normally before completion'), {
+                            wsCloseCode: 1000,
+                        });
+                    },
+                }),
+                _sendViaHttpSseFn: async () => {
+                    httpCalls += 1;
+                    return { content: 'unsafe fallback', toolCalls: [], usage: {} };
+                },
+            }),
+            (err) => err.wsCloseCode === 1000
+                && err.emittedToolCall === true
+                && err.unsafeToRetry === true,
+        );
+        assert.equal(acquires, 1);
+        assert.equal(httpCalls, 0);
+    } finally {
+        for (const [name, value] of Object.entries(savedEnv)) {
+            if (value == null) delete process.env[name];
+            else process.env[name] = value;
+        }
+    }
+});
+
+test('post-tool unknown-model errors never refresh or recursively replay', async () => {
+    for (const shape of [
+        { httpStatus: 404, message: 'not found' },
+        { message: 'model_not_found: unavailable model' },
+    ]) {
+        const provider = new OpenAIOAuthProvider({});
+        provider.ensureAuth = async () => ({ access_token: 'test-token' });
+        let wsCalls = 0;
+        let refreshCalls = 0;
+        provider._refreshModelCache = async () => {
+            refreshCalls += 1;
+            return [];
+        };
+        const unsafe = Object.assign(new Error(shape.message), shape, {
+            emittedToolCall: true,
+            unsafeToRetry: true,
+        });
+        await assert.rejects(
+            provider.send([], 'gpt-5.5', [], {
+                sessionId: `post-tool-model-${shape.httpStatus || 'message'}`,
+                _prebuiltBody: { model: 'gpt-5.5', input: [] },
+                _sendViaWebSocketFn: async () => {
+                    wsCalls += 1;
+                    throw unsafe;
+                },
+                _sendViaHttpSseFn: async () => {
+                    throw new Error('unsafe HTTP fallback');
+                },
+            }),
+            (err) => err === unsafe,
+        );
+        assert.equal(wsCalls, 1);
+        assert.equal(refreshCalls, 0);
+    }
+});
+
 test('post-emission 1006 refuses replay after text or tool output', async () => {
     for (const emitted of ['emittedText', 'emittedToolCall']) {
         let acquires = 0;

package/scripts/patch-binary-cache-test.mjs

@@ -0,0 +1,181 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import {
+  mkdirSync, mkdtempSync, rmSync, writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  ensurePatchBinary,
+  findCachedPatchBinary,
+} from '../src/runtime/agent/orchestrator/tools/patch-binary-fetcher.mjs';
+import {
+  ensureNativePatchBinaryAvailable,
+  nativePatchBinPath,
+} from '../src/runtime/agent/orchestrator/tools/patch/native-server.mjs';
+
+const pkey = `${process.platform === 'win32' ? 'win32' : process.platform}-${process.arch}`;
+const suffix = process.platform === 'win32' ? '.exe' : '';
+
+function sha256(body) {
+  return createHash('sha256').update(body).digest('hex');
+}
+
+function makeManifest(version, body, url = `https://github.com/tribgames/mixdog/releases/download/patch-v${version}/mixdog-patch-${pkey}${suffix}`) {
+  return {
+    version,
+    assets: { [pkey]: { url, sha256: sha256(body) } },
+  };
+}
+
+function fixture(t) {
+  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-patch-cache-'));
+  const binDir = join(dataDir, 'patch-bin');
+  mkdirSync(binDir, { recursive: true });
+  t.after(() => rmSync(dataDir, { recursive: true, force: true }));
+  return {
+    dataDir,
+    binDir,
+    bin(version) {
+      return join(binDir, `mixdog-patch-${version}${suffix}`);
+    },
+    localBin: join(dataDir, 'local-build', `mixdog-patch${suffix}`),
+  };
+}
+
+function nativeOptions(f, bundledManifest, download) {
+  return {
+    dataDir: f.dataDir,
+    defaultBin: f.localBin,
+    fetcherOptions: { bundledManifest, download },
+  };
+}
+
+test('stale cached manifest and binary cannot bypass native resolution', async (t) => {
+  const f = fixture(t);
+  const oldBody = Buffer.from('old binary');
+  const bundledBody = Buffer.from('bundled binary');
+  const bundledManifest = makeManifest('2.0.0', bundledBody);
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(makeManifest('1.0.0', oldBody)));
+  writeFileSync(f.bin('1.0.0'), oldBody);
+  const options = nativeOptions(f, bundledManifest, async (_url, destination) => {
+    writeFileSync(destination, bundledBody);
+  });
+
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), null);
+  assert.equal(nativePatchBinPath(options), f.localBin);
+  assert.equal(await ensureNativePatchBinaryAvailable(options), f.bin('2.0.0'));
+});
+
+test('wrong-hash binary cannot bypass native resolution', async (t) => {
+  const f = fixture(t);
+  const expectedBody = Buffer.from('expected binary');
+  const manifest = makeManifest('2.0.0', expectedBody);
+  writeFileSync(f.bin('2.0.0'), 'wrong binary');
+  const options = nativeOptions(f, manifest, async (_url, destination) => {
+    writeFileSync(destination, expectedBody);
+  });
+
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest: manifest }), null);
+  assert.equal(nativePatchBinPath(options), f.localBin);
+  assert.equal(await ensureNativePatchBinaryAvailable(options), f.bin('2.0.0'));
+});
+
+test('exact bundled filename with the correct hash is selected', (t) => {
+  const f = fixture(t);
+  const body = Buffer.from('correct binary');
+  const manifest = makeManifest('2.0.0', body);
+  writeFileSync(f.bin('2.0.0'), body);
+
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest: manifest }), f.bin('2.0.0'));
+});
+
+test('upgrade downloads the bundled version through the network-free seam', async (t) => {
+  const f = fixture(t);
+  const oldBody = Buffer.from('old binary');
+  const newBody = Buffer.from('new binary');
+  const oldManifest = makeManifest('1.0.0', oldBody);
+  const bundledManifest = makeManifest('2.0.0', newBody);
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(oldManifest));
+  writeFileSync(f.bin('1.0.0'), oldBody);
+  let downloads = 0;
+
+  const selected = await ensurePatchBinary(f.dataDir, {
+    bundledManifest,
+    download: async (url, destination) => {
+      downloads += 1;
+      assert.equal(url, bundledManifest.assets[pkey].url);
+      writeFileSync(destination, newBody);
+    },
+  });
+
+  assert.equal(downloads, 1);
+  assert.equal(selected, f.bin('2.0.0'));
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), selected);
+});
+
+test('only a trusted, strictly newer valid cached manifest may advance policy', (t) => {
+  const f = fixture(t);
+  const bundledBody = Buffer.from('bundled binary');
+  const newerBody = Buffer.from('newer binary');
+  const bundledManifest = makeManifest('2.0.0', bundledBody);
+  const newerManifest = makeManifest('2.1.0', newerBody);
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(newerManifest));
+  writeFileSync(f.bin('2.1.0'), newerBody);
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), f.bin('2.1.0'));
+
+  newerManifest.assets[pkey].url = 'https://example.com/untrusted';
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(newerManifest));
+  writeFileSync(f.bin('2.0.0'), bundledBody);
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), f.bin('2.0.0'));
+});
+
+test('equal-version cached manifest cannot replace bundled policy', (t) => {
+  const f = fixture(t);
+  const bundledBody = Buffer.from('bundled binary');
+  const bundledManifest = makeManifest('2.0.0', bundledBody);
+  const equalManifest = makeManifest('2.0.0', Buffer.from('different binary'));
+  writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(equalManifest));
+  writeFileSync(f.bin('2.0.0'), bundledBody);
+
+  assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), f.bin('2.0.0'));
+});
+
+for (const [label, badUrl] of [
+  ['wrong release tag', `https://github.com/tribgames/mixdog/releases/download/patch-v9.9.9/mixdog-patch-${pkey}${suffix}`],
+  ['wrong platform filename', `https://github.com/tribgames/mixdog/releases/download/patch-v2.1.0/mixdog-patch-wrong-platform${suffix}`],
+]) {
+  test(`newer cached manifest with ${label} cannot replace bundled policy`, (t) => {
+    const f = fixture(t);
+    const bundledBody = Buffer.from('bundled binary');
+    const newerBody = Buffer.from('newer binary');
+    const bundledManifest = makeManifest('2.0.0', bundledBody);
+    const newerManifest = makeManifest('2.1.0', newerBody, badUrl);
+    writeFileSync(join(f.binDir, 'manifest.json'), JSON.stringify(newerManifest));
+    writeFileSync(f.bin('2.0.0'), bundledBody);
+    writeFileSync(f.bin('2.1.0'), newerBody);
+
+    assert.equal(findCachedPatchBinary(f.dataDir, { bundledManifest }), f.bin('2.0.0'));
+  });
+}
+
+test('explicit native override and local cargo path retain precedence', (t) => {
+  const f = fixture(t);
+  const body = Buffer.from('cached binary');
+  const bundledManifest = makeManifest('2.0.0', body);
+  writeFileSync(f.bin('2.0.0'), body);
+  mkdirSync(join(f.dataDir, 'local-build'), { recursive: true });
+  writeFileSync(f.localBin, 'local binary');
+  const options = nativeOptions(f, bundledManifest);
+
+  assert.equal(nativePatchBinPath(options), f.localBin);
+  const previous = process.env.MIXDOG_PATCH_NATIVE_BIN;
+  process.env.MIXDOG_PATCH_NATIVE_BIN = join(f.dataDir, 'explicit-binary');
+  try {
+    assert.equal(nativePatchBinPath(options), process.env.MIXDOG_PATCH_NATIVE_BIN);
+  } finally {
+    if (previous === undefined) delete process.env.MIXDOG_PATCH_NATIVE_BIN;
+    else process.env.MIXDOG_PATCH_NATIVE_BIN = previous;
+  }
+});

package/scripts/prompt-immediate-render-test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  cancelPromptImmediateFlush,
+  schedulePromptImmediateFlush,
+} from '../src/tui/components/prompt-input/immediate-render.mjs';
+
+test('busy prompt input cancels a pending immediate render and schedules nothing', () => {
+  const throttle = { lastAt: 90, timer: 7 };
+  const cleared = [];
+  let queued = 0;
+  let flushed = 0;
+
+  const scheduled = schedulePromptImmediateFlush({
+    throttle,
+    isSuppressed: true,
+    flush: () => { flushed += 1; },
+    now: () => 100,
+    enqueue: () => { queued += 1; },
+    clearTimer: (timer) => cleared.push(timer),
+  });
+
+  assert.equal(scheduled, false);
+  assert.equal(throttle.timer, null);
+  assert.deepEqual(cleared, [7]);
+  assert.equal(queued, 0);
+  assert.equal(flushed, 0);
+});
+
+test('idle prompt input keeps one leading and one coalesced trailing immediate render', () => {
+  const throttle = { lastAt: 0, timer: null };
+  let current = 100;
+  const queued = [];
+  const timers = [];
+  let flushed = 0;
+  const options = {
+    throttle,
+    isSuppressed: false,
+    flush: () => { flushed += 1; },
+    now: () => current,
+    enqueue: (callback) => queued.push(callback),
+    setTimer: (callback, delay) => {
+      timers.push({ callback, delay });
+      return timers.length;
+    },
+  };
+
+  assert.equal(schedulePromptImmediateFlush(options), true);
+  assert.equal(queued.length, 1);
+  queued.shift()();
+  assert.equal(flushed, 1);
+
+  current = 105;
+  assert.equal(schedulePromptImmediateFlush(options), true);
+  current = 106;
+  assert.equal(schedulePromptImmediateFlush(options), false);
+  assert.equal(timers.length, 1);
+  assert.equal(timers[0].delay, 11);
+
+  current = 116;
+  timers[0].callback();
+  assert.equal(flushed, 2);
+  assert.equal(throttle.timer, null);
+});
+
+test('a trailing immediate render is dropped if the turn becomes busy', () => {
+  const throttle = { lastAt: 100, timer: null };
+  let busy = false;
+  let timerCallback;
+  let flushed = 0;
+
+  schedulePromptImmediateFlush({
+    throttle,
+    isSuppressed: () => busy,
+    flush: () => { flushed += 1; },
+    now: () => 105,
+    setTimer: (callback) => {
+      timerCallback = callback;
+      return 1;
+    },
+  });
+  busy = true;
+  timerCallback();
+
+  assert.equal(flushed, 0);
+  assert.equal(throttle.timer, null);
+  assert.equal(cancelPromptImmediateFlush(throttle), false);
+});