@iderouter/index-mcp 0.2.0-beta.1

package/scripts/benchmark-background-fine-resume.mjs

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+
+import { backgroundBucketKey } from "../src/background-fine-selection.js";
+import { benchRepoId, cleanupBenchmarkRun, installBenchmarkSignalCleanup, parseDiagnostics, readIndexMeta, readJobStatus, sleep, spawnMcpClient } from "./lib/mcp-bench.mjs";
+import { createBenchmarkSnapshot } from "./lib/benchmark-snapshot.mjs";
+
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 1000);
+const ROUNDS = Math.max(2, Number(process.env.IDEROUTER_BENCH_RESUME_ROUNDS || 3));
+const ROUND_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_RESUME_TIMEOUT_MS || 180000);
+
+function bucketFamily(relativePath) {
+  const key = backgroundBucketKey(relativePath);
+  return key.startsWith("relay_channel:") ? "relay_channel" : key;
+}
+
+function summarize(text) {
+  const diagnostics = parseDiagnostics(text);
+  return {
+    status: text.split("\n")[0],
+    diagnostics,
+    deferred: /^Priority semantic search is ready\b/.test(text) && /background fine rebuild .*deferred/i.test(text),
+    full_ready: /^Indexed\b/.test(text),
+    failed: /^Last index job .* failed\b/.test(text),
+  };
+}
+
+function coverageFromMeta(meta) {
+  const files = Array.isArray(meta?.files) ? meta.files.map((item) => item.relativePath).filter(Boolean) : [];
+  const familyCounts = new Map();
+  for (const relativePath of files) {
+    const family = bucketFamily(relativePath);
+    familyCounts.set(family, (familyCounts.get(family) || 0) + 1);
+  }
+  return {
+    files,
+    fine_semantic_files: Number(meta?.fineSemanticFileCount || 0),
+    fine_semantic_chunks: Number(meta?.fineSemanticChunkCount || 0),
+    background_bucket_cursor: String(meta?.backgroundBucketCursor || ""),
+    priority_ready_anchor_coverage: meta?.priorityReadyAnchorCoverage || null,
+    family_counts: Object.fromEntries(Array.from(familyCounts.entries()).sort((a, b) => a[0].localeCompare(b[0]))),
+  };
+}
+
+async function readSemanticCoverage(indexHome, targetPath) {
+  try {
+    const filePath = path.join(indexHome, "indexes", `${benchRepoId(targetPath)}.json`);
+    const content = await fs.readFile(filePath, "utf8");
+    const index = JSON.parse(content);
+    const semanticChunkCounts = new Map();
+    const semanticFiles = new Set();
+    for (const chunk of Array.isArray(index?.chunks) ? index.chunks : []) {
+      const hasVector = Array.isArray(chunk?.vector)
+        ? chunk.vector.length > 0
+        : typeof chunk?.vectorBase64 === "string" && chunk.vectorBase64.length > 0;
+      if (!hasVector || !chunk?.relativePath) continue;
+      semanticFiles.add(chunk.relativePath);
+      semanticChunkCounts.set(chunk.relativePath, (semanticChunkCounts.get(chunk.relativePath) || 0) + 1);
+    }
+    const familyCounts = new Map();
+    for (const relativePath of semanticFiles) {
+      const family = bucketFamily(relativePath);
+      familyCounts.set(family, (familyCounts.get(family) || 0) + 1);
+    }
+    return {
+      semantic_files: Array.from(semanticFiles).sort(),
+      semantic_family_counts: Object.fromEntries(Array.from(familyCounts.entries()).sort((a, b) => a[0].localeCompare(b[0]))),
+      semantic_chunk_counts: Object.fromEntries(Array.from(semanticChunkCounts.entries()).sort((a, b) => a[0].localeCompare(b[0]))),
+    };
+  } catch {
+    return {
+      semantic_files: [],
+      semantic_family_counts: {},
+      semantic_chunk_counts: {},
+    };
+  }
+}
+
+async function waitForRound(client, targetPath, indexHome) {
+  const startedAt = Date.now();
+  let lastText = "";
+  while (Date.now() - startedAt < ROUND_TIMEOUT_MS) {
+    lastText = await client.callTool("get_indexing_status", { path: targetPath });
+    if (
+      /^Indexed\b/.test(lastText) ||
+      /^Last index job .* failed\b/.test(lastText) ||
+      (/^Priority semantic search is ready\b/.test(lastText) && /background fine rebuild .*deferred/i.test(lastText))
+    ) {
+      const meta = await readIndexMeta(indexHome, targetPath);
+      return {
+        settled: true,
+        wall_ms: Date.now() - startedAt,
+        text: lastText,
+        summary: summarize(lastText),
+        meta,
+      };
+    }
+    await sleep(POLL_MS);
+  }
+  return {
+    settled: false,
+    wall_ms: Date.now() - startedAt,
+    text: lastText,
+    summary: summarize(lastText),
+    meta: await readIndexMeta(indexHome, targetPath),
+  };
+}
+
+async function runRound(round, targetPath, indexHome, baseEnv) {
+  const env = {
+    ...baseEnv,
+    IDEROUTER_INDEX_HOME: indexHome,
+    IDEROUTER_AUTO_CONTINUE_BACKGROUND_BENCH: "false",
+  };
+  const { child, client } = spawnMcpClient(env);
+  const uninstallSignalCleanup = installBenchmarkSignalCleanup(() => ({
+    child,
+    indexHome,
+    targetPath,
+  }));
+  try {
+    await client.initialize();
+    const startText = await client.callTool("index_codebase", { path: targetPath, wait: false, cloud: false });
+    const settled = await waitForRound(client, targetPath, indexHome);
+    const job = await readJobStatus(indexHome, targetPath);
+    return {
+      round,
+      start_status: startText.split("\n")[0],
+      job,
+      ...settled,
+    };
+  } finally {
+    uninstallSignalCleanup();
+    await cleanupBenchmarkRun({
+      child,
+      targetPath,
+    });
+  }
+}
+
+function diffFiles(previousFiles, currentFiles) {
+  const previous = new Set(previousFiles);
+  return currentFiles.filter((item) => !previous.has(item));
+}
+
+async function main() {
+  const snapshot = await createBenchmarkSnapshot(TARGET_PATH, process.env);
+  const snapshotDir = snapshot.snapshotDir;
+  const isolatedIndexHome = await fs.mkdtemp(path.join(os.tmpdir(), "iderouter-bench-home-"));
+  const rounds = [];
+  const cumulativeFiles = new Set();
+  const cumulativeFamilies = new Set();
+
+  try {
+    for (let round = 1; round <= ROUNDS; round += 1) {
+      const result = await runRound(round, snapshotDir, isolatedIndexHome, process.env);
+      const coverage = coverageFromMeta(result.meta);
+      const semanticCoverage = await readSemanticCoverage(isolatedIndexHome, snapshotDir);
+      const newFiles = diffFiles(Array.from(cumulativeFiles), semanticCoverage.semantic_files);
+      const newFamilies = Array.from(new Set(newFiles.map((item) => bucketFamily(item)))).sort();
+      for (const file of semanticCoverage.semantic_files) cumulativeFiles.add(file);
+      for (const family of Object.keys(semanticCoverage.semantic_family_counts)) cumulativeFamilies.add(family);
+      rounds.push({
+        round,
+        settled: result.settled,
+        wall_ms: result.wall_ms,
+        start_status: result.start_status,
+        final_status: result.summary.status,
+        deferred: result.summary.deferred,
+        full_ready: result.summary.full_ready,
+        failed: result.summary.failed,
+        fine_semantic_files: coverage.fine_semantic_files,
+        fine_semantic_chunks: coverage.fine_semantic_chunks,
+        background_bucket_cursor: coverage.background_bucket_cursor,
+        priority_ready_anchor_coverage: coverage.priority_ready_anchor_coverage,
+        manifest_family_counts: coverage.family_counts,
+        semantic_family_counts: semanticCoverage.semantic_family_counts,
+        new_files_count: newFiles.length,
+        new_families: newFamilies,
+        new_files: newFiles,
+        new_file_chunk_counts: Object.fromEntries(
+          newFiles
+            .map((relativePath) => [relativePath, Number(semanticCoverage.semantic_chunk_counts[relativePath] || 0)])
+            .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])),
+        ),
+        diagnostics: {
+          background_fine_target_files: Number(result.summary.diagnostics.background_fine_target_files || 0),
+          background_fine_target_chunks: Number(result.summary.diagnostics.background_fine_target_chunks || 0),
+          background_fine_completed_files: Number(result.summary.diagnostics.background_fine_completed_files || 0),
+          embedding_request_ms_total: Number(result.summary.diagnostics.embedding_request_ms_total || 0),
+          embedding_requests: Number(result.summary.diagnostics.embedding_requests || 0),
+        },
+        job_observed: {
+          embedding_model_source: result.job?.embeddingModelSource || result.job?.diagnostics?.embeddingModelSource || "",
+          background_embedding_profile: result.job?.backgroundEmbeddingProfile || null,
+          previous_background_embedding_profile: result.job?.previousBackgroundEmbeddingProfile || null,
+          previous_diagnostics: result.job?.previousDiagnostics
+            ? {
+              embedding_request_ms_total: Number(result.job.previousDiagnostics.embeddingRequestMsTotal || 0),
+              embedding_requests: Number(result.job.previousDiagnostics.embeddingRequests || 0),
+              embedding_batch_max_size: Number(result.job.previousDiagnostics.embeddingBatchMaxSize || 0),
+            }
+            : null,
+        },
+      });
+      if (result.summary.full_ready || result.summary.failed) break;
+    }
+
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          path: TARGET_PATH,
+          snapshot_path: snapshotDir,
+          snapshot_mode: snapshot.mode,
+          isolated_index_home: isolatedIndexHome,
+          rounds,
+          summary: {
+            rounds_run: rounds.length,
+            deferred_rounds: rounds.filter((item) => item.deferred).length,
+            full_ready_rounds: rounds.filter((item) => item.full_ready).length,
+            cursor_sequence: rounds.map((item) => item.background_bucket_cursor),
+            priority_ready_anchor_coverage_sequence: rounds.map((item) => item.priority_ready_anchor_coverage),
+            cumulative_families: Array.from(cumulativeFamilies).sort(),
+            cumulative_file_count: cumulativeFiles.size,
+          },
+        },
+        null,
+        2,
+      )}\n`,
+    );
+  } finally {
+    await fs.rm(snapshotDir, { recursive: true, force: true });
+    await fs.rm(isolatedIndexHome, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/scripts/benchmark-background-fine-wait.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+import { cleanupBenchmarkRun, installBenchmarkSignalCleanup, normalizeBenchmarkResult, spawnMcpClient } from "./lib/mcp-bench.mjs";
+
+const execFileAsync = promisify(execFile);
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+
+async function createSnapshotDir() {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "iderouter-bench-bgwait-"));
+  await execFileAsync("git", ["clone", "--shared", "--no-checkout", TARGET_PATH, tempDir], {
+    cwd: process.cwd(),
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  await execFileAsync("git", ["-C", tempDir, "checkout", "-f", "HEAD"], {
+    cwd: process.cwd(),
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  return tempDir;
+}
+
+async function main() {
+  const snapshotDir = await createSnapshotDir();
+  const isolatedIndexHome = await fs.mkdtemp(path.join(os.tmpdir(), "iderouter-bench-home-"));
+  const env = {
+    ...process.env,
+    IDEROUTER_INDEX_HOME: isolatedIndexHome,
+  };
+  const { child, client } = spawnMcpClient(env);
+  const uninstallSignalCleanup = installBenchmarkSignalCleanup(() => ({
+    child,
+    indexHome: isolatedIndexHome,
+    targetPath: snapshotDir,
+    snapshotDir,
+  }));
+
+  try {
+    await client.initialize();
+    const startedAt = Date.now();
+    const finalText = await client.callTool("index_codebase", { path: snapshotDir, wait: true, cloud: false });
+    const wallMs = Date.now() - startedAt;
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          path: TARGET_PATH,
+          snapshot_path: snapshotDir,
+          isolated_index_home: isolatedIndexHome,
+          wall_ms: wallMs,
+          final_status: finalText.split("\n")[0],
+          parsed: normalizeBenchmarkResult(snapshotDir, finalText, wallMs),
+          final_text: finalText,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+  } finally {
+    uninstallSignalCleanup();
+    await cleanupBenchmarkRun({
+      child,
+      indexHome: isolatedIndexHome,
+      targetPath: snapshotDir,
+      snapshotDir,
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/scripts/benchmark-background-fine.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+import { cleanupBenchmarkRun, installBenchmarkSignalCleanup, parseDiagnostics, sleep, spawnMcpClient } from "./lib/mcp-bench.mjs";
+
+const execFileAsync = promisify(execFile);
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 1000);
+const PRIORITY_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_PRIORITY_TIMEOUT_MS || 180000);
+const FULL_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_FULL_TIMEOUT_MS || 300000);
+
+async function createSnapshotDir() {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "iderouter-bench-bg-"));
+  await execFileAsync("git", ["clone", "--shared", "--no-checkout", TARGET_PATH, tempDir], {
+    cwd: process.cwd(),
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  await execFileAsync("git", ["-C", tempDir, "checkout", "-f", "HEAD"], {
+    cwd: process.cwd(),
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  return tempDir;
+}
+
+function summarize(text) {
+  const diagnostics = parseDiagnostics(text);
+  return {
+    status: text.split("\n")[0],
+    diagnostics,
+    deferred: /^Priority semantic search is ready\b/.test(text) && /background fine rebuild .*deferred/i.test(text),
+    full_ready: /^Indexed\b/.test(text),
+    priority_ready: /^Priority semantic search is ready\b/.test(text),
+    failed: /^Last index job .* failed\b/.test(text),
+  };
+}
+
+async function waitFor(client, targetPath, predicate, timeoutMs) {
+  const startedAt = Date.now();
+  let lastText = "";
+  while (Date.now() - startedAt < timeoutMs) {
+    lastText = await client.callTool("get_indexing_status", { path: targetPath });
+    if (predicate(lastText)) {
+      return {
+        settled: true,
+        wall_ms: Date.now() - startedAt,
+        text: lastText,
+        summary: summarize(lastText),
+      };
+    }
+    await sleep(POLL_MS);
+  }
+  return {
+    settled: false,
+    wall_ms: Date.now() - startedAt,
+    text: lastText,
+    summary: summarize(lastText),
+  };
+}
+
+async function main() {
+  const snapshotDir = await createSnapshotDir();
+  const isolatedIndexHome = await fs.mkdtemp(path.join(os.tmpdir(), "iderouter-bench-home-"));
+  const env = {
+    ...process.env,
+    IDEROUTER_INDEX_HOME: isolatedIndexHome,
+  };
+  const { child, client } = spawnMcpClient(env);
+  const uninstallSignalCleanup = installBenchmarkSignalCleanup(() => ({
+    child,
+    indexHome: isolatedIndexHome,
+    targetPath: snapshotDir,
+    snapshotDir,
+  }));
+
+  try {
+    await client.initialize();
+    const startText = await client.callTool("index_codebase", { path: snapshotDir, wait: false, cloud: false });
+    const priorityReady = await waitFor(
+      client,
+      snapshotDir,
+      (text) => /^Priority semantic search is ready\b/.test(text) || /^Indexed\b/.test(text),
+      PRIORITY_TIMEOUT_MS,
+    );
+
+    let fullReady = null;
+    if (priorityReady.settled && !priorityReady.summary.full_ready) {
+      fullReady = await waitFor(
+        client,
+        snapshotDir,
+        (text) =>
+          /^Indexed\b/.test(text) ||
+          /^Background fine rebuild is temporarily paused\b/.test(text) ||
+          (/^Priority semantic search is ready\b/.test(text) && /background fine rebuild .*deferred/i.test(text)) ||
+          /^Last index job .* failed\b/.test(text),
+        FULL_TIMEOUT_MS,
+      );
+    }
+
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          path: TARGET_PATH,
+          snapshot_path: snapshotDir,
+          isolated_index_home: isolatedIndexHome,
+          start_status: startText.split("\n")[0],
+          priority_ready: priorityReady,
+          full_ready: fullReady,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+  } finally {
+    uninstallSignalCleanup();
+    await cleanupBenchmarkRun({
+      child,
+      indexHome: isolatedIndexHome,
+      targetPath: snapshotDir,
+      snapshotDir,
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/scripts/benchmark-clean-snapshot.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+import { isUsableIndexStatus, waitForIndexStatus } from "./lib/mcp-bench.mjs";
+import { createBenchmarkSnapshot } from "./lib/benchmark-snapshot.mjs";
+
+const execFileAsync = promisify(execFile);
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const SCRIPT_DIR = path.resolve("scripts");
+const TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_TIMEOUT_MS || 30000);
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 500);
+
+async function runScript(scriptName, targetPath, env) {
+  const scriptPath = path.join(SCRIPT_DIR, scriptName);
+  const { stdout } = await execFileAsync(process.execPath, [scriptPath, targetPath], {
+    cwd: process.cwd(),
+    env,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  return JSON.parse(String(stdout || "").trim());
+}
+
+async function main() {
+  const snapshot = await createBenchmarkSnapshot(TARGET_PATH, {
+    ...process.env,
+    IDEROUTER_BENCH_SNAPSHOT_MODE: "head",
+  });
+  const snapshotDir = snapshot.snapshotDir;
+  const isolatedIndexHome = await fs.mkdtemp(path.join(os.tmpdir(), "iderouter-bench-home-"));
+  const env = {
+    ...process.env,
+    IDEROUTER_BENCH_TIMEOUT_MS: String(TIMEOUT_MS),
+    IDEROUTER_BENCH_POLL_MS: String(POLL_MS),
+    IDEROUTER_INDEX_HOME: isolatedIndexHome,
+  };
+
+  try {
+    const warmup = await runScript("benchmark-noop.mjs", snapshotDir, env);
+    const warmupReady = await waitForIndexStatus({
+      targetPath: snapshotDir,
+      timeoutMs: Math.max(TIMEOUT_MS, 180000),
+      pollMs: POLL_MS,
+      env,
+      isSettled: isUsableIndexStatus,
+    });
+    const measure = warmupReady.settled
+      ? await runScript("benchmark-noop.mjs", snapshotDir, env)
+      : null;
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          path: TARGET_PATH,
+          snapshot_path: snapshotDir,
+          snapshot_mode: snapshot.mode,
+          isolated_index_home: isolatedIndexHome,
+          skipped: false,
+          api_key_present: Boolean(process.env.IDEROUTER_API_KEY),
+          strategy_mode: process.env.IDEROUTER_API_KEY ? "remote_or_cached" : "local_fallback",
+          comparable_to_auggie: Boolean(process.env.IDEROUTER_API_KEY && warmupReady.settled),
+          warmup_not_ready: !warmupReady.settled,
+          warmup,
+          warmup_ready: warmupReady,
+          measure,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+  } finally {
+    await fs.rm(snapshotDir, { recursive: true, force: true });
+    await fs.rm(isolatedIndexHome, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/scripts/benchmark-coarse-ready-search.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+
+import {
+  cleanupBenchmarkRun,
+  installBenchmarkSignalCleanup,
+  normalizeBenchmarkResult,
+  readIndexMeta,
+  sleep,
+  spawnMcpClient,
+} from "./lib/mcp-bench.mjs";
+import { getBenchmarkQueryPack } from "./lib/benchmark-query-packs.mjs";
+import { createBenchmarkSnapshot } from "./lib/benchmark-snapshot.mjs";
+
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 500);
+const TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_TIMEOUT_MS || 30000);
+const QUERY_PACK = String(process.env.IDEROUTER_BENCH_QUERY_PACK || "core").trim().toLowerCase();
+const QUERIES = getBenchmarkQueryPack(QUERY_PACK);
+
+function extractResultPaths(text) {
+  return String(text || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => /^\d+\.\s+/.test(line))
+    .map((line) => {
+      const match = line.match(/^\d+\.\s+(.+?):\d+-\d+\s+score=/);
+      return match ? match[1] : null;
+    })
+    .filter(Boolean);
+}
+
+function evaluatePaths(paths, expected) {
+  const top1 = paths[0] || "";
+  const top3 = paths.slice(0, 3);
+  return {
+    top1,
+    top3,
+    top1_hit: expected.includes(top1),
+    top3_hit: top3.some((item) => expected.includes(item)),
+  };
+}
+
+async function waitUntilCoarseReady(client, targetPath, timeoutMs, pollMs, indexHome) {
+  const startedAt = Date.now();
+  const deadline = startedAt + timeoutMs;
+  let finalText = "";
+  while (Date.now() < deadline) {
+    const text = await client.callTool("get_indexing_status", { path: targetPath });
+    finalText = text;
+    const meta = indexHome ? await readIndexMeta(indexHome, targetPath) : null;
+    const coarseReadyFromMeta = Boolean(meta?.coarseReady);
+    if (
+      /^Coarse lexical index is ready\b/.test(text) ||
+      /^Priority semantic search is ready\b/.test(text) ||
+      /^Indexed\b/.test(text) ||
+      coarseReadyFromMeta
+    ) {
+      return {
+        settled: true,
+        wallMs: Date.now() - startedAt,
+        finalText,
+        meta,
+        parsed: normalizeBenchmarkResult(targetPath, finalText, Date.now() - startedAt),
+      };
+    }
+    await sleep(pollMs);
+  }
+  return {
+    settled: false,
+    wallMs: Date.now() - startedAt,
+    finalText,
+    meta: indexHome ? await readIndexMeta(indexHome, targetPath) : null,
+    parsed: normalizeBenchmarkResult(targetPath, finalText, Date.now() - startedAt),
+  };
+}
+
+async function main() {
+  const snapshot = await createBenchmarkSnapshot(TARGET_PATH, process.env);
+  const snapshotDir = snapshot.snapshotDir;
+  const isolatedIndexHome = await fs.mkdtemp(path.join(os.tmpdir(), "iderouter-bench-coarse-home-"));
+  const env = {
+    ...process.env,
+    IDEROUTER_INDEX_HOME: isolatedIndexHome,
+  };
+  const { child, client } = spawnMcpClient(env);
+  const uninstallSignalCleanup = installBenchmarkSignalCleanup(() => ({
+    child,
+    indexHome: isolatedIndexHome,
+    targetPath: snapshotDir,
+    snapshotDir,
+  }));
+
+  try {
+    await client.initialize();
+    const startText = await client.callTool("index_codebase", { path: snapshotDir, wait: false, cloud: false });
+    const ready = await waitUntilCoarseReady(
+      client,
+      snapshotDir,
+      Math.max(TIMEOUT_MS, 30000),
+      POLL_MS,
+      isolatedIndexHome,
+    );
+
+    const searches = [];
+    if (ready.settled) {
+      for (const item of QUERIES) {
+        const startedAt = Date.now();
+        const text = await client.callTool("search_code", {
+          path: snapshotDir,
+          query: item.query,
+          limit: 5,
+        });
+        const wallMs = Date.now() - startedAt;
+        const resultPaths = extractResultPaths(text);
+        searches.push({
+          name: item.name,
+          query: item.query,
+          wall_ms: wallMs,
+          result_paths: resultPaths,
+          ...evaluatePaths(resultPaths, item.expect_any),
+          raw_status: text.split("\n")[0],
+        });
+      }
+    }
+
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          path: TARGET_PATH,
+          snapshot_path: snapshotDir,
+          snapshot_mode: snapshot.mode,
+          isolated_index_home: isolatedIndexHome,
+          start_status: startText.split("\n")[0],
+          query_pack: QUERY_PACK,
+          coarse_ready: ready,
+          searches,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+  } finally {
+    uninstallSignalCleanup();
+    await cleanupBenchmarkRun({
+      child,
+      indexHome: isolatedIndexHome,
+      targetPath: snapshotDir,
+      snapshotDir,
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});