mixdog 0.9.36 → 0.9.37

package/scripts/session-bench.mjs

@@ -226,11 +226,11 @@ function cacheRatioFromUsage(rows) {
 
 function cacheBreakExplanation(reason) {
   const r = String(reason || '');
-  if (r === 'no_anchor') return 'delta 기준점/previous response 없음';
-  if (r === 'input_prefix_mismatch') return '요청 prefix가 이전 turn과 달라짐';
-  if (r.startsWith('response_output_mismatch')) return '이전 응답 output 체인이 기대값과 다름';
-  if (r === 'cache_key_changed') return 'cache key 변경';
-  return r ? '원인 미분류' : '원인 기록 없음';
+  if (r === 'no_anchor') return 'delta \uAE30\uC900\uC810/previous response \uC5C6\uC74C';
+  if (r === 'input_prefix_mismatch') return '\uC694\uCCAD prefix\uAC00 \uC774\uC804 turn\uACFC \uB2EC\uB77C\uC9D0';
+  if (r.startsWith('response_output_mismatch')) return '\uC774\uC804 \uC751\uB2F5 output \uCCB4\uC778\uC774 \uAE30\uB300\uAC12\uACFC \uB2E4\uB984';
+  if (r === 'cache_key_changed') return 'cache key \uBCC0\uACBD';
+  return r ? '\uC6D0\uC778 \uBBF8\uBD84\uB958' : '\uC6D0\uC778 \uAE30\uB85D \uC5C6\uC74C';
 }
 
 function classifyCacheBreakPhase(row, usageRows, transportRows) {
@@ -1342,27 +1342,27 @@ function buildExecutiveSummary(report) {
   const tools = report.summary.total_tool_ms || 0;
   const total = headers + stream + tools;
   const dominant = [['stream', stream], ['tools', tools], ['headers', headers]].sort((a, b) => b[1] - a[1])[0];
-  lines.push(`주 병목=${dominant[0]} ${fmtMs(dominant[1])}/${fmtMs(total)}; cache=${fmtPct((report.summary.cache_ratio ?? 0) * 100)}; turns=${report.summary.turns}; tools=${report.summary.tool_calls}`);
+  lines.push(`\uC8FC \uBCD1\uBAA9=${dominant[0]} ${fmtMs(dominant[1])}/${fmtMs(total)}; cache=${fmtPct((report.summary.cache_ratio ?? 0) * 100)}; turns=${report.summary.turns}; tools=${report.summary.tool_calls}`);
   if (report.cache.cache_breaks.length) {
     const summary = countBy(report.cache.cache_breaks, (b) => `${b.reason || 'unknown'}/${b.phase || 'unknown'}`).slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
-    lines.push(`캐시 깨짐=${report.cache.cache_breaks.length} (${summary})`);
+    lines.push(`\uCE90\uC2DC \uAE68\uC9D0=${report.cache.cache_breaks.length} (${summary})`);
   }
   if (report.cache.actual_cache_misses?.length) {
     const top = [...report.cache.actual_cache_misses].sort((a, b) => (b.uncached_tokens || 0) - (a.uncached_tokens || 0))[0];
-    lines.push(`실제 캐시 미스=${report.cache.actual_cache_misses.length} (top uncached=${fmtTok(top?.uncached_tokens || 0)})`);
+    lines.push(`\uC2E4\uC81C \uCE90\uC2DC \uBBF8\uC2A4=${report.cache.actual_cache_misses.length} (top uncached=${fmtTok(top?.uncached_tokens || 0)})`);
   }
   if (report.compact?.cache_breaks?.length) {
     const summary = countBy(report.compact.cache_breaks, (b) => `${b.reason || 'unknown'}/${b.phase || 'unknown'}`).slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
-    lines.push(`컴팩트 호출=${report.compact.sessions.length} session, cache reset=${report.compact.cache_breaks.length} (${summary})`);
+    lines.push(`\uCEF4\uD329\uD2B8 \uD638\uCD9C=${report.compact.sessions.length} session, cache reset=${report.compact.cache_breaks.length} (${summary})`);
   }
   if (report.tools.failures.length) {
     const summary = countBy(report.tools.failures, (f) => f.category || f.tool || 'unknown').slice(0, 3).map(([k, v]) => `${k}×${v}`).join(', ');
-    lines.push(`툴 실패=${report.tools.failures.length} (${summary})`);
+    lines.push(`\uD234 \uC2E4\uD328=${report.tools.failures.length} (${summary})`);
   }
   const topGrowth = report.tokens.growth_turns[0];
-  if (topGrowth) lines.push(`토큰 증폭=${topGrowth.agent || '-'} it=${topGrowth.turn_label} promptΔ=${fmtTok(topGrowth.prompt_delta)} out=${fmtTok(topGrowth.output_tokens + topGrowth.thinking_tokens)}`);
+  if (topGrowth) lines.push(`\uD1A0\uD070 \uC99D\uD3ED=${topGrowth.agent || '-'} it=${topGrowth.turn_label} promptΔ=${fmtTok(topGrowth.prompt_delta)} out=${fmtTok(topGrowth.output_tokens + topGrowth.thinking_tokens)}`);
   const topChurn = report.tools.duplicates[0];
-  if (topChurn) lines.push(`툴 헛돎=${topChurn.tool}×${topChurn.count} ${compactText(topChurn.target, 90)}`);
+  if (topChurn) lines.push(`\uD234 \uD5DB\uB3CE=${topChurn.tool}×${topChurn.count} ${compactText(topChurn.target, 90)}`);
   return lines;
 }
 
@@ -1626,7 +1626,7 @@ function renderText(report) {
     if (report.tools.failures.length) {
       lines.push('tool failures:');
       for (const f of report.tools.failures.slice(0, 10)) {
-        lines.push(`- ${f.agent || '-'} it=${f.iteration ?? '-'} ${f.tool || '-'} ${fmtMs(f.tool_ms)} category=${f.category || '-'} reason=${f.reason || 'trace에 상세 stderr/예외 미저장'} result=${Math.round(f.bytes / 1024)}KB/${f.lines}l: ${f.target}`);
+        lines.push(`- ${f.agent || '-'} it=${f.iteration ?? '-'} ${f.tool || '-'} ${fmtMs(f.tool_ms)} category=${f.category || '-'} reason=${f.reason || 'trace\uC5D0 \uC0C1\uC138 stderr/\uC608\uC678 \uBBF8\uC800\uC7A5'} result=${Math.round(f.bytes / 1024)}KB/${f.lines}l: ${f.target}`);
         if (opts.failuresOnly && f.preview) {
           const preview = compactText(f.preview, 700);
           lines.push(`  preview: ${preview}`);

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;

package/src/defaults/cycle3-review-prompt.md

@@ -51,6 +51,14 @@ or inconclusive, keep the CORE entry.
 - `keep` — durable and already one short clause.
 - `update` — durable but verbose or multi-sentence → rewrite as one ≤120-char clause.
 - `merge` — duplicates another entry → fold into the survivor (same project pool).
+- `reclassify` — the entry is filed under the WRONG project pool. Its subject
+  clearly belongs to a different pool shown among the entries under review: a
+  project-specific fact stored in COMMON belongs under that project, or a generic
+  cross-project rule mis-filed under one project belongs in COMMON. Name the
+  correct destination: `<id>|reclassify|<project_slug|common>`. The target must
+  be COMMON or a project pool that already appears on another entry above — never
+  invent a new pool. Reclassify only MOVES the entry (its text is unchanged and
+  nothing is deleted); use it only when the mis-scoping is unambiguous, else `keep`.
 - `superseded` — a NEWER active core entry directly CONTRADICTS the value/state
   this older entry asserts (same
   subject, changed fact: a renamed thing, a moved location, a reversed
@@ -103,6 +111,7 @@ One line per entry id, any order:
 <id>|keep
 <id>|update|<element>|<summary>
 <id>|merge|<target_id>|<source_ids_csv>
+<id>|reclassify|<project_slug|common>
 <id>|superseded|<newer_id>
 <id>|delete|<reason>
 ```