@iderouter/index-mcp 0.2.0-beta.1

package/scripts/benchmark-repeat-search.mjs

@@ -0,0 +1,148 @@
+#!/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 { 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 REPEAT_QUERY = "billing backend execution path RunExprWithRequest model pricing editor";
+
+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,
+    );
+
+    let first = null;
+    let second = null;
+    if (ready.settled) {
+      const startedFirst = Date.now();
+      const firstText = await client.callTool("search_code", {
+        path: snapshotDir,
+        query: REPEAT_QUERY,
+        limit: 5,
+      });
+      first = {
+        wall_ms: Date.now() - startedFirst,
+        status: firstText.split("\n")[0],
+      };
+
+      const startedSecond = Date.now();
+      const secondText = await client.callTool("search_code", {
+        path: snapshotDir,
+        query: REPEAT_QUERY,
+        limit: 5,
+      });
+      second = {
+        wall_ms: Date.now() - startedSecond,
+        status: secondText.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],
+          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",
+          repeat_query: REPEAT_QUERY,
+          first,
+          second,
+          speedup_ratio: first && second && second.wall_ms > 0
+            ? Number((first.wall_ms / second.wall_ms).toFixed(2))
+            : null,
+        },
+        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-resumed-retry-burst.mjs

@@ -0,0 +1,187 @@
+#!/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";
+
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 500);
+const FIRST_PHASE_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_RETRY_BURST_FIRST_PHASE_TIMEOUT_MS || 30000);
+const TOTAL_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_RETRY_BURST_TOTAL_TIMEOUT_MS || 90000);
+const MAX_RETRIES = Math.max(1, Number(process.env.IDEROUTER_BENCH_RETRY_BURST_MAX_RETRIES || 4));
+
+function snapshotState(meta, job, statusText) {
+  return {
+    status_text: String(statusText || "").split("\n")[0],
+    job_id: job?.id || "",
+    job_status: job?.status || "",
+    current_step: job?.currentStep || "",
+    embedding_model: job?.embeddingModel || job?.diagnostics?.embeddingModel || "",
+    embedding_model_source: job?.embeddingModelSource || job?.diagnostics?.embeddingModelSource || "",
+    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),
+    semantic_retry_count: Number(job?.semanticRetryCount || 0),
+    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 waitForInitialDeferred(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 (state.semantic_retry_deferred) {
+      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 observeRetryBurst(client, snapshotDir, indexHome, baselineJobId) {
+  const startedAt = Date.now();
+  let lastText = "";
+  const attempts = [];
+  let lastRecordedJobId = baselineJobId;
+
+  while (Date.now() - startedAt < TOTAL_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,
+        outcome: "semantic_visible",
+        attempts,
+        state,
+      };
+    }
+
+    const newDeferredCycle =
+      state.semantic_retry_deferred &&
+      state.job_id &&
+      state.job_id !== baselineJobId &&
+      state.job_id !== lastRecordedJobId;
+
+    if (newDeferredCycle) {
+      attempts.push({
+        job_id: state.job_id,
+        embedding_model: state.embedding_model,
+        embedding_model_source: state.embedding_model_source,
+        semantic_retry_count: state.semantic_retry_count,
+        wall_ms: Date.now() - startedAt,
+        status_text: state.status_text,
+      });
+      lastRecordedJobId = state.job_id;
+      if (attempts.length >= MAX_RETRIES) {
+        return {
+          settled: true,
+          wall_ms: Date.now() - startedAt,
+          outcome: "max_retries_observed",
+          attempts,
+          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,
+    outcome: "timeout",
+    attempts,
+    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-retry-burst-"));
+  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 waitForInitialDeferred(client, snapshotDir, isolatedIndexHome);
+    const burst = firstPhase.settled
+      ? await observeRetryBurst(client, snapshotDir, isolatedIndexHome, firstPhase.state.job_id)
+      : { settled: false, wall_ms: 0, outcome: "no_first_phase", attempts: [], 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,
+          burst,
+        },
+        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-resumed-single-chunk-success.mjs

@@ -0,0 +1,154 @@
+#!/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";
+
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 500);
+const FIRST_PHASE_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_RESUMED_SINGLE_CHUNK_FIRST_PHASE_TIMEOUT_MS || 30000);
+const RESUME_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_RESUMED_SINGLE_CHUNK_RESUME_TIMEOUT_MS || 30000);
+
+function snapshotState(meta, job, statusText) {
+  return {
+    status_text: String(statusText || "").split("\n")[0],
+    job_id: job?.id || "",
+    job_status: job?.status || "",
+    current_step: job?.currentStep || "",
+    embedding_model: job?.embeddingModel || job?.diagnostics?.embeddingModel || "",
+    embedding_model_source: job?.embeddingModelSource || job?.diagnostics?.embeddingModelSource || "",
+    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 waitForFirstDeferredReady(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 (state.semantic_retry_deferred) {
+      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 waitForResumedOutcome(client, snapshotDir, indexHome, baselineJobId) {
+  const startedAt = Date.now();
+  let lastText = "";
+  while (Date.now() - startedAt < RESUME_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);
+    const resumedJob = state.job_id && state.job_id !== baselineJobId;
+    const semanticVisible = state.fine_semantic_chunks > 0 || state.fine_semantic_files > 0;
+    const reDeferred = resumedJob && state.semantic_retry_deferred;
+    const failed = resumedJob && state.job_status === "failed";
+    if (semanticVisible || reDeferred || failed) {
+      return {
+        settled: true,
+        wall_ms: Date.now() - startedAt,
+        outcome: semanticVisible ? "semantic_visible" : reDeferred ? "re_deferred" : "failed",
+        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,
+    outcome: "timeout",
+    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-resumed-success-"));
+  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 waitForFirstDeferredReady(client, snapshotDir, isolatedIndexHome);
+    const resumedOutcome = firstPhase.settled
+      ? await waitForResumedOutcome(client, snapshotDir, isolatedIndexHome, firstPhase.state.job_id)
+      : { settled: false, wall_ms: 0, outcome: "no_first_phase", 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,
+          resumed_outcome: resumedOutcome,
+        },
+        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-resumed-single-chunk.mjs

@@ -0,0 +1,146 @@
+#!/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";
+
+const TARGET_PATH = path.resolve(process.argv[2] || process.cwd());
+const POLL_MS = Number(process.env.IDEROUTER_BENCH_POLL_MS || 500);
+const FIRST_PHASE_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_RESUMED_SINGLE_CHUNK_FIRST_PHASE_TIMEOUT_MS || 30000);
+const RESUME_TIMEOUT_MS = Number(process.env.IDEROUTER_BENCH_RESUMED_SINGLE_CHUNK_RESUME_TIMEOUT_MS || 30000);
+
+function snapshotState(meta, job, statusText) {
+  return {
+    status_text: String(statusText || "").split("\n")[0],
+    job_id: job?.id || "",
+    job_status: job?.status || "",
+    current_step: job?.currentStep || "",
+    embedding_model: job?.embeddingModel || job?.diagnostics?.embeddingModel || "",
+    embedding_model_source: job?.embeddingModelSource || job?.diagnostics?.embeddingModelSource || "",
+    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 waitForDeferredReady(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);
+    if (job?.semanticRetryDeferred) {
+      return {
+        settled: true,
+        wall_ms: Date.now() - startedAt,
+        state: snapshotState(meta, job, lastText),
+      };
+    }
+    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 waitForResumedSingleChunk(client, snapshotDir, indexHome, baselineJobId) {
+  const startedAt = Date.now();
+  let lastText = "";
+  while (Date.now() - startedAt < RESUME_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.job_id &&
+      state.job_id !== baselineJobId &&
+      state.job_status === "indexing" &&
+      state.embedding_model_source.startsWith("previous_failure_fallback_deferred_resume") &&
+      state.total_chunks === 1
+    ) {
+      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-resumed-single-"));
+  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 waitForDeferredReady(client, snapshotDir, isolatedIndexHome);
+    const resumed = firstPhase.settled
+      ? await waitForResumedSingleChunk(client, snapshotDir, isolatedIndexHome, firstPhase.state.job_id)
+      : { 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,
+          resumed_single_chunk: resumed,
+        },
+        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;
+});