@lzehrung/codegraph 2.3.6 → 2.3.7

package/README.md

@@ -18,8 +18,6 @@ codegraph is a local CLI **and TypeScript library** that turns a source tree int
 
 Without structural context, an agent burns early turns listing directories, guessing search terms, opening candidate files, and reconstructing relationships. codegraph does that discovery once so the context window can stay focused on the problem.
 
-Warm-cache timings for `codegraph orient --root . --budget small --json` on this repository have ranged from about **0.6s** (Windows 11, Node 24) to about **2.5s** (a 4-core Linux container, Node 22), so treat them as machine-dependent rather than a headline figure; the matching MCP `orient` call returned in about **100ms** on the faster of the two. [The performance program index](docs/plans/2026-07-25-performance-program-index.md) records the current measurements and the conditions behind them.
-
 With Node.js 22.16 or newer, install from npm:
 
 ```bash
@@ -132,13 +130,16 @@ Do not begin by generating every possible report. Start with the question you ac
 ### Understand an unfamiliar repo
 
 ```bash
-# Ask one concrete architecture question
-codegraph explore "how does the CLI reach review analysis?" --root .
-
-# If you do not know the question yet, get a bounded map
+# Map the repository before selecting a target
 codegraph orient --root . --budget small
 
-# Follow an anchor returned by either command
+# Search a concrete term
+codegraph search "review analysis CLI" --json
+
+# Use explore only when those results need packets and dependency paths
+codegraph explore "review analysis CLI" --root .
+
+# Follow a returned target
 codegraph explain src/review.ts
 codegraph deps src/review.ts --json
 codegraph refs src/review.ts:215:23

package/codegraph-skill/codegraph/SKILL.md

@@ -131,6 +131,7 @@ Current-state commands validate the on-disk index automatically and default to t
 - Repeated agent queries over one repo snapshot: prefer MCP so the index stays warm. MCP inputs are flat JSON objects and the server root is fixed at startup; send only fields in the mounted tool schema, never CLI flags such as `--root` or `--json`. Unknown tool fields are rejected as invalid parameters. If the first MCP call fails at startup or loses its transport, do not retry the same server; run `codegraph doctor`, use the equivalent CLI command for this session, and restart the agent client after package upgrades.
 - Durable graph handoff: use `codegraph graph --root . ./src --json --output codegraph.json` rather than parsing display text. `graph --json` and `index --json` payloads include an `analysis` object (`mode`, `backend`, `label`, fallback counts); when `mode` is `mixed` or `reduced` the run used regex/graph-only extraction for some or all files, so treat symbol accuracy accordingly. Degraded runs also print a `Backend:` warning on stderr even without `--progress`.
 - Search and inspect performance diagnosis: add `--report` for JSON on stderr or `--report-file <path>` for a file while keeping normal command output unchanged.
+- Index discovery diagnosis: `--report` timing JSON can include `sourceDiscoveryMs` and `metadataDiscoveryMs` when those discovery steps run.
 
 ### Human Graph Viewer
 

package/dist/bin/cli.js

@@ -13534,6 +13534,7 @@ __export(git_exports, {
   isGitWorktreeSentinel: () => isGitWorktreeSentinel,
   listChangedFiles: () => listChangedFiles,
   listGitExcludeFiles: () => listGitExcludeFiles,
+  listGitIgnoreFiles: () => listGitIgnoreFiles,
   listGitSubmoduleDirectories: () => listGitSubmoduleDirectories,
   listTrackedFiles: () => listTrackedFiles,
   listUntrackedFiles: () => listUntrackedFiles,
@@ -13969,6 +13970,32 @@ async function listTrackedFiles(projectRoot, opts) {
     throw createGitError(projectRoot, args, error51);
   }
 }
+async function listGitIgnoreFiles(projectRoot, opts) {
+  if (!(opts?.gitAvailable ?? true))
+    return [];
+  const pathspec = [".gitignore", ":(glob)**/.gitignore"];
+  const commands = [
+    ["ls-files", "--cached", "-z", "--", ...pathspec],
+    ["ls-files", "--others", "--exclude-standard", "-z", "--", ...pathspec],
+    ["ls-files", "--others", "--ignored", "--exclude-standard", "-z", "--", ...pathspec]
+  ];
+  const results = await Promise.all(commands.map(async (args) => {
+    try {
+      return await runGit(projectRoot, args, { maxBuffer: 64 * 1024 * 1024 });
+    } catch (error51) {
+      throw createGitError(projectRoot, args, error51);
+    }
+  }));
+  const out = [];
+  for (const { stdout } of results) {
+    for (const rel of stdout.split("\0").filter(Boolean)) {
+      const abs = resolveGitListedPath(projectRoot, rel);
+      if (abs)
+        out.push(abs);
+    }
+  }
+  return Array.from(new Set(out));
+}
 async function listGitSubmoduleDirectories(projectRoot, opts) {
   if (!(opts?.gitAvailable ?? true))
     return [];
@@ -14380,24 +14407,24 @@ function collectCandidateAncestorDirectories(root, files) {
   }
   return directories;
 }
-async function findGitIgnoreSources(sourceRoots, files) {
+async function findGitIgnoreSources(sourceRoots) {
   const roots = Array.from(new Map(sourceRoots.map(({ path: sourceRoot, repositoryRoot }) => [
     fileIdentityKey(sourceRoot),
     { path: normalizePath(sourceRoot), repositoryRoot: normalizePath(repositoryRoot) }
   ])).values());
   const sources = [];
   for (const { path: sourceRoot, repositoryRoot } of roots) {
-    const directories = collectCandidateAncestorDirectories(sourceRoot, files.filter((file2) => isFilePathWithinRoot(sourceRoot, file2)));
-    const present = await mapLimitSemaphore(directories, REALPATH_FILTER_CONCURRENCY, async (directory) => {
-      const candidate = normalizePath(path9.join(directory, ".gitignore"));
-      try {
-        return (await fsp5.stat(candidate)).isFile() ? { file: candidate, baseDir: directory, repositoryRoot, priority: 2 } : null;
-      } catch {
-        return null;
-      }
-    });
-    sources.push(...present.filter((entry) => entry !== null));
-    sources.push(...(await listGitExcludeFiles(sourceRoot)).map((source) => ({
+    const [gitignoreFiles, excludeFiles] = await Promise.all([
+      listGitIgnoreFiles(sourceRoot),
+      listGitExcludeFiles(sourceRoot)
+    ]);
+    sources.push(...gitignoreFiles.map((file2) => ({
+      file: file2,
+      baseDir: path9.dirname(file2),
+      repositoryRoot,
+      priority: 2
+    })));
+    sources.push(...excludeFiles.map((source) => ({
       ...source,
       repositoryRoot: source.baseDir
     })));
@@ -14428,13 +14455,6 @@ 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 physicalFiles = normalizePath(root) === realRoot ? [] : (await mapLimitSemaphore(files, REALPATH_FILTER_CONCURRENCY, async (file2) => {
-      try {
-        return normalizePath(await fsp5.realpath(file2));
-      } catch {
-        return null;
-      }
-    })).filter((file2) => file2 !== null);
     const gitignoreRoots = [gitRepositoryRoot, ...submoduleRoots.map(({ physicalPath }) => physicalPath)].map(normalizePath);
     const sourceRoots = [
       { path: root, repositoryRoot: gitRepositoryRoot },
@@ -14447,7 +14467,7 @@ async function listGitCandidateFiles(root, logLevel) {
     ];
     return {
       files,
-      gitignoreFiles: await findGitIgnoreSources(sourceRoots, [...rawFiles, ...files, ...physicalFiles]),
+      gitignoreFiles: await findGitIgnoreSources(sourceRoots),
       gitignoreRoots,
       gitignoreAliases: sourceRoots
     };
@@ -53074,12 +53094,17 @@ var init_parsed_cache = __esm({
 // dist/indexer/finalize.js
 import { performance as performance2 } from "node:perf_hooks";
 async function finalizeProjectIndex(args) {
-  if (args.timings)
-    args.timings.totalMs = Math.round(performance2.now() - args.totalStart);
+  const discoveryTimings = args.opts?.report ? args.opts.report.timings ??= {} : void 0;
+  const metadataDiscoveryStart = args.projectFiles === void 0 ? performance2.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);
+  }
+  if (args.timings)
+    args.timings.totalMs = Math.round(performance2.now() - args.totalStart);
   const languageExtensions = normalizeLanguageExtensions(args.opts?.languageExtensions);
   const parsed = retainedParsedCache(args.parsedMap, args.opts);
   return {
@@ -55698,6 +55723,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
   }
 }
 async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpts) {
+  const timings = opts?.report ? opts.report.timings ??= {} : void 0;
   await initializeFileIdentityCaseSensitivity(projectRoot);
   try {
     const useDiskCache = (opts?.cache ?? "off") === "disk";
@@ -55717,6 +55743,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
     const onDiscoveryProgress = helperOpts?.reportDiscoveryProgress ? (progress) => emitIndexCheckActivity(opts, progress.activity, progress.current, progress.total) : void 0;
     if (helperOpts?.reportDiscoveryProgress)
       emitIndexCheckActivity(opts, "Discovering source files");
+    const sourceDiscoveryStart = performance5.now();
     const discoveredFiles = await listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
       ...opts?.discovery,
       ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
@@ -55725,6 +55752,8 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
       onGitCandidatesDiscovered,
       ...onDiscoveryProgress ? { onDiscoveryProgress } : {}
     });
+    if (timings)
+      timings.sourceDiscoveryMs = Math.round(performance5.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));
@@ -55733,12 +55762,15 @@ 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 projectFiles = await discoverProjectFilesWithGitCandidates(projectRoot, {
       ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
       ...discoveredSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: discoveredSymlinkDirectories } : {},
       ...discoveredGitCandidates !== void 0 ? { knownGitCandidates: discoveredGitCandidates } : {},
       ...onDiscoveryProgress ? { onDiscoveryProgress } : {}
     });
+    if (timings)
+      timings.metadataDiscoveryMs = Math.round(performance5.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`,
@@ -55794,6 +55826,7 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
   if (strictIncremental && graphOptions.fast)
     graphOptions.fast = false;
   const { normalizedProjectRoot, report, timings, totalStart, cacheMode, cacheEnabled, onFallbackImportExtraction } = createIndexBuildRunState(projectRoot, opts, graphOptions);
+  const discoveryTimings = opts?.report ? opts.report.timings ??= {} : void 0;
   let checkProgressActive = false;
   const startCheckProgress = () => {
     if (checkProgressActive)
@@ -55886,13 +55919,31 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
     const hasExplicitGitRange = !!opts?.gitBase || !!opts?.gitHead;
     const shouldDiffAgainstWorkingTree = !hasExplicitGitRange && gitAvailable && !!manifest.lastCommit;
     const canReuseReconciliation = opts?.reconciledManifestUpdatedAt === manifest.updatedAt;
+    let sourceDiscoveryMs = 0;
+    let sourceDiscoveryPerformed = false;
+    const measureSourceDiscovery = async (operation) => {
+      if (!discoveryTimings || opts?.filesAreProjectScope)
+        return await operation();
+      sourceDiscoveryPerformed = true;
+      const start = performance5.now();
+      try {
+        return await operation();
+      } finally {
+        sourceDiscoveryMs += performance5.now() - start;
+      }
+    };
     let manifestDiffFiles = [];
     if (shouldDiffAgainstWorkingTree) {
       try {
-        manifestDiffFiles = (canReuseReconciliation ? opts?.reconciledWorkingTreeDiffFiles : void 0) ?? await listChangedFiles(projectRoot, {
-          base: manifest.lastCommit,
-          head: "WORKTREE"
-        });
+        const reconciledWorkingTreeDiffFiles = canReuseReconciliation ? opts?.reconciledWorkingTreeDiffFiles : void 0;
+        if (reconciledWorkingTreeDiffFiles !== void 0) {
+          manifestDiffFiles = reconciledWorkingTreeDiffFiles;
+        } else {
+          manifestDiffFiles = await measureSourceDiscovery(() => listChangedFiles(projectRoot, {
+            base: manifest.lastCommit,
+            head: "WORKTREE"
+          }));
+        }
       } catch (error51) {
         if (!isMissingGitRevisionError(error51))
           throw error51;
@@ -55937,13 +55988,21 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
     const previousTransientFiles = sanitizeManifestTransientFilesForRoot(projectRoot, projectRoot, manifest.transientFiles).filter((file2) => Object.hasOwn(trackedEntries, file2));
     const previousTransientFileSet = new Set(previousTransientFiles);
     const needsGitScan = !!opts?.gitBase || !!opts?.changedSince;
-    const gitFiles = needsGitScan ? await listChangedFiles(projectRoot, buildIncrementalGitDiffOptions(opts)) : [];
+    let gitFiles = [];
+    if (needsGitScan) {
+      gitFiles = await measureSourceDiscovery(() => listChangedFiles(projectRoot, buildIncrementalGitDiffOptions(opts)));
+    }
     let untrackedFiles = [];
     let rediscoveredFiles = [];
     let discoveredGitCandidates;
     if (canUseIncrementalDiscoveryFastPath(gitAvailable, opts?.cacheStrict)) {
       try {
-        untrackedFiles = (canReuseReconciliation ? opts?.reconciledUntrackedFiles : void 0) ?? await listUntrackedProjectFiles(projectRoot, opts?.discovery, gitAvailable);
+        const reconciledUntrackedFiles = canReuseReconciliation ? opts?.reconciledUntrackedFiles : void 0;
+        if (reconciledUntrackedFiles !== void 0) {
+          untrackedFiles = reconciledUntrackedFiles;
+        } else {
+          untrackedFiles = await measureSourceDiscovery(() => listUntrackedProjectFiles(projectRoot, opts?.discovery, gitAvailable));
+        }
       } catch (error51) {
         if (manifestReport) {
           manifestReport.reason = "gitUntrackedScanFailed";
@@ -55956,14 +56015,17 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
         });
       }
     } else if (!opts?.filesAreProjectScope) {
-      rediscoveredFiles = await listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
+      rediscoveredFiles = await measureSourceDiscovery(() => listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
         ...opts?.discovery,
         ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
         ...!opts?.cacheStrict && manifest.symlinkDirectories !== void 0 ? { knownSymlinkDirectories: manifest.symlinkDirectories } : {},
         onGitCandidatesDiscovered: (candidates) => {
           discoveredGitCandidates = candidates;
         }
-      });
+      }));
+    }
+    if (discoveryTimings && sourceDiscoveryPerformed) {
+      discoveryTimings.sourceDiscoveryMs = Math.round(sourceDiscoveryMs);
     }
     const candidateFiles = [
       ...explicitFiles,
@@ -56062,10 +56124,16 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
       if (!snapshotLoad)
         return null;
       const snapshot = snapshotLoad.index;
-      snapshot.projectFiles ??= await discoverProjectFilesWithGitCandidates(projectRoot, {
-        ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
-        ...discoveredGitCandidates !== void 0 ? { knownGitCandidates: discoveredGitCandidates } : {}
-      });
+      snapshot.manifestSignaturesFresh = false;
+      if (snapshot.projectFiles === void 0) {
+        const metadataDiscoveryStart = performance5.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);
+      }
       if (opts?.cache) {
         snapshot.cacheMode = opts.cache;
         snapshot.cacheRootDir = cacheRoot(projectRoot, opts);
@@ -56350,6 +56418,17 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
           edges: []
         });
       }
+      for (const [file2, entry] of manifestEntries) {
+        const signature = fileSignatures.get(file2);
+        if (!signature)
+          continue;
+        const { gitSig: _previousGitSig, ...entryWithoutGitSig } = entry;
+        manifestEntries.set(file2, {
+          ...entryWithoutGitSig,
+          sig: signature.sig,
+          ...signature.gitSig ? { gitSig: signature.gitSig } : {}
+        });
+      }
       await writeIndexManifestSnapshot({
         projectRoot,
         opts,
@@ -58577,7 +58656,7 @@ async function buildLifecycleManifest(root, buildOptions, existing, options = {}
     configHash: await hashConfig(root, buildOptions?.logLevel),
     buildOptionsHash: hashBuildOptions(buildOptions),
     fileCount: snapshot.files.length,
-    fileSignatureHash: await hashDiscoveredFiles(snapshot.files, root),
+    fileSignatureHash: hashManifestEntries(snapshot.files, root, snapshot.index.manifestEntries, snapshot.index.manifestSignaturesFresh) ?? await hashDiscoveredFiles(snapshot.files, root),
     files: discoveredFileRelativePaths(snapshot.files, root),
     analysis: snapshot.analysis
   };
@@ -58653,6 +58732,56 @@ function isMissingStatRace2(error51) {
     return false;
   return error51.code === "ENOENT" || error51.code === "ENOTDIR";
 }
+function hashManifestEntries(files, root, entries, signaturesFresh) {
+  if (!signaturesFresh || !entries || entries.size !== files.length)
+    return void 0;
+  const sorted = [...files].sort((left, right) => left.localeCompare(right));
+  const signatures = /* @__PURE__ */ new Map();
+  for (const file2 of sorted) {
+    const entry = entries.get(file2);
+    const signature = parseLifecycleFileSignature(entry?.sig);
+    if (!signature)
+      return void 0;
+    signatures.set(file2, signature);
+  }
+  const hash2 = createHash4("sha256");
+  for (const file2 of sorted) {
+    const signature = signatures.get(file2);
+    if (!signature)
+      return void 0;
+    const relative = path51.relative(root, file2).replace(/\\/g, "/");
+    hash2.update(relative);
+    hash2.update("\0");
+    hash2.update(signature.size);
+    hash2.update("\0");
+    hash2.update(signature.mtimeMs);
+    hash2.update("\0");
+  }
+  return hash2.digest("hex");
+}
+function parseLifecycleFileSignature(value) {
+  if (typeof value !== "string")
+    return void 0;
+  if (value === "0:0")
+    return void 0;
+  const parts = value.split(":");
+  if (parts.length !== 2)
+    return void 0;
+  const [mtimeMs, size] = parts;
+  if (!mtimeMs || !size)
+    return void 0;
+  if (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(mtimeMs))
+    return void 0;
+  if (!/^(?:0|[1-9]\d*)$/.test(size))
+    return void 0;
+  const numericMtimeMs = Number(mtimeMs);
+  const numericSize = Number(size);
+  if (!Number.isFinite(numericMtimeMs) || String(numericMtimeMs) !== mtimeMs)
+    return void 0;
+  if (!Number.isSafeInteger(numericSize) || String(numericSize) !== size)
+    return void 0;
+  return { size, mtimeMs };
+}
 async function hashDiscoveredFiles(files, root) {
   const sorted = [...files].sort((left, right) => left.localeCompare(right));
   const signatures = /* @__PURE__ */ new Map();

package/dist/indexer/build-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-index.d.ts","sourceRoot":"","sources":["../../src/indexer/build-index.ts"],"names":[],"mappings":"AAuFA,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,gBAAgB,EAErB,KAAK,uBAAuB,EAI5B,KAAK,YAAY,EAIlB,MAAM,YAAY,CAAC;AAykCpB;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAEvG;AAED;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAAE,EACpB,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,YAAY,CAAC,CAgBvB;AA4BD;;;;;;GAMG;AACH,wBAAsB,4BAA4B,CAChD,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,uBAAuB,GAC7B,OAAO,CAAC,YAAY,CAAC,CA8sBvB;AAED,wBAAsB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA8IpH"}
+{"version":3,"file":"build-index.d.ts","sourceRoot":"","sources":["../../src/indexer/build-index.ts"],"names":[],"mappings":"AAuFA,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,gBAAgB,EAErB,KAAK,uBAAuB,EAI5B,KAAK,YAAY,EAIlB,MAAM,YAAY,CAAC;AA8kCpB;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAEvG;AAED;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAAE,EACpB,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,YAAY,CAAC,CAgBvB;AA4BD;;;;;;GAMG;AACH,wBAAsB,4BAA4B,CAChD,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,uBAAuB,GAC7B,OAAO,CAAC,YAAY,CAAC,CAmwBvB;AAED,wBAAsB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA8IpH"}

package/dist/indexer/build-index.js

@@ -853,6 +853,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     }
 }
 async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpts) {
+    const timings = opts?.report ? (opts.report.timings ??= {}) : undefined;
     await initializeFileIdentityCaseSensitivity(projectRoot);
     try {
         const useDiskCache = (opts?.cache ?? "off") === "disk";
@@ -888,6 +889,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
         // Git a second time.
         if (helperOpts?.reportDiscoveryProgress)
             emitIndexCheckActivity(opts, "Discovering source files");
+        const sourceDiscoveryStart = performance.now();
         const discoveredFiles = await listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
             ...opts?.discovery,
             ...(opts?.logLevel ? { logLevel: opts.logLevel } : {}),
@@ -896,6 +898,8 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
             onGitCandidatesDiscovered,
             ...(onDiscoveryProgress ? { onDiscoveryProgress } : {}),
         });
+        if (timings)
+            timings.sourceDiscoveryMs = Math.round(performance.now() - sourceDiscoveryStart);
         const additionalFileCandidates = await normalizeIndexedFileInputsWithinRoot(projectRoot, opts?.additionalFiles ?? [], "Additional index file");
         const additionalFileExistence = await probePathExistence(additionalFileCandidates, buildConcurrency(opts));
         const additionalFiles = additionalFileCandidates.filter((file) => additionalFileExistence.get(file));
@@ -904,12 +908,15 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
         const transientFiles = additionalFiles.filter((file) => !discoveredFileSet.has(file));
         if (helperOpts?.reportDiscoveryProgress)
             emitIndexCheckActivity(opts, "Discovering project metadata");
+        const metadataDiscoveryStart = performance.now();
         const projectFiles = await discoverProjectFilesWithGitCandidates(projectRoot, {
             ...(opts?.logLevel ? { logLevel: opts.logLevel } : {}),
             ...(discoveredSymlinkDirectories !== undefined ? { knownSymlinkDirectories: discoveredSymlinkDirectories } : {}),
             ...(discoveredGitCandidates !== undefined ? { knownGitCandidates: discoveredGitCandidates } : {}),
             ...(onDiscoveryProgress ? { onDiscoveryProgress } : {}),
         });
+        if (timings)
+            timings.metadataDiscoveryMs = Math.round(performance.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`,
@@ -998,6 +1005,7 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
     if (strictIncremental && graphOptions.fast)
         graphOptions.fast = false;
     const { normalizedProjectRoot, report, timings, totalStart, cacheMode, cacheEnabled, onFallbackImportExtraction } = createIndexBuildRunState(projectRoot, opts, graphOptions);
+    const discoveryTimings = opts?.report ? (opts.report.timings ??= {}) : undefined;
     let checkProgressActive = false;
     const startCheckProgress = () => {
         if (checkProgressActive)
@@ -1108,15 +1116,35 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
         // covers ordinary new-commit history when the working tree is clean at the new HEAD.
         const shouldDiffAgainstWorkingTree = !hasExplicitGitRange && gitAvailable && !!manifest.lastCommit;
         const canReuseReconciliation = opts?.reconciledManifestUpdatedAt === manifest.updatedAt;
+        let sourceDiscoveryMs = 0;
+        let sourceDiscoveryPerformed = false;
+        const measureSourceDiscovery = async (operation) => {
+            if (!discoveryTimings || opts?.filesAreProjectScope)
+                return await operation();
+            sourceDiscoveryPerformed = true;
+            const start = performance.now();
+            try {
+                return await operation();
+            }
+            finally {
+                sourceDiscoveryMs += performance.now() - start;
+            }
+        };
         let manifestDiffFiles = [];
         if (shouldDiffAgainstWorkingTree) {
             try {
-                manifestDiffFiles =
-                    (canReuseReconciliation ? opts?.reconciledWorkingTreeDiffFiles : undefined) ??
-                        (await listChangedFiles(projectRoot, {
-                            base: manifest.lastCommit,
-                            head: "WORKTREE",
-                        }));
+                const reconciledWorkingTreeDiffFiles = canReuseReconciliation
+                    ? opts?.reconciledWorkingTreeDiffFiles
+                    : undefined;
+                if (reconciledWorkingTreeDiffFiles !== undefined) {
+                    manifestDiffFiles = reconciledWorkingTreeDiffFiles;
+                }
+                else {
+                    manifestDiffFiles = await measureSourceDiscovery(() => listChangedFiles(projectRoot, {
+                        base: manifest.lastCommit,
+                        head: "WORKTREE",
+                    }));
+                }
             }
             catch (error) {
                 if (!isMissingGitRevisionError(error))
@@ -1163,7 +1191,10 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
         const previousTransientFiles = sanitizeManifestTransientFilesForRoot(projectRoot, projectRoot, manifest.transientFiles).filter((file) => Object.hasOwn(trackedEntries, file));
         const previousTransientFileSet = new Set(previousTransientFiles);
         const needsGitScan = !!opts?.gitBase || !!opts?.changedSince;
-        const gitFiles = needsGitScan ? await listChangedFiles(projectRoot, buildIncrementalGitDiffOptions(opts)) : [];
+        let gitFiles = [];
+        if (needsGitScan) {
+            gitFiles = await measureSourceDiscovery(() => listChangedFiles(projectRoot, buildIncrementalGitDiffOptions(opts)));
+        }
         // New files that were never committed, staged, or passed explicitly have no tracked
         // manifest entry and no working-tree-diff record, so they would otherwise stay
         // invisible to an incremental build until the next full rebuild. Detecting them via
@@ -1183,9 +1214,13 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
         let discoveredGitCandidates;
         if (canUseIncrementalDiscoveryFastPath(gitAvailable, opts?.cacheStrict)) {
             try {
-                untrackedFiles =
-                    (canReuseReconciliation ? opts?.reconciledUntrackedFiles : undefined) ??
-                        (await listUntrackedProjectFiles(projectRoot, opts?.discovery, gitAvailable));
+                const reconciledUntrackedFiles = canReuseReconciliation ? opts?.reconciledUntrackedFiles : undefined;
+                if (reconciledUntrackedFiles !== undefined) {
+                    untrackedFiles = reconciledUntrackedFiles;
+                }
+                else {
+                    untrackedFiles = await measureSourceDiscovery(() => listUntrackedProjectFiles(projectRoot, opts?.discovery, gitAvailable));
+                }
             }
             catch (error) {
                 if (manifestReport) {
@@ -1200,7 +1235,7 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
             }
         }
         else if (!opts?.filesAreProjectScope) {
-            rediscoveredFiles = await listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
+            rediscoveredFiles = await measureSourceDiscovery(() => listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
                 ...opts?.discovery,
                 ...(opts?.logLevel ? { logLevel: opts.logLevel } : {}),
                 ...(!opts?.cacheStrict && manifest.symlinkDirectories !== undefined
@@ -1209,7 +1244,10 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                 onGitCandidatesDiscovered: (candidates) => {
                     discoveredGitCandidates = candidates;
                 },
-            });
+            }));
+        }
+        if (discoveryTimings && sourceDiscoveryPerformed) {
+            discoveryTimings.sourceDiscoveryMs = Math.round(sourceDiscoveryMs);
         }
         const candidateFiles = [
             ...explicitFiles,
@@ -1314,10 +1352,19 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
             if (!snapshotLoad)
                 return null;
             const snapshot = snapshotLoad.index;
-            snapshot.projectFiles ??= await discoverProjectFilesWithGitCandidates(projectRoot, {
-                ...(opts?.logLevel ? { logLevel: opts.logLevel } : {}),
-                ...(discoveredGitCandidates !== undefined ? { knownGitCandidates: discoveredGitCandidates } : {}),
-            });
+            // The early Git fast path does not stat tracked files. Its persisted mtime:size
+            // values can therefore be stale after a byte-identical rewrite; lifecycle must
+            // re-stat until the validated path below replaces every signature.
+            snapshot.manifestSignaturesFresh = false;
+            if (snapshot.projectFiles === undefined) {
+                const metadataDiscoveryStart = performance.now();
+                snapshot.projectFiles = await discoverProjectFilesWithGitCandidates(projectRoot, {
+                    ...(opts?.logLevel ? { logLevel: opts.logLevel } : {}),
+                    ...(discoveredGitCandidates !== undefined ? { knownGitCandidates: discoveredGitCandidates } : {}),
+                });
+                if (discoveryTimings)
+                    discoveryTimings.metadataDiscoveryMs = Math.round(performance.now() - metadataDiscoveryStart);
+            }
             if (opts?.cache) {
                 snapshot.cacheMode = opts.cache;
                 snapshot.cacheRootDir = cacheRoot(projectRoot, opts);
@@ -1646,6 +1693,20 @@ export async function buildProjectIndexIncremental(projectRoot, opts) {
                     edges: [],
                 });
             }
+            // A Git blob match proves source bytes, not mtime. Refresh every retained
+            // entry from the stat signatures computed above before declaring lifecycle
+            // signatures fresh.
+            for (const [file, entry] of manifestEntries) {
+                const signature = fileSignatures.get(file);
+                if (!signature)
+                    continue;
+                const { gitSig: _previousGitSig, ...entryWithoutGitSig } = entry;
+                manifestEntries.set(file, {
+                    ...entryWithoutGitSig,
+                    sig: signature.sig,
+                    ...(signature.gitSig ? { gitSig: signature.gitSig } : {}),
+                });
+            }
             await writeIndexManifestSnapshot({
                 projectRoot,
                 opts,