mixdog 0.9.36 → 0.9.38

package/scripts/session-sweep.mjs

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+/**
+ * session-sweep.mjs — DRY-RUN ONLY session-store retention reporter.
+ *
+ * Reports which session files a prune would reclaim WITHOUT touching disk:
+ * NO unlink, NO writes to session-summaries.json, NO mutation of store.mjs
+ * runtime behavior. It only reads.
+ *
+ * Reuses the real store helpers read-only:
+ *   - getPluginData()  → resolves the live data dir (…/.mixdog/data)
+ *   - summaryIndexPath()/listStoredSessionSummaries() → authoritative
+ *     per-session lifecycle rows (updatedAt/closed/status), avoiding a full
+ *     476MB JSON.parse of every session file.
+ *
+ * Candidate policy (conservative; keep everything else):
+ *   - closed/tombstoned sessions  (row.closed === true || status === 'closed')
+ *     ONLY when their closedAt/updatedAt is older than --min-closed-age-days
+ *     (default 7d) — a recently-closed session may still be resumed, so it is
+ *     kept until the gate elapses.
+ *   - OR sessions older than --max-age-days by updatedAt (default 30d)
+ * Thresholds are params:  --max-age-days=<n>  --min-closed-age-days=<n>  --now=<epochMs>
+ *
+ * This tool NEVER deletes. It only prints a report.
+ */
+import { existsSync, readdirSync, statSync } from 'fs';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { getPluginData } from '../src/runtime/agent/orchestrator/config.mjs';
+import {
+    summaryIndexPath,
+    listStoredSessionSummaries,
+} from '../src/runtime/agent/orchestrator/session/store.mjs';
+
+// ── Cheap top-level-only scalar scan ────────────────────────────────────────
+// Same depth-1 tokenizer idea as lifecycle-scan.mjs's scanTopLevelLifecycle
+// (bracket-depth + string-escape aware; the whole `messages` array is skipped
+// by depth counting, never parsed), extended to capture the lifecycle+age
+// scalars we classify on (closed/status/updatedAt/createdAt). This lets the
+// report read the AUTHORITATIVE per-file lifecycle without a full 476MB
+// JSON.parse and without depending on the (stale) summary index.
+const WANT = new Set(['closed', 'status', 'updatedAt', 'createdAt', 'closedAt']);
+function isWs(ch) { return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r'; }
+function skipString(raw, i) {
+    const len = raw.length;
+    i++;
+    while (i < len) {
+        const ch = raw[i];
+        if (ch === '\\') { i += 2; continue; }
+        if (ch === '"') return i + 1;
+        i++;
+    }
+    return i;
+}
+function skipValue(raw, i) {
+    const len = raw.length;
+    const c = raw[i];
+    if (c === '"') return skipString(raw, i);
+    if (c === '{' || c === '[') {
+        let depth = 1; i++;
+        while (i < len && depth > 0) {
+            const ch = raw[i];
+            if (ch === '"') { i = skipString(raw, i); continue; }
+            if (ch === '{' || ch === '[') depth++;
+            else if (ch === '}' || ch === ']') depth--;
+            i++;
+        }
+        return i;
+    }
+    while (i < len && raw[i] !== ',' && raw[i] !== '}' && raw[i] !== ']' && !isWs(raw[i])) i++;
+    return i;
+}
+function scanTopLevelScalars(raw) {
+    const len = raw.length;
+    let i = 0;
+    while (i < len && isWs(raw[i])) i++;
+    if (raw[i] !== '{') return null;
+    i++;
+    const out = {};
+    while (i < len) {
+        while (i < len && isWs(raw[i])) i++;
+        if (i >= len) return out;
+        if (raw[i] === '}') return out;
+        if (raw[i] === ',') { i++; continue; }
+        if (raw[i] !== '"') return out;
+        const keyStart = i;
+        i = skipString(raw, i);
+        let key;
+        try { key = JSON.parse(raw.slice(keyStart, i)); } catch { return out; }
+        while (i < len && isWs(raw[i])) i++;
+        if (raw[i] !== ':') return out;
+        i++;
+        while (i < len && isWs(raw[i])) i++;
+        const valStart = i;
+        i = skipValue(raw, i);
+        if (WANT.has(key)) {
+            try { out[key] = JSON.parse(raw.slice(valStart, i)); } catch { /* ignore */ }
+        }
+    }
+    return out;
+}
+
+function parseArgs(argv) {
+    const out = { maxAgeDays: 30, minClosedAgeDays: 7, now: Date.now() };
+    for (const arg of argv) {
+        const m = /^--([^=]+)=(.*)$/.exec(arg);
+        if (!m) continue;
+        const [, key, val] = m;
+        if (key === 'max-age-days') out.maxAgeDays = Number(val);
+        else if (key === 'min-closed-age-days') out.minClosedAgeDays = Number(val);
+        else if (key === 'now') out.now = Number(val);
+    }
+    if (!Number.isFinite(out.maxAgeDays) || out.maxAgeDays < 0) out.maxAgeDays = 30;
+    if (!Number.isFinite(out.minClosedAgeDays) || out.minClosedAgeDays < 0) out.minClosedAgeDays = 7;
+    if (!Number.isFinite(out.now) || out.now <= 0) out.now = Date.now();
+    return out;
+}
+
+function fmtBytes(n) {
+    if (!Number.isFinite(n) || n <= 0) return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let i = 0;
+    let v = n;
+    while (v >= 1024 && i < units.length - 1) { v /= 1024; i += 1; }
+    return `${v.toFixed(i === 0 ? 0 : 2)} ${units[i]}`;
+}
+
+function fmtTs(ms) {
+    if (!Number.isFinite(ms) || ms <= 0) return 'n/a';
+    try { return new Date(ms).toISOString(); } catch { return String(ms); }
+}
+
+function main() {
+    const { maxAgeDays, minClosedAgeDays, now } = parseArgs(process.argv.slice(2));
+    const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+    const minClosedAgeMs = minClosedAgeDays * 24 * 60 * 60 * 1000;
+
+    const dir = join(getPluginData(), 'sessions');
+    if (!existsSync(dir)) {
+        process.stdout.write(`[session-sweep] no sessions dir at ${dir}\n`);
+        return;
+    }
+
+    // Authoritative lifecycle rows (read-only). rebuildIfMissing:false so this
+    // report never triggers a summary-index write.
+    const rows = listStoredSessionSummaries({ rebuildIfMissing: false });
+    const rowById = new Map();
+    for (const r of rows) if (r?.id) rowById.set(r.id, r);
+
+    // Disk scan for sizes + mtime fallback. `.hb` sidecar bytes are attributed
+    // to their session so reclaimable bytes reflect the full on-disk footprint.
+    const files = readdirSync(dir);
+    const jsonFiles = files.filter((f) => f.endsWith('.json'));
+    const hbSizeById = new Map();
+    for (const f of files) {
+        if (!f.endsWith('.hb')) continue;
+        const id = f.slice(0, -3);
+        try { hbSizeById.set(id, statSync(join(dir, f)).size || 0); } catch { /* ignore */ }
+    }
+
+    let totalFiles = 0;
+    let totalBytes = 0;
+    const candidates = []; // { id, reason, updatedAt, bytes, inIndex }
+    let closedCount = 0;
+    let ageOnlyCount = 0;
+    let closedBytes = 0;
+    let ageOnlyBytes = 0;
+    let reclaimBytes = 0;
+    let scanFailFiles = 0;
+    let closedButFreshCount = 0; // closed, but within the min-closed-age gate → kept
+    let closedButFreshBytes = 0;
+    const fileIds = new Set();
+
+    for (const f of jsonFiles) {
+        const id = f.slice(0, -5);
+        fileIds.add(id);
+        const full = join(dir, f);
+        let size = 0;
+        let mtimeMs = 0;
+        try { const st = statSync(full); size = st.size || 0; mtimeMs = st.mtimeMs || 0; } catch { /* skip */ }
+        const hb = hbSizeById.get(id) || 0;
+        const bytes = size + hb;
+        totalFiles += 1;
+        totalBytes += bytes;
+
+        const row = rowById.get(id) || null;
+        // Authoritative per-file lifecycle via cheap top-level scan; the summary
+        // index is stale here (most on-disk files are unindexed), so the file
+        // itself — not the index — decides closed/age. Fall back to the index
+        // row, then to file mtime, only when the scan can't resolve a field.
+        let scan = null;
+        try { scan = scanTopLevelScalars(readFileSync(full, 'utf-8')); } catch { scan = null; }
+        if (!scan) scanFailFiles += 1;
+        const closedScan = scan && (scan.closed === true || scan.status === 'closed');
+        const closedRow = row && (row.closed === true || row.status === 'closed');
+        const closed = scan ? !!closedScan : !!closedRow;
+        let updatedAt = scan && Number(scan.updatedAt) > 0 ? Number(scan.updatedAt) : 0;
+        if (!updatedAt && row && Number(row.updatedAt) > 0) updatedAt = Number(row.updatedAt);
+        if (!updatedAt) updatedAt = mtimeMs;
+        const ageMs = now - updatedAt;
+        // Min-closed-age gate: a closed session only qualifies once its close
+        // timestamp (closedAt when present, else updatedAt — markSessionClosed
+        // sets updatedAt=Date.now() at tombstone time) is older than the gate.
+        // Recently-closed sessions may still be resumed, so keep them.
+        const closedAt = scan && Number(scan.closedAt) > 0 ? Number(scan.closedAt) : updatedAt;
+        const closedAge = now - closedAt;
+        const closedQualifies = closed
+            && (minClosedAgeMs <= 0
+                || (Number.isFinite(closedAt) && closedAt > 0 && closedAge > minClosedAgeMs));
+        const ageOnly = !closed && maxAgeMs > 0 && Number.isFinite(updatedAt) && updatedAt > 0 && ageMs > maxAgeMs;
+
+        if (closed && !closedQualifies) {
+            closedButFreshCount += 1;
+            closedButFreshBytes += bytes;
+        }
+        if (!closedQualifies && !ageOnly) continue; // keep
+
+        const reason = closedQualifies ? 'closed' : 'age';
+        candidates.push({ id, reason, updatedAt, bytes, inIndex: !!row });
+        reclaimBytes += bytes;
+        if (closedQualifies) { closedCount += 1; closedBytes += bytes; }
+        else { ageOnlyCount += 1; ageOnlyBytes += bytes; }
+    }
+
+    candidates.sort((a, b) => (a.updatedAt || 0) - (b.updatedAt || 0));
+    const oldest = candidates[0] || null;
+    const newest = candidates[candidates.length - 1] || null;
+    const dropRows = candidates.filter((c) => c.inIndex).length;
+    const remainFiles = totalFiles - candidates.length;
+    // Rows in the index whose session file is already gone from disk — a
+    // rebuild (scans existing files only) drops these regardless of retention.
+    const staleRows = rows.filter((r) => r?.id && !fileIds.has(r.id)).length;
+    // A real prune would delete candidate files then rebuild the index from the
+    // surviving files, so the post-rebuild index equals the surviving-file count
+    // (every remaining file gets a row, including currently-unindexed ones).
+    const rebuiltIndexRows = remainFiles;
+
+    const L = [];
+    L.push('══ session-sweep DRY-RUN report (NO files deleted, NO writes) ══');
+    L.push(`data dir            : ${dir}`);
+    L.push(`summary index       : ${summaryIndexPath()} (${rows.length} rows)`);
+    L.push(`now                 : ${fmtTs(now)}`);
+    L.push(`retention (age)     : > ${maxAgeDays} days by updatedAt`);
+    L.push(`retention (closed)  : (closed=true OR status='closed') AND closed > ${minClosedAgeDays}d ago`);
+    L.push('');
+    L.push(`total session files : ${totalFiles}  (${fmtBytes(totalBytes)})`);
+    L.push(`candidates (drop)   : ${candidates.length}  (${fmtBytes(reclaimBytes)} reclaimable)`);
+    L.push(`  ├─ closed         : ${closedCount}  (${fmtBytes(closedBytes)})`);
+    L.push(`  └─ age-only >${maxAgeDays}d   : ${ageOnlyCount}  (${fmtBytes(ageOnlyBytes)})`);
+    L.push(`kept: closed <${minClosedAgeDays}d : ${closedButFreshCount}  (${fmtBytes(closedButFreshBytes)}) — within min-closed-age gate`);
+    L.push(`would remain        : ${remainFiles} files  (${fmtBytes(totalBytes - reclaimBytes)})`);
+    L.push(`oldest candidate    : ${oldest ? `${oldest.id} @ ${fmtTs(oldest.updatedAt)} [${oldest.reason}]` : 'n/a'}`);
+    L.push(`newest candidate    : ${newest ? `${newest.id} @ ${fmtTs(newest.updatedAt)} [${newest.reason}]` : 'n/a'}`);
+    if (scanFailFiles > 0) L.push(`unparsable files    : ${scanFailFiles} (fell back to index/mtime)`);
+    L.push('');
+    L.push('── summary-index rebuild plan ──');
+    L.push(`index rows total    : ${rows.length}`);
+    L.push(`stale rows (no file): ${staleRows}  (already-deleted sessions; drop on rebuild)`);
+    L.push(`candidate rows drop : ${dropRows}  (candidate files that also have an index row)`);
+    L.push(`orphan candidates   : ${candidates.length - dropRows}  (candidate file present, no index row)`);
+    L.push(`index rows after    : ${rebuiltIndexRows}  (= surviving files; rebuild reindexes all remaining)`);
+    L.push('');
+    L.push('DRY-RUN ONLY — this tool performed no unlink and no disk writes.');
+    process.stdout.write(L.join('\n') + '\n');
+}
+
+main();

package/scripts/steering-drain-buckets-test.mjs

@@ -7,6 +7,7 @@ import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
 // a valid session key). No provider/runTurn wiring needed.
 function makeFlow() {
   let seq = 0;
+  let runTurns = 0;
   const state = { queued: [], busy: false };
   const bag = {
     runtime: { id: null },
@@ -27,33 +28,93 @@ function makeFlow() {
     routeState: {},
     syncContextStats: () => {},
     flushDeferredExecutionPendingResumeKick: () => {},
+    runTurn: async () => {
+      runTurns += 1;
+      return 'done';
+    },
   };
-  return { flow: createSessionFlow(bag), bag };
+  return { flow: createSessionFlow(bag), bag, getRunTurns: () => runTurns };
 }
 
-test('drainPendingSteering empties every non-slash priority/mode bucket in one call', () => {
+test('drainPendingSteering drains prompt/next mid-turn but leaves later notifications', () => {
   const { flow, bag } = makeFlow();
-  // Concurrent user steering (prompt bucket) + task notification (its own
-  // priority/mode bucket) queued while a turn is running.
   bag.pending.push(flow.makeQueueEntry('steer the turn', { mode: 'prompt' }));
   bag.pending.push(flow.makeQueueEntry('task finished', { mode: 'task-notification', key: 'task-1' }));
 
   const out = flow.drainPendingSteering();
 
-  assert.equal(bag.pending.length, 0, 'no bucket left pending to spawn a follow-up turn');
-  assert.equal(out.length, 2, 'both buckets injected into the current turn');
-  assert.ok(out.some((v) => String(typeof v === 'string' ? v : v.text).includes('steer the turn')));
-  assert.ok(out.some((v) => String(typeof v === 'string' ? v : v.text).includes('task finished')));
+  assert.equal(out.length, 1, 'next-priority prompt is injected into the active continuation');
+  assert.equal(out[0], 'steer the turn');
+  assert.equal(bag.pending.length, 1, 'later task notification waits for post-turn or explicit later flush');
+  assert.equal(bag.pending[0].content, 'task finished');
 });
 
-test('drainPendingSteering leaves slash commands pending for the post-turn processor', () => {
+test('drainPendingSteering can explicitly flush later notifications', () => {
+  const { flow, bag } = makeFlow();
+  bag.pending.push(flow.makeQueueEntry('task finished', { mode: 'task-notification', key: 'task-1' }));
+
+  const out = flow.drainPendingSteering({ maxPriority: 'later' });
+
+  assert.equal(out.length, 1);
+  assert.equal(out[0], 'task finished');
+  assert.equal(bag.pending.length, 0);
+});
+
+test('drainPendingSteering accepts runtime callback signature', () => {
+  const { flow, bag } = makeFlow();
+  bag.pending.push(flow.makeQueueEntry('task finished', { mode: 'task-notification', key: 'task-1' }));
+
+  const out = flow.drainPendingSteering('session-id', { maxPriority: 'later' });
+
+  assert.deepEqual(out, ['task finished']);
+  assert.equal(bag.pending.length, 0);
+});
+
+test('drained notification key remains deduped and displayed key is not cleared', () => {
+  const { flow, bag } = makeFlow();
+  bag.getState().busy = true;
+  assert.equal(flow.enqueue('task finished', { mode: 'task-notification', key: 'task-1' }), true);
+  bag.displayedExecutionNotificationKeys.add('task-1');
+
+  const out = flow.drainPendingSteering({ maxPriority: 'later' });
+
+  assert.deepEqual(out, ['task finished']);
+  assert.equal(flow.enqueue('task duplicate', { mode: 'task-notification', key: 'task-1' }), false);
+  assert.equal(bag.displayedExecutionNotificationKeys.has('task-1'), true);
+});
+
+test('drainPendingSteering leaves slash commands pending', () => {
   const { flow, bag } = makeFlow();
   bag.pending.push(flow.makeQueueEntry('/clear', { mode: 'prompt' }));
   bag.pending.push(flow.makeQueueEntry('steer text', { mode: 'prompt' }));
 
   const out = flow.drainPendingSteering();
 
-  assert.equal(out.length, 1, 'only the non-slash entry drained');
-  assert.equal(bag.pending.length, 1, 'slash command stays queued');
+  assert.equal(out.length, 1, 'non-slash prompt drains');
+  assert.equal(out[0], 'steer text');
+  assert.equal(bag.pending.length, 1, 'slash command stays queued for post-turn processing');
+  assert.equal(bag.pending[0].content, '/clear');
+});
+
+test('enqueue while busy does not start a parallel Lead turn', async () => {
+  const { flow, bag, getRunTurns } = makeFlow();
+  bag.getState().busy = true;
+
+  assert.equal(flow.enqueue('scheduled message', { mode: 'task-notification' }), true);
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.equal(getRunTurns(), 0, 'busy enqueue must wait for active turn boundary');
+  assert.equal(bag.pending.length, 1, 'message remains pending for post-turn drain');
+});
+
+test('post-turn drain does not send queued slash command to model', async () => {
+  const { flow, bag, getRunTurns } = makeFlow();
+  bag.pending.push(flow.makeQueueEntry('/clear', { mode: 'prompt' }));
+
+  await flow.drain();
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.equal(getRunTurns(), 0, 'slash command must not be runTurn model text');
+  assert.equal(bag.pending.length, 1, 'slash command remains for command dispatcher');
   assert.equal(bag.pending[0].content, '/clear');
 });

package/scripts/submit-commandbusy-race-test.mjs

@@ -0,0 +1,114 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
+import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
+
+// Regression harness for prompt loss when a submit races an in-flight session
+// command (commandBusy) or an auto-clear. Wires the real session-flow queue
+// (enqueue/drain) + the real submit() against a minimal bag whose set() mirrors
+// engine.mjs's commandBusy-release drain kick.
+function makeEngine({ autoClearBeforeSubmit } = {}) {
+  let seq = 0;
+  const executed = [];
+  let state = { queued: [], busy: false, commandBusy: false };
+  const bag = {
+    runtime: { id: null, consumePendingSessionReset: () => null },
+    nextId: () => `id_${++seq}`,
+    tuiDebug: () => {},
+    flags: {},
+    pending: [],
+    listeners: new Set(),
+    pendingNotificationKeys: new Set(),
+    displayedExecutionNotificationKeys: new Set(),
+    getState: () => state,
+    set: (patch) => {
+      if (!patch || typeof patch !== 'object') return false;
+      const released = state.commandBusy === true
+        && Object.prototype.hasOwnProperty.call(patch, 'commandBusy')
+        && patch.commandBusy === false;
+      state = { ...state, ...patch };
+      if (released) queueMicrotask(() => { void bag.drain?.(); });
+      return true;
+    },
+    pushItem: () => {},
+    patchItem: () => {},
+    replaceItems: (x) => x,
+    pushNotice: () => {},
+    pushUserOrSyntheticItem: (text) => { executed.push(text); },
+    autoClearState: () => ({ enabled: false }),
+    agentStatusState: () => ({}),
+    routeState: () => ({}),
+    syncContextStats: () => {},
+    denyAllToolApprovals: () => {},
+    updateAgentJobCard: () => {},
+    requeueEntriesFront: () => {},
+    resetStatsAndSyncContext: () => {},
+    flushDeferredExecutionPendingResumeKick: () => {},
+    runTurn: async () => 'ok',
+  };
+  Object.assign(bag, createSessionFlow(bag));
+  if (autoClearBeforeSubmit) bag.autoClearBeforeSubmit = autoClearBeforeSubmit;
+  const api = createEngineApiA(bag);
+  return {
+    api,
+    bag,
+    getExecuted: () => executed,
+    getState: () => bag.getState(),
+    mutateState: (mutator) => { mutator(state); },
+  };
+}
+
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+test('submit during commandBusy queues the prompt instead of dropping it', async () => {
+  const { api, bag, getExecuted } = makeEngine();
+  bag.set({ commandBusy: true });
+  const ok = api.submit('queued while busy');
+  assert.equal(ok, true, 'submit accepted (not dropped)');
+  assert.equal(bag.pending.length, 1, 'prompt preserved in queue');
+  await tick();
+  assert.equal(getExecuted().length, 0, 'drain bails while commandBusy');
+  bag.set({ commandBusy: false });
+  await tick(); await tick();
+  assert.deepEqual(getExecuted(), ['queued while busy'], 'prompt runs after command releases');
+  assert.equal(bag.pending.length, 0);
+});
+
+test('blocked drain retries even if commandBusy is cleared outside set hook', async () => {
+  const { api, bag, getExecuted, mutateState } = makeEngine();
+  bag.set({ commandBusy: true });
+  assert.equal(api.submit('queued until direct release'), true);
+  assert.equal(bag.pending.length, 1);
+  await tick();
+  assert.equal(getExecuted().length, 0);
+
+  mutateState((state) => { state.commandBusy = false; });
+  await new Promise((r) => setTimeout(r, 80));
+  assert.deepEqual(getExecuted(), ['queued until direct release']);
+  assert.equal(bag.pending.length, 0);
+});
+
+test('idle submit runs the prompt after autoClearBeforeSubmit resolves', async () => {
+  const { api, getExecuted, bag } = makeEngine();
+  const ok = api.submit('idle prompt');
+  assert.equal(ok, true);
+  await tick(); await tick();
+  assert.deepEqual(getExecuted(), ['idle prompt']);
+  assert.equal(bag.pending.length, 0);
+});
+
+test('submit still enqueues when autoClearBeforeSubmit rejects', async () => {
+  const { api, getExecuted } = makeEngine({
+    autoClearBeforeSubmit: () => Promise.reject(new Error('compaction timed out')),
+  });
+  const ok = api.submit('survives rejection');
+  assert.equal(ok, true);
+  await tick(); await tick();
+  assert.deepEqual(getExecuted(), ['survives rejection'], 'rejected auto-clear must not lose the prompt');
+});
+
+test('empty and whitespace submits are still rejected', () => {
+  const { api, bag } = makeEngine();
+  assert.equal(api.submit('   '), false);
+  assert.equal(bag.pending.length, 0);
+});

package/scripts/tool-smoke.mjs

@@ -193,7 +193,12 @@ function assertOk(name, result, pattern = null) {
 
 {
   const prevTraceDisable = process.env.MIXDOG_AGENT_TRACE_DISABLE;
+  const prevOaiTransport = process.env.MIXDOG_OAI_TRANSPORT;
   process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+  // This smoke intentionally verifies the pinned WS-only escape hatch. Default
+  // transport is now refs-style auto (WS-first with HTTP fallback), so
+  // forceHttpFallback would legitimately call fakeHttp unless we pin ws-delta.
+  process.env.MIXDOG_OAI_TRANSPORT = 'ws-delta';
   try {
     const provider = new OpenAIOAuthProvider({});
     provider.ensureAuth = async () => ({ access_token: 'fake-token' });
@@ -252,6 +257,8 @@ function assertOk(name, result, pattern = null) {
   } finally {
     if (prevTraceDisable == null) delete process.env.MIXDOG_AGENT_TRACE_DISABLE;
     else process.env.MIXDOG_AGENT_TRACE_DISABLE = prevTraceDisable;
+    if (prevOaiTransport == null) delete process.env.MIXDOG_OAI_TRANSPORT;
+    else process.env.MIXDOG_OAI_TRANSPORT = prevOaiTransport;
   }
 }
 
@@ -485,6 +492,28 @@ const findOut = await executeBuiltinTool('find', {
 }, root);
 assertOk('find', findOut, /scripts[\\/]tool-smoke\.mjs/i);
 
+// find query[] batch: fan-out must emit one section per query in caller order
+// and share the broad enumeration sweep across queries (single-flight dedup).
+const findBatchOut = await executeBuiltinTool('find', {
+  query: ['tool smoke', 'smoke'],
+  path: '.',
+  head_limit: 5,
+}, root);
+{
+  const s = String(findBatchOut);
+  const iA = s.indexOf('# find tool smoke');
+  const iB = s.indexOf('# find smoke');
+  if (iA < 0 || iB < 0) {
+    throw new Error(`find query[] must emit a section per query:\n${s.slice(0, 600)}`);
+  }
+  if (!(iA < iB)) {
+    throw new Error(`find query[] must preserve caller order:\n${s.slice(0, 600)}`);
+  }
+  if (!/scripts[\\/]tool-smoke\.mjs/i.test(s)) {
+    throw new Error(`find query[] sections must carry match bodies:\n${s.slice(0, 600)}`);
+  }
+}
+
 const readOut = await executeBuiltinTool('read', {
   path: 'scripts/smoke.mjs',
   offset: 0,
@@ -743,13 +772,22 @@ const shellOut = await shellOutPromise;
 assertOk('bash explicit shell/cwd', shellOut, /v\d+\.\d+\.\d+/);
 
 const shellFailOut = await shellFailOutPromise;
-if (!/^Error[\s:[]/.test(String(shellFailOut)) || !/\[exit code: 7\]/.test(String(shellFailOut))) {
-  throw new Error(`bash non-zero exit must be classified as Error:\n${shellFailOut}`);
+if (!/^Error[\s:[]/.test(String(shellFailOut)) || !/\[shell-run-failed\]/.test(String(shellFailOut)) || !/\[exit code: 7\]/.test(String(shellFailOut))) {
+  throw new Error(`bash non-zero exit must be classified as shell-run-failed Error:\n${shellFailOut}`);
 }
 
 const shellTimeoutOut = await shellTimeoutOutPromise;
-if (!/^Error[\s:[]/.test(String(shellTimeoutOut)) || !/\[timeout: 500ms\b/.test(String(shellTimeoutOut))) {
-  throw new Error(`bash timeout must be milliseconds and classified as Error:\n${shellTimeoutOut}`);
+if (!/^Error[\s:[]/.test(String(shellTimeoutOut)) || !/\[shell-run-failed\]/.test(String(shellTimeoutOut)) || !/\[timeout: 500ms\b/.test(String(shellTimeoutOut))) {
+  throw new Error(`bash timeout must be milliseconds and classified as shell-run-failed Error:\n${shellTimeoutOut}`);
+}
+
+const shellArgFailOut = await executeBuiltinTool('shell', {
+  command: '',
+  cwd: root,
+  shell: 'powershell',
+}, root);
+if (!/^Error[\s:[]/.test(String(shellArgFailOut)) || !/\[shell-tool-failed\]/.test(String(shellArgFailOut))) {
+  throw new Error(`shell tool/preflight failures must be classified as shell-tool-failed Error:\n${shellArgFailOut}`);
 }
 
 // Auto-promotion: a sync foreground command still running past the (soft)
@@ -1207,6 +1245,14 @@ const explorerPrompt = buildExplorerPrompt('where is <agent> & status?');
 if (!explorerPrompt.includes('&lt;agent&gt;') || !explorerPrompt.includes('&amp;') || /verdicts, ratings, or recommendations/.test(explorerPrompt) === false) {
   throw new Error(`explorer prompt contract failed: ${explorerPrompt}`);
 }
+if (
+  !/STOP and answer NOW/.test(explorerPrompt)
+  || !/Turns 2-3 exist SOLELY as zero-hit recovery/.test(explorerPrompt)
+  || !/HARD max 3 tool turns/.test(explorerPrompt)
+  || !/turn 1\/3/.test(explorerPrompt)
+) {
+  throw new Error(`explorer prompt must force immediate answer on a specific-token anchor while preserving the 3-turn cap: ${explorerPrompt}`);
+}
 setInternalToolsProvider({
   executor: async () => 'tool-smoke internal tool',
   tools: [
@@ -1737,8 +1783,35 @@ if (/line\/context/i.test(JSON.stringify(readTool?.inputSchema || {}))) {
   if (!/applyToCurrentSession = options\?\.applyToCurrentSession === true/.test(setRouteBlock)) {
     throw new Error('setRoute must default applyToCurrentSession to false (model changes apply to the next session only)');
   }
-  if (!/if \(!applyToCurrentSession\)/.test(setRouteBlock) || !/return (?:route|getRoute\(\));/.test(setRouteBlock)) {
-    throw new Error('setRoute must early-return before touching the live session when applyToCurrentSession is false');
+  if (!/const applyLive = applyToCurrentSession \|\| currentSessionEmpty/.test(setRouteBlock)
+    || !/if \(!applyLive\)/.test(setRouteBlock)
+    || !/return getRoute\(\);/.test(setRouteBlock)) {
+    throw new Error('setRoute must early-return before touching a non-empty live session when applyToCurrentSession is false');
+  }
+  // Empty current session must apply live so /model before the first chat
+  // updates route + statusline at once, but compact summary anchors are route
+  // history and must keep a compacted session next-session-only. Seeded system
+  // or synthetic assistant/tool rows alone must NOT make the session non-empty.
+  if (!/!hasRouteHistoryMessage\(session\.messages\)/.test(setRouteBlock)
+    || !/!hasRouteHistoryMessage\(session\.liveTurnMessages\)/.test(setRouteBlock)
+    || !/SUMMARY_PREFIX/.test(runtimeSrc)
+    || !/hasUserConversationMessage\(list\) \|\| list\.some\(isSummaryAnchorMessage\)/.test(runtimeSrc)
+    || !/function hasRouteHistoryMessage/.test(runtimeSrc)) {
+    throw new Error('setRoute must apply live only to route-empty sessions and must treat compact summary anchors as non-empty route history');
+  }
+  if (!/createCurrentSession\('model-switch-empty'\)/.test(setRouteBlock)
+    || !/createCurrentSession\('model-switch-empty-drain'\)/.test(setRouteBlock)
+    || !/const emptySession = getSession\(\)/.test(setRouteBlock)
+    || !/cli-model-switch-empty/.test(setRouteBlock)
+    || !/pushTranscriptRebind\?\.\(\)/.test(setRouteBlock)
+    || !/invalidatePreSessionToolSurface\?\.\(\)/.test(setRouteBlock)) {
+    throw new Error('setRoute must drain in-flight create then recreate/rebind empty live sessions so provider-specific BP1/tool surface is rebuilt for /model before first chat');
+  }
+  const sessionLifecycleSrc = readMjsSources('src/runtime/agent/orchestrator/session/manager/session-lifecycle.mjs');
+  const updateSessionRouteBlock = sessionLifecycleSrc.match(/export function updateSessionRoute\(id, route = \{\}\) \{[\s\S]*?\n\}/)?.[0] || '';
+  if (!/session\.promptCacheKey = providerCacheKey\(session\.provider\)/.test(updateSessionRouteBlock)
+    || !/session\.providerCacheOpts = buildSessionProviderCacheOpts\(session\.provider, session\.id, session\.agent\) \|\| null/.test(updateSessionRouteBlock)) {
+    throw new Error('updateSessionRoute must refresh provider-scoped prompt cache fields when an empty live session changes provider/model');
   }
   const engineSrc = [readMjsSources('src/tui/engine.mjs'), readMjsSources('src/tui/engine')].join('\n');
   if (/setRoute\(\{ model: m \}, \{ applyToCurrentSession: true \}\)/.test(engineSrc)) {
@@ -2074,13 +2147,13 @@ const grepPathDescription = grepTool?.inputSchema?.properties?.path?.description
 const grepGlobDescription = grepTool?.inputSchema?.properties?.glob?.description || '';
 const grepOutputModeDescription = grepTool?.inputSchema?.properties?.output_mode?.description || '';
 const grepHeadLimitDescription = grepTool?.inputSchema?.properties?.head_limit?.description || '';
-if (!/Array = variants in one call/i.test(grepPatternDescription) || !/Verified file or dir/i.test(grepPathDescription)) {
+if (!/Array = variants in one call/i.test(grepPatternDescription) || !/Verified file\/dir/i.test(grepPathDescription)) {
   throw new Error('grep schema must keep compact pattern/path guidance');
 }
-if (!/verified file\/dir scope/i.test(grepTool?.description || '') || !/Unknown scope.*find\/glob first/i.test(grepTool?.description || '')) {
+if (!/verified scope/i.test(grepTool?.description || '') || !/Unknown path\/name.*find first/i.test(grepTool?.description || '')) {
   throw new Error('grep description must require verified scopes and locator-first unknown paths');
 }
-if (!/narrow scope/i.test(grepGlobDescription)) {
+if (!/Glob filter/i.test(grepGlobDescription) || !/no guessed src\/\*\*/i.test(grepGlobDescription)) {
   throw new Error('grep glob schema must describe scope narrowing');
 }
 if (!/files_with_matches\/count/i.test(grepOutputModeDescription) || !/content_with_context/i.test(grepOutputModeDescription)) {
@@ -2098,7 +2171,7 @@ const listTool = BUILTIN_TOOLS.find((tool) => tool.name === 'list');
 if (!/exact glob from verified roots/i.test(globTool?.description || '')) {
   throw new Error('glob description must route exact-pattern unknown paths before read/grep/list');
 }
-if (!/unverified path\/name guesses/i.test(findTool?.description || '') || !/returns verified paths/i.test(findTool?.description || '')) {
+if (!/Partial path\/name lookup/i.test(findTool?.description || '') || !/verify roots before grep\/glob/i.test(findTool?.description || '')) {
   throw new Error('find description must advertise unverified path/name lookup and verified outputs');
 }
 if (!/List verified directories/i.test(listTool?.description || '') || !/Unknown dir.*find first/i.test(listTool?.description || '') || !/Verified directory/i.test(listTool?.inputSchema?.properties?.path?.description || '')) {

package/src/app.mjs

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { performance } from 'node:perf_hooks';
+import { ensureProcessListenerHeadroom } from './runtime/shared/process-listener-headroom.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // --workflow is consumed (with its value) but ignored on the headless role
@@ -35,7 +36,7 @@ const BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__
 // which legitimately exceeds Node's default 10-listener warning threshold in a
 // fully-loaded runtime. Raise the cap once at the CLI entry so a benign
 // MaxListenersExceededWarning never leaks into the user's terminal.
-try { process.setMaxListeners(Math.max(process.getMaxListeners(), 64)); } catch { /* ignore */ }
+ensureProcessListenerHeadroom(64);
 
 function bootProfile(event, fields = {}) {
   if (!BOOT_PROFILE_ENABLED) return;