mixdog 0.9.47 → 0.9.50

package/scripts/compact-pressure-test.mjs

@@ -396,6 +396,46 @@ test('provider baseline pressure includes only the configured extra reserve', ()
     assert.equal(resolveCompactionPressureTokens(1, policy, { messages, sessionRef: session }), 87_000);
 });
 
+test('context status uses the automatic compaction pressure numerator and trigger', () => {
+    const session = {
+        id: 'status-pressure',
+        provider: 'openai',
+        model: 'm',
+        tools: [],
+        contextWindow: 100_000,
+        messages: [{ role: 'user', content: 'small local estimate' }],
+        compaction: {},
+    };
+    recordProviderContextBaseline(session, session.messages, {
+        inputTokens: 80_000,
+        outputTokens: 2_000,
+    });
+    const policy = policyFor(session);
+    const expectedPressure = resolveCompactionPressureTokens(
+        estimateMessagesTokens(session.messages),
+        policy,
+        { messages: session.messages, sessionRef: session },
+    );
+    const { contextStatus } = createContextStatus({
+        getSession: () => session,
+        getRoute: () => ({ provider: 'openai', model: 'm' }),
+        getCurrentCwd: () => '',
+        getMode: () => 'default',
+    });
+
+    const status = contextStatus();
+    assert.equal(status.usedTokens, expectedPressure);
+    assert.equal(status.currentEstimatedTokens, expectedPressure);
+    assert.equal(status.compaction.triggerTokens, policy.triggerTokens);
+    assert.equal(
+        shouldCompactForSession(estimateMessagesTokens(session.messages), policy, {
+            messages: session.messages,
+            sessionRef: session,
+        }),
+        status.usedTokens >= status.compaction.triggerTokens,
+    );
+});
+
 test('provider baselines fingerprint actual sendTools and reject provider, model, tool-schema, and prefix changes', () => {
     const make = () => ({
         provider: 'openai',

package/scripts/deferred-tool-loading-test.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  applyDeferredToolSurface,
+  rebuildDeferredToolSurfaceForProvider,
+  reconcileDeferredMcpToolCatalog,
+  renderToolSearch,
+} from '../src/session-runtime/tool-catalog.mjs';
+import { prepareDeferredToolCallThrough } from '../src/runtime/agent/orchestrator/session/loop/deferred-call-through.mjs';
+import { buildRequestBody } from '../src/runtime/agent/orchestrator/providers/openai-oauth.mjs';
+import { _buildRequestBodyForCacheSmoke as buildAnthropicRequestBody } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
+
+const schema = { type: 'object', properties: {} };
+const catalog = [
+  { name: 'load_tool', description: 'Load deferred tools.', annotations: { readOnlyHint: true }, inputSchema: schema },
+  { name: 'read', description: 'Read.', annotations: { readOnlyHint: true }, inputSchema: schema },
+  { name: 'mcp__demo__ping', description: 'Ping.', annotations: { readOnlyHint: true }, inputSchema: schema },
+];
+
+test('OpenAI first/repeated load uses history schemas and keeps base tools/cache key stable', () => {
+  const session = { id: 'deferred-openai', provider: 'openai-oauth', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  const baseTools = JSON.stringify(session.tools);
+  const firstBody = buildRequestBody(
+    [{ role: 'user', content: 'load ping' }],
+    'gpt-5.4',
+    session.tools,
+    { sessionId: session.id, session },
+  );
+
+  const first = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  assert.deepEqual(first.loaded, ['mcp__demo__ping']);
+  assert.equal(session.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+  assert.equal(JSON.stringify(session.tools), baseTools);
+
+  const history = [
+    { role: 'user', content: 'load ping' },
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{
+        id: 'search-1',
+        name: 'load_tool',
+        arguments: { names: ['mcp__demo__ping'] },
+        nativeType: 'tool_search_call',
+      }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'search-1',
+      content: first.nativeToolSearch.summary,
+      nativeToolSearch: first.nativeToolSearch,
+    },
+  ];
+  const followup = buildRequestBody(history, 'gpt-5.4', session.tools, {
+    sessionId: session.id,
+    session,
+  });
+  assert.equal(JSON.stringify(followup.tools), JSON.stringify(firstBody.tools));
+  assert.equal(followup.prompt_cache_key, firstBody.prompt_cache_key);
+  assert.equal(followup.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+  assert.equal(
+    followup.input.find((item) => item.type === 'tool_search_output').tools[0].name,
+    'mcp__demo__ping',
+  );
+
+  const repeated = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  assert.deepEqual(repeated.loaded, []);
+  assert.deepEqual(repeated.alreadyActive, ['mcp__demo__ping']);
+  assert.deepEqual(repeated.nativeToolSearch.toolReferences, []);
+  assert.deepEqual(repeated.nativeToolSearch.openaiTools, []);
+  assert.equal(JSON.stringify(session.tools), baseTools);
+
+  const repeatedFollowup = buildRequestBody([
+    ...history,
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{
+        id: 'search-2',
+        name: 'load_tool',
+        arguments: { names: ['mcp__demo__ping'] },
+        nativeType: 'tool_search_call',
+      }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'search-2',
+      content: repeated.nativeToolSearch.summary,
+      nativeToolSearch: repeated.nativeToolSearch,
+    },
+  ], 'gpt-5.4', session.tools, { sessionId: session.id, session });
+  const repeatedOutput = repeatedFollowup.input.at(-1);
+  assert.equal(JSON.stringify(repeatedFollowup.tools), JSON.stringify(firstBody.tools));
+  assert.equal(repeatedFollowup.prompt_cache_key, firstBody.prompt_cache_key);
+  assert.equal(repeatedFollowup.input.at(-2).type, 'tool_search_call');
+  assert.equal(repeatedOutput.type, 'tool_search_output');
+  assert.deepEqual(repeatedOutput.tools, []);
+});
+
+test('Anthropic repeated native loads retain an empty provider envelope', () => {
+  const session = { provider: 'anthropic-oauth', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  const first = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  const before = JSON.stringify(session.tools);
+  const repeated = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+
+  assert.deepEqual(first.nativeToolSearch.toolReferences, ['mcp__demo__ping']);
+  assert.deepEqual(repeated.loaded, []);
+  assert.deepEqual(repeated.alreadyActive, ['mcp__demo__ping']);
+  assert.deepEqual(repeated.nativeToolSearch.toolReferences, []);
+  assert.deepEqual(repeated.nativeToolSearch.openaiTools, []);
+  assert.equal(JSON.stringify(session.tools), before);
+  assert.equal(session.deferredCallableTools.includes('mcp__demo__ping'), true);
+  assert.equal(session.deferredDiscoveredTools.includes('mcp__demo__ping'), true);
+
+  const body = buildAnthropicRequestBody([
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{ id: 'load-a1', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] } }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'load-a1',
+      content: first.nativeToolSearch.summary,
+      nativeToolSearch: first.nativeToolSearch,
+    },
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{ id: 'load-a2', name: 'load_tool', arguments: { names: ['mcp__demo__ping'] } }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'load-a2',
+      content: repeated.nativeToolSearch.summary,
+      nativeToolSearch: repeated.nativeToolSearch,
+    },
+  ], 'claude-sonnet-4-6', session.tools, { session });
+  const results = body.messages.flatMap((message) => (
+    Array.isArray(message.content) ? message.content.filter((block) => block.type === 'tool_result') : []
+  ));
+  assert.deepEqual(results.map((block) => block.tool_use_id), ['load-a1', 'load-a2']);
+  assert.deepEqual(results[0].content, [{ type: 'tool_reference', tool_name: 'mcp__demo__ping' }]);
+  assert.equal(results[1].content, 'Already active: mcp__demo__ping');
+  assert.equal(body.tools.find((tool) => tool.name === 'mcp__demo__ping')?.defer_loading, true);
+});
+
+test('OpenAI API-key path accepts its own native tool_search_output history', () => {
+  const session = { id: 'deferred-openai-direct', provider: 'openai', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  const loaded = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  const body = buildRequestBody([
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{
+        id: 'search-direct',
+        name: 'load_tool',
+        arguments: { names: ['mcp__demo__ping'] },
+        nativeType: 'tool_search_call',
+      }],
+    },
+    {
+      role: 'tool',
+      toolCallId: 'search-direct',
+      content: loaded.nativeToolSearch.summary,
+      nativeToolSearch: loaded.nativeToolSearch,
+    },
+  ], 'gpt-5.4', session.tools, {
+    sessionId: session.id,
+    session,
+    promptCacheProvider: 'openai',
+  });
+  assert.equal(body.input[0].type, 'tool_search_call');
+  assert.equal(body.input[1].type, 'tool_search_output');
+});
+
+test('subsequent ordinary MCP calls use the callable registry, not session.tools promotion', () => {
+  const session = { provider: 'openai-oauth', toolSpec: 'full', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+  const before = JSON.stringify(session.tools);
+  assert.equal(prepareDeferredToolCallThrough(session, 'mcp__demo__ping', {}), null);
+  assert.equal(JSON.stringify(session.tools), before);
+  assert.equal(session.deferredCallableTools.includes('mcp__demo__ping'), true);
+});
+
+test('xAI/Grok and unsupported providers use a fixed canonical non-native surface', () => {
+  for (const provider of ['xai', 'grok-oauth', 'opencode-go']) {
+    const session = { provider, tools: [], messages: [] };
+    applyDeferredToolSurface(session, 'full', catalog, { provider });
+    const before = JSON.stringify(session.tools);
+    const result = JSON.parse(renderToolSearch({ names: ['mcp__demo__ping'] }, session, 'full'));
+    assert.equal(session.deferredNativeTools, false);
+    assert.equal(result.nativeToolSearch, undefined);
+    assert.deepEqual(result.alreadyActive, ['mcp__demo__ping']);
+    assert.equal(JSON.stringify(session.tools), before);
+  }
+});
+
+test('Gemini manifest changes only at the next user-turn reconciliation', () => {
+  const session = { provider: 'gemini', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog.slice(0, 2), { provider: session.provider });
+  const duringTurn = JSON.stringify(session.tools);
+  const orderedBaseNames = session.tools.map((tool) => tool.name);
+  assert.equal(JSON.stringify(session.tools), duringTurn);
+
+  reconcileDeferredMcpToolCatalog(session, [catalog[2]]);
+  assert.deepEqual(session.tools.map((tool) => tool.name), [...orderedBaseNames, 'mcp__demo__ping']);
+  assert.equal(session.deferredProviderMode, 'manifest');
+});
+
+test('live provider switching rebuilds native and canonical surfaces in both directions', () => {
+  const session = { provider: 'openai-oauth', tools: [], messages: [] };
+  applyDeferredToolSurface(session, 'full', catalog, { provider: session.provider });
+  assert.equal(session.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+
+  rebuildDeferredToolSurfaceForProvider(session, 'xai');
+  session.provider = 'xai';
+  assert.equal(session.deferredProviderMode, 'canonical');
+  assert.deepEqual(session.tools.map((tool) => tool.name), session.deferredCallableTools);
+  assert.equal(session.tools.some((tool) => tool.name === 'mcp__demo__ping'), true);
+
+  rebuildDeferredToolSurfaceForProvider(session, 'openai');
+  session.provider = 'openai';
+  assert.equal(session.deferredProviderMode, 'native');
+  assert.equal(session.tools.some((tool) => tool.name === 'mcp__demo__ping'), false);
+  assert.equal(session.deferredCallableTools.includes('mcp__demo__ping'), false);
+});

package/scripts/embedding-worker-exit-test.mjs

@@ -0,0 +1,76 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const providerUrl = new URL('../src/runtime/memory/lib/embedding-provider.mjs', import.meta.url)
+const CHILD_DEADLINE_MS = 3_000
+
+async function createExitWorkerFixture() {
+  const tempDir = await mkdtemp(join(tmpdir(), 'mixdog-embed-worker-exit-'))
+  const workerPath = join(tempDir, 'exit-before-reply.mjs')
+  await writeFile(workerPath, `
+    import { parentPort } from 'node:worker_threads'
+    parentPort.once('message', () => process.exit(0))
+  `)
+  const source = await readFile(providerUrl, 'utf8')
+  const instrumented = source
+    .replace("'./model-profile.mjs'", JSON.stringify(new URL('../src/runtime/memory/lib/model-profile.mjs', import.meta.url).href))
+    .replace("'./embedding-model-config.mjs'", JSON.stringify(new URL('../src/runtime/memory/lib/embedding-model-config.mjs', import.meta.url).href))
+    .replace(/^const WORKER_PATH = .*$/m, `const WORKER_PATH = ${JSON.stringify(workerPath)}`)
+  const providerModule = `data:text/javascript;base64,${Buffer.from(instrumented).toString('base64')}#${Date.now()}`
+  const fixturePath = join(tempDir, 'run-exit-test.mjs')
+  await writeFile(fixturePath, `
+    import { embedText } from ${JSON.stringify(providerModule)}
+    const started = Date.now()
+    const settled = await Promise.allSettled([embedText('first'), embedText('second')])
+    if (Date.now() - started >= 2_000) throw new Error('worker exit did not reject pending embeds promptly')
+    if (settled.some(({ status }) => status !== 'rejected')) throw new Error('worker exit resolved a pending embed')
+    for (const result of settled) {
+      if (result.reason?.message !== 'Worker exited with code 0') throw result.reason
+    }
+    process.stdout.write('ok')
+  `)
+  return { fixturePath, tempDir }
+}
+
+function runFixture(fixturePath) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [fixturePath], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
+    let stdout = ''
+    let stderr = ''
+    let timedOut = false
+    const deadline = setTimeout(() => {
+      timedOut = true
+      child.kill()
+    }, CHILD_DEADLINE_MS)
+    child.stdout.on('data', (chunk) => { stdout += chunk })
+    child.stderr.on('data', (chunk) => { stderr += chunk })
+    child.once('error', (error) => {
+      clearTimeout(deadline)
+      reject(error)
+    })
+    child.once('close', (code, signal) => {
+      clearTimeout(deadline)
+      if (timedOut) {
+        reject(new Error(`exit-worker fixture exceeded ${CHILD_DEADLINE_MS}ms and was killed`))
+        return
+      }
+      resolve({ code, signal, stdout, stderr })
+    })
+  })
+}
+
+test('code-zero worker exit before reply promptly rejects every pending embed', async () => {
+  const { fixturePath, tempDir } = await createExitWorkerFixture()
+  try {
+    const result = await runFixture(fixturePath)
+    assert.equal(result.code, 0, result.stderr)
+    assert.equal(result.signal, null, result.stderr)
+    assert.equal(result.stdout, 'ok')
+  } finally {
+    await rm(tempDir, { recursive: true, force: true })
+  }
+})

package/scripts/execution-completion-dedup-test.mjs

@@ -155,3 +155,51 @@ test('bodyless failure preview does not suppress its later body', () => {
   deliver({ content: 'Async agent task task_fail completed.\n\nResult:\n> retry', meta: { type: 'background_task_result', execution_id: 'task_fail', status: 'finished' } });
   assert.equal(cardPushes(), 2, 'same-body retry remains idempotent');
 });
+
+test('parallel agent status bursts coalesce to one status snapshot per frame', async () => {
+  let handler = null;
+  let setCalls = 0;
+  const statusArgs = [];
+  const feed = createAgentJobFeed({
+    runtime: { onNotification: (fn) => { handler = fn; return () => {}; } },
+    getState: () => ({ busy: false }),
+    set: () => { setCalls += 1; },
+    nextId: () => 'id',
+    getDisposed: () => false,
+    patchItem: () => {},
+    enqueue: () => true,
+    drain: () => Promise.resolve(),
+    pushUserOrSyntheticItem: () => {},
+    makeQueueEntry: (text, opts = {}) => ({ text, ...opts }),
+    getPending: () => [],
+    agentStatusState: (args) => {
+      statusArgs.push(args);
+      return {};
+    },
+    displayedExecutionNotificationKeys: new Set(),
+    pushNotice: () => {},
+  });
+  const unsubscribe = feed.subscribeRuntimeNotifications();
+
+  for (let i = 0; i < 24; i += 1) {
+    handler({
+      content: `agent task: burst_${i}\nstatus: running`,
+      meta: { type: 'agent_task_status', execution_id: `burst_${i}`, status: 'running' },
+    });
+  }
+  assert.equal(setCalls, 0, 'burst stays deferred until the coalesce boundary');
+  await new Promise((resolve) => setTimeout(resolve, 30));
+  assert.equal(setCalls, 1);
+  assert.equal(statusArgs.length, 1);
+
+  for (let i = 0; i < 24; i += 1) {
+    handler({
+      content: `agent task: burst_${i}\nstatus: completed`,
+      meta: { type: 'agent_task_result', execution_id: `burst_${i}`, status: 'completed' },
+    });
+  }
+  await new Promise((resolve) => setTimeout(resolve, 30));
+  assert.equal(setCalls, 2);
+  assert.deepEqual(statusArgs.at(-1), { force: true }, 'terminal burst forces one fresh snapshot');
+  unsubscribe();
+});

package/scripts/explore-prompt-policy-test.mjs

@@ -6,7 +6,14 @@ import { buildExplorerPrompt } from '../src/standalone/explore-tool.mjs';
 import { EXPLORE_TOOL } from '../src/standalone/explore-tool.mjs';
 import { BUILTIN_TOOLS } from '../src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs';
 import { CODE_GRAPH_TOOL_DEFS } from '../src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs';
-import { isEagerDispatchable } from '../src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs';
+import { TOOL_SEARCH_TOOL } from '../src/session-runtime/tool-defs.mjs';
+import { createEagerDispatcher } from '../src/runtime/agent/orchestrator/session/eager-dispatch.mjs';
+import { crossTurnSignature } from '../src/runtime/agent/orchestrator/session/loop/completion-guards.mjs';
+import {
+  isEagerDispatchable,
+  isToolCallDedupEligible,
+} from '../src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs';
+import { assertCodeGraphDescriptionContract } from './code-graph-description-contract.mjs';
 
 test('explore per-query prompt contains only escaped query XML', () => {
   const prompt = buildExplorerPrompt('display model usage show usage model_usage provider_usage session cache usage state');
@@ -89,9 +96,19 @@ test('explorer locator policy retains its compact behavioral contract', () => {
 });
 
 test('canonical schemas advertise safe batching without changing tool shapes', () => {
-  const graph = readFileSync(new URL('../src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs', import.meta.url), 'utf8');
+  const graph = CODE_GRAPH_TOOL_DEFS[0];
   const patch = readFileSync(new URL('../src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs', import.meta.url), 'utf8');
-  assert.match(graph, /Batch symbols\[\]\/files\[\] by mode/i);
+  const mode = graph?.inputSchema?.properties?.mode?.description || '';
+  const description = graph?.description || '';
+  const symbols = graph?.inputSchema?.properties?.symbols?.description || '';
+  assert.doesNotThrow(() => assertCodeGraphDescriptionContract({
+    description,
+    modeDescription: mode,
+    symbolsDescription: symbols,
+  }));
+  assert.deepEqual(graph?.inputSchema?.required, ['mode']);
+  assert.equal(graph?.inputSchema?.properties?.file, undefined);
+  assert.equal(graph?.inputSchema?.properties?.symbol, undefined);
   assert.match(patch, /one patch/i);
   assert.match(patch, /one file block per target/i);
 });
@@ -121,6 +138,74 @@ test('code graph and eager-dispatch boundaries preserve runtime shape', () => {
   assert.equal(isEagerDispatchable('shell', tools), false);
   assert.equal(isEagerDispatchable('mcp_read', tools), true);
   assert.equal(isEagerDispatchable('mcp_write', tools), false);
+  assert.equal(isToolCallDedupEligible('read', tools), true);
+  assert.equal(isToolCallDedupEligible('mcp_read', tools), true);
+});
+
+test('same-batch load_tool and legacy tool_search repeats all execute eagerly', async () => {
+  const tools = [...BUILTIN_TOOLS, TOOL_SEARCH_TOOL];
+  assert.equal(isEagerDispatchable('load_tool', tools), true);
+  assert.equal(isEagerDispatchable('tool_search', tools), true);
+  assert.equal(isToolCallDedupEligible('load_tool', tools), false);
+  assert.equal(isToolCallDedupEligible('tool_search', tools), false);
+  assert.equal(isToolCallDedupEligible('read', tools), true);
+
+  const args = { names: ['shell'] };
+  const calls = [
+    { id: 'load-1', name: 'load_tool', arguments: args },
+    { id: 'load-2', name: 'load_tool', arguments: args },
+    { id: 'legacy-1', name: 'tool_search', arguments: args },
+    { id: 'legacy-2', name: 'tool_search', arguments: args },
+  ];
+  const executed = [];
+  const crossTurnCalls = new Map([
+    [crossTurnSignature('load_tool', args), { count: 1, firstIteration: 1 }],
+    [crossTurnSignature('tool_search', args), { count: 1, firstIteration: 1 }],
+  ]);
+  const dispatcher = createEagerDispatcher({
+    tools,
+    cwd: process.cwd(),
+    sessionId: null,
+    sessionRef: {},
+    signal: null,
+    opts: {},
+    crossTurnCalls,
+    getIterations: () => 2,
+    getNextIteration: () => 2,
+    repeatFailLimit: 3,
+    executeToolFn: async (name) => {
+      executed.push(name);
+      return '{}';
+    },
+  });
+  dispatcher.startEagerRun(calls, 0, new Set());
+  assert.equal(dispatcher.pending.size, 4);
+  await Promise.all([...dispatcher.pending.values()].map((entry) => entry.promise));
+  assert.deepEqual(executed, ['load_tool', 'load_tool', 'tool_search', 'tool_search']);
+
+  const normalExecuted = [];
+  const normalDispatcher = createEagerDispatcher({
+    tools,
+    cwd: process.cwd(),
+    sessionId: null,
+    sessionRef: {},
+    signal: null,
+    opts: {},
+    crossTurnCalls: new Map(),
+    getIterations: () => 1,
+    getNextIteration: () => 1,
+    repeatFailLimit: 3,
+    executeToolFn: async (name) => {
+      normalExecuted.push(name);
+      return 'ok';
+    },
+  });
+  normalDispatcher.startEagerRun([
+    { id: 'read-1', name: 'read', arguments: { path: 'same.txt' } },
+    { id: 'read-2', name: 'read', arguments: { path: 'same.txt' } },
+  ], 0, new Set());
+  await Promise.all([...normalDispatcher.pending.values()].map((entry) => entry.promise));
+  assert.deepEqual(normalExecuted, ['read']);
 });
 
 test('code graph descriptions partition file and symbol targets', () => {