@lzehrung/codegraph 3.1.0 → 3.1.1

package/dist/bin/cli.js

@@ -685,6 +685,7 @@ var init_options = __esm({
       "--min-tokens",
       "--max-tokens",
       "--max-bucket-size",
+      "--max-candidate-pairs",
       "--min-confidence",
       "--max-hits",
       "--resolution-hint",
@@ -722,6 +723,7 @@ var init_options = __esm({
       "--graph",
       "--port",
       "--idle-timeout-ms",
+      "--index-wait-ms",
       "--startup-timeout-ms",
       "--offset",
       "--max-bytes",
@@ -848,6 +850,7 @@ var init_options = __esm({
           "--include-root-glob",
           "--limit",
           "--max-bucket-size",
+          "--max-candidate-pairs",
           "--max-tokens",
           "--min-confidence",
           "--min-tokens",
@@ -994,7 +997,7 @@ var init_options = __esm({
       ],
       [
         "mcp",
-        commandSchema([...SHARED_BUILD_FLAGS, "--allow-build", "--stdio", "--warmup", "--warmup-symbols", "--no-warmup", "--no-watch"], [...SHARED_BUILD_OPTIONS, "--artifact", "--host", "--port", "--idle-timeout-ms"], {
+        commandSchema([...SHARED_BUILD_FLAGS, "--allow-build", "--stdio", "--warmup", "--warmup-symbols", "--no-warmup", "--no-watch"], [...SHARED_BUILD_OPTIONS, "--artifact", "--host", "--port", "--idle-timeout-ms", "--index-wait-ms"], {
           kind: "max",
           max: 1,
           usage: "Usage: codegraph mcp [serve] [--root <path>] [--stdio | --port <number>]"
@@ -1019,6 +1022,7 @@ var init_options = __esm({
           "--host",
           "--ignore-glob",
           "--include-glob",
+          "--index-wait-ms",
           "--port",
           "--resolution-hint",
           "--root",
@@ -1237,6 +1241,7 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
   let current = 0;
   let total = 0;
   let mode = "build";
+  let unit = DEFAULT_COUNT_UNIT;
   let activity = progressAction(mode);
   let interval;
   let delay3;
@@ -1252,7 +1257,7 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
       return;
     const frame = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length];
     frameIndex += 1;
-    const count = hasProgressCount(mode, current, total) ? formatProgressCount(current, total) : "";
+    const count = hasProgressCount(mode, current, total) ? formatProgressCount(current, total, unit) : "";
     const elapsed = ` (${formatDuration(performance2.now() - phaseStartedAt)})`;
     write(`${CLEAR_LINE}${activity}... ${frame}${count}${elapsed}`);
     rendered = true;
@@ -1276,6 +1281,7 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
     current = update.current;
     total = update.total;
     mode = update.mode ?? "build";
+    unit = update.unit ?? DEFAULT_COUNT_UNIT;
     activity = update.activity ?? `${progressAction(mode)} project index`;
     phaseStartedAt = performance2.now();
     const beginRendering = () => {
@@ -1300,10 +1306,14 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
     if (!rendered)
       return;
     clear();
-    const verb = progressCompleteVerb(update.mode ?? mode);
-    const fileCount = formatFileCount(update.total, "words");
     const elapsed = update.elapsedMs === void 0 ? "" : ` in ${formatDuration(update.elapsedMs)}`;
-    write(`${verb} project index: ${fileCount}${elapsed}.
+    if (update.activity !== void 0) {
+      write(`${update.activity}: ${formatCount(update.total, update.unit ?? DEFAULT_COUNT_UNIT, "words")}${elapsed}.
+`);
+      return;
+    }
+    const verb = progressCompleteVerb(update.mode ?? mode);
+    write(`${verb} project index: ${formatCount(update.total, DEFAULT_COUNT_UNIT, "words")}${elapsed}.
 `);
   };
   return {
@@ -1324,10 +1334,17 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
       current = update.current;
       total = update.total;
       mode = update.mode ?? mode;
-      if (update.activity !== void 0 && update.activity !== activity)
+      if (update.activity !== void 0)
+        unit = update.unit ?? DEFAULT_COUNT_UNIT;
+      else if (update.unit !== void 0)
+        unit = update.unit;
+      const activityChanged = update.activity !== void 0 && update.activity !== activity;
+      if (activityChanged)
         phaseStartedAt = performance2.now();
       if (update.activity !== void 0)
         activity = update.activity;
+      if (activityChanged && interval !== void 0)
+        render();
     },
     clear,
     dispose: () => {
@@ -1337,15 +1354,15 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
     }
   };
 }
-function formatFileCount(count, zeroFormat = "numeric") {
+function formatCount(count, unit, zeroFormat = "numeric") {
   if (!count && zeroFormat === "words")
-    return "no files";
-  return `${count} file${count === 1 ? "" : "s"}`;
+    return `no ${unit}s`;
+  return `${count} ${unit}${count === 1 ? "" : "s"}`;
 }
-function formatProgressCount(current, total) {
+function formatProgressCount(current, total, unit) {
   if (total > 0)
-    return ` ${current}/${formatFileCount(total)}`;
-  return ` ${formatFileCount(current)} processed`;
+    return ` ${current}/${formatCount(total, unit)}`;
+  return ` ${formatCount(current, unit)} processed`;
 }
 function hasProgressCount(mode, current, total) {
   return mode !== "check" || current > 0 || total > 0;
@@ -1356,6 +1373,7 @@ function createLogProgressDisplay(write, delayMs = 0) {
   let current = 0;
   let total = 0;
   let mode = "build";
+  let unit = DEFAULT_COUNT_UNIT;
   let activity = progressAction(mode);
   let delay3;
   let heartbeat;
@@ -1379,7 +1397,7 @@ function createLogProgressDisplay(write, delayMs = 0) {
     heartbeat = setInterval(() => {
       if (!active)
         return;
-      const count = hasProgressCount(mode, current, total) ? `:${formatProgressCount(current, total)}` : "";
+      const count = hasProgressCount(mode, current, total) ? `:${formatProgressCount(current, total, unit)}` : "";
       const elapsed = formatDuration(performance2.now() - phaseStartedAt);
       write(`[Progress] ${activity}${count}. (${elapsed})
 `);
@@ -1393,6 +1411,7 @@ function createLogProgressDisplay(write, delayMs = 0) {
     current = update.current;
     total = update.total;
     mode = update.mode ?? "build";
+    unit = update.unit ?? DEFAULT_COUNT_UNIT;
     activity = update.activity ?? `${progressAction(mode)} project index`;
     phaseStartedAt = performance2.now();
     if (delayMs) {
@@ -1415,9 +1434,14 @@ function createLogProgressDisplay(write, delayMs = 0) {
         stopTimers();
         if (!rendered)
           return;
-        const verb = progressCompleteVerb(update.mode ?? mode);
         const elapsed = update.elapsedMs === void 0 ? "" : ` in ${formatDuration(update.elapsedMs)}`;
-        write(`[Progress] ${verb} project index: ${formatFileCount(update.total, "words")}${elapsed}.
+        if (update.activity !== void 0) {
+          write(`[Progress] ${update.activity}: ${formatCount(update.total, update.unit ?? DEFAULT_COUNT_UNIT, "words")}${elapsed}.
+`);
+          return;
+        }
+        const verb = progressCompleteVerb(update.mode ?? mode);
+        write(`[Progress] ${verb} project index: ${formatCount(update.total, DEFAULT_COUNT_UNIT, "words")}${elapsed}.
 `);
         return;
       }
@@ -1430,6 +1454,10 @@ function createLogProgressDisplay(write, delayMs = 0) {
       current = update.current;
       total = update.total;
       mode = update.mode ?? mode;
+      if (update.activity !== void 0)
+        unit = update.unit ?? DEFAULT_COUNT_UNIT;
+      else if (update.unit !== void 0)
+        unit = update.unit;
       if (update.activity !== void 0)
         activity = update.activity;
       const activityChanged = activity !== previousActivity;
@@ -1444,10 +1472,10 @@ function createLogProgressDisplay(write, delayMs = 0) {
       if (shouldPrintCount) {
         const elapsed = formatDuration(performance2.now() - phaseStartedAt);
         if (update.activity !== void 0) {
-          write(`[Progress] ${activity}:${formatProgressCount(update.current, update.total)}. (${elapsed})
+          write(`[Progress] ${activity}:${formatProgressCount(update.current, update.total, unit)}. (${elapsed})
 `);
         } else {
-          write(`[Progress] ${formatFileCount(update.current)} processed. (${elapsed})
+          write(`[Progress] ${formatCount(update.current, unit)} processed. (${elapsed})
 `);
         }
       }
@@ -1480,13 +1508,14 @@ function formatDuration(elapsedMs2) {
     return `${Math.round(durationMs)}ms`;
   return `${(durationMs / 1e3).toFixed(1)}s`;
 }
-var REFRESH_INTERVAL_MS, CLEAR_LINE, SPINNER_FRAMES;
+var REFRESH_INTERVAL_MS, CLEAR_LINE, SPINNER_FRAMES, DEFAULT_COUNT_UNIT;
 var init_progress = __esm({
   "dist/cli/progress.js"() {
     "use strict";
     REFRESH_INTERVAL_MS = 100;
     CLEAR_LINE = "\r\x1B[2K";
     SPINNER_FRAMES = ["-", "\\", "|", "/"];
+    DEFAULT_COUNT_UNIT = "file";
   }
 });
 
@@ -9499,12 +9528,14 @@ var init_dist2 = __esm({
 // dist/util/concurrency.js
 var concurrency_exports = {};
 __export(concurrency_exports, {
+  EVENT_LOOP_SLICE_MS: () => EVENT_LOOP_SLICE_MS,
   Semaphore: () => Semaphore,
   delay: () => delay,
   getIOSemaphore: () => getIOSemaphore,
   mapLimit: () => mapLimit,
   mapLimitSemaphore: () => mapLimitSemaphore,
-  resetIOSemaphore: () => resetIOSemaphore
+  resetIOSemaphore: () => resetIOSemaphore,
+  yieldToEventLoop: () => yieldToEventLoop
 });
 async function mapLimit(items, limit, fn) {
   if (!items.length)
@@ -9572,7 +9603,12 @@ function delay(ms) {
   setTimeout(resolve3, ms);
   return promise3;
 }
-var Semaphore, globalIOSemaphore;
+function yieldToEventLoop() {
+  const { promise: promise3, resolve: resolve3 } = Promise.withResolvers();
+  setImmediate(resolve3);
+  return promise3;
+}
+var Semaphore, globalIOSemaphore, EVENT_LOOP_SLICE_MS;
 var init_concurrency = __esm({
   "dist/util/concurrency.js"() {
     "use strict";
@@ -9625,6 +9661,7 @@ var init_concurrency = __esm({
       }
     };
     globalIOSemaphore = null;
+    EVENT_LOOP_SLICE_MS = 10;
   }
 });
 
@@ -68918,6 +68955,68 @@ var init_unit_cache = __esm({
   }
 });
 
+// dist/duplicates/progress.js
+import { performance as performance4 } from "node:perf_hooks";
+function createDuplicateProgress(onProgress, startedAt) {
+  if (!onProgress)
+    return void 0;
+  const origin = startedAt ?? performance4.now();
+  let opened = false;
+  let lastYield = performance4.now();
+  return {
+    stage: (activity, current = 0, total = 0, unit) => {
+      onProgress({
+        type: "progress",
+        phase: opened ? "update" : "start",
+        mode: "check",
+        message: activity,
+        activity,
+        current,
+        total,
+        ...unit !== void 0 ? { unit } : {}
+      });
+      opened = true;
+    },
+    complete: (units) => {
+      if (!opened)
+        return;
+      onProgress({
+        type: "progress",
+        phase: "complete",
+        mode: "check",
+        message: DUPLICATE_STAGE_DONE,
+        activity: DUPLICATE_STAGE_DONE,
+        current: units,
+        total: units,
+        unit: "unit",
+        elapsedMs: performance4.now() - origin
+      });
+    },
+    yieldPoint: () => {
+      if (performance4.now() - lastYield < YIELD_INTERVAL_MS)
+        return void 0;
+      return new Promise((resolve3) => {
+        setImmediate(() => {
+          lastYield = performance4.now();
+          resolve3();
+        });
+      });
+    }
+  };
+}
+var YIELD_INTERVAL_MS, DUPLICATE_STAGE_UNITS, DUPLICATE_STAGE_PAIRS, DUPLICATE_STAGE_SCORING, DUPLICATE_STAGE_GROUPING, DUPLICATE_STAGE_DONE;
+var init_progress2 = __esm({
+  "dist/duplicates/progress.js"() {
+    "use strict";
+    YIELD_INTERVAL_MS = 50;
+    DUPLICATE_STAGE_UNITS = "Collecting duplicate units";
+    DUPLICATE_STAGE_PAIRS = "Finding candidate pairs";
+    DUPLICATE_STAGE_SCORING = "Scoring candidate pairs";
+    DUPLICATE_STAGE_GROUPING = "Grouping duplicate findings";
+    DUPLICATE_STAGE_DONE = "Detected duplicates";
+  }
+});
+
 // dist/duplicates/units.js
 var units_exports = {};
 __export(units_exports, {
@@ -69379,7 +69478,7 @@ function shouldKeepUnit(unit, includeSmall, minTokens) {
     return true;
   return unit.tokenCount >= minTokens;
 }
-async function collectDuplicateUnits(index, options) {
+async function collectDuplicateUnits(index, options, progress) {
   const files = options.files ?? Array.from(index.byFile.values(), (module2) => module2.file);
   const filesByIdentity = /* @__PURE__ */ new Map();
   for (const file2 of files) {
@@ -69392,8 +69491,14 @@ async function collectDuplicateUnits(index, options) {
   const variant = duplicateUnitCacheVariant(index, options.minTokens, options.maxTokens, options.shingleSize, options.windowSize, options.projectRoot);
   let belowThresholdUnits = 0;
   const belowThresholdUnitsByFile = /* @__PURE__ */ new Map();
+  let sliceStartedAt = performance.now();
   const pendingWrites = [];
+  let processedFiles = 0;
   for (const file2 of normalizedFiles) {
+    if (performance.now() - sliceStartedAt >= EVENT_LOOP_SLICE_MS) {
+      await yieldToEventLoop();
+      sliceStartedAt = performance.now();
+    }
     const fileKey = fileIdentityKey(file2);
     const cacheSignature = duplicateUnitCacheSignature(index, file2, options.projectRoot);
     let source = index.parsed?.get(fileKey)?.source;
@@ -69421,9 +69526,18 @@ async function collectDuplicateUnits(index, options) {
       }
       units.push(unit);
     }
+    if (progress) {
+      processedFiles++;
+      progress.stage(DUPLICATE_STAGE_UNITS, processedFiles, normalizedFiles.length, "file");
+      const pending = progress.yieldPoint();
+      if (pending)
+        await pending;
+    }
   }
-  if (pendingWrites.length) {
-    writeDuplicateUnitsBatchToCache(index, pendingWrites, options.projectRoot);
+  for (let start = 0; start < pendingWrites.length; start += DUPLICATE_CACHE_WRITE_SLICE_FILES) {
+    const slice = pendingWrites.slice(start, start + DUPLICATE_CACHE_WRITE_SLICE_FILES);
+    writeDuplicateUnitsBatchToCache(index, slice, options.projectRoot);
+    await yieldToEventLoop();
   }
   units.sort((left, right) => {
     const fileCompare = left.absoluteFile.localeCompare(right.absoluteFile);
@@ -69464,7 +69578,7 @@ async function buildDuplicateUnitsForFile(index, file2, projectRoot, minTokens,
   const chunkUnits = makeChunkUnits(file2, chunks, projectRoot, shingleSize, windowSize, astContext);
   return [...symbolUnits, ...chunkUnits];
 }
-var DEFAULT_MAX_FINGERPRINTS, textLanguageByExtension, symbolUnitKinds, duplicateImportStatementQueries, graphOnlyImportStatementPatterns;
+var DEFAULT_MAX_FINGERPRINTS, textLanguageByExtension, symbolUnitKinds, duplicateImportStatementQueries, graphOnlyImportStatementPatterns, DUPLICATE_CACHE_WRITE_SLICE_FILES;
 var init_units = __esm({
   "dist/duplicates/units.js"() {
     "use strict";
@@ -69482,8 +69596,10 @@ var init_units = __esm({
     init_tree_sitter_native();
     init_comments();
     init_lines();
+    init_concurrency();
     init_paths();
     init_unit_cache();
+    init_progress2();
     DEFAULT_MAX_FINGERPRINTS = 128;
     textLanguageByExtension = {
       ".json": "json",
@@ -69555,6 +69671,7 @@ var init_units = __esm({
       astro: /^[\t ]*import\b(?![\t ]*\()(?:[\t ]*["'][^"']*["']|[\s\S]*?\bfrom[\t ]*["'][^"']*["']|[\s\S]*?;)/gmu,
       mdx: /^[\t ]*import\b(?![\t ]*\()(?:[\t ]*["'][^"']*["']|[\s\S]*?\bfrom[\t ]*["'][^"']*["']|[\s\S]*?;)/gmu
     };
+    DUPLICATE_CACHE_WRITE_SLICE_FILES = 25;
   }
 });
 
@@ -69564,27 +69681,16 @@ __export(scoring_exports, {
   DEFAULT_GROUP_VARIANT_LIMIT: () => DEFAULT_GROUP_VARIANT_LIMIT,
   DEFAULT_LIMIT: () => DEFAULT_LIMIT,
   DEFAULT_MAX_BUCKET_SIZE: () => DEFAULT_MAX_BUCKET_SIZE,
+  DEFAULT_MAX_CANDIDATE_PAIRS: () => DEFAULT_MAX_CANDIDATE_PAIRS,
   DEFAULT_MAX_TOKENS: () => DEFAULT_MAX_TOKENS,
   DEFAULT_MIN_TOKENS: () => DEFAULT_MIN_TOKENS,
   DEFAULT_SHINGLE_SIZE: () => DEFAULT_SHINGLE_SIZE,
   DEFAULT_WINDOW_SIZE: () => DEFAULT_WINDOW_SIZE,
   GROUP_PRIMARY_LENGTH_RATIO_FLOOR: () => GROUP_PRIMARY_LENGTH_RATIO_FLOOR,
-  MIN_SIMILARITY_HINT_INDEX: () => MIN_SIMILARITY_HINT_INDEX,
+  MAX_CANDIDATE_PAIRS_LIMIT: () => MAX_CANDIDATE_PAIRS_LIMIT,
   NEARBY_CHUNK_VARIANT_MAX_GAP: () => NEARBY_CHUNK_VARIANT_MAX_GAP,
-  addAlignedSimilarityHintPairs: () => addAlignedSimilarityHintPairs,
-  addBucketPairs: () => addBucketPairs,
-  addBucketsToPairs: () => addBucketsToPairs,
-  addConsideredSignature: () => addConsideredSignature,
-  addPairEvidence: () => addPairEvidence,
-  addSignatureBucketsToPairs: () => addSignatureBucketsToPairs,
-  addSimilarityHintPair: () => addSimilarityHintPair,
-  addSimilarityHintPairs: () => addSimilarityHintPairs,
-  addToBucket: () => addToBucket,
   bestCloneType: () => bestCloneType,
   bestConfidence: () => bestConfidence,
-  bucketPairCountExceeds: () => bucketPairCountExceeds,
-  buildCandidatePairs: () => buildCandidatePairs,
-  buildCandidatePairsFromPreparedBuckets: () => buildCandidatePairsFromPreparedBuckets,
   cleanupLabelsForGroup: () => cleanupLabelsForGroup,
   cloneTypeForPair: () => cloneTypeForPair,
   cloneTypeRank: () => cloneTypeRank,
@@ -69603,20 +69709,15 @@ __export(scoring_exports, {
   duplicateUnitRefQuality: () => duplicateUnitRefQuality,
   enrichDuplicateGroups: () => enrichDuplicateGroups,
   estimatedLinesSavedForLocations: () => estimatedLinesSavedForLocations,
-  filterPreparedDuplicateBucketMap: () => filterPreparedDuplicateBucketMap,
-  filterPreparedDuplicateBuckets: () => filterPreparedDuplicateBuckets,
-  forEachBucketPair: () => forEachBucketPair,
   groupClusterSummary: () => groupClusterSummary,
   groupForSuggestions: () => groupForSuggestions,
   groupLocations: () => groupLocations,
   groupLooksLikeBarrelNoise: () => groupLooksLikeBarrelNoise,
   groupLooksLikeImportListNoise: () => groupLooksLikeImportListNoise,
   groupSuggestions: () => groupSuggestions,
-  hasEnoughSharedFingerprints: () => hasEnoughSharedFingerprints,
-  hasEnoughSharedFingerprintsFor: () => hasEnoughSharedFingerprintsFor,
-  hasLineOverlap: () => hasLineOverlap,
   isFixtureLikeFile: () => isFixtureLikeFile,
   isLocationClique: () => isLocationClique,
+  isScorablePair: () => isScorablePair,
   isTestFile: () => isTestFile,
   lineOverlap: () => lineOverlap,
   locationsForSuggestions: () => locationsForSuggestions,
@@ -69627,21 +69728,16 @@ __export(scoring_exports, {
   metricsForPair: () => metricsForPair,
   normalizeConfidence: () => normalizeConfidence,
   normalizeIntegerOption: () => normalizeIntegerOption,
+  normalizeMaxCandidatePairsOption: () => normalizeMaxCandidatePairsOption,
   normalizeNonNegativeIntegerOption: () => normalizeNonNegativeIntegerOption,
   normalizePositiveIntegerOption: () => normalizePositiveIntegerOption,
-  normalizeSimilarityHintFile: () => normalizeSimilarityHintFile,
   orderedGroupKey: () => orderedGroupKey,
-  orderedPair: () => orderedPair,
   orderedUnitPairKey: () => orderedUnitPairKey,
   orderedUnitRangePairKey: () => orderedUnitRangePairKey,
-  pairKey: () => pairKey,
   preferredDuplicateUnitRef: () => preferredDuplicateUnitRef,
-  prepareDuplicateCandidateBuckets: () => prepareDuplicateCandidateBuckets,
   reducedLinesForPair: () => reducedLinesForPair,
   scorePair: () => scorePair,
   shouldScoreSignatureEvidence: () => shouldScoreSignatureEvidence,
-  similarityAlignmentKey: () => similarityAlignmentKey,
-  similarityHintPairCountExceeds: () => similarityHintPairCountExceeds,
   singletonUnitCluster: () => singletonUnitCluster,
   suggestionForPair: () => suggestionForPair,
   suggestionPrimaryRank: () => suggestionPrimaryRank,
@@ -69686,14 +69782,6 @@ function ratio(left, right) {
     return 0;
   return Math.min(left, right) / Math.max(left, right);
 }
-function normalizeSimilarityIndex(value) {
-  if (!Number.isFinite(value))
-    return void 0;
-  const bounded = Math.max(0, Math.min(100, Math.round(value)));
-  if (bounded < MIN_SIMILARITY_HINT_INDEX)
-    return void 0;
-  return bounded;
-}
 function jaccard(left, right) {
   if (!left.size && !right.size)
     return 1;
@@ -69723,6 +69811,13 @@ function normalizePositiveIntegerOption(value, optionName2, fallback) {
 function normalizeNonNegativeIntegerOption(value, optionName2, fallback) {
   return normalizeIntegerOption(value, optionName2, fallback, 0, "a non-negative integer");
 }
+function normalizeMaxCandidatePairsOption(value) {
+  const resolved = normalizePositiveIntegerOption(value, "maxCandidatePairs", DEFAULT_MAX_CANDIDATE_PAIRS);
+  if (resolved > MAX_CANDIDATE_PAIRS_LIMIT) {
+    throw new Error(`Invalid maxCandidatePairs value "${resolved}". Expected an integer from 1 to ${MAX_CANDIDATE_PAIRS_LIMIT}.`);
+  }
+  return resolved;
+}
 function bestConfidence(left, right) {
   if (confidenceRank[left] >= confidenceRank[right])
     return left;
@@ -69759,182 +69854,15 @@ function shouldScoreSignatureEvidence(evidence, metrics) {
   }
   return metrics.shingleOverlap >= 0.55;
 }
-function pairKey(left, right) {
-  if (left.id < right.id)
-    return `${left.id}\0${right.id}`;
-  return `${right.id}\0${left.id}`;
-}
-function orderedPair(left, right) {
-  if (left.absoluteFile < right.absoluteFile)
-    return [left, right];
-  if (left.absoluteFile > right.absoluteFile)
-    return [right, left];
-  if (left.startLine <= right.startLine)
-    return [left, right];
-  return [right, left];
-}
 function hasLineOverlap(left, right) {
   if (left.absoluteFile !== right.absoluteFile)
     return false;
   return left.startLine <= right.endLine && right.startLine <= left.endLine;
 }
-function addPairEvidence(pairs, evidenceKind, left, right) {
-  const key = pairKey(left, right);
-  const existing = pairs.get(key);
-  if (existing) {
-    if (evidenceKind === "signature") {
-      existing.signatureMatches++;
-    } else {
-      existing[evidenceKind] = true;
-    }
-    return;
-  }
-  pairs.set(key, {
-    left,
-    right,
-    rawHash: evidenceKind === "rawHash",
-    normalizedHash: evidenceKind === "normalizedHash",
-    astShape: evidenceKind === "astShape",
-    signature: false,
-    signatureMatches: evidenceKind === "signature" ? 1 : 0
-  });
-}
-function forEachBucketPair(bucket, pairFilter, unitFilter, visit2) {
-  if (unitFilter) {
-    const targetUnits = bucket.filter(unitFilter);
-    const seenPairs = /* @__PURE__ */ new Set();
-    for (const targetUnit of targetUnits) {
-      for (const otherUnit of bucket) {
-        if (targetUnit.id === otherUnit.id)
-          continue;
-        const [left, right] = orderedPair(targetUnit, otherUnit);
-        const key = pairKey(left, right);
-        if (seenPairs.has(key))
-          continue;
-        seenPairs.add(key);
-        if (pairFilter && !pairFilter(left, right))
-          continue;
-        visit2(left, right);
-      }
-    }
-    return;
-  }
-  for (let i = 0; i < bucket.length; i++) {
-    for (let j = i + 1; j < bucket.length; j++) {
-      const [left, right] = orderedPair(bucket[i], bucket[j]);
-      if (pairFilter && !pairFilter(left, right))
-        continue;
-      visit2(left, right);
-    }
-  }
-}
-function addBucketPairs(bucket, pairs, evidenceKind, pairFilter, unitFilter) {
-  forEachBucketPair(bucket, pairFilter, unitFilter, (left, right) => {
-    addPairEvidence(pairs, evidenceKind, left, right);
-  });
-}
-function bucketPairCountExceeds(bucket, limit, pairFilter, unitFilter) {
-  let count = 0;
-  const leftUnits = unitFilter ? bucket.filter(unitFilter) : bucket;
-  if (!leftUnits.length)
+function isScorablePair(left, right, crossFileOnly) {
+  if (crossFileOnly && left.absoluteFile === right.absoluteFile)
     return false;
-  const seenPairs = /* @__PURE__ */ new Set();
-  for (const leftUnit of leftUnits) {
-    for (const rightUnit of bucket) {
-      if (leftUnit.id === rightUnit.id)
-        continue;
-      const [left, right] = orderedPair(leftUnit, rightUnit);
-      const key = pairKey(left, right);
-      if (seenPairs.has(key))
-        continue;
-      seenPairs.add(key);
-      if (!pairFilter(left, right))
-        continue;
-      count++;
-      if (count > limit)
-        return true;
-    }
-  }
-  return false;
-}
-function addBucketsToPairs(buckets, pairs, evidenceKind, maxBucketSize, pairFilter, unitFilter) {
-  let oversizedBuckets = 0;
-  for (const bucket of buckets.values()) {
-    if (bucket.length < 2)
-      continue;
-    if (unitFilter && !bucket.some(unitFilter))
-      continue;
-    if (bucket.length > maxBucketSize) {
-      if (!pairFilter || bucketPairCountExceeds(bucket, maxBucketSize, pairFilter, unitFilter)) {
-        oversizedBuckets++;
-        continue;
-      }
-    }
-    addBucketPairs(bucket, pairs, evidenceKind, pairFilter, unitFilter);
-  }
-  return oversizedBuckets;
-}
-function addConsideredSignature(consideredSignaturesByUnit, unit, signature) {
-  const signatures = consideredSignaturesByUnit.get(unit.id);
-  if (signatures) {
-    signatures.add(signature);
-    return;
-  }
-  consideredSignaturesByUnit.set(unit.id, /* @__PURE__ */ new Set([signature]));
-}
-function addSignatureBucketsToPairs(buckets, pairs, consideredSignaturesByUnit, maxBucketSize, pairFilter, unitFilter) {
-  const signatureMatchCounts = /* @__PURE__ */ new Map();
-  const signatureMatchUnits = /* @__PURE__ */ new Map();
-  let oversizedBuckets = 0;
-  for (const [signature, bucket] of buckets) {
-    if (bucket.length < 2)
-      continue;
-    if (unitFilter && !bucket.some(unitFilter))
-      continue;
-    if (bucket.length > maxBucketSize) {
-      if (!pairFilter || bucketPairCountExceeds(bucket, maxBucketSize, pairFilter, unitFilter)) {
-        oversizedBuckets++;
-        continue;
-      }
-    }
-    for (const unit of bucket) {
-      addConsideredSignature(consideredSignaturesByUnit, unit, signature);
-    }
-    forEachBucketPair(bucket, pairFilter, unitFilter, (left, right) => {
-      const key = pairKey(left, right);
-      const next = (signatureMatchCounts.get(key) ?? 0) + 1;
-      signatureMatchCounts.set(key, next);
-      if (next === 2 && !pairs.has(key) && !signatureMatchUnits.has(key)) {
-        signatureMatchUnits.set(key, [left, right]);
-      }
-    });
-  }
-  for (const [key, count] of signatureMatchCounts) {
-    const existing = pairs.get(key);
-    if (existing) {
-      existing.signatureMatches = count;
-      continue;
-    }
-    if (count < 2)
-      continue;
-    const units = signatureMatchUnits.get(key);
-    if (!units)
-      continue;
-    const [left, right] = units;
-    if (!hasEnoughSharedFingerprintsFor(count, left.id, right.id, consideredSignaturesByUnit)) {
-      continue;
-    }
-    pairs.set(key, {
-      left,
-      right,
-      rawHash: false,
-      normalizedHash: false,
-      astShape: false,
-      signature: false,
-      signatureMatches: count
-    });
-  }
-  return oversizedBuckets;
+  return !hasLineOverlap(left, right);
 }
 function scorePair(evidence, metrics) {
   let score = 0;
@@ -69993,222 +69921,6 @@ function metricsForPair(evidence) {
   }
   return metrics;
 }
-function addToBucket(buckets, key, unit) {
-  appendToArrayMap(buckets, key, unit);
-}
-function prepareDuplicateCandidateBuckets(units) {
-  const rawHashBuckets = /* @__PURE__ */ new Map();
-  const normalizedHashBuckets = /* @__PURE__ */ new Map();
-  const astShapeBuckets = /* @__PURE__ */ new Map();
-  const signatureBuckets = /* @__PURE__ */ new Map();
-  for (const unit of units) {
-    const languagePrefix = `${unit.languageId}:`;
-    addToBucket(rawHashBuckets, `${languagePrefix}${unit.rawHash}`, unit);
-    addToBucket(normalizedHashBuckets, `${languagePrefix}${unit.normalizedHash}`, unit);
-    if (unit.astShapeHash !== void 0) {
-      addToBucket(astShapeBuckets, `${languagePrefix}${unit.astShapeHash}`, unit);
-    }
-    for (const signature of unit.signatures) {
-      addToBucket(signatureBuckets, `${languagePrefix}${signature}`, unit);
-    }
-  }
-  return {
-    units,
-    rawHashBuckets,
-    normalizedHashBuckets,
-    astShapeBuckets,
-    signatureBuckets
-  };
-}
-function filterPreparedDuplicateBucketMap(buckets, unitFilter) {
-  const filteredBuckets = /* @__PURE__ */ new Map();
-  for (const [key, bucket] of buckets) {
-    const filteredBucket = bucket.filter(unitFilter);
-    if (filteredBucket.length)
-      filteredBuckets.set(key, filteredBucket);
-  }
-  return filteredBuckets;
-}
-function filterPreparedDuplicateBuckets(preparedBuckets, unitFilter) {
-  return {
-    units: preparedBuckets.units.filter(unitFilter),
-    rawHashBuckets: filterPreparedDuplicateBucketMap(preparedBuckets.rawHashBuckets, unitFilter),
-    normalizedHashBuckets: filterPreparedDuplicateBucketMap(preparedBuckets.normalizedHashBuckets, unitFilter),
-    astShapeBuckets: filterPreparedDuplicateBucketMap(preparedBuckets.astShapeBuckets, unitFilter),
-    signatureBuckets: filterPreparedDuplicateBucketMap(preparedBuckets.signatureBuckets, unitFilter)
-  };
-}
-function buildCandidatePairsFromPreparedBuckets(preparedBuckets, maxBucketSize, similarityHints, projectRoot, pairFilter, unitFilter) {
-  const pairs = /* @__PURE__ */ new Map();
-  const consideredSignaturesByUnit = /* @__PURE__ */ new Map();
-  let oversizedBuckets = 0;
-  oversizedBuckets += addBucketsToPairs(preparedBuckets.rawHashBuckets, pairs, "rawHash", maxBucketSize, pairFilter, unitFilter);
-  oversizedBuckets += addBucketsToPairs(preparedBuckets.normalizedHashBuckets, pairs, "normalizedHash", maxBucketSize, pairFilter, unitFilter);
-  oversizedBuckets += addBucketsToPairs(preparedBuckets.astShapeBuckets, pairs, "astShape", maxBucketSize, pairFilter, unitFilter);
-  oversizedBuckets += addSimilarityHintPairs(preparedBuckets.units, pairs, similarityHints, projectRoot, maxBucketSize, pairFilter);
-  oversizedBuckets += addSignatureBucketsToPairs(preparedBuckets.signatureBuckets, pairs, consideredSignaturesByUnit, maxBucketSize, pairFilter, unitFilter);
-  for (const [key, evidence] of pairs) {
-    if (hasEnoughSharedFingerprints(evidence, consideredSignaturesByUnit)) {
-      evidence.signature = true;
-      continue;
-    }
-    if (!evidence.rawHash && !evidence.normalizedHash && !evidence.astShape && evidence.gitSimilarity === void 0) {
-      pairs.delete(key);
-    }
-  }
-  return { pairs, oversizedBuckets };
-}
-function buildCandidatePairs(units, maxBucketSize, similarityHints, projectRoot, pairFilter, unitFilter) {
-  return buildCandidatePairsFromPreparedBuckets(prepareDuplicateCandidateBuckets(units), maxBucketSize, similarityHints, projectRoot, pairFilter, unitFilter);
-}
-function addSimilarityHintPairs(units, pairs, similarityHints, projectRoot, maxBucketSize, pairFilter) {
-  if (!similarityHints?.length)
-    return 0;
-  const unitsByFile = /* @__PURE__ */ new Map();
-  for (const unit of units) {
-    const bucket = unitsByFile.get(unit.absoluteFile);
-    if (bucket) {
-      bucket.push(unit);
-    } else {
-      unitsByFile.set(unit.absoluteFile, [unit]);
-    }
-  }
-  let oversizedHints = 0;
-  for (const hint of similarityHints) {
-    const similarityIndex = normalizeSimilarityIndex(hint.similarityIndex);
-    if (similarityIndex === void 0)
-      continue;
-    const leftFile = normalizeSimilarityHintFile(hint.leftFile, projectRoot);
-    const rightFile = normalizeSimilarityHintFile(hint.rightFile, projectRoot);
-    if (!leftFile || !rightFile || leftFile === rightFile)
-      continue;
-    const leftUnits = unitsByFile.get(leftFile);
-    const rightUnits = unitsByFile.get(rightFile);
-    if (!leftUnits?.length || !rightUnits?.length)
-      continue;
-    if (similarityHintPairCountExceeds(leftUnits, rightUnits, maxBucketSize, pairFilter)) {
-      oversizedHints++;
-      addAlignedSimilarityHintPairs(pairs, leftUnits, rightUnits, similarityIndex, maxBucketSize, pairFilter);
-      continue;
-    }
-    for (const leftUnit of leftUnits) {
-      for (const rightUnit of rightUnits) {
-        if (leftUnit.languageId !== rightUnit.languageId)
-          continue;
-        const [left, right] = orderedPair(leftUnit, rightUnit);
-        if (pairFilter && !pairFilter(left, right))
-          continue;
-        addSimilarityHintPair(pairs, left, right, similarityIndex);
-      }
-    }
-  }
-  return oversizedHints;
-}
-function similarityHintPairCountExceeds(leftUnits, rightUnits, limit, pairFilter) {
-  let count = 0;
-  for (const leftUnit of leftUnits) {
-    for (const rightUnit of rightUnits) {
-      if (leftUnit.languageId !== rightUnit.languageId)
-        continue;
-      const [left, right] = orderedPair(leftUnit, rightUnit);
-      if (pairFilter && !pairFilter(left, right))
-        continue;
-      count++;
-      if (count > limit)
-        return true;
-    }
-  }
-  return false;
-}
-function similarityAlignmentKey(unit) {
-  return [unit.languageId, unit.kind, unit.symbolKind ?? ""].join(":");
-}
-function addAlignedSimilarityHintPairs(pairs, leftUnits, rightUnits, similarityIndex, maxPairs, pairFilter) {
-  const rightByKey = /* @__PURE__ */ new Map();
-  for (const unit of rightUnits) {
-    const key = similarityAlignmentKey(unit);
-    const bucket = rightByKey.get(key);
-    if (bucket)
-      bucket.push(unit);
-    else
-      rightByKey.set(key, [unit]);
-  }
-  for (const bucket of rightByKey.values()) {
-    bucket.sort(compareUnitRefs);
-  }
-  const leftByKey = /* @__PURE__ */ new Map();
-  for (const unit of leftUnits) {
-    const key = similarityAlignmentKey(unit);
-    const bucket = leftByKey.get(key);
-    if (bucket)
-      bucket.push(unit);
-    else
-      leftByKey.set(key, [unit]);
-  }
-  for (const bucket of leftByKey.values()) {
-    bucket.sort(compareUnitRefs);
-  }
-  const seenPairs = /* @__PURE__ */ new Set();
-  let addedPairs = 0;
-  for (const [key, sortedLeftUnits] of Array.from(leftByKey.entries()).sort(([left], [right]) => left.localeCompare(right))) {
-    const sortedRightUnits = rightByKey.get(key);
-    if (!sortedRightUnits?.length)
-      continue;
-    const limit = Math.min(sortedLeftUnits.length, sortedRightUnits.length);
-    for (let index = 0; index < limit; index++) {
-      if (addedPairs >= maxPairs)
-        return;
-      const [left, right] = orderedPair(sortedLeftUnits[index], sortedRightUnits[index]);
-      const pairId = pairKey(left, right);
-      if (seenPairs.has(pairId))
-        continue;
-      seenPairs.add(pairId);
-      if (pairFilter && !pairFilter(left, right))
-        continue;
-      addSimilarityHintPair(pairs, left, right, similarityIndex);
-      addedPairs++;
-    }
-  }
-}
-function normalizeSimilarityHintFile(file2, projectRoot) {
-  try {
-    return normalizeDetectionFile(file2, projectRoot);
-  } catch {
-    return void 0;
-  }
-}
-function addSimilarityHintPair(pairs, left, right, similarityIndex) {
-  const key = pairKey(left, right);
-  const existing = pairs.get(key);
-  if (existing) {
-    existing.gitSimilarity = Math.max(existing.gitSimilarity ?? 0, similarityIndex);
-    return;
-  }
-  pairs.set(key, {
-    left,
-    right,
-    rawHash: false,
-    normalizedHash: false,
-    astShape: false,
-    gitSimilarity: similarityIndex,
-    signature: false,
-    signatureMatches: 0
-  });
-}
-function hasEnoughSharedFingerprintsFor(signatureMatches, leftUnitId, rightUnitId, consideredSignaturesByUnit) {
-  if (!signatureMatches)
-    return false;
-  const leftConsideredSignatures = consideredSignaturesByUnit.get(leftUnitId)?.size ?? 0;
-  const rightConsideredSignatures = consideredSignaturesByUnit.get(rightUnitId)?.size ?? 0;
-  const smallerConsideredSignatureCount = Math.min(leftConsideredSignatures, rightConsideredSignatures);
-  if (!smallerConsideredSignatureCount)
-    return false;
-  const minimumShared = Math.max(2, Math.ceil(smallerConsideredSignatureCount * 0.25));
-  return signatureMatches >= minimumShared;
-}
-function hasEnoughSharedFingerprints(evidence, consideredSignaturesByUnit) {
-  return hasEnoughSharedFingerprintsFor(evidence.signatureMatches, evidence.left.id, evidence.right.id, consideredSignaturesByUnit);
-}
 function suggestionForPair(evidence) {
   const metrics = metricsForPair(evidence);
   const { score, reasons } = scorePair(evidence, metrics);
@@ -70661,13 +70373,22 @@ function enrichDuplicateGroups(groups) {
       continue;
     appendToArrayMap(groupIdsByComponentId, componentId, group.id);
   }
+  const clusterByComponentId = /* @__PURE__ */ new Map();
   return groups.map((group) => {
     const localLocations = locationsByGroupId.get(group.id) ?? groupLocations(group);
     const primaryKey = unitRefRangeIdentity(group.primaryLeft);
     const componentLocations = componentByKey.get(primaryKey) ?? localLocations;
     const componentId = componentIdByKey.get(primaryKey);
-    const groupIds = componentId ? Array.from(new Set(groupIdsByComponentId.get(componentId) ?? [group.id])).sort() : [group.id];
-    const cluster = groupClusterSummary(componentLocations, groupIds, coveredPairs);
+    let cluster;
+    if (!componentId) {
+      cluster = groupClusterSummary(componentLocations, [group.id], coveredPairs);
+    } else if (clusterByComponentId.has(componentId)) {
+      cluster = clusterByComponentId.get(componentId);
+    } else {
+      const groupIds = Array.from(new Set(groupIdsByComponentId.get(componentId) ?? [group.id])).sort();
+      cluster = groupClusterSummary(componentLocations, groupIds, coveredPairs);
+      clusterByComponentId.set(componentId, cluster);
+    }
     const cleanupLabels = cleanupLabelsForGroup(group, localLocations);
     if (!cleanupLabels.includes("test-helper-extraction") && cluster) {
       if (cluster.files.length && cluster.files.every(isTestFile) && cluster.locationCount >= 3) {
@@ -70833,7 +70554,7 @@ function groupSuggestions(suggestions, includeRawPairs) {
   const groups = Array.from(suggestionsByGroup, ([key, value]) => groupForSuggestions(key, value.suggestions, value.left, value.right, variantLimit));
   return enrichDuplicateGroups(coalesceDuplicateGroups(groups, variantLimit));
 }
-var DEFAULT_MIN_TOKENS, DEFAULT_MAX_TOKENS, DEFAULT_LIMIT, DEFAULT_MAX_BUCKET_SIZE, DEFAULT_GROUP_VARIANT_LIMIT, DEFAULT_SHINGLE_SIZE, DEFAULT_WINDOW_SIZE, GROUP_PRIMARY_LENGTH_RATIO_FLOOR, NEARBY_CHUNK_VARIANT_MAX_GAP, MIN_SIMILARITY_HINT_INDEX, confidenceRank, cloneTypeRank;
+var DEFAULT_MIN_TOKENS, DEFAULT_MAX_TOKENS, DEFAULT_LIMIT, DEFAULT_MAX_BUCKET_SIZE, DEFAULT_MAX_CANDIDATE_PAIRS, MAX_CANDIDATE_PAIRS_LIMIT, DEFAULT_GROUP_VARIANT_LIMIT, DEFAULT_SHINGLE_SIZE, DEFAULT_WINDOW_SIZE, GROUP_PRIMARY_LENGTH_RATIO_FLOOR, NEARBY_CHUNK_VARIANT_MAX_GAP, confidenceRank, cloneTypeRank;
 var init_scoring = __esm({
   "dist/duplicates/scoring.js"() {
     "use strict";
@@ -70843,12 +70564,13 @@ var init_scoring = __esm({
     DEFAULT_MAX_TOKENS = 800;
     DEFAULT_LIMIT = 50;
     DEFAULT_MAX_BUCKET_SIZE = 200;
+    DEFAULT_MAX_CANDIDATE_PAIRS = 2e6;
+    MAX_CANDIDATE_PAIRS_LIMIT = 16e6;
     DEFAULT_GROUP_VARIANT_LIMIT = 5;
     DEFAULT_SHINGLE_SIZE = 5;
     DEFAULT_WINDOW_SIZE = 4;
     GROUP_PRIMARY_LENGTH_RATIO_FLOOR = 0.7;
     NEARBY_CHUNK_VARIANT_MAX_GAP = 2;
-    MIN_SIMILARITY_HINT_INDEX = 80;
     confidenceRank = {
       low: 1,
       medium: 2,
@@ -70863,6 +70585,827 @@ var init_scoring = __esm({
   }
 });
 
+// dist/duplicates/candidates.js
+var candidates_exports = {};
+__export(candidates_exports, {
+  buildCandidatePairs: () => buildCandidatePairs,
+  filterPreparedDuplicateBuckets: () => filterPreparedDuplicateBuckets,
+  orderedPair: () => orderedPair,
+  prepareDuplicateCandidateBuckets: () => prepareDuplicateCandidateBuckets
+});
+function prepareDuplicateCandidateBuckets(units) {
+  const rawHashBuckets = /* @__PURE__ */ new Map();
+  const normalizedHashBuckets = /* @__PURE__ */ new Map();
+  const astShapeBuckets = /* @__PURE__ */ new Map();
+  const signatureBuckets = /* @__PURE__ */ new Map();
+  for (const unit of units) {
+    const languagePrefix = `${unit.languageId}:`;
+    appendToArrayMap(rawHashBuckets, `${languagePrefix}${unit.rawHash}`, unit);
+    appendToArrayMap(normalizedHashBuckets, `${languagePrefix}${unit.normalizedHash}`, unit);
+    if (unit.astShapeHash !== void 0) {
+      appendToArrayMap(astShapeBuckets, `${languagePrefix}${unit.astShapeHash}`, unit);
+    }
+    for (const signature of unit.signatures) {
+      appendToArrayMap(signatureBuckets, `${languagePrefix}${signature}`, unit);
+    }
+  }
+  return {
+    units,
+    rawHashBuckets,
+    normalizedHashBuckets,
+    astShapeBuckets,
+    signatureBuckets
+  };
+}
+function filterPreparedDuplicateBucketMap(buckets, unitFilter) {
+  const filteredBuckets = /* @__PURE__ */ new Map();
+  for (const [key, bucket] of buckets) {
+    const filteredBucket = bucket.filter(unitFilter);
+    if (filteredBucket.length)
+      filteredBuckets.set(key, filteredBucket);
+  }
+  return filteredBuckets;
+}
+function filterPreparedDuplicateBuckets(preparedBuckets, unitFilter) {
+  return {
+    units: preparedBuckets.units.filter(unitFilter),
+    rawHashBuckets: filterPreparedDuplicateBucketMap(preparedBuckets.rawHashBuckets, unitFilter),
+    normalizedHashBuckets: filterPreparedDuplicateBucketMap(preparedBuckets.normalizedHashBuckets, unitFilter),
+    astShapeBuckets: filterPreparedDuplicateBucketMap(preparedBuckets.astShapeBuckets, unitFilter),
+    signatureBuckets: filterPreparedDuplicateBucketMap(preparedBuckets.signatureBuckets, unitFilter)
+  };
+}
+function createUnitIndex(units) {
+  const positions = /* @__PURE__ */ new Map();
+  const firstById = /* @__PURE__ */ new Map();
+  const canon = new Int32Array(units.length);
+  let hasSharedIds = false;
+  for (let position = 0; position < units.length; position++) {
+    const unit = units[position];
+    positions.set(unit, position);
+    const first = firstById.get(unit.id);
+    if (first === void 0) {
+      firstById.set(unit.id, position);
+      canon[position] = position;
+    } else {
+      canon[position] = first;
+      hasSharedIds = true;
+    }
+  }
+  return { units, positions, canon, hasSharedIds };
+}
+function positionOf(index, unit) {
+  const position = index.positions.get(unit);
+  if (position === void 0)
+    throw new Error(`Duplicate unit ${unit.id} is not part of the prepared candidates.`);
+  return position;
+}
+function canonOf(index, unit) {
+  return index.canon[positionOf(index, unit)];
+}
+function pairNumber(index, left, right) {
+  const radix = index.units.length;
+  return left <= right ? left * radix + right : right * radix + left;
+}
+function orderedPair(left, right) {
+  if (left.absoluteFile < right.absoluteFile)
+    return [left, right];
+  if (left.absoluteFile > right.absoluteFile)
+    return [right, left];
+  if (left.startLine <= right.startLine)
+    return [left, right];
+  return [right, left];
+}
+function blankEvidence(left, right) {
+  return { left, right, rawHash: false, normalizedHash: false, astShape: false, signature: false, signatureMatches: 0 };
+}
+function tallyUnscorable(state, key) {
+  if (state.unscorable.size < state.limit)
+    state.unscorable.add(key);
+}
+function takePair(state, key, first, second) {
+  const existing = state.pairs.get(key);
+  if (existing)
+    return existing;
+  if (!isScorablePair(first, second, state.crossFileOnly)) {
+    tallyUnscorable(state, key);
+    return void 0;
+  }
+  if (state.pairs.size >= state.limit) {
+    state.skipped++;
+    return void 0;
+  }
+  const [left, right] = orderedPair(first, second);
+  const evidence = blankEvidence(left, right);
+  state.pairs.set(key, evidence);
+  return evidence;
+}
+function addStrongEvidence(state, kind, first, second, key) {
+  const evidence = takePair(state, key, first, second);
+  if (evidence)
+    evidence[kind] = true;
+}
+function forEachFilteredBucketPair(index, bucket, filter, visit2) {
+  const targetUnits = bucket.filter(filter.unit);
+  const seenPairs = /* @__PURE__ */ new Set();
+  for (const targetUnit of targetUnits) {
+    const targetCanon = canonOf(index, targetUnit);
+    for (const otherUnit of bucket) {
+      if (targetUnit.id === otherUnit.id)
+        continue;
+      const [left, right] = orderedPair(targetUnit, otherUnit);
+      const key = pairNumber(index, targetCanon, canonOf(index, otherUnit));
+      if (seenPairs.has(key))
+        continue;
+      seenPairs.add(key);
+      if (!filter.pair(left, right))
+        continue;
+      visit2(left, right, key);
+    }
+  }
+}
+function filteredPairCountExceeds(index, bucket, limit, filter) {
+  let count = 0;
+  const targetUnits = bucket.filter(filter.unit);
+  if (!targetUnits.length)
+    return false;
+  const seenPairs = /* @__PURE__ */ new Set();
+  for (const targetUnit of targetUnits) {
+    const targetCanon = canonOf(index, targetUnit);
+    for (const otherUnit of bucket) {
+      if (targetUnit.id === otherUnit.id)
+        continue;
+      const [left, right] = orderedPair(targetUnit, otherUnit);
+      const key = pairNumber(index, targetCanon, canonOf(index, otherUnit));
+      if (seenPairs.has(key))
+        continue;
+      seenPairs.add(key);
+      if (!filter.pair(left, right))
+        continue;
+      count++;
+      if (count > limit)
+        return true;
+    }
+  }
+  return false;
+}
+function classifyBucket(index, bucket, maxBucketSize, filter) {
+  if (bucket.length < 2)
+    return "skip";
+  if (filter && !bucket.some(filter.unit))
+    return "skip";
+  if (bucket.length > maxBucketSize) {
+    if (!filter || filteredPairCountExceeds(index, bucket, maxBucketSize, filter))
+      return "oversized";
+  }
+  return "pair";
+}
+function addBucketPairs(state, bucket, kind, filter) {
+  const { index } = state;
+  if (filter) {
+    forEachFilteredBucketPair(index, bucket, filter, (left, right, key) => {
+      addStrongEvidence(state, kind, left, right, key);
+    });
+    return;
+  }
+  const canons = new Int32Array(bucket.length);
+  for (let i = 0; i < bucket.length; i++)
+    canons[i] = canonOf(index, bucket[i]);
+  for (let i = 0; i < bucket.length; i++) {
+    for (let j = i + 1; j < bucket.length; j++) {
+      addStrongEvidence(state, kind, bucket[i], bucket[j], pairNumber(index, canons[i], canons[j]));
+    }
+  }
+}
+async function addEvidenceBuckets(state, buckets, kind, options) {
+  let oversizedBuckets = 0;
+  for (const bucket of buckets.values()) {
+    const verdict = classifyBucket(state.index, bucket, options.maxBucketSize, options.filter);
+    if (verdict === "skip")
+      continue;
+    if (verdict === "oversized") {
+      oversizedBuckets++;
+      continue;
+    }
+    addBucketPairs(state, bucket, kind, options.filter);
+    const pending = options.yieldPoint?.();
+    if (pending)
+      await pending;
+  }
+  return oversizedBuckets;
+}
+function hasEnoughFingerprints(sharedFingerprints, smallerConsideredCount) {
+  if (!sharedFingerprints || !smallerConsideredCount)
+    return false;
+  return sharedFingerprints >= Math.max(2, Math.ceil(smallerConsideredCount * 0.25));
+}
+function eligibleFingerprintBuckets(state, buckets, options) {
+  const eligible = [];
+  let oversizedBuckets = 0;
+  for (const bucket of buckets.values()) {
+    const verdict = classifyBucket(state.index, bucket, options.maxBucketSize, options.filter);
+    if (verdict === "skip")
+      continue;
+    if (verdict === "oversized") {
+      oversizedBuckets++;
+      continue;
+    }
+    eligible.push(bucket);
+  }
+  return { eligible, oversizedBuckets };
+}
+function layoutFingerprintBuckets(index, eligible) {
+  const unitCount = index.units.length;
+  const bucketCount = eligible.length;
+  const bucketStart = new Int32Array(bucketCount + 1);
+  const rankBase = new Float64Array(bucketCount);
+  let total = 0;
+  let rank = 0;
+  for (let bucket = 0; bucket < bucketCount; bucket++) {
+    const size = eligible[bucket].length;
+    bucketStart[bucket] = total;
+    rankBase[bucket] = rank;
+    total += size;
+    rank += size * size;
+  }
+  bucketStart[bucketCount] = total;
+  const memberUnit = new Int32Array(total);
+  const memberCanon = new Int32Array(total);
+  const entryStart = new Int32Array(unitCount + 1);
+  const consideredCount = new Int32Array(unitCount);
+  const lastBucket = new Int32Array(unitCount).fill(-1);
+  for (let bucket = 0, member = 0; bucket < bucketCount; bucket++) {
+    for (const unit of eligible[bucket]) {
+      const position = positionOf(index, unit);
+      const unitCanon = index.canon[position];
+      memberUnit[member] = position;
+      memberCanon[member] = unitCanon;
+      member++;
+      entryStart[unitCanon + 1] = entryStart[unitCanon + 1] + 1;
+      if (lastBucket[unitCanon] !== bucket) {
+        lastBucket[unitCanon] = bucket;
+        consideredCount[unitCanon] = consideredCount[unitCanon] + 1;
+      }
+    }
+  }
+  for (let unit = 0; unit < unitCount; unit++)
+    entryStart[unit + 1] = entryStart[unit + 1] + entryStart[unit];
+  const entryMember = new Int32Array(total);
+  const entryBucket = new Int32Array(total);
+  const nextEntry = entryStart.slice(0, unitCount);
+  for (let bucket = 0; bucket < bucketCount; bucket++) {
+    for (let member = bucketStart[bucket]; member < bucketStart[bucket + 1]; member++) {
+      const unitCanon = memberCanon[member];
+      const slot = nextEntry[unitCanon];
+      nextEntry[unitCanon] = slot + 1;
+      entryMember[slot] = member;
+      entryBucket[slot] = bucket;
+    }
+  }
+  return { bucketStart, rankBase, memberUnit, memberCanon, entryStart, entryMember, entryBucket, consideredCount };
+}
+function wholeProjectVisit(layout, units, first, second) {
+  const { bucketStart, rankBase, memberUnit, entryStart, entryMember, entryBucket } = layout;
+  const visits = [];
+  let a = entryStart[first];
+  const aEnd = entryStart[first + 1];
+  let b = entryStart[second];
+  const bEnd = entryStart[second + 1];
+  while (a < aEnd && b < bEnd && visits.length < 2) {
+    const bucketA = entryBucket[a];
+    const bucketB = entryBucket[b];
+    if (bucketA < bucketB) {
+      a++;
+      continue;
+    }
+    if (bucketB < bucketA) {
+      b++;
+      continue;
+    }
+    let aNext = a;
+    while (aNext < aEnd && entryBucket[aNext] === bucketA)
+      aNext++;
+    let bNext = b;
+    while (bNext < bEnd && entryBucket[bNext] === bucketA)
+      bNext++;
+    const start = bucketStart[bucketA];
+    const size = bucketStart[bucketA + 1] - start;
+    for (let x = a; x < aNext; x++) {
+      for (let y = b; y < bNext; y++) {
+        if (first === second && y <= x)
+          continue;
+        const low = Math.min(entryMember[x], entryMember[y]);
+        const high = Math.max(entryMember[x], entryMember[y]);
+        visits.push({ rank: rankBase[bucketA] + (low - start) * size + (high - start), low, high });
+      }
+    }
+    a = aNext;
+    b = bNext;
+  }
+  visits.sort((left2, right2) => left2.rank - right2.rank);
+  const firstVisit = visits[0];
+  const secondVisit = visits[1];
+  const [left, right] = orderedPair(units[memberUnit[secondVisit.low]], units[memberUnit[secondVisit.high]]);
+  return { rank: firstVisit.rank, left, right };
+}
+async function addProjectFingerprintPairs(state, layout, options) {
+  const { index } = state;
+  const unitCount = index.units.length;
+  const { bucketStart, memberUnit, memberCanon, entryStart, entryMember, entryBucket } = layout;
+  const selection = new FingerprintSelection(state, layout, void 0);
+  const sharedBuckets = new Int32Array(unitCount);
+  const touched = new Int32Array(unitCount);
+  const sharesIds = index.hasSharedIds;
+  const reportEvery = Math.max(1, Math.floor(unitCount / 100));
+  for (let unit = 0; unit < unitCount; unit++) {
+    const firstEntry = entryStart[unit];
+    const lastEntry = entryStart[unit + 1];
+    let touchedCount = 0;
+    const lowestPartner = sharesIds ? unit : 0;
+    for (let slot = firstEntry; slot < lastEntry; slot++) {
+      const member = entryMember[slot];
+      const bucket = entryBucket[slot];
+      const bucketEnd = bucketStart[bucket + 1];
+      for (let other = member + 1; other < bucketEnd; other++) {
+        const partner = memberCanon[other];
+        if (partner < lowestPartner)
+          continue;
+        const shared = sharedBuckets[partner];
+        if (!shared)
+          touched[touchedCount++] = partner;
+        sharedBuckets[partner] = shared + 1;
+      }
+      if (sharesIds && memberUnit[member] !== unit) {
+        for (let other = bucketStart[bucket]; other < member; other++) {
+          const partner = memberCanon[other];
+          if (partner <= unit)
+            continue;
+          const shared = sharedBuckets[partner];
+          if (!shared)
+            touched[touchedCount++] = partner;
+          sharedBuckets[partner] = shared + 1;
+        }
+      }
+    }
+    for (let at = 0; at < touchedCount; at++) {
+      const partner = touched[at];
+      const count = sharedBuckets[partner];
+      sharedBuckets[partner] = 0;
+      selection.consider(unit, partner, count);
+    }
+    if (unit % reportEvery === 0)
+      options.onFingerprintProgress?.(unit + 1, unitCount);
+    const pending = options.yieldPoint?.();
+    if (pending)
+      await pending;
+  }
+  options.onFingerprintProgress?.(unitCount, unitCount);
+  selection.admit((first, second) => wholeProjectVisit(layout, index.units, first, second));
+}
+function targetedVisit(layout, units, targets, first, second) {
+  const { bucketStart, rankBase, memberUnit, entryStart, entryMember, entryBucket } = layout;
+  let a = entryStart[first];
+  const aEnd = entryStart[first + 1];
+  let b = entryStart[second];
+  const bEnd = entryStart[second + 1];
+  const firstIsTarget = targets.isTarget[first] === 1;
+  const secondIsTarget = targets.isTarget[second] === 1;
+  let firstRank = -1;
+  while (a < aEnd && b < bEnd) {
+    const bucket = entryBucket[a];
+    if (bucket < entryBucket[b]) {
+      a++;
+      continue;
+    }
+    if (entryBucket[b] < bucket) {
+      b++;
+      continue;
+    }
+    const slotA = entryMember[a];
+    const slotB = entryMember[b];
+    const walkedFromA = firstIsTarget && (!secondIsTarget || slotA < slotB);
+    const targetSlot = walkedFromA ? slotA : slotB;
+    const otherSlot = walkedFromA ? slotB : slotA;
+    if (firstRank < 0) {
+      const start = bucketStart[bucket];
+      const size = bucketStart[bucket + 1] - start;
+      firstRank = rankBase[bucket] + targets.before[targetSlot] * size + (otherSlot - start);
+    } else {
+      const [left, right] = orderedPair(units[memberUnit[targetSlot]], units[memberUnit[otherSlot]]);
+      return { rank: firstRank, left, right };
+    }
+    while (a < aEnd && entryBucket[a] === bucket)
+      a++;
+    while (b < bEnd && entryBucket[b] === bucket)
+      b++;
+  }
+  throw new Error("A candidate pair from shared fingerprints shares fewer than two buckets.");
+}
+function addTargetedFingerprintPairs(state, layout, filter) {
+  const { index } = state;
+  const unitCount = index.units.length;
+  const { bucketStart, memberCanon, entryStart, entryBucket } = layout;
+  const bucketCount = bucketStart.length - 1;
+  const isTarget = new Uint8Array(unitCount);
+  for (let unit = 0; unit < unitCount; unit++) {
+    if (entryStart[unit + 1] > entryStart[unit] && filter.unit(index.units[unit]))
+      isTarget[unit] = 1;
+  }
+  const before = new Int32Array(memberCanon.length);
+  for (let bucket = 0; bucket < bucketCount; bucket++) {
+    let targetsSoFar = 0;
+    for (let member = bucketStart[bucket]; member < bucketStart[bucket + 1]; member++) {
+      before[member] = targetsSoFar;
+      targetsSoFar += isTarget[memberCanon[member]];
+    }
+  }
+  const selection = new FingerprintSelection(state, layout, filter.pair);
+  const sharedBuckets = new Int32Array(unitCount);
+  const touched = new Int32Array(unitCount);
+  const countedIn = index.hasSharedIds ? new Int32Array(unitCount) : void 0;
+  let walk = 0;
+  for (let target = 0; target < unitCount; target++) {
+    if (!isTarget[target])
+      continue;
+    let touchedCount = 0;
+    let previousBucket = -1;
+    for (let slot = entryStart[target]; slot < entryStart[target + 1]; slot++) {
+      const bucket = entryBucket[slot];
+      if (bucket === previousBucket)
+        continue;
+      previousBucket = bucket;
+      walk++;
+      for (let member = bucketStart[bucket]; member < bucketStart[bucket + 1]; member++) {
+        const partner = memberCanon[member];
+        if (partner === target || partner < target && isTarget[partner])
+          continue;
+        if (countedIn) {
+          if (countedIn[partner] === walk)
+            continue;
+          countedIn[partner] = walk;
+        }
+        const shared = sharedBuckets[partner];
+        if (!shared)
+          touched[touchedCount++] = partner;
+        sharedBuckets[partner] = shared + 1;
+      }
+    }
+    for (let at = 0; at < touchedCount; at++) {
+      const partner = touched[at];
+      const count = sharedBuckets[partner];
+      sharedBuckets[partner] = 0;
+      selection.consider(target, partner, count);
+    }
+  }
+  selection.admit((first, second) => targetedVisit(layout, index.units, { isTarget, before }, first, second));
+}
+function normalizeSimilarityIndex(value) {
+  if (!Number.isFinite(value))
+    return void 0;
+  const bounded = Math.max(0, Math.min(100, Math.round(value)));
+  if (bounded < MIN_SIMILARITY_HINT_INDEX)
+    return void 0;
+  return bounded;
+}
+function normalizeSimilarityHintFile(file2, projectRoot) {
+  try {
+    return normalizeDetectionFile(file2, projectRoot);
+  } catch {
+    return void 0;
+  }
+}
+function addSimilarityHintPair(state, left, right, similarityIndex) {
+  const key = pairNumber(state.index, canonOf(state.index, left), canonOf(state.index, right));
+  const evidence = takePair(state, key, left, right);
+  if (evidence)
+    evidence.gitSimilarity = Math.max(evidence.gitSimilarity ?? 0, similarityIndex);
+}
+function similarityHintPairCountExceeds(leftUnits, rightUnits, limit, pairFilter) {
+  let count = 0;
+  for (const leftUnit of leftUnits) {
+    for (const rightUnit of rightUnits) {
+      if (leftUnit.languageId !== rightUnit.languageId)
+        continue;
+      const [left, right] = orderedPair(leftUnit, rightUnit);
+      if (pairFilter && !pairFilter(left, right))
+        continue;
+      count++;
+      if (count > limit)
+        return true;
+    }
+  }
+  return false;
+}
+function similarityAlignmentKey(unit) {
+  return [unit.languageId, unit.kind, unit.symbolKind ?? ""].join(":");
+}
+function addAlignedSimilarityHintPairs(state, leftUnits, rightUnits, similarityIndex, maxPairs, pairFilter) {
+  const rightByKey = /* @__PURE__ */ new Map();
+  for (const unit of rightUnits) {
+    const key = similarityAlignmentKey(unit);
+    const bucket = rightByKey.get(key);
+    if (bucket)
+      bucket.push(unit);
+    else
+      rightByKey.set(key, [unit]);
+  }
+  for (const bucket of rightByKey.values()) {
+    bucket.sort(compareUnitRefs);
+  }
+  const leftByKey = /* @__PURE__ */ new Map();
+  for (const unit of leftUnits) {
+    const key = similarityAlignmentKey(unit);
+    const bucket = leftByKey.get(key);
+    if (bucket)
+      bucket.push(unit);
+    else
+      leftByKey.set(key, [unit]);
+  }
+  for (const bucket of leftByKey.values()) {
+    bucket.sort(compareUnitRefs);
+  }
+  const seenPairs = /* @__PURE__ */ new Set();
+  let addedPairs = 0;
+  for (const [key, sortedLeftUnits] of Array.from(leftByKey.entries()).sort(([left], [right]) => left.localeCompare(right))) {
+    const sortedRightUnits = rightByKey.get(key);
+    if (!sortedRightUnits?.length)
+      continue;
+    const limit = Math.min(sortedLeftUnits.length, sortedRightUnits.length);
+    for (let index = 0; index < limit; index++) {
+      if (addedPairs >= maxPairs)
+        return;
+      const [left, right] = orderedPair(sortedLeftUnits[index], sortedRightUnits[index]);
+      const pairId = pairNumber(state.index, canonOf(state.index, left), canonOf(state.index, right));
+      if (seenPairs.has(pairId))
+        continue;
+      seenPairs.add(pairId);
+      if (pairFilter && !pairFilter(left, right))
+        continue;
+      addSimilarityHintPair(state, left, right, similarityIndex);
+      addedPairs++;
+    }
+  }
+}
+function addSimilarityHintPairs(state, similarityHints, projectRoot, maxBucketSize, pairFilter) {
+  if (!similarityHints?.length)
+    return 0;
+  const unitsByFile = /* @__PURE__ */ new Map();
+  for (const unit of state.index.units) {
+    const bucket = unitsByFile.get(unit.absoluteFile);
+    if (bucket) {
+      bucket.push(unit);
+    } else {
+      unitsByFile.set(unit.absoluteFile, [unit]);
+    }
+  }
+  let oversizedHints = 0;
+  for (const hint of similarityHints) {
+    const similarityIndex = normalizeSimilarityIndex(hint.similarityIndex);
+    if (similarityIndex === void 0)
+      continue;
+    const leftFile = normalizeSimilarityHintFile(hint.leftFile, projectRoot);
+    const rightFile = normalizeSimilarityHintFile(hint.rightFile, projectRoot);
+    if (!leftFile || !rightFile || leftFile === rightFile)
+      continue;
+    const leftUnits = unitsByFile.get(leftFile);
+    const rightUnits = unitsByFile.get(rightFile);
+    if (!leftUnits?.length || !rightUnits?.length)
+      continue;
+    if (similarityHintPairCountExceeds(leftUnits, rightUnits, maxBucketSize, pairFilter)) {
+      oversizedHints++;
+      addAlignedSimilarityHintPairs(state, leftUnits, rightUnits, similarityIndex, maxBucketSize, pairFilter);
+      continue;
+    }
+    for (const leftUnit of leftUnits) {
+      for (const rightUnit of rightUnits) {
+        if (leftUnit.languageId !== rightUnit.languageId)
+          continue;
+        const [left, right] = orderedPair(leftUnit, rightUnit);
+        if (pairFilter && !pairFilter(left, right))
+          continue;
+        addSimilarityHintPair(state, left, right, similarityIndex);
+      }
+    }
+  }
+  return oversizedHints;
+}
+async function buildCandidatePairs(preparedBuckets, options) {
+  const state = {
+    index: createUnitIndex(preparedBuckets.units),
+    crossFileOnly: options.crossFileOnly,
+    pairs: /* @__PURE__ */ new Map(),
+    unscorable: /* @__PURE__ */ new Set(),
+    limit: options.maxCandidatePairs,
+    skipped: 0
+  };
+  let oversizedBuckets = 0;
+  oversizedBuckets += await addEvidenceBuckets(state, preparedBuckets.rawHashBuckets, "rawHash", options);
+  oversizedBuckets += await addEvidenceBuckets(state, preparedBuckets.normalizedHashBuckets, "normalizedHash", options);
+  oversizedBuckets += await addEvidenceBuckets(state, preparedBuckets.astShapeBuckets, "astShape", options);
+  oversizedBuckets += addSimilarityHintPairs(state, options.similarityHints, options.projectRoot, options.maxBucketSize, options.filter?.pair);
+  const fingerprints = eligibleFingerprintBuckets(state, preparedBuckets.signatureBuckets, options);
+  oversizedBuckets += fingerprints.oversizedBuckets;
+  const layout = layoutFingerprintBuckets(state.index, fingerprints.eligible);
+  if (options.filter) {
+    addTargetedFingerprintPairs(state, layout, options.filter);
+  } else {
+    await addProjectFingerprintPairs(state, layout, options);
+  }
+  return {
+    pairs: state.pairs,
+    oversizedBuckets,
+    skippedPairs: state.skipped,
+    unscorablePairs: state.unscorable.size,
+    overlappingPairs: state.crossFileOnly ? 0 : state.unscorable.size
+  };
+}
+var MIN_SIMILARITY_HINT_INDEX, BestPairs, FingerprintSelection;
+var init_candidates = __esm({
+  "dist/duplicates/candidates.js"() {
+    "use strict";
+    init_collections();
+    init_scoring();
+    init_units();
+    MIN_SIMILARITY_HINT_INDEX = 80;
+    BestPairs = class {
+      capacity;
+      size = 0;
+      priority;
+      first;
+      second;
+      matches;
+      constructor(capacity) {
+        this.capacity = capacity;
+        const initial = Math.min(capacity, 1024);
+        this.priority = new Float64Array(initial);
+        this.first = new Int32Array(initial);
+        this.second = new Int32Array(initial);
+        this.matches = new Int32Array(initial);
+      }
+      /** Better means more of the smaller unit's fingerprints shared, then the earlier unit ids. */
+      isWorse(a, b) {
+        if (this.priority[a] !== this.priority[b])
+          return this.priority[a] < this.priority[b];
+        if (this.first[a] !== this.first[b])
+          return this.first[a] > this.first[b];
+        return this.second[a] > this.second[b];
+      }
+      swap(a, b) {
+        const priority = this.priority[a];
+        this.priority[a] = this.priority[b];
+        this.priority[b] = priority;
+        const first = this.first[a];
+        this.first[a] = this.first[b];
+        this.first[b] = first;
+        const second = this.second[a];
+        this.second[a] = this.second[b];
+        this.second[b] = second;
+        const matches = this.matches[a];
+        this.matches[a] = this.matches[b];
+        this.matches[b] = matches;
+      }
+      grow() {
+        const next = Math.min(this.capacity, this.priority.length * 2);
+        const priority = new Float64Array(next);
+        priority.set(this.priority);
+        this.priority = priority;
+        for (const name of ["first", "second", "matches"]) {
+          const grown = new Int32Array(next);
+          grown.set(this[name]);
+          this[name] = grown;
+        }
+      }
+      siftUp(start) {
+        let slot = start;
+        while (slot > 0) {
+          const parent = slot - 1 >> 1;
+          if (!this.isWorse(slot, parent))
+            return;
+          this.swap(slot, parent);
+          slot = parent;
+        }
+      }
+      siftDown(start) {
+        let slot = start;
+        for (; ; ) {
+          const left = slot * 2 + 1;
+          const right = left + 1;
+          let worst = slot;
+          if (left < this.size && this.isWorse(left, worst))
+            worst = left;
+          if (right < this.size && this.isWorse(right, worst))
+            worst = right;
+          if (worst === slot)
+            return;
+          this.swap(slot, worst);
+          slot = worst;
+        }
+      }
+      /** Whether a pair ranks above the worst pair kept, by the same order `isWorse` uses. */
+      beatsWorst(priority, first, second) {
+        if (priority !== this.priority[0])
+          return priority > this.priority[0];
+        if (first !== this.first[0])
+          return first < this.first[0];
+        return second < this.second[0];
+      }
+      offer(priority, first, second, matches) {
+        if (!this.capacity)
+          return;
+        if (this.size === this.capacity) {
+          if (!this.beatsWorst(priority, first, second))
+            return;
+          this.priority[0] = priority;
+          this.first[0] = first;
+          this.second[0] = second;
+          this.matches[0] = matches;
+          this.siftDown(0);
+          return;
+        }
+        if (this.size === this.priority.length)
+          this.grow();
+        const slot = this.size++;
+        this.priority[slot] = priority;
+        this.first[slot] = first;
+        this.second[slot] = second;
+        this.matches[slot] = matches;
+        this.siftUp(slot);
+      }
+      entries() {
+        const entries = [];
+        for (let slot = 0; slot < this.size; slot++) {
+          entries.push({ first: this.first[slot], second: this.second[slot], matches: this.matches[slot] });
+        }
+        return entries;
+      }
+    };
+    FingerprintSelection = class {
+      state;
+      layout;
+      pairFilter;
+      best;
+      qualifying = 0;
+      constructor(state, layout, pairFilter) {
+        this.state = state;
+        this.layout = layout;
+        this.pairFilter = pairFilter;
+        this.best = new BestPairs(Math.max(0, state.limit - state.pairs.size));
+      }
+      /** Takes two canonical units that share `count` eligible buckets; fewer than two cannot qualify. */
+      consider(first, second, count) {
+        if (count < 2)
+          return;
+        const { index, pairs } = this.state;
+        const smaller = Math.min(this.layout.consideredCount[first], this.layout.consideredCount[second]);
+        if (!hasEnoughFingerprints(count, smaller))
+          return;
+        const firstUnit = index.units[first];
+        const secondUnit = index.units[second];
+        if (this.pairFilter) {
+          const [left, right] = orderedPair(firstUnit, secondUnit);
+          if (!this.pairFilter(left, right))
+            return;
+        }
+        const key = pairNumber(index, first, second);
+        const existing = pairs.get(key);
+        if (existing) {
+          existing.signatureMatches = count;
+          existing.signature = true;
+          return;
+        }
+        if (!isScorablePair(firstUnit, secondUnit, this.state.crossFileOnly)) {
+          tallyUnscorable(this.state, key);
+          return;
+        }
+        this.qualifying++;
+        this.best.offer(count / smaller, Math.min(first, second), Math.max(first, second), count);
+      }
+      /** Adds the kept pairs in the order a walk of the buckets would first have met them, and counts the rest skipped. */
+      admit(visitOf) {
+        const { index, pairs } = this.state;
+        const admissions = this.best.entries().map(({ first, second, matches }) => ({
+          ...visitOf(first, second),
+          key: pairNumber(index, first, second),
+          count: matches
+        }));
+        admissions.sort((left, right) => left.rank - right.rank);
+        for (const admission of admissions) {
+          pairs.set(admission.key, {
+            left: admission.left,
+            right: admission.right,
+            rawHash: false,
+            normalizedHash: false,
+            astShape: false,
+            signature: true,
+            signatureMatches: admission.count
+          });
+        }
+        this.state.skipped += this.qualifying - admissions.length;
+      }
+    };
+  }
+});
+
 // dist/duplicates.js
 async function findDuplicates(index, options = {}) {
   const releaseDuplicateUnitCache = leaseDuplicateUnitCacheForIndex2(index);
@@ -70874,15 +71417,14 @@ async function findDuplicates(index, options = {}) {
     releaseDuplicateUnitCache();
   }
 }
-async function findDuplicatesWithOpenDuplicateUnitCache(index, options = {}, preparedData) {
-  const collectionOptions = duplicateUnitCollectionOptions(index, options);
-  const projectRoot = collectionOptions.projectRoot;
-  const maxBucketSize = normalizePositiveIntegerOption2(options.maxBucketSize, "maxBucketSize", DEFAULT_MAX_BUCKET_SIZE2);
-  const maxPairs = options.maxPairs === void 0 ? Number.POSITIVE_INFINITY : normalizeNonNegativeIntegerOption2(options.maxPairs, "maxPairs", DEFAULT_LIMIT2);
-  const crossFileOnly = options.crossFileOnly ?? !(options.includeSameFile ?? false);
-  const minConfidence = normalizeConfidence2(options.minConfidence);
-  const limit = normalizeNonNegativeIntegerOption2(options.limit, "limit", DEFAULT_LIMIT2);
-  const collectedUnits = preparedData?.collectedUnits ?? await collectDuplicateUnits2(index, collectionOptions);
+function omittedCandidatePairs(uncomparedPairs, budget) {
+  return uncomparedPairs + (budget?.skipped ?? 0);
+}
+function foundCandidatePairs(keptPairs, unscorablePairs, maxCandidatePairs) {
+  return Math.min(maxCandidatePairs, keptPairs + unscorablePairs);
+}
+async function collectCandidatePairs(index, options, collectionOptions, preparedData, limits, progress) {
+  const collectedUnits = preparedData?.collectedUnits ?? await collectDuplicateUnits2(index, collectionOptions, progress);
   let units = collectedUnits.units;
   let belowThresholdUnits = collectedUnits.belowThresholdUnits;
   let candidateBuckets = preparedData?.preparedBuckets;
@@ -70896,13 +71438,44 @@ async function findDuplicatesWithOpenDuplicateUnitCache(index, options = {}, pre
       belowThresholdUnits += collectedUnits.belowThresholdUnitsByFile.get(file2) ?? 0;
     }
   }
-  const candidateResult = candidateBuckets ? buildCandidatePairsFromPreparedBuckets2(candidateBuckets, maxBucketSize, options.similarityHints, projectRoot) : buildCandidatePairs2(units, maxBucketSize, options.similarityHints, projectRoot);
-  const { pairs, oversizedBuckets } = candidateResult;
+  progress?.stage(DUPLICATE_STAGE_PAIRS);
+  const { pairs, oversizedBuckets, skippedPairs, unscorablePairs, overlappingPairs } = await buildCandidatePairs2(candidateBuckets ?? prepareDuplicateCandidateBuckets2(units), {
+    ...limits,
+    similarityHints: options.similarityHints,
+    projectRoot: collectionOptions.projectRoot,
+    onFingerprintProgress: progress ? (current, total) => progress.stage(DUPLICATE_STAGE_PAIRS, current, total, "unit") : void 0,
+    yieldPoint: progress?.yieldPoint
+  });
+  return {
+    unitCount: units.length,
+    belowThresholdUnits,
+    pairs,
+    oversizedBuckets,
+    skippedPairs,
+    unscorablePairs,
+    overlappingPairs
+  };
+}
+async function findDuplicatesWithOpenDuplicateUnitCache(index, options = {}, preparedData) {
+  const collectionOptions = duplicateUnitCollectionOptions(index, options);
+  const maxBucketSize = normalizePositiveIntegerOption2(options.maxBucketSize, "maxBucketSize", DEFAULT_MAX_BUCKET_SIZE2);
+  const maxCandidatePairs = normalizeMaxCandidatePairsOption2(options.maxCandidatePairs);
+  const maxPairs = options.maxPairs === void 0 ? Number.POSITIVE_INFINITY : normalizeNonNegativeIntegerOption2(options.maxPairs, "maxPairs", DEFAULT_LIMIT2);
+  const crossFileOnly = options.crossFileOnly ?? !(options.includeSameFile ?? false);
+  const minConfidence = normalizeConfidence2(options.minConfidence);
+  const limit = normalizeNonNegativeIntegerOption2(options.limit, "limit", DEFAULT_LIMIT2);
+  const progress = createDuplicateProgress(options.onProgress, options.progressStartedAt);
+  progress?.stage(preparedData ? DUPLICATE_STAGE_PAIRS : DUPLICATE_STAGE_UNITS);
+  const { unitCount, belowThresholdUnits, pairs, oversizedBuckets, skippedPairs, unscorablePairs, overlappingPairs } = await collectCandidatePairs(index, options, collectionOptions, preparedData, { maxBucketSize, maxCandidatePairs, crossFileOnly }, progress);
+  const scorablePairCount = pairs.size;
+  const candidatePairCount = foundCandidatePairs(scorablePairCount, unscorablePairs, maxCandidatePairs);
+  const candidatePairBudget = skippedPairs ? { limit: maxCandidatePairs, skipped: skippedPairs } : void 0;
   if (options.countOnly) {
-    const groupCount = countCandidateDuplicateGroups(pairs, crossFileOnly);
+    const groupCount = countCandidateDuplicateGroups(pairs);
+    progress?.complete(unitCount);
     return {
       schemaVersion: 3,
-      units: units.length,
+      units: unitCount,
       groups: [],
       omittedCounts: {
         groups: groupCount,
@@ -70910,24 +71483,28 @@ async function findDuplicatesWithOpenDuplicateUnitCache(index, options = {}, pre
         oversizedBuckets,
         belowThresholdUnits,
         overlappingPairs: 0,
-        candidatePairs: countComparableCandidatePairs(pairs, crossFileOnly)
+        candidatePairs: omittedCandidatePairs(pairs.size, candidatePairBudget)
       },
       stats: {
         comparedPairs: 0,
-        candidatePairs: pairs.size
+        candidatePairs: candidatePairCount,
+        ...candidatePairBudget ? { candidatePairBudget } : {}
       }
     };
   }
   const suggestions = [];
-  let overlappingPairs = 0;
   let comparedPairs = 0;
   let skippedCandidatePairs = 0;
+  progress?.stage(DUPLICATE_STAGE_SCORING, 0, scorablePairCount, "pair");
+  const reportEvery = Math.max(1, Math.floor(scorablePairCount / 100));
+  let visitedPairs = 0;
   for (const evidence of pairs.values()) {
-    if (crossFileOnly && evidence.left.absoluteFile === evidence.right.absoluteFile)
-      continue;
-    if (hasLineOverlap2(evidence.left, evidence.right)) {
-      overlappingPairs++;
-      continue;
+    visitedPairs++;
+    if (progress && visitedPairs % reportEvery === 0) {
+      progress.stage(DUPLICATE_STAGE_SCORING, visitedPairs, scorablePairCount, "pair");
+      const pending = progress.yieldPoint();
+      if (pending)
+        await pending;
     }
     if (comparedPairs >= maxPairs) {
       skippedCandidatePairs++;
@@ -70939,6 +71516,8 @@ async function findDuplicatesWithOpenDuplicateUnitCache(index, options = {}, pre
       continue;
     suggestions.push(suggestion);
   }
+  pairs.clear();
+  progress?.stage(DUPLICATE_STAGE_GROUPING);
   suggestions.sort(compareSuggestions2);
   const includeRawPairs = options.includeRawPairs ?? false;
   const groups = groupSuggestions2(suggestions, includeRawPairs).filter((group) => confidenceRank2[group.confidence] >= confidenceRank2[minConfidence]);
@@ -70947,7 +71526,7 @@ async function findDuplicatesWithOpenDuplicateUnitCache(index, options = {}, pre
   const limitedRawSuggestions = includeRawPairs ? suggestions.slice(0, limit) : [];
   const result = {
     schemaVersion: 3,
-    units: units.length,
+    units: unitCount,
     groups: limitedGroups,
     omittedCounts: {
       groups: omittedGroups,
@@ -70955,37 +71534,36 @@ async function findDuplicatesWithOpenDuplicateUnitCache(index, options = {}, pre
       oversizedBuckets,
       belowThresholdUnits,
       overlappingPairs,
-      candidatePairs: skippedCandidatePairs
+      candidatePairs: omittedCandidatePairs(skippedCandidatePairs, candidatePairBudget)
     },
     stats: {
       comparedPairs,
-      candidatePairs: pairs.size
+      candidatePairs: candidatePairCount,
+      ...candidatePairBudget ? { candidatePairBudget } : {}
     }
   };
   if (includeRawPairs) {
     result.suggestions = limitedRawSuggestions;
   }
+  progress?.complete(unitCount);
   return result;
 }
-function countComparableCandidatePairs(pairs, crossFileOnly) {
-  let count = 0;
-  for (const evidence of pairs.values()) {
-    if (crossFileOnly && evidence.left.absoluteFile === evidence.right.absoluteFile)
-      continue;
-    if (hasLineOverlap2(evidence.left, evidence.right))
-      continue;
-    count += 1;
-  }
-  return count;
-}
-function countCandidateDuplicateGroups(pairs, crossFileOnly) {
+function countCandidateDuplicateGroups(pairs) {
   const parents = /* @__PURE__ */ new Map();
   const find = (id) => {
-    const parent = parents.get(id);
-    if (!parent || parent === id)
-      return id;
-    const root = find(parent);
-    parents.set(id, root);
+    let root = id;
+    for (; ; ) {
+      const parent = parents.get(root);
+      if (!parent || parent === root)
+        break;
+      root = parent;
+    }
+    let current = id;
+    while (current !== root) {
+      const next = parents.get(current);
+      parents.set(current, root);
+      current = next;
+    }
     return root;
   };
   const join = (left, right) => {
@@ -70996,10 +71574,6 @@ function countCandidateDuplicateGroups(pairs, crossFileOnly) {
     parents.set(leftRoot, rightRoot);
   };
   for (const evidence of pairs.values()) {
-    if (crossFileOnly && evidence.left.absoluteFile === evidence.right.absoluteFile)
-      continue;
-    if (hasLineOverlap2(evidence.left, evidence.right))
-      continue;
     parents.set(evidence.left.id, parents.get(evidence.left.id) ?? evidence.left.id);
     parents.set(evidence.right.id, parents.get(evidence.right.id) ?? evidence.right.id);
     join(evidence.left.id, evidence.right.id);
@@ -71072,7 +71646,9 @@ function duplicateContextFromResult(result, target, options) {
       ...result.omittedCounts,
       groups: omittedGroups,
       rawSuggestions: Math.max(0, rawSuggestions.length - limitedRawSuggestions.length),
-      candidatePairs: result.perTargetSkippedCandidateCounts?.get(duplicateTargetKey(normalizedTarget)) ?? 0
+      // The pair limit is shared by every target of one call, so each context carries the whole call's skips,
+      // as it carries the call's `oversizedBuckets` and `overlappingPairs`.
+      candidatePairs: omittedCandidatePairs(result.perTargetSkippedCandidateCounts?.get(duplicateTargetKey(normalizedTarget)) ?? 0, result.stats.candidatePairBudget)
     },
     stats: {
       ...result.stats,
@@ -71160,6 +71736,7 @@ async function findDuplicatesTouchingTargets(index, targets, options, collectedU
   const projectRoot = options.projectRoot ?? index.projectRoot;
   const normalizedTargets = targets.map((target) => normalizeDuplicateTarget(target, projectRoot));
   const maxBucketSize = normalizePositiveIntegerOption2(options.maxBucketSize, "maxBucketSize", DEFAULT_MAX_BUCKET_SIZE2);
+  const maxCandidatePairs = normalizeMaxCandidatePairsOption2(options.maxCandidatePairs);
   const maxPairs = options.maxPairs === void 0 ? Number.POSITIVE_INFINITY : normalizeNonNegativeIntegerOption2(options.maxPairs, "maxPairs", DEFAULT_LIMIT2);
   const crossFileOnly = options.crossFileOnly ?? !(options.includeSameFile ?? false);
   const minConfidence = normalizeConfidence2(options.minConfidence);
@@ -71174,18 +71751,19 @@ async function findDuplicatesTouchingTargets(index, targets, options, collectedU
   }
   const targetsTouchedByPair = (left, right) => normalizedTargets.filter((target) => unitTouchesDuplicateTarget(left, target) || unitTouchesDuplicateTarget(right, target));
   const touchesAnyTarget = (left, right) => targetsTouchedByPair(left, right).length > 0;
-  const { pairs, oversizedBuckets } = buildCandidatePairsFromPreparedBuckets2(preparedBuckets ?? prepareDuplicateCandidateBuckets2(units), maxBucketSize, options.similarityHints, projectRoot, touchesAnyTarget, touchesTarget);
+  const { pairs, oversizedBuckets, skippedPairs, unscorablePairs, overlappingPairs } = await buildCandidatePairs2(preparedBuckets ?? prepareDuplicateCandidateBuckets2(units), {
+    maxBucketSize,
+    maxCandidatePairs,
+    crossFileOnly,
+    similarityHints: options.similarityHints,
+    projectRoot,
+    filter: { unit: touchesTarget, pair: touchesAnyTarget }
+  });
+  const candidatePairBudget = skippedPairs ? { limit: maxCandidatePairs, skipped: skippedPairs } : void 0;
   const suggestions = [];
-  let overlappingPairs = 0;
   let comparedPairs = 0;
   let skippedCandidatePairs = 0;
   for (const evidence of pairs.values()) {
-    if (crossFileOnly && evidence.left.absoluteFile === evidence.right.absoluteFile)
-      continue;
-    if (hasLineOverlap2(evidence.left, evidence.right)) {
-      overlappingPairs++;
-      continue;
-    }
     const touchedTargets = targetsTouchedByPair(evidence.left, evidence.right);
     if (!touchedTargets.length)
       continue;
@@ -71237,11 +71815,12 @@ async function findDuplicatesTouchingTargets(index, targets, options, collectedU
       oversizedBuckets,
       belowThresholdUnits,
       overlappingPairs,
-      candidatePairs: skippedCandidatePairs
+      candidatePairs: omittedCandidatePairs(skippedCandidatePairs, candidatePairBudget)
     },
     stats: {
       comparedPairs,
-      candidatePairs: pairs.size
+      candidatePairs: foundCandidatePairs(pairs.size, unscorablePairs, maxCandidatePairs),
+      ...candidatePairBudget ? { candidatePairBudget } : {}
     },
     perTargetCandidateCounts: targetCandidateCounts,
     perTargetComparedCounts: targetCompareCounts,
@@ -71282,17 +71861,21 @@ async function findDuplicateContext(index, target, options = {}) {
   const contexts = await findDuplicateContexts(index, [target], options);
   return contexts[0];
 }
-var collectDuplicateUnits2, normalizeDetectionFile2, DEFAULT_GROUP_VARIANT_LIMIT2, DEFAULT_LIMIT2, DEFAULT_MAX_BUCKET_SIZE2, DEFAULT_MAX_TOKENS2, DEFAULT_MIN_TOKENS2, DEFAULT_SHINGLE_SIZE2, DEFAULT_WINDOW_SIZE2, buildCandidatePairs2, buildCandidatePairsFromPreparedBuckets2, compareSuggestions2, confidenceRank2, filterPreparedDuplicateBuckets2, groupSuggestions2, hasLineOverlap2, lineOverlap2, normalizeConfidence2, normalizeNonNegativeIntegerOption2, normalizePositiveIntegerOption2, prepareDuplicateCandidateBuckets2, suggestionForPair2, suggestionVariantKey2, closeDuplicateUnitCacheForIndex2, leaseDuplicateUnitCacheForIndex2, maintainDuplicateUnitDiskCache2, duplicatePreparedAnalyses;
+var collectDuplicateUnits2, normalizeDetectionFile2, buildCandidatePairs2, filterPreparedDuplicateBuckets2, prepareDuplicateCandidateBuckets2, DEFAULT_GROUP_VARIANT_LIMIT2, DEFAULT_LIMIT2, DEFAULT_MAX_BUCKET_SIZE2, DEFAULT_MAX_TOKENS2, DEFAULT_MIN_TOKENS2, DEFAULT_SHINGLE_SIZE2, DEFAULT_WINDOW_SIZE2, compareSuggestions2, confidenceRank2, groupSuggestions2, lineOverlap2, normalizeConfidence2, normalizeMaxCandidatePairsOption2, normalizeNonNegativeIntegerOption2, normalizePositiveIntegerOption2, suggestionForPair2, suggestionVariantKey2, closeDuplicateUnitCacheForIndex2, leaseDuplicateUnitCacheForIndex2, maintainDuplicateUnitDiskCache2, duplicatePreparedAnalyses;
 var init_duplicates = __esm({
   "dist/duplicates.js"() {
     "use strict";
     init_paths();
     init_units();
+    init_candidates();
     init_scoring();
     init_unit_cache();
+    init_progress2();
     init_unit_cache();
+    init_scoring();
     ({ collectDuplicateUnits: collectDuplicateUnits2, normalizeDetectionFile: normalizeDetectionFile2 } = units_exports);
-    ({ DEFAULT_GROUP_VARIANT_LIMIT: DEFAULT_GROUP_VARIANT_LIMIT2, DEFAULT_LIMIT: DEFAULT_LIMIT2, DEFAULT_MAX_BUCKET_SIZE: DEFAULT_MAX_BUCKET_SIZE2, DEFAULT_MAX_TOKENS: DEFAULT_MAX_TOKENS2, DEFAULT_MIN_TOKENS: DEFAULT_MIN_TOKENS2, DEFAULT_SHINGLE_SIZE: DEFAULT_SHINGLE_SIZE2, DEFAULT_WINDOW_SIZE: DEFAULT_WINDOW_SIZE2, buildCandidatePairs: buildCandidatePairs2, buildCandidatePairsFromPreparedBuckets: buildCandidatePairsFromPreparedBuckets2, compareSuggestions: compareSuggestions2, confidenceRank: confidenceRank2, filterPreparedDuplicateBuckets: filterPreparedDuplicateBuckets2, groupSuggestions: groupSuggestions2, hasLineOverlap: hasLineOverlap2, lineOverlap: lineOverlap2, normalizeConfidence: normalizeConfidence2, normalizeNonNegativeIntegerOption: normalizeNonNegativeIntegerOption2, normalizePositiveIntegerOption: normalizePositiveIntegerOption2, prepareDuplicateCandidateBuckets: prepareDuplicateCandidateBuckets2, suggestionForPair: suggestionForPair2, suggestionVariantKey: suggestionVariantKey2 } = scoring_exports);
+    ({ buildCandidatePairs: buildCandidatePairs2, filterPreparedDuplicateBuckets: filterPreparedDuplicateBuckets2, prepareDuplicateCandidateBuckets: prepareDuplicateCandidateBuckets2 } = candidates_exports);
+    ({ DEFAULT_GROUP_VARIANT_LIMIT: DEFAULT_GROUP_VARIANT_LIMIT2, DEFAULT_LIMIT: DEFAULT_LIMIT2, DEFAULT_MAX_BUCKET_SIZE: DEFAULT_MAX_BUCKET_SIZE2, DEFAULT_MAX_TOKENS: DEFAULT_MAX_TOKENS2, DEFAULT_MIN_TOKENS: DEFAULT_MIN_TOKENS2, DEFAULT_SHINGLE_SIZE: DEFAULT_SHINGLE_SIZE2, DEFAULT_WINDOW_SIZE: DEFAULT_WINDOW_SIZE2, compareSuggestions: compareSuggestions2, confidenceRank: confidenceRank2, groupSuggestions: groupSuggestions2, lineOverlap: lineOverlap2, normalizeConfidence: normalizeConfidence2, normalizeMaxCandidatePairsOption: normalizeMaxCandidatePairsOption2, normalizeNonNegativeIntegerOption: normalizeNonNegativeIntegerOption2, normalizePositiveIntegerOption: normalizePositiveIntegerOption2, suggestionForPair: suggestionForPair2, suggestionVariantKey: suggestionVariantKey2 } = scoring_exports);
     ({ closeDuplicateUnitCacheForIndex: closeDuplicateUnitCacheForIndex2, leaseDuplicateUnitCacheForIndex: leaseDuplicateUnitCacheForIndex2, maintainDuplicateUnitDiskCache: maintainDuplicateUnitDiskCache2 } = unit_cache_exports);
     duplicatePreparedAnalyses = /* @__PURE__ */ new WeakMap();
   }
@@ -73537,27 +74120,27 @@ var init_parsed_cache = __esm({
 });
 
 // dist/indexer/finalize.js
-import { performance as performance4 } from "node:perf_hooks";
+import { performance as performance5 } from "node:perf_hooks";
 async function finalizeProjectIndex(args) {
   const discoveryTimings = args.opts?.report ? args.opts.report.timings ??= {} : void 0;
   let projectFiles;
   if (args.projectFiles !== void 0) {
     projectFiles = await args.projectFiles;
   } else {
-    const metadataDiscoveryStart = performance4.now();
+    const metadataDiscoveryStart = performance5.now();
     projectFiles = await discoverProjectFilesWithGitCandidates(args.projectRoot, {
       ...args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {},
       ...args.knownGitCandidates !== void 0 ? { knownGitCandidates: args.knownGitCandidates } : {},
       ...args.discoveryContext ? { discoveryContext: args.discoveryContext } : {}
     });
     if (discoveryTimings) {
-      const metadataDiscoveryMs = Math.round(performance4.now() - metadataDiscoveryStart);
+      const metadataDiscoveryMs = Math.round(performance5.now() - metadataDiscoveryStart);
       discoveryTimings.metadataDiscoveryMs = metadataDiscoveryMs;
       (discoveryTimings.steps ??= []).push({ name: "metadata-discovery", ms: metadataDiscoveryMs });
     }
   }
   if (args.timings)
-    args.timings.totalMs = Math.round(performance4.now() - args.totalStart);
+    args.timings.totalMs = Math.round(performance5.now() - args.totalStart);
   const languageExtensions = normalizeLanguageExtensions(args.opts?.languageExtensions);
   const parsed = retainedParsedCache(args.parsedMap, args.opts);
   return {
@@ -73594,7 +74177,7 @@ var init_finalize = __esm({
 // dist/indexer/build-manifest.js
 import fsp27 from "node:fs/promises";
 import path52 from "node:path";
-import { performance as performance5 } from "node:perf_hooks";
+import { performance as performance6 } from "node:perf_hooks";
 function toManifestFileEntry(entry) {
   if (!entry.sig)
     return void 0;
@@ -73616,22 +74199,22 @@ function serializeDeclaredContainers(projectRoot, index) {
 function recordManifestTimingStep(timings, name, startedAt) {
   if (!timings)
     return;
-  (timings.steps ??= []).push({ name, ms: Math.round(performance5.now() - startedAt) });
+  (timings.steps ??= []).push({ name, ms: Math.round(performance6.now() - startedAt) });
 }
 async function writeIndexManifestSnapshot(args) {
   const files = args.files instanceof Map ? Object.fromEntries(args.files) : args.files;
   if (!Object.keys(files).length && !args.allowEmpty)
     return;
-  const writeManifestStart = performance5.now();
-  const gitHeadStartedAt = performance5.now();
+  const writeManifestStart = performance6.now();
+  const gitHeadStartedAt = performance6.now();
   const lastCommit = await getGitHead(args.projectRoot);
   recordManifestTimingStep(args.timings, "git-head", gitHeadStartedAt);
-  const configHashStartedAt = performance5.now();
+  const configHashStartedAt = performance6.now();
   const configHashResult = args.configHash ?? await computeConfigHash(args.projectRoot, args.opts?.logLevel, args.discoveryContext);
   recordManifestTimingStep(args.timings, "config-hash", configHashStartedAt);
   const projectRootMtimeMs = args.symlinkDirectories !== void 0 ? (await fsp27.stat(args.projectRoot)).mtimeMs : void 0;
   const configHash = recordConfigHashResult(args.manifestReport, configHashResult, args.opts?.logLevel);
-  const transformStartedAt = performance5.now();
+  const transformStartedAt = performance6.now();
   const manifestData = {
     version: MANIFEST_VERSION,
     projectRoot: path52.resolve(args.projectRoot).replace(/\\/g, "/"),
@@ -73650,16 +74233,16 @@ async function writeIndexManifestSnapshot(args) {
     } : {}
   };
   recordManifestTimingStep(args.timings, "manifest-transform", transformStartedAt);
-  const manifestWriteStartedAt = performance5.now();
+  const manifestWriteStartedAt = performance6.now();
   const manifestWritten = await writeManifest2(args.projectRoot, args.opts, manifestData);
   recordManifestTimingStep(args.timings, "manifest-write", manifestWriteStartedAt);
   if (manifestWritten) {
-    const cachePruneStartedAt = performance5.now();
+    const cachePruneStartedAt = performance6.now();
     pruneDiskModuleCache(args.projectRoot, Object.keys(files), args.opts);
     recordManifestTimingStep(args.timings, "cache-prune", cachePruneStartedAt);
   }
   if (args.timings) {
-    args.timings.writeManifestMs = Math.round(performance5.now() - writeManifestStart);
+    args.timings.writeManifestMs = Math.round(performance6.now() - writeManifestStart);
   }
 }
 var init_build_manifest = __esm({
@@ -73736,7 +74319,7 @@ var init_native_worker_pool = __esm({
 });
 
 // dist/indexer/build-workers.js
-import { performance as performance6 } from "node:perf_hooks";
+import { performance as performance7 } from "node:perf_hooks";
 function shouldEnableNativeWorkers(opts, fileCount) {
   if (fileCount === 0)
     return false;
@@ -73828,14 +74411,14 @@ async function setupWorkerPool(opts, fileCount) {
   return {
     pool,
     report: report2,
-    startTime: pool ? performance6.now() : 0,
+    startTime: pool ? performance7.now() : 0,
     batchSize: NATIVE_WORKER_BATCH_SIZE
   };
 }
 async function teardownWorkerPool(setup, buildReport2) {
   if (setup.pool) {
     if (setup.report) {
-      setup.report.wallClockMs = Math.round(performance6.now() - setup.startTime);
+      setup.report.wallClockMs = Math.round(performance7.now() - setup.startTime);
     }
     try {
       await setup.pool.destroy();
@@ -74275,7 +74858,7 @@ import crypto11 from "node:crypto";
 import fs24 from "node:fs";
 import fsp28 from "node:fs/promises";
 import path55 from "node:path";
-import { performance as performance7 } from "node:perf_hooks";
+import { performance as performance8 } from "node:perf_hooks";
 function isConfinedFileReadError(error62) {
   return error62 instanceof Error && /outside project root|possible path confinement race|changed between verification and open|confined file target/u.test(error62.message);
 }
@@ -74815,7 +75398,7 @@ function createIndexBuildRunState(projectRoot, opts, graphOptions = normalizeGra
     timings: report2?.timings,
     // Delegated rebuilds mint a fresh run state after the preamble; reuse the caller's
     // origin so totalMs covers the whole wait, matching progress completion.
-    totalStart: opts?.progressStartedAt ?? performance7.now(),
+    totalStart: opts?.progressStartedAt ?? performance8.now(),
     cacheMode,
     cacheEnabled: cacheMode !== "off",
     graphOptions
@@ -74874,9 +75457,9 @@ async function timeIndexBuildPhase(args) {
   if (args.buildStartedAt !== void 0) {
     emitIndexBuildActivity(args.opts, args.activity, args.current, args.total, args.mode ?? "build");
   }
-  const startedAt = performance7.now();
+  const startedAt = performance8.now();
   const result = await args.fn();
-  recordBuildTimingStep(args.timings, { name: args.stepName, ms: Math.round(performance7.now() - startedAt) });
+  recordBuildTimingStep(args.timings, { name: args.stepName, ms: Math.round(performance8.now() - startedAt) });
   return result;
 }
 function createCountedCheckProgress(opts, activity, total) {
@@ -74916,9 +75499,9 @@ function recordBuildTimingStep(timings, step) {
     timings.filesystemScanMs = step.ms;
 }
 async function recordTimedBuildStep(timings, name, fn) {
-  const startedAt = performance7.now();
+  const startedAt = performance8.now();
   const result = await fn();
-  recordBuildTimingStep(timings, { name, ms: Math.round(performance7.now() - startedAt) });
+  recordBuildTimingStep(timings, { name, ms: Math.round(performance8.now() - startedAt) });
   return result;
 }
 function buildConcurrency(opts) {
@@ -75212,7 +75795,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
   const fileReport = initFileReport(report2);
   if (fileReport)
     fileReport.total = normalizedFiles.length;
-  const manifestStart = performance7.now();
+  const manifestStart = performance8.now();
   const manifest = useManifest && !helperOpts?.ignoreExistingManifest ? await loadManifest(projectRoot, opts, report2) : null;
   const manifestFiles = sanitizeManifestEntriesForRoot(projectRoot, manifest?.files);
   const manifestOptionDiffs = manifest ? diffBuildOptions(manifest.buildOptions, opts) : [];
@@ -75228,7 +75811,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     }
   }
   if (timings && useManifest) {
-    timings.manifestMs = Math.round(performance7.now() - manifestStart);
+    timings.manifestMs = Math.round(performance8.now() - manifestStart);
   }
   const edgeProbeConcurrency = buildConcurrency(opts);
   const staleCachedEdgeFiles = /* @__PURE__ */ new Set();
@@ -75257,7 +75840,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
   const moduleCacheAvailable = opts?.cache !== "disk" || diskModuleCacheExists(projectRoot, opts);
   const shouldReportFileCacheCheck = Boolean(helperOpts?.reportDiscoveryProgress);
   const reportFileCacheCheck = shouldReportFileCacheCheck ? createCountedCheckProgress(opts, "Checking file cache", normalizedFiles.length) : () => void 0;
-  const cacheProbeStart = performance7.now();
+  const cacheProbeStart = performance8.now();
   const evictionSerialAtStart = memoryCacheEvictionSerial();
   const gitAvailable = await isGitRepo(projectRoot, helperOpts?.discoveryContext?.git);
   const needsPersistentSignatures = cacheEnabled || useManifest;
@@ -75327,7 +75910,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     }
   }));
   if (timings) {
-    const cacheProbeMs = Math.round(performance7.now() - cacheProbeStart);
+    const cacheProbeMs = Math.round(performance8.now() - cacheProbeStart);
     timings.cacheProbeMs = cacheProbeMs;
     recordBuildTimingStep(timings, { name: "cache-probe", ms: cacheProbeMs });
   }
@@ -75397,7 +75980,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     const bloomFilterCache = useBloomFilters ? new (await Promise.resolve().then(() => (init_bloom_filter(), bloom_filter_exports))).BloomFilterCache() : void 0;
     const persistedBloomFilters = bloomFilterCache ? await tryLoadPersistedBloomFilters(projectRoot, opts, report2) : null;
     const parsedMap = /* @__PURE__ */ new Map();
-    const parseStart = performance7.now();
+    const parseStart = performance8.now();
     const graph = { nodes: new Set(normalizedFiles), edges: [] };
     const onFileEdges = manifestEntries ? (file2, entry) => {
       const manifestEntry = toManifestFileEntry(entry);
@@ -75411,7 +75994,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     const ensureBuildProgressStarted = () => {
       if (buildStartedAt !== void 0)
         return;
-      buildStartedAt = performance7.now();
+      buildStartedAt = performance8.now();
       emitIndexLifecycleProgress(opts, "start", "build", totalFiles);
     };
     if (cacheMisses.length)
@@ -75538,8 +76121,8 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
       }
     });
     if (timings)
-      timings.parseMs = Math.round(performance7.now() - parseStart);
-    const graphStart = performance7.now();
+      timings.parseMs = Math.round(performance8.now() - parseStart);
+    const graphStart = performance8.now();
     const seenGraphEdges = /* @__PURE__ */ new Set();
     const appendUniqueGraphEdges = (edges) => {
       if (!edges.length)
@@ -75595,7 +76178,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     });
     appendUniqueGraphEdges(workspaceManifestEdges);
     if (timings)
-      timings.graphMs = Math.round(performance7.now() - graphStart);
+      timings.graphMs = Math.round(performance8.now() - graphStart);
     for (const jsonPath of jsonDependencies.values()) {
       ensureJsonModule(modules, jsonPath);
     }
@@ -75641,7 +76224,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
       return [file2, { ...entry, ...cacheSig ? { cacheSig } : {} }];
     })) : manifestEntriesForIndex;
     const discoveredInsideFinalize = projectFiles === void 0;
-    const finalizeStartedAt = performance7.now();
+    const finalizeStartedAt = performance8.now();
     if (buildStartedAt !== void 0) {
       emitIndexBuildActivity(opts, "Finalizing project graph", totalFiles, totalFiles);
     }
@@ -75661,7 +76244,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
       manifestEntries: indexManifestEntries
     });
     if (timings) {
-      const elapsed = Math.round(performance7.now() - finalizeStartedAt);
+      const elapsed = Math.round(performance8.now() - finalizeStartedAt);
       const discoveryMs = discoveredInsideFinalize ? timings.metadataDiscoveryMs ?? 0 : 0;
       const finalizeMs = discoveredInsideFinalize ? Math.max(0, elapsed - discoveryMs) : elapsed;
       recordBuildTimingStep(timings, { name: "finalize", ms: finalizeMs });
@@ -75680,7 +76263,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     }
     if (buildStartedAt !== void 0) {
       const progressStartedAt = opts?.progressStartedAt ?? buildStartedAt;
-      emitIndexLifecycleProgress(opts, "complete", "build", index.byFile.size, performance7.now() - progressStartedAt);
+      emitIndexLifecycleProgress(opts, "complete", "build", index.byFile.size, performance8.now() - progressStartedAt);
     }
     return index;
   } finally {
@@ -75714,7 +76297,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
     const onDiscoveryTiming = timings ? (step) => recordBuildTimingStep(timings, step) : void 0;
     if (helperOpts?.reportDiscoveryProgress)
       emitIndexCheckActivity(opts, "Discovering source files");
-    const sourceDiscoveryStart = performance7.now();
+    const sourceDiscoveryStart = performance8.now();
     const discoveredFiles = await listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
       ...opts?.discovery,
       ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
@@ -75726,7 +76309,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
       ...discoveryContext ? { discoveryContext } : {}
     });
     if (timings)
-      timings.sourceDiscoveryMs = Math.round(performance7.now() - sourceDiscoveryStart);
+      timings.sourceDiscoveryMs = Math.round(performance8.now() - sourceDiscoveryStart);
     const additionalFileCandidates = await normalizeIndexedFileInputsWithinRoot(projectRoot, opts?.additionalFiles ?? [], "Additional index file");
     const additionalFileExistence = await probePathExistence(additionalFileCandidates, buildConcurrency(opts));
     const additionalFiles = additionalFileCandidates.filter((file2) => additionalFileExistence.get(file2));
@@ -75735,7 +76318,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
     const transientFiles = additionalFiles.filter((file2) => !discoveredFileSet.has(file2));
     if (helperOpts?.reportDiscoveryProgress)
       emitIndexCheckActivity(opts, "Discovering project metadata");
-    const metadataDiscoveryStart = performance7.now();
+    const metadataDiscoveryStart = performance8.now();
     const projectFiles = await discoverProjectFilesWithGitCandidates(projectRoot, {
       ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
       ...discoveredSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: discoveredSymlinkDirectories } : {},
@@ -75745,7 +76328,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
       ...discoveryContext ? { discoveryContext } : {}
     });
     if (timings)
-      timings.metadataDiscoveryMs = Math.round(performance7.now() - metadataDiscoveryStart);
+      timings.metadataDiscoveryMs = Math.round(performance8.now() - metadataDiscoveryStart);
     return await buildIndexFromFileListShared(projectRoot, files, opts, {
       manifestMode: useDiskCache ? "read-write" : "off",
       warnNoFilesMessage: `Warning: No files found in project root: ${projectRoot}. Check codegraph.config.json globs and CLI --include-glob/--ignore-glob filters. Diagnostic: codegraph doctor`,
@@ -75765,7 +76348,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
   }
 }
 async function buildProjectIndex(projectRoot, opts) {
-  const progressStartedAt = opts?.progressStartedAt ?? performance7.now();
+  const progressStartedAt = opts?.progressStartedAt ?? performance8.now();
   const timings = opts?.report ? opts.report.timings ??= {} : void 0;
   resetTransientBuildTimings(timings);
   return buildProjectIndexWithManifestOptions(projectRoot, {
@@ -75775,7 +76358,7 @@ async function buildProjectIndex(projectRoot, opts) {
 }
 async function buildProjectIndexFromFiles(projectRoot, inputFiles, rawOpts) {
   assertNativeRequiredAvailable();
-  const opts = { ...rawOpts, progressStartedAt: rawOpts?.progressStartedAt ?? performance7.now() };
+  const opts = { ...rawOpts, progressStartedAt: rawOpts?.progressStartedAt ?? performance8.now() };
   const timings = opts.report ? opts.report.timings ??= {} : void 0;
   resetTransientBuildTimings(timings);
   try {
@@ -75812,7 +76395,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
   assertNativeRequiredAvailable();
   const opts = {
     ...rawOpts,
-    progressStartedAt: rawOpts?.progressStartedAt ?? performance7.now()
+    progressStartedAt: rawOpts?.progressStartedAt ?? performance8.now()
   };
   const discoveryContext = opts.discoveryContext ?? createProjectDiscoveryContext(projectRoot);
   const discoveryTimings = opts.report ? opts.report.timings ??= {} : void 0;
@@ -75848,7 +76431,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       message: "Checked project index",
       current: total,
       total,
-      elapsedMs: performance7.now() - totalStart
+      elapsedMs: performance8.now() - totalStart
     });
   };
   try {
@@ -75863,10 +76446,10 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       return await buildProjectIndexFromExport(projectRoot, opts, { ignoreExistingManifest: true, discoveryContext });
     }
     startCheckProgress();
-    const manifestStart = performance7.now();
+    const manifestStart = performance8.now();
     const manifest = await recordTimedBuildStep(timings, "load-manifest", () => loadManifest(projectRoot, opts, report2));
     if (timings)
-      timings.manifestMs = Math.round(performance7.now() - manifestStart);
+      timings.manifestMs = Math.round(performance8.now() - manifestStart);
     const manifestUsed = !!manifest;
     const manifestReport = initManifestReport(report2, manifestUsed, false);
     if (manifestReport && !manifestUsed)
@@ -75927,11 +76510,11 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       if (!discoveryTimings || opts?.filesAreProjectScope)
         return await operation();
       sourceDiscoveryPerformed = true;
-      const start = performance7.now();
+      const start = performance8.now();
       try {
         return await operation();
       } finally {
-        sourceDiscoveryMs += performance7.now() - start;
+        sourceDiscoveryMs += performance8.now() - start;
       }
     };
     let manifestDiffFiles = [];
@@ -76149,14 +76732,14 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       const snapshot = snapshotLoad.index;
       snapshot.manifestSignaturesFresh = false;
       if (snapshot.projectFiles === void 0) {
-        const metadataDiscoveryStart = performance7.now();
+        const metadataDiscoveryStart = performance8.now();
         snapshot.projectFiles = await discoverProjectFilesWithGitCandidates(projectRoot, {
           ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
           ...discoveredGitCandidates !== void 0 ? { knownGitCandidates: discoveredGitCandidates } : {},
           ...discoveryContext ? { discoveryContext } : {}
         });
         if (discoveryTimings)
-          discoveryTimings.metadataDiscoveryMs = Math.round(performance7.now() - metadataDiscoveryStart);
+          discoveryTimings.metadataDiscoveryMs = Math.round(performance8.now() - metadataDiscoveryStart);
       }
       if (opts?.cache) {
         snapshot.cacheMode = opts.cache;
@@ -76192,7 +76775,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       const snapshot = await reuseUnchangedSnapshot();
       if (snapshot) {
         if (timings)
-          timings.totalMs = Math.round(performance7.now() - totalStart);
+          timings.totalMs = Math.round(performance8.now() - totalStart);
         completeCheckProgress(allFiles.size);
         return snapshot;
       }
@@ -76267,7 +76850,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         unchangedSnapshot.manifestEntries = new Map(Array.from(fileSignatures, ([file2, signature]) => [file2, toProjectIndexManifestEntry(signature)]));
         unchangedSnapshot.manifestSignaturesFresh = true;
         if (timings)
-          timings.totalMs = Math.round(performance7.now() - totalStart);
+          timings.totalMs = Math.round(performance8.now() - totalStart);
         completeCheckProgress(allFiles.size);
         return unchangedSnapshot;
       }
@@ -76363,13 +76946,13 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       workerSetup = await setupWorkerPool(opts, countNativeWorkerEligibleFiles(changedList, opts?.languageExtensions));
       let updateStartedAt;
       if (changedList.length || deletedTrackedFiles.size) {
-        updateStartedAt = performance7.now();
+        updateStartedAt = performance8.now();
         emitIndexLifecycleProgress(opts, "start", "update", changedList.length);
       }
       if (fileReport)
         fileReport.changed = changedList.length;
       if (changedList.length) {
-        const parseStart = performance7.now();
+        const parseStart = performance8.now();
         let processedFiles = 0;
         const totalFiles = changedList.length;
         const fileResults = await mapLimit(changedList, conc, async (file2) => {
@@ -76431,7 +77014,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
           writeModulesToCache(projectRoot, pendingIncrementalCacheWrites, opts);
         }
         if (timings)
-          timings.parseMs = Math.round(performance7.now() - parseStart);
+          timings.parseMs = Math.round(performance8.now() - parseStart);
       }
       for (const jsonPath of jsonDependencies.values()) {
         ensureJsonModule(modules, jsonPath);
@@ -76465,7 +77048,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         }
       }
       const filesList = Array.from(changedFiles);
-      const graphStart = performance7.now();
+      const graphStart = performance8.now();
       const graph = !filesList.length && baseGraph ? { nodes: new Set(baseGraph.nodes), edges: [...baseGraph.edges] } : await collectGraph(projectRoot, filesList, {
         parsed: parsedMap,
         resolveNodeModules: !!graphOptions.resolveNodeModules,
@@ -76487,7 +77070,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         }
       });
       if (timings)
-        timings.graphMs = Math.round(performance7.now() - graphStart);
+        timings.graphMs = Math.round(performance8.now() - graphStart);
       for (const file2 of /* @__PURE__ */ new Set([...changedFiles, ...transientFiles])) {
         const signature = fileSignatures.get(file2);
         if (!signature || manifestEntries.has(file2))
@@ -76571,7 +77154,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         fn: () => writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries, projectRoot))
       });
       if (updateStartedAt !== void 0) {
-        emitIndexLifecycleProgress(opts, "complete", "update", index.byFile.size, performance7.now() - updateStartedAt);
+        emitIndexLifecycleProgress(opts, "complete", "update", index.byFile.size, performance8.now() - updateStartedAt);
       } else {
         completeCheckProgress(allFiles.size);
       }
@@ -97014,7 +97597,7 @@ async function readGitFilesAtRevision(projectRoot, revision, files) {
     return /* @__PURE__ */ new Map();
   const maxOutputBytes = Math.min(MAX_GIT_BATCH_OUTPUT_BYTES_PER_FILE * requests.length, MAX_GIT_BATCH_OUTPUT_BYTES);
   try {
-    const child = spawn2("git", ["cat-file", "--batch"], { cwd: projectRoot });
+    const child = spawn2("git", ["cat-file", "--batch"], { windowsHide: true, cwd: projectRoot });
     const stdoutChunks = [];
     let stdoutBytes = 0;
     let stderr = "";
@@ -97291,7 +97874,7 @@ var init_deleted = __esm({
 });
 
 // dist/review/candidates.js
-import { performance as performance8 } from "node:perf_hooks";
+import { performance as performance9 } from "node:perf_hooks";
 function mergeCandidateTestEntries(baseCandidates, additionalCandidates) {
   const merged = /* @__PURE__ */ new Map();
   const upsert = (candidate) => {
@@ -97311,7 +97894,7 @@ function mergeCandidateTestEntries(baseCandidates, additionalCandidates) {
   return Array.from(merged.values());
 }
 async function collectReviewCandidateTests(input2) {
-  const candidateStart = performance8.now();
+  const candidateStart = performance9.now();
   const configuredMaxCandidates = input2.appliedOptions.maxCandidates;
   const maxCandidates = typeof configuredMaxCandidates === "number" && Number.isFinite(configuredMaxCandidates) ? Math.max(0, Math.floor(configuredMaxCandidates)) : REVIEW_DEFAULT_CANDIDATE_TEST_LIMIT;
   const candidateTests = mergeCandidateTestEntries(listCandidateTestFiles(input2.index, input2.changedFileList, input2.changedSymbolIds, {
@@ -97323,11 +97906,11 @@ async function collectReviewCandidateTests(input2) {
     file: toProjectDisplayPath(input2.projectRoot, candidate.file)
   })).sort(compareCandidateTests).slice(0, maxCandidates);
   if (input2.reviewTimings) {
-    input2.reviewTimings.candidatesMs = Math.round(performance8.now() - candidateStart);
+    input2.reviewTimings.candidatesMs = Math.round(performance9.now() - candidateStart);
   }
   return candidateTests;
 }
-var init_candidates = __esm({
+var init_candidates2 = __esm({
   "dist/review/candidates.js"() {
     "use strict";
     init_context2();
@@ -97619,7 +98202,7 @@ var init_parse4 = __esm({
 });
 
 // dist/review/changes.js
-import { performance as performance9 } from "node:perf_hooks";
+import { performance as performance10 } from "node:perf_hooks";
 function deletedPathsForChange(change2) {
   if (change2.kind === "deleted") {
     return [change2.path];
@@ -97637,16 +98220,16 @@ async function collectReviewChanges(projectRoot, appliedOptions, reviewTimings)
   const isIncludedReviewFile = createImpactIncludeMatcher(discoveryGlobRoot, appliedOptions.discovery?.includeGlobs ?? []);
   const changedFiles = /* @__PURE__ */ new Set();
   const explicitFiles = /* @__PURE__ */ new Set();
-  const changesStart = performance9.now();
+  const changesStart = performance10.now();
   for (const file2 of appliedOptions.files ?? []) {
     const normalized = normalizeFile(file2, "Review file");
     changedFiles.add(normalized);
     explicitFiles.add(normalized);
   }
   if (reviewTimings) {
-    reviewTimings.changesMs = Math.round(performance9.now() - changesStart);
+    reviewTimings.changesMs = Math.round(performance10.now() - changesStart);
   }
-  const diffStart = performance9.now();
+  const diffStart = performance10.now();
   const shouldLoadGitDiff = Boolean(appliedOptions.gitBase || appliedOptions.changedSince);
   const diffText = appliedOptions.diffText ?? (shouldLoadGitDiff ? await getUnifiedDiff(projectRoot, {
     base: appliedOptions.gitBase,
@@ -97655,7 +98238,7 @@ async function collectReviewChanges(projectRoot, appliedOptions, reviewTimings)
   }) : "");
   const diff = diffText ? parseUnifiedDiff(diffText) : null;
   if (reviewTimings) {
-    reviewTimings.diffMs = Math.round(performance9.now() - diffStart);
+    reviewTimings.diffMs = Math.round(performance10.now() - diffStart);
   }
   const diffHunksByFile = /* @__PURE__ */ new Map();
   const diffKindsByFile = /* @__PURE__ */ new Map();
@@ -99224,10 +99807,10 @@ var init_severity = __esm({
 });
 
 // dist/impact/budgets.js
-import { performance as performance10 } from "node:perf_hooks";
+import { performance as performance11 } from "node:perf_hooks";
 function createImpactWorkBudget(options) {
   return {
-    ...typeof options.timeBudgetMs === "number" && options.timeBudgetMs >= 0 ? { deadlineAt: performance10.now() + options.timeBudgetMs } : {},
+    ...typeof options.timeBudgetMs === "number" && options.timeBudgetMs >= 0 ? { deadlineAt: performance11.now() + options.timeBudgetMs } : {},
     ...typeof options.maxReferenceLookups === "number" && options.maxReferenceLookups >= 0 ? { maxReferenceLookups: options.maxReferenceLookups } : {},
     ...typeof options.maxTotalReferences === "number" && options.maxTotalReferences >= 0 ? { maxTotalReferences: options.maxTotalReferences } : {},
     referenceLookupsStarted: 0,
@@ -99242,7 +99825,7 @@ function isImpactDeadlineExceeded(budget) {
     return true;
   if (budget.deadlineAt === void 0)
     return false;
-  if (performance10.now() >= budget.deadlineAt) {
+  if (performance11.now() >= budget.deadlineAt) {
     budget.deadlineExceeded = true;
     return true;
   }
@@ -100233,7 +100816,7 @@ var init_reference_cache = __esm({
 // dist/review/summaries.js
 import fsp39 from "node:fs/promises";
 import path79 from "node:path";
-import { performance as performance11 } from "node:perf_hooks";
+import { performance as performance12 } from "node:perf_hooks";
 function sortSymbols(symbols) {
   return symbols.slice().sort((left, right) => symbolId(left).localeCompare(symbolId(right)));
 }
@@ -100564,7 +101147,7 @@ async function summarizeChangedFiles2(input2) {
     }
   }
   const defsToResolve = fileEntries.flatMap((entry) => entry.locals);
-  const referencesStart = performance11.now();
+  const referencesStart = performance12.now();
   const referenceResults = includeSymbolDetails && maxCallsites > 0 ? await mapLimit(defsToResolve, referenceConcurrency, async (def) => {
     const refs = await referenceCache.getUsages(index, def, {
       maxReferences: maxCallsites
@@ -100572,7 +101155,7 @@ async function summarizeChangedFiles2(input2) {
     return { def, refs };
   }) : [];
   if (reviewTimings) {
-    reviewTimings.referencesMs = Math.round(performance11.now() - referencesStart);
+    reviewTimings.referencesMs = Math.round(performance12.now() - referencesStart);
   }
   const referencesByHandle = /* @__PURE__ */ new Map();
   for (const entry of referenceResults) {
@@ -100757,7 +101340,7 @@ var init_summaries = __esm({
 });
 
 // dist/review.js
-import { performance as performance12 } from "node:perf_hooks";
+import { performance as performance13 } from "node:perf_hooks";
 function applyReviewPresetOptions(opts) {
   if (!opts.reviewDepth)
     return opts;
@@ -100787,7 +101370,7 @@ async function buildReviewIndex(input2) {
     diffChangesByFile,
     ...appliedOptions.graph ? { graphOptions: appliedOptions.graph } : {}
   });
-  const indexStart = performance12.now();
+  const indexStart = performance13.now();
   const indexReport = reviewReport?.indexReport ?? (reviewReport ? { timings: {} } : void 0);
   if (reviewReport && !reviewReport.indexReport && indexReport) {
     reviewReport.indexReport = indexReport;
@@ -100819,7 +101402,7 @@ async function buildReviewIndex(input2) {
     });
   }
   if (reviewTimings) {
-    reviewTimings.indexMs = Math.round(performance12.now() - indexStart);
+    reviewTimings.indexMs = Math.round(performance13.now() - indexStart);
   }
   return {
     index,
@@ -100837,8 +101420,8 @@ async function buildReviewReport(projectRoot, opts = {}, cached2) {
   if (reviewReport && appliedOptions.duplicateTasks === false) {
     delete reviewReport.duplicateAnalysis;
   }
-  const totalStart = performance12.now();
-  const { changedFiles, explicitFiles, diffHunksByFile, diffKindsByFile, diffChangesByFile } = await collectReviewChanges(projectRoot, appliedOptions, reviewTimings);
+  const totalStart = performance13.now();
+  const { changedFiles, explicitFiles, diffHunksByFile, diffKindsByFile, diffChangesByFile } = cached2?.changes ?? await collectReviewChanges(projectRoot, appliedOptions, reviewTimings);
   if (changedFiles.size === 0) {
     const riskSummary = computeRiskSummary({
       filesChanged: 0,
@@ -100871,7 +101454,7 @@ async function buildReviewReport(projectRoot, opts = {}, cached2) {
       report3.base = appliedOptions.gitBase;
     report3.head = appliedOptions.gitHead ?? "HEAD";
     if (reviewTimings)
-      reviewTimings.totalMs = Math.round(performance12.now() - totalStart);
+      reviewTimings.totalMs = Math.round(performance13.now() - totalStart);
     return report3;
   }
   const changedFileList = Array.from(changedFiles).sort((left, right) => left.localeCompare(right));
@@ -100950,7 +101533,7 @@ async function buildReviewReport(projectRoot, opts = {}, cached2) {
     riskRelevantParseFailures,
     exportedChangedCount
   });
-  const duplicateAnalysisStart = performance12.now();
+  const duplicateAnalysisStart = performance13.now();
   if (appliedOptions.duplicateTasks !== false) {
     const duplicateReview = await collectReviewDuplicateTasks({
       projectRoot,
@@ -100971,10 +101554,10 @@ async function buildReviewReport(projectRoot, opts = {}, cached2) {
     }
   }
   if (reviewTimings && appliedOptions.duplicateTasks !== false) {
-    reviewTimings.duplicateAnalysisMs = Math.round(performance12.now() - duplicateAnalysisStart);
+    reviewTimings.duplicateAnalysisMs = Math.round(performance13.now() - duplicateAnalysisStart);
   }
   if (reviewTimings)
-    reviewTimings.totalMs = Math.round(performance12.now() - totalStart);
+    reviewTimings.totalMs = Math.round(performance13.now() - totalStart);
   return report2;
 }
 function buildSymbolDefLookup(index) {
@@ -101135,7 +101718,7 @@ var init_review2 = __esm({
     init_workspace();
     init_project_files();
     init_concurrency();
-    init_candidates();
+    init_candidates2();
     init_changes();
     init_deleted();
     init_report();
@@ -102361,7 +102944,7 @@ async function explainCodegraphTargetWithSession(session, request) {
   const snapshot = await session.loadProject();
   const lookup2 = buildSymbolLookup(snapshot);
   const resolved = resolveTarget(snapshot, lookup2, request.target);
-  return await buildExplanation(snapshot, lookup2, resolved, request);
+  return await buildExplanation(snapshot, lookup2, resolved, request, session);
 }
 async function resolveCodegraphTargetWithSession(session, request) {
   const snapshot = await session.loadProject();
@@ -102525,7 +103108,7 @@ function basename2(name) {
   const parts = name.split(".");
   return parts[parts.length - 1] ?? name;
 }
-async function buildExplanation(snapshot, lookup2, resolved, request) {
+async function buildExplanation(snapshot, lookup2, resolved, request, session) {
   const maxDependencies = defaultAgentLimit(request.maxDependencies, AGENT_EXPLAIN_DEFAULT_DEPENDENCY_LIMIT, AGENT_EXPLAIN_MAX_DEPENDENCY_LIMIT);
   const maxReferences = defaultAgentLimit(request.maxReferences ?? request.maxDependencies, AGENT_EXPLAIN_DEFAULT_DEPENDENCY_LIMIT, AGENT_EXPLAIN_MAX_DEPENDENCY_LIMIT);
   const maxRelatedSqlObjects = defaultAgentLimit(request.maxRelatedSqlObjects ?? request.maxDependencies, AGENT_EXPLAIN_DEFAULT_DEPENDENCY_LIMIT, AGENT_EXPLAIN_MAX_DEPENDENCY_LIMIT);
@@ -102549,7 +103132,7 @@ async function buildExplanation(snapshot, lookup2, resolved, request) {
   const references = referenceContext.references;
   const snippets = referenceContext.snippets;
   const relatedSqlObjects = await collectRelatedSqlObjects(snapshot, lookup2, resolved, file2, maxRelatedSqlObjects);
-  const duplicates = await collectDuplicateContext(snapshot, resolved, relFile, maxDuplicates);
+  const duplicates = await collectDuplicateContext(snapshot, session, resolved, relFile, maxDuplicates);
   const followUps = collectFollowUps(snapshot, resolved, boundedSymbols.items, relFile, duplicates.items);
   const changedContext = await collectChangedContext(request);
   return {
@@ -102692,7 +103275,7 @@ function compareDependencies(left, right) {
     return depthDelta;
   return left.file.localeCompare(right.file);
 }
-async function collectDuplicateContext(snapshot, resolved, relFile, limit) {
+async function collectDuplicateContext(snapshot, session, resolved, relFile, limit) {
   if (resolved.kind === "sql_object")
     return emptyAgentBoundedList();
   const target = resolved.kind === "file" ? { file: relFile } : {
@@ -102700,13 +103283,15 @@ async function collectDuplicateContext(snapshot, resolved, relFile, limit) {
     startLine: resolved.def.range.start.line,
     endLine: resolved.def.range.end.line
   };
-  const result = await findDuplicateContext(snapshot.index, target, {
+  const options = {
     projectRoot: snapshot.root,
     minConfidence: "medium",
     includeSameFile: true,
     limit,
     maxPairs: AGENT_DUPLICATE_MAX_PAIRS
-  });
+  };
+  const analysis = await session.loadDuplicateAnalysis?.();
+  const result = analysis ? (await findDuplicateContextsWithPreparedAnalysis(analysis, [target], options))[0] : await findDuplicateContext(snapshot.index, target, options);
   return {
     items: result.groups.map((group) => summarizeDuplicateGroup(group, result.target)),
     omitted: result.omittedCounts.groups + result.omittedCounts.candidatePairs
@@ -104071,7 +104656,7 @@ function findQueryIndexChunkCandidates(store, rankTerms, normalizedRankPhrase =
   };
 }
 var QUERY_INDEX_CANDIDATE_VERSION;
-var init_candidates2 = __esm({
+var init_candidates3 = __esm({
   "dist/agent/query-index/candidates.js"() {
     "use strict";
     init_content();
@@ -104648,9 +105233,8 @@ async function searchCodegraphWithSession(session, request) {
       return freshResponse;
     return { ...freshResponse, query: request.query };
   }
-  const mode = request.mode ?? "hybrid";
   let queryIndex;
-  if (mode === "hybrid" || mode === "text") {
+  if (searchUsesQueryIndex(request)) {
     const { ensureSessionQueryIndex: ensureSessionQueryIndex2 } = await Promise.resolve().then(() => (init_session_store(), session_store_exports));
     queryIndex = await ensureSessionQueryIndex2(session, snapshot);
   }
@@ -104847,6 +105431,10 @@ function searchNeedsSymbolGraph(request) {
   const mode = request.mode ?? "hybrid";
   return mode !== "path" && mode !== "text" && mode !== "sql";
 }
+function searchUsesQueryIndex(request) {
+  const mode = request.mode ?? "hybrid";
+  return mode === "hybrid" || mode === "text";
+}
 function buildQueryTerms(input2, snapshot) {
   const normalized = normalizeSearchText(input2);
   const tokenSequence = normalized.split(/\s+/).filter((token) => token.length);
@@ -105613,7 +106201,7 @@ var init_search = __esm({
     init_session();
     init_follow_ups();
     init_content();
-    init_candidates2();
+    init_candidates3();
     init_store();
     init_session_lifecycle();
     DEFAULT_LIMIT3 = 20;
@@ -106715,33 +107303,34 @@ ${SHARED_INDEX_OPTIONS_HELP}
     SERVER_HELP_TEXT = `codegraph server - Manage a shared project-local MCP HTTP server
 
 Usage:
-  codegraph server start [--root <path>] [--host <host>] [--port <1-65535>] [--startup-timeout-ms <1-86400000>] [--json] [--replace] [--warmup | --warmup-symbols | --no-warmup] [--no-watch]
+  codegraph server start [--root <path>] [--host <host>] [--port <1-65535>] [--startup-timeout-ms <1-86400000>] [--index-wait-ms <ms>] [--json] [--replace] [--warmup | --warmup-symbols | --no-warmup] [--no-watch]
   codegraph server status [--root <path>] [--json | --pretty]
   codegraph server stop [--root <path>]
 
 Behavior:
   start runs codegraph mcp serve in a separate process, waits for a challenged /health proof, then writes .codegraph/server.json. --json emits the started registry with status and update fields; startup diagnostics go to .codegraph/server.log.
-  The default server listens on 127.0.0.1:7331. A public bind requires an explicit --host. --startup-timeout-ms defaults to 15000 and allows up to 86400000 for long warmups. Startup warms the base session cache by default; --no-warmup starts lazily instead, and --warmup-symbols also warms the detailed symbol graph.
+  The default server listens on 127.0.0.1:7331. A public bind requires an explicit --host. --startup-timeout-ms defaults to 15000 and covers starting the process; the warmup builds in the background and does not count against it. By default the server warms the base session cache and the search index; --no-warmup starts lazily instead, and --warmup-symbols also warms the detailed symbol graph.
   status retries proven health checks and reports a verification remedy for an unreachable or mismatched server. stop removes only confirmed stale registries or signals a Codegraph server whose root, process, and startup time match the registry.
 
 Forwarded startup options:
   --cache, --cache-dir, --cache-strict, --cache-verify, --threads, --workers,
-  --include-glob, --ignore-glob, --no-gitignore, --no-watch, and --resolution-hint pass to mcp serve.
+  --include-glob, --ignore-glob, --no-gitignore, --no-watch, --index-wait-ms, and --resolution-hint pass to mcp serve.
 
 Safety:
   The registry stores process metadata and a non-secret credential ID. Its credential remains in the per-user Codegraph state directory, outside the project and separate from compiler cache data. An installed-version change requires an explicit server restart; Codegraph does not replace mapped native files or terminate clients automatically.
 `;
     MCP_HELP_TEXT = `codegraph mcp - Serve MCP tools for agent graph navigation
 
-Usage: codegraph mcp [serve] [--root <path>] [--artifact <path>] [--stdio | --port <number>] [--host <host>] [--idle-timeout-ms <ms>] [--allow-build] [--warmup | --warmup-symbols | --no-warmup] [--no-watch]
+Usage: codegraph mcp [serve] [--root <path>] [--artifact <path>] [--stdio | --port <number>] [--host <host>] [--idle-timeout-ms <ms>] [--index-wait-ms <ms>] [--allow-build] [--warmup | --warmup-symbols | --no-warmup] [--no-watch]
 
 Transports:
   --stdio          Serve MCP over stdio (default)
   --port <number> Serve Streamable HTTP at /mcp
-  --warmup        Build the base session cache at startup (default)
-  --warmup-symbols Build the base cache and detailed symbol graph at startup
-  --no-warmup     Skip startup warmup; the first tool call pays for discovery and building
+  --warmup        Build the base session cache and the search index in the background after startup (default)
+  --warmup-symbols Also build the detailed symbol graph in the background
+  --no-warmup     Skip the startup warmup; the first tool call that needs the index starts the build
   --no-watch      Do not watch project files; rely on the freshness check of each tool call
+  --index-wait-ms <ms> Longest wait of search, explore, orient, get_file with includeGraphContext, review, packet_get, workspace_symbols, and impact for a running index build before they answer index_building (default 15000; 0 waits without limit)
 
 Index Options:
   --cache <mode>     Session cache mode: disk, memory, off
@@ -106759,7 +107348,7 @@ Tools are read-only unless --allow-build is passed.
 `;
     MCP_SERVE_HELP_TEXT = `codegraph mcp serve - MCP server for agent graph navigation
 
-Usage: codegraph mcp [serve] [--root <path>] [--artifact <path>] [--stdio | --port <number>] [--host <host>] [--idle-timeout-ms <ms>] [--allow-build] [--warmup | --warmup-symbols | --no-warmup] [--no-watch]
+Usage: codegraph mcp [serve] [--root <path>] [--artifact <path>] [--stdio | --port <number>] [--host <host>] [--idle-timeout-ms <ms>] [--index-wait-ms <ms>] [--allow-build] [--warmup | --warmup-symbols | --no-warmup] [--no-watch]
 
 Tools:
   orient          Build a compact first-turn repo packet
@@ -106793,7 +107382,8 @@ Index Options:
 Defaults:
   Transport defaults to stdio.
   HTTP transport binds to 127.0.0.1 unless --host is passed and serves /mcp.
-  Startup warms the base session cache by default. --warmup-symbols also warms the detailed symbol graph. --no-warmup starts lazily instead, leaving the first tool call to pay for discovery and building.
+  The server answers initialize and tools/list at once. By default it then builds the base session cache and the search index in the background; --warmup-symbols also warms the detailed symbol graph, and --no-warmup builds only when a tool call needs the index.
+  search, explore, orient, get_file with includeGraphContext, review, packet_get, workspace_symbols, and impact wait for a running build for at most --index-wait-ms (default 15000, well below the 30 seconds that clients commonly allow). Past that they answer { "status": "index_building" } with progress and a retry hint; the build continues, and the same call succeeds once it ends. Every other tool waits for the index without a limit.
   Warmup uses the configured session cache and shared index flags.
   The server watches project files and refreshes the index in the background: 500 ms after the last change, at most once every 5 seconds, and paused after 30 minutes without a tool call. --no-watch relies on the freshness check of each tool call instead.
   Tools are read-only unless --allow-build is passed.
@@ -106831,11 +107421,15 @@ Options:
   --min-tokens        Minimum unit tokens. Defaults to 40, or 80 under cleanup profile.
   --max-tokens        Maximum fallback chunk tokens. Defaults to 800.
   --max-bucket-size   Skip candidate buckets larger than this value. Defaults to 200.
+  --max-candidate-pairs
+                      Keep at most this many candidate pairs for scoring, strongest evidence first. Defaults to 2000000; maximum 16000000.
 
 Output:
   Pretty output is the default and emits one line per group with file spans, symbol or chunk labels, confidence, clone type, score, reduced lines, estimated reducible lines, token counts, heuristic family annotations, and cleanup labels.
   Pretty output also emits a compact summary footer unless --no-summary is passed.
   JSON output reports grouped duplicate findings, confidence, clone type, metrics, reduced-line fields, cleanup labels, clustered locations, omission counts including skipped candidate pairs, and pair stats.
+  When --max-candidate-pairs drops pairs, stats.candidatePairBudget names the limit and the skipped count, and pretty output says the results are partial.
+  Progress for unit collection, candidate pairs, scoring, and grouping, and the total elapsed time, goes to stderr; use --progress or --no-progress.
   Grouped duplicate JSON uses schemaVersion 3.
   --raw-pairs is only supported with similarity-ranked JSON output and cannot be combined with the cleanup profile.
 `;
@@ -107121,7 +107715,7 @@ var search_exports = {};
 __export(search_exports, {
   handleSearchCommand: () => handleSearchCommand
 });
-import { performance as performance13 } from "node:perf_hooks";
+import { performance as performance14 } from "node:perf_hooks";
 function parseAgentSearchMode(rawValue) {
   if (rawValue === void 0)
     return "hybrid";
@@ -107131,7 +107725,7 @@ function parseAgentSearchMode(rawValue) {
   throw new Error(`Invalid --mode value "${rawValue}". Expected hybrid, symbol, path, text, graph, or sql.`);
 }
 async function handleSearchCommand(context) {
-  const commandStart = performance13.now();
+  const commandStart = performance14.now();
   const query = context.positionals.join(" ").trim();
   if (!query) {
     context.writeStderrLine(SEARCH_HELP_TEXT.trimEnd());
@@ -107155,7 +107749,7 @@ async function handleSearchCommand(context) {
     context.writeStdoutLine(formatAgentSearchResponse(response));
   }
   if (context.commandReport && context.writeCommandReport) {
-    context.commandReport.timings.commandMs = Math.round(performance13.now() - commandStart);
+    context.commandReport.timings.commandMs = Math.round(performance14.now() - commandStart);
     context.commandReport.timings.totalMs = context.commandReport.timings.commandMs;
     await context.writeCommandReport(context.commandReport, context.reportFile);
   }
@@ -107632,25 +108226,25 @@ function getCallHierarchyIndex(graph) {
   for (const edge of graph.edges) {
     if (edge.label !== "calls")
       continue;
-    const pairKey2 = `${edge.from}->${edge.to}`;
-    const relationship = relationshipByPair.get(pairKey2) ?? {
+    const pairKey = `${edge.from}->${edge.to}`;
+    const relationship = relationshipByPair.get(pairKey) ?? {
       caller: edge.from,
       callee: edge.to,
       sites: [],
       unresolvedSites: 0
     };
     if (edge.site) {
-      const siteKeys = siteKeysByPair.get(pairKey2) ?? /* @__PURE__ */ new Set();
+      const siteKeys = siteKeysByPair.get(pairKey) ?? /* @__PURE__ */ new Set();
       const siteKey3 = callsiteKey(edge.site);
       if (!siteKeys.has(siteKey3)) {
         siteKeys.add(siteKey3);
         relationship.sites.push(edge.site);
       }
-      siteKeysByPair.set(pairKey2, siteKeys);
+      siteKeysByPair.set(pairKey, siteKeys);
     } else {
       relationship.unresolvedSites += 1;
     }
-    relationshipByPair.set(pairKey2, relationship);
+    relationshipByPair.set(pairKey, relationship);
   }
   for (const relationship of relationshipByPair.values()) {
     relationship.sites.sort(compareCallsites);
@@ -108904,7 +109498,7 @@ var init_base = __esm({
         const cwd = opts.cwd || process.cwd();
         const args = gitDiffArgs(opts.base, opts.head, ["--no-ext-diff", "--unified=0"]);
         try {
-          const child = spawn3("git", args, { cwd });
+          const child = spawn3("git", args, { windowsHide: true, cwd });
           let stderr = "";
           child.stderr.on("data", (data) => {
             stderr += String(data);
@@ -113809,7 +114403,7 @@ __export(orient_exports, {
   formatAgentOrientation: () => formatAgentOrientation,
   handleOrientCommand: () => handleOrientCommand
 });
-import { performance as performance14 } from "node:perf_hooks";
+import { performance as performance15 } from "node:perf_hooks";
 function parseAgentOrientBudget(rawValue) {
   if (rawValue === void 0)
     return "small";
@@ -113827,7 +114421,7 @@ function parseAgentOrientHealthMode(rawValue) {
   throw new Error(`Invalid --health value "${rawValue}". Expected skip, summary, or full.`);
 }
 async function handleOrientCommand(context) {
-  const commandStart = performance14.now();
+  const commandStart = performance15.now();
   const healthMode = parseAgentOrientHealthMode(context.getOpt("--health"));
   const writesJson = context.hasFlag("--json");
   const indexReport = context.commandReport?.index;
@@ -113849,7 +114443,7 @@ async function handleOrientCommand(context) {
     context.writeStdoutLine(formatAgentOrientation(response));
   }
   if (context.commandReport && context.writeCommandReport) {
-    context.commandReport.timings.commandMs = Math.round(performance14.now() - commandStart);
+    context.commandReport.timings.commandMs = Math.round(performance15.now() - commandStart);
     context.commandReport.timings.totalMs = context.commandReport.timings.commandMs;
     await context.writeCommandReport(context.commandReport, context.reportFile);
   }
@@ -131149,17 +131743,286 @@ var init_project_watcher = __esm({
   }
 });
 
+// dist/mcp/cancellation.js
+function mcpCancellationError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error && reason.name !== "AbortError")
+    return reason;
+  return new Error("MCP tool call was cancelled.");
+}
+var init_cancellation = __esm({
+  "dist/mcp/cancellation.js"() {
+    "use strict";
+  }
+});
+
+// dist/mcp/stale-install.js
+function isStaleInstallError(error62) {
+  let current = error62;
+  for (let depth = 0; depth < MAX_CAUSE_DEPTH && current instanceof Error; depth += 1) {
+    if ("code" in current && (current.code === "ERR_MODULE_NOT_FOUND" || current.code === "MODULE_NOT_FOUND"))
+      return true;
+    if (MODULE_NOT_FOUND_MESSAGE.test(current.message))
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+function describeMcpRuntimeError(error62) {
+  return isStaleInstallError(error62) ? STALE_INSTALL_MESSAGE : errorMessage(error62);
+}
+var STALE_INSTALL_MESSAGE, MODULE_NOT_FOUND_MESSAGE, MAX_CAUSE_DEPTH;
+var init_stale_install = __esm({
+  "dist/mcp/stale-install.js"() {
+    "use strict";
+    init_errors();
+    STALE_INSTALL_MESSAGE = "The codegraph package changed on disk after this MCP server started, so a part of it that had not been loaded yet is gone. Restart the MCP server (or reload the MCP client) to run the installed version.";
+    MODULE_NOT_FOUND_MESSAGE = /^Cannot find (?:module|package)\b/;
+    MAX_CAUSE_DEPTH = 5;
+  }
+});
+
+// dist/mcp/index-readiness.js
+function assertMcpIndexWait(value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > MAX_MCP_INDEX_WAIT_MS) {
+    throw new RangeError(`mcpIndexWaitMs must be a whole number from 0 through ${MAX_MCP_INDEX_WAIT_MS}; 0 disables the budget.`);
+  }
+  return value;
+}
+function searchNeeds(request) {
+  if (canUsePathFastPath(request))
+    return [];
+  const needs = [searchNeedsSymbolGraph(request) ? "symbolGraph" : "index"];
+  if (searchUsesQueryIndex(request))
+    needs.push("queryIndex");
+  return needs;
+}
+function exploreNeeds(request) {
+  const needs = searchNeeds({});
+  if (request.includeSource && request.maxPackets !== 0)
+    needs.push("detailedGraph", "duplicates");
+  return needs;
+}
+function describeBuildUpdate(update) {
+  if (update.activity)
+    return update.activity;
+  if (update.phase === "start")
+    return update.message;
+  if (update.mode === "update")
+    return "Updating project index";
+  if (update.mode === "check")
+    return "Checking project index";
+  return "Indexing files";
+}
+function createMcpBuildProgress() {
+  let latest;
+  return {
+    record: (update) => {
+      if (update.phase === "complete") {
+        latest = void 0;
+        return;
+      }
+      latest = { activity: describeBuildUpdate(update), current: update.current, total: update.total };
+    },
+    latest: () => latest
+  };
+}
+function settleWithinBudget(work, budgetMs, signal) {
+  if (signal?.aborted)
+    return Promise.reject(mcpCancellationError(signal));
+  const { promise: promise3, resolve: resolve3, reject } = Promise.withResolvers();
+  let timer;
+  const onAbort = () => {
+    cleanup();
+    if (signal)
+      reject(mcpCancellationError(signal));
+  };
+  const cleanup = () => {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  if (budgetMs > 0) {
+    timer = setTimeout(() => {
+      cleanup();
+      resolve3("timeout");
+    }, budgetMs);
+    timer.unref();
+  }
+  work.then(() => {
+    cleanup();
+    resolve3("ready");
+  }, (error62) => {
+    cleanup();
+    reject(error62 instanceof Error ? error62 : new Error(String(error62)));
+  });
+  return promise3;
+}
+function createMcpIndexReadiness(session, options) {
+  const pending = /* @__PURE__ */ new Set();
+  let busySince;
+  let warmupStarted = false;
+  let invalidations = 0;
+  const countInvalidations = () => {
+    registerSessionInvalidationHook(session, () => {
+      invalidations += 1;
+      countInvalidations();
+    });
+  };
+  countInvalidations();
+  const track = (work) => {
+    if (!pending.size)
+      busySince = performance.now();
+    pending.add(work);
+    const release = () => {
+      pending.delete(work);
+      if (!pending.size)
+        busySince = void 0;
+    };
+    work.then(release, release);
+    return work;
+  };
+  const buildsSettled = async () => {
+    while (pending.size)
+      await Promise.allSettled([...pending]);
+  };
+  const load = async (need) => {
+    if (need === "symbolGraph") {
+      await session.loadProject({ symbolGraph: "basic" });
+    } else if (need === "detailedGraph") {
+      await session.loadProject();
+    } else if (need === "duplicates") {
+      await session.loadDuplicateAnalysis?.();
+    } else if (need === "queryIndex") {
+      const snapshot = await session.loadProject({ symbolGraph: "skip" });
+      const { ensureSessionQueryIndex: ensureSessionQueryIndex2 } = await Promise.resolve().then(() => (init_session_store(), session_store_exports));
+      await ensureSessionQueryIndex2(session, snapshot);
+    } else {
+      await session.loadProject({ symbolGraph: "skip" });
+    }
+  };
+  const trackedLoad = (need) => track(load(need));
+  const startWarmup = () => {
+    if (warmupStarted)
+      return;
+    warmupStarted = true;
+    if (!options.warmup.length)
+      return;
+    void track(Promise.all(options.warmup.map(trackedLoad)).then(() => void 0, (error62) => {
+      console.error(`[codegraph] MCP startup warmup failed: ${describeMcpRuntimeError(error62)}`);
+    }));
+  };
+  const describeProgress = (needs, done, waitedMs) => {
+    const elapsedMs2 = Math.round(busySince === void 0 ? waitedMs : performance.now() - busySince);
+    const update = options.progress.latest();
+    if (update) {
+      return {
+        activity: update.activity,
+        ...update.total > 0 ? { current: update.current, total: update.total } : {},
+        elapsedMs: elapsedMs2
+      };
+    }
+    const unfinished = needs.find((need) => !done.has(need));
+    return { activity: unfinished ? ACTIVITY[unfinished] : CHECKING_ACTIVITY, elapsedMs: elapsedMs2 };
+  };
+  const waitFor = async (tool, needs, signal, followUp) => {
+    if (signal?.aborted)
+      throw mcpCancellationError(signal);
+    const startedAt = performance.now();
+    let wanted = [...needs];
+    const done = /* @__PURE__ */ new Set();
+    const loadAll = async (list) => {
+      await Promise.all(list.map(async (need) => {
+        await trackedLoad(need);
+        done.add(need);
+      }));
+    };
+    const ready = track((async () => {
+      await checkSessionFreshness(session);
+      for (let round = 0; round < MAX_READINESS_ROUNDS; round += 1) {
+        const loadedAt = invalidations;
+        wanted = [...needs];
+        done.clear();
+        await loadAll(needs);
+        if (followUp) {
+          const later = await followUp();
+          wanted.push(...later);
+          await loadAll(later);
+        }
+        await checkSessionFreshness(session);
+        if (invalidations === loadedAt)
+          return;
+      }
+    })());
+    if (await settleWithinBudget(ready, options.waitMs, signal) === "ready")
+      return;
+    const waitedMs = Math.round(performance.now() - startedAt);
+    const progress = describeProgress(wanted, done, waitedMs);
+    const counts = progress.total === void 0 ? "" : ` ${progress.current ?? 0}/${progress.total}`;
+    throw new McpIndexBuildingError({
+      status: "index_building",
+      tool,
+      message: `Codegraph is still building the index for this project (${progress.activity}${counts}, ${Math.round(progress.elapsedMs / 1e3)}s so far). The build continues in the background; call '${tool}' again to wait for it.`,
+      retryAfterMs: MCP_INDEX_RETRY_AFTER_MS,
+      waitedMs,
+      progress
+    });
+  };
+  return { startWarmup, buildsSettled, waitFor };
+}
+var DEFAULT_MCP_INDEX_WAIT_MS, MCP_INDEX_RETRY_AFTER_MS, MAX_MCP_INDEX_WAIT_MS, McpIndexBuildingError, ACTIVITY, CHECKING_ACTIVITY, MAX_READINESS_ROUNDS;
+var init_index_readiness = __esm({
+  "dist/mcp/index-readiness.js"() {
+    "use strict";
+    init_search();
+    init_session();
+    init_session_lifecycle();
+    init_cancellation();
+    init_stale_install();
+    DEFAULT_MCP_INDEX_WAIT_MS = 15e3;
+    MCP_INDEX_RETRY_AFTER_MS = 1e3;
+    MAX_MCP_INDEX_WAIT_MS = 2147483647;
+    McpIndexBuildingError = class extends Error {
+      result;
+      constructor(result) {
+        super(result.message);
+        this.name = "McpIndexBuildingError";
+        this.result = result;
+      }
+    };
+    ACTIVITY = {
+      index: "Building project index",
+      symbolGraph: "Building symbol graph",
+      queryIndex: "Building search index",
+      detailedGraph: "Building detailed symbol graph",
+      duplicates: "Preparing duplicate analysis"
+    };
+    CHECKING_ACTIVITY = "Checking the project for changed files";
+    MAX_READINESS_ROUNDS = 3;
+  }
+});
+
 // dist/mcp/handlers.js
 import fs42 from "node:fs/promises";
 import path96 from "node:path";
 function assertMcpSessionOptions(options) {
   assertNoPrebuiltSessionWithBuildOptions(options, "MCP server options");
 }
-function createCodegraphMcpSession(options, root) {
+function createCodegraphMcpSession(options, root, buildProgress) {
   assertMcpSessionOptions(options);
-  return options.session ?? createAgentSession({
+  if (options.session)
+    return options.session;
+  const onProgress = options.buildOptions?.onProgress;
+  const buildOptions = buildProgress ? {
+    ...options.buildOptions,
+    onProgress: (update) => {
+      buildProgress.record(update);
+      onProgress?.(update);
+    }
+  } : options.buildOptions;
+  return createAgentSession({
     root,
-    ...options.buildOptions ? { buildOptions: options.buildOptions } : {},
+    ...buildOptions ? { buildOptions } : {},
     freshness: { policy: "auto" }
   });
 }
@@ -131170,14 +132033,49 @@ function resolveWatchedCacheDirectory(root, buildOptions) {
     return void 0;
   }
 }
-function startCodegraphMcpWarmup(session, warmup, sessionProvidedExplicitly) {
-  const mode = warmup ?? (sessionProvidedExplicitly ? "off" : "base");
+function resolveStartupWarmupMode(warmup, sessionProvidedExplicitly) {
+  return warmup ?? (sessionProvidedExplicitly ? "off" : "base");
+}
+function rebuildSession(session, mode) {
   if (mode === "off")
     return void 0;
   if (mode === "symbols")
     return session.loadProject();
   return session.loadProject({ symbolGraph: "skip" });
 }
+function warmupNeeds(mode) {
+  if (mode === "off")
+    return [];
+  if (mode === "symbols")
+    return ["symbolGraph", "queryIndex", "detailedGraph"];
+  return ["symbolGraph", "queryIndex"];
+}
+function withIndexBudget(handlers, readiness, session) {
+  const budgeted = (tool, handler, needsOf, followUpOf) => async (request, signal) => {
+    const needs = needsOf(request);
+    if (needs)
+      await readiness.waitFor(tool, needs, signal, followUpOf?.(request));
+    return await handler(request, signal);
+  };
+  return {
+    ...handlers,
+    search: budgeted("search", handlers.search, searchNeeds),
+    explore: budgeted("explore", handlers.explore, exploreNeeds),
+    orient: budgeted("orient", handlers.orient, () => ["index"]),
+    workspace_symbols: budgeted("workspace_symbols", handlers.workspace_symbols, () => ["index"]),
+    impact: budgeted("impact", handlers.impact, () => ["index"]),
+    // Only a graph context reads the index; the bytes of a file come from disk.
+    get_file: budgeted("get_file", handlers.get_file, (request) => request.includeGraphContext ? ["index"] : void 0),
+    // A `review:` target builds its own report from git and reads no session build. Any other target reads the detailed
+    // symbol graph, and also the duplicate analysis of its duplicate context, except a SQL object, which has none, and
+    // a target that does not resolve, which fails at once. What the target resolves to is known once the detailed
+    // symbol graph is loaded, so that decision follows it.
+    packet_get: budgeted("packet_get", handlers.packet_get, (request) => request.target.startsWith("review:") ? [] : ["detailedGraph"], (request) => request.target.startsWith("review:") ? void 0 : async () => {
+      const { kind } = await resolveCodegraphTargetWithSession(session, { target: request.target });
+      return kind === "sql_object" || kind === "not_found" ? [] : ["duplicates"];
+    })
+  };
+}
 function withToolActivity(handlers, noteActivity) {
   return new Proxy(handlers, {
     get(target, property, receiver) {
@@ -131191,19 +132089,25 @@ function withToolActivity(handlers, noteActivity) {
     }
   });
 }
-async function createWarmedCodegraphMcpResources(options) {
+function createCodegraphMcpResources(options) {
   const root = path96.resolve(options.root);
   const sessionProvidedExplicitly = options.session !== void 0;
-  const { warmup, host, port, onHttpListen, watch, watchDebounceMs, watchMinRefreshIntervalMs, watchIdleMs, ...handlerOptions } = options;
+  const { warmup, host, port, onHttpListen, watch, watchDebounceMs, watchMinRefreshIntervalMs, watchIdleMs, mcpIndexWaitMs, ...handlerOptions } = options;
   void host;
   void port;
   void onHttpListen;
   assertMcpWatchMs("watchDebounceMs", watchDebounceMs);
   assertMcpWatchMs("watchMinRefreshIntervalMs", watchMinRefreshIntervalMs);
   assertMcpWatchMs("watchIdleMs", watchIdleMs);
-  const session = createCodegraphMcpSession(options, root);
-  await startCodegraphMcpWarmup(session, warmup, sessionProvidedExplicitly);
-  const { handlers, runExclusive } = createCodegraphMcpHandlersForSession({ ...handlerOptions, root }, session);
+  const indexWaitMs = assertMcpIndexWait(mcpIndexWaitMs ?? DEFAULT_MCP_INDEX_WAIT_MS);
+  const buildProgress = createMcpBuildProgress();
+  const session = createCodegraphMcpSession(options, root, buildProgress);
+  const readiness = createMcpIndexReadiness(session, {
+    waitMs: indexWaitMs,
+    warmup: warmupNeeds(resolveStartupWarmupMode(warmup, sessionProvidedExplicitly)),
+    progress: buildProgress
+  });
+  const { handlers, runExclusive } = createCodegraphMcpHandlersForSession({ ...handlerOptions, root }, session, readiness);
   const watcher = sessionProvidedExplicitly || watch === false ? void 0 : createWatchController(session, {
     root,
     runExclusive,
@@ -131216,10 +132120,12 @@ async function createWarmedCodegraphMcpResources(options) {
   return {
     handlers: watcher ? withToolActivity(handlers, watcher.noteActivity) : handlers,
     session,
-    closeWatcher: () => watcher?.close() ?? Promise.resolve()
+    closeWatcher: () => watcher?.close() ?? Promise.resolve(),
+    startWarmup: readiness.startWarmup,
+    buildsSettled: readiness.buildsSettled
   };
 }
-function createCodegraphMcpHandlersForSession(options, session) {
+function createCodegraphMcpHandlersForSession(options, session, readiness) {
   const root = path96.resolve(options.root);
   const readOnly = options.readOnly ?? true;
   const realRoot = fs42.realpath(root);
@@ -131672,20 +132578,30 @@ function createCodegraphMcpHandlersForSession(options, session) {
         ...DEFAULT_BOUNDED_IMPACT_BUDGETS
       });
     }),
-    review: async (request) => await withFreshness(async () => {
-      const report2 = await buildReviewReport(root, {
+    review: async (request, signal) => {
+      const reviewOptions = {
         ...options.buildOptions,
         gitBase: request.base,
         gitHead: request.head,
         ...request.reviewDepth !== void 0 ? { reviewDepth: request.reviewDepth } : {}
-      }, {
-        ...session.loadProject ? {
-          loadIndex: async () => (await session.loadProject({ symbolGraph: "skip" })).index
-        } : {},
-        ...session.loadDuplicateAnalysis ? { loadDuplicateAnalysis: session.loadDuplicateAnalysis } : {}
+      };
+      const changes = await collectReviewChanges(root, reviewOptions);
+      if (!changes.changedFiles.size) {
+        const report2 = await buildReviewReport(root, reviewOptions, { changes });
+        return { ...boundReviewReportForTransport(report2), freshness: { state: "fresh" } };
+      }
+      await readiness?.waitFor("review", ["index", "duplicates"], signal);
+      return await withFreshness(async () => {
+        const report2 = await buildReviewReport(root, reviewOptions, {
+          changes,
+          ...session.loadProject ? {
+            loadIndex: async () => (await session.loadProject({ symbolGraph: "skip" })).index
+          } : {},
+          ...session.loadDuplicateAnalysis ? { loadDuplicateAnalysis: session.loadDuplicateAnalysis } : {}
+        });
+        return boundReviewReportForTransport(report2);
       });
-      return boundReviewReportForTransport(report2);
-    })
+    }
   };
   const artifactHandlers = {
     query_sqlite: async (request, executionOptions) => {
@@ -131721,7 +132637,7 @@ function createCodegraphMcpHandlersForSession(options, session) {
         sqlitePath = configuredSqlitePath;
         sqliteOutDir = configuredSqliteOutDir;
         sqliteCanRefresh = configuredSqliteCanRefresh;
-        await startCodegraphMcpWarmup(session, warmup, true);
+        await rebuildSession(session, warmup);
       })();
       refreshPromise = refresh;
       try {
@@ -131766,8 +132682,14 @@ function createCodegraphMcpHandlersForSession(options, session) {
         session.invalidate();
     }
   };
+  const handlers = {
+    ...searchHandlers,
+    ...navigationHandlers,
+    ...reviewHandlers,
+    ...artifactHandlers
+  };
   return {
-    handlers: { ...searchHandlers, ...navigationHandlers, ...reviewHandlers, ...artifactHandlers },
+    handlers: readiness ? withIndexBudget(handlers, readiness, session) : handlers,
     runExclusive: withArtifactWriteLock
   };
 }
@@ -131796,6 +132718,7 @@ var init_handlers = __esm({
     init_impact();
     init_budgets();
     init_review2();
+    init_changes();
     init_types4();
     init_sqlite();
     init_bounds();
@@ -131812,6 +132735,7 @@ var init_handlers = __esm({
     init_runtime_identity();
     init_security();
     init_project_watcher();
+    init_index_readiness();
     MAX_MCP_FRESHNESS_CHANGED_FILES = 25;
     MAX_MCP_FRESHNESS_RETRIES = 3;
     SQLITE_ARTIFACT_STAT_CONCURRENCY = 64;
@@ -135209,6 +136133,10 @@ function createCodegraphMcpProtocolServerWithTracker(handlers, runtimeIdentity,
         } catch (error62) {
           if (error62 instanceof ProtocolError || toolCallAbort.signal.aborted)
             throw error62;
+          if (error62 instanceof McpIndexBuildingError) {
+            await emitFirstToolCallVisibility("info", 1, error62.result.message);
+            return toToolResult(error62.result);
+          }
           return toToolErrorResult(error62);
         }
       } finally {
@@ -135320,16 +136248,10 @@ function awaitMcpToolOperation(signal, operation, onSettled) {
 function withAbortSignal(signal, operation) {
   if (!signal)
     return operation;
-  const cancellationError = () => {
-    const reason = signal.reason;
-    if (reason instanceof Error && reason.name !== "AbortError")
-      return reason;
-    return new Error("MCP tool call was cancelled.");
-  };
   if (signal.aborted)
-    return Promise.reject(cancellationError());
+    return Promise.reject(mcpCancellationError(signal));
   const cancellation = Promise.withResolvers();
-  const onAbort = () => cancellation.reject(cancellationError());
+  const onAbort = () => cancellation.reject(mcpCancellationError(signal));
   signal.addEventListener("abort", onAbort, { once: true });
   return Promise.race([operation, cancellation.promise]).finally(() => signal.removeEventListener("abort", onAbort));
 }
@@ -135499,7 +136421,7 @@ function firstDuplicateFile(arguments_) {
   return files.find((file2) => typeof file2 === "string") ?? ".";
 }
 function toToolErrorResult(error62) {
-  const message = errorMessage(error62).replace(/(?:[A-Za-z]:)?[/\\][^'"\n]*?(?=(?:[/\\][^'"\n]*)?['"]|$)/g, "<path>");
+  const message = describeMcpRuntimeError(error62).replace(/(?:[A-Za-z]:)?[/\\][^'"\n]*?(?=(?:[/\\][^'"\n]*)?['"]|$)/g, "<path>");
   return { isError: true, content: [{ type: "text", text: message }] };
 }
 function getToolCallProgressToken(params) {
@@ -135521,12 +136443,19 @@ function parseMcpToolInput(schema, input2, toolName) {
     return parsed.data;
   throw new ProtocolError(ProtocolErrorCode.InvalidParams, formatMcpInvalidParams(toolName, parsed.error));
 }
+function describeReceivedValue(value) {
+  if (value === null)
+    return "null";
+  if (value === void 0)
+    return "nothing (the field is missing)";
+  return typeof value;
+}
 function createCodegraphMcpStdioTransport(input2, output2) {
   return new StdioServerTransport(createParseErrorReportingStdin(input2, output2), output2, {
     maxBufferSize: MAX_MCP_STDIO_FRAME_BYTES
   });
 }
-var DEFAULT_MCP_TOOL_TIMEOUT_MS, MAX_MCP_TOOL_TIMEOUT_MS, MAX_MCP_STDIO_FRAME_BYTES, DEFAULT_MCP_TOOL_CONCURRENCY, mcpProgressTokenSchema, toolCallMetaSchema, searchSchema, workspaceSymbolsSchema, renamePreviewSchema, refactorPlanSchema, callHierarchySchema, callsSchema, typeHierarchySchema, typeHierarchyUnifiedSchema, implementationsSchema, exploreSchema, orientSchema, packetGetSchema, getFileSchema, handleSchema, navigationSchema, refsSchema, fileGraphSchema, fileDepsUnifiedSchema, pathSchema, gitRangeSchema, reviewSchema, querySqliteSchema, refreshIndexSchema, artifactBuildSchema;
+var DEFAULT_MCP_TOOL_TIMEOUT_MS, MAX_MCP_TOOL_TIMEOUT_MS, MAX_MCP_STDIO_FRAME_BYTES, DEFAULT_MCP_TOOL_CONCURRENCY, mcpProgressTokenSchema, toolCallMetaSchema, searchSchema, workspaceSymbolsSchema, renamePreviewSchema, refactorPlanSchema, callHierarchySchema, callsSchema, typeHierarchySchema, typeHierarchyUnifiedSchema, implementationsSchema, exploreSchema, orientSchema, packetGetSchema, getFilePathSchema, getFileSchema, handleSchema, navigationSchema, refsSchema, fileGraphSchema, fileDepsUnifiedSchema, pathSchema, gitRangeSchema, reviewSchema, querySqliteSchema, refreshIndexSchema, artifactBuildSchema;
 var init_protocol = __esm({
   "dist/mcp/protocol.js"() {
     "use strict";
@@ -135541,7 +136470,10 @@ var init_protocol = __esm({
     init_tools();
     init_runtime();
     init_runtime_identity();
+    init_cancellation();
+    init_index_readiness();
     init_legacy_sessions();
+    init_stale_install();
     DEFAULT_MCP_TOOL_TIMEOUT_MS = 5 * 60 * 1e3;
     MAX_MCP_TOOL_TIMEOUT_MS = 2147483647;
     MAX_MCP_STDIO_FRAME_BYTES = 10 * 1024 * 1024;
@@ -135620,8 +136552,11 @@ var init_protocol = __esm({
       maxSnippets: external_exports.number().int().positive().max(50).optional(),
       maxDuplicates: external_exports.number().int().positive().max(20).optional()
     }).strict();
+    getFilePathSchema = external_exports.string({
+      error: (issue2) => `expected a project-relative file path string, received ${describeReceivedValue(issue2.input)}`
+    });
     getFileSchema = external_exports.object({
-      file: external_exports.string(),
+      file: getFilePathSchema,
       offset: external_exports.number().int().positive().optional(),
       limit: external_exports.number().int().positive().max(MAX_FILE_VIEW_LINES).optional(),
       maxBytes: external_exports.number().int().positive().max(MAX_FILE_VIEW_BYTES).optional(),
@@ -135762,7 +136697,7 @@ async function startCodegraphMcpHttpServer(options) {
   const configuredMcpToolTimeout = options.mcpToolTimeoutMs === void 0 ? DEFAULT_MCP_TOOL_TIMEOUT_MS : options.mcpToolTimeoutMs;
   const mcpToolTimeoutMs = assertMcpToolTimeout(configuredMcpToolTimeout);
   const host = options.host ?? "127.0.0.1", lifecycleHealth = await Promise.resolve().then(() => (init_lifecycle_health(), lifecycle_health_exports));
-  const { handlers, session, closeWatcher } = await createWarmedCodegraphMcpResources(options);
+  const { handlers, session, closeWatcher, startWarmup, buildsSettled } = createCodegraphMcpResources(options);
   const runtimeIdentity = options.runtimeIdentity ?? captureCodegraphRuntimeIdentity(getCurrentNativeBindingOrigin());
   const installedVersionChecker = createInstalledVersionChecker(runtimeIdentity, { warn: () => {
   } });
@@ -135796,6 +136731,7 @@ async function startCodegraphMcpHttpServer(options) {
       } finally {
         await protocolFactory.drain();
         await watcherClosed;
+        await buildsSettled();
         session.invalidate();
       }
     })();
@@ -135837,6 +136773,7 @@ async function startCodegraphMcpHttpServer(options) {
   const urlHost = formatHostForUrl(host);
   const url2 = `http://${urlHost}:${actualPort}${MCP_HTTP_PATH}`;
   allowedHostHeaders = buildAllowedHostHeaders(host, actualPort);
+  startWarmup();
   return {
     server,
     host,
@@ -135953,7 +136890,7 @@ async function serveCodegraphMcp(options) {
     await waitForHttpServerClose(started.server);
     return;
   }
-  const { handlers, session, closeWatcher } = await createWarmedCodegraphMcpResources(options);
+  const { handlers, session, closeWatcher, startWarmup, buildsSettled } = createCodegraphMcpResources(options);
   const runtimeIdentity = options.runtimeIdentity ?? captureCodegraphRuntimeIdentity(getCurrentNativeBindingOrigin());
   const protocolFactory = createCodegraphMcpProtocolFactory(handlers, runtimeIdentity, options.mcpToolConcurrency ?? DEFAULT_MCP_TOOL_CONCURRENCY, mcpToolTimeoutMs);
   const transport = createCodegraphMcpStdioTransport(process.stdin, process.stdout);
@@ -135964,6 +136901,7 @@ async function serveCodegraphMcp(options) {
       console.error(`[codegraph] MCP stdio error: ${error62.message}`);
     }
   });
+  startWarmup();
   const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_MCP_STDIO_IDLE_TIMEOUT_MS;
   try {
     await awaitStdioMcpLifecycle(handle, {
@@ -135977,6 +136915,7 @@ async function serveCodegraphMcp(options) {
     const watcherClosed = closeWatcher();
     await protocolFactory.drain();
     await watcherClosed;
+    await buildsSettled();
     session.invalidate();
   }
   process.exitCode = 0;
@@ -135997,6 +136936,7 @@ var init_server = __esm({
     init_protocol();
     init_http_transport();
     init_http_transport();
+    init_index_readiness();
     init_legacy_sessions();
   }
 });
@@ -136015,9 +136955,11 @@ async function handleMcpServeCommand(context) {
   const artifactPath = context.getOpt("--artifact");
   let port;
   let idleTimeoutMs;
+  let indexWaitMs;
   try {
     port = parseOptionalBoundedIntegerOption(context.getOpt("--port"), "--port", 0, 65535);
     idleTimeoutMs = parseOptionalBoundedIntegerOption(context.getOpt("--idle-timeout-ms"), "--idle-timeout-ms", 0, 24 * 60 * 60 * 1e3);
+    indexWaitMs = parseOptionalBoundedIntegerOption(context.getOpt("--index-wait-ms"), "--index-wait-ms", 0, MAX_MCP_INDEX_WAIT_MS);
   } catch (error62) {
     exitWithError(context, error62, 2);
   }
@@ -136045,6 +136987,7 @@ async function handleMcpServeCommand(context) {
     warmup,
     ...context.hasFlag("--no-watch") ? { watch: false } : {},
     ...idleTimeoutMs !== void 0 ? { idleTimeoutMs } : {},
+    ...indexWaitMs !== void 0 ? { mcpIndexWaitMs: indexWaitMs } : {},
     onHttpListen: (info) => {
       context.writeStderrLine(`Codegraph MCP HTTP server listening at ${info.url}`);
     }
@@ -136070,6 +137013,7 @@ var init_mcp = __esm({
   "dist/cli/mcp.js"() {
     "use strict";
     init_server();
+    init_index_readiness();
     init_help();
     init_options();
     init_context();
@@ -136898,6 +137842,7 @@ var init_server2 = __esm({
         "--host",
         "--ignore-glob",
         "--include-glob",
+        "--index-wait-ms",
         "--port",
         "--resolution-hint",
         "--startup-timeout-ms",
@@ -136928,6 +137873,7 @@ var init_server2 = __esm({
       "--cache-dir",
       "--include-glob",
       "--ignore-glob",
+      "--index-wait-ms",
       "--resolution-hint",
       "--threads"
     ];
@@ -137499,7 +138445,7 @@ __export(graph_exports, {
 });
 import fs44 from "node:fs";
 import fsp43 from "node:fs/promises";
-import { performance as performance15 } from "node:perf_hooks";
+import { performance as performance16 } from "node:perf_hooks";
 function resolveGraphCacheMode(cache) {
   return cache ?? "disk";
 }
@@ -137636,11 +138582,11 @@ function stabilizeSymbolGraph(graph) {
 }
 async function handleGraphCommand(context) {
   const commandReport = context.reportEnabled ? { command: "graph", timings: {} } : void 0;
-  const commandStart = performance15.now();
-  const resolveStart = performance15.now();
+  const commandStart = performance16.now();
+  const resolveStart = performance16.now();
   const files = await context.resolveFiles();
   if (commandReport) {
-    commandReport.timings.resolveFilesMs = Math.round(performance15.now() - resolveStart);
+    commandReport.timings.resolveFilesMs = Math.round(performance16.now() - resolveStart);
   }
   const hasExplicitSymbolFlag = context.hasFlag("--symbols") || context.hasFlag("--symbols-only") || context.hasFlag("--symbols-detailed");
   const outputArg = context.getOpt("--output") ?? context.getOpt("--out");
@@ -137682,7 +138628,7 @@ async function handleGraphCommand(context) {
   const finalizeReport = async () => {
     if (!commandReport)
       return;
-    commandReport.timings.commandMs = Math.round(performance15.now() - commandStart);
+    commandReport.timings.commandMs = Math.round(performance16.now() - commandStart);
     commandReport.timings.totalMs = commandReport.timings.commandMs;
     await context.writeCommandReport(commandReport, context.reportFile);
   };
@@ -137915,7 +138861,7 @@ var cli_exports = {};
 __export(cli_exports, {
   handleIndexCommand: () => handleIndexCommand
 });
-import { performance as performance16 } from "node:perf_hooks";
+import { performance as performance17 } from "node:perf_hooks";
 function formatIndexOutput(output2) {
   const lines = [`Indexed ${output2.files} file(s) with ${output2.edges} edge(s).`];
   if (!isAnalysisComplete(output2.analysis)) {
@@ -137933,16 +138879,16 @@ function formatIndexOutput(output2) {
 async function handleIndexCommand(context) {
   const verbose = context.hasFlag("--verbose");
   const commandReport = context.reportEnabled ? { command: "index", timings: {} } : void 0;
-  const commandStart = performance16.now();
+  const commandStart = performance17.now();
   const shouldWriteManifest = !context.includeRootsAbs.length && !context.gitBase && !context.changedSince;
   const hasCliDiscoveryGlob = context.getOpt("--include-glob") !== void 0 || context.getOpt("--ignore-glob") !== void 0;
   const needsResolvedFiles = !shouldWriteManifest || hasCliDiscoveryGlob;
   let files = [];
   if (needsResolvedFiles) {
-    const resolveStart = performance16.now();
+    const resolveStart = performance17.now();
     files = await context.resolveFiles();
     if (commandReport) {
-      commandReport.timings.resolveFilesMs = Math.round(performance16.now() - resolveStart);
+      commandReport.timings.resolveFilesMs = Math.round(performance17.now() - resolveStart);
     }
   }
   const threads = parseNonNegativeIntegerOption(context.getOpt("--threads"), "--threads", 0);
@@ -138003,7 +138949,7 @@ async function handleIndexCommand(context) {
     }
   }
   if (commandReport) {
-    commandReport.timings.commandMs = Math.round(performance16.now() - commandStart);
+    commandReport.timings.commandMs = Math.round(performance17.now() - commandStart);
     commandReport.timings.totalMs = commandReport.timings.commandMs;
     await context.writeCommandReport(commandReport, context.reportFile);
   }
@@ -138810,6 +139756,7 @@ async function cleanupTempDir(dir) {
 async function resolveGitCommit(root, ref) {
   const rev = `${ref}^{commit}`;
   const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "--quiet", "--end-of-options", rev], {
+    windowsHide: true,
     cwd: root,
     env: process.env
   });
@@ -138824,9 +139771,16 @@ async function materializeGitRef(root, ref, prefix) {
     return { root };
   const tempRoot = await fsp45.mkdtemp(path101.join(os12.tmpdir(), prefix));
   try {
-    await execFileAsync("git", ["clone", "--quiet", "--no-checkout", root, tempRoot], { env: process.env });
+    await execFileAsync("git", ["clone", "--quiet", "--no-checkout", root, tempRoot], {
+      windowsHide: true,
+      env: process.env
+    });
     const checkoutCommit = await resolveGitCommit(root, checkoutRef);
-    await execFileAsync("git", ["checkout", "--quiet", checkoutCommit], { cwd: tempRoot, env: process.env });
+    await execFileAsync("git", ["checkout", "--quiet", checkoutCommit], {
+      windowsHide: true,
+      cwd: tempRoot,
+      env: process.env
+    });
     return { root: tempRoot, cleanup: tempRoot };
   } catch (error62) {
     await cleanupTempDir(tempRoot);
@@ -139066,6 +140020,8 @@ function getOptionWithProfileDefault(context, optionName2, profile, cleanupDefau
 function parseDuplicateDetectionOptions(context, profile) {
   const minConfidence = parseConfidenceOption(getOptionWithProfileDefault(context, "--min-confidence", profile, "medium"));
   const minTokens = parsePositiveIntegerOption(getOptionWithProfileDefault(context, "--min-tokens", profile, "80"), "--min-tokens", 40);
+  const maxCandidatePairsRaw = context.getOpt("--max-candidate-pairs");
+  const maxCandidatePairs = maxCandidatePairsRaw === void 0 ? void 0 : parseBoundedIntegerOption(maxCandidatePairsRaw, "--max-candidate-pairs", DEFAULT_MAX_CANDIDATE_PAIRS, 1, MAX_CANDIDATE_PAIRS_LIMIT);
   const options = {
     projectRoot: context.projectRootFs,
     files: context.files,
@@ -139074,6 +140030,7 @@ function parseDuplicateDetectionOptions(context, profile) {
     minTokens,
     maxTokens: parsePositiveIntegerOption(context.getOpt("--max-tokens"), "--max-tokens", 800),
     maxBucketSize: parsePositiveIntegerOption(context.getOpt("--max-bucket-size"), "--max-bucket-size", 200),
+    ...maxCandidatePairs !== void 0 ? { maxCandidatePairs } : {},
     ...context.hasFlag("--include-same-file") ? { includeSameFile: true } : {},
     ...context.hasFlag("--include-small") ? { includeSmall: true } : {},
     ...context.hasFlag("--raw-pairs") ? { includeRawPairs: true } : {}
@@ -139293,6 +140250,10 @@ function formatPrettyDuplicates(result, sortMode, options) {
     `Candidate pairs compared: ${result.stats.comparedPairs}/${result.stats.candidatePairs}`,
     "Family annotations are heuristic and derived from the displayed duplicate pair."
   ];
+  const budget = result.stats.candidatePairBudget;
+  if (budget) {
+    lines.push(`Candidate pair limit reached: kept ${budget.limit}, skipped ${budget.skipped}. Results are partial; raise --max-candidate-pairs or lower --max-bucket-size.`);
+  }
   const omitted = formatOmittedCounts(result);
   if (result.filteredCounts?.cleanupProfileGroups) {
     lines.push(`Filtered by cleanup profile: ${result.filteredCounts.cleanupProfileGroups}`);
@@ -139397,6 +140358,10 @@ async function handleDuplicatesCommand(context) {
       const boundedLimit = Math.max(requestedLimit, Math.min(ACTIONABILITY_SORT_MAX_CANDIDATES, requestedLimit * ACTIONABILITY_SORT_OVERFETCH_MULTIPLIER));
       options.limit = boundedLimit;
     }
+    if (context.progressHandler)
+      options.onProgress = context.progressHandler;
+    if (context.progressStartedAt !== void 0)
+      options.progressStartedAt = context.progressStartedAt;
     const index = await context.loadCurrentIndex();
     const result = await findDuplicates(index, options);
     const sorted = sortedResult(result, sortMode, requestedLimit, profile);
@@ -140962,7 +141927,7 @@ var review_exports = {};
 __export(review_exports, {
   handleReviewCommand: () => handleReviewCommand
 });
-import { performance as performance17 } from "node:perf_hooks";
+import { performance as performance18 } from "node:perf_hooks";
 import path102 from "node:path";
 function parseReviewDepth(value) {
   if (value === "minimal" || value === "standard" || value === "deep") {
@@ -141154,7 +142119,7 @@ async function collectReviewDuplicateSummary(input2) {
   });
 }
 async function handleReviewCommand(context) {
-  const commandStart = performance17.now();
+  const commandStart = performance18.now();
   const changedSince = context.getOpt("--changed-since");
   const base = context.getOpt("--base") ?? (changedSince === void 0 ? "HEAD" : void 0);
   const head = context.getOpt("--head") ?? (changedSince === void 0 ? "WORKTREE" : void 0);
@@ -141246,7 +142211,7 @@ async function handleReviewCommand(context) {
     context.writeJSONLine(report2);
   }
   if (context.commandReport) {
-    context.commandReport.timings.commandMs = Math.round(performance17.now() - commandStart);
+    context.commandReport.timings.commandMs = Math.round(performance18.now() - commandStart);
     context.commandReport.timings.totalMs = context.commandReport.timings.commandMs;
     await context.writeCommandReport(context.commandReport, context.reportFile);
   }
@@ -141561,7 +142526,7 @@ __export(inspect_exports, {
   handleHotspotsCommand: () => handleHotspotsCommand,
   handleInspectCommand: () => handleInspectCommand
 });
-import { performance as performance18 } from "node:perf_hooks";
+import { performance as performance19 } from "node:perf_hooks";
 import fs46 from "node:fs";
 import path103 from "node:path";
 function defaultCacheIndexPath(projectRoot, cacheDir, cacheLocation) {
@@ -141821,18 +142786,18 @@ async function buildInspectReport(projectRoot, includeRoots, files, discovery, g
   };
 }
 async function handleInspectCommand(context) {
-  const commandStart = performance18.now();
+  const commandStart = performance19.now();
   const cache = parseCacheModeOption(context.getOpt("--cache"));
   const limit = parsePositiveIntegerOption(context.getOpt("--limit"), "--limit", 20);
-  const resolveStart = performance18.now();
+  const resolveStart = performance19.now();
   const files = await context.resolveFilesFromRoots();
   if (context.commandReport) {
-    context.commandReport.timings.resolveFilesMs = Math.round(performance18.now() - resolveStart);
+    context.commandReport.timings.resolveFilesMs = Math.round(performance19.now() - resolveStart);
   }
   const report2 = await buildInspectReport(context.projectRootFs, context.includeRootsAbs, files, context.discoveryOptions, context.graphOptions, context.languageExtensions, cache, context.getOpt("--cache-dir"), context.cacheLocation, context.workerOpts, context.progressHandler, context.commandReport?.index, limit, context.hasFlag("--duplicates"), context.writeStderrLine);
   writeCliOutput(context, report2, formatInspectReport);
   if (context.commandReport && context.writeCommandReport) {
-    context.commandReport.timings.commandMs = Math.round(performance18.now() - commandStart);
+    context.commandReport.timings.commandMs = Math.round(performance19.now() - commandStart);
     context.commandReport.timings.totalMs = context.commandReport.timings.commandMs;
     await context.writeCommandReport(context.commandReport, context.reportFile);
   }
@@ -141886,6 +142851,7 @@ var init_inspect = __esm({
 });
 
 // dist/cli/command-table.js
+import { performance as performance20 } from "node:perf_hooks";
 function agentIo(ctx) {
   return {
     positionals: ctx.parsed.positionals,
@@ -142358,6 +143324,7 @@ var init_command_table = __esm({
       duplicates: {
         stage: "project",
         run: async (ctx) => {
+          const startedAt = performance20.now();
           const files = await ctx.resolveFiles();
           const { handleDuplicatesCommand: handleDuplicatesCommand2 } = await Promise.resolve().then(() => (init_duplicates2(), duplicates_exports));
           await handleDuplicatesCommand2({
@@ -142366,6 +143333,8 @@ var init_command_table = __esm({
             getOpt: ctx.getOpt,
             hasFlag: ctx.hasFlag,
             loadCurrentIndex: ctx.createDuplicateIndexLoader(),
+            progressHandler: ctx.progressHandler,
+            progressStartedAt: startedAt,
             writeJSONLine,
             writeStdoutLine,
             writeStderrLine,
@@ -143481,7 +144450,7 @@ function openViewerUrl(url2) {
     command = "xdg-open";
     args = [url2];
   }
-  const child = spawn5(command, args, { detached: true, stdio: "ignore" });
+  const child = spawn5(command, args, { windowsHide: true, detached: true, stdio: "ignore" });
   child.once("error", () => {
   });
   child.unref();