mixdog 0.7.18 → 0.8.1

package/scripts/live-worker-smoke.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { BRIDGE_TOOL, createStandaloneBridge } from '../src/standalone/bridge-tool.mjs';
+import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+import { executeBuiltinTool } from '../src/runtime/agent/orchestrator/tools/builtin.mjs';
+import { initProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
+import {
+  closeSession,
+  enqueuePendingMessage,
+  getSession,
+  getSessionLastProgressAt,
+  getSessionRuntime,
+  listSessions,
+} from '../src/runtime/agent/orchestrator/session/manager.mjs';
+
+const root = mkdtempSync(join(tmpdir(), 'mixdog-live-worker-'));
+const dataDir = join(root, '.mixdog-data');
+let activeAsks = 0;
+let maxActiveAsks = 0;
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function jobId(text) {
+  return String(text).match(/bridge job: (\S+)/)?.[1] || null;
+}
+
+async function main() {
+  const leadToolRules = readFileSync('src/rules/lead/00-tool-lead.md', 'utf8');
+  const workflowRules = readFileSync('src/defaults/user-workflow.md', 'utf8');
+  assert(/Use `bridge` to delegate actual scoped work/i.test(leadToolRules), 'lead rules must direct scoped work to bridge');
+  assert(/parallelize independent files\/concerns/i.test(leadToolRules), 'lead rules must keep independent work parallel');
+  assert(/Use bridge workers/i.test(workflowRules) && /parallelizes useful work/i.test(workflowRules), 'workflow rules must recommend bridge parallelism');
+  assert(/Prefer async by default/i.test(BRIDGE_TOOL.description || '') && /distinct tags/i.test(BRIDGE_TOOL.description || '') && /completion notification/i.test(BRIDGE_TOOL.description || ''), 'bridge tool description must expose async parallel tags');
+
+  mkdirSync(dataDir, { recursive: true });
+  await initProviders({ 'openai-oauth': { enabled: true } });
+  writeFileSync(join(dataDir, 'user-workflow.json'), JSON.stringify({
+    roles: [
+      { name: 'worker', preset: 'fake-worker', permission: 'full', maxLoopIterations: 3, idleTimeoutMs: 5000 },
+      { name: 'reviewer', preset: 'fake-reviewer', permission: 'read' },
+      { name: 'debugger', preset: 'fake-debugger', permission: 'read' },
+    ],
+  }));
+  writeFileSync(join(root, 'feature.txt'), 'alpha\nbeta\n', 'utf8');
+  writeFileSync(join(root, 'notes.txt'), 'TODO investigate timeout\n', 'utf8');
+
+  const cfgMod = {
+    loadConfig() {
+      return {
+        providers: { 'openai-oauth': { enabled: true } },
+        presets: [
+          { id: 'fake-worker', name: 'Fake Worker', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'full', effort: 'medium', fast: true },
+          { id: 'fake-reviewer', name: 'Fake Reviewer', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'readonly', effort: 'low' },
+          { id: 'fake-debugger', name: 'Fake Debugger', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'readonly', effort: 'low' },
+        ],
+      };
+    },
+    resolveRuntimeSpec(preset, ctx) {
+      return { lane: 'bridge', scopeKey: `smoke:${ctx.agentId}`, provider: preset.provider, model: preset.model };
+    },
+  };
+  const reg = { initProviders };
+
+  async function fakeAskSession(sessionId, prompt, _context, _onToolCall, cwdOverride) {
+    const session = getSession(sessionId);
+    if (session) {
+      session.status = 'running';
+      session.lastStreamDeltaAt = Date.now();
+    }
+    activeAsks += 1;
+    maxActiveAsks = Math.max(maxActiveAsks, activeAsks);
+    try {
+      if (/parallel slow/i.test(prompt)) await sleep(600);
+      if (/long busy/i.test(prompt)) await sleep(350);
+      if (/write implementation/i.test(prompt)) {
+        const out = await executePatchTool('apply_patch', {
+          base_path: cwdOverride,
+          patch: `*** Begin Patch
+*** Update File: feature.txt
+@@
+ alpha
+-beta
++beta from worker
+*** End Patch
+`,
+        }, cwdOverride);
+        return { content: `worker wrote feature\n${String(out).split(/\r?\n/)[0]}` };
+      }
+      if (/run verification/i.test(prompt)) {
+        const out = await executeBuiltinTool('shell', {
+          command: 'Get-Content feature.txt',
+          cwd: cwdOverride,
+          shell: 'powershell',
+          timeout: 30_000,
+        }, cwdOverride);
+        return { content: `verification\n${out}` };
+      }
+      if (/review/i.test(prompt)) {
+        const body = readFileSync(join(cwdOverride, 'feature.txt'), 'utf8');
+        return { content: body.includes('worker') ? 'reviewer ok' : 'reviewer missing worker change' };
+      }
+      if (/debug/i.test(prompt)) {
+        return { content: `debugger ${readFileSync(join(cwdOverride, 'notes.txt'), 'utf8').trim()}` };
+      }
+      return { content: `ack ${session?.role || 'worker'}` };
+    } finally {
+      activeAsks -= 1;
+      if (session) {
+        session.status = 'idle';
+        session.lastUsedAt = new Date().toISOString();
+        session.lastStreamDeltaAt = Date.now();
+      }
+    }
+  }
+
+  const mgr = {
+    getSession,
+    listSessions,
+    closeSession,
+    getSessionRuntime,
+    enqueuePendingMessage,
+    getSessionLastProgressAt,
+    askSession: fakeAskSession,
+  };
+  const bridge = createStandaloneBridge({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
+
+  async function waitJob(out, pattern, label) {
+    const id = jobId(out);
+    assert(id, `missing job id for ${label}: ${out}`);
+    let last = '';
+    for (let i = 0; i < 40; i += 1) {
+      last = await bridge.execute({ type: 'read', jobId: id }, { invocationSource: 'model-tool', cwd: root });
+      if (pattern.test(last)) return last;
+      if (/^Error[\s:[]/.test(last) || /status: error/.test(last)) break;
+      await sleep(100);
+    }
+    throw new Error(`${label} did not finish with ${pattern}: ${last}`);
+  }
+
+  const spawnOut = await bridge.execute({
+    type: 'spawn',
+    role: 'worker',
+    tag: 'impl1',
+    cwd: root,
+    prompt: 'write implementation: update feature.txt with apply_patch',
+  }, { invocationSource: 'model-tool', cwd: root });
+  await waitJob(spawnOut, /worker wrote feature/, 'worker write');
+
+  const sendOut = await bridge.execute({
+    type: 'send',
+    tag: 'impl1',
+    message: 'run verification: inspect feature.txt using bash',
+  }, { invocationSource: 'model-tool', cwd: root });
+  assert(/bridge job:/.test(sendOut), `completed worker send should be async job, got ${sendOut}`);
+  await waitJob(sendOut, /beta from worker/, 'worker verify');
+
+  const reviewOut = await bridge.execute({
+    type: 'spawn',
+    role: 'reviewer',
+    tag: 'rev1',
+    cwd: root,
+    prompt: 'review feature.txt for the worker change',
+  }, { invocationSource: 'model-tool', cwd: root });
+  const debugOut = await bridge.execute({
+    type: 'spawn',
+    role: 'debugger',
+    tag: 'dbg1',
+    cwd: root,
+    prompt: 'debug notes.txt timeout clue',
+  }, { invocationSource: 'model-tool', cwd: root });
+  await waitJob(reviewOut, /reviewer ok/, 'reviewer');
+  await waitJob(debugOut, /debugger TODO/, 'debugger');
+
+  const parallelSpawns = await Promise.all([
+    bridge.execute({
+      type: 'spawn',
+      role: 'worker',
+      tag: 'parWorker',
+      cwd: root,
+      prompt: 'parallel slow worker task',
+    }, { invocationSource: 'model-tool', cwd: root }),
+    bridge.execute({
+      type: 'spawn',
+      role: 'reviewer',
+      tag: 'parReviewer',
+      cwd: root,
+      prompt: 'parallel slow review task',
+    }, { invocationSource: 'model-tool', cwd: root }),
+    bridge.execute({
+      type: 'spawn',
+      role: 'debugger',
+      tag: 'parDebugger',
+      cwd: root,
+      prompt: 'parallel slow debug task',
+    }, { invocationSource: 'model-tool', cwd: root }),
+  ]);
+  assert(parallelSpawns.every((out) => /bridge job:/.test(out)), `parallel spawns must return jobs: ${parallelSpawns.join('\n---\n')}`);
+  await Promise.all([
+    waitJob(parallelSpawns[0], /ack worker/, 'parallel worker'),
+    waitJob(parallelSpawns[1], /reviewer ok/, 'parallel reviewer'),
+    waitJob(parallelSpawns[2], /debugger TODO/, 'parallel debugger'),
+  ]);
+  assert(maxActiveAsks >= 2, `bridge workers did not overlap; maxActiveAsks=${maxActiveAsks}`);
+
+  const busyOut = await bridge.execute({
+    type: 'spawn',
+    role: 'worker',
+    tag: 'busy1',
+    cwd: root,
+    prompt: 'long busy worker task',
+  }, { invocationSource: 'model-tool', cwd: root });
+  const queued = await bridge.execute({
+    type: 'send',
+    tag: 'busy1',
+    message: 'follow-up while still busy',
+  }, { invocationSource: 'model-tool', cwd: root });
+  assert(/bridge message queued/.test(queued), `busy send should queue, got ${queued}`);
+  await waitJob(busyOut, /ack worker/, 'busy worker');
+
+  const missing = await bridge.execute({ type: 'read', jobId: 'job_missing_live_smoke' }, { invocationSource: 'model-tool', cwd: root });
+  assert(/^Error[\s:[]/.test(missing), 'missing bridge job should be Error result');
+  assert(readFileSync(join(root, 'feature.txt'), 'utf8').includes('beta from worker'), 'final file missing worker edit');
+  bridge.closeAll('live-worker-smoke-end');
+  process.stdout.write('live worker smoke passed\n');
+}
+
+try {
+  await main();
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}

package/scripts/output-style-smoke.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+const rulesBuilder = require('../src/lib/rules-builder.cjs');
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function assertCleanOutput(name, value, { maxLines = 2, maxBullets = 3 } = {}) {
+  const text = String(value || '').trim();
+  assert(text, `${name}: empty output`);
+  assert(!/\n\s*\n/.test(text), `${name}: multiple paragraphs are not compact`);
+  assert(!/^\s*#{1,6}\s/m.test(text), `${name}: heading found`);
+  assert(!/^\s*\d+[.)]\s/m.test(text), `${name}: numbered list found`);
+  assert(!/^\s{2,}[-*]\s/m.test(text), `${name}: nested bullet found`);
+  assert(!/^\s*[\p{L}\p{N}][\p{L}\p{N} _-]{0,30}:\s/um.test(text), `${name}: report label found`);
+  assert(!/\b(?:tool trace|session metadata|model metadata|searched-path list)\b/i.test(text), `${name}: tool/meta trace found`);
+  assert(!/\b(?:Mapped|Searched|Read|Called) for \d/i.test(text), `${name}: timing/tool status found`);
+  assert(!/^(?:네|예|맞아요|좋아요|알겠습니다|Sure|Okay|Understood)[,.\s]/i.test(text), `${name}: acknowledgment preface found`);
+  assert(!/(.+)(?:\n|\s{2,})\1/.test(text), `${name}: repeated conclusion found`);
+
+  const lines = text.split(/\r?\n/).filter((line) => line.trim());
+  const bulletLines = lines.filter((line) => /^\s*[-*]\s+/.test(line));
+  if (bulletLines.length > 0) {
+    assert(bulletLines.length === lines.length, `${name}: mixed prose and bullets`);
+    assert(bulletLines.length <= maxBullets, `${name}: too many bullets`);
+    return;
+  }
+  assert(lines.length <= maxLines, `${name}: too many lines`);
+
+  const withoutCode = text.replace(/`[^`]*`/g, '');
+  const sentenceMarks = withoutCode.match(/[.!?。！？]|다\.|요\./g) || [];
+  assert(sentenceMarks.length <= 2, `${name}: too many sentences`);
+}
+
+const defaultStyle = readFileSync(join(root, 'src', 'output-styles', 'default.md'), 'utf8');
+for (const required of [
+  'name: default',
+  'Uniformity beats local cleverness.',
+  'One answer only.',
+  'Hard cap user-visible replies at 2 short sentences',
+  'Explore/retrieval results are evidence only',
+  'Do not use label prefixes',
+]) {
+  assert(defaultStyle.includes(required), `default.md missing: ${required}`);
+}
+assert(!defaultStyle.includes('Claude Code-compact'), 'default.md must not reference the old compact style name');
+
+const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-output-style-smoke-'));
+try {
+  writeFileSync(join(dataDir, 'user-workflow.md'), 'workflow context should not override output style\n');
+  const leadRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
+  const outputStyleIndex = leadRules.lastIndexOf('# Output Style');
+  assert(outputStyleIndex >= 0, 'Lead output style missing');
+  assert(outputStyleIndex > leadRules.lastIndexOf('# User Workflow'), 'Lead output style must be injected after workflow/user context');
+
+  mkdirSync(join(dataDir, 'output-styles'), { recursive: true });
+  writeFileSync(join(dataDir, 'mixdog-config.json'), JSON.stringify({ outputStyle: 'custom-smoke' }));
+  writeFileSync(join(dataDir, 'output-styles', 'custom-smoke.md'), '---\nname: custom-smoke\n---\n\n# Custom Output Style\n\ncustom smoke style\n');
+  const customRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
+  assert(customRules.includes('# Custom Output Style'), 'configured outputStyle must select custom style');
+  assert(!customRules.includes('Default concise engineering replies'), 'custom outputStyle should not append default style');
+} finally {
+  rmSync(dataDir, { recursive: true, force: true });
+}
+
+const goodOutputs = {
+  explanation: '기본 출력은 한 문장으로 결론만 말하고, 추가 설명은 사용자가 요청할 때만 붙입니다.',
+  implementation: 'default 출력 스타일을 한 문장 우선으로 조였고 `npm run smoke:output`으로 확인했습니다.',
+  crowded: '- default 스타일은 한 문장 우선입니다.\n- 상세/후보 요청이 있을 때만 목록을 펼칩니다.',
+  blocker: '`src/output-styles/default.md`를 찾을 수 없어 변경이 막혔습니다.',
+  semicolon: '`default.md`를 다듬었고; 출력 스모크가 예시 응답 모양을 검증합니다.',
+};
+for (const [name, output] of Object.entries(goodOutputs)) assertCleanOutput(name, output);
+
+const badOutputs = {
+  heading: '## Summary\nDone.',
+  label: 'Changed: updated default style.',
+  koreanLabel: '변경: default 스타일을 수정했습니다.\n검증: 스모크를 통과했습니다.',
+  numbered: '1. Updated style\n2. Ran smoke',
+  paragraphs: 'Done.\n\nDone again.',
+  nested: '- Updated\n  - Nested detail',
+  ack: '네, default 스타일을 수정했습니다.',
+  timing: 'Mapped for 2m 32s\n\ndefault 스타일을 수정했습니다.',
+  tooManySentences: '수정했습니다. 검증했습니다. 보고했습니다.',
+  mixed: '수정했습니다.\n- 검증했습니다.',
+};
+for (const [name, output] of Object.entries(badOutputs)) {
+  let failed = false;
+  try { assertCleanOutput(`bad:${name}`, output); } catch { failed = true; }
+  assert(failed, `bad sample unexpectedly passed: ${name}`);
+}
+
+process.stdout.write(`output style smoke passed samples=${Object.keys(goodOutputs).length}\n`);

package/scripts/session-context-bench.mjs

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig, getDefaultPreset, getPreset } from '../src/runtime/agent/orchestrator/config.mjs';
+import { initProviders, getProvider } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
+import { loadSession } from '../src/runtime/agent/orchestrator/session/store.mjs';
+import { semanticCompactMessages } from '../src/runtime/agent/orchestrator/session/compact.mjs';
+import { estimateMessagesTokens } from '../src/runtime/agent/orchestrator/session/context-utils.mjs';
+import * as memory from '../src/runtime/memory/index.mjs';
+
+const ROOT = resolve(fileURLToPath(new URL('..', import.meta.url)));
+
+function arg(name, fallback = null) {
+  const prefix = `--${name}=`;
+  const found = process.argv.find((item) => item.startsWith(prefix));
+  if (found) return found.slice(prefix.length);
+  const idx = process.argv.indexOf(`--${name}`);
+  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
+  return fallback;
+}
+
+function flag(name) {
+  return process.argv.includes(`--${name}`);
+}
+
+function textOfResult(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result.content.map((part) => part?.type === 'text' ? part.text || '' : JSON.stringify(part)).join('\n');
+  }
+  if (typeof result === 'string') return result;
+  return JSON.stringify(result ?? '', null, 2);
+}
+
+function messageText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === 'string') return part;
+      if (part?.type === 'text') return part.text || '';
+      if (part?.type === 'image') return '[image]';
+      return part?.text || '';
+    }).filter(Boolean).join('\n');
+  }
+  try { return JSON.stringify(content ?? ''); } catch { return String(content ?? ''); }
+}
+
+function renderMessages(messages) {
+  return (messages || [])
+    .map((m, i) => `# message ${i + 1} role=${m.role}\n${messageText(m.content)}`.trim())
+    .join('\n\n');
+}
+
+function coverageScore(sourceText, candidateText) {
+  const terms = [...new Set(String(sourceText || '').toLowerCase().match(/[\p{L}\p{N}_./:-]{4,}/gu) || [])]
+    .filter((term) => !/^(https?|that|this|with|from|have|there|would|could|should)$/i.test(term))
+    .slice(0, 5000);
+  if (!terms.length) return 0;
+  const hay = String(candidateText || '').toLowerCase();
+  let hit = 0;
+  for (const term of terms) if (hay.includes(term)) hit += 1;
+  return Number((hit / terms.length).toFixed(4));
+}
+
+async function providerFromConfig(config, { providerName, modelName }) {
+  await initProviders(config.providers || {});
+  let provider = providerName;
+  let model = modelName;
+  if (!provider || !model) {
+    const presetName = arg('preset', null);
+    const preset = presetName ? getPreset(config, presetName) : getDefaultPreset(config);
+    provider ||= preset?.provider;
+    model ||= preset?.model;
+  }
+  if (!provider || !model) throw new Error('provider/model required; pass --provider and --model or configure a default preset');
+  const impl = getProvider(provider);
+  if (!impl) throw new Error(`provider not available: ${provider}`);
+  return { provider, model, impl };
+}
+
+async function judgePair(provider, model, sourceText, semanticText, recallText) {
+  const prompt = `You are judging two context-compression strategies for continuing a coding session.\n\nEvaluate which preserves actionable state better for the next assistant turn. Prefer factual coverage, exact constraints, file paths, decisions, and current task continuity.\n\nReturn strict JSON: {"winner":"semantic"|"recall_roots"|"tie","semantic_score":1-10,"recall_roots_score":1-10,"reason":"short"}.\n\n# Original session excerpt\n${sourceText.slice(0, 30000)}\n\n# Candidate A: semantic compact\n${semanticText.slice(0, 30000)}\n\n# Candidate B: recall root/raw chunks\n${recallText.slice(0, 30000)}`;
+  const response = await provider.send([
+    { role: 'system', content: 'Judge compression quality. Output JSON only.' },
+    { role: 'user', content: prompt },
+  ], model, undefined, { effort: 'low', fast: true, maxOutputTokens: 800 });
+  const text = String(response?.content || '').trim();
+  try { return JSON.parse(text.replace(/^```json\s*/i, '').replace(/```$/i, '').trim()); }
+  catch { return { raw: text }; }
+}
+
+async function main() {
+  if (flag('help') || flag('h')) {
+    process.stdout.write('usage: node scripts/session-context-bench.mjs --session <sessionId> [--provider p --model m] [--preset name] [--budget n] [--judge]\n');
+    return;
+  }
+  const sessionId = arg('session');
+  if (!sessionId) throw new Error('usage: node scripts/session-context-bench.mjs --session <sessionId> [--provider p --model m] [--judge]');
+  const session = loadSession(sessionId);
+  if (!session) throw new Error(`session not found: ${sessionId}`);
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  if (!messages.length) throw new Error(`session has no messages: ${sessionId}`);
+
+  const config = loadConfig();
+  const { provider, model, impl } = await providerFromConfig(config, {
+    providerName: arg('provider', session.provider || null),
+    modelName: arg('model', session.model || null),
+  });
+
+  await memory.init();
+  await memory.handleToolCall('memory', {
+    action: 'ingest_session',
+    sessionId,
+    cwd: session.cwd || ROOT,
+    messages,
+    limit: Number(arg('ingest-limit', 500)) || 500,
+  });
+  await memory.handleToolCall('memory', {
+    action: 'cycle1',
+    min_batch: 1,
+    session_cap: 1,
+    batch_size: Math.max(1, Math.min(200, Number(arg('batch-size', messages.length)) || messages.length)),
+  });
+  const recallDumpResult = await memory.handleToolCall('memory', {
+    action: 'dump_session_roots',
+    sessionId,
+    includeRaw: true,
+    limit: Number(arg('limit', 1000)) || 1000,
+  });
+  const recallText = textOfResult(recallDumpResult);
+
+  const budget = Number(arg('budget', 16000)) || 16000;
+  const semantic = await semanticCompactMessages(impl, messages, model, budget, {
+    force: true,
+    sessionId,
+    providerName: provider,
+    tailTurns: Number(arg('tail-turns', 2)) || 2,
+    timeoutMs: Number(arg('timeout-ms', 60000)) || 60000,
+  });
+  const semanticText = renderMessages(semantic.messages);
+  const sourceText = renderMessages(messages);
+
+  const report = {
+    sessionId,
+    provider,
+    model,
+    source: { messages: messages.length, tokens: estimateMessagesTokens(messages), chars: sourceText.length },
+    semantic: { messages: semantic.messages.length, tokens: estimateMessagesTokens(semantic.messages), chars: semanticText.length, lexicalCoverage: coverageScore(sourceText, semanticText), usage: semantic.usage || null },
+    recallRoots: { chars: recallText.length, lexicalCoverage: coverageScore(sourceText, recallText) },
+    judge: null,
+  };
+  if (flag('judge')) {
+    report.judge = await judgePair(impl, model, sourceText, semanticText, recallText);
+  }
+
+  const outDir = resolve(arg('out', join(ROOT, '.mixdog-bench', `session-context-${sessionId}`)));
+  mkdirSync(outDir, { recursive: true });
+  writeFileSync(join(outDir, 'source.txt'), sourceText, 'utf8');
+  writeFileSync(join(outDir, 'semantic.txt'), semanticText, 'utf8');
+  writeFileSync(join(outDir, 'recall-roots.txt'), recallText, 'utf8');
+  writeFileSync(join(outDir, 'report.json'), JSON.stringify(report, null, 2), 'utf8');
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\noutputs: ${outDir}\n`);
+}
+
+main()
+  .catch((err) => {
+    process.stderr.write(`${err?.stack || err?.message || err}\n`);
+    process.exitCode = 1;
+  })
+  .finally(async () => {
+    try { await memory.stop?.(); } catch {}
+  });