mixdog 0.9.63 → 0.9.64

package/scripts/code-graph-aggregate-cwd-test.mjs

@@ -1,158 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { join, parse, relative } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
-import { findCachedGraphBinary } from '../src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs';
-
-const previousDataDir = process.env.MIXDOG_DATA_DIR;
-const previousHome = process.env.MIXDOG_HOME;
-const previousGraphBin = process.env.MIXDOG_GRAPH_BIN;
-const ambientDataDir = previousDataDir || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data');
-const ambientGraphBin = findCachedGraphBinary(ambientDataDir);
-const isolatedDataDir = await mkdtemp(join(tmpdir(), 'mixdog-code-graph-test-data-'));
-process.env.MIXDOG_DATA_DIR = isolatedDataDir;
-process.env.MIXDOG_HOME = isolatedDataDir;
-if (!previousGraphBin && ambientGraphBin) process.env.MIXDOG_GRAPH_BIN = ambientGraphBin;
-const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
-const { drainCodeGraphCache } = await import('../src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs');
-let testTail = Promise.resolve();
-
-function serialTest(name, fn) {
-  test(name, async (t) => {
-    const previous = testTail;
-    let release;
-    testTail = new Promise((resolve) => { release = resolve; });
-    await previous;
-    try {
-      await fn(t);
-    } finally {
-      release();
-    }
-  });
-}
-
-async function makeProject() {
-  const root = await mkdtemp(join(tmpdir(), 'mixdog-code-graph-project-'));
-  await mkdir(join(root, 'src'));
-  await writeFile(join(root, 'package.json'), '{}');
-  await writeFile(join(root, 'src', 'one.mjs'), 'export const one = 1;\n');
-  await writeFile(join(root, 'src', 'two.mjs'), 'export const two = 2;\n');
-  return root;
-}
-
-const primaryProject = await makeProject();
-await writeFile(join(isolatedDataDir, 'projects.json'), JSON.stringify({
-  projects: [{ name: 'primary', path: primaryProject, addedAt: 1 }],
-}));
-
-test.after(async () => {
-  drainCodeGraphCache();
-  await Promise.all([
-    rm(primaryProject, { recursive: true, force: true }),
-    rm(isolatedDataDir, { recursive: true, force: true }),
-  ]);
-  if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
-  else process.env.MIXDOG_DATA_DIR = previousDataDir;
-  if (previousHome === undefined) delete process.env.MIXDOG_HOME;
-  else process.env.MIXDOG_HOME = previousHome;
-  if (previousGraphBin === undefined) delete process.env.MIXDOG_GRAPH_BIN;
-  else process.env.MIXDOG_GRAPH_BIN = previousGraphBin;
-});
-
-serialTest('aggregate file anchors recover an invalid cwd only for one project root', async () => {
-  const project = primaryProject;
-  const invalidCwd = parse(project).root;
-  const files = [join(project, 'src', 'one.mjs'), join(project, 'src', 'two.mjs')];
-  const relativeFiles = files.map((file) => relative(invalidCwd, file));
-  const result = await executeCodeGraphTool('code_graph', { mode: 'overview', files }, invalidCwd);
-  assert.match(result, new RegExp(`# overview ${files[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
-  assert.match(result, new RegExp(`# overview ${files[1].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
-
-  const relativeResult = await executeCodeGraphTool('code_graph', { mode: 'overview', files: relativeFiles }, invalidCwd);
-  assert.match(relativeResult, /file: src\/one\.mjs/);
-  assert.match(relativeResult, /file: src\/two\.mjs/);
-  drainCodeGraphCache();
-});
-
-serialTest('singleton JSON files retain aggregate cwd provenance', async () => {
-  const project = primaryProject;
-  const invalidCwd = parse(project).root;
-  const file = join(project, 'src', 'one.mjs');
-  const result = await executeCodeGraphTool(
-    'code_graph',
-    { mode: 'overview', files: JSON.stringify([file]), cwd: invalidCwd },
-    project,
-  );
-  assert.doesNotMatch(result, /^Error:/);
-  const missingAggregate = await executeCodeGraphTool(
-    'code_graph',
-    { mode: 'overview', files: JSON.stringify([join(project, 'missing.mjs')]), cwd: invalidCwd },
-    project,
-  );
-  assert.match(missingAggregate, /^Error: code_graph: file not found:/);
-  const scalarResult = await executeCodeGraphTool(
-    'code_graph',
-    { mode: 'overview', file: join(project, 'missing.mjs'), cwd: invalidCwd },
-    project,
-  );
-  assert.match(scalarResult, /^Error: code_graph: file not found:/);
-});
-
-serialTest('aggregate cwd recovery rejects missing and multi-root anchors', async () => {
-  const first = await makeProject();
-  const second = await makeProject();
-  const invalidCwd = parse(first).root;
-  const relativeFirst = relative(invalidCwd, join(first, 'src', 'one.mjs'));
-  const relativeSecond = relative(invalidCwd, join(second, 'src', 'one.mjs'));
-  try {
-    for (const filesArg of [
-      [join(first, 'src', 'one.mjs'), join(first, 'missing.mjs')],
-      [relativeFirst, relative(invalidCwd, join(first, 'missing.mjs'))],
-    ]) {
-      assert.match(
-        await executeCodeGraphTool('code_graph', { mode: 'overview', files: filesArg }, invalidCwd),
-        /^Error: code_graph: file not found:/,
-      );
-    }
-    for (const filesArg of [
-      [join(first, 'src', 'one.mjs'), join(second, 'src', 'one.mjs')],
-      [relativeFirst, relativeSecond],
-    ]) {
-      assert.match(
-        await executeCodeGraphTool('code_graph', { mode: 'overview', files: filesArg }, invalidCwd),
-        /^Error: code_graph: file anchor is not owned by a trusted project:/,
-      );
-    }
-  } finally {
-    await Promise.all([rm(first, { recursive: true, force: true }), rm(second, { recursive: true, force: true })]);
-  }
-});
-
-serialTest('aggregate cwd recovery rejects capped, comma-delimited, and wildcard anchors', async () => {
-  const project = await makeProject();
-  const invalidCwd = parse(project).root;
-  const cappedFiles = await Promise.all(Array.from({ length: 21 }, async (_, index) => {
-    const file = join(project, 'src', `anchor-${index}.mjs`);
-    await writeFile(file, `export const anchor${index} = ${index};\n`);
-    return file;
-  }));
-  const literalWildcard = join(project, 'src', 'literal[glob].mjs');
-  await writeFile(literalWildcard, 'export const wildcard = true;\n');
-  try {
-    assert.match(
-      await executeCodeGraphTool('code_graph', { mode: 'overview', files: cappedFiles }, invalidCwd),
-      /file list exceeds cap/,
-    );
-    assert.match(
-      await executeCodeGraphTool('code_graph', { mode: 'overview', files: `${join(project, 'src', 'one.mjs')},${join(project, 'src', 'two.mjs')}` }, invalidCwd),
-      /^Error: code_graph: file anchor is not owned by a trusted project:/,
-    );
-    assert.match(
-      await executeCodeGraphTool('code_graph', { mode: 'overview', files: [literalWildcard] }, invalidCwd),
-      /wildcard-shaped file anchors/,
-    );
-  } finally {
-    await rm(project, { recursive: true, force: true });
-  }
-});

package/scripts/code-graph-disk-hit-test.mjs

@@ -1,290 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  _codeGraphWorkerFailure,
-  _isCompatibleDiskCodeGraphEntry,
-  _postCodeGraphWorkerSuccess,
-  _prewarmCodeGraph,
-  _prepareDiskCodeGraphFastPath,
-  _runDiskCodeGraphFastPath,
-  _spawnCodeGraphWorker,
-  _validateDiskCodeGraphHit,
-} from '../src/runtime/agent/orchestrator/tools/code-graph/build.mjs';
-import { CODE_GRAPH_MAX_FILES } from '../src/runtime/agent/orchestrator/tools/code-graph/constants.mjs';
-import { _serializeGraph } from '../src/runtime/agent/orchestrator/tools/code-graph/graph-model.mjs';
-import { _persistDiskCodeGraphCacheNow } from '../src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs';
-
-function workerMessage(message, hooks = {}) {
-  return _spawnCodeGraphWorker('/worker', '/worker', 0, null, () => {}, null, null, {
-    createWorker: () => ({
-      once(event, listener) {
-        if (event === 'message') queueMicrotask(() => listener(message));
-      },
-      terminate() {},
-    }),
-    getGeneration: () => 0,
-    setMemoryCache: () => {},
-    setDiskCache: () => {},
-    ...hooks,
-  });
-}
-
-test('Worker message path preserves success and validates failure text', async () => {
-  const graph = { signature: 'success', nodes: new Map() };
-  const memory = [];
-  const disk = [];
-  assert.equal(await workerMessage({ ok: true, signature: 'success', graph }, {
-    setMemoryCache: (cwd, entry) => memory.push({ cwd, entry }),
-    setDiskCache: (cwd, entry) => disk.push({ cwd, entry }),
-  }), graph);
-  assert.deepEqual(memory, [{ cwd: '/worker', entry: { ts: memory[0].entry.ts, signature: 'success', graph } }]);
-  assert.deepEqual(disk, [{ cwd: '/worker', entry: graph }]);
-  await assert.rejects(workerMessage({ ok: false, error: ' worker build failed ' }), /worker build failed/);
-  for (const message of [{ ok: false }, { ok: false, error: ' \t ' }, null]) {
-    await assert.rejects(workerMessage(message), /code-graph prewarm worker failed/);
-  }
-});
-
-test('worker failure protocol trims its error text', () => {
-  assert.equal(
-    _codeGraphWorkerFailure({ ok: false, error: ' disk cache flush failed ' }).message,
-    'disk cache flush failed',
-  );
-  for (const message of [{ ok: false }, { ok: false, error: '' }, { ok: false, error: ' \t ' }]) {
-    assert.equal(_codeGraphWorkerFailure(message).message, 'code-graph prewarm worker failed');
-  }
-});
-
-test('best-effort prewarm swallows build failures', () => {
-  let swallowed = false;
-  _prewarmCodeGraph('/worker', () => ({
-    catch(handler) {
-      swallowed = true;
-      handler(new Error('worker build failed'));
-    },
-  }));
-  assert.equal(swallowed, true);
-});
-
-test('signature-validated disk hit restores memory without a Worker build', async () => {
-  const graph = { nodes: new Map() };
-  let restored = null;
-  const result = await _validateDiskCodeGraphHit({
-    graphCwd: '/project',
-    diskEntry: { signature: 'sig', maxFiles: CODE_GRAPH_MAX_FILES },
-    genAtStart: 4,
-    now: 123,
-    runManifest: async () => [{ rel: 'a.mjs', fp: '1' }],
-    computeSignature: () => 'sig',
-    deserializeGraph: () => graph,
-    getGeneration: () => 4,
-    setMemoryCache: (cwd, entry) => { restored = { cwd, entry }; },
-  });
-  assert.equal(result.graph, graph);
-  assert.deepEqual(restored, {
-    cwd: '/project',
-    entry: { ts: 123, signature: 'sig', graph },
-  });
-});
-
-test('disk mismatch hands one manifest to the isolated rebuild without restoring stale data', async () => {
-  let deserialized = false;
-  const manifest = [{ rel: 'changed.mjs', fp: '2' }];
-  const result = await _validateDiskCodeGraphHit({
-    graphCwd: '/project',
-    diskEntry: { signature: 'old', maxFiles: CODE_GRAPH_MAX_FILES },
-    genAtStart: 1,
-    runManifest: async () => manifest,
-    computeSignature: () => 'new',
-    deserializeGraph: () => { deserialized = true; },
-  });
-  assert.equal(result.graph, null);
-  assert.equal(result.manifest, manifest);
-  assert.equal(result.signature, 'new');
-  assert.equal(deserialized, false);
-});
-
-test('generation change rejects a validated stale disk graph', async () => {
-  const result = await _validateDiskCodeGraphHit({
-    graphCwd: '/project',
-    diskEntry: { signature: 'sig', maxFiles: CODE_GRAPH_MAX_FILES },
-    genAtStart: 1,
-    runManifest: async () => [],
-    computeSignature: () => 'sig',
-    deserializeGraph: () => ({ nodes: new Map() }),
-    getGeneration: () => 2,
-  });
-  assert.deepEqual(result, { invalidated: true });
-});
-
-function fastProbe(overrides = {}) {
-  return { isFastPathEligible: true, maxFiles: CODE_GRAPH_MAX_FILES, bytes: 1, ...overrides };
-}
-
-test('validated hit releases its pre-acquired slot exactly once', async () => {
-  let releases = 0;
-  let workers = 0;
-  const result = await _runDiskCodeGraphFastPath({
-    graphCwd: '/project',
-    diskProbe: fastProbe(),
-    genAtStart: 1,
-    loadDiskEntry: () => ({ maxFiles: CODE_GRAPH_MAX_FILES }),
-    acquireSlot: async () => () => { releases++; },
-    validateDiskHit: async () => ({ graph: 'hit' }),
-    spawnWorker: () => { workers++; },
-  });
-  assert.equal(result, 'hit');
-  assert.equal(releases, 1);
-  assert.equal(workers, 0);
-});
-
-test('validation errors release the pre-acquired slot', async () => {
-  let releases = 0;
-  await assert.rejects(_runDiskCodeGraphFastPath({
-    graphCwd: '/project',
-    diskProbe: fastProbe(),
-    genAtStart: 1,
-    loadDiskEntry: () => ({ maxFiles: CODE_GRAPH_MAX_FILES }),
-    acquireSlot: async () => () => { releases++; },
-    validateDiskHit: async () => { throw new Error('manifest failed'); },
-    spawnWorker: () => assert.fail('Worker must not start'),
-  }), /manifest failed/);
-  assert.equal(releases, 1);
-});
-
-test('validated miss hands its slot to Worker exactly once', async () => {
-  let releases = 0;
-  let receivedRelease = null;
-  const result = await _runDiskCodeGraphFastPath({
-    graphCwd: '/project',
-    diskProbe: fastProbe(),
-    genAtStart: 1,
-    loadDiskEntry: () => ({ maxFiles: CODE_GRAPH_MAX_FILES }),
-    acquireSlot: async () => () => { releases++; },
-    validateDiskHit: async () => ({ graph: null, manifest: ['one'], signature: 'new' }),
-    spawnWorker: (release, manifest, signature) => {
-      receivedRelease = release;
-      assert.deepEqual(manifest, ['one']);
-      assert.equal(signature, 'new');
-      return 'worker-result';
-    },
-  });
-  assert.equal(result, 'worker-result');
-  assert.equal(releases, 0);
-  receivedRelease();
-  assert.equal(releases, 1);
-});
-
-test('abort after slot acquisition or validation releases the slot and never starts a Worker', async () => {
-  for (const abortAt of ['acquire', 'validate']) {
-    const controller = new AbortController();
-    let releases = 0;
-    let workers = 0;
-    await assert.rejects(_runDiskCodeGraphFastPath({
-      graphCwd: '/project',
-      diskProbe: fastProbe(),
-      genAtStart: 1,
-      signal: controller.signal,
-      loadDiskEntry: () => ({ maxFiles: CODE_GRAPH_MAX_FILES }),
-      acquireSlot: async () => {
-        if (abortAt === 'acquire') controller.abort();
-        return () => { releases++; };
-      },
-      validateDiskHit: async () => {
-        if (abortAt === 'validate') controller.abort();
-        return { graph: 'hit' };
-      },
-      spawnWorker: () => { workers++; },
-    }), /aborted/);
-    assert.equal(releases, 1, abortAt);
-    assert.equal(workers, 0, abortAt);
-  }
-});
-
-test('oversized or maxFiles-incompatible entries bypass main-thread load and use Worker', async () => {
-  for (const probe of [fastProbe({ isFastPathEligible: false }), fastProbe({ maxFiles: null })]) {
-    let loaded = 0;
-    let acquired = 0;
-    const result = await _runDiskCodeGraphFastPath({
-      graphCwd: '/project',
-      diskProbe: probe,
-      genAtStart: 1,
-      loadDiskEntry: () => { loaded++; return { maxFiles: CODE_GRAPH_MAX_FILES }; },
-      acquireSlot: async () => { acquired++; return () => {}; },
-      spawnWorker: (release) => ({ release }),
-    });
-    assert.deepEqual(result, { release: null });
-    assert.equal(loaded, 0);
-    assert.equal(acquired, 0);
-  }
-});
-
-test('persisted entries require matching maxFiles in both cache paths', () => {
-  assert.equal(_isCompatibleDiskCodeGraphEntry({ maxFiles: CODE_GRAPH_MAX_FILES }), true);
-  assert.equal(_isCompatibleDiskCodeGraphEntry({}), false);
-  assert.equal(_isCompatibleDiskCodeGraphEntry({ maxFiles: CODE_GRAPH_MAX_FILES - 1 }), false);
-  assert.equal(_serializeGraph({ nodes: new Map() }).maxFiles, CODE_GRAPH_MAX_FILES);
-});
-
-test('large legacy cache bypasses parent migration/parser and routes directly to Worker', () => {
-  let migrationOrParserCalls = 0;
-  let probeCalls = 0;
-  const result = _prepareDiskCodeGraphFastPath({
-    graphCwd: '/project',
-    hasLegacyCache: () => true,
-    ensureDiskLoaded: () => { migrationOrParserCalls++; },
-    probeDiskEntry: () => { probeCalls++; return assert.fail('legacy probe must not run'); },
-    runFastPath: (probe) => ({ probe, route: 'worker' }),
-  });
-  assert.deepEqual(result, { probe: null, route: 'worker' });
-  assert.equal(migrationOrParserCalls, 0);
-  assert.equal(probeCalls, 0);
-});
-
-test('Worker drains all migrated cache entries before posting success', () => {
-  const migratedEntries = new Map([
-    ['/requested', { signature: 'requested' }],
-    ['/legacy-project', { signature: 'legacy' }],
-  ]);
-  const events = [];
-  _postCodeGraphWorkerSuccess(
-    { signature: 'requested', nodes: new Map() },
-    (message) => {
-      events.push('post');
-      assert.equal(migratedEntries.size, 2);
-      assert.equal(message.ok, true);
-    },
-    () => {
-      events.push('drain');
-      assert.deepEqual([...migratedEntries.keys()], ['/requested', '/legacy-project']);
-    },
-  );
-  assert.deepEqual(events, ['drain', 'post']);
-});
-
-test('cache-disabled scoped Worker posts success without touching disk-cache state', () => {
-  const events = [];
-  _postCodeGraphWorkerSuccess(
-    { signature: 'scoped', nodes: new Map() },
-    (message) => events.push(message.ok ? 'post' : 'bad-post'),
-    () => events.push('drain'),
-    { cache: false },
-  );
-  assert.deepEqual(events, ['post']);
-});
-
-test('strict persistence failure prevents Worker success post', () => {
-  let posted = false;
-  assert.throws(
-    () => _postCodeGraphWorkerSuccess(
-      { signature: 'requested' },
-      () => { posted = true; },
-      () => _persistDiskCodeGraphCacheNow({
-        strict: true,
-        writeJson: () => { throw new Error('persist failed'); },
-      }),
-    ),
-    /persist failed/,
-  );
-  assert.equal(posted, false);
-});

package/scripts/code-graph-dispatch-test.mjs

@@ -1,96 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
-import { findCachedGraphBinary } from '../src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs';
-
-const previousDataDir = process.env.MIXDOG_DATA_DIR;
-const previousGraphBin = process.env.MIXDOG_GRAPH_BIN;
-const ambientDataDir = previousDataDir || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data');
-const ambientGraphBin = findCachedGraphBinary(ambientDataDir);
-const isolatedDataDir = await mkdtemp(join(tmpdir(), 'mixdog-code-graph-dispatch-data-'));
-process.env.MIXDOG_DATA_DIR = isolatedDataDir;
-if (!previousGraphBin && ambientGraphBin) process.env.MIXDOG_GRAPH_BIN = ambientGraphBin;
-
-const { executeCodeGraphTool } = await import('../src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
-const { drainCodeGraphCache } = await import('../src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs');
-const project = await mkdtemp(join(tmpdir(), 'mixdog-code-graph-dispatch-project-'));
-const sourceDir = join(project, 'src');
-await mkdir(sourceDir);
-await writeFile(join(project, 'package.json'), '{}');
-await writeFile(join(sourceDir, 'one.mjs'), [
-  'export function alpha() { return beta(); }',
-  'export function beta() { return 2; }',
-  '',
-].join('\n'));
-await writeFile(join(sourceDir, 'two.mjs'), [
-  "import { alpha } from './one.mjs';",
-  'export function gamma() { return alpha(); }',
-  '',
-].join('\n'));
-
-test.after(async () => {
-  drainCodeGraphCache();
-  await Promise.all([
-    rm(project, { recursive: true, force: true }),
-    rm(isolatedDataDir, { recursive: true, force: true }),
-  ]);
-  if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
-  else process.env.MIXDOG_DATA_DIR = previousDataDir;
-  if (previousGraphBin === undefined) delete process.env.MIXDOG_GRAPH_BIN;
-  else process.env.MIXDOG_GRAPH_BIN = previousGraphBin;
-});
-
-test('dispatch partitions every file and symbol mode by its supported target array', async () => {
-  const files = ['src/one.mjs', 'src/two.mjs'];
-  const assertNoErrorBody = (mode, result) => {
-    assert.doesNotMatch(result, /(?:^|\n)Error:/i, `${mode} returned a caught/error body`);
-  };
-  const fileModeEvidence = {
-    overview: [/file: src\/one\.mjs/, /file: src\/two\.mjs/, /symbols:.*alpha/, /symbols:.*gamma/],
-    imports: [/# imports src\/two\.mjs[\s\S]*src\/one\.mjs/],
-    dependents: [/# dependents src\/one\.mjs[\s\S]*src\/two\.mjs/],
-    related: [/file\tsrc\/one\.mjs/, /file\tsrc\/two\.mjs/, /# related/],
-    impact: [/file\tsrc\/one\.mjs/, /file\tsrc\/two\.mjs/, /external_callers\t\d+/],
-    symbols: [/function alpha \(L1\)/, /function beta \(L2\)/, /function gamma \(L2\)/],
-  };
-  for (const mode of ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols']) {
-    const result = await executeCodeGraphTool('code_graph', { mode, files }, project);
-    assertNoErrorBody(mode, result);
-    for (const file of files) assert.match(result, new RegExp(`# ${mode} ${file.replace('.', '\\.')}`));
-    for (const evidence of fileModeEvidence[mode]) assert.match(result, evidence);
-  }
-
-  const exactModeEvidence = {
-    find_symbol: [/src\/one\.mjs:1/, /src\/one\.mjs:2/, /# candidates/],
-    references: [/src\/two\.mjs:2:\d+\s+export function gamma\(\) \{ return alpha\(\); \}/, /src\/one\.mjs:1:\d+\s+export function alpha\(\) \{ return beta\(\); \}/],
-    callers: [/caller=gamma/, /caller=alpha/],
-    callees: [/# callees/, /\bbeta\b/, /\(no callees\)/],
-  };
-  for (const mode of ['find_symbol', 'references', 'callers', 'callees']) {
-    const result = await executeCodeGraphTool('code_graph', {
-      mode,
-      symbols: ['alpha', 'beta'],
-      body: false,
-    }, project);
-    assertNoErrorBody(mode, result);
-    assert.match(result, new RegExp(`# ${mode} alpha\\b`));
-    assert.match(result, new RegExp(`# ${mode} beta\\b`));
-    for (const evidence of exactModeEvidence[mode]) assert.match(result, evidence);
-  }
-
-  for (const mode of ['symbol_search', 'search']) {
-    const result = await executeCodeGraphTool('code_graph', {
-      mode,
-      symbols: ['alp', 'bet'],
-      body: false,
-    }, project);
-    const routedMode = mode === 'search' ? 'symbol_search' : mode;
-    assertNoErrorBody(mode, result);
-    assert.match(result, new RegExp(`# ${routedMode} alp\\b`));
-    assert.match(result, new RegExp(`# ${routedMode} bet\\b`));
-    assert.match(result, /# search keyword=alp matches=\d+ shown=\d+[\s\S]*\balpha\b/);
-    assert.match(result, /# search keyword=bet matches=\d+ shown=\d+[\s\S]*\bbeta\b/);
-  }
-});