@iderouter/index-mcp 0.2.0-beta.1

package/scripts/benchmark-deferred.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import process from "node:process";
+import { parseDiagnostics, sleep, spawnMcpClient } from "./lib/mcp-bench.mjs";
+
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 500);
+const RECHECK_MS = Number(process.env.IDEROUTER_BENCH_RECHECK_MS || 1500);
+
+function extractSummary(text) {
+  const diagnostics = parseDiagnostics(text);
+  return {
+    status: text.split("\n")[0],
+    deferred_ready: /^Priority semantic search is ready\b/.test(text) && /background fine rebuild .*deferred/i.test(text),
+    failed: /^Last index job .* failed\b/.test(text),
+    diagnostics,
+  };
+}
+
+async function main() {
+  const { child, client } = spawnMcpClient(process.env);
+  try {
+    await client.initialize();
+    const startedAt = Date.now();
+    const firstText = await client.callTool("get_indexing_status", { path: TARGET_PATH });
+    await sleep(Math.max(POLL_MS, RECHECK_MS));
+    const secondText = await client.callTool("get_indexing_status", { path: TARGET_PATH });
+    const wallMs = Date.now() - startedAt;
+
+    const first = extractSummary(firstText);
+    const second = extractSummary(secondText);
+    const output = {
+      path: TARGET_PATH,
+      wall_ms: wallMs,
+      first_status: first.status,
+      second_status: second.status,
+      first_deferred_ready: first.deferred_ready,
+      second_deferred_ready: second.deferred_ready,
+      first_failed: first.failed,
+      second_failed: second.failed,
+      stable_status: first.status === second.status,
+      resumed_unexpectedly: first.deferred_ready && !second.deferred_ready,
+      scan_ms: Number(second.diagnostics.scan_ms || first.diagnostics.scan_ms || 0),
+      total_ms: Number(second.diagnostics.total_ms || first.diagnostics.total_ms || 0),
+      strategy_version: second.diagnostics.strategy_version || first.diagnostics.strategy_version || "",
+      strategy_source: second.diagnostics.strategy_source || first.diagnostics.strategy_source || "",
+      embedding_model_source: second.diagnostics.embedding_model_source || first.diagnostics.embedding_model_source || "",
+      background_fine_target_files: Number(second.diagnostics.background_fine_target_files || first.diagnostics.background_fine_target_files || 0),
+      background_fine_target_chunks: Number(second.diagnostics.background_fine_target_chunks || first.diagnostics.background_fine_target_chunks || 0),
+    };
+
+    process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+  } finally {
+    child.kill("SIGTERM");
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/scripts/benchmark-first-semantic-visible.mjs

@@ -0,0 +1,151 @@
+#!/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,
+  readIndexMeta,
+  readJobStatus,
+  sleep,
+  spawnMcpClient,
+} from "./lib/mcp-bench.mjs";
+import { createBenchmarkSnapshot } from "./lib/benchmark-snapshot.mjs";
+import { isCoarseDeferredReady } from "./lib/auto-continuation-state.mjs";
+
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 1000);
+const FIRST_PHASE_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_AUTO_CONTINUE_FIRST_PHASE_TIMEOUT_MS || 180000);
+const SEMANTIC_VISIBLE_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_FIRST_SEMANTIC_VISIBLE_TIMEOUT_MS || 180000);
+
+function snapshotState(meta, job, statusText) {
+  return {
+    status_text: statusText.split("\n")[0],
+    job_id: job?.id || "",
+    job_status: job?.status || "",
+    current_step: job?.currentStep || "",
+    progress: Number(job?.progress || 0),
+    embedded_count: Number(job?.embeddedCount || 0),
+    total_chunks: Number(job?.totalChunks || 0),
+    background_fine_deferred: Boolean(job?.backgroundFineDeferred),
+    semantic_retry_deferred: Boolean(job?.semanticRetryDeferred),
+    searchable_modes: job?.searchableModes || meta?.searchableModes || "",
+    fine_semantic_files: Number(meta?.fineSemanticFileCount || 0),
+    fine_semantic_chunks: Number(meta?.fineSemanticChunkCount || 0),
+    updated_at: job?.updatedAt || meta?.updatedAt || "",
+  };
+}
+
+async function waitForCoarseDeferredReady(client, snapshotDir, indexHome) {
+  const startedAt = Date.now();
+  let lastText = "";
+  while (Date.now() - startedAt < FIRST_PHASE_TIMEOUT_MS) {
+    lastText = await client.callTool("get_indexing_status", { path: snapshotDir });
+    const meta = await readIndexMeta(indexHome, snapshotDir);
+    const job = await readJobStatus(indexHome, snapshotDir);
+    const state = snapshotState(meta, job, lastText);
+    if (
+      Boolean(job?.backgroundFineDeferred) &&
+      !Boolean(job?.priorityFineReady) &&
+      isCoarseDeferredReady(state)
+    ) {
+      return {
+        settled: true,
+        wall_ms: Date.now() - startedAt,
+        state,
+      };
+    }
+    await sleep(POLL_MS);
+  }
+  const meta = await readIndexMeta(indexHome, snapshotDir);
+  const job = await readJobStatus(indexHome, snapshotDir);
+  return {
+    settled: false,
+    wall_ms: Date.now() - startedAt,
+    state: snapshotState(meta, job, lastText),
+  };
+}
+
+async function waitForFirstSemanticVisible(client, snapshotDir, indexHome) {
+  const startedAt = Date.now();
+  let lastText = "";
+  while (Date.now() - startedAt < SEMANTIC_VISIBLE_TIMEOUT_MS) {
+    lastText = await client.callTool("get_indexing_status", { path: snapshotDir });
+    const meta = await readIndexMeta(indexHome, snapshotDir);
+    const job = await readJobStatus(indexHome, snapshotDir);
+    const state = snapshotState(meta, job, lastText);
+    if (state.fine_semantic_chunks > 0 || state.fine_semantic_files > 0) {
+      return {
+        settled: true,
+        wall_ms: Date.now() - startedAt,
+        state,
+      };
+    }
+    await sleep(POLL_MS);
+  }
+  const meta = await readIndexMeta(indexHome, snapshotDir);
+  const job = await readJobStatus(indexHome, snapshotDir);
+  return {
+    settled: false,
+    wall_ms: Date.now() - startedAt,
+    state: snapshotState(meta, job, lastText),
+  };
+}
+
+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-first-semantic-"));
+  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 firstPhase = await waitForCoarseDeferredReady(client, snapshotDir, isolatedIndexHome);
+    const firstSemanticVisible = firstPhase.settled
+      ? await waitForFirstSemanticVisible(client, snapshotDir, isolatedIndexHome)
+      : { settled: false, wall_ms: 0, state: firstPhase.state };
+
+    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],
+          first_phase: firstPhase,
+          first_semantic_visible: firstSemanticVisible,
+        },
+        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-gate.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import { execFile } from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const SCRIPT_DIR = path.resolve("scripts");
+const PRIORITY_READY_MAX_MS = Number(process.env.IDEROUTER_BENCH_GATE_PRIORITY_READY_MAX_MS || 20000);
+const PRIORITY_SEARCH_MAX_MS = Number(process.env.IDEROUTER_BENCH_GATE_PRIORITY_SEARCH_MAX_MS || 300);
+const REPEAT_SPEEDUP_MIN = Number(process.env.IDEROUTER_BENCH_GATE_REPEAT_SPEEDUP_MIN || 5);
+
+async function runScript(scriptName) {
+  const scriptPath = path.join(SCRIPT_DIR, scriptName);
+  const { stdout } = await execFileAsync(process.execPath, [scriptPath, TARGET_PATH], {
+    cwd: process.cwd(),
+    env: process.env,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  return JSON.parse(String(stdout || "").trim());
+}
+
+function fail(message, details) {
+  const output = {
+    ok: false,
+    message,
+    details,
+  };
+  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+  process.exitCode = 1;
+}
+
+async function main() {
+  const priority = await runScript("benchmark-priority-ready-search.mjs");
+  const repeat = await runScript("benchmark-repeat-search.mjs");
+
+  const priorityReadyKind = String(priority?.priority_ready_kind || "not_ready");
+  const repeatReadyKind = String(repeat?.priority_ready_kind || "not_ready");
+  const priorityReadyMs = Number(priority?.priority_ready?.parsed?.priority_ready_ms || priority?.priority_ready?.wallMs || 0);
+  const priorityAnchorCompleted = Number(priority?.priority_ready_anchor_coverage?.completed || 0);
+  const priorityAnchorTotal = Number(priority?.priority_ready_anchor_coverage?.total || 0);
+  const repeatAnchorCompleted = Number(repeat?.priority_ready_anchor_coverage?.completed || 0);
+  const repeatAnchorTotal = Number(repeat?.priority_ready_anchor_coverage?.total || 0);
+  const allTop1Hit = Array.isArray(priority?.searches) && priority.searches.every((item) => item?.top1_hit === true);
+  const maxSearchMs = Array.isArray(priority?.searches)
+    ? Math.max(...priority.searches.map((item) => Number(item?.wall_ms || 0)), 0)
+    : 0;
+  const repeatSpeedup = Number(repeat?.speedup_ratio || 0);
+
+  const failedChecks = [];
+  if (!["priority_semantic", "full_ready"].includes(priorityReadyKind)) {
+    failedChecks.push(`priority_ready_kind=${priorityReadyKind} is not semantic-ready`);
+  }
+  if (!["priority_semantic", "full_ready"].includes(repeatReadyKind)) {
+    failedChecks.push(`repeat_ready_kind=${repeatReadyKind} is not semantic-ready`);
+  }
+  if (priorityAnchorTotal <= 0 || priorityAnchorCompleted < priorityAnchorTotal) {
+    failedChecks.push(`priority_ready_anchor_coverage=${priorityAnchorCompleted}/${priorityAnchorTotal} is incomplete`);
+  }
+  if (repeatAnchorTotal <= 0 || repeatAnchorCompleted < repeatAnchorTotal) {
+    failedChecks.push(`repeat_ready_anchor_coverage=${repeatAnchorCompleted}/${repeatAnchorTotal} is incomplete`);
+  }
+  if (!allTop1Hit) failedChecks.push("priority_ready_all_top1_hit=false");
+  if (priorityReadyMs <= 0 || priorityReadyMs > PRIORITY_READY_MAX_MS) {
+    failedChecks.push(`priority_ready_ms=${priorityReadyMs} exceeds ${PRIORITY_READY_MAX_MS}`);
+  }
+  if (maxSearchMs <= 0 || maxSearchMs > PRIORITY_SEARCH_MAX_MS) {
+    failedChecks.push(`priority_ready_max_search_ms=${maxSearchMs} exceeds ${PRIORITY_SEARCH_MAX_MS}`);
+  }
+  if (repeatSpeedup <= 0 || repeatSpeedup < REPEAT_SPEEDUP_MIN) {
+    failedChecks.push(`repeat_search_speedup_ratio=${repeatSpeedup} below ${REPEAT_SPEEDUP_MIN}`);
+  }
+
+  const output = {
+    ok: failedChecks.length === 0,
+    thresholds: {
+      priority_ready_max_ms: PRIORITY_READY_MAX_MS,
+      priority_search_max_ms: PRIORITY_SEARCH_MAX_MS,
+      repeat_speedup_min: REPEAT_SPEEDUP_MIN,
+    },
+    summary: {
+      priority_ready_kind: priorityReadyKind,
+      priority_ready_ms: priorityReadyMs,
+      priority_ready_anchor_completed: priorityAnchorCompleted,
+      priority_ready_anchor_total: priorityAnchorTotal,
+      priority_ready_all_top1_hit: allTop1Hit,
+      priority_ready_max_search_ms: maxSearchMs,
+      repeat_ready_kind: repeatReadyKind,
+      repeat_ready_anchor_completed: repeatAnchorCompleted,
+      repeat_ready_anchor_total: repeatAnchorTotal,
+      repeat_search_speedup_ratio: repeatSpeedup,
+    },
+  };
+
+  if (failedChecks.length > 0) {
+    fail("benchmark gate failed", { ...output, failed_checks: failedChecks });
+    return;
+  }
+
+  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+}
+
+main().catch((error) => {
+  fail(error instanceof Error ? error.message : String(error), {});
+});

package/scripts/benchmark-generic-resumed-single-chunk-embed.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+
+import { createBenchmarkSnapshot } from "./lib/benchmark-snapshot.mjs";
+import { extractPriorityReadyHotspotChunks } from "../src/priority-ready-hotspots.js";
+import { compactEmbeddingContentForSingleResumeChunk } from "../src/single-chunk-embedding-content.js";
+
+const execFileAsync = promisify(execFile);
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const MODEL = String(process.env.IDEROUTER_BENCH_SINGLE_CHUNK_MODEL || "openai/text-embedding-3-small").trim();
+const TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_SINGLE_CHUNK_TIMEOUT_MS || 15000);
+const RELATIVE_PATH = "src/index.js";
+
+async function postEmbeddingWithCurl({ endpoint, apiKey, model, input, timeoutMs }) {
+  const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1000));
+  const marker = "\n__IDEROUTER_HTTP_STATUS__:";
+  const payload = JSON.stringify({
+    model,
+    input: [input],
+  });
+  const args = [
+    "-sS",
+    "-X", "POST",
+    "--connect-timeout", String(Math.min(15, timeoutSeconds)),
+    "--max-time", String(timeoutSeconds),
+    "-H", "Content-Type: application/json",
+    "-H", `Authorization: Bearer ${apiKey}`,
+    "--data-binary", "@-",
+    "-w", `${marker}%{http_code}`,
+    endpoint,
+  ];
+  const startedAt = Date.now();
+  const { stdout } = await execFileAsync("curl", args, {
+    input: payload,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  const wallMs = Date.now() - startedAt;
+  const output = String(stdout || "");
+  const markerIndex = output.lastIndexOf(marker);
+  if (markerIndex < 0) {
+    throw new Error("curl did not return HTTP status marker");
+  }
+  const responseBody = output.slice(0, markerIndex);
+  const status = Number(output.slice(markerIndex + marker.length).trim());
+  return {
+    status,
+    wall_ms: wallMs,
+    response_preview: responseBody.slice(0, 500),
+  };
+}
+
+async function main() {
+  const apiKey = process.env.IDEROUTER_API_KEY;
+  if (!apiKey) throw new Error("IDEROUTER_API_KEY is required");
+  const baseURL = process.env.IDEROUTER_BASE_URL || "https://cursor.iderouter.com/v1";
+  const endpoint = `${baseURL.replace(/\/+$/, "")}/embeddings`;
+  const snapshot = await createBenchmarkSnapshot(TARGET_PATH, process.env);
+  const filePath = path.join(snapshot.snapshotDir, RELATIVE_PATH);
+  try {
+    const content = await fs.readFile(filePath, "utf8");
+    const chunks = extractPriorityReadyHotspotChunks(content, {
+      relativePath: RELATIVE_PATH,
+      extension: ".js",
+    }, {
+      chunkSize: 600,
+      chunkCap: 3,
+      primaryOnly: true,
+    });
+    if (!chunks[0]) {
+      throw new Error(`generic resumed single chunk not found in ${RELATIVE_PATH}`);
+    }
+    const payload = compactEmbeddingContentForSingleResumeChunk(chunks[0]);
+    const result = await postEmbeddingWithCurl({
+      endpoint,
+      apiKey,
+      model: MODEL,
+      input: payload,
+      timeoutMs: TIMEOUT_MS,
+    });
+    process.stdout.write(`${JSON.stringify({
+      path: TARGET_PATH,
+      snapshot_path: snapshot.snapshotDir,
+      model: MODEL,
+      timeout_ms: TIMEOUT_MS,
+      relative_path: RELATIVE_PATH,
+      chunk_preview: chunks[0].content.slice(0, 160),
+      payload,
+      payload_length: payload.length,
+      result,
+    }, null, 2)}\n`);
+  } finally {
+    await fs.rm(snapshot.snapshotDir, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/scripts/benchmark-noop.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import process from "node:process";
+import { runIndexBenchmark } from "./lib/mcp-bench.mjs";
+
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_TIMEOUT_MS || 30000);
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 500);
+
+async function main() {
+  const result = await runIndexBenchmark({
+    targetPath: TARGET_PATH,
+    timeoutMs: TIMEOUT_MS,
+    pollMs: POLL_MS,
+    startArgs: { path: TARGET_PATH, wait: false, cloud: false },
+  });
+  process.stdout.write(`${JSON.stringify(result.parsed, null, 2)}\n`);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

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

@@ -0,0 +1,165 @@
+#!/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 waitUntilPriorityReady(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 priorityReadyFromMeta = Boolean(meta?.priorityFineReady) && Number(meta?.fineSemanticChunkCount || 0) > 0;
+    const fullReadyFromMeta = Boolean(meta?.complete);
+    if (/^Priority semantic search is ready\b/.test(text) || /^Indexed\b/.test(text) || priorityReadyFromMeta || fullReadyFromMeta) {
+      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),
+  };
+}
+
+function anchorCoverageFromMeta(meta) {
+  const coverage = meta?.priorityReadyAnchorCoverage || {};
+  return {
+    total: Number(coverage.total || 0),
+    completed: Number(coverage.completed || 0),
+    completed_paths: Array.isArray(coverage.completed_paths) ? coverage.completed_paths : [],
+    pending_paths: Array.isArray(coverage.pending_paths) ? coverage.pending_paths : [],
+  };
+}
+
+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 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 waitUntilPriorityReady(
+      client,
+      snapshotDir,
+      Math.max(TIMEOUT_MS, 180000),
+      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,
+          priority_ready: ready,
+          priority_ready_anchor_coverage: anchorCoverageFromMeta(ready.meta),
+          priority_ready_kind: /^Indexed\b/.test(ready.finalText || "")
+            ? "full_ready"
+            : ((/^Priority semantic search is ready\b/.test(ready.finalText || "") && Number(ready?.meta?.fineSemanticChunkCount || 0) > 0) || ready?.settled)
+              ? "priority_semantic"
+              : "not_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;
+});