mixdog 0.9.2 → 0.9.4

package/scripts/explore-bench.mjs

@@ -0,0 +1,124 @@
+// Explore quality bench — round-based tuning harness.
+//
+// Runs a fixed query set through runExplore against this repo, then reads
+// agent-trace.jsonl to report per-session tool-call counts, wall time, and
+// anchor quality. Usage:
+//   node scripts/explore-bench.mjs [roundLabel]
+// Fresh process per run = no in-memory result cache carryover.
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { runExplore } from '../src/standalone/explore-tool.mjs';
+
+const ROUND = process.argv[2] || 'r0';
+const CWD = 'C:/Project/mixdog';
+
+// Representative locator queries with ground truth: expect = substrings, at
+// least one must appear in the anchor output (quality hit). expectFail = the
+// correct answer is EXPLORATION_FAILED (miss discipline).
+const QUERIES = [
+  {
+    q: 'where is the tool-call stall watchdog policy resolved and what defaults does it use',
+    expect: ['agent-progress-watchdog', 'stall-policy'],
+  },
+  {
+    q: 'session compact / smart compact trigger threshold logic',
+    expect: ['compact'],
+  },
+  {
+    q: 'where are hidden agent tool schema profiles defined (read / read-write-search)',
+    expect: ['agent-dispatch', 'agents.json', 'internal-agents'],
+  },
+  {
+    q: 'recall memory chunk importance scoring implementation',
+    expect: ['importance', 'memory'],
+  },
+  {
+    q: 'websocket reconnect backoff handling',
+    expect: ['openai-oauth-ws', 'retry-classifier'],
+  },
+  // ── extended set: symbol-exact, filename, error-string, korean, flow, config ──
+  {
+    q: 'buildExplorerPrompt definition', // exact known symbol
+    expect: ['explore-tool'],
+  },
+  {
+    q: 'where does the explore tool cache results and what is the TTL',
+    expect: ['explore-tool'],
+  },
+  {
+    q: 'error text "maintenance route unresolved for agent" — where is it thrown',
+    expect: ['agent-dispatch'],
+  },
+  {
+    q: '에이전트 세션의 최대 루프 반복 횟수는 어디서 정해져?', // korean concept query
+    expect: ['agent-loop-policy'],
+  },
+  {
+    q: 'how does a fixed agent slot map to a workflow slot (explore/explorer)',
+    expect: ['mixdog-session-runtime', 'internal-agents'],
+  },
+  {
+    q: 'where is the mixdog config json file path resolved (data dir)',
+    expect: ['config', 'plugin-paths'],
+  },
+  {
+    q: 'GraphQL schema stitching resolver implementation', // not in this repo
+    expectFail: true,
+  },
+];
+
+function tracePath() {
+  return process.env.MIXDOG_AGENT_TRACE_PATH
+    || join(process.env.MIXDOG_DATA_DIR || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data'), 'history', 'agent-trace.jsonl');
+}
+
+function readTraceSince(ts) {
+  const p = tracePath();
+  if (!existsSync(p)) return [];
+  const rows = [];
+  for (const line of readFileSync(p, 'utf8').split('\n')) {
+    if (!line) continue;
+    try {
+      const r = JSON.parse(line);
+      if (r.ts >= ts && r.agent === 'explorer') rows.push(r);
+    } catch { /* skip */ }
+  }
+  return rows;
+}
+
+const t0 = Date.now();
+const results = [];
+for (const { q, expect, expectFail } of QUERIES) {
+  const qt0 = Date.now();
+  const res = await runExplore({ query: q, cwd: CWD }, { callerCwd: CWD });
+  const text = res?.content?.[0]?.text || '';
+  const anchors = text.split('\n').filter((l) => /:\d+/.test(l)).length;
+  const failed = /EXPLORATION_FAILED/.test(text);
+  const lower = text.toLowerCase();
+  const hit = expectFail
+    ? (failed && anchors === 0)
+    : (!failed && (expect || []).some((e) => lower.includes(e.toLowerCase())));
+  results.push({ q: q.slice(0, 48), ms: Date.now() - qt0, anchors, failed, hit, bytes: text.length });
+}
+
+// Attribute tool calls per explorer session spawned during this run.
+const rows = readTraceSince(t0);
+const bySession = new Map();
+for (const r of rows) {
+  if (r.kind !== 'tool') continue;
+  const s = bySession.get(r.session_id) || { calls: 0, tools: [] };
+  s.calls++; s.tools.push(r.tool_name);
+  bySession.set(r.session_id, s);
+}
+const callCounts = [...bySession.values()].map((s) => s.calls).sort((a, b) => a - b);
+const p50 = callCounts[Math.floor(callCounts.length / 2)] ?? 0;
+
+console.log(`\n=== explore-bench round=${ROUND} ===`);
+for (const r of results) {
+  console.log(`  [${String(r.ms).padStart(6)}ms] ${r.hit ? 'HIT ' : 'MISS'} anchors=${r.anchors} failed=${r.failed} bytes=${r.bytes}  ${r.q}`);
+}
+console.log(`  quality: ${results.filter((r) => r.hit).length}/${results.length} hits`);
+console.log(`  sessions=${bySession.size} toolcalls p50=${p50} max=${callCounts[callCounts.length - 1] ?? 0} total=${callCounts.reduce((a, b) => a + b, 0)}`);
+for (const [id, s] of bySession) console.log(`    ${id.slice(-8)}: ${s.tools.join(',')}`);
+console.log(`  wall total=${((Date.now() - t0) / 1000).toFixed(1)}s`);

package/scripts/freevar-smoke.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+/**
+ * scripts/freevar-smoke.mjs — undeclared-identifier gate for runtime source.
+ *
+ * Same engine as tui-render-smoke.mjs (acorn + eslint-scope) but pointed at
+ * the plain-ESM runtime sources instead of the TUI bundle. Any reference that
+ * resolves to no binding and is not a known Node global is a guaranteed
+ * ReferenceError on that code path — exactly the class of bug that section
+ * extractions leave behind on cold paths (missed import, orphaned helper).
+ *
+ * Run:  node scripts/freevar-smoke.mjs   (or `npm run smoke:freevars`)
+ * Exit: 0 = clean, 1 = undeclared identifiers found / parse failure.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from 'acorn';
+import { analyze } from 'eslint-scope';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+// Plain .mjs source roots. src/tui is covered by smoke:tui on the BUILT
+// bundle (App.jsx is JSX — acorn can't parse it raw); vendor is third-party.
+const SCAN_ROOTS = ['src/runtime', 'src/standalone', 'src/shared', 'scripts'].map(p => join(ROOT, p));
+const SKIP_DIRS = new Set(['node_modules', 'dist', '.git']);
+
+const KNOWN_GLOBALS = new Set([
+  'Array', 'ArrayBuffer', 'Atomics', 'BigInt', 'BigInt64Array', 'BigUint64Array', 'Boolean',
+  'DataView', 'Date', 'Error', 'EvalError', 'FinalizationRegistry', 'Float32Array',
+  'Float64Array', 'Function', 'Infinity', 'Int8Array', 'Int16Array', 'Int32Array',
+  'Intl', 'JSON', 'Map', 'Math', 'NaN', 'Number', 'Object', 'Promise', 'Proxy',
+  'RangeError', 'ReferenceError', 'Reflect', 'RegExp', 'Set', 'SharedArrayBuffer',
+  'String', 'Symbol', 'SyntaxError', 'TypeError', 'URIError', 'Uint8Array',
+  'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap', 'WeakRef', 'WeakSet',
+  'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'eval',
+  'globalThis', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined',
+  'AbortController', 'AbortSignal', 'Blob', 'Buffer', 'ByteLengthQueuingStrategy',
+  'CompressionStream', 'CountQueuingStrategy', 'Crypto', 'CryptoKey', 'CustomEvent',
+  'DecompressionStream', 'Event', 'EventTarget', 'File', 'FormData', 'Headers',
+  'MessageChannel', 'MessageEvent', 'MessagePort', 'Navigator', 'PerformanceEntry',
+  'PerformanceObserver', 'ReadableStream', 'ReadableStreamDefaultReader', 'Request',
+  'Response', 'SubtleCrypto', 'TextDecoder', 'TextDecoderStream', 'TextEncoder',
+  'TextEncoderStream', 'TransformStream', 'URL', 'URLSearchParams', 'WebAssembly',
+  'WebSocket', 'WritableStream', 'atob', 'btoa', 'clearImmediate', 'clearInterval',
+  'clearTimeout', 'console', 'crypto', 'fetch', 'navigator', 'performance',
+  'process', 'queueMicrotask', 'require', 'setImmediate', 'setInterval',
+  'setTimeout', 'structuredClone', 'reportError',
+  // Browser globals: legal inside puppeteer page.evaluate() callbacks, which
+  // execute in the BROWSER context (web-tools.mjs scrapers).
+  'document', 'window',
+]);
+
+function* walk(dir) {
+  for (const name of readdirSync(dir)) {
+    if (SKIP_DIRS.has(name)) continue;
+    const p = join(dir, name);
+    const st = statSync(p);
+    if (st.isDirectory()) yield* walk(p);
+    else if (name.endsWith('.mjs')) yield p;
+  }
+}
+
+let failures = 0;
+let scanned = 0;
+for (const root of SCAN_ROOTS) {
+  let files;
+  try { files = [...walk(root)]; } catch { continue; }
+  for (const file of files) {
+    scanned++;
+    const source = readFileSync(file, 'utf8');
+    let ast;
+    try {
+      ast = parse(source, { ecmaVersion: 'latest', sourceType: 'module', locations: true, ranges: true });
+    } catch (err) {
+      failures++;
+      console.error(`freevar-smoke: PARSE FAIL ${relative(ROOT, file)}: ${err.message}`);
+      continue;
+    }
+    const scopeManager = analyze(ast, { ecmaVersion: 2022, sourceType: 'module' });
+    const seen = new Set();
+    for (const ref of scopeManager.globalScope.through) {
+      const { name } = ref.identifier;
+      if (KNOWN_GLOBALS.has(name) || seen.has(name)) continue;
+      seen.add(name);
+      failures++;
+      const loc = ref.identifier.loc?.start;
+      console.error(`freevar-smoke: FAIL ${relative(ROOT, file)}:${loc ? `${loc.line}:${loc.column}` : '?'} — undeclared identifier \`${name}\``);
+    }
+  }
+}
+
+if (failures > 0) {
+  console.error(`freevar-smoke: ${failures} problem(s) across ${scanned} files — these are ReferenceErrors waiting on their code path.`);
+  process.exit(1);
+}
+console.log(`freevar-smoke: ok — ${scanned} files, no undeclared identifiers`);

package/scripts/hook-bus-test.mjs

@@ -328,3 +328,194 @@ console.log(JSON.stringify({ hookSpecificOutput: {
     else process.env.MIXDOG_HOOKS_FILE = prev;
   }
 });
+
+test('mcp_tool handler routes output through parseHandlerOutput', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [{ type: 'mcp_tool', server: 'guard', tool: 'check' }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    let seenName = null;
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      mcpToolRunner: async ({ name }) => {
+        seenName = name;
+        return JSON.stringify({ hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: 'mcp denied',
+        }});
+      },
+    });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(seenName, 'mcp__guard__check');
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /mcp denied/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler ok:false maps to deny', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [{ type: 'prompt', prompt: 'is this safe?' }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: async () => JSON.stringify({ ok: false, reason: 'unsafe' }),
+    });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /unsafe/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('unconfigured prompt/mcp_tool and unsupported agent emit hook:error and skip', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'shell',
+        hooks: [
+          { type: 'prompt', prompt: 'x' },
+          { type: 'mcp_tool', server: 'g', tool: 't' },
+          { type: 'agent', agent: 'a' },
+        ],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root });
+    const result = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(result, null);
+    const errs = bus.status().recent.filter((e) => e.name === 'hook:error');
+    assert.ok(errs.some((e) => /prompt not configured/.test(e.payload?.error || '')));
+    assert.ok(errs.some((e) => /mcp_tool not configured/.test(e.payload?.error || '')));
+    assert.ok(errs.some((e) => /unsupported hook type: agent/.test(e.payload?.error || '')));
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('setRewakeHandler fires on async child exit code 2', async () => {
+  const root = tempRoot();
+  const hookScript = join(root, 'rewake.mjs');
+  writeFileSync(hookScript, `process.stderr.write('needs rewake'); process.exit(2);`, 'utf8');
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      Stop: [{
+        hooks: [{ type: 'command', command: process.execPath, args: [hookScript], asyncRewake: true }],
+      }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root });
+    const fired = new Promise((resolve) => bus.setRewakeHandler((info) => resolve(info)));
+    await bus.dispatch('Stop', { session_id: 's', cwd: root });
+    const info = await fired;
+    assert.equal(info.eventName, 'Stop');
+    assert.match(info.text, /needs rewake/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler plain-text "no" denies', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{ matcher: 'shell', hooks: [{ type: 'prompt', prompt: 'safe?' }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({ dataDir: root, promptRunner: async () => 'no' });
+    const denied = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(denied.action, 'deny');
+    assert.match(denied.reason, /no/i);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt handler timeout does not hang and reports error', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      PreToolUse: [{ matcher: 'shell', hooks: [{ type: 'prompt', prompt: 'x', timeout: 0.05 }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: () => new Promise(() => {}),
+    });
+    const result = await bus.beforeTool({ sessionId: 's', cwd: root, name: 'shell', args: { command: 'x' } });
+    assert.equal(result, null);
+    const errs = bus.status().recent.filter((e) => e.name === 'hook:error');
+    assert.ok(errs.some((e) => /timed out/i.test(e.payload?.error || '')));
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});
+
+test('prompt deny uses universal exit-2 path on Stop event', async () => {
+  const root = tempRoot();
+  const hooksFile = join(root, 'hooks.json');
+  writeJson(hooksFile, {
+    hooks: {
+      Stop: [{ hooks: [{ type: 'prompt', prompt: 'done?' }] }],
+    },
+  });
+  const prev = process.env.MIXDOG_HOOKS_FILE;
+  process.env.MIXDOG_HOOKS_FILE = hooksFile;
+  try {
+    const bus = createStandaloneHookBus({
+      dataDir: root,
+      promptRunner: async () => JSON.stringify({ ok: false, reason: 'not done' }),
+    });
+    const result = await bus.dispatch('Stop', { session_id: 's', cwd: root });
+    assert.equal(result.blocked, true);
+    assert.match(result.reason, /not done/);
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_HOOKS_FILE;
+    else process.env.MIXDOG_HOOKS_FILE = prev;
+  }
+});

package/scripts/internal-comms-bench.mjs

@@ -36,6 +36,7 @@ const RULE_FILES = [
   'agents/debugger/AGENT.md',
   'workflows/default/WORKFLOW.md',
   'rules/lead/lead-tool.md',
+  'rules/lead/lead-brief.md',
 ];
 
 const DEFAULT_WORKER_PROMPT =

package/scripts/internal-comms-smoke.mjs

@@ -24,17 +24,18 @@ function flat(text) {
   return String(text || '').replace(/\s+/g, ' ');
 }
 
-// --- Lead brief contract: canonical in lead-tool.md, referenced from WORKFLOW -
+// --- Lead brief contract: canonical in lead-brief.md, referenced from WORKFLOW -
 const workflow = readSrc('workflows', 'default', 'WORKFLOW.md');
-const leadTool = readSrc('rules', 'lead', 'lead-tool.md');
+const leadBrief = readSrc('rules', 'lead', 'lead-brief.md');
 const BRIEF_FIELDS = ['Goal:', 'Anchors:', 'Allow/Forbid:', 'Deliver:', 'Verify:'];
-// Canonical brief contract lives in lead-tool.md (Lead tool-use rules).
-assert(/minimum characters, maximum information/i.test(flat(leadTool)), 'lead-tool.md: brief must state min-char/max-info principle');
-for (const field of BRIEF_FIELDS) assert(leadTool.includes(field), `lead-tool.md: brief missing labeled field ${field}`);
-assert(leadTool.includes('Stop:'), 'lead-tool.md: brief must add Stop: for heavy-worker bound');
-assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(flat(leadTool)), 'lead-tool.md: brief must ban restating known rules/background as cost');
-// WORKFLOW.md must not duplicate the field list; it defers to the lead-tool contract.
-assert(/lead-tool brief contract/i.test(flat(workflow)), 'WORKFLOW.md: must defer to the lead-tool brief contract');
+// Canonical brief contract lives in lead-brief.md (Lead brief contract).
+assert(/minimum characters, maximum information/i.test(flat(leadBrief)), 'lead-brief.md: brief must state min-char/max-info principle');
+for (const field of BRIEF_FIELDS) assert(leadBrief.includes(field), `lead-brief.md: brief missing labeled field ${field}`);
+assert(leadBrief.includes('Stop:'), 'lead-brief.md: brief must add Stop: for heavy-worker bound');
+assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(flat(leadBrief)), 'lead-brief.md: brief must ban restating known rules/background as cost');
+assert(/authoritative/i.test(flat(leadBrief)), 'lead-brief.md: brief must state spec-file precedence over summary');
+// WORKFLOW.md must not duplicate the field list; it defers to the lead brief contract.
+assert(/lead brief contract/i.test(flat(workflow)), 'WORKFLOW.md: must defer to the lead brief contract');
 assert(!BRIEF_FIELDS.every((field) => workflow.includes(field)), 'WORKFLOW.md: must not duplicate the full brief field list');
 
 // --- Agent handoff contract (00-common.md) ---------------------------------

package/scripts/mouse-probe.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * scripts/mouse-probe.mjs — raw SGR mouse event probe.
+ *
+ * Enables the same SGR mouse tracking the TUI uses and prints every mouse
+ * escape sequence it receives, decoded (button id + modifier bits + coords).
+ * Use it to see EXACTLY what the terminal sends for ctrl+wheel — if the ctrl
+ * bit (16) never appears, the terminal is not forwarding the modifier and the
+ * app-side zoom passthrough can never trigger.
+ *
+ * Run:  node scripts/mouse-probe.mjs   (q or Ctrl+C to quit)
+ */
+const ON = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
+const OFF = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
+const MOUSE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+
+process.stdout.write(ON);
+process.stdout.write('mouse-probe: wheel / ctrl+wheel / click here. q to quit.\n');
+process.stdin.setRawMode(true);
+process.stdin.resume();
+
+const cleanup = () => {
+  process.stdout.write(OFF);
+  process.stdin.setRawMode(false);
+  process.exit(0);
+};
+process.on('SIGINT', cleanup);
+
+process.stdin.on('data', (buf) => {
+  const s = buf.toString('utf8');
+  if (s === 'q' || s === '\x03') return cleanup();
+  let m; MOUSE.lastIndex = 0;
+  let sawMouse = false;
+  while ((m = MOUSE.exec(s)) !== null) {
+    sawMouse = true;
+    const b = Number(m[1]);
+    const mods = [b & 4 ? 'shift' : '', b & 8 ? 'alt' : '', b & 16 ? 'ctrl' : ''].filter(Boolean).join('+') || 'none';
+    const base = b & ~(4 | 8 | 16);
+    const kind = base === 64 ? 'wheel-up' : base === 65 ? 'wheel-down' : base === 0 ? 'left' : base === 2 ? 'right' : (b & 32) ? 'motion' : `btn${base}`;
+    process.stdout.write(`button=${b} base=${base} kind=${kind} mods=${mods} x=${m[2]} y=${m[3]} ${m[4] === 'M' ? 'press' : 'release'}\n`);
+  }
+  if (!sawMouse && s.startsWith('\x1b')) {
+    process.stdout.write(`non-mouse escape: ${JSON.stringify(s)}\n`);
+  }
+});

package/scripts/output-style-bench.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Lead output-style verbosity bench (default >= simple >= minimal >= oneline).
+// Lead output-style verbosity bench (default >= simple >= minimal >= extreme-minimal).
 import { createRequire } from 'node:module';
 import { execFileSync } from 'node:child_process';
 import {
@@ -19,7 +19,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 const __dir = dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = resolve(__dir, '..');
 const PLUGIN_ROOT = join(REPO_ROOT, 'src');
-const STYLES = ['default', 'simple', 'minimal', 'oneline'];
+const STYLES = ['default', 'simple', 'minimal', 'extreme-minimal'];
 const DEFAULT_PROMPT =
   'Reply in plain English only. What is 2+2? Give a short summary suitable for a status report (no tools, no file reads).';
 const MODEL_ALIASES = {
@@ -85,10 +85,10 @@ function runInjectionScaffold() {
     ? JSON.parse(readFileSync(templatePath, 'utf8'))
     : { outputStyle: 'default' };
   const markers = {
-    default: 'most detailed of the three',
+    default: 'most detailed style',
     simple: 'Practical concise',
     minimal: 'a very short summary',
-    oneline: 'exactly one sentence',
+    'extreme-minimal': 'exactly one sentence',
   };
   const snippets = {};
   try {
@@ -179,11 +179,18 @@ function runLiveLeadTurn({ dataDir, prompt, provider, model, cwd, effort, fast }
     `let result;`,
     `try { result = await askSession(session.id, ${JSON.stringify(prompt)}, null, null, ${JSON.stringify(cwd)}); }`,
     `finally { try { closeSession(session.id, 'output-style-bench'); } catch {} }`,
-    `process.stdout.write(JSON.stringify({ text: String(result?.text || result?.content || '').trim(), sessionId: session.id }));`,
+    // Pooled provider sockets (e.g. openai-oauth WS, 20-min idle TTL) keep the
+    // child alive after the turn; flush JSON then force-exit so execFileSync
+    // returns as soon as the turn completes.
+    `const payload = JSON.stringify({ text: String(result?.text || result?.content || '').trim(), sessionId: session.id });`,
+    `await new Promise((r) => process.stdout.write(payload, r));`,
+    `process.exit(0);`,
   ].filter(Boolean).join('\n');
   const raw = execFileSync('node', ['--input-type=module', '-e', driver], {
     encoding: 'utf8',
     maxBuffer: 64 * 1024 * 1024,
+    timeout: Number(process.env.OUTPUT_STYLE_BENCH_TURN_TIMEOUT_MS || 10 * 60_000),
+    killSignal: 'SIGKILL',
     env: { ...process.env, MIXDOG_ROOT: PLUGIN_ROOT, MIXDOG_DATA_DIR: dataDir },
   });
   const jsonStart = raw.lastIndexOf('{');
@@ -209,7 +216,7 @@ function evaluateVerbosityOrdering(results) {
   return { orderingOk, verdict, counts: styleCharCountsFromResults(results) };
 }
 function printUsage() {
-  process.stdout.write(`output-style-bench — Lead verbosity ladder (default >= simple >= minimal >= oneline).
+  process.stdout.write(`output-style-bench — Lead verbosity ladder (default >= simple >= minimal >= extreme-minimal).
 
 Output style is Lead-only (buildLeadMetaContent when owner is not agent).
 runHeadlessRole worker paths (owner=agent) do NOT inject outputStyle.

package/scripts/output-style-smoke.mjs

@@ -49,8 +49,8 @@ const defaultStyle = readFileSync(join(root, 'src', 'output-styles', 'default.md
 for (const required of [
   'name: default',
   'Concise engineering summaries',
-  'Mixdog default — the most detailed of the three styles',
-  'match length to the work',
+  'Mixdog default — the most detailed style',
+  'State conclusions, not reasoning',
   'Use labels such as',
   '`바뀐 점`, `확인한 것`,',
   'Synthesize agent or retrieval results',
@@ -72,7 +72,7 @@ for (const required of [
   'controlled detail',
   'Synthesize agent or retrieval results',
   'Do not hide blockers',
-  'if verification was',
+  'verification was not run, say so once',
 ]) {
   assert(simpleStyle.includes(required), `simple.md missing: ${required}`);
 }
@@ -81,7 +81,7 @@ for (const [name, style] of Object.entries({
   default: defaultStyle,
   simple: simpleStyle,
   minimal: readFileSync(join(root, 'src', 'output-styles', 'minimal.md'), 'utf8'),
-  oneline: readFileSync(join(root, 'src', 'output-styles', 'oneline.md'), 'utf8'),
+  'extreme-minimal': readFileSync(join(root, 'src', 'output-styles', 'extreme-minimal.md'), 'utf8'),
 })) {
   assert(!style.includes('pre-tool preamble'), `${name} output style must not own language preamble rules`);
   assert(!style.includes('selected/default user language'), `${name} output style must not duplicate profile language rules`);

package/scripts/path-suffix-test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { findBySuffixStrip } from '../src/runtime/agent/orchestrator/tools/builtin/path-diagnostics.mjs';
+
+function makeRepo() {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-suffix-test-'));
+    mkdirSync(join(root, 'src', 'tui'), { recursive: true });
+    writeFileSync(join(root, 'src', 'tui', 'input-editing.mjs'), '// real file\n');
+    mkdirSync(join(root, 'vendor', 'ink', 'build'), { recursive: true });
+    writeFileSync(join(root, 'vendor', 'ink', 'build', 'index.js'), '// vendored\n');
+    return root;
+}
+
+test('resolves a hallucinated absolute prefix to the real repo-relative file', () => {
+    const root = makeRepo();
+    try {
+        const hallucinated = '/Users/danma/Local/Project/ink/src/tui/input-editing.mjs';
+        const hit = findBySuffixStrip(root, hallucinated);
+        assert.equal(hit, 'src/tui/input-editing.mjs');
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('resolves a hallucinated prefix onto a vendor/ path (no skip-dir filtering)', () => {
+    const root = makeRepo();
+    try {
+        const hallucinated = '/Users/danma/Local/Project/vendor/ink/build/index.js';
+        const hit = findBySuffixStrip(root, hallucinated);
+        assert.equal(hit, 'vendor/ink/build/index.js');
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('returns null when no tail length matches a real file', () => {
+    const root = makeRepo();
+    try {
+        const hit = findBySuffixStrip(root, '/Users/danma/Local/Project/does/not/exist.mjs');
+        assert.equal(hit, null);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('a bare basename (1 segment) is never matched', () => {
+    const root = makeRepo();
+    try {
+        const hit = findBySuffixStrip(root, 'input-editing.mjs');
+        assert.equal(hit, null);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});