mixdog 0.9.3 → 0.9.5

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/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 =
@@ -211,6 +212,8 @@ function runHeadlessWorker({ pluginRoot, dataDir, taskCwd, prompt, provider, mod
     `  message: ${JSON.stringify(prompt)},`,
     `  provider: ${JSON.stringify(provider || null)},`,
     `  model: ${JSON.stringify(model || null)},`,
+    `  effort: ${JSON.stringify(effort || null)},`,
+    `  fast: ${JSON.stringify(fast === true)},`,
     `  cwd: ${JSON.stringify(taskCwd)},`,
     `  write: (t) => out.push(t),`,
     `  writeErr: (t) => process.stderr.write(t),`,
@@ -229,8 +232,6 @@ function runHeadlessWorker({ pluginRoot, dataDir, taskCwd, prompt, provider, mod
         ...process.env,
         MIXDOG_ROOT: pluginRoot,
         MIXDOG_DATA_DIR: dataDir,
-        ...(effort ? { MIXDOG_AGENT_EFFORT: effort } : {}),
-        ...(fast ? { MIXDOG_AGENT_FAST: '1' } : {}),
       },
     });
     ok = true;
@@ -477,8 +478,6 @@ function runLiveLeadDelegation({ pluginRoot, dataDir, taskCwd, prompt, provider,
         ...process.env,
         MIXDOG_ROOT: pluginRoot,
         MIXDOG_DATA_DIR: dataDir,
-        ...(effort ? { MIXDOG_AGENT_EFFORT: effort } : {}),
-        ...(fast ? { MIXDOG_AGENT_FAST: '1' } : {}),
       },
     });
     const j = raw.lastIndexOf('{');

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/model-catalog-audit.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import { loadConfig } from '../src/runtime/agent/orchestrator/config.mjs';
+import { initProviders, getAllProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
+import {
+  loadModelsDevCatalog,
+  warmModelMetadataCatalogs,
+} from '../src/runtime/agent/orchestrator/providers/model-catalog.mjs';
+import { QUICK_SEARCH_MODELS } from '../src/session-runtime/quick-search-models.mjs';
+
+const args = new Set(process.argv.slice(2));
+const json = args.has('--json');
+const allRows = args.has('--all');
+const refresh = !args.has('--no-refresh');
+
+const PROVIDER_ALIAS = Object.freeze({
+  'openai-oauth': 'openai',
+  openai: 'openai',
+  'grok-oauth': 'xai',
+  xai: 'xai',
+  gemini: 'google',
+  google: 'google',
+  'anthropic-oauth': 'anthropic',
+  anthropic: 'anthropic',
+});
+
+const LIT_PREFIXES = Object.freeze({
+  openai: ['openai/'],
+  xai: ['xai/'],
+  google: ['gemini/', 'google/'],
+  anthropic: ['anthropic/'],
+  deepseek: ['deepseek/'],
+});
+
+function n(value) {
+  const num = Number(value);
+  return Number.isFinite(num) && num > 0 ? Math.floor(num) : null;
+}
+
+function contextLabel(value) {
+  const v = n(value);
+  if (!v) return '-';
+  if (v >= 1_000_000) {
+    const m = v / 1_000_000;
+    const label = Number.isInteger(m)
+      ? m.toFixed(0)
+      : m.toFixed(3).replace(/0+$/, '').replace(/\.$/, '');
+    return `${label}M`;
+  }
+  return `${Math.round(v / 1000)}k`;
+}
+
+function isInteresting(id) {
+  const s = String(id || '').toLowerCase();
+  return /^(gpt-5|gpt-4\.1|claude-|gemini-|grok-|deepseek-v4|glm-|qwen|minimax|kimi)/.test(s);
+}
+
+function litellmRow(litellm, provider, id) {
+  const p = PROVIDER_ALIAS[provider] || provider;
+  const keys = [id, ...(LIT_PREFIXES[p] || []).map(prefix => prefix + id)];
+  if (p === 'anthropic') keys.push(`anthropic.${id}-v1:0`, `bedrock/anthropic.${id}-v1:0`);
+  for (const key of keys) {
+    if (litellm?.[key]) return { key, row: litellm[key] };
+  }
+  return null;
+}
+
+function externalMeta(modelsDev, litellm, provider, id) {
+  const p = PROVIDER_ALIAS[provider] || provider;
+  const md = modelsDev?.[p]?.models?.[id] || null;
+  const lit = litellmRow(litellm, provider, id);
+  return {
+    modelsDevContext: n(md?.limit?.context),
+    modelsDevOutput: n(md?.limit?.output),
+    litellmContext: n(lit?.row?.max_input_tokens ?? lit?.row?.max_tokens),
+    litellmOutput: n(lit?.row?.max_output_tokens),
+    externalName: md?.name || null,
+    litellmKey: lit?.key || null,
+  };
+}
+
+function classifyOneMillion(value) {
+  const v = n(value);
+  if (!v) return 'unknown';
+  if (v === 1_000_000) return 'exact-1M';
+  if (v > 900_000 && v < 1_100_000) return 'near-1M-not-exact';
+  return 'not-1M';
+}
+
+async function listProviderModels(name, provider) {
+  let models = null;
+  let refreshed = false;
+  let error = null;
+  try {
+    if (refresh && typeof provider?._refreshModelCache === 'function') {
+      models = await provider._refreshModelCache();
+      refreshed = true;
+    }
+    if (!Array.isArray(models) && typeof provider?.listModels === 'function') {
+      models = await provider.listModels();
+    }
+  } catch (err) {
+    error = err?.message || String(err);
+  }
+  return { provider: name, refreshed, error, models: Array.isArray(models) ? models : [] };
+}
+
+const cfg = loadConfig();
+try {
+  await initProviders(cfg.providers || {});
+} catch (err) {
+  if (!json) console.error(`[model-audit] init failed: ${err?.message || err}`);
+}
+
+const [modelsDev, litellm] = await Promise.all([
+  loadModelsDevCatalog().catch(() => ({})),
+  warmModelMetadataCatalogs().catch(() => ({})),
+]);
+
+const providerResults = [];
+for (const [name, provider] of getAllProviders()) {
+  if (typeof provider?.listModels !== 'function') continue;
+  const listed = await listProviderModels(name, provider);
+  const rows = listed.models
+    .filter(row => row?.id && (allRows || isInteresting(row.id)))
+    .map(row => {
+      const liveContext = n(row.contextWindow ?? row.maxContextWindow);
+      const liveOutput = n(row.outputTokens);
+      const external = externalMeta(modelsDev, litellm, name, row.id);
+      const externalContext = external.modelsDevContext ?? external.litellmContext;
+      const externalOutput = external.modelsDevOutput ?? external.litellmOutput;
+      return {
+        provider: name,
+        id: row.id,
+        display: row.display || row.name || null,
+        liveContext,
+        liveContextLabel: contextLabel(liveContext),
+        liveOutput,
+        externalContext,
+        externalContextLabel: contextLabel(externalContext),
+        externalOutput,
+        contextVerdict: classifyOneMillion(liveContext),
+        contextMismatch: liveContext != null && externalContext != null && liveContext !== externalContext,
+        outputMismatch: liveOutput != null && externalOutput != null && liveOutput !== externalOutput,
+        source: listed.refreshed ? 'live-refresh' : 'live-list',
+        ...external,
+      };
+    });
+  providerResults.push({
+    provider: name,
+    refreshed: listed.refreshed,
+    error: listed.error,
+    count: listed.models.length,
+    rows,
+  });
+}
+
+const quickRows = [];
+for (const [provider, models] of Object.entries(QUICK_SEARCH_MODELS)) {
+  for (const model of models) {
+    if (model?.contextWindow == null) continue;
+    const external = externalMeta(modelsDev, litellm, provider, model.id);
+    const externalContext = external.modelsDevContext ?? external.litellmContext;
+    quickRows.push({
+      provider,
+      id: model.id,
+      staticContext: n(model.contextWindow),
+      externalContext,
+      mismatch: n(model.contextWindow) != null && externalContext != null && n(model.contextWindow) !== externalContext,
+    });
+  }
+}
+
+const mismatches = providerResults.flatMap(p => p.rows.filter(r => r.contextMismatch || r.outputMismatch));
+const exactOneM = providerResults.flatMap(p => p.rows.filter(r => r.liveContext === 1_000_000));
+const nearOneM = providerResults.flatMap(p => p.rows.filter(r => r.contextVerdict === 'near-1M-not-exact'));
+
+const report = {
+  generatedAt: new Date().toISOString(),
+  enabledProviders: Object.entries(cfg.providers || {}).filter(([, v]) => v?.enabled).map(([k]) => k),
+  providerResults,
+  mismatches,
+  exactOneM,
+  nearOneM,
+  quickStaticContextRows: quickRows,
+};
+
+if (json) {
+  console.log(JSON.stringify(report, null, 2));
+} else {
+  console.log(`model catalog audit @ ${report.generatedAt}`);
+  console.log(`enabled providers: ${report.enabledProviders.join(', ') || '-'}`);
+  for (const p of providerResults) {
+    console.log(`\n[${p.provider}] count=${p.count} refreshed=${p.refreshed}${p.error ? ` error=${p.error}` : ''}`);
+    for (const r of p.rows) {
+      const flags = [
+        r.contextMismatch ? `context ${r.liveContextLabel} != external ${r.externalContextLabel}` : '',
+        r.outputMismatch ? `output ${r.liveOutput} != external ${r.externalOutput}` : '',
+      ].filter(Boolean).join('; ');
+      console.log(`  ${r.id}: ${r.liveContextLabel} ctx, out=${r.liveOutput ?? '-'}${flags ? `  [${flags}]` : ''}`);
+    }
+  }
+  console.log(`\nsummary: mismatches=${mismatches.length}, exact1M=${exactOneM.length}, near1MNotExact=${nearOneM.length}, staticContextRows=${quickRows.length}`);
+  if (mismatches.length) {
+    console.log('mismatches:');
+    for (const r of mismatches.slice(0, 50)) {
+      console.log(`  ${r.provider}/${r.id}: live=${r.liveContextLabel}/${r.liveOutput ?? '-'} external=${r.externalContextLabel}/${r.externalOutput ?? '-'}`);
+    }
+  }
+}

package/scripts/model-list-sanitize-test.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { sanitizeModelList } from '../src/runtime/agent/orchestrator/providers/model-list-sanitize.mjs';
+
+test('Anthropic staleness keeps Claude subfamilies separate', () => {
+  const prev = process.env.MIXDOG_MODEL_STALE_MONTHS;
+  process.env.MIXDOG_MODEL_STALE_MONTHS = '0';
+  try {
+    const models = [
+      { id: 'claude-opus-4-8', mode: 'chat' },
+      { id: 'claude-sonnet-4-6', mode: 'chat' },
+      { id: 'claude-haiku-4-5-20251001', mode: 'chat' },
+    ];
+    const catalogRow = (release_date) => ({
+      family: 'claude',
+      release_date,
+      tool_call: true,
+      modalities: { output: ['text'] },
+    });
+    const out = sanitizeModelList(models, {
+      provider: 'anthropic',
+      _testCatalog: {
+        anthropic: {
+          models: {
+            'claude-opus-4-8': catalogRow('2025-12-01'),
+            'claude-sonnet-4-6': catalogRow('2025-11-01'),
+            'claude-haiku-4-5-20251001': catalogRow('2025-10-15'),
+          },
+        },
+      },
+    });
+    assert.deepEqual(out.map((m) => m.id), models.map((m) => m.id));
+  } finally {
+    if (prev == null) delete process.env.MIXDOG_MODEL_STALE_MONTHS;
+    else process.env.MIXDOG_MODEL_STALE_MONTHS = prev;
+  }
+});

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/provider-toolcall-test.mjs

@@ -946,17 +946,21 @@ test('anthropic effort: legacy sonnet-4-5 maps effort to thinking budget', () =>
     assert.equal(modelSupportsEffort(model), false);
 });
 
-test('anthropic effort: xhigh on opus-4-8 normalizes to max in output_config', () => {
+test('anthropic effort: xhigh on opus-4-8 is a first-class level (not downgraded to max)', () => {
+    // Opus 4.8 supports xhigh (modelSupportsXhighEffort), so xhigh is kept
+    // verbatim as a first-class effort level — matching codex's ReasoningEffort
+    // enum which lists xhigh between high and max. Only models WITHOUT xhigh
+    // support clamp it down to high.
     const model = 'claude-opus-4-8';
     assert.equal(modelSupportsMaxEffort(model), true);
-    assert.equal(normalizeAnthropicEffortInput('xhigh', model), 'max');
+    assert.equal(normalizeAnthropicEffortInput('xhigh', model), 'xhigh');
     const body = _buildRequestBodyForCacheSmoke(
         [{ role: 'user', content: 'hi' }],
         model,
         [],
         { effort: 'xhigh' },
     );
-    assert.deepEqual(body.output_config, { effort: 'max' });
+    assert.deepEqual(body.output_config, { effort: 'xhigh' });
     assert.equal(body.thinking, undefined);
 });