mixdog 0.8.1 → 0.9.0

package/scripts/sanitize-tool-pairs-test.mjs

@@ -0,0 +1,260 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { sanitizeToolPairs, sanitizeAnthropicContentPairs } from '../src/runtime/agent/orchestrator/session/context-utils.mjs';
+import { repairTranscriptBeforeProviderSend } from '../src/runtime/agent/orchestrator/session/loop.mjs';
+
+const TOOL_MISSING_STUB = '[Older tool result unavailable after context compaction]';
+
+const assistantA = {
+    role: 'assistant',
+    content: '',
+    toolCalls: [{ id: 'call_a', name: 'grep', arguments: {} }],
+};
+
+const toolA = {
+    role: 'tool',
+    toolCallId: 'call_a',
+    content: 'grep output',
+    toolKind: 'normal',
+};
+
+test('reattaches interleaved tool result immediately after assistant toolCalls', () => {
+    const user = { role: 'user', content: 'continue' };
+    const input = [assistantA, user, toolA];
+    const out = sanitizeToolPairs(input);
+
+    assert.deepEqual(out, [assistantA, toolA, user]);
+    assert.equal(out.filter((m) => m.role === 'tool').length, 1);
+});
+
+test('contiguous block for multiple toolCalls when results were separated', () => {
+    const assistant = {
+        role: 'assistant',
+        content: '',
+        toolCalls: [
+            { id: 'call_a', name: 'read', arguments: {} },
+            { id: 'call_b', name: 'grep', arguments: {} },
+        ],
+    };
+    const user = { role: 'user', content: 'next' };
+    const input = [
+        assistant,
+        { role: 'tool', toolCallId: 'call_a', content: 'a', toolKind: 'normal' },
+        user,
+        { role: 'tool', toolCallId: 'call_b', content: 'b', toolKind: 'normal' },
+    ];
+    const out = sanitizeToolPairs(input);
+
+    assert.equal(out.length, 4);
+    assert.equal(out[0], assistant);
+    assert.equal(out[1].toolCallId, 'call_a');
+    assert.equal(out[1].content, 'a');
+    assert.equal(out[2].toolCallId, 'call_b');
+    assert.equal(out[3], user);
+});
+
+test('inserts stub when assistant toolCall has no matching tool message', () => {
+    const out = sanitizeToolPairs([assistantA, { role: 'user', content: 'hi' }]);
+
+    assert.equal(out.length, 3);
+    assert.equal(out[1].role, 'tool');
+    assert.equal(out[1].toolCallId, 'call_a');
+    assert.equal(out[1].content, TOOL_MISSING_STUB);
+});
+
+test('drops tool messages with no surviving assistant tool_call', () => {
+    const orphan = { role: 'tool', toolCallId: 'orphan', content: 'gone' };
+    const out = sanitizeToolPairs([orphan, { role: 'user', content: 'hi' }]);
+
+    assert.deepEqual(out, [{ role: 'user', content: 'hi' }]);
+});
+
+test('drops malformed tool messages without toolCallId', () => {
+    const malformed = { role: 'tool', content: 'no id' };
+    const out = sanitizeToolPairs([malformed, assistantA, toolA]);
+
+    assert.equal(out.length, 2);
+    assert.equal(out[0], assistantA);
+    assert.equal(out[1].toolCallId, 'call_a');
+});
+
+test('duplicate same-id prefers valid result after assistant over stale before', () => {
+    const stale = { role: 'tool', toolCallId: 'call_a', content: 'stale', toolKind: 'normal' };
+    const valid = { role: 'tool', toolCallId: 'call_a', content: 'valid', toolKind: 'normal' };
+    const out = sanitizeToolPairs([stale, assistantA, { role: 'user', content: 'x' }, valid]);
+
+    assert.equal(out.length, 3);
+    assert.equal(out[1].content, 'valid');
+});
+
+test('duplicate same-id in contiguous block after assistant keeps first there', () => {
+    const first = { role: 'tool', toolCallId: 'call_a', content: 'first', toolKind: 'normal' };
+    const second = { role: 'tool', toolCallId: 'call_a', content: 'second', toolKind: 'normal' };
+    const out = sanitizeToolPairs([assistantA, first, { role: 'user', content: 'x' }, second]);
+
+    assert.equal(out.length, 3);
+    assert.equal(out[1].content, 'first');
+});
+
+test('debugger06: assistantBlocks + role tool keeps REAL_BODY after sanitizeToolPairs', () => {
+    const REAL_BODY = 'REAL_BODY from debugger06 fixture';
+    const assistant = {
+        role: 'assistant',
+        content: '',
+        assistantBlocks: [
+            { type: 'text', text: 'calling tool' },
+            { type: 'tool_use', id: 'call_blocks', name: 'read', input: { path: 'x' } },
+        ],
+    };
+    const toolMsg = {
+        role: 'tool',
+        toolCallId: 'call_blocks',
+        content: REAL_BODY,
+        toolKind: 'normal',
+    };
+    const user = { role: 'user', content: 'next' };
+    const out = sanitizeToolPairs([assistant, user, toolMsg]);
+
+    assert.equal(out.length, 3);
+    assert.equal(out[0], assistant);
+    assert.equal(out[1].role, 'tool');
+    assert.equal(out[1].toolCallId, 'call_blocks');
+    assert.equal(out[1].content, REAL_BODY);
+    assert.equal(out[2], user);
+});
+
+test('debugger06: assistant content tool_use + role tool keeps REAL_BODY after sanitizeToolPairs', () => {
+    const REAL_BODY = 'REAL_BODY content-array fixture';
+    const assistant = {
+        role: 'assistant',
+        content: [
+            { type: 'text', text: 'hi' },
+            { type: 'tool_use', id: 'call_content', name: 'grep', input: {} },
+        ],
+    };
+    const toolMsg = {
+        role: 'tool',
+        toolCallId: 'call_content',
+        content: REAL_BODY,
+    };
+    const out = sanitizeToolPairs([assistant, toolMsg]);
+
+    assert.equal(out.length, 2);
+    assert.equal(out[1].content, REAL_BODY);
+});
+
+test('sanitizeAnthropicContentPairs reorders tool_result before user text for multi-tool assistant', () => {
+    const assistant = {
+        role: 'assistant',
+        content: [
+            { type: 'tool_use', id: 'call_a', name: 'read', input: {} },
+            { type: 'tool_use', id: 'call_b', name: 'grep', input: {} },
+        ],
+    };
+    const user = {
+        role: 'user',
+        content: [
+            { type: 'text', text: 'continue after tools' },
+            { type: 'tool_result', tool_use_id: 'call_a', content: 'a out' },
+            { type: 'tool_result', tool_use_id: 'call_b', content: 'b out' },
+        ],
+    };
+    const out = sanitizeAnthropicContentPairs([assistant, user]);
+
+    assert.equal(out.length, 2);
+    assert.equal(out[1].content[0].type, 'tool_result');
+    assert.equal(out[1].content[1].type, 'tool_result');
+    assert.equal(out[1].content[2].type, 'text');
+});
+
+test('sanitizeAnthropicContentPairs inserts user tool_result when no following user message', () => {
+    const assistant = {
+        role: 'assistant',
+        content: [{ type: 'tool_use', id: 'call_x', name: 'shell', input: {} }],
+    };
+    const out = sanitizeAnthropicContentPairs([assistant]);
+
+    assert.equal(out.length, 2);
+    assert.equal(out[0], assistant);
+    assert.equal(out[1].role, 'user');
+    assert.equal(out[1].content.length, 1);
+    assert.equal(out[1].content[0].type, 'tool_result');
+    assert.equal(out[1].content[0].tool_use_id, 'call_x');
+});
+
+test('sanitizeAnthropicContentPairs stubs missing ids and leads with all tool_result blocks', () => {
+    const assistant = {
+        role: 'assistant',
+        content: [
+            { type: 'tool_use', id: 'call_a', name: 'read', input: {} },
+            { type: 'tool_use', id: 'call_b', name: 'grep', input: {} },
+        ],
+    };
+    const user = {
+        role: 'user',
+        content: [
+            { type: 'text', text: 'steer' },
+            { type: 'tool_result', tool_use_id: 'call_a', content: 'only a' },
+        ],
+    };
+    const out = sanitizeAnthropicContentPairs([assistant, user]);
+    const blocks = out[1].content;
+
+    assert.equal(blocks[0].type, 'tool_result');
+    assert.equal(blocks[0].tool_use_id, 'call_b');
+    assert.equal(blocks[1].type, 'tool_result');
+    assert.equal(blocks[1].tool_use_id, 'call_a');
+    assert.equal(blocks[2].type, 'text');
+});
+
+test('debugger06: sanitizeAnthropicContentPairs drops leading orphan tool_result', () => {
+    const leadingOrphan = {
+        role: 'user',
+        content: [{ type: 'tool_result', tool_use_id: 'stale_lead', content: 'orphan' }],
+    };
+    const assistant = {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'hello' }],
+    };
+    const out = sanitizeAnthropicContentPairs([leadingOrphan, assistant]);
+
+    assert.equal(out.length, 1);
+    assert.equal(out[0].role, 'assistant');
+});
+
+test('debugger06: sanitizeAnthropicContentPairs drops stale tool_result and reorders valid', () => {
+    const assistant = {
+        role: 'assistant',
+        content: [{ type: 'tool_use', id: 'call_live', name: 'read', input: {} }],
+    };
+    const user = {
+        role: 'user',
+        content: [
+            { type: 'tool_result', tool_use_id: 'stale_other', content: 'drop me' },
+            { type: 'text', text: 'between' },
+            { type: 'tool_result', tool_use_id: 'call_live', content: 'VALID_KEEP' },
+        ],
+    };
+    const out = sanitizeAnthropicContentPairs([assistant, user]);
+    const blocks = out[1].content;
+
+    assert.equal(blocks[0].type, 'tool_result');
+    assert.equal(blocks[0].tool_use_id, 'call_live');
+    assert.equal(blocks[0].content, 'VALID_KEEP');
+    assert.equal(blocks[1].type, 'text');
+    assert.ok(!blocks.some((b) => b.tool_use_id === 'stale_other'));
+});
+
+test('loop pre-send repair reattaches separated assistant/tool instead of deleting', () => {
+    const user = { role: 'user', content: 'steer' };
+    const msgs = [assistantA, user, { ...toolA }];
+    repairTranscriptBeforeProviderSend(msgs, 'test-sess');
+
+    assert.equal(msgs.length, 3);
+    assert.equal(msgs[0].role, 'assistant');
+    assert.equal(msgs[1].toolCallId, 'call_a');
+    assert.equal(msgs[1].content, 'grep output');
+    assert.equal(msgs[2], user);
+});
+
+

package/scripts/session-context-bench.mjs

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } 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)));
+let memoryModule = null;
 
 function arg(name, fallback = null) {
   const prefix = `--${name}=`;
@@ -24,14 +24,50 @@ function flag(name) {
   return process.argv.includes(`--${name}`);
 }
 
+function isMainScript() {
+  return import.meta.url === pathToFileURL(process.argv[1] || '').href;
+}
+
+async function withTimeout(promise, ms) {
+  const timeoutMs = Number(ms) || 0;
+  if (!(timeoutMs > 0)) return { timedOut: false, value: await promise };
+  let timer = null;
+  try {
+    return await Promise.race([
+      Promise.resolve(promise).then((value) => ({ timedOut: false, value })),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ timedOut: true }), timeoutMs);
+        timer.unref?.();
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 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 (result && typeof result === 'object' && typeof result.content === 'string') return result.content;
   if (typeof result === 'string') return result;
   return JSON.stringify(result ?? '', null, 2);
 }
 
+function directCycle1Llm(provider, model) {
+  return async (_opts, prompt) => {
+    const response = await provider.send([
+      { role: 'system', content: 'You chunk memory entries. Output only the requested line format; no prose, no markdown.' },
+      { role: 'user', content: String(prompt || '') },
+    ], model, undefined, {
+      effort: 'low',
+      fast: true,
+      maxOutputTokens: Number(arg('cycle1-max-output-tokens', 1200)) || 1200,
+    });
+    return textOfResult(response).trim();
+  };
+}
+
 function messageText(content) {
   if (typeof content === 'string') return content;
   if (Array.isArray(content)) {
@@ -62,6 +98,114 @@ function coverageScore(sourceText, candidateText) {
   return Number((hit / terms.length).toFixed(4));
 }
 
+function latestUserText(messages, max = 1600) {
+  for (let i = (messages || []).length - 1; i >= 0; i -= 1) {
+    if (messages[i]?.role !== 'user') continue;
+    const text = messageText(messages[i].content).trim();
+    if (text) return text.slice(-max);
+  }
+  return '';
+}
+
+function recallQueryForSession(messages) {
+  return [
+    latestUserText(messages),
+    'current task decisions constraints file paths changed files verification failures next steps',
+  ].filter(Boolean).join('\n').slice(0, 2400);
+}
+
+function parseCycle1Text(text) {
+  const value = String(text || '');
+  const num = (name) => {
+    const match = new RegExp(`${name}=([0-9]+)`).exec(value);
+    return match ? Number(match[1]) : null;
+  };
+  return {
+    chunks: num('chunks'),
+    processed: num('processed'),
+    skippedChunks: num('skipped_chunks'),
+    omitted: num('omitted'),
+    failedRows: num('failed_rows'),
+    invalidChunks: num('invalid_chunks'),
+    pending: num('pending'),
+    inFlight: /inFlight=true/.test(value),
+    timedOut: /timedOut=true/.test(value),
+  };
+}
+
+function rawChunkCount(dumpResult) {
+  const chunks = Array.isArray(dumpResult?.chunks) ? dumpResult.chunks : [];
+  return chunks.filter((chunk) => chunk?.kind === 'raw').length;
+}
+
+async function dumpSessionRoots(memoryModule, sessionId, limit) {
+  return await memoryModule.handleToolCall('memory', {
+    action: 'dump_session_roots',
+    sessionId,
+    includeRaw: true,
+    limit,
+  });
+}
+
+async function drainCycle1ForSession(memoryModule, sessionId, options = {}) {
+  const maxPasses = Math.max(1, Number(options.maxPasses) || 4);
+  const windowSize = Math.max(1, Number(options.windowSize) || 50);
+  const concurrency = Math.max(1, Math.min(8, Number(options.concurrency) || 4));
+  const rowsPerSession = Math.max(windowSize, Number(options.rowsPerSession) || (windowSize * concurrency));
+  const callerDeadlineMs = Math.max(0, Number(options.callerDeadlineMs) || 0);
+  const callLlm = typeof options.callLlm === 'function' ? options.callLlm : null;
+  const limit = Math.max(1, Number(options.limit) || 1000);
+  const runs = [];
+  let rawRemaining = null;
+  for (let pass = 1; pass <= maxPasses; pass += 1) {
+    const beforeDump = await dumpSessionRoots(memoryModule, sessionId, limit);
+    const rawBefore = rawChunkCount(beforeDump);
+    rawRemaining = rawBefore;
+    if (rawBefore === 0) break;
+    const startedAt = Date.now();
+    const cycle = await memoryModule.handleToolCall('memory', {
+      action: 'cycle1',
+      sessionId,
+      min_batch: 1,
+      session_cap: 1,
+      batch_size: windowSize,
+      window_size: windowSize,
+      rows_per_session: rowsPerSession,
+      concurrency,
+      ...(callerDeadlineMs > 0 ? { _callerDeadlineMs: callerDeadlineMs } : {}),
+      ...(callLlm ? { _callLlm: callLlm } : {}),
+    });
+    const text = textOfResult(cycle);
+    const parsed = parseCycle1Text(text);
+    const afterDump = await dumpSessionRoots(memoryModule, sessionId, limit);
+    const rawAfter = rawChunkCount(afterDump);
+    rawRemaining = rawAfter;
+    runs.push({
+      pass,
+      ms: Date.now() - startedAt,
+      rawBefore,
+      rawAfter,
+      ...parsed,
+      quality: cycle?.quality || null,
+      invalidChunksDetail: Array.isArray(cycle?.invalid_chunks) ? cycle.invalid_chunks.slice(0, 5) : [],
+      failedRowIds: Array.isArray(cycle?.failed_row_ids) ? cycle.failed_row_ids.slice(0, 20) : [],
+      text,
+    });
+    if (rawAfter === 0) break;
+    if ((parsed.processed || 0) === 0 && (parsed.chunks || 0) === 0 && rawAfter >= rawBefore) break;
+  }
+  return { maxPasses, windowSize, rowsPerSession, concurrency, callerDeadlineMs, rawRemaining, runs };
+}
+
+async function timed(label, timings, fn) {
+  const startedAt = Date.now();
+  try {
+    return await fn();
+  } finally {
+    timings[label] = Date.now() - startedAt;
+  }
+}
+
 async function providerFromConfig(config, { providerName, modelName }) {
   await initProviders(config.providers || {});
   let provider = providerName;
@@ -78,8 +222,9 @@ async function providerFromConfig(config, { providerName, modelName }) {
   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)}`;
+async function judgePair(provider, model, sourceText, semanticText, candidateBText, candidateBLabel) {
+  const safeLabel = String(candidateBLabel || 'candidate_b').replace(/[^a-z0-9_]+/gi, '_').toLowerCase() || 'candidate_b';
+  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"|"${safeLabel}"|"tie","semantic_score":1-10,"${safeLabel}_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: ${safeLabel}\n${candidateBText.slice(0, 30000)}`;
   const response = await provider.send([
     { role: 'system', content: 'Judge compression quality. Output JSON only.' },
     { role: 'user', content: prompt },
@@ -91,7 +236,7 @@ async function judgePair(provider, model, sourceText, semanticText, recallText)
 
 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');
+    process.stdout.write('usage: node scripts/session-context-bench.mjs --session <sessionId> [--provider p --model m] [--preset name] [--budget n] [--judge] [--recall-query q]\n');
     return;
   }
   const sessionId = arg('session');
@@ -107,57 +252,75 @@ async function main() {
     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 timings = {};
   const budget = Number(arg('budget', 16000)) || 16000;
-  const semantic = await semanticCompactMessages(impl, messages, model, budget, {
+  const semantic = await timed('semantic_compact_ms', timings, () => 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 candidateB = 'recall';
+  let candidateBText = '';
+  let candidateBMeta = null;
+  memoryModule = await import('../src/runtime/memory/index.mjs');
+  await timed('memory_init_ms', timings, () => memoryModule.init());
+  const ingest = await timed('recall_ingest_ms', timings, () => memoryModule.handleToolCall('memory', {
+    action: 'ingest_session',
+    sessionId,
+    cwd: session.cwd || ROOT,
+    messages,
+    limit: Number(arg('ingest-limit', 500)) || 500,
+  }));
+  const cycle1 = await timed('recall_cycle1_drain_ms', timings, () => drainCycle1ForSession(memoryModule, sessionId, {
+    maxPasses: Number(arg('cycle1-passes', 4)) || 4,
+    windowSize: Number(arg('window-size', arg('batch-size', 50))) || 50,
+    rowsPerSession: Number(arg('rows-per-session', 0)) || 0,
+    concurrency: Number(arg('concurrency', 4)) || 4,
+    callerDeadlineMs: Number(arg('cycle1-deadline-ms', 120000)) || 120000,
+    callLlm: directCycle1Llm(impl, model),
+    limit: Number(arg('limit', 1000)) || 1000,
+  }));
+  const recallQuery = String(arg('recall-query', recallQueryForSession(messages)) || '').trim();
+  const recallResult = await timed('recall_search_ms', timings, () => memoryModule.handleToolCall('memory', {
+    action: 'search',
+    sessionId,
+    query: recallQuery,
+    limit: Number(arg('recall-limit', 100)) || 100,
+    includeArchived: true,
+    includeMembers: true,
+  }));
+  candidateBText = textOfResult(recallResult);
+  candidateBMeta = {
+    chars: candidateBText.length,
+    lexicalCoverage: coverageScore(sourceText, candidateBText),
+    query: recallQuery,
+    ingest: textOfResult(ingest),
+    cycle1,
+  };
 
   const report = {
     sessionId,
     provider,
     model,
+    timings,
     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) },
+    candidateB: { label: candidateB, ...candidateBMeta },
     judge: null,
   };
   if (flag('judge')) {
-    report.judge = await judgePair(impl, model, sourceText, semanticText, recallText);
+    report.judge = await timed('judge_ms', timings, () => judgePair(impl, model, sourceText, semanticText, candidateBText, candidateB));
   }
 
   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, `${candidateB}.txt`), candidateBText, 'utf8');
   writeFileSync(join(outDir, 'report.json'), JSON.stringify(report, null, 2), 'utf8');
   process.stdout.write(`${JSON.stringify(report, null, 2)}\noutputs: ${outDir}\n`);
 }
@@ -168,5 +331,14 @@ main()
     process.exitCode = 1;
   })
   .finally(async () => {
-    try { await memory.stop?.(); } catch {}
+    try {
+      if (memoryModule?.stop) {
+        const stopped = await withTimeout(memoryModule.stop(), Number(arg('stop-timeout-ms', 5000)) || 5000);
+        if (stopped.timedOut) process.stderr.write('warning: memory stop timed out; forcing bench exit\n');
+      }
+    } catch {}
+    if (isMainScript() && !flag('no-force-exit')) {
+      await new Promise((resolve) => process.stdout.write('', resolve));
+      setImmediate(() => process.exit(process.exitCode || 0));
+    }
   });