@lzehrung/codegraph 2.3.11 → 2.3.13

package/dist/bin/cli.js

@@ -13552,10 +13552,12 @@ __export(git_exports, {
   isGitPathTracked: () => isGitPathTracked,
   isGitProjectRootIgnored: () => isGitProjectRootIgnored,
   isGitRepo: () => isGitRepo,
+  isGitTimeoutError: () => isGitTimeoutError,
   isGitWorktreeSentinel: () => isGitWorktreeSentinel,
   listChangedFiles: () => listChangedFiles,
   listGitExcludeFiles: () => listGitExcludeFiles,
   listGitIgnoreFiles: () => listGitIgnoreFiles,
+  listGitStageSpecialPaths: () => listGitStageSpecialPaths,
   listGitSubmoduleDirectories: () => listGitSubmoduleDirectories,
   listTrackedFiles: () => listTrackedFiles,
   listUntrackedFiles: () => listUntrackedFiles,
@@ -13604,8 +13606,9 @@ function decodeGitPath(rawPath) {
   }
   return Buffer.from(bytes).toString("utf8");
 }
-function setGitExecutableForTests(executable) {
+function setGitExecutableForTests(executable, prefixArgs = []) {
   gitExecutableForTests = executable;
+  gitExecutablePrefixArgsForTests = executable ? [...prefixArgs] : [];
 }
 function clearGitRepositoryCheckCacheForTests() {
   gitRepositoryChecks.clear();
@@ -13672,12 +13675,13 @@ async function runGit(projectRoot, args, options) {
   const timeoutMs = resolveGitTimeoutMs(options?.timeoutMs);
   const maxBuffer = options?.maxBuffer ?? 64 * 1024 * 1024;
   const executable = gitExecutableForTests ?? "git";
+  const childArgs = gitExecutablePrefixArgsForTests.length ? [...gitExecutablePrefixArgsForTests, ...args] : args;
   const signal = options?.signal;
   if (signal?.aborted) {
     throw createGitError(projectRoot, args, new Error("aborted before start"));
   }
   return await new Promise((resolve, reject) => {
-    const child = spawn(executable, args, {
+    const child = spawn(executable, childArgs, {
       cwd: projectRoot,
       env: process.env,
       stdio: [options?.input !== void 0 ? "pipe" : "ignore", "pipe", "pipe"],
@@ -13994,7 +13998,7 @@ async function listTrackedFiles(projectRoot, opts) {
 async function listGitIgnoreFiles(projectRoot, opts) {
   if (!(opts?.gitAvailable ?? true))
     return [];
-  const pathspec = [".gitignore", ":(glob)**/.gitignore"];
+  const pathspec = [".gitignore", ":(glob)**/.gitignore", ...opts?.excludePathspecs ?? []];
   const commands = [
     ["ls-files", "--cached", "-z", "--", ...pathspec],
     ["ls-files", "--others", "--exclude-standard", "-z", "--", ...pathspec],
@@ -14017,31 +14021,49 @@ async function listGitIgnoreFiles(projectRoot, opts) {
   }
   return Array.from(new Set(out));
 }
-async function listGitSubmoduleDirectories(projectRoot, opts) {
+function parseGitStageSpecialPaths(projectRoot, stdout) {
+  const gitlinks = [];
+  const symlinks = [];
+  for (const record2 of stdout.split("\0").filter(Boolean)) {
+    const tabIndex = record2.indexOf("	");
+    if (tabIndex < 0)
+      continue;
+    const rel = record2.slice(tabIndex + 1);
+    if (!rel)
+      continue;
+    const abs = normalizePath(path8.resolve(projectRoot, rel));
+    if (record2.startsWith("160000 "))
+      gitlinks.push(abs);
+    else if (record2.startsWith("120000 "))
+      symlinks.push(abs);
+  }
+  return { gitlinks, symlinks };
+}
+async function listGitStageSpecialPaths(projectRoot, opts) {
   if (!(opts?.gitAvailable ?? true))
-    return [];
+    return { gitlinks: [], symlinks: [] };
   const args = ["ls-files", "--stage", "-z"];
   try {
     const { stdout } = await runGit(projectRoot, args, { maxBuffer: 64 * 1024 * 1024 });
-    const direct = [];
-    for (const record2 of stdout.split("\0").filter(Boolean)) {
-      if (!record2.startsWith("160000 "))
-        continue;
-      const tabIndex = record2.indexOf("	");
-      if (tabIndex < 0)
-        continue;
-      const rel = record2.slice(tabIndex + 1);
-      if (rel)
-        direct.push(normalizePath(path8.resolve(projectRoot, rel)));
-    }
-    if (!opts?.recurse || !direct.length)
-      return Array.from(new Set(direct));
-    const nested = await Promise.all(direct.map(async (directory) => await listGitSubmoduleDirectories(directory, opts)));
-    return Array.from(/* @__PURE__ */ new Set([...direct, ...nested.flat()]));
+    const direct = parseGitStageSpecialPaths(projectRoot, stdout);
+    if (!opts?.recurse || !direct.gitlinks.length) {
+      return {
+        gitlinks: Array.from(new Set(direct.gitlinks)),
+        symlinks: Array.from(new Set(direct.symlinks))
+      };
+    }
+    const nested = await Promise.all(direct.gitlinks.map(async (directory) => await listGitStageSpecialPaths(directory, opts)));
+    return {
+      gitlinks: Array.from(/* @__PURE__ */ new Set([...direct.gitlinks, ...nested.flatMap((entry) => entry.gitlinks)])),
+      symlinks: Array.from(/* @__PURE__ */ new Set([...direct.symlinks, ...nested.flatMap((entry) => entry.symlinks)]))
+    };
   } catch (error51) {
     throw createGitError(projectRoot, args, error51);
   }
 }
+async function listGitSubmoduleDirectories(projectRoot, opts) {
+  return (await listGitStageSpecialPaths(projectRoot, opts)).gitlinks;
+}
 async function listGitExcludeFiles(projectRoot, opts) {
   if (!(opts?.gitAvailable ?? true))
     return [];
@@ -14140,6 +14162,10 @@ async function getUnifiedDiff(projectRoot, opts) {
     throw createGitError(projectRoot, args, error51);
   }
 }
+function isGitTimeoutError(error51) {
+  const detail = error51 instanceof Error ? error51.message : stringifyUnknown(error51);
+  return /timed out after \d+ms/i.test(detail);
+}
 function createGitError(projectRoot, args, error51) {
   let detail = stringifyUnknown(error51);
   if (typeof error51 === "object" && error51 !== null && "stderr" in error51 && typeof error51.stderr === "string" && error51.stderr.trim()) {
@@ -14149,7 +14175,7 @@ function createGitError(projectRoot, args, error51) {
   }
   return new Error(`git ${args.join(" ")} failed in ${projectRoot}: ${detail}`);
 }
-var DEFAULT_GIT_TIMEOUT_MS, gitRepositoryChecks, gitDiscoveryRootIgnoredChecks, gitExcludeFileChecks, MAX_GIT_HASH_OBJECT_ARGUMENT_BYTES, gitExecutableForTests, GIT_QUOTED_PATH_SINGLE_BYTE_ESCAPES, UNSAFE_REVISION_CHARACTERS;
+var DEFAULT_GIT_TIMEOUT_MS, gitRepositoryChecks, gitDiscoveryRootIgnoredChecks, gitExcludeFileChecks, MAX_GIT_HASH_OBJECT_ARGUMENT_BYTES, gitExecutableForTests, gitExecutablePrefixArgsForTests, GIT_QUOTED_PATH_SINGLE_BYTE_ESCAPES, UNSAFE_REVISION_CHARACTERS;
 var init_git = __esm({
   "dist/util/git.js"() {
     "use strict";
@@ -14162,6 +14188,7 @@ var init_git = __esm({
     gitExcludeFileChecks = /* @__PURE__ */ new Map();
     MAX_GIT_HASH_OBJECT_ARGUMENT_BYTES = 24 * 1024;
     gitExecutableForTests = null;
+    gitExecutablePrefixArgsForTests = [];
     GIT_QUOTED_PATH_SINGLE_BYTE_ESCAPES = {
       a: 7,
       b: 8,
@@ -14194,6 +14221,13 @@ __export(projectFiles_exports, {
 import fs6 from "node:fs";
 import fsp5 from "node:fs/promises";
 import path9 from "node:path";
+import { performance as performance2 } from "node:perf_hooks";
+function emitDiscoveryActivity(report, activity, current = 0, total = 0) {
+  report?.({ activity, current, total });
+}
+function emitDiscoveryTiming(record2, name, startedAt) {
+  record2?.({ name, ms: Math.round(performance2.now() - startedAt) });
+}
 function createPathCheckProgressReporter(total, onProgress) {
   onProgress?.(0, total);
   let completed = 0;
@@ -14209,13 +14243,49 @@ function isPresent(value) {
 function normalizeGlobPattern(globPattern) {
   return globPattern.trim().replace(/\\/g, "/");
 }
+function defaultIgnoreGitExcludePathspecs(includeGlobs = []) {
+  const activeIgnores = includeGlobs.length ? DEFAULT_PROJECT_FILE_IGNORES.filter((ignoreGlob) => !isIgnoreGlobReopenedByIncludes(ignoreGlob, includeGlobs)) : DEFAULT_PROJECT_FILE_IGNORES;
+  return activeIgnores.map((globPattern) => `:(exclude,glob)${normalizeGlobPattern(globPattern)}`);
+}
+function couldBeDirectorySymlink(filePath) {
+  const basename2 = path9.posix.basename(normalizePath(filePath));
+  if (DIRECTORY_METADATA_BASENAMES.has(basename2.toLowerCase()))
+    return true;
+  const extension = path9.posix.extname(basename2);
+  if (!extension)
+    return true;
+  return DIRECTORY_METADATA_EXTENSIONS.has(extension.toLowerCase());
+}
+function globLiteralPrefix(globPattern) {
+  const prefix = [];
+  let seenLiteral = false;
+  for (const segment of globPattern.split("/")) {
+    if (!segment)
+      continue;
+    if (!seenLiteral && segment === "**")
+      continue;
+    if (segment.includes("*") || segment.includes("?"))
+      break;
+    seenLiteral = true;
+    prefix.push(segment);
+  }
+  return prefix;
+}
+function isSegmentPrefix(prefix, pathSegments) {
+  if (!prefix.length || prefix.length > pathSegments.length)
+    return false;
+  return prefix.every((segment, index) => pathSegments[index] === segment);
+}
 function isIgnoreGlobReopenedByIncludes(ignoreGlob, includeGlobs) {
-  const literalSegments = ignoreGlob.split("/").filter((segment) => segment && !segment.includes("*"));
-  if (!literalSegments.length)
+  const ignoreLiterals = ignoreGlob.split("/").filter((segment) => segment && !segment.includes("*"));
+  if (!ignoreLiterals.length)
     return false;
   return includeGlobs.some((includeGlob) => {
     const includeSegments = includeGlob.split("/");
-    return literalSegments.every((segment) => includeSegments.includes(segment));
+    if (ignoreLiterals.every((segment) => includeSegments.includes(segment)))
+      return true;
+    const includePrefix = globLiteralPrefix(includeGlob);
+    return isSegmentPrefix(includePrefix, ignoreLiterals) || isSegmentPrefix(ignoreLiterals, includePrefix);
   });
 }
 function isLocationIndependentGlob(globPattern) {
@@ -14428,7 +14498,7 @@ function collectCandidateAncestorDirectories(root, files) {
   }
   return directories;
 }
-async function findGitIgnoreSources(sourceRoots) {
+async function findGitIgnoreSources(sourceRoots, excludePathspecs = defaultIgnoreGitExcludePathspecs()) {
   const roots = Array.from(new Map(sourceRoots.map(({ path: sourceRoot, repositoryRoot }) => [
     fileIdentityKey(sourceRoot),
     { path: normalizePath(sourceRoot), repositoryRoot: normalizePath(repositoryRoot) }
@@ -14436,7 +14506,7 @@ async function findGitIgnoreSources(sourceRoots) {
   const sources = [];
   for (const { path: sourceRoot, repositoryRoot } of roots) {
     const [gitignoreFiles, excludeFiles] = await Promise.all([
-      listGitIgnoreFiles(sourceRoot),
+      listGitIgnoreFiles(sourceRoot, { excludePathspecs }),
       listGitExcludeFiles(sourceRoot)
     ]);
     sources.push(...gitignoreFiles.map((file2) => ({
@@ -14452,7 +14522,9 @@ async function findGitIgnoreSources(sourceRoots) {
   }
   return sources;
 }
-async function listGitCandidateFiles(root, logLevel) {
+async function listGitCandidateFiles(root, logLevel, opts) {
+  let gitListStart;
+  let gitIgnoreStart;
   try {
     const realRoot = normalizePath(await fsp5.realpath(root));
     const gitRoot = await isGitRepo(root) ? root : realRoot;
@@ -14463,11 +14535,15 @@ async function listGitCandidateFiles(root, logLevel) {
     const gitRepositoryRoot = await getGitRepositoryRoot(gitRoot);
     if (!gitRepositoryRoot)
       return null;
-    const [tracked, untracked, submoduleDirectories] = await Promise.all([
+    emitDiscoveryActivity(opts?.onDiscoveryProgress, "Listing Git files");
+    const listStartedAt = performance2.now();
+    gitListStart = listStartedAt;
+    const [tracked, untracked, stageSpecial] = await Promise.all([
       listTrackedFiles(gitRoot, { recurseSubmodules: true, ...logLevel === void 0 ? {} : { logLevel } }),
       listUntrackedFiles(gitRoot, { respectGitignore: true }),
-      listGitSubmoduleDirectories(gitRoot, { recurse: true })
+      listGitStageSpecialPaths(gitRoot, { recurse: true })
     ]);
+    const submoduleDirectories = stageSpecial.gitlinks;
     const submoduleRoots = await Promise.all(submoduleDirectories.map(async (logicalPath) => ({
       logicalPath: normalizePath(logicalPath),
       physicalPath: normalizePath(await fsp5.realpath(logicalPath).catch(() => logicalPath))
@@ -14476,6 +14552,8 @@ async function listGitCandidateFiles(root, logLevel) {
     const rawFiles = Array.from(/* @__PURE__ */ new Set([...tracked, ...untracked, ...submoduleUntracked.flat()])).sort();
     const needsLogicalRemap = normalizePath(gitRoot) !== normalizePath(root);
     const files = Array.from(new Set(rawFiles.map((file2) => needsLogicalRemap && isFilePathWithinRoot(realRoot, file2) ? normalizePath(path9.resolve(root, path9.relative(realRoot, file2))) : normalizePath(file2)))).sort();
+    const remapGitPath = (file2) => needsLogicalRemap && isFilePathWithinRoot(realRoot, file2) ? normalizePath(path9.resolve(root, path9.relative(realRoot, file2))) : normalizePath(file2);
+    const symlinkCandidatePaths = Array.from(/* @__PURE__ */ new Set([...stageSpecial.symlinks.map(remapGitPath), ...files.filter((file2) => couldBeDirectorySymlink(file2))])).sort();
     const gitignoreRoots = [gitRepositoryRoot, ...submoduleRoots.map(({ physicalPath }) => physicalPath)].map(normalizePath);
     const sourceRoots = [
       { path: root, repositoryRoot: gitRepositoryRoot },
@@ -14486,14 +14564,35 @@ async function listGitCandidateFiles(root, logLevel) {
         { path: physicalPath, repositoryRoot: physicalPath }
       ])
     ];
+    emitDiscoveryTiming(opts?.onDiscoveryTiming, "git-list", listStartedAt);
+    gitListStart = void 0;
+    emitDiscoveryActivity(opts?.onDiscoveryProgress, "Listing Git files", files.length, files.length);
+    emitDiscoveryActivity(opts?.onDiscoveryProgress, "Listing Git ignore files");
+    const ignoreStartedAt = performance2.now();
+    gitIgnoreStart = ignoreStartedAt;
+    const gitignoreFiles = await findGitIgnoreSources(sourceRoots, defaultIgnoreGitExcludePathspecs(opts?.includeGlobs ?? []));
+    emitDiscoveryTiming(opts?.onDiscoveryTiming, "git-ignore", ignoreStartedAt);
+    gitIgnoreStart = void 0;
+    emitDiscoveryActivity(opts?.onDiscoveryProgress, "Listing Git ignore files", gitignoreFiles.length, gitignoreFiles.length);
     return {
       files,
-      gitignoreFiles: await findGitIgnoreSources(sourceRoots),
+      symlinkCandidatePaths,
+      gitignoreFiles,
       gitignoreRoots,
       gitignoreAliases: sourceRoots
     };
   } catch (error51) {
-    logWithLevel(logLevel, "debug", `Git discovery unavailable for ${root}: ${stringifyUnknown(error51)}`);
+    const listingTimedOut = isGitTimeoutError(error51) && (gitIgnoreStart !== void 0 || gitListStart !== void 0);
+    if (gitIgnoreStart !== void 0) {
+      emitDiscoveryTiming(opts?.onDiscoveryTiming, "git-ignore", gitIgnoreStart);
+    } else if (gitListStart !== void 0) {
+      emitDiscoveryTiming(opts?.onDiscoveryTiming, "git-list", gitListStart);
+    }
+    if (listingTimedOut) {
+      logWithLevel(logLevel, "warn", "Warning: Git listing timed out; scanning the filesystem instead. Ignore large untracked trees in .gitignore to keep discovery fast.");
+    } else {
+      logWithLevel(logLevel, "debug", `Git discovery unavailable for ${root}: ${stringifyUnknown(error51)}`);
+    }
     return null;
   }
 }
@@ -14522,7 +14621,11 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
     const useGitignore = options?.useGitignore ?? true;
     const realRoot = await fsp5.realpath(root);
     const attemptedGitCandidates = useGitignore && options?.gitignoreRoot === void 0 && normalizePath(realRoot) === normalizePath(root);
-    const gitCandidates = attemptedGitCandidates ? await listGitCandidateFiles(root, options?.logLevel) : null;
+    const gitDiscoveryCallbacks = {
+      ...options?.onDiscoveryProgress ? { onDiscoveryProgress: options.onDiscoveryProgress } : {},
+      ...options?.onDiscoveryTiming ? { onDiscoveryTiming: options.onDiscoveryTiming } : {}
+    };
+    const gitCandidates = attemptedGitCandidates ? await listGitCandidateFiles(root, options?.logLevel, { includeGlobs, ...gitDiscoveryCallbacks }) : null;
     if (attemptedGitCandidates) {
       options?.onGitCandidatesDiscovered?.(gitCandidates);
     }
@@ -14533,13 +14636,22 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
       const gitignoreRoot = options?.gitignoreRoot ? await ensureDirectoryReadable(options.gitignoreRoot, "Gitignore root") : root;
       gitignoreIndex = await loadGitignoreIndexForRootAliases(gitignoreRoot);
     }
-    const files = gitCandidates ? gitCandidates.files : await (0, import_fast_glob2.default)(patterns, {
-      cwd: root,
-      absolute: true,
-      dot: true,
-      followSymbolicLinks: false,
-      ignore: fastGlobIgnoreGlobs
-    });
+    let files;
+    if (gitCandidates) {
+      files = gitCandidates.files;
+    } else {
+      emitDiscoveryActivity(options?.onDiscoveryProgress, "Scanning project files");
+      const scanStart = performance2.now();
+      files = await (0, import_fast_glob2.default)(patterns, {
+        cwd: root,
+        absolute: true,
+        dot: true,
+        followSymbolicLinks: false,
+        ignore: fastGlobIgnoreGlobs
+      });
+      emitDiscoveryTiming(options?.onDiscoveryTiming, "filesystem-scan", scanStart);
+      emitDiscoveryActivity(options?.onDiscoveryProgress, "Scanning project files", files.length, files.length);
+    }
     const includedOverrideFiles = includeGlobs.length && !gitCandidates ? await (0, import_fast_glob2.default)(translateGlobRootIgnoreGlobsForScanRoot(root, globRoot, includeGlobs), {
       cwd: root,
       absolute: true,
@@ -14551,7 +14663,7 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
     const reportSourcePathChecks = options?.onDiscoveryProgress ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking source file paths", current, total }) : void 0;
     const symlinkOptions = {
       globRoot,
-      ...gitCandidates ? { candidatePaths: gitCandidates.files } : {},
+      ...gitCandidates ? { candidatePaths: gitCandidates.symlinkCandidatePaths } : {},
       ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
       ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {},
       ...reportSourceSymlinkChecks ? { onPathCheckProgress: reportSourceSymlinkChecks } : {}
@@ -14663,7 +14775,9 @@ async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
       const relativePath3 = normalizePath(path9.relative(root, candidatePath));
       if (!isRelativePathInside(relativePath3))
         return false;
-      return !ignoreMatchers.some((matcher) => matcher(relativePath3));
+      if (ignoreMatchers.some((matcher) => matcher(relativePath3)))
+        return false;
+      return true;
     });
     const discovered2 = await verifySafeSymlinkDirectories(root, realRoot, candidatePaths, options.onPathCheckProgress);
     options.onSymlinkDirectoriesDiscovered?.(discovered2, "git-candidates");
@@ -14781,7 +14895,10 @@ async function discoverProjectFilesInternal(projectRoot, options) {
     if (options?.knownGitCandidates !== void 0) {
       gitCandidates = options.knownGitCandidates;
     } else {
-      gitCandidates = await listGitCandidateFiles(root, options?.logLevel);
+      gitCandidates = await listGitCandidateFiles(root, options?.logLevel, {
+        ...options?.onDiscoveryProgress ? { onDiscoveryProgress: options.onDiscoveryProgress } : {},
+        ...options?.onDiscoveryTiming ? { onDiscoveryTiming: options.onDiscoveryTiming } : {}
+      });
     }
     options?.onGitCandidatesDiscovered?.(gitCandidates);
     const reportMetadataSymlinkChecks = options?.onDiscoveryProgress ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking project metadata symlinks", current, total }) : void 0;
@@ -14803,7 +14920,7 @@ async function discoverProjectFilesInternal(projectRoot, options) {
         return normalizePath(realPath) === filePath || !isIgnoredByGitignore(realPath, gitignoreIndex, isDirectory2);
       }).map(({ filePath }) => filePath);
       const symlinkOptions = {
-        candidatePaths: gitCandidates.files,
+        candidatePaths: gitCandidates.symlinkCandidatePaths,
         ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
         ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {},
         ...reportMetadataSymlinkChecks ? { onPathCheckProgress: reportMetadataSymlinkChecks } : {}
@@ -14884,7 +15001,7 @@ async function discoverProjectFilesInternal(projectRoot, options) {
     throw new Error(`Failed to discover project files in ${root}: ${stringifyUnknown(error51)}`);
   }
 }
-var import_fast_glob2, import_picomatch, DEFAULT_PROJECT_FILE_IGNORES, DEFAULT_PROJECT_MANIFESTS, DEFAULT_PROJECT_PATTERNS, REALPATH_FILTER_CONCURRENCY, EMPTY_GITIGNORE_INDEX;
+var import_fast_glob2, import_picomatch, DEFAULT_PROJECT_FILE_IGNORES, DEFAULT_PROJECT_MANIFESTS, DEFAULT_PROJECT_PATTERNS, REALPATH_FILTER_CONCURRENCY, DIRECTORY_METADATA_EXTENSIONS, DIRECTORY_METADATA_BASENAMES, EMPTY_GITIGNORE_INDEX;
 var init_projectFiles = __esm({
   "dist/util/projectFiles.js"() {
     "use strict";
@@ -14986,6 +15103,23 @@ var init_projectFiles = __esm({
       ...DEFAULT_PROJECT_MANIFESTS.map((name) => `**/${name}`)
     ];
     REALPATH_FILTER_CONCURRENCY = 64;
+    DIRECTORY_METADATA_EXTENSIONS = /* @__PURE__ */ new Set();
+    DIRECTORY_METADATA_BASENAMES = /* @__PURE__ */ new Set();
+    for (const definition of PROJECT_FILE_DEFINITIONS) {
+      if (definition.kind !== "dir")
+        continue;
+      for (const pattern of definition.patterns) {
+        if (!pattern.includes("*") && !pattern.includes("?")) {
+          DIRECTORY_METADATA_BASENAMES.add(pattern.toLowerCase());
+          continue;
+        }
+        const trimmed = pattern.replaceAll("*", "").replaceAll("?", "");
+        const lastDot = trimmed.lastIndexOf(".");
+        if (lastDot < 0)
+          continue;
+        DIRECTORY_METADATA_EXTENSIONS.add(trimmed.slice(lastDot).toLowerCase());
+      }
+    }
     EMPTY_GITIGNORE_INDEX = {
       hasRules: false,
       repositoryRoots: [],
@@ -53504,19 +53638,19 @@ var init_parsed_cache = __esm({
 });
 
 // dist/indexer/finalize.js
-import { performance as performance2 } from "node:perf_hooks";
+import { performance as performance3 } from "node:perf_hooks";
 async function finalizeProjectIndex(args) {
   const discoveryTimings = args.opts?.report ? args.opts.report.timings ??= {} : void 0;
-  const metadataDiscoveryStart = args.projectFiles === void 0 ? performance2.now() : void 0;
+  const metadataDiscoveryStart = args.projectFiles === void 0 ? performance3.now() : void 0;
   const projectFiles = await (args.projectFiles ?? discoverProjectFilesWithGitCandidates(args.projectRoot, {
     ...args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {},
     ...args.knownGitCandidates !== void 0 ? { knownGitCandidates: args.knownGitCandidates } : {}
   }));
   if (metadataDiscoveryStart !== void 0 && discoveryTimings) {
-    discoveryTimings.metadataDiscoveryMs = Math.round(performance2.now() - metadataDiscoveryStart);
+    discoveryTimings.metadataDiscoveryMs = Math.round(performance3.now() - metadataDiscoveryStart);
   }
   if (args.timings)
-    args.timings.totalMs = Math.round(performance2.now() - args.totalStart);
+    args.timings.totalMs = Math.round(performance3.now() - args.totalStart);
   const languageExtensions = normalizeLanguageExtensions(args.opts?.languageExtensions);
   const parsed = retainedParsedCache(args.parsedMap, args.opts);
   return {
@@ -53554,7 +53688,7 @@ var init_finalize = __esm({
 // dist/indexer/build-manifest.js
 import fsp24 from "node:fs/promises";
 import path45 from "node:path";
-import { performance as performance3 } from "node:perf_hooks";
+import { performance as performance4 } from "node:perf_hooks";
 function toManifestFileEntry(entry) {
   if (!entry.sig)
     return void 0;
@@ -53569,7 +53703,7 @@ 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 = performance3.now();
+  const writeManifestStart = performance4.now();
   const lastCommit = await getGitHead(args.projectRoot);
   const configHashResult = await computeConfigHash(args.projectRoot, args.opts?.logLevel);
   const projectRootMtimeMs = args.symlinkDirectories !== void 0 ? (await fsp24.stat(args.projectRoot)).mtimeMs : void 0;
@@ -53594,7 +53728,7 @@ async function writeIndexManifestSnapshot(args) {
   if (manifestWritten)
     pruneDiskModuleCache(args.projectRoot, Object.keys(files), args.opts);
   if (args.timings) {
-    args.timings.writeManifestMs = Math.round(performance3.now() - writeManifestStart);
+    args.timings.writeManifestMs = Math.round(performance4.now() - writeManifestStart);
   }
 }
 var init_build_manifest = __esm({
@@ -55029,7 +55163,7 @@ var init_nativeWorkerPool = __esm({
 });
 
 // dist/indexer/build-workers.js
-import { performance as performance4 } from "node:perf_hooks";
+import { performance as performance5 } from "node:perf_hooks";
 function shouldEnableNativeWorkers(opts, fileCount) {
   if (opts?.native === "off")
     return false;
@@ -55123,14 +55257,14 @@ async function setupWorkerPool(opts, fileCount) {
   return {
     pool,
     report,
-    startTime: pool ? performance4.now() : 0,
+    startTime: pool ? performance5.now() : 0,
     batchSize: NATIVE_WORKER_BATCH_SIZE
   };
 }
 async function teardownWorkerPool(setup, buildReport2) {
   if (setup.pool) {
     if (setup.report) {
-      setup.report.wallClockMs = Math.round(performance4.now() - setup.startTime);
+      setup.report.wallClockMs = Math.round(performance5.now() - setup.startTime);
     }
     try {
       await setup.pool.destroy();
@@ -55398,7 +55532,7 @@ import crypto10 from "node:crypto";
 import fs23 from "node:fs";
 import fsp26 from "node:fs/promises";
 import path47 from "node:path";
-import { performance as performance5 } from "node:perf_hooks";
+import { performance as performance6 } from "node:perf_hooks";
 function initParserBackendDegradationReport(report) {
   if (!report)
     return void 0;
@@ -55697,7 +55831,7 @@ function createIndexBuildRunState(projectRoot, opts, graphOptions = normalizeGra
     normalizedProjectRoot: normalizePath(path47.resolve(projectRoot)),
     report,
     timings: report?.timings,
-    totalStart: performance5.now(),
+    totalStart: performance6.now(),
     cacheMode,
     cacheEnabled: cacheMode !== "off",
     graphOptions,
@@ -55742,6 +55876,31 @@ function emitIndexCheckActivity(opts, activity, current = 0, total = 0) {
     total
   });
 }
+function resetDiscoveryTimingSteps(timings) {
+  if (!timings)
+    return;
+  delete timings.gitListMs;
+  delete timings.filesystemScanMs;
+  delete timings.sourceDiscoveryMs;
+  delete timings.metadataDiscoveryMs;
+  const remaining = (timings.steps ?? []).filter((step) => !DISCOVERY_TIMING_STEP_NAMES.has(step.name));
+  if (remaining.length) {
+    timings.steps = remaining;
+    return;
+  }
+  delete timings.steps;
+}
+function recordBuildTimingStep(timings, step) {
+  if (!timings)
+    return;
+  (timings.steps ??= []).push(step);
+  if (step.name === "git-list") {
+    timings.gitListMs = step.ms;
+    return;
+  }
+  if (step.name === "filesystem-scan")
+    timings.filesystemScanMs = step.ms;
+}
 function buildConcurrency(opts) {
   return resolveWorkerThreadCount({ requested: Number(opts?.threads || 0), defaultCount: 8, max: 64 });
 }
@@ -55783,7 +55942,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
   const fileReport = initFileReport(report);
   if (fileReport)
     fileReport.total = normalizedFiles.length;
-  const manifestStart = performance5.now();
+  const manifestStart = performance6.now();
   const manifest = useManifest && !helperOpts?.ignoreExistingManifest ? await loadManifest(projectRoot, opts, report) : null;
   const manifestFiles = sanitizeManifestEntriesForRoot(projectRoot, manifest?.files);
   const manifestOptionDiffs = manifest ? diffBuildOptions(manifest.buildOptions, opts) : [];
@@ -55798,7 +55957,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     }
   }
   if (timings && useManifest) {
-    timings.manifestMs = Math.round(performance5.now() - manifestStart);
+    timings.manifestMs = Math.round(performance6.now() - manifestStart);
   }
   const edgeProbeConcurrency = buildConcurrency(opts);
   const staleCachedEdgeFiles = /* @__PURE__ */ new Set();
@@ -55912,7 +56071,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
       }
       return matchPath;
     };
-    const parseStart = performance5.now();
+    const parseStart = performance6.now();
     const graph = { nodes: new Set(normalizedFiles), edges: [] };
     const onFileEdges = manifestEntries ? (file2, entry) => {
       const manifestEntry = toManifestFileEntry(entry);
@@ -55926,7 +56085,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     const ensureBuildProgressStarted = () => {
       if (buildStartedAt !== void 0)
         return;
-      buildStartedAt = performance5.now();
+      buildStartedAt = performance6.now();
       emitIndexLifecycleProgress(opts, "start", "build", totalFiles);
     };
     const fileResults = await mapLimit(normalizedFiles, conc, async (file2) => {
@@ -56058,8 +56217,8 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
       }
     });
     if (timings)
-      timings.parseMs = Math.round(performance5.now() - parseStart);
-    const graphStart = performance5.now();
+      timings.parseMs = Math.round(performance6.now() - parseStart);
+    const graphStart = performance6.now();
     const seenGraphEdges = /* @__PURE__ */ new Set();
     const appendUniqueGraphEdges = (edges) => {
       if (!edges.length)
@@ -56087,7 +56246,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     const workspaceManifestEdges = await collectWorkspaceManifestDependencyEdges(projectRoot, normalizedFiles.filter((file2) => path47.basename(file2) === "package.json"), opts?.discovery, opts?.logLevel);
     appendUniqueGraphEdges(workspaceManifestEdges);
     if (timings)
-      timings.graphMs = Math.round(performance5.now() - graphStart);
+      timings.graphMs = Math.round(performance6.now() - graphStart);
     for (const jsonPath of jsonDependencies.values()) {
       ensureJsonModule(modules, jsonPath);
     }
@@ -56139,7 +56298,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     }
     if (buildStartedAt !== void 0) {
       const progressStartedAt = opts?.progressStartedAt ?? buildStartedAt;
-      emitIndexLifecycleProgress(opts, "complete", "build", index.byFile.size, performance5.now() - progressStartedAt);
+      emitIndexLifecycleProgress(opts, "complete", "build", index.byFile.size, performance6.now() - progressStartedAt);
     }
     return index;
   } finally {
@@ -56148,6 +56307,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
 }
 async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpts) {
   const timings = opts?.report ? opts.report.timings ??= {} : void 0;
+  resetDiscoveryTimingSteps(timings);
   await initializeFileIdentityCaseSensitivity(projectRoot);
   try {
     const useDiskCache = (opts?.cache ?? "off") === "disk";
@@ -56168,19 +56328,21 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
       discoveredGitCandidates = candidates;
     };
     const onDiscoveryProgress = helperOpts?.reportDiscoveryProgress ? (progress) => emitIndexCheckActivity(opts, progress.activity, progress.current, progress.total) : void 0;
+    const onDiscoveryTiming = timings ? (step) => recordBuildTimingStep(timings, step) : void 0;
     if (helperOpts?.reportDiscoveryProgress)
       emitIndexCheckActivity(opts, "Discovering source files");
-    const sourceDiscoveryStart = performance5.now();
+    const sourceDiscoveryStart = performance6.now();
     const discoveredFiles = await listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
       ...opts?.discovery,
       ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
       ...knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories } : {},
       onSymlinkDirectoriesDiscovered,
       onGitCandidatesDiscovered,
-      ...onDiscoveryProgress ? { onDiscoveryProgress } : {}
+      ...onDiscoveryProgress ? { onDiscoveryProgress } : {},
+      ...onDiscoveryTiming ? { onDiscoveryTiming } : {}
     });
     if (timings)
-      timings.sourceDiscoveryMs = Math.round(performance5.now() - sourceDiscoveryStart);
+      timings.sourceDiscoveryMs = Math.round(performance6.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));
@@ -56189,15 +56351,16 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
     const transientFiles = additionalFiles.filter((file2) => !discoveredFileSet.has(file2));
     if (helperOpts?.reportDiscoveryProgress)
       emitIndexCheckActivity(opts, "Discovering project metadata");
-    const metadataDiscoveryStart = performance5.now();
+    const metadataDiscoveryStart = performance6.now();
     const projectFiles = await discoverProjectFilesWithGitCandidates(projectRoot, {
       ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
       ...discoveredSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: discoveredSymlinkDirectories } : {},
       ...discoveredGitCandidates !== void 0 ? { knownGitCandidates: discoveredGitCandidates } : {},
-      ...onDiscoveryProgress ? { onDiscoveryProgress } : {}
+      ...onDiscoveryProgress ? { onDiscoveryProgress } : {},
+      ...onDiscoveryTiming ? { onDiscoveryTiming } : {}
     });
     if (timings)
-      timings.metadataDiscoveryMs = Math.round(performance5.now() - metadataDiscoveryStart);
+      timings.metadataDiscoveryMs = Math.round(performance6.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`,
@@ -56216,11 +56379,11 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
 async function buildProjectIndex(projectRoot, opts) {
   return buildProjectIndexWithManifestOptions(projectRoot, {
     ...opts,
-    progressStartedAt: opts?.progressStartedAt ?? performance5.now()
+    progressStartedAt: opts?.progressStartedAt ?? performance6.now()
   });
 }
 async function buildProjectIndexFromFiles(projectRoot, inputFiles, rawOpts) {
-  const opts = { ...rawOpts, progressStartedAt: rawOpts?.progressStartedAt ?? performance5.now() };
+  const opts = { ...rawOpts, progressStartedAt: rawOpts?.progressStartedAt ?? performance6.now() };
   try {
     const useDiskCache = (opts?.cache ?? "off") === "disk";
     const normalizedInputFiles = await normalizeIndexedFileInputsWithinRoot(projectRoot, inputFiles, "Index file");
@@ -56252,7 +56415,7 @@ async function buildDeclaredScopeIndex(projectRoot, scopeFiles, opts) {
 async function buildProjectIndexIncremental(projectRoot, rawOpts) {
   const opts = {
     ...rawOpts,
-    progressStartedAt: rawOpts?.progressStartedAt ?? performance5.now()
+    progressStartedAt: rawOpts?.progressStartedAt ?? performance6.now()
   };
   await initializeFileIdentityCaseSensitivity(projectRoot);
   clearResolutionCaches();
@@ -56262,6 +56425,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
     graphOptions.fast = false;
   const { normalizedProjectRoot, report, timings, totalStart, cacheMode, cacheEnabled, onFallbackImportExtraction } = createIndexBuildRunState(projectRoot, opts, graphOptions);
   const discoveryTimings = opts?.report ? opts.report.timings ??= {} : void 0;
+  resetDiscoveryTimingSteps(discoveryTimings);
   let checkProgressActive = false;
   const startCheckProgress = () => {
     if (checkProgressActive)
@@ -56287,7 +56451,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       message: "Checked project index",
       current: total,
       total,
-      elapsedMs: performance5.now() - totalStart
+      elapsedMs: performance6.now() - totalStart
     });
   };
   try {
@@ -56302,10 +56466,10 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       return await buildProjectIndexFromExport(projectRoot, opts, { ignoreExistingManifest: true });
     }
     startCheckProgress();
-    const manifestStart = performance5.now();
+    const manifestStart = performance6.now();
     const manifest = await loadManifest(projectRoot, opts, report);
     if (timings)
-      timings.manifestMs = Math.round(performance5.now() - manifestStart);
+      timings.manifestMs = Math.round(performance6.now() - manifestStart);
     const manifestUsed = !!manifest;
     const manifestReport = initManifestReport(report, manifestUsed, false);
     if (manifestReport && !manifestUsed)
@@ -56360,11 +56524,11 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       if (!discoveryTimings || opts?.filesAreProjectScope)
         return await operation();
       sourceDiscoveryPerformed = true;
-      const start = performance5.now();
+      const start = performance6.now();
       try {
         return await operation();
       } finally {
-        sourceDiscoveryMs += performance5.now() - start;
+        sourceDiscoveryMs += performance6.now() - start;
       }
     };
     let manifestDiffFiles = [];
@@ -56456,7 +56620,10 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         ...!opts?.cacheStrict && manifest.symlinkDirectories !== void 0 ? { knownSymlinkDirectories: manifest.symlinkDirectories } : {},
         onGitCandidatesDiscovered: (candidates) => {
           discoveredGitCandidates = candidates;
-        }
+        },
+        ...discoveryTimings ? {
+          onDiscoveryTiming: (step) => recordBuildTimingStep(discoveryTimings, step)
+        } : {}
       }));
     }
     if (discoveryTimings && sourceDiscoveryPerformed) {
@@ -56561,13 +56728,13 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       const snapshot = snapshotLoad.index;
       snapshot.manifestSignaturesFresh = false;
       if (snapshot.projectFiles === void 0) {
-        const metadataDiscoveryStart = performance5.now();
+        const metadataDiscoveryStart = performance6.now();
         snapshot.projectFiles = await discoverProjectFilesWithGitCandidates(projectRoot, {
           ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
           ...discoveredGitCandidates !== void 0 ? { knownGitCandidates: discoveredGitCandidates } : {}
         });
         if (discoveryTimings)
-          discoveryTimings.metadataDiscoveryMs = Math.round(performance5.now() - metadataDiscoveryStart);
+          discoveryTimings.metadataDiscoveryMs = Math.round(performance6.now() - metadataDiscoveryStart);
       }
       if (opts?.cache) {
         snapshot.cacheMode = opts.cache;
@@ -56605,7 +56772,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       const snapshot = await reuseUnchangedSnapshot();
       if (snapshot) {
         if (timings)
-          timings.totalMs = Math.round(performance5.now() - totalStart);
+          timings.totalMs = Math.round(performance6.now() - totalStart);
         completeCheckProgress(allFiles.size);
         return snapshot;
       }
@@ -56675,7 +56842,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(performance5.now() - totalStart);
+          timings.totalMs = Math.round(performance6.now() - totalStart);
         completeCheckProgress(allFiles.size);
         return unchangedSnapshot;
       }
@@ -56717,13 +56884,13 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       workerSetup = await setupWorkerPool(opts, countNativeWorkerEligibleFiles(changedList, opts?.languageExtensions));
       let updateStartedAt;
       if (changedList.length || deletedTrackedFiles.size) {
-        updateStartedAt = performance5.now();
+        updateStartedAt = performance6.now();
         emitIndexLifecycleProgress(opts, "start", "update", changedList.length);
       }
       if (fileReport)
         fileReport.changed = changedList.length;
       if (changedList.length) {
-        const parseStart = performance5.now();
+        const parseStart = performance6.now();
         let processedFiles = 0;
         const totalFiles = changedList.length;
         const fileResults = await mapLimit(changedList, conc, async (file2) => {
@@ -56786,7 +56953,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
           writeModulesToCache(projectRoot, pendingIncrementalCacheWrites, opts);
         }
         if (timings)
-          timings.parseMs = Math.round(performance5.now() - parseStart);
+          timings.parseMs = Math.round(performance6.now() - parseStart);
       }
       for (const jsonPath of jsonDependencies.values()) {
         ensureJsonModule(modules, jsonPath);
@@ -56816,7 +56983,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         }
       }
       const filesList = Array.from(changedFiles);
-      const graphStart = performance5.now();
+      const graphStart = performance6.now();
       const graph = !filesList.length && baseGraph ? { nodes: new Set(baseGraph.nodes), edges: [...baseGraph.edges] } : await collectGraph(projectRoot, filesList, {
         parsed: parsedMap,
         fast: !!graphOptions.fast,
@@ -56842,7 +57009,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
         }
       });
       if (timings)
-        timings.graphMs = Math.round(performance5.now() - graphStart);
+        timings.graphMs = Math.round(performance6.now() - graphStart);
       for (const file2 of /* @__PURE__ */ new Set([...changedFiles, ...transientFiles])) {
         const signature = fileSignatures.get(file2);
         if (!signature || manifestEntries.has(file2))
@@ -56902,7 +57069,7 @@ async function buildProjectIndexIncremental(projectRoot, rawOpts) {
       });
       await writeProjectIndexSnapshot(projectRoot, opts, index, projectSnapshotFilesSignature(manifestEntries, projectRoot));
       if (updateStartedAt !== void 0) {
-        emitIndexLifecycleProgress(opts, "complete", "update", index.byFile.size, performance5.now() - updateStartedAt);
+        emitIndexLifecycleProgress(opts, "complete", "update", index.byFile.size, performance6.now() - updateStartedAt);
       } else {
         completeCheckProgress(allFiles.size);
       }
@@ -57048,6 +57215,7 @@ async function buildGraphDelta(projectRoot, opts) {
     removed: removedRelative.sort(compareEdges)
   };
 }
+var DISCOVERY_TIMING_STEP_NAMES;
 var init_build_index = __esm({
   "dist/indexer/build-index.js"() {
     "use strict";
@@ -57087,6 +57255,7 @@ var init_build_index = __esm({
     init_build_workers();
     init_incremental_plan();
     init_parsed_cache();
+    DISCOVERY_TIMING_STEP_NAMES = /* @__PURE__ */ new Set(["git-list", "git-ignore", "filesystem-scan"]);
   }
 });
 
@@ -67720,7 +67889,7 @@ var init_deleted = __esm({
 });
 
 // dist/review/candidates.js
-import { performance as performance6 } from "node:perf_hooks";
+import { performance as performance7 } from "node:perf_hooks";
 function relativePath(root, file2) {
   return toProjectDisplayPath(root, file2);
 }
@@ -67753,7 +67922,7 @@ function mergeCandidateTestEntries(baseCandidates, additionalCandidates) {
   return Array.from(merged.values());
 }
 async function collectReviewCandidateTests(input) {
-  const candidateStart = performance6.now();
+  const candidateStart = performance7.now();
   const configuredMaxCandidates = input.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(input.index, input.changedFileList, input.changedSymbolIds, {
@@ -67773,7 +67942,7 @@ async function collectReviewCandidateTests(input) {
     return left.reason.localeCompare(right.reason);
   }).slice(0, maxCandidates);
   if (input.reviewTimings) {
-    input.reviewTimings.candidatesMs = Math.round(performance6.now() - candidateStart);
+    input.reviewTimings.candidatesMs = Math.round(performance7.now() - candidateStart);
   }
   return candidateTests;
 }
@@ -68069,7 +68238,7 @@ var init_parse4 = __esm({
 });
 
 // dist/review/changes.js
-import { performance as performance7 } from "node:perf_hooks";
+import { performance as performance8 } from "node:perf_hooks";
 function deletedPathsForChange(change2) {
   if (change2.kind === "deleted") {
     return [change2.path];
@@ -68087,16 +68256,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 = performance7.now();
+  const changesStart = performance8.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(performance7.now() - changesStart);
+    reviewTimings.changesMs = Math.round(performance8.now() - changesStart);
   }
-  const diffStart = performance7.now();
+  const diffStart = performance8.now();
   const shouldLoadGitDiff = Boolean(appliedOptions.gitBase || appliedOptions.changedSince);
   const diffText = appliedOptions.diffText ?? (shouldLoadGitDiff ? await getUnifiedDiff(projectRoot, {
     base: appliedOptions.gitBase,
@@ -68105,7 +68274,7 @@ async function collectReviewChanges(projectRoot, appliedOptions, reviewTimings)
   }) : "");
   const diff = diffText ? parseUnifiedDiff(diffText) : null;
   if (reviewTimings) {
-    reviewTimings.diffMs = Math.round(performance7.now() - diffStart);
+    reviewTimings.diffMs = Math.round(performance8.now() - diffStart);
   }
   const diffHunksByFile = /* @__PURE__ */ new Map();
   const diffKindsByFile = /* @__PURE__ */ new Map();
@@ -69479,10 +69648,10 @@ var init_severity = __esm({
 });
 
 // dist/impact/budgets.js
-import { performance as performance8 } from "node:perf_hooks";
+import { performance as performance9 } from "node:perf_hooks";
 function createImpactWorkBudget(options) {
   return {
-    ...typeof options.timeBudgetMs === "number" && options.timeBudgetMs >= 0 ? { deadlineAt: performance8.now() + options.timeBudgetMs } : {},
+    ...typeof options.timeBudgetMs === "number" && options.timeBudgetMs >= 0 ? { deadlineAt: performance9.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,
@@ -69497,7 +69666,7 @@ function isImpactDeadlineExceeded(budget) {
     return true;
   if (budget.deadlineAt === void 0)
     return false;
-  if (performance8.now() >= budget.deadlineAt) {
+  if (performance9.now() >= budget.deadlineAt) {
     budget.deadlineExceeded = true;
     return true;
   }
@@ -71551,7 +71720,7 @@ var init_referenceCache = __esm({
 // dist/review/summaries.js
 import fsp37 from "node:fs/promises";
 import path70 from "node:path";
-import { performance as performance9 } from "node:perf_hooks";
+import { performance as performance10 } from "node:perf_hooks";
 function relativePath2(root, file2) {
   return toProjectDisplayPath(root, file2);
 }
@@ -71917,7 +72086,7 @@ async function summarizeChangedFiles2(input) {
     }
   }
   const defsToResolve = fileEntries.flatMap((entry) => entry.locals);
-  const referencesStart = performance9.now();
+  const referencesStart = performance10.now();
   const referenceResults = includeSymbolDetails && maxCallsites > 0 ? await mapLimit(defsToResolve, referenceConcurrency, async (def) => {
     const refs = await referenceCache.get(index, def, {
       maxReferences: maxCallsites + 1
@@ -71925,7 +72094,7 @@ async function summarizeChangedFiles2(input) {
     return { def, refs };
   }) : [];
   if (reviewTimings) {
-    reviewTimings.referencesMs = Math.round(performance9.now() - referencesStart);
+    reviewTimings.referencesMs = Math.round(performance10.now() - referencesStart);
   }
   const referencesByHandle = /* @__PURE__ */ new Map();
   for (const entry of referenceResults) {
@@ -72105,7 +72274,7 @@ var init_summaries = __esm({
 });
 
 // dist/review.js
-import { performance as performance10 } from "node:perf_hooks";
+import { performance as performance11 } from "node:perf_hooks";
 function mergeGraphOptions2(base, override) {
   if (!base)
     return override;
@@ -72149,7 +72318,7 @@ async function buildReviewIndex(input) {
     diffChangesByFile,
     graphOptions
   });
-  const indexStart = performance10.now();
+  const indexStart = performance11.now();
   const indexReport = reviewReport?.indexReport ?? (reviewReport ? { timings: {} } : void 0);
   if (reviewReport && !reviewReport.indexReport && indexReport) {
     reviewReport.indexReport = indexReport;
@@ -72182,7 +72351,7 @@ async function buildReviewIndex(input) {
     });
   }
   if (reviewTimings) {
-    reviewTimings.indexMs = Math.round(performance10.now() - indexStart);
+    reviewTimings.indexMs = Math.round(performance11.now() - indexStart);
   }
   return {
     index,
@@ -72201,7 +72370,7 @@ async function buildReviewReport(projectRoot, opts = {}, cached2) {
   if (reviewReport && appliedOptions.duplicateTasks === false) {
     delete reviewReport.duplicateAnalysis;
   }
-  const totalStart = performance10.now();
+  const totalStart = performance11.now();
   const { changedFiles, explicitFiles, diffHunksByFile, diffKindsByFile, diffChangesByFile } = await collectReviewChanges(projectRoot, appliedOptions, reviewTimings);
   if (changedFiles.size === 0) {
     const riskSummary = computeRiskSummary({
@@ -72235,7 +72404,7 @@ async function buildReviewReport(projectRoot, opts = {}, cached2) {
       report2.base = appliedOptions.gitBase;
     report2.head = appliedOptions.gitHead ?? "HEAD";
     if (reviewTimings)
-      reviewTimings.totalMs = Math.round(performance10.now() - totalStart);
+      reviewTimings.totalMs = Math.round(performance11.now() - totalStart);
     return report2;
   }
   const changedFileList = Array.from(changedFiles).sort(comparePaths2);
@@ -72313,7 +72482,7 @@ async function buildReviewReport(projectRoot, opts = {}, cached2) {
     riskRelevantParseFailures,
     exportedChangedCount
   });
-  const duplicateAnalysisStart = performance10.now();
+  const duplicateAnalysisStart = performance11.now();
   if (appliedOptions.duplicateTasks !== false) {
     const duplicateReview = await collectReviewDuplicateTasks({
       projectRoot,
@@ -72334,10 +72503,10 @@ async function buildReviewReport(projectRoot, opts = {}, cached2) {
     }
   }
   if (reviewTimings && appliedOptions.duplicateTasks !== false) {
-    reviewTimings.duplicateAnalysisMs = Math.round(performance10.now() - duplicateAnalysisStart);
+    reviewTimings.duplicateAnalysisMs = Math.round(performance11.now() - duplicateAnalysisStart);
   }
   if (reviewTimings)
-    reviewTimings.totalMs = Math.round(performance10.now() - totalStart);
+    reviewTimings.totalMs = Math.round(performance11.now() - totalStart);
   return report;
 }
 function buildSymbolDefLookup(index) {
@@ -78423,7 +78592,7 @@ var search_exports = {};
 __export(search_exports, {
   handleSearchCommand: () => handleSearchCommand
 });
-import { performance as performance11 } from "node:perf_hooks";
+import { performance as performance12 } from "node:perf_hooks";
 function parseAgentSearchMode(rawValue) {
   if (rawValue === void 0)
     return "hybrid";
@@ -78433,7 +78602,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 = performance11.now();
+  const commandStart = performance12.now();
   const query = context.positionals.join(" ").trim();
   if (!query) {
     context.writeStderrLine(SEARCH_HELP_TEXT.trimEnd());
@@ -78457,7 +78626,7 @@ async function handleSearchCommand(context) {
     context.writeStdoutLine(formatAgentSearchResponse(response));
   }
   if (context.commandReport && context.writeCommandReport) {
-    context.commandReport.timings.commandMs = Math.round(performance11.now() - commandStart);
+    context.commandReport.timings.commandMs = Math.round(performance12.now() - commandStart);
     context.commandReport.timings.totalMs = context.commandReport.timings.commandMs;
     await context.writeCommandReport(context.commandReport, context.reportFile);
   }
@@ -107438,7 +107607,7 @@ __export(graph_exports, {
 import fs42 from "node:fs";
 import fsp40 from "node:fs/promises";
 import path88 from "node:path";
-import { performance as performance12 } from "node:perf_hooks";
+import { performance as performance13 } from "node:perf_hooks";
 function resolveGraphCacheMode(cache) {
   return cache ?? "disk";
 }
@@ -107578,11 +107747,11 @@ function stabilizeSymbolGraph(graph) {
 }
 async function handleGraphCommand(context) {
   const commandReport = context.reportEnabled ? { command: "graph", timings: {} } : void 0;
-  const commandStart = performance12.now();
-  const resolveStart = performance12.now();
+  const commandStart = performance13.now();
+  const resolveStart = performance13.now();
   const files = await context.resolveFiles();
   if (commandReport) {
-    commandReport.timings.resolveFilesMs = Math.round(performance12.now() - resolveStart);
+    commandReport.timings.resolveFilesMs = Math.round(performance13.now() - resolveStart);
   }
   const hasExplicitSymbolFlag = context.hasFlag("--symbols") || context.hasFlag("--symbols-only") || context.hasFlag("--symbols-detailed");
   const outputArg = context.getOpt("--output") ?? context.getOpt("--out");
@@ -107624,7 +107793,7 @@ async function handleGraphCommand(context) {
   const finalizeReport = async () => {
     if (!commandReport)
       return;
-    commandReport.timings.commandMs = Math.round(performance12.now() - commandStart);
+    commandReport.timings.commandMs = Math.round(performance13.now() - commandStart);
     commandReport.timings.totalMs = commandReport.timings.commandMs;
     await context.writeCommandReport(commandReport, context.reportFile);
   };
@@ -107844,7 +108013,7 @@ var cli_exports = {};
 __export(cli_exports, {
   handleIndexCommand: () => handleIndexCommand
 });
-import { performance as performance13 } from "node:perf_hooks";
+import { performance as performance14 } from "node:perf_hooks";
 function formatIndexOutput(output) {
   const lines = [`Indexed ${output.files} file(s) with ${output.edges} edge(s).`];
   if (output.analysis.mode !== "semantic") {
@@ -107862,11 +108031,11 @@ function formatIndexOutput(output) {
 async function handleIndexCommand(context) {
   const verbose = context.hasFlag("--verbose");
   const commandReport = context.reportEnabled ? { command: "index", timings: {} } : void 0;
-  const commandStart = performance13.now();
-  const resolveStart = performance13.now();
+  const commandStart = performance14.now();
+  const resolveStart = performance14.now();
   const files = await context.resolveFiles();
   if (commandReport) {
-    commandReport.timings.resolveFilesMs = Math.round(performance13.now() - resolveStart);
+    commandReport.timings.resolveFilesMs = Math.round(performance14.now() - resolveStart);
   }
   const threads = parseNonNegativeIntegerOption(context.getOpt("--threads"), "--threads", 0);
   const cache = parseCacheModeOption(context.getOpt("--cache"));
@@ -107932,7 +108101,7 @@ async function handleIndexCommand(context) {
     }
   }
   if (commandReport) {
-    commandReport.timings.commandMs = Math.round(performance13.now() - commandStart);
+    commandReport.timings.commandMs = Math.round(performance14.now() - commandStart);
     commandReport.timings.totalMs = commandReport.timings.commandMs;
     await context.writeCommandReport(commandReport, context.reportFile);
   }
@@ -110925,7 +111094,7 @@ var review_exports = {};
 __export(review_exports, {
   handleReviewCommand: () => handleReviewCommand
 });
-import { performance as performance14 } from "node:perf_hooks";
+import { performance as performance15 } from "node:perf_hooks";
 import path92 from "node:path";
 function parseReviewDepth(value) {
   if (value === "minimal" || value === "standard" || value === "deep") {
@@ -111117,7 +111286,7 @@ async function collectReviewDuplicateSummary(input) {
   });
 }
 async function handleReviewCommand(context) {
-  const commandStart = performance14.now();
+  const commandStart = performance15.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);
@@ -111212,7 +111381,7 @@ async function handleReviewCommand(context) {
     context.writeJSONLine(report);
   }
   if (context.commandReport) {
-    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);
   }
@@ -111501,7 +111670,7 @@ __export(inspect_exports, {
   handleHotspotsCommand: () => handleHotspotsCommand,
   handleInspectCommand: () => handleInspectCommand
 });
-import { performance as performance15 } from "node:perf_hooks";
+import { performance as performance16 } from "node:perf_hooks";
 import fs44 from "node:fs";
 import path93 from "node:path";
 function defaultCacheIndexPath(projectRoot, cacheDir, cacheLocation) {
@@ -111763,18 +111932,18 @@ async function buildInspectReport(projectRoot, includeRoots, files, discovery, g
   };
 }
 async function handleInspectCommand(context) {
-  const commandStart = performance15.now();
+  const commandStart = performance16.now();
   const cache = parseCacheModeOption(context.getOpt("--cache"));
   const limit = parsePositiveIntegerOption(context.getOpt("--limit"), "--limit", 20);
-  const resolveStart = performance15.now();
+  const resolveStart = performance16.now();
   const files = await context.resolveFilesFromRoots();
   if (context.commandReport) {
-    context.commandReport.timings.resolveFilesMs = Math.round(performance15.now() - resolveStart);
+    context.commandReport.timings.resolveFilesMs = Math.round(performance16.now() - resolveStart);
   }
   const report = await buildInspectReport(context.projectRootFs, context.includeRootsAbs, files, context.discoveryOptions, context.graphOptions, context.languageExtensions, cache, context.getOpt("--cache-dir"), context.cacheLocation, context.nativeMode, context.workerOpts, context.progressHandler, context.commandReport?.index, limit, context.hasFlag("--duplicates"), context.writeStderrLine);
   writeCliOutput(context, report, formatInspectReport);
   if (context.commandReport && context.writeCommandReport) {
-    context.commandReport.timings.commandMs = Math.round(performance15.now() - commandStart);
+    context.commandReport.timings.commandMs = Math.round(performance16.now() - commandStart);
     context.commandReport.timings.totalMs = context.commandReport.timings.commandMs;
     await context.writeCommandReport(context.commandReport, context.reportFile);
   }