@lzehrung/codegraph 2.2.2 → 2.3.0

package/dist/bin/cli.js

@@ -432,6 +432,13 @@ function graphCommandSchema(positionals) {
     "--symbols-detailed-scope"
   ], positionals);
 }
+function getCliCommandUsage(command) {
+  const usage = CLI_COMMAND_SCHEMAS.get(command)?.positionals.usage;
+  if (!usage) {
+    throw new Error(`No validation usage is defined for ${command}.`);
+  }
+  return usage;
+}
 function allowedFlagsForSchema(schema) {
   return /* @__PURE__ */ new Set(["--help", "-h", "--version", "-v", "--debug", ...schema.flags ?? []]);
 }
@@ -692,7 +699,8 @@ var init_options = __esm({
       [
         "affected",
         commandSchema([...SHARED_BUILD_FLAGS, "--json", "--quiet", "--stdin"], [...SHARED_BUILD_OPTIONS, "--base", "--depth", "--filter", "--head"], {
-          kind: "any"
+          kind: "any",
+          usage: "Usage: codegraph affected <file...> [--stdin] [--base <ref> --head <ref>] [--root <path>] [--depth <n>] [--filter <glob>] [--json | --quiet]"
         })
       ],
       [
@@ -716,7 +724,7 @@ var init_options = __esm({
         commandSchema([...JSON_OUTPUT_FLAGS, "--text"], ["--language", "--max-tokens", "--min-tokens"], {
           kind: "max",
           max: 1,
-          usage: "Usage: codegraph chunk <file-path> [options]"
+          usage: "Usage: codegraph chunk <file-path> [--language <language>] [--min-tokens <n>] [--max-tokens <n>] [--text] [--json | --pretty]"
         })
       ],
       [
@@ -727,10 +735,10 @@ var init_options = __esm({
       ],
       [
         "deps",
-        commandSchema([...SHARED_BUILD_FLAGS, ...JSON_OUTPUT_FLAGS], [...SHARED_BUILD_OPTIONS, "--depth"], {
+        commandSchema([...SHARED_BUILD_FLAGS, ...JSON_OUTPUT_FLAGS, "--all"], [...SHARED_BUILD_OPTIONS, "--depth"], {
           kind: "max",
           max: 1,
-          usage: "Usage: codegraph deps <file> [--root <path>] [--depth <n>] [--json | --pretty]"
+          usage: "Usage: codegraph deps <file|file::symbol|symbol:...> [--root <path>] [--depth <n> | --all] [--json | --pretty]"
         })
       ],
       [
@@ -813,7 +821,7 @@ var init_options = __esm({
         commandSchema([...SHARED_BUILD_FLAGS, ...JSON_OUTPUT_FLAGS], SHARED_BUILD_OPTIONS, {
           kind: "max",
           max: 3,
-          usage: "Usage: codegraph goto <file>[:line[:column]] [line] [column] [--root <path>] [--json | --pretty]"
+          usage: "Usage: codegraph goto <file|file::symbol|symbol:...> [--root <path>] [--json | --pretty]\n       codegraph goto <file>[:line[:column]] [line] [column] [--root <path>] [--json | --pretty]"
         })
       ],
       ["graph", graphCommandSchema({ kind: "any" })],
@@ -832,7 +840,16 @@ var init_options = __esm({
       [
         "grep",
         commandSchema(["--ignore-case", "--json", "--pretty", "-i", "--no-gitignore"], ["--glob", "--ignore-glob", "--include-glob", "--max-hits", "--pattern", "--query", "--regex", "--root"], {
-          kind: "any"
+          kind: "max",
+          max: 1,
+          // `handleGrepCommand` takes the pattern from --pattern, then --regex, then the
+          // positional, and --query is a separate syntax-tree mode. Present all three forms
+          // so a parse failure does not imply the positional regex is mandatory.
+          usage: [
+            "Usage: codegraph grep <regex> [--root <dir>] [--glob|--include-glob|--ignore-glob <glob>] [--ignore-case|-i] [--no-gitignore] [--max-hits <n>] [--json | --pretty]",
+            "       codegraph grep --pattern|--regex <expr> [--root <dir>] [--glob|--include-glob|--ignore-glob <glob>] [--ignore-case|-i] [--no-gitignore] [--max-hits <n>] [--json | --pretty]",
+            "       codegraph grep --query <tree-sitter-query> [--root <dir>] [--json | --pretty]"
+          ].join("\n")
         })
       ],
       [
@@ -872,7 +889,7 @@ var init_options = __esm({
         ], {
           kind: "max",
           max: 1,
-          usage: "Usage: codegraph impact [project-root] [--provider git|github|raw] [options]"
+          usage: "Usage: codegraph impact [project-root] [--provider git|github|raw] [--depth <n>] [options] [--json | --pretty]"
         })
       ],
       [
@@ -947,7 +964,7 @@ var init_options = __esm({
         ], {
           kind: "max",
           max: 1,
-          usage: "Usage: codegraph server <start|status|stop> [--root <path>]"
+          usage: "Usage: codegraph server <start|status|stop> [--root <path>] [--json | --pretty]"
         })
       ],
       [
@@ -974,10 +991,10 @@ var init_options = __esm({
       ],
       [
         "rdeps",
-        commandSchema([...SHARED_BUILD_FLAGS, ...JSON_OUTPUT_FLAGS], [...SHARED_BUILD_OPTIONS, "--depth"], {
+        commandSchema([...SHARED_BUILD_FLAGS, ...JSON_OUTPUT_FLAGS, "--all"], [...SHARED_BUILD_OPTIONS, "--depth"], {
           kind: "max",
           max: 1,
-          usage: "Usage: codegraph rdeps <file> [--root <path>] [--depth <n>] [--json | --pretty]"
+          usage: "Usage: codegraph rdeps <file|file::symbol|symbol:...> [--root <path>] [--depth <n> | --all] [--json | --pretty]"
         })
       ],
       [
@@ -985,7 +1002,7 @@ var init_options = __esm({
         commandSchema([...SHARED_BUILD_FLAGS, ...JSON_OUTPUT_FLAGS], [...SHARED_BUILD_OPTIONS, "--col", "--column", "--file", "--line"], {
           kind: "max",
           max: 3,
-          usage: "Usage: codegraph refs <file>[:line[:column]] [line] [column] [--root <path>] [--json | --pretty]"
+          usage: "Usage: codegraph refs <file|file::symbol|symbol:...> [--root <path>] [--json | --pretty]\n       codegraph refs <file>[:line[:column]] [line] [column] [--root <path>] [--json | --pretty]\n       codegraph refs --file <file> [--line <line> --col <column>] [--root <path>] [--json | --pretty]"
         })
       ],
       [
@@ -1095,7 +1112,7 @@ var init_options = __esm({
         commandSchema(["--json", "--pretty"], ["--db", "--query", "--sqlite"], {
           kind: "max",
           max: 2,
-          usage: 'Usage: codegraph sql <sqlite-path> "SELECT ..." [--json | --pretty] OR codegraph sql --db <sqlite path> --query "SELECT ..." [--json | --pretty]'
+          usage: 'Usage: codegraph sql <sqlite-path> "SELECT ..." [--json | --pretty] OR codegraph sql --db <sqlite-path> --query "SELECT ..." [--json | --pretty]'
         })
       ],
       [
@@ -1148,16 +1165,14 @@ function resolveCliProgressPresentation(input) {
   if (input.stderrIsTTY) {
     return input.terminalSupportsControlSequences ? "interactive" : "log";
   }
-  if (input.policy === "always")
-    return "log";
-  return "off";
+  return "log";
 }
 function createCliProgressDisplay(options) {
   if (options.presentation === "log")
-    return createLogProgressDisplay(options.write);
-  return createInteractiveProgressDisplay(options.write);
+    return createLogProgressDisplay(options.write, options.delayMs);
+  return createInteractiveProgressDisplay(options.write, options.delayMs);
 }
-function createInteractiveProgressDisplay(write) {
+function createInteractiveProgressDisplay(write, delayMs = 0) {
   let active = false;
   let rendered = false;
   let frameIndex = 0;
@@ -1165,6 +1180,7 @@ function createInteractiveProgressDisplay(write) {
   let total = 0;
   let mode = "build";
   let interval;
+  let delay;
   const clear = () => {
     if (!rendered)
       return;
@@ -1177,39 +1193,55 @@ function createInteractiveProgressDisplay(write) {
     const action = progressAction(mode);
     const frame = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length];
     frameIndex += 1;
-    const count = total > 0 ? ` ${current}/${total} files` : "";
+    const count = formatProgressCount(current, total);
     write(`${CLEAR_LINE}${action} project index... ${frame}${count}`);
     rendered = true;
   };
   const stopInterval = () => {
-    if (interval === void 0)
-      return;
-    clearInterval(interval);
-    interval = void 0;
+    if (interval !== void 0) {
+      clearInterval(interval);
+      interval = void 0;
+    }
+    if (delay !== void 0) {
+      clearTimeout(delay);
+      delay = void 0;
+    }
   };
   const start = (update) => {
     stopInterval();
     clear();
     active = true;
+    rendered = false;
     frameIndex = 0;
     current = update.current;
     total = update.total;
     mode = update.mode ?? "build";
-    render();
-    interval = setInterval(render, REFRESH_INTERVAL_MS);
-    interval.unref();
+    const beginRendering = () => {
+      if (!active)
+        return;
+      render();
+      interval = setInterval(render, REFRESH_INTERVAL_MS);
+      interval.unref();
+    };
+    if (delayMs) {
+      delay = setTimeout(beginRendering, delayMs);
+      delay.unref();
+    } else {
+      beginRendering();
+    }
   };
   const complete = (update) => {
     if (!active)
       return;
     active = false;
     stopInterval();
+    if (!rendered)
+      return;
     clear();
     const verb = progressCompleteVerb(mode);
-    const fileCount = update.total;
-    const files = fileCount === 1 ? "file" : "files";
+    const fileCount = formatFileCount(update.total, "words");
     const elapsed = update.elapsedMs === void 0 ? "" : ` in ${formatDuration(update.elapsedMs)}`;
-    write(`${verb} project index: ${fileCount} ${files}${elapsed}.
+    write(`${verb} project index: ${fileCount}${elapsed}.
 `);
   };
   return {
@@ -1239,37 +1271,92 @@ function createInteractiveProgressDisplay(write) {
     }
   };
 }
-function createLogProgressDisplay(write) {
+function formatFileCount(count, zeroFormat = "numeric") {
+  if (!count && zeroFormat === "words")
+    return "no files";
+  return `${count} file${count === 1 ? "" : "s"}`;
+}
+function formatProgressCount(current, total) {
+  if (total > 0)
+    return ` ${current}/${formatFileCount(total)}`;
+  return ` ${formatFileCount(current)} processed`;
+}
+function createLogProgressDisplay(write, delayMs = 0) {
   let active = false;
+  let rendered = false;
+  let current = 0;
+  let total = 0;
   let mode = "build";
+  let delay;
+  let heartbeat;
+  const stopTimers = () => {
+    if (delay !== void 0) {
+      clearTimeout(delay);
+      delay = void 0;
+    }
+    if (heartbeat !== void 0) {
+      clearInterval(heartbeat);
+      heartbeat = void 0;
+    }
+  };
+  const renderStart = () => {
+    if (!active || rendered)
+      return;
+    rendered = true;
+    write(`[Progress] ${progressAction(mode)} project index.
+`);
+    heartbeat = setInterval(() => {
+      if (!active)
+        return;
+      write(`[Progress] ${progressAction(mode)} project index:${formatProgressCount(current, total)}.
+`);
+    }, 1e3);
+    heartbeat.unref();
+  };
+  const start = (update) => {
+    stopTimers();
+    active = true;
+    rendered = false;
+    current = update.current;
+    total = update.total;
+    mode = update.mode ?? "build";
+    if (delayMs) {
+      delay = setTimeout(renderStart, delayMs);
+      delay.unref();
+    } else {
+      renderStart();
+    }
+  };
   return {
     update: (update) => {
       if (update.phase === "start") {
-        active = true;
-        mode = update.mode ?? "build";
-        const action = progressAction(mode);
-        write(`[Progress] ${action} project index.
-`);
+        start(update);
         return;
       }
       if (update.phase === "complete") {
         if (!active)
           return;
         active = false;
+        stopTimers();
+        if (!rendered)
+          return;
         const verb = progressCompleteVerb(mode);
         const elapsed = update.elapsedMs === void 0 ? "" : ` in ${formatDuration(update.elapsedMs)}`;
-        write(`[Progress] ${verb} project index: ${update.total} files${elapsed}.
+        write(`[Progress] ${verb} project index: ${formatFileCount(update.total, "words")}${elapsed}.
 `);
         return;
       }
       if (!active) {
         if (update.phase === "update")
           return;
-        active = true;
+        start(update);
       }
-      const isComplete = update.current >= update.total;
-      if (update.current === 1 || isComplete || update.current % 100 === 0) {
-        write(`[Progress] ${update.current}/${update.total} files processed.
+      current = update.current;
+      total = update.total;
+      mode = update.mode ?? mode;
+      const isComplete = update.total > 0 && update.current >= update.total;
+      if (rendered && (update.current === 1 || isComplete || update.current % 100 === 0)) {
+        write(`[Progress] ${formatFileCount(update.current)} processed.
 `);
       }
     },
@@ -1277,6 +1364,7 @@ function createLogProgressDisplay(write) {
     },
     dispose: () => {
       active = false;
+      stopTimers();
     }
   };
 }
@@ -1295,9 +1383,10 @@ function progressCompleteVerb(mode) {
   return "Checked";
 }
 function formatDuration(elapsedMs2) {
-  if (elapsedMs2 < 1e3)
-    return `${Math.max(0, Math.round(elapsedMs2))}ms`;
-  return `${(elapsedMs2 / 1e3).toFixed(1)}s`;
+  const durationMs = Math.max(0, elapsedMs2);
+  if (durationMs < 1e3)
+    return `${Math.round(durationMs)}ms`;
+  return `${(durationMs / 1e3).toFixed(1)}s`;
 }
 var REFRESH_INTERVAL_MS, CLEAR_LINE, SPINNER_FRAMES;
 var init_progress = __esm({
@@ -1519,7 +1608,8 @@ function createCliProgressHandler(policy) {
   context.progressDisplay?.dispose();
   const display = createCliProgressDisplay({
     presentation,
-    write: context.runtime.stderr
+    write: context.runtime.stderr,
+    ...policy === "auto" ? { delayMs: 1e3 } : {}
   });
   context.progressDisplay = display;
   return display.update;
@@ -4671,9 +4761,9 @@ var require_path = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
-    var os11 = __require("os");
+    var os12 = __require("os");
     var path99 = __require("path");
-    var IS_WINDOWS_PLATFORM = os11.platform() === "win32";
+    var IS_WINDOWS_PLATFORM = os12.platform() === "win32";
     var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
     var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
     var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
@@ -10191,8 +10281,8 @@ var require_settings4 = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
     var fs49 = __require("fs");
-    var os11 = __require("os");
-    var CPU_COUNT = Math.max(os11.cpus().length, 1);
+    var os12 = __require("os");
+    var CPU_COUNT = Math.max(os12.cpus().length, 1);
     exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
       lstat: fs49.lstat,
       lstatSync: fs49.lstatSync,
@@ -13403,1029 +13493,1256 @@ var init_concurrency = __esm({
   }
 });
 
-// dist/util/projectFiles.js
-var projectFiles_exports = {};
-__export(projectFiles_exports, {
-  DEFAULT_PROJECT_FILE_IGNORES: () => DEFAULT_PROJECT_FILE_IGNORES,
-  DEFAULT_PROJECT_MANIFESTS: () => DEFAULT_PROJECT_MANIFESTS,
-  DEFAULT_PROJECT_PATTERNS: () => DEFAULT_PROJECT_PATTERNS,
-  createDiscoveredFileMatcher: () => createDiscoveredFileMatcher,
-  discoverProjectFiles: () => discoverProjectFiles,
-  filterRealPathsWithinRoot: () => filterRealPathsWithinRoot,
-  isRelativePathInside: () => isRelativePathInside,
-  listProjectFiles: () => listProjectFiles,
-  matchesDiscoveryGlob: () => matchesDiscoveryGlob,
-  translateGlobRootIgnoreGlobsForScanRoot: () => translateGlobRootIgnoreGlobsForScanRoot
+// dist/util/git.js
+var git_exports = {};
+__export(git_exports, {
+  DEFAULT_GIT_TIMEOUT_MS: () => DEFAULT_GIT_TIMEOUT_MS,
+  assertSafeRevision: () => assertSafeRevision,
+  clearGitDiscoveryCacheForTests: () => clearGitDiscoveryCacheForTests,
+  clearGitRepositoryCheckCacheForTests: () => clearGitRepositoryCheckCacheForTests,
+  decodeGitPath: () => decodeGitPath,
+  getGitBlobHashes: () => getGitBlobHashes,
+  getGitHead: () => getGitHead,
+  getUnifiedDiff: () => getUnifiedDiff,
+  gitDiffArgs: () => gitDiffArgs,
+  isGitIndexSentinel: () => isGitIndexSentinel,
+  isGitPathIgnored: () => isGitPathIgnored,
+  isGitPathTracked: () => isGitPathTracked,
+  isGitProjectRootIgnored: () => isGitProjectRootIgnored,
+  isGitRepo: () => isGitRepo,
+  isGitWorktreeSentinel: () => isGitWorktreeSentinel,
+  listChangedFiles: () => listChangedFiles,
+  listGitExcludeFiles: () => listGitExcludeFiles,
+  listGitSubmoduleDirectories: () => listGitSubmoduleDirectories,
+  listTrackedFiles: () => listTrackedFiles,
+  listUntrackedFiles: () => listUntrackedFiles,
+  runGit: () => runGit,
+  setGitExecutableForTests: () => setGitExecutableForTests
 });
-import fs6 from "node:fs";
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
 import fsp4 from "node:fs/promises";
+import os2 from "node:os";
 import path8 from "node:path";
-function isPresent(value) {
-  return value !== void 0;
-}
-function normalizeGlobPattern(globPattern) {
-  return globPattern.trim().replace(/\\/g, "/");
-}
-function isIgnoreGlobReopenedByIncludes(ignoreGlob, includeGlobs) {
-  const literalSegments = ignoreGlob.split("/").filter((segment) => segment && !segment.includes("*"));
-  if (!literalSegments.length)
-    return false;
-  return includeGlobs.some((includeGlob) => {
-    const includeSegments = includeGlob.split("/");
-    return literalSegments.every((segment) => includeSegments.includes(segment));
-  });
-}
-function isLocationIndependentGlob(globPattern) {
-  return globPattern.startsWith("**/");
-}
-function translateGlobRootIgnoreGlobsForScanRoot(scanRoot, globRoot, ignoreGlobs) {
-  const relativeScanRoot = normalizePath(path8.relative(globRoot, scanRoot));
-  if (!relativeScanRoot || !isRelativePathInside(relativeScanRoot)) {
-    return ignoreGlobs.map(normalizeGlobPattern).filter(Boolean);
+function decodeGitPath(rawPath) {
+  if (!rawPath.startsWith('"') || !rawPath.endsWith('"')) {
+    return rawPath;
   }
-  const rootPrefix = `${relativeScanRoot}/`;
-  return ignoreGlobs.map(normalizeGlobPattern).filter(Boolean).map((globPattern) => {
-    const rootRelativePattern = globPattern.startsWith("/") ? globPattern.slice(1) : globPattern;
-    if (isLocationIndependentGlob(rootRelativePattern))
-      return rootRelativePattern;
-    if (rootRelativePattern === relativeScanRoot || rootRelativePattern === `${relativeScanRoot}/**`)
-      return "**";
-    if (rootRelativePattern.startsWith(rootPrefix))
-      return rootRelativePattern.slice(rootPrefix.length) || "**";
-    return void 0;
-  }).filter(isPresent);
-}
-function stripGitignoreTrailingSpaces(line) {
-  let end = line.length;
-  while (end > 0 && line[end - 1] === " ") {
-    let slashCount = 0;
-    for (let i = end - 2; i >= 0 && line[i] === "\\"; i -= 1) {
-      slashCount += 1;
+  const inner = rawPath.slice(1, -1);
+  const bytes = [];
+  for (let index = 0; index < inner.length; ) {
+    const char = inner[index];
+    if (char !== "\\") {
+      const codePoint = inner.codePointAt(index);
+      bytes.push(...Buffer.from(String.fromCodePoint(codePoint), "utf8"));
+      index += codePoint > 65535 ? 2 : 1;
+      continue;
     }
-    if (slashCount % 2 === 1) {
-      break;
+    const octal = inner.slice(index + 1, index + 4).match(/^[0-7]{1,3}/);
+    if (octal) {
+      bytes.push(parseInt(octal[0], 8) & 255);
+      index += 1 + octal[0].length;
+      continue;
     }
-    end -= 1;
-  }
-  return line.slice(0, end);
-}
-function parseGitignoreRule(baseDir, rawLine) {
-  const trimmedLine = stripGitignoreTrailingSpaces(rawLine);
-  if (!trimmedLine)
-    return null;
-  if (trimmedLine.startsWith("#"))
-    return null;
-  const negated = trimmedLine.startsWith("!");
-  let pattern = negated ? trimmedLine.slice(1) : trimmedLine;
-  if (!pattern || pattern === "/")
-    return null;
-  const dirOnly = pattern.endsWith("/");
-  if (dirOnly) {
-    pattern = pattern.slice(0, -1);
-  }
-  if (pattern.startsWith("/")) {
-    pattern = pattern.slice(1);
-  }
-  pattern = pattern.replace(/^\\([#!])/, "$1").replace(/\\/g, "/");
-  if (!pattern)
-    return null;
-  const anchored = trimmedLine.startsWith("/") || negated && trimmedLine.startsWith("!/");
-  const baseMatcherPattern = anchored || pattern.includes("/") ? pattern : `**/${pattern}`;
-  const matcherPattern = dirOnly ? `${baseMatcherPattern}/**` : [baseMatcherPattern, `${baseMatcherPattern}/**`];
-  const matches = (0, import_picomatch.default)(matcherPattern, { dot: true });
-  return {
-    baseDir: normalizePath(baseDir),
-    negated,
-    dirOnly,
-    matches
-  };
-}
-async function loadGitignoreRules(projectRoot) {
-  const gitignoreFiles = await (0, import_fast_glob2.default)(["**/.gitignore"], {
-    cwd: projectRoot,
-    absolute: true,
-    dot: true,
-    followSymbolicLinks: false,
-    ignore: DEFAULT_PROJECT_FILE_IGNORES
-  });
-  gitignoreFiles.sort((left, right) => normalizePath(left).localeCompare(normalizePath(right)));
-  const rules = [];
-  for (const gitignoreFile of gitignoreFiles) {
-    if (isIgnoredByGitignore(gitignoreFile, rules)) {
+    const next = inner[index + 1];
+    if (next === "\\" || next === '"') {
+      bytes.push(next.charCodeAt(0));
+      index += 2;
       continue;
     }
-    try {
-      const baseDir = path8.dirname(gitignoreFile);
-      const raw = await fsp4.readFile(gitignoreFile, "utf8");
-      rules.push(...raw.split(/\r?\n/).map((line) => parseGitignoreRule(baseDir, line)).filter((rule) => !!rule));
-    } catch {
+    const singleByteEscape = GIT_QUOTED_PATH_SINGLE_BYTE_ESCAPES[next ?? ""];
+    if (singleByteEscape !== void 0) {
+      bytes.push(singleByteEscape);
+      index += 2;
       continue;
     }
+    bytes.push(92);
+    index += 1;
   }
-  return rules;
+  return Buffer.from(bytes).toString("utf8");
 }
-async function loadGitignoreRulesForRootAliases(projectRoot) {
-  const roots = [projectRoot];
-  const realRoot = await fsp4.realpath(projectRoot);
-  if (normalizePath(realRoot) !== normalizePath(projectRoot)) {
-    roots.push(realRoot);
-  }
-  const rules = [];
-  for (const root of roots) {
-    rules.push(...await loadGitignoreRules(root));
+function setGitExecutableForTests(executable) {
+  gitExecutableForTests = executable;
+}
+function clearGitRepositoryCheckCacheForTests() {
+  gitRepositoryChecks.clear();
+}
+function clearGitDiscoveryCacheForTests() {
+  gitDiscoveryRootIgnoredChecks.clear();
+  gitExcludeFileChecks.clear();
+}
+function resolveGitTimeoutMs(timeoutMs) {
+  if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+    return Math.floor(timeoutMs);
   }
-  return rules;
+  return DEFAULT_GIT_TIMEOUT_MS;
 }
-function isIgnoredByGitignore(absolutePath, rules) {
-  let ignored = false;
-  for (const rule of rules) {
-    const relativePath3 = path8.relative(rule.baseDir, absolutePath);
-    if (!isRelativePathInside(relativePath3)) {
-      continue;
-    }
-    const normalizedRelativePath2 = normalizePath(relativePath3);
-    if (rule.dirOnly && !normalizedRelativePath2.includes("/")) {
-      continue;
-    }
-    if (rule.matches(normalizedRelativePath2)) {
-      ignored = !rule.negated;
+function appendBoundedTail(current, chunk, maxBytes) {
+  function utf8Tail(value, byteLimit) {
+    let start = value.length;
+    let bytes = 0;
+    while (start) {
+      const last = value.charCodeAt(start - 1);
+      const preceding = start > 1 ? value.charCodeAt(start - 2) : void 0;
+      const isSurrogatePair = last >= 56320 && last <= 57343 && preceding !== void 0 && preceding >= 55296 && preceding <= 56319;
+      const codeUnits = isSurrogatePair ? 2 : 1;
+      let codePointBytes = 3;
+      if (isSurrogatePair) {
+        codePointBytes = 4;
+      } else if (last <= 127) {
+        codePointBytes = 1;
+      } else if (last <= 2047) {
+        codePointBytes = 2;
+      }
+      if (bytes + codePointBytes > byteLimit)
+        break;
+      bytes += codePointBytes;
+      start -= codeUnits;
     }
+    return value.slice(start);
   }
-  return ignored;
+  if (maxBytes <= 0)
+    return "";
+  const retainedChunk = utf8Tail(chunk, maxBytes);
+  const retainedChunkBytes = Buffer.byteLength(retainedChunk, "utf8");
+  if (retainedChunkBytes >= maxBytes)
+    return retainedChunk;
+  return utf8Tail(current, maxBytes - retainedChunkBytes) + retainedChunk;
 }
-async function ensureDirectoryReadable(directoryPath, label) {
-  const resolvedPath = path8.resolve(directoryPath);
-  let stats;
+function killGitChild(child) {
+  if (child.killed || child.exitCode !== null)
+    return;
   try {
-    stats = await fsp4.stat(resolvedPath);
-  } catch (error51) {
-    throw new Error(`${label} does not exist or is not readable: ${resolvedPath} (${stringifyUnknown(error51)})`);
-  }
-  if (!stats.isDirectory()) {
-    throw new Error(`${label} is not a directory: ${resolvedPath}`);
+    child.kill("SIGTERM");
+  } catch {
   }
-  return resolvedPath;
+  setTimeout(() => {
+    if (child.killed || child.exitCode !== null)
+      return;
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }, 1e3).unref?.();
 }
-async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS, options) {
-  const root = await ensureDirectoryReadable(projectRoot, "Project root");
-  const globRoot = options?.globRoot ? await ensureDirectoryReadable(options.globRoot, "Glob root") : root;
-  const includeGlobs = (options?.includeGlobs ?? []).map(normalizeGlobPattern).filter(Boolean);
-  const includeMatchers = includeGlobs.map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
-  const userIgnoreGlobs = (options?.ignoreGlobs ?? []).map(normalizeGlobPattern).filter(Boolean);
-  const userIgnoreMatchers = userIgnoreGlobs.map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
-  const defaultIgnoreMatchers = DEFAULT_PROJECT_FILE_IGNORES.map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
-  const patternMatchers = patterns.map((pattern) => (0, import_picomatch.default)(normalizeGlobPattern(pattern), { dot: true }));
-  const translatedUserIgnoreGlobs = translateGlobRootIgnoreGlobsForScanRoot(root, globRoot, userIgnoreGlobs);
-  const fastGlobIgnoreGlobs = [...DEFAULT_PROJECT_FILE_IGNORES, ...translatedUserIgnoreGlobs];
-  const symlinkProbeIgnoreGlobs = includeGlobs.length ? [
-    ...translatedUserIgnoreGlobs,
-    ...DEFAULT_PROJECT_FILE_IGNORES.filter((ignoreGlob) => !isIgnoreGlobReopenedByIncludes(ignoreGlob, includeGlobs))
-  ] : fastGlobIgnoreGlobs;
-  try {
-    const useGitignore = options?.useGitignore ?? true;
-    const realRoot = await fsp4.realpath(root);
-    const gitignoreRules = !useGitignore ? [] : await loadGitignoreRulesForRootAliases(options?.gitignoreRoot ? await ensureDirectoryReadable(options.gitignoreRoot, "Gitignore root") : root);
-    const files = await (0, import_fast_glob2.default)(patterns, {
-      cwd: root,
-      absolute: true,
-      dot: true,
-      followSymbolicLinks: false,
-      ignore: fastGlobIgnoreGlobs
+async function runGit(projectRoot, args, options) {
+  const timeoutMs = resolveGitTimeoutMs(options?.timeoutMs);
+  const maxBuffer = options?.maxBuffer ?? 64 * 1024 * 1024;
+  const executable = gitExecutableForTests ?? "git";
+  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, {
+      cwd: projectRoot,
+      env: process.env,
+      stdio: [options?.input !== void 0 ? "pipe" : "ignore", "pipe", "pipe"],
+      windowsHide: true
     });
-    const includedOverrideFiles = includeGlobs.length ? await (0, import_fast_glob2.default)(translateGlobRootIgnoreGlobsForScanRoot(root, globRoot, includeGlobs), {
-      cwd: root,
-      absolute: true,
-      dot: true,
-      followSymbolicLinks: false,
-      ignore: translatedUserIgnoreGlobs
-    }) : [];
-    const symlinkOptions = {
-      globRoot,
-      ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
-      ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {}
+    options?.onSpawn?.(child.pid === void 0 ? {} : { pid: child.pid });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    let aborted2 = false;
+    let totalBytes = 0;
+    let stderrBytes = 0;
+    let stderrOverflowed = false;
+    const settle = (fn) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (signal)
+        signal.removeEventListener("abort", onAbort);
+      fn();
     };
-    const safeSymlinkDirectories = await resolveSafeSymlinkDirectories(root, realRoot, symlinkProbeIgnoreGlobs, symlinkOptions);
-    const linkedFiles = await listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, fastGlobIgnoreGlobs, {
-      ...symlinkOptions,
-      filterIgnoreGlobs: [...DEFAULT_PROJECT_FILE_IGNORES, ...userIgnoreGlobs],
-      resolvedSafeSymlinkDirectories: safeSymlinkDirectories
-    });
-    const linkedOverrideFiles = includeGlobs.length === 0 ? [] : await listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, translatedUserIgnoreGlobs, {
-      globRoot,
-      filterIgnoreGlobs: userIgnoreGlobs,
-      resolvedSafeSymlinkDirectories: safeSymlinkDirectories
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killGitChild(child);
+    }, timeoutMs);
+    timer.unref?.();
+    const onAbort = () => {
+      aborted2 = true;
+      killGitChild(child);
+    };
+    if (signal)
+      signal.addEventListener("abort", onAbort, { once: true });
+    const stdoutStream = child.stdout;
+    const stderrStream = child.stderr;
+    if (!stdoutStream || !stderrStream) {
+      killGitChild(child);
+      settle(() => reject(createGitError(projectRoot, args, new Error("git child missing stdio pipes"))));
+      return;
+    }
+    const stdoutDecoder = new StringDecoder("utf8");
+    const stderrDecoder = new StringDecoder("utf8");
+    stdoutStream.on("data", (chunk) => {
+      const chunkBytes = typeof chunk === "string" ? Buffer.byteLength(chunk, "utf8") : chunk.length;
+      totalBytes += chunkBytes;
+      if (totalBytes > maxBuffer) {
+        killGitChild(child);
+        settle(() => reject(createGitError(projectRoot, args, new Error(`stdout exceeded maxBuffer (${maxBuffer} bytes)`))));
+        return;
+      }
+      stdout += typeof chunk === "string" ? chunk : stdoutDecoder.write(chunk);
     });
-    const rootSafeFiles = await filterRealPathsWithinRootEntries([...files, ...includedOverrideFiles, ...linkedFiles, ...linkedOverrideFiles], realRoot);
-    const seen = /* @__PURE__ */ new Set();
-    return rootSafeFiles.map(({ path: filePath, realPath }) => ({ filePath: normalizePath(filePath), realPath })).filter(({ filePath, realPath }) => {
-      if (seen.has(filePath))
-        return false;
-      seen.add(filePath);
-      const rootRelative = normalizePath(path8.relative(root, filePath));
-      if (!isRelativePathInside(rootRelative))
-        return false;
-      if (!patternMatchers.some((matcher) => matcher(rootRelative)))
-        return false;
-      const matchesInclude = !includeMatchers.length || includeMatchers.some((matcher) => matchesDiscoveryGlob(filePath, globRoot, matcher));
-      if (!matchesInclude)
-        return false;
-      if (userIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(filePath, globRoot, matcher))) {
-        return false;
+    stderrStream.on("data", (chunk) => {
+      if (stderrOverflowed)
+        return;
+      const chunkBytes = typeof chunk === "string" ? Buffer.byteLength(chunk, "utf8") : chunk.length;
+      stderrBytes += chunkBytes;
+      const decoded = typeof chunk === "string" ? chunk : stderrDecoder.write(chunk);
+      stderr = appendBoundedTail(stderr, decoded, maxBuffer);
+      if (stderrBytes > maxBuffer) {
+        stderrOverflowed = true;
+        killGitChild(child);
+        settle(() => reject(createGitError(projectRoot, args, new Error(`stderr exceeded maxBuffer (${maxBuffer} bytes): ${stderr.trim()}`))));
       }
-      const ignoredByDefault = defaultIgnoreMatchers.some((matcher) => matcher(rootRelative));
-      if (ignoredByDefault && !(includeMatchers.length > 0 && matchesInclude)) {
-        return false;
+    });
+    child.on("error", (error51) => {
+      settle(() => reject(createGitError(projectRoot, args, error51)));
+    });
+    child.on("close", (code, signalName) => {
+      stdout += stdoutDecoder.end();
+      stderr = appendBoundedTail(stderr, stderrDecoder.end(), maxBuffer);
+      settle(() => {
+        if (timedOut) {
+          reject(createGitError(projectRoot, args, new Error(`timed out after ${timeoutMs}ms${stderr ? `: ${stderr.trim()}` : ""}`)));
+          return;
+        }
+        if (aborted2) {
+          reject(createGitError(projectRoot, args, new Error(`aborted${stderr ? `: ${stderr.trim()}` : ""}`)));
+          return;
+        }
+        if (code !== 0) {
+          reject(new Error(`git ${args.join(" ")} failed (${code ?? signalName ?? "unknown"}): ${stderr || stdout || "unknown error"}`));
+          return;
+        }
+        resolve({ stdout, stderr });
+      });
+    });
+    if (options?.input !== void 0) {
+      if (!child.stdin) {
+        killGitChild(child);
+        settle(() => reject(createGitError(projectRoot, args, new Error("git child missing stdin pipe"))));
+        return;
       }
-      return !isIgnoredByGitignore(filePath, gitignoreRules) && !isIgnoredByGitignore(realPath, gitignoreRules);
-    }).map(({ filePath }) => filePath);
-  } catch (error51) {
-    logWithLevel(options?.logLevel, "debug", `listProjectFiles failed for ${root}: ${stringifyUnknown(error51)}`);
-    throw new Error(`Failed to list files in ${root}: ${stringifyUnknown(error51)}`);
+      child.stdin.write(options.input);
+      child.stdin.end();
+    }
+  });
+}
+async function runGitCollectStdout(projectRoot, args) {
+  const { stdout } = await runGit(projectRoot, args);
+  return stdout;
+}
+function isGitWorktreeSentinel(value) {
+  return value.toUpperCase() === "WORKTREE";
+}
+function isGitIndexSentinel(value) {
+  const normalized = value.toUpperCase();
+  return normalized === "INDEX" || normalized === "STAGED";
+}
+function assertSafeRevision(value, label) {
+  if (UNSAFE_REVISION_CHARACTERS.test(value)) {
+    throw new Error(`Invalid ${label}: revisions must not contain NUL or newline characters.`);
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`Invalid ${label}: revision must not be empty.`);
+  }
+  if (trimmed.startsWith("-")) {
+    throw new Error(`Invalid ${label} "${trimmed}": revisions must not start with "-".`);
   }
+  return trimmed;
 }
-function createDiscoveredFileMatcher(root, globRoot, patterns, options) {
-  const patternMatchers = patterns.map((pattern) => (0, import_picomatch.default)(normalizeGlobPattern(pattern), { dot: true }));
-  const defaultIgnoreMatchers = DEFAULT_PROJECT_FILE_IGNORES.map((pattern) => (0, import_picomatch.default)(normalizeGlobPattern(pattern), { dot: true }));
-  const includeMatchers = (options?.includeGlobs ?? []).map(normalizeGlobPattern).filter(Boolean).map((pattern) => (0, import_picomatch.default)(pattern, { dot: true }));
-  const userIgnoreMatchers = (options?.ignoreGlobs ?? []).map(normalizeGlobPattern).filter(Boolean).map((pattern) => (0, import_picomatch.default)(pattern, { dot: true }));
-  return (absolutePath) => {
-    const rootRelative = path8.relative(root, absolutePath);
-    if (!isRelativePathInside(rootRelative))
-      return false;
-    const normalizedRootRelative = normalizePath(rootRelative);
-    if (!patternMatchers.some((matcher) => matcher(normalizedRootRelative)))
-      return false;
-    const matchesInclude = !includeMatchers.length || includeMatchers.some((matcher) => matchesDiscoveryGlob(absolutePath, globRoot, matcher));
-    if (!matchesInclude)
-      return false;
-    if (defaultIgnoreMatchers.some((matcher) => matcher(normalizedRootRelative))) {
-      if (!(includeMatchers.length > 0 && matchesInclude))
-        return false;
-    }
-    return !userIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(absolutePath, globRoot, matcher));
-  };
+function gitDiffArgs(base, head, extraArgs = []) {
+  const safeBase = assertSafeRevision(base, "base");
+  const diffSafetyArgs = ["--no-ext-diff", "--no-textconv"];
+  const renameArgs = ["--find-renames"];
+  if (isGitWorktreeSentinel(head)) {
+    return ["diff", ...diffSafetyArgs, ...renameArgs, ...extraArgs, "--end-of-options", safeBase];
+  }
+  if (isGitIndexSentinel(head)) {
+    return ["diff", "--cached", ...diffSafetyArgs, ...renameArgs, ...extraArgs, "--end-of-options", safeBase];
+  }
+  const safeHead = assertSafeRevision(head, "head");
+  return ["diff", ...diffSafetyArgs, ...renameArgs, ...extraArgs, "--end-of-options", `${safeBase}..${safeHead}`];
 }
-async function isSafeSymlinkDirectory(root, linkPath, realRoot) {
+async function getGitHead(projectRoot) {
   try {
-    if (!isRelativePathInside(path8.relative(root, linkPath)))
-      return false;
-    const [linkStats, realPath, targetStats] = await Promise.all([
-      fsp4.lstat(linkPath),
-      fsp4.realpath(linkPath),
-      fsp4.stat(linkPath)
-    ]);
-    if (!linkStats.isSymbolicLink())
-      return false;
-    if (!targetStats.isDirectory())
-      return false;
-    if (!isFilePathWithinRoot(realRoot, realPath))
-      return false;
-    return normalizePath(realPath) !== normalizePath(realRoot);
+    const { stdout } = await runGit(projectRoot, ["rev-parse", "HEAD"]);
+    const hash2 = stdout.trim();
+    return hash2 || null;
   } catch {
-    return false;
+    return null;
   }
 }
-async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
-  if (options.knownSymlinkDirectories !== void 0) {
-    const verified = await mapLimitSemaphore(Array.from(new Set(options.knownSymlinkDirectories)), REALPATH_FILTER_CONCURRENCY, async (linkPath) => await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null);
-    const resolved = verified.filter((entry) => entry !== null);
-    options.onSymlinkDirectoriesDiscovered?.(resolved);
-    return resolved;
-  }
-  const entries = await (0, import_fast_glob2.default)(["**/*"], {
-    cwd: root,
-    absolute: true,
-    dot: true,
-    onlyFiles: false,
-    followSymbolicLinks: false,
-    objectMode: true,
-    ignore
-  });
-  const candidates = await mapLimitSemaphore(entries.filter((entry) => entry.dirent.isSymbolicLink()).map((entry) => entry.path), REALPATH_FILTER_CONCURRENCY, async (linkPath) => await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null);
-  const discovered = candidates.filter((entry) => entry !== null);
-  options.onSymlinkDirectoriesDiscovered?.(discovered);
-  return discovered;
+async function isGitRepo(projectRoot) {
+  const resolvedRoot = path8.resolve(projectRoot);
+  const cached2 = gitRepositoryChecks.get(resolvedRoot);
+  if (cached2)
+    return await cached2;
+  const check2 = (async () => {
+    try {
+      const { stdout } = await runGit(resolvedRoot, ["rev-parse", "--is-inside-work-tree"]);
+      return stdout.trim() === "true";
+    } catch {
+      return false;
+    }
+  })();
+  gitRepositoryChecks.set(resolvedRoot, check2);
+  return await check2;
 }
-async function listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, ignore, options = {}) {
-  const globRoot = options.globRoot ?? root;
-  const filterIgnoreGlobs = options.filterIgnoreGlobs ?? ignore;
-  const rootRelativeIgnoreMatchers = filterIgnoreGlobs.map(normalizeGlobPattern).filter(Boolean).map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
-  const locationIndependentIgnores = ignore.map(normalizeGlobPattern).filter(isLocationIndependentGlob);
-  const safeSymlinkDirectories = options.resolvedSafeSymlinkDirectories ?? await resolveSafeSymlinkDirectories(root, realRoot, ignore, options);
-  if (!safeSymlinkDirectories.length)
+async function isGitPathTracked(projectRoot, file2) {
+  return await runGitPathPredicate(projectRoot, ["ls-files", "--error-unmatch", "--", normalizePath(file2)]);
+}
+async function isGitPathIgnored(projectRoot, file2) {
+  return await runGitPathPredicate(projectRoot, ["check-ignore", "--quiet", "--no-index", "--", normalizePath(file2)]);
+}
+async function isGitProjectRootIgnored(projectRoot) {
+  const resolvedRoot = path8.resolve(projectRoot);
+  const cached2 = gitDiscoveryRootIgnoredChecks.get(resolvedRoot);
+  if (cached2)
+    return await cached2;
+  const check2 = isGitPathIgnored(resolvedRoot, resolvedRoot);
+  gitDiscoveryRootIgnoredChecks.set(resolvedRoot, check2);
+  return await check2;
+}
+async function runGitPathPredicate(projectRoot, args) {
+  try {
+    await runGit(projectRoot, args);
+    return true;
+  } catch (error51) {
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    if (/\bfailed \(1\):/.test(message))
+      return false;
+    if (error51 instanceof Error && message.startsWith(`git ${args.join(" ")} failed in ${projectRoot}:`)) {
+      throw error51;
+    }
+    throw createGitError(projectRoot, args, error51);
+  }
+}
+async function getGitBlobHashes(projectRoot, files, opts) {
+  const gitAvailable = opts?.gitAvailable ?? true;
+  if (!gitAvailable)
+    return /* @__PURE__ */ new Map();
+  const relFileSet = new Set(files.map((file2) => normalizePath(path8.relative(projectRoot, file2))).filter((rel) => rel && !rel.startsWith("..") && !path8.isAbsolute(rel) && rel !== "."));
+  if (!relFileSet.size)
+    return /* @__PURE__ */ new Map();
+  try {
+    const { stdout: trackedStdout } = await runGit(projectRoot, ["ls-files", "-z"], {
+      maxBuffer: 64 * 1024 * 1024
+    });
+    const trackedRel = trackedStdout.split("\0").filter((rel) => rel && relFileSet.has(rel));
+    if (!trackedRel.length)
+      return /* @__PURE__ */ new Map();
+    const hashes = await hashGitPaths(projectRoot, trackedRel);
+    if (hashes.length !== trackedRel.length) {
+      logWithLevel(opts?.logLevel, "warn", `Warning: git hash-object returned ${hashes.length} hash(es) for ${trackedRel.length} requested file(s); discarding Git signatures for this build.`);
+      return /* @__PURE__ */ new Map();
+    }
+    const out = /* @__PURE__ */ new Map();
+    for (let i = 0; i < trackedRel.length; i += 1) {
+      const rel = trackedRel[i];
+      const hash2 = hashes[i];
+      if (!hash2)
+        continue;
+      const abs = normalizePath(path8.resolve(projectRoot, rel));
+      out.set(abs, hash2);
+    }
+    return out;
+  } catch (error51) {
+    logWithLevel(opts?.logLevel, "warn", "Warning: Failed to read Git blob hashes; falling back to content hashing.", error51);
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function hashGitPaths(projectRoot, trackedRel) {
+  const batches = [];
+  let currentBatch = [];
+  let currentBatchBytes = 0;
+  for (const rel of trackedRel) {
+    const absolutePath = path8.resolve(projectRoot, rel);
+    const pathBytes = Buffer.byteLength(absolutePath, "utf8") + 1;
+    const wouldExceedBatchLimit = currentBatch.length && currentBatchBytes + pathBytes > MAX_GIT_HASH_OBJECT_ARGUMENT_BYTES;
+    if (wouldExceedBatchLimit) {
+      batches.push(currentBatch);
+      currentBatch = [];
+      currentBatchBytes = 0;
+    }
+    currentBatch.push(absolutePath);
+    currentBatchBytes += pathBytes;
+  }
+  if (currentBatch.length)
+    batches.push(currentBatch);
+  const hashes = [];
+  for (const batch of batches) {
+    const { stdout } = await runGit(projectRoot, ["hash-object", "--", ...batch]);
+    hashes.push(...stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+  }
+  return hashes;
+}
+async function listChangedFiles(projectRoot, opts) {
+  let args = [
+    "diff",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--find-renames",
+    "--name-only",
+    "-z",
+    "--diff-filter=ACDMRTUXB"
+  ];
+  if (opts.base) {
+    const head = opts.head ?? "HEAD";
+    args = gitDiffArgs(opts.base, head, ["--name-only", "-z", "--diff-filter=ACDMRTUXB"]);
+  } else if (opts.changedSince) {
+    args.push("--end-of-options", assertSafeRevision(opts.changedSince, "changedSince"));
+  } else {
     return [];
-  const filesByPath = /* @__PURE__ */ new Map();
-  const filesByDirectory = await mapLimitSemaphore(Array.from(safeSymlinkDirectories), REALPATH_FILTER_CONCURRENCY, async (directory) => (await (0, import_fast_glob2.default)(patterns, {
-    cwd: directory,
-    absolute: true,
-    dot: true,
-    followSymbolicLinks: false,
-    ignore: locationIndependentIgnores,
-    ...options.onlyFiles !== void 0 ? { onlyFiles: options.onlyFiles } : {},
-    ...options.markDirectories !== void 0 ? { markDirectories: options.markDirectories } : {}
-  })).filter((filePath) => {
-    const cleanPath = filePath.endsWith("/") ? filePath.slice(0, -1) : filePath;
-    return !rootRelativeIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(cleanPath, globRoot, matcher));
-  }));
-  for (const files of filesByDirectory) {
-    for (const file2 of files) {
-      filesByPath.set(normalizePath(file2), file2);
+  }
+  args.push("--");
+  try {
+    const stdout = await runGitCollectStdout(projectRoot, args);
+    const relFiles = stdout.split("\0").filter(Boolean);
+    const out = [];
+    for (const rel of relFiles) {
+      const abs = normalizePath(path8.resolve(projectRoot, rel));
+      if (abs)
+        out.push(abs);
     }
+    return Array.from(new Set(out));
+  } catch (error51) {
+    throw createGitError(projectRoot, args, error51);
   }
-  return [...filesByPath.values()];
 }
-async function filterRealPathsWithinRootEntries(paths, realRoot) {
-  const filtered = await mapLimitSemaphore(paths, REALPATH_FILTER_CONCURRENCY, async (filePath) => {
-    try {
-      const realPath = await fsp4.realpath(filePath);
-      return isFilePathWithinRoot(realRoot, realPath) ? { path: filePath, realPath } : null;
-    } catch {
-      return null;
+async function listTrackedFiles(projectRoot, opts) {
+  if (!(opts?.gitAvailable ?? true))
+    return [];
+  const args = ["ls-files", "-z"];
+  if (opts?.recurseSubmodules)
+    args.push("--recurse-submodules");
+  try {
+    const { stdout } = await runGit(projectRoot, args, { maxBuffer: 64 * 1024 * 1024 });
+    const out = [];
+    for (const rel of stdout.split("\0").filter(Boolean)) {
+      const abs = normalizePath(path8.resolve(projectRoot, rel));
+      if (abs)
+        out.push(abs);
     }
-  });
-  return filtered.filter((entry) => entry !== null);
+    return Array.from(new Set(out));
+  } catch (error51) {
+    throw createGitError(projectRoot, args, error51);
+  }
 }
-async function filterRealPathsWithinRoot(paths, realRoot) {
-  const entries = await filterRealPathsWithinRootEntries(paths, realRoot);
-  return entries.map((entry) => entry.path);
+async function listGitSubmoduleDirectories(projectRoot, opts) {
+  if (!(opts?.gitAvailable ?? true))
+    return [];
+  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()]));
+  } catch (error51) {
+    throw createGitError(projectRoot, args, error51);
+  }
 }
-function toProjectGlob(pattern) {
-  return pattern.startsWith("**/") ? pattern : `**/${pattern}`;
+async function listGitExcludeFiles(projectRoot, opts) {
+  if (!(opts?.gitAvailable ?? true))
+    return [];
+  const resolvedRoot = path8.resolve(projectRoot);
+  const cached2 = gitExcludeFileChecks.get(resolvedRoot);
+  if (cached2)
+    return await cached2;
+  const check2 = listGitExcludeFilesUncached(resolvedRoot);
+  gitExcludeFileChecks.set(resolvedRoot, check2);
+  return await check2;
 }
-async function buildProjectFileInfo(def, filePath) {
-  const normalizedPath = normalizePath(filePath);
-  const projectRoot = normalizePath(path8.dirname(filePath));
-  let name = null;
-  if (def.parseName && def.kind === "file") {
+async function listGitExcludeFilesUncached(projectRoot) {
+  let baseDir;
+  try {
+    const { stdout } = await runGit(projectRoot, ["rev-parse", "--show-toplevel"]);
+    baseDir = normalizePath(stdout.trim());
+  } catch {
+    return [];
+  }
+  if (!baseDir)
+    return [];
+  const candidates = [];
+  try {
+    const { stdout } = await runGit(projectRoot, ["rev-parse", "--git-path", "info/exclude"]);
+    const resolved = stdout.trim();
+    if (resolved)
+      candidates.push(normalizePath(path8.resolve(projectRoot, resolved)));
+  } catch {
+  }
+  try {
+    const { stdout } = await runGit(projectRoot, ["config", "--get", "core.excludesFile"]);
+    const configured = stdout.trim();
+    if (configured) {
+      const expanded = configured.startsWith("~") ? path8.join(os2.homedir(), configured.slice(1)) : path8.resolve(projectRoot, configured);
+      candidates.push(normalizePath(expanded));
+    }
+  } catch {
+  }
+  const sources = [];
+  for (const file2 of Array.from(new Set(candidates))) {
     try {
-      const raw = await fsp4.readFile(filePath, "utf8");
-      name = def.parseName(raw, filePath);
+      if ((await fsp4.stat(file2)).isFile())
+        sources.push({ file: file2, baseDir });
     } catch {
-      name = null;
     }
   }
-  if (!name && def.nameFromPath) {
-    if (def.nameFromPath === "file") {
-      name = trimToNull(path8.basename(filePath, path8.extname(filePath)));
-    } else {
-      name = trimToNull(path8.basename(projectRoot));
+  return sources;
+}
+async function listUntrackedFiles(projectRoot, opts) {
+  const gitAvailable = opts?.gitAvailable ?? true;
+  if (!gitAvailable)
+    return [];
+  const args = ["ls-files", "--others", "-z"];
+  if (opts?.respectGitignore ?? true)
+    args.push("--exclude-standard");
+  try {
+    const stdout = await runGitCollectStdout(projectRoot, args);
+    const relFiles = stdout.toString().split("\0").filter(Boolean);
+    const out = [];
+    for (const rel of relFiles) {
+      const abs = normalizePath(path8.resolve(projectRoot, rel));
+      if (abs)
+        out.push(abs);
     }
+    return Array.from(new Set(out));
+  } catch (error51) {
+    throw createGitError(projectRoot, args, error51);
   }
-  return {
-    path: normalizedPath,
-    kind: def.kind,
-    type: def.type,
-    role: def.role,
-    projectRoot,
-    ...name ? { name } : {}
-  };
 }
-async function discoverProjectFiles(projectRoot, options) {
-  const root = await ensureDirectoryReadable(projectRoot, "Project root");
+async function getUnifiedDiff(projectRoot, opts) {
+  let args = [
+    "diff",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--find-renames",
+    "--unified=0",
+    "--no-color",
+    "--diff-filter=ACDMRTUXB"
+  ];
+  if (opts.base) {
+    const head = opts.head ?? "HEAD";
+    args = gitDiffArgs(opts.base, head, ["--unified=0", "--no-color", "--diff-filter=ACDMRTUXB"]);
+  } else if (opts.changedSince) {
+    args.push("--end-of-options", assertSafeRevision(opts.changedSince, "changedSince"));
+  } else {
+    return "";
+  }
+  args.push("--");
   try {
-    const realRoot = await fsp4.realpath(root);
-    const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((def) => def.patterns.map(toProjectGlob));
-    const matches = await (0, import_fast_glob2.default)(allPatterns, {
-      cwd: root,
-      absolute: true,
-      dot: true,
-      followSymbolicLinks: false,
-      ignore: DEFAULT_PROJECT_FILE_IGNORES,
-      markDirectories: true,
-      onlyFiles: false
-    });
-    const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
-      markDirectories: true,
-      onlyFiles: false,
-      ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
-      ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {}
-    });
-    const rootSafeMatches = await filterRealPathsWithinRoot([...matches, ...linkedMatches].map((match) => match.endsWith("/") ? match.slice(0, -1) : match), realRoot);
-    const projectFileDefinitionMatchers = PROJECT_FILE_DEFINITIONS.map((definition) => definition.patterns.map((pattern) => pattern.includes("*") || pattern.includes("?") ? new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$") : void 0));
-    const entries = [];
-    const matchTasks = rootSafeMatches.map(async (cleanMatch) => {
-      const stats = await fsp4.stat(cleanMatch);
-      const isDir = stats.isDirectory();
-      const fileName = path8.basename(cleanMatch);
-      for (let definitionIndex = 0; definitionIndex < PROJECT_FILE_DEFINITIONS.length; definitionIndex++) {
-        const def = PROJECT_FILE_DEFINITIONS[definitionIndex];
-        if (isDir && def.kind !== "dir")
-          continue;
-        if (!isDir && def.kind !== "file")
-          continue;
-        const matchesPattern = def.patterns.some((pattern, patternIndex) => {
-          const matcher = projectFileDefinitionMatchers[definitionIndex][patternIndex];
-          return matcher ? matcher.test(fileName) : pattern === fileName;
-        });
-        if (matchesPattern) {
-          entries.push(await buildProjectFileInfo(def, cleanMatch));
-        }
-      }
-    });
-    await Promise.all(matchTasks);
-    const byKey2 = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
-      const key = `${entry.path}::${entry.type}::${entry.role}`;
-      const existing = byKey2.get(key);
-      if (!existing || !existing.name && entry.name) {
-        byKey2.set(key, entry);
-      }
-    }
-    return Array.from(byKey2.values()).sort((a, b) => {
-      if (a.path === b.path)
-        return a.type.localeCompare(b.type);
-      return a.path.localeCompare(b.path);
-    });
+    return await runGitCollectStdout(projectRoot, args);
   } catch (error51) {
-    logWithLevel(options?.logLevel, "debug", `discoverProjectFiles failed for ${root}: ${stringifyUnknown(error51)}`);
-    throw new Error(`Failed to discover project files in ${root}: ${stringifyUnknown(error51)}`);
+    throw createGitError(projectRoot, args, error51);
   }
 }
-var import_fast_glob2, import_picomatch, DEFAULT_PROJECT_FILE_IGNORES, DEFAULT_PROJECT_MANIFESTS, DEFAULT_PROJECT_PATTERNS, REALPATH_FILTER_CONCURRENCY;
-var init_projectFiles = __esm({
-  "dist/util/projectFiles.js"() {
+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()) {
+    detail = error51.stderr.trim();
+  } else if (error51 instanceof Error && error51.message) {
+    detail = error51.message;
+  }
+  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 init_git = __esm({
+  "dist/util/git.js"() {
     "use strict";
-    import_fast_glob2 = __toESM(require_out4(), 1);
-    import_picomatch = __toESM(require_picomatch4(), 1);
-    init_logging();
     init_ast();
     init_paths();
-    init_discoveryPath();
-    init_discoveryPath();
-    init_definitions();
-    init_parsers();
-    init_concurrency();
-    DEFAULT_PROJECT_FILE_IGNORES = [
-      "**/node_modules/**",
-      "**/.git/**",
-      // Never treat Codegraph's own on-disk state as project input. `.codegraph/` is the
-      // lifecycle manifest root; `.codegraph-cache/` is the indexer disk cache. Either can
-      // contain JSON/markdown/source-looking files that would otherwise match discovery
-      // patterns and create perpetual "new untracked file" / reindex churn.
-      "**/.codegraph/**",
-      "**/.codegraph-cache/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/target/**",
-      "**/.venv/**",
-      "**/venv/**",
-      "**/site-packages/**",
-      "**/__pycache__/**",
-      "**/vendor/bundle/**",
-      "**/.build/**",
-      "**/Pods/**"
-    ];
-    DEFAULT_PROJECT_MANIFESTS = [
-      "package.json",
-      "package-lock.json",
-      "pnpm-lock.yaml",
-      "yarn.lock",
-      "bun.lockb",
-      "pnpm-workspace.yaml",
-      "lerna.json",
-      "nx.json",
-      "turbo.json",
-      "tsconfig.json",
-      "jsconfig.json",
-      "requirements.txt",
-      "requirements.in",
-      "pyproject.toml",
-      "Pipfile",
-      "Pipfile.lock",
-      "poetry.lock",
-      "setup.py",
-      "setup.cfg",
-      "Cargo.toml",
-      "Cargo.lock",
-      "rust-toolchain",
-      "rust-toolchain.toml",
-      "go.mod",
-      "go.sum",
-      "go.work",
-      "Gemfile",
-      "Gemfile.lock",
-      "*.gemspec",
-      "pom.xml",
-      "mvnw",
-      "build.gradle",
-      "build.gradle.kts",
-      "settings.gradle",
-      "settings.gradle.kts",
-      "gradle.properties",
-      "gradlew",
-      "*.csproj",
-      "*.fsproj",
-      "*.vbproj",
-      "*.sln",
-      "Directory.Build.props",
-      "Directory.Build.targets",
-      "global.json",
-      "composer.json",
-      "composer.lock",
-      "Package.swift",
-      "Package.resolved",
-      "CMakeLists.txt",
-      "CMakePresets.json",
-      "CMakeUserPresets.json",
-      "Makefile",
-      "makefile",
-      "GNUmakefile",
-      "configure.ac",
-      "configure.in",
-      "meson.build",
-      "meson_options.txt",
-      "conanfile.txt",
-      "conanfile.py",
-      "vcpkg.json"
-    ];
-    DEFAULT_PROJECT_PATTERNS = [
-      "**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs,py,pyi,php,vue,svelte,astro,hbs,handlebars,md,mdx,rst,adoc,asciidoc,go,java,cs,rb,rs,html,htm,css,scss,less,kt,kts,swift,zig,c,h,cc,cpp,cxx,c++,hpp,hh,hxx,ipp,tpp,inl,sql}",
-      ...DEFAULT_PROJECT_MANIFESTS.map((name) => `**/${name}`)
-    ];
-    REALPATH_FILTER_CONCURRENCY = 64;
+    init_logging();
+    DEFAULT_GIT_TIMEOUT_MS = 3e4;
+    gitRepositoryChecks = /* @__PURE__ */ new Map();
+    gitDiscoveryRootIgnoredChecks = /* @__PURE__ */ new Map();
+    gitExcludeFileChecks = /* @__PURE__ */ new Map();
+    MAX_GIT_HASH_OBJECT_ARGUMENT_BYTES = 24 * 1024;
+    gitExecutableForTests = null;
+    GIT_QUOTED_PATH_SINGLE_BYTE_ESCAPES = {
+      a: 7,
+      b: 8,
+      f: 12,
+      n: 10,
+      r: 13,
+      t: 9,
+      v: 11
+    };
+    UNSAFE_REVISION_CHARACTERS = /[\0\r\n]/;
   }
 });
 
-// dist/util/git.js
-var git_exports = {};
-__export(git_exports, {
-  DEFAULT_GIT_TIMEOUT_MS: () => DEFAULT_GIT_TIMEOUT_MS,
-  assertSafeRevision: () => assertSafeRevision,
-  clearGitRepositoryCheckCacheForTests: () => clearGitRepositoryCheckCacheForTests,
-  decodeGitPath: () => decodeGitPath,
-  getGitBlobHashes: () => getGitBlobHashes,
-  getGitHead: () => getGitHead,
-  getUnifiedDiff: () => getUnifiedDiff,
-  gitDiffArgs: () => gitDiffArgs,
-  isGitIndexSentinel: () => isGitIndexSentinel,
-  isGitPathIgnored: () => isGitPathIgnored,
-  isGitPathTracked: () => isGitPathTracked,
-  isGitRepo: () => isGitRepo,
-  isGitWorktreeSentinel: () => isGitWorktreeSentinel,
-  listChangedFiles: () => listChangedFiles,
-  listUntrackedFiles: () => listUntrackedFiles,
-  runGit: () => runGit,
-  setGitExecutableForTests: () => setGitExecutableForTests
+// dist/util/projectFiles.js
+var projectFiles_exports = {};
+__export(projectFiles_exports, {
+  DEFAULT_PROJECT_FILE_IGNORES: () => DEFAULT_PROJECT_FILE_IGNORES,
+  DEFAULT_PROJECT_MANIFESTS: () => DEFAULT_PROJECT_MANIFESTS,
+  DEFAULT_PROJECT_PATTERNS: () => DEFAULT_PROJECT_PATTERNS,
+  createDiscoveredFileMatcher: () => createDiscoveredFileMatcher,
+  discoverProjectFiles: () => discoverProjectFiles,
+  filterRealPathsWithinRoot: () => filterRealPathsWithinRoot,
+  isRelativePathInside: () => isRelativePathInside,
+  listProjectFiles: () => listProjectFiles,
+  matchesDiscoveryGlob: () => matchesDiscoveryGlob,
+  translateGlobRootIgnoreGlobsForScanRoot: () => translateGlobRootIgnoreGlobsForScanRoot
 });
-import { spawn } from "node:child_process";
-import { StringDecoder } from "node:string_decoder";
+import fs6 from "node:fs";
+import fsp5 from "node:fs/promises";
 import path9 from "node:path";
-function decodeGitPath(rawPath) {
-  if (!rawPath.startsWith('"') || !rawPath.endsWith('"')) {
-    return rawPath;
+function isPresent(value) {
+  return value !== void 0;
+}
+function normalizeGlobPattern(globPattern) {
+  return globPattern.trim().replace(/\\/g, "/");
+}
+function isIgnoreGlobReopenedByIncludes(ignoreGlob, includeGlobs) {
+  const literalSegments = ignoreGlob.split("/").filter((segment) => segment && !segment.includes("*"));
+  if (!literalSegments.length)
+    return false;
+  return includeGlobs.some((includeGlob) => {
+    const includeSegments = includeGlob.split("/");
+    return literalSegments.every((segment) => includeSegments.includes(segment));
+  });
+}
+function isLocationIndependentGlob(globPattern) {
+  return globPattern.startsWith("**/");
+}
+function translateGlobRootIgnoreGlobsForScanRoot(scanRoot, globRoot, ignoreGlobs) {
+  const relativeScanRoot = normalizePath(path9.relative(globRoot, scanRoot));
+  if (!relativeScanRoot || !isRelativePathInside(relativeScanRoot)) {
+    return ignoreGlobs.map(normalizeGlobPattern).filter(Boolean);
   }
-  const inner = rawPath.slice(1, -1);
-  const bytes = [];
-  for (let index = 0; index < inner.length; ) {
-    const char = inner[index];
-    if (char !== "\\") {
-      const codePoint = inner.codePointAt(index);
-      bytes.push(...Buffer.from(String.fromCodePoint(codePoint), "utf8"));
-      index += codePoint > 65535 ? 2 : 1;
-      continue;
+  const rootPrefix = `${relativeScanRoot}/`;
+  return ignoreGlobs.map(normalizeGlobPattern).filter(Boolean).map((globPattern) => {
+    const rootRelativePattern = globPattern.startsWith("/") ? globPattern.slice(1) : globPattern;
+    if (isLocationIndependentGlob(rootRelativePattern))
+      return rootRelativePattern;
+    if (rootRelativePattern === relativeScanRoot || rootRelativePattern === `${relativeScanRoot}/**`)
+      return "**";
+    if (rootRelativePattern.startsWith(rootPrefix))
+      return rootRelativePattern.slice(rootPrefix.length) || "**";
+    return void 0;
+  }).filter(isPresent);
+}
+function stripGitignoreTrailingSpaces(line) {
+  let end = line.length;
+  while (end > 0 && line[end - 1] === " ") {
+    let slashCount = 0;
+    for (let i = end - 2; i >= 0 && line[i] === "\\"; i -= 1) {
+      slashCount += 1;
     }
-    const octal = inner.slice(index + 1, index + 4).match(/^[0-7]{1,3}/);
-    if (octal) {
-      bytes.push(parseInt(octal[0], 8) & 255);
-      index += 1 + octal[0].length;
-      continue;
+    if (slashCount % 2 === 1) {
+      break;
     }
-    const next = inner[index + 1];
-    if (next === "\\" || next === '"') {
-      bytes.push(next.charCodeAt(0));
-      index += 2;
+    end -= 1;
+  }
+  return line.slice(0, end);
+}
+function parseGitignoreRule(baseDir, rawLine) {
+  const trimmedLine = stripGitignoreTrailingSpaces(rawLine);
+  if (!trimmedLine)
+    return null;
+  if (trimmedLine.startsWith("#"))
+    return null;
+  const negated = trimmedLine.startsWith("!");
+  let pattern = negated ? trimmedLine.slice(1) : trimmedLine;
+  if (!pattern || pattern === "/")
+    return null;
+  const dirOnly = pattern.endsWith("/");
+  if (dirOnly) {
+    pattern = pattern.slice(0, -1);
+  }
+  if (pattern.startsWith("/")) {
+    pattern = pattern.slice(1);
+  }
+  pattern = pattern.replace(/^\\([#!])/, "$1").replace(/\\/g, "/");
+  if (!pattern)
+    return null;
+  const anchored = trimmedLine.startsWith("/") || negated && trimmedLine.startsWith("!/");
+  const baseMatcherPattern = anchored || pattern.includes("/") ? pattern : `**/${pattern}`;
+  const matcherPattern = dirOnly ? `${baseMatcherPattern}/**` : [baseMatcherPattern, `${baseMatcherPattern}/**`];
+  const matches = (0, import_picomatch.default)(matcherPattern, { dot: true });
+  return {
+    baseDir: normalizePath(baseDir),
+    negated,
+    dirOnly,
+    matches
+  };
+}
+async function buildGitignoreIndex(sources) {
+  const sorted = [...sources].map(({ file: file2, baseDir }) => ({ file: normalizePath(file2), baseDir: normalizePath(baseDir) })).sort((left, right) => {
+    const leftFile = left.file;
+    const rightFile = right.file;
+    const depthDelta = leftFile.split("/").length - rightFile.split("/").length;
+    if (depthDelta !== 0)
+      return depthDelta;
+    if (leftFile < rightFile)
+      return -1;
+    return leftFile > rightFile ? 1 : 0;
+  });
+  const gitignoreIndex = { hasRules: false, byBaseDir: /* @__PURE__ */ new Map() };
+  for (const { file: file2, baseDir } of sorted) {
+    if (isIgnoredByGitignore(file2, gitignoreIndex)) {
       continue;
     }
-    const singleByteEscape = GIT_QUOTED_PATH_SINGLE_BYTE_ESCAPES[next ?? ""];
-    if (singleByteEscape !== void 0) {
-      bytes.push(singleByteEscape);
-      index += 2;
+    let raw;
+    try {
+      raw = await fsp5.readFile(file2, "utf8");
+    } catch {
       continue;
     }
-    bytes.push(92);
-    index += 1;
+    const baseKey = fileIdentityKey(baseDir);
+    for (const line of raw.split(/\r?\n/)) {
+      const rule = parseGitignoreRule(baseDir, line);
+      if (!rule)
+        continue;
+      const existing = gitignoreIndex.byBaseDir.get(baseKey);
+      if (existing)
+        existing.rules.push(rule);
+      else
+        gitignoreIndex.byBaseDir.set(baseKey, { baseDir, rules: [rule] });
+      gitignoreIndex.hasRules = true;
+    }
   }
-  return Buffer.from(bytes).toString("utf8");
+  return gitignoreIndex;
 }
-function setGitExecutableForTests(executable) {
-  gitExecutableForTests = executable;
-}
-function clearGitRepositoryCheckCacheForTests() {
-  gitRepositoryChecks.clear();
+async function findGitignoreFiles(projectRoot) {
+  return await (0, import_fast_glob2.default)(["**/.gitignore"], {
+    cwd: projectRoot,
+    absolute: true,
+    dot: true,
+    followSymbolicLinks: false,
+    ignore: DEFAULT_PROJECT_FILE_IGNORES
+  });
 }
-function resolveGitTimeoutMs(timeoutMs) {
-  if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
-    return Math.floor(timeoutMs);
+async function loadGitignoreIndexForRootAliases(projectRoot) {
+  const roots = [projectRoot];
+  const realRoot = await fsp5.realpath(projectRoot);
+  if (normalizePath(realRoot) !== normalizePath(projectRoot)) {
+    roots.push(realRoot);
   }
-  return DEFAULT_GIT_TIMEOUT_MS;
-}
-function appendBoundedTail(current, chunk, maxBytes) {
-  function utf8Tail(value, byteLimit) {
-    let start = value.length;
-    let bytes = 0;
-    while (start) {
-      const last = value.charCodeAt(start - 1);
-      const preceding = start > 1 ? value.charCodeAt(start - 2) : void 0;
-      const isSurrogatePair = last >= 56320 && last <= 57343 && preceding !== void 0 && preceding >= 55296 && preceding <= 56319;
-      const codeUnits = isSurrogatePair ? 2 : 1;
-      let codePointBytes = 3;
-      if (isSurrogatePair) {
-        codePointBytes = 4;
-      } else if (last <= 127) {
-        codePointBytes = 1;
-      } else if (last <= 2047) {
-        codePointBytes = 2;
-      }
-      if (bytes + codePointBytes > byteLimit)
-        break;
-      bytes += codePointBytes;
-      start -= codeUnits;
+  const sources = [];
+  for (const root of roots) {
+    for (const file2 of await findGitignoreFiles(root)) {
+      sources.push({ file: file2, baseDir: path9.dirname(file2) });
     }
-    return value.slice(start);
   }
-  if (maxBytes <= 0)
-    return "";
-  const retainedChunk = utf8Tail(chunk, maxBytes);
-  const retainedChunkBytes = Buffer.byteLength(retainedChunk, "utf8");
-  if (retainedChunkBytes >= maxBytes)
-    return retainedChunk;
-  return utf8Tail(current, maxBytes - retainedChunkBytes) + retainedChunk;
-}
-function killGitChild(child) {
-  if (child.killed || child.exitCode !== null)
-    return;
-  try {
-    child.kill("SIGTERM");
-  } catch {
-  }
-  setTimeout(() => {
-    if (child.killed || child.exitCode !== null)
-      return;
-    try {
-      child.kill("SIGKILL");
-    } catch {
-    }
-  }, 1e3).unref?.();
+  return await buildGitignoreIndex(sources);
 }
-async function runGit(projectRoot, args, options) {
-  const timeoutMs = resolveGitTimeoutMs(options?.timeoutMs);
-  const maxBuffer = options?.maxBuffer ?? 64 * 1024 * 1024;
-  const executable = gitExecutableForTests ?? "git";
-  const signal = options?.signal;
-  if (signal?.aborted) {
-    throw createGitError(projectRoot, args, new Error("aborted before start"));
+function isIgnoredByGitignore(absolutePath, gitignoreIndex) {
+  if (!gitignoreIndex.hasRules)
+    return false;
+  const chain = [];
+  let current = normalizePath(path9.dirname(absolutePath));
+  for (; ; ) {
+    const group = gitignoreIndex.byBaseDir.get(fileIdentityKey(current));
+    if (group)
+      chain.push(group);
+    const parent = normalizePath(path9.dirname(current));
+    if (parent === current)
+      break;
+    current = parent;
   }
-  return await new Promise((resolve, reject) => {
-    const child = spawn(executable, args, {
-      cwd: projectRoot,
-      env: process.env,
-      stdio: [options?.input !== void 0 ? "pipe" : "ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-    options?.onSpawn?.(child.pid === void 0 ? {} : { pid: child.pid });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    let timedOut = false;
-    let aborted2 = false;
-    let totalBytes = 0;
-    let stderrBytes = 0;
-    let stderrOverflowed = false;
-    const settle = (fn) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      if (signal)
-        signal.removeEventListener("abort", onAbort);
-      fn();
-    };
-    const timer = setTimeout(() => {
-      timedOut = true;
-      killGitChild(child);
-    }, timeoutMs);
-    timer.unref?.();
-    const onAbort = () => {
-      aborted2 = true;
-      killGitChild(child);
-    };
-    if (signal)
-      signal.addEventListener("abort", onAbort, { once: true });
-    const stdoutStream = child.stdout;
-    const stderrStream = child.stderr;
-    if (!stdoutStream || !stderrStream) {
-      killGitChild(child);
-      settle(() => reject(createGitError(projectRoot, args, new Error("git child missing stdio pipes"))));
-      return;
+  let ignored = false;
+  for (let depth = chain.length - 1; depth >= 0; depth -= 1) {
+    const group = chain[depth];
+    const relativePath3 = path9.relative(group.baseDir, absolutePath);
+    if (!isRelativePathInside(relativePath3)) {
+      continue;
     }
-    const stdoutDecoder = new StringDecoder("utf8");
-    const stderrDecoder = new StringDecoder("utf8");
-    stdoutStream.on("data", (chunk) => {
-      const chunkBytes = typeof chunk === "string" ? Buffer.byteLength(chunk, "utf8") : chunk.length;
-      totalBytes += chunkBytes;
-      if (totalBytes > maxBuffer) {
-        killGitChild(child);
-        settle(() => reject(createGitError(projectRoot, args, new Error(`stdout exceeded maxBuffer (${maxBuffer} bytes)`))));
-        return;
-      }
-      stdout += typeof chunk === "string" ? chunk : stdoutDecoder.write(chunk);
-    });
-    stderrStream.on("data", (chunk) => {
-      if (stderrOverflowed)
-        return;
-      const chunkBytes = typeof chunk === "string" ? Buffer.byteLength(chunk, "utf8") : chunk.length;
-      stderrBytes += chunkBytes;
-      const decoded = typeof chunk === "string" ? chunk : stderrDecoder.write(chunk);
-      stderr = appendBoundedTail(stderr, decoded, maxBuffer);
-      if (stderrBytes > maxBuffer) {
-        stderrOverflowed = true;
-        killGitChild(child);
-        settle(() => reject(createGitError(projectRoot, args, new Error(`stderr exceeded maxBuffer (${maxBuffer} bytes): ${stderr.trim()}`))));
+    const normalizedRelativePath2 = normalizePath(relativePath3);
+    const hasSeparator = normalizedRelativePath2.includes("/");
+    for (const rule of group.rules) {
+      if (rule.dirOnly && !hasSeparator) {
+        continue;
       }
-    });
-    child.on("error", (error51) => {
-      settle(() => reject(createGitError(projectRoot, args, error51)));
-    });
-    child.on("close", (code, signalName) => {
-      stdout += stdoutDecoder.end();
-      stderr = appendBoundedTail(stderr, stderrDecoder.end(), maxBuffer);
-      settle(() => {
-        if (timedOut) {
-          reject(createGitError(projectRoot, args, new Error(`timed out after ${timeoutMs}ms${stderr ? `: ${stderr.trim()}` : ""}`)));
-          return;
-        }
-        if (aborted2) {
-          reject(createGitError(projectRoot, args, new Error(`aborted${stderr ? `: ${stderr.trim()}` : ""}`)));
-          return;
-        }
-        if (code !== 0) {
-          reject(new Error(`git ${args.join(" ")} failed (${code ?? signalName ?? "unknown"}): ${stderr || stdout || "unknown error"}`));
-          return;
-        }
-        resolve({ stdout, stderr });
-      });
-    });
-    if (options?.input !== void 0) {
-      if (!child.stdin) {
-        killGitChild(child);
-        settle(() => reject(createGitError(projectRoot, args, new Error("git child missing stdin pipe"))));
-        return;
+      if (rule.matches(normalizedRelativePath2)) {
+        ignored = !rule.negated;
       }
-      child.stdin.write(options.input);
-      child.stdin.end();
     }
-  });
-}
-async function runGitCollectStdout(projectRoot, args) {
-  const { stdout } = await runGit(projectRoot, args);
-  return stdout;
-}
-function isGitWorktreeSentinel(value) {
-  return value.toUpperCase() === "WORKTREE";
-}
-function isGitIndexSentinel(value) {
-  const normalized = value.toUpperCase();
-  return normalized === "INDEX" || normalized === "STAGED";
-}
-function assertSafeRevision(value, label) {
-  if (UNSAFE_REVISION_CHARACTERS.test(value)) {
-    throw new Error(`Invalid ${label}: revisions must not contain NUL or newline characters.`);
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    throw new Error(`Invalid ${label}: revision must not be empty.`);
-  }
-  if (trimmed.startsWith("-")) {
-    throw new Error(`Invalid ${label} "${trimmed}": revisions must not start with "-".`);
   }
-  return trimmed;
+  return ignored;
 }
-function gitDiffArgs(base, head, extraArgs = []) {
-  const safeBase = assertSafeRevision(base, "base");
-  const diffSafetyArgs = ["--no-ext-diff", "--no-textconv"];
-  const renameArgs = ["--find-renames"];
-  if (isGitWorktreeSentinel(head)) {
-    return ["diff", ...diffSafetyArgs, ...renameArgs, ...extraArgs, "--end-of-options", safeBase];
+async function ensureDirectoryReadable(directoryPath, label) {
+  const resolvedPath = path9.resolve(directoryPath);
+  let stats;
+  try {
+    stats = await fsp5.stat(resolvedPath);
+  } catch (error51) {
+    throw new Error(`${label} does not exist or is not readable: ${resolvedPath} (${stringifyUnknown(error51)})`);
   }
-  if (isGitIndexSentinel(head)) {
-    return ["diff", "--cached", ...diffSafetyArgs, ...renameArgs, ...extraArgs, "--end-of-options", safeBase];
+  if (!stats.isDirectory()) {
+    throw new Error(`${label} is not a directory: ${resolvedPath}`);
   }
-  const safeHead = assertSafeRevision(head, "head");
-  return ["diff", ...diffSafetyArgs, ...renameArgs, ...extraArgs, "--end-of-options", `${safeBase}..${safeHead}`];
+  return resolvedPath;
 }
-async function getGitHead(projectRoot) {
-  try {
-    const { stdout } = await runGit(projectRoot, ["rev-parse", "HEAD"]);
-    const hash2 = stdout.trim();
-    return hash2 || null;
-  } catch {
-    return null;
+function collectCandidateAncestorDirectories(root, files) {
+  const rootKey = fileIdentityKey(root);
+  const seen = /* @__PURE__ */ new Set([rootKey]);
+  const directories = [normalizePath(root)];
+  for (const file2 of files) {
+    let current = normalizePath(path9.dirname(file2));
+    while (fileIdentityKey(current) !== rootKey) {
+      if (seen.has(fileIdentityKey(current)))
+        break;
+      seen.add(fileIdentityKey(current));
+      directories.push(current);
+      const parent = normalizePath(path9.dirname(current));
+      if (parent === current)
+        break;
+      current = parent;
+    }
   }
+  return directories;
 }
-async function isGitRepo(projectRoot) {
-  const resolvedRoot = path9.resolve(projectRoot);
-  const cached2 = gitRepositoryChecks.get(resolvedRoot);
-  if (cached2)
-    return await cached2;
-  const check2 = (async () => {
+async function findGitIgnoreSources(root, files) {
+  const directories = collectCandidateAncestorDirectories(root, files);
+  const present = await mapLimitSemaphore(directories, REALPATH_FILTER_CONCURRENCY, async (directory) => {
+    const candidate = normalizePath(path9.join(directory, ".gitignore"));
     try {
-      const { stdout } = await runGit(resolvedRoot, ["rev-parse", "--is-inside-work-tree"]);
-      return stdout.trim() === "true";
+      return (await fsp5.stat(candidate)).isFile() ? { file: candidate, baseDir: directory } : null;
     } catch {
-      return false;
+      return null;
     }
-  })();
-  gitRepositoryChecks.set(resolvedRoot, check2);
-  return await check2;
-}
-async function isGitPathTracked(projectRoot, file2) {
-  return await runGitPathPredicate(projectRoot, ["ls-files", "--error-unmatch", "--", normalizePath(file2)]);
+  });
+  const sources = present.filter((entry) => entry !== null);
+  sources.push(...await listGitExcludeFiles(root));
+  return sources;
 }
-async function isGitPathIgnored(projectRoot, file2) {
-  return await runGitPathPredicate(projectRoot, ["check-ignore", "--quiet", "--no-index", "--", normalizePath(file2)]);
+async function listGitCandidateFiles(root, logLevel) {
+  try {
+    if (!await isGitRepo(root))
+      return null;
+    if (await isGitProjectRootIgnored(root))
+      return null;
+    const [tracked, untracked, submoduleDirectories] = await Promise.all([
+      listTrackedFiles(root, { recurseSubmodules: true, ...logLevel === void 0 ? {} : { logLevel } }),
+      listUntrackedFiles(root, { respectGitignore: true }),
+      listGitSubmoduleDirectories(root, { recurse: true })
+    ]);
+    const submoduleUntracked = await Promise.all(submoduleDirectories.map(async (directory) => await listUntrackedFiles(directory, { respectGitignore: true })));
+    const files = Array.from(/* @__PURE__ */ new Set([...tracked, ...untracked, ...submoduleUntracked.flat()])).sort();
+    return { files, gitignoreFiles: await findGitIgnoreSources(root, files) };
+  } catch (error51) {
+    logWithLevel(logLevel, "debug", `Git discovery unavailable for ${root}: ${stringifyUnknown(error51)}`);
+    return null;
+  }
 }
-async function runGitPathPredicate(projectRoot, args) {
+async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS, options) {
+  const root = await ensureDirectoryReadable(projectRoot, "Project root");
+  const globRoot = options?.globRoot ? await ensureDirectoryReadable(options.globRoot, "Glob root") : root;
+  const includeGlobs = (options?.includeGlobs ?? []).map(normalizeGlobPattern).filter(Boolean);
+  const includeMatchers = includeGlobs.map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
+  const userIgnoreGlobs = (options?.ignoreGlobs ?? []).map(normalizeGlobPattern).filter(Boolean);
+  const userIgnoreMatchers = userIgnoreGlobs.map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
+  const defaultIgnoreMatchers = DEFAULT_PROJECT_FILE_IGNORES.map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
+  const patternMatchers = patterns.map((pattern) => (0, import_picomatch.default)(normalizeGlobPattern(pattern), { dot: true }));
+  const translatedUserIgnoreGlobs = translateGlobRootIgnoreGlobsForScanRoot(root, globRoot, userIgnoreGlobs);
+  const fastGlobIgnoreGlobs = [...DEFAULT_PROJECT_FILE_IGNORES, ...translatedUserIgnoreGlobs];
+  const symlinkProbeIgnoreGlobs = includeGlobs.length ? [
+    ...translatedUserIgnoreGlobs,
+    ...DEFAULT_PROJECT_FILE_IGNORES.filter((ignoreGlob) => !isIgnoreGlobReopenedByIncludes(ignoreGlob, includeGlobs))
+  ] : fastGlobIgnoreGlobs;
   try {
-    await runGit(projectRoot, args);
-    return true;
+    const useGitignore = options?.useGitignore ?? true;
+    const realRoot = await fsp5.realpath(root);
+    const gitCandidates = useGitignore && options?.gitignoreRoot === void 0 && normalizePath(realRoot) === normalizePath(root) ? await listGitCandidateFiles(root, options?.logLevel) : null;
+    let gitignoreIndex = EMPTY_GITIGNORE_INDEX;
+    if (useGitignore && gitCandidates) {
+      gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles);
+    } else if (useGitignore) {
+      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
+    });
+    const includedOverrideFiles = includeGlobs.length && !gitCandidates ? await (0, import_fast_glob2.default)(translateGlobRootIgnoreGlobsForScanRoot(root, globRoot, includeGlobs), {
+      cwd: root,
+      absolute: true,
+      dot: true,
+      followSymbolicLinks: false,
+      ignore: translatedUserIgnoreGlobs
+    }) : [];
+    const symlinkOptions = {
+      globRoot,
+      ...gitCandidates ? { candidatePaths: gitCandidates.files } : {},
+      ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
+      ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {}
+    };
+    const safeSymlinkDirectories = await resolveSafeSymlinkDirectories(root, realRoot, symlinkProbeIgnoreGlobs, symlinkOptions);
+    const linkedFiles = await listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, fastGlobIgnoreGlobs, {
+      ...symlinkOptions,
+      filterIgnoreGlobs: [...DEFAULT_PROJECT_FILE_IGNORES, ...userIgnoreGlobs],
+      resolvedSafeSymlinkDirectories: safeSymlinkDirectories
+    });
+    const linkedOverrideFiles = includeGlobs.length === 0 ? [] : await listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, translatedUserIgnoreGlobs, {
+      globRoot,
+      filterIgnoreGlobs: userIgnoreGlobs,
+      resolvedSafeSymlinkDirectories: safeSymlinkDirectories
+    });
+    const rootSafeFiles = await filterRealPathsWithinRootEntries([...files, ...includedOverrideFiles, ...linkedFiles, ...linkedOverrideFiles], realRoot);
+    const seen = /* @__PURE__ */ new Set();
+    return rootSafeFiles.map(({ path: filePath, realPath }) => ({ filePath: normalizePath(filePath), realPath })).filter(({ filePath, realPath }) => {
+      if (seen.has(filePath))
+        return false;
+      seen.add(filePath);
+      const rootRelative = normalizePath(path9.relative(root, filePath));
+      if (!isRelativePathInside(rootRelative))
+        return false;
+      if (!patternMatchers.some((matcher) => matcher(rootRelative)))
+        return false;
+      const matchesInclude = !includeMatchers.length || includeMatchers.some((matcher) => matchesDiscoveryGlob(filePath, globRoot, matcher));
+      if (!matchesInclude)
+        return false;
+      if (userIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(filePath, globRoot, matcher))) {
+        return false;
+      }
+      const ignoredByDefault = defaultIgnoreMatchers.some((matcher) => matcher(rootRelative));
+      if (ignoredByDefault && !(includeMatchers.length > 0 && matchesInclude)) {
+        return false;
+      }
+      if (isIgnoredByGitignore(filePath, gitignoreIndex))
+        return false;
+      return normalizePath(realPath) === filePath || !isIgnoredByGitignore(realPath, gitignoreIndex);
+    }).map(({ filePath }) => filePath);
   } catch (error51) {
-    const message = error51 instanceof Error ? error51.message : String(error51);
-    if (/\bfailed \(1\):/.test(message))
+    logWithLevel(options?.logLevel, "debug", `listProjectFiles failed for ${root}: ${stringifyUnknown(error51)}`);
+    throw new Error(`Failed to list files in ${root}: ${stringifyUnknown(error51)}`);
+  }
+}
+function createDiscoveredFileMatcher(root, globRoot, patterns, options) {
+  const patternMatchers = patterns.map((pattern) => (0, import_picomatch.default)(normalizeGlobPattern(pattern), { dot: true }));
+  const defaultIgnoreMatchers = DEFAULT_PROJECT_FILE_IGNORES.map((pattern) => (0, import_picomatch.default)(normalizeGlobPattern(pattern), { dot: true }));
+  const includeMatchers = (options?.includeGlobs ?? []).map(normalizeGlobPattern).filter(Boolean).map((pattern) => (0, import_picomatch.default)(pattern, { dot: true }));
+  const userIgnoreMatchers = (options?.ignoreGlobs ?? []).map(normalizeGlobPattern).filter(Boolean).map((pattern) => (0, import_picomatch.default)(pattern, { dot: true }));
+  return (absolutePath) => {
+    const rootRelative = path9.relative(root, absolutePath);
+    if (!isRelativePathInside(rootRelative))
       return false;
-    if (error51 instanceof Error && message.startsWith(`git ${args.join(" ")} failed in ${projectRoot}:`)) {
-      throw error51;
+    const normalizedRootRelative = normalizePath(rootRelative);
+    if (!patternMatchers.some((matcher) => matcher(normalizedRootRelative)))
+      return false;
+    const matchesInclude = !includeMatchers.length || includeMatchers.some((matcher) => matchesDiscoveryGlob(absolutePath, globRoot, matcher));
+    if (!matchesInclude)
+      return false;
+    if (defaultIgnoreMatchers.some((matcher) => matcher(normalizedRootRelative))) {
+      if (!(includeMatchers.length > 0 && matchesInclude))
+        return false;
     }
-    throw createGitError(projectRoot, args, error51);
-  }
+    return !userIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(absolutePath, globRoot, matcher));
+  };
 }
-async function getGitBlobHashes(projectRoot, files, opts) {
-  const gitAvailable = opts?.gitAvailable ?? true;
-  if (!gitAvailable)
-    return /* @__PURE__ */ new Map();
-  const relFileSet = new Set(files.map((file2) => normalizePath(path9.relative(projectRoot, file2))).filter((rel) => rel && !rel.startsWith("..") && !path9.isAbsolute(rel) && rel !== "."));
-  if (!relFileSet.size)
-    return /* @__PURE__ */ new Map();
+async function isSafeSymlinkDirectory(root, linkPath, realRoot) {
   try {
-    const { stdout: trackedStdout } = await runGit(projectRoot, ["ls-files", "-z"], {
-      maxBuffer: 64 * 1024 * 1024
+    if (!isRelativePathInside(path9.relative(root, linkPath)))
+      return false;
+    if (!(await fsp5.lstat(linkPath)).isSymbolicLink())
+      return false;
+    const [realPath, targetStats] = await Promise.all([fsp5.realpath(linkPath), fsp5.stat(linkPath)]);
+    if (!targetStats.isDirectory())
+      return false;
+    if (!isFilePathWithinRoot(realRoot, realPath))
+      return false;
+    return normalizePath(realPath) !== normalizePath(realRoot);
+  } catch {
+    return false;
+  }
+}
+async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
+  if (options.knownSymlinkDirectories !== void 0) {
+    const verified = await mapLimitSemaphore(Array.from(new Set(options.knownSymlinkDirectories)), REALPATH_FILTER_CONCURRENCY, async (linkPath) => await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null);
+    const resolved = verified.filter((entry) => entry !== null);
+    options.onSymlinkDirectoriesDiscovered?.(resolved, "known");
+    return resolved;
+  }
+  if (options.candidatePaths !== void 0) {
+    const ignoreMatchers = ignore.map(normalizeGlobPattern).filter(Boolean).map((pattern) => (0, import_picomatch.default)(pattern, { dot: true }));
+    const candidatePaths = Array.from(new Set(options.candidatePaths)).filter((candidatePath) => {
+      const relativePath3 = normalizePath(path9.relative(root, candidatePath));
+      if (!isRelativePathInside(relativePath3))
+        return false;
+      return !ignoreMatchers.some((matcher) => matcher(relativePath3));
     });
-    const trackedRel = trackedStdout.split("\0").filter((rel) => rel && relFileSet.has(rel));
-    if (!trackedRel.length)
-      return /* @__PURE__ */ new Map();
-    const hashes = await hashGitPaths(projectRoot, trackedRel);
-    if (hashes.length !== trackedRel.length) {
-      logWithLevel(opts?.logLevel, "warn", `Warning: git hash-object returned ${hashes.length} hash(es) for ${trackedRel.length} requested file(s); discarding Git signatures for this build.`);
-      return /* @__PURE__ */ new Map();
-    }
-    const out = /* @__PURE__ */ new Map();
-    for (let i = 0; i < trackedRel.length; i += 1) {
-      const rel = trackedRel[i];
-      const hash2 = hashes[i];
-      if (!hash2)
-        continue;
-      const abs = normalizePath(path9.resolve(projectRoot, rel));
-      out.set(abs, hash2);
+    const verified = await mapLimitSemaphore(candidatePaths, REALPATH_FILTER_CONCURRENCY, async (linkPath) => await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null);
+    const discovered2 = verified.filter((entry) => entry !== null);
+    options.onSymlinkDirectoriesDiscovered?.(discovered2, "git-candidates");
+    return discovered2;
+  }
+  const entries = await (0, import_fast_glob2.default)(["**/*"], {
+    cwd: root,
+    absolute: true,
+    dot: true,
+    onlyFiles: false,
+    followSymbolicLinks: false,
+    objectMode: true,
+    ignore
+  });
+  const candidates = await mapLimitSemaphore(entries.filter((entry) => entry.dirent.isSymbolicLink()).map((entry) => entry.path), REALPATH_FILTER_CONCURRENCY, async (linkPath) => await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null);
+  const discovered = candidates.filter((entry) => entry !== null);
+  options.onSymlinkDirectoriesDiscovered?.(discovered, "filesystem");
+  return discovered;
+}
+async function listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, ignore, options = {}) {
+  const globRoot = options.globRoot ?? root;
+  const filterIgnoreGlobs = options.filterIgnoreGlobs ?? ignore;
+  const rootRelativeIgnoreMatchers = filterIgnoreGlobs.map(normalizeGlobPattern).filter(Boolean).map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
+  const locationIndependentIgnores = ignore.map(normalizeGlobPattern).filter(isLocationIndependentGlob);
+  const safeSymlinkDirectories = options.resolvedSafeSymlinkDirectories ?? await resolveSafeSymlinkDirectories(root, realRoot, ignore, options);
+  if (!safeSymlinkDirectories.length)
+    return [];
+  const filesByPath = /* @__PURE__ */ new Map();
+  const filesByDirectory = await mapLimitSemaphore(Array.from(safeSymlinkDirectories), REALPATH_FILTER_CONCURRENCY, async (directory) => (await (0, import_fast_glob2.default)(patterns, {
+    cwd: directory,
+    absolute: true,
+    dot: true,
+    followSymbolicLinks: false,
+    ignore: locationIndependentIgnores,
+    ...options.onlyFiles !== void 0 ? { onlyFiles: options.onlyFiles } : {},
+    ...options.markDirectories !== void 0 ? { markDirectories: options.markDirectories } : {}
+  })).filter((filePath) => {
+    const cleanPath = filePath.endsWith("/") ? filePath.slice(0, -1) : filePath;
+    return !rootRelativeIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(cleanPath, globRoot, matcher));
+  }));
+  for (const files of filesByDirectory) {
+    for (const file2 of files) {
+      filesByPath.set(normalizePath(file2), file2);
     }
-    return out;
-  } catch (error51) {
-    logWithLevel(opts?.logLevel, "warn", "Warning: Failed to read Git blob hashes; falling back to content hashing.", error51);
-    return /* @__PURE__ */ new Map();
   }
+  return [...filesByPath.values()];
 }
-async function hashGitPaths(projectRoot, trackedRel) {
-  const batches = [];
-  let currentBatch = [];
-  let currentBatchBytes = 0;
-  for (const rel of trackedRel) {
-    const absolutePath = path9.resolve(projectRoot, rel);
-    const pathBytes = Buffer.byteLength(absolutePath, "utf8") + 1;
-    const wouldExceedBatchLimit = currentBatch.length && currentBatchBytes + pathBytes > MAX_GIT_HASH_OBJECT_ARGUMENT_BYTES;
-    if (wouldExceedBatchLimit) {
-      batches.push(currentBatch);
-      currentBatch = [];
-      currentBatchBytes = 0;
+async function filterRealPathsWithinRootEntries(paths, realRoot) {
+  const filtered = await mapLimitSemaphore(paths, REALPATH_FILTER_CONCURRENCY, async (filePath) => {
+    try {
+      const realPath = await fsp5.realpath(filePath);
+      return isFilePathWithinRoot(realRoot, realPath) ? { path: filePath, realPath } : null;
+    } catch {
+      return null;
     }
-    currentBatch.push(absolutePath);
-    currentBatchBytes += pathBytes;
-  }
-  if (currentBatch.length)
-    batches.push(currentBatch);
-  const hashes = [];
-  for (const batch of batches) {
-    const { stdout } = await runGit(projectRoot, ["hash-object", "--", ...batch]);
-    hashes.push(...stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
-  }
-  return hashes;
+  });
+  return filtered.filter((entry) => entry !== null);
 }
-async function listChangedFiles(projectRoot, opts) {
-  let args = [
-    "diff",
-    "--no-ext-diff",
-    "--no-textconv",
-    "--find-renames",
-    "--name-only",
-    "-z",
-    "--diff-filter=ACDMRTUXB"
-  ];
-  if (opts.base) {
-    const head = opts.head ?? "HEAD";
-    args = gitDiffArgs(opts.base, head, ["--name-only", "-z", "--diff-filter=ACDMRTUXB"]);
-  } else if (opts.changedSince) {
-    args.push("--end-of-options", assertSafeRevision(opts.changedSince, "changedSince"));
-  } else {
-    return [];
-  }
-  args.push("--");
-  try {
-    const stdout = await runGitCollectStdout(projectRoot, args);
-    const relFiles = stdout.split("\0").filter(Boolean);
-    const out = [];
-    for (const rel of relFiles) {
-      const abs = normalizePath(path9.resolve(projectRoot, rel));
-      if (abs)
-        out.push(abs);
+async function filterRealPathsWithinRoot(paths, realRoot) {
+  const entries = await filterRealPathsWithinRootEntries(paths, realRoot);
+  return entries.map((entry) => entry.path);
+}
+function toProjectGlob(pattern) {
+  return pattern.startsWith("**/") ? pattern : `**/${pattern}`;
+}
+async function buildProjectFileInfo(def, filePath) {
+  const normalizedPath = normalizePath(filePath);
+  const projectRoot = normalizePath(path9.dirname(filePath));
+  let name = null;
+  if (def.parseName && def.kind === "file") {
+    try {
+      const raw = await fsp5.readFile(filePath, "utf8");
+      name = def.parseName(raw, filePath);
+    } catch {
+      name = null;
     }
-    return Array.from(new Set(out));
-  } catch (error51) {
-    throw createGitError(projectRoot, args, error51);
   }
-}
-async function listUntrackedFiles(projectRoot, opts) {
-  const gitAvailable = opts?.gitAvailable ?? true;
-  if (!gitAvailable)
-    return [];
-  const args = ["ls-files", "--others", "-z"];
-  if (opts?.respectGitignore ?? true)
-    args.push("--exclude-standard");
-  try {
-    const stdout = await runGitCollectStdout(projectRoot, args);
-    const relFiles = stdout.toString().split("\0").filter(Boolean);
-    const out = [];
-    for (const rel of relFiles) {
-      const abs = normalizePath(path9.resolve(projectRoot, rel));
-      if (abs)
-        out.push(abs);
+  if (!name && def.nameFromPath) {
+    if (def.nameFromPath === "file") {
+      name = trimToNull(path9.basename(filePath, path9.extname(filePath)));
+    } else {
+      name = trimToNull(path9.basename(projectRoot));
     }
-    return Array.from(new Set(out));
-  } catch (error51) {
-    throw createGitError(projectRoot, args, error51);
   }
+  return {
+    path: normalizedPath,
+    kind: def.kind,
+    type: def.type,
+    role: def.role,
+    projectRoot,
+    ...name ? { name } : {}
+  };
 }
-async function getUnifiedDiff(projectRoot, opts) {
-  let args = [
-    "diff",
-    "--no-ext-diff",
-    "--no-textconv",
-    "--find-renames",
-    "--unified=0",
-    "--no-color",
-    "--diff-filter=ACDMRTUXB"
-  ];
-  if (opts.base) {
-    const head = opts.head ?? "HEAD";
-    args = gitDiffArgs(opts.base, head, ["--unified=0", "--no-color", "--diff-filter=ACDMRTUXB"]);
-  } else if (opts.changedSince) {
-    args.push("--end-of-options", assertSafeRevision(opts.changedSince, "changedSince"));
-  } else {
-    return "";
-  }
-  args.push("--");
+async function discoverProjectFiles(projectRoot, options) {
+  const root = await ensureDirectoryReadable(projectRoot, "Project root");
   try {
-    return await runGitCollectStdout(projectRoot, args);
+    const realRoot = await fsp5.realpath(root);
+    const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((def) => def.patterns.map(toProjectGlob));
+    const matches = await (0, import_fast_glob2.default)(allPatterns, {
+      cwd: root,
+      absolute: true,
+      dot: true,
+      followSymbolicLinks: false,
+      ignore: DEFAULT_PROJECT_FILE_IGNORES,
+      markDirectories: true,
+      onlyFiles: false
+    });
+    const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
+      markDirectories: true,
+      onlyFiles: false,
+      ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
+      ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {}
+    });
+    const rootSafeMatches = await filterRealPathsWithinRoot([...matches, ...linkedMatches].map((match) => match.endsWith("/") ? match.slice(0, -1) : match), realRoot);
+    const projectFileDefinitionMatchers = PROJECT_FILE_DEFINITIONS.map((definition) => definition.patterns.map((pattern) => pattern.includes("*") || pattern.includes("?") ? new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$") : void 0));
+    const entries = [];
+    const matchTasks = rootSafeMatches.map(async (cleanMatch) => {
+      const stats = await fsp5.stat(cleanMatch);
+      const isDir = stats.isDirectory();
+      const fileName = path9.basename(cleanMatch);
+      for (let definitionIndex = 0; definitionIndex < PROJECT_FILE_DEFINITIONS.length; definitionIndex++) {
+        const def = PROJECT_FILE_DEFINITIONS[definitionIndex];
+        if (isDir && def.kind !== "dir")
+          continue;
+        if (!isDir && def.kind !== "file")
+          continue;
+        const matchesPattern = def.patterns.some((pattern, patternIndex) => {
+          const matcher = projectFileDefinitionMatchers[definitionIndex][patternIndex];
+          return matcher ? matcher.test(fileName) : pattern === fileName;
+        });
+        if (matchesPattern) {
+          entries.push(await buildProjectFileInfo(def, cleanMatch));
+        }
+      }
+    });
+    await Promise.all(matchTasks);
+    const byKey2 = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const key = `${entry.path}::${entry.type}::${entry.role}`;
+      const existing = byKey2.get(key);
+      if (!existing || !existing.name && entry.name) {
+        byKey2.set(key, entry);
+      }
+    }
+    return Array.from(byKey2.values()).sort((a, b) => {
+      if (a.path === b.path)
+        return a.type.localeCompare(b.type);
+      return a.path.localeCompare(b.path);
+    });
   } catch (error51) {
-    throw createGitError(projectRoot, args, error51);
-  }
-}
-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()) {
-    detail = error51.stderr.trim();
-  } else if (error51 instanceof Error && error51.message) {
-    detail = error51.message;
+    logWithLevel(options?.logLevel, "debug", `discoverProjectFiles failed for ${root}: ${stringifyUnknown(error51)}`);
+    throw new Error(`Failed to discover project files in ${root}: ${stringifyUnknown(error51)}`);
   }
-  return new Error(`git ${args.join(" ")} failed in ${projectRoot}: ${detail}`);
 }
-var DEFAULT_GIT_TIMEOUT_MS, gitRepositoryChecks, MAX_GIT_HASH_OBJECT_ARGUMENT_BYTES, gitExecutableForTests, GIT_QUOTED_PATH_SINGLE_BYTE_ESCAPES, UNSAFE_REVISION_CHARACTERS;
-var init_git = __esm({
-  "dist/util/git.js"() {
+var import_fast_glob2, import_picomatch, DEFAULT_PROJECT_FILE_IGNORES, DEFAULT_PROJECT_MANIFESTS, DEFAULT_PROJECT_PATTERNS, REALPATH_FILTER_CONCURRENCY, EMPTY_GITIGNORE_INDEX;
+var init_projectFiles = __esm({
+  "dist/util/projectFiles.js"() {
     "use strict";
+    import_fast_glob2 = __toESM(require_out4(), 1);
+    import_picomatch = __toESM(require_picomatch4(), 1);
+    init_logging();
     init_ast();
     init_paths();
-    init_logging();
-    DEFAULT_GIT_TIMEOUT_MS = 3e4;
-    gitRepositoryChecks = /* @__PURE__ */ new Map();
-    MAX_GIT_HASH_OBJECT_ARGUMENT_BYTES = 24 * 1024;
-    gitExecutableForTests = null;
-    GIT_QUOTED_PATH_SINGLE_BYTE_ESCAPES = {
-      a: 7,
-      b: 8,
-      f: 12,
-      n: 10,
-      r: 13,
-      t: 9,
-      v: 11
-    };
-    UNSAFE_REVISION_CHARACTERS = /[\0\r\n]/;
+    init_discoveryPath();
+    init_discoveryPath();
+    init_definitions();
+    init_parsers();
+    init_concurrency();
+    init_git();
+    DEFAULT_PROJECT_FILE_IGNORES = [
+      "**/node_modules/**",
+      "**/.git/**",
+      // Never treat Codegraph's own on-disk state as project input. `.codegraph/` contains
+      // lifecycle metadata and the indexer disk cache. Keep the legacy cache ignore so
+      // pre-migration checkouts stay excluded from discovery.
+      "**/.codegraph/**",
+      "**/.codegraph-cache/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/target/**",
+      "**/.venv/**",
+      "**/venv/**",
+      "**/site-packages/**",
+      "**/__pycache__/**",
+      "**/vendor/bundle/**",
+      "**/.build/**",
+      "**/Pods/**"
+    ];
+    DEFAULT_PROJECT_MANIFESTS = [
+      "package.json",
+      "package-lock.json",
+      "pnpm-lock.yaml",
+      "yarn.lock",
+      "bun.lockb",
+      "pnpm-workspace.yaml",
+      "lerna.json",
+      "nx.json",
+      "turbo.json",
+      "tsconfig.json",
+      "jsconfig.json",
+      "requirements.txt",
+      "requirements.in",
+      "pyproject.toml",
+      "Pipfile",
+      "Pipfile.lock",
+      "poetry.lock",
+      "setup.py",
+      "setup.cfg",
+      "Cargo.toml",
+      "Cargo.lock",
+      "rust-toolchain",
+      "rust-toolchain.toml",
+      "go.mod",
+      "go.sum",
+      "go.work",
+      "Gemfile",
+      "Gemfile.lock",
+      "*.gemspec",
+      "pom.xml",
+      "mvnw",
+      "build.gradle",
+      "build.gradle.kts",
+      "settings.gradle",
+      "settings.gradle.kts",
+      "gradle.properties",
+      "gradlew",
+      "*.csproj",
+      "*.fsproj",
+      "*.vbproj",
+      "*.sln",
+      "Directory.Build.props",
+      "Directory.Build.targets",
+      "global.json",
+      "composer.json",
+      "composer.lock",
+      "Package.swift",
+      "Package.resolved",
+      "CMakeLists.txt",
+      "CMakePresets.json",
+      "CMakeUserPresets.json",
+      "Makefile",
+      "makefile",
+      "GNUmakefile",
+      "configure.ac",
+      "configure.in",
+      "meson.build",
+      "meson_options.txt",
+      "conanfile.txt",
+      "conanfile.py",
+      "vcpkg.json"
+    ];
+    DEFAULT_PROJECT_PATTERNS = [
+      "**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs,py,pyi,php,vue,svelte,astro,hbs,handlebars,md,mdx,rst,adoc,asciidoc,go,java,cs,rb,rs,html,htm,css,scss,less,kt,kts,swift,zig,c,h,cc,cpp,cxx,c++,hpp,hh,hxx,ipp,tpp,inl,sql}",
+      ...DEFAULT_PROJECT_MANIFESTS.map((name) => `**/${name}`)
+    ];
+    REALPATH_FILTER_CONCURRENCY = 64;
+    EMPTY_GITIGNORE_INDEX = { hasRules: false, byBaseDir: /* @__PURE__ */ new Map() };
   }
 });
 
@@ -14523,13 +14840,13 @@ var init_projectSymbols = __esm({
 });
 
 // dist/util/resolution/jvm.js
-import fsp5 from "node:fs/promises";
+import fsp6 from "node:fs/promises";
 import path10 from "node:path";
 async function readJvmSymbolIndex(filePath, cache, options) {
   const cached2 = cache.get(filePath);
   if (cached2)
     return cached2;
-  const source = await fsp5.readFile(filePath, "utf8");
+  const source = await fsp6.readFile(filePath, "utf8");
   const packageName = source.match(options.packagePattern)?.[1] ?? null;
   const symbols = /* @__PURE__ */ new Set();
   for (const match of source.matchAll(options.declarationPattern)) {
@@ -14684,7 +15001,7 @@ var init_findFirstExisting = __esm({
 });
 
 // dist/util/resolution/files.js
-import fsp6 from "node:fs/promises";
+import fsp7 from "node:fs/promises";
 import path12 from "node:path";
 async function findNearestFile(startDir, stopDir, fileName) {
   let dir = path12.resolve(startDir);
@@ -14704,7 +15021,7 @@ async function findNearestFile(startDir, stopDir, fileName) {
 }
 async function isDirectory(p) {
   try {
-    const st = await fsp6.stat(p);
+    const st = await fsp7.stat(p);
     return st.isDirectory();
   } catch {
     return false;
@@ -14719,7 +15036,7 @@ var init_files = __esm({
 
 // dist/util/resolution/go.js
 import fs7 from "node:fs";
-import fsp7 from "node:fs/promises";
+import fsp8 from "node:fs/promises";
 import path13 from "node:path";
 function stripInlineComment(line) {
   const idx = line.indexOf("//");
@@ -14729,7 +15046,7 @@ async function parseGoMod(moduleRoot) {
   const modPath = path13.join(moduleRoot, "go.mod");
   if (!await fileExists(modPath))
     return null;
-  const raw = await fsp7.readFile(modPath, "utf8");
+  const raw = await fsp8.readFile(modPath, "utf8");
   const lines = raw.split(/\r?\n/);
   let modulePath = null;
   const replacements = /* @__PURE__ */ new Map();
@@ -14765,7 +15082,7 @@ async function parseGoMod(moduleRoot) {
   };
 }
 async function parseGoWork(goWorkPath) {
-  const content = await fsp7.readFile(goWorkPath, "utf8");
+  const content = await fsp8.readFile(goWorkPath, "utf8");
   const lines = content.split(/\r?\n/);
   const modules = [];
   let inUseBlock = false;
@@ -14794,7 +15111,7 @@ async function parseGoWork(goWorkPath) {
 }
 async function findGoPackageEntry(dirPath) {
   try {
-    const stat = await fsp7.stat(dirPath);
+    const stat = await fsp8.stat(dirPath);
     if (!stat.isDirectory())
       return null;
   } catch {
@@ -14802,7 +15119,7 @@ async function findGoPackageEntry(dirPath) {
   }
   let entries = [];
   try {
-    entries = await fsp7.readdir(dirPath, { withFileTypes: true });
+    entries = await fsp8.readdir(dirPath, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -14954,7 +15271,7 @@ var init_node = __esm({
 });
 
 // dist/util/resolution/phpComposer.js
-import fsp8 from "node:fs/promises";
+import fsp9 from "node:fs/promises";
 import path15 from "node:path";
 function readComposerNamespaceDirs(value, composerDir) {
   const result = /* @__PURE__ */ new Map();
@@ -15004,7 +15321,7 @@ async function loadPhpComposerConfig(composerPath) {
     return await cached2;
   const pending = (async () => {
     try {
-      const raw = await fsp8.readFile(composerPath, "utf8");
+      const raw = await fsp9.readFile(composerPath, "utf8");
       const parsed = JSON.parse(raw);
       const composerDir = path15.dirname(composerPath);
       const autoload = parsed.autoload && typeof parsed.autoload === "object" ? parsed.autoload : {};
@@ -15141,7 +15458,7 @@ async function getPhpComposerAutoloadFiles(composerPath, composerConfig) {
     }
     for (const root of roots) {
       try {
-        const stat = await fsp8.stat(root.path);
+        const stat = await fsp9.stat(root.path);
         if (stat.isDirectory()) {
           const files = await listProjectFiles(root.path, ["**/*.php"]);
           for (const filePath of files) {
@@ -15181,7 +15498,7 @@ async function phpFileMatchesNamespacePrefixes(filePath, namespacePrefixes) {
   }
   let source;
   try {
-    source = await fsp8.readFile(filePath, "utf8");
+    source = await fsp9.readFile(filePath, "utf8");
   } catch {
     return false;
   }
@@ -15217,7 +15534,7 @@ var init_phpComposer = __esm({
 });
 
 // dist/util/resolution/php.js
-import fsp9 from "node:fs/promises";
+import fsp10 from "node:fs/promises";
 import path16 from "node:path";
 async function resolvePhpPathLikeSpecifier(projectRoot, fromFile, spec) {
   let base = path16.resolve(path16.dirname(fromFile), spec);
@@ -15270,7 +15587,7 @@ async function readPhpSymbolIndex(filePath) {
   const cached2 = phpSymbolIndexCache.get(filePath);
   if (cached2)
     return cached2;
-  const source = await fsp9.readFile(filePath, "utf8");
+  const source = await fsp10.readFile(filePath, "utf8");
   const packageEntries = extractPhpTopLevelPackageEntries(source);
   const primaryEntry = packageEntries[0] ?? {
     packageName: "",
@@ -15719,7 +16036,7 @@ var init_php2 = __esm({
 
 // dist/util/resolution/python.js
 import fs8 from "node:fs";
-import fsp10 from "node:fs/promises";
+import fsp11 from "node:fs/promises";
 import path17 from "node:path";
 function pythonResolutionCacheKey(projectRoot, fromFile, moduleName, importDotCount) {
   const normalizedRoot = normalizePath(path17.resolve(projectRoot));
@@ -15731,7 +16048,7 @@ async function findPythonPackageAnchor(startDir) {
   let topWithInit = startDir;
   while (true) {
     try {
-      await fsp10.access(path17.join(dir, "__init__.py"), fs8.constants.R_OK);
+      await fsp11.access(path17.join(dir, "__init__.py"), fs8.constants.R_OK);
       topWithInit = dir;
     } catch {
     }
@@ -15777,7 +16094,7 @@ async function resolvePythonModule(projectRoot, fromFile, moduleName, importDotC
         resolvePythonModuleCache.set(cacheKey3, res);
         return res;
       }
-      await fsp10.access(c, fs8.constants.R_OK);
+      await fsp11.access(c, fs8.constants.R_OK);
       {
         const res = normalizePath(path17.resolve(c));
         resolvePythonModuleCache.set(cacheKey3, res);
@@ -15815,7 +16132,7 @@ async function resolvePythonModule(projectRoot, fromFile, moduleName, importDotC
           resolvePythonModuleCache.set(cacheKey3, res);
           return res;
         }
-        await fsp10.access(c, fs8.constants.R_OK);
+        await fsp11.access(c, fs8.constants.R_OK);
         {
           const res = normalizePath(path17.resolve(c));
           resolvePythonModuleCache.set(cacheKey3, res);
@@ -17987,7 +18304,7 @@ var require_lib2 = __commonJS({
 
 // dist/util/resolution/tsconfig.js
 import fs9 from "node:fs";
-import fsp11 from "node:fs/promises";
+import fsp12 from "node:fs/promises";
 import { createRequire } from "node:module";
 import path19 from "node:path";
 async function findNearestTsconfig(startFromFile, projectRoot) {
@@ -17997,7 +18314,7 @@ async function findNearestTsconfig(startFromFile, projectRoot) {
   while (isFilePathWithinRoot(resolvedProjectRoot, dir)) {
     const candidate = path19.join(dir, "tsconfig.json");
     try {
-      await fsp11.access(candidate, fs9.constants.R_OK);
+      await fsp12.access(candidate, fs9.constants.R_OK);
       return candidate;
     } catch {
     }
@@ -18058,7 +18375,7 @@ async function loadTsconfigConfig(cfgPath, projectRoot, seen = /* @__PURE__ */ n
     return { baseUrl: path19.dirname(normalizedCfgPath).replace(/\\/g, "/"), paths: {} };
   }
   seen.add(cfgKey);
-  const raw = await fsp11.readFile(cfgPath, "utf8");
+  const raw = await fsp12.readFile(cfgPath, "utf8");
   const json3 = parseJsonc(raw);
   const cfgDir = path19.dirname(cfgPath);
   const compilerOptions = json3.compilerOptions;
@@ -18181,7 +18498,7 @@ __export(resolution_exports, {
   resolveSpecifier: () => resolveSpecifier
 });
 import fs10 from "node:fs";
-import fsp12 from "node:fs/promises";
+import fsp13 from "node:fs/promises";
 import path20 from "node:path";
 function getResolveSpecifierCacheEntry(key) {
   return lruMapGet(resolveSpecifierCache, key);
@@ -18237,7 +18554,7 @@ async function resolvePathLikeModule(projectRoot, spec, resolutionExtensions) {
         return path20.resolve(path20.join(p, "index" + e));
     }
     if (await fileExists(p)) {
-      const st = await fsp12.stat(p);
+      const st = await fsp13.stat(p);
       if (!st.isDirectory())
         return path20.resolve(p);
     }
@@ -18584,7 +18901,7 @@ var init_confinedFile = __esm({
 });
 
 // dist/util/workerThreads.js
-import os2 from "node:os";
+import os3 from "node:os";
 function resolveWorkerThreadCount(options) {
   const max = options?.max ?? 64;
   const requested = options?.requested;
@@ -18595,7 +18912,7 @@ function resolveWorkerThreadCount(options) {
   if (typeof defaultCount === "number" && Number.isFinite(defaultCount) && defaultCount > 0) {
     return Math.min(Math.max(Math.floor(defaultCount), 1), max);
   }
-  return Math.min(Math.max(os2.availableParallelism() - 1, 1), max);
+  return Math.min(Math.max(os3.availableParallelism() - 1, 1), max);
 }
 var init_workerThreads = __esm({
   "dist/util/workerThreads.js"() {
@@ -19000,17 +19317,17 @@ var init_sfc = __esm({
 });
 
 // dist/languages/filePrep.js
-import fsp13 from "node:fs/promises";
+import fsp14 from "node:fs/promises";
 async function prepareSourceInput(file2, opts) {
   const framework = detectSFCFramework(file2);
   if (framework) {
-    const rawSource2 = opts?.source ?? await fsp13.readFile(file2, "utf8");
+    const rawSource2 = opts?.source ?? await fsp14.readFile(file2, "utf8");
     return prepareSFCSourceInput(rawSource2, framework);
   }
   const sup = supportForFile(file2, opts?.languageExtensions);
   if (!sup)
     throw new UnsupportedParserInputError(file2);
-  const rawSource = opts?.source ?? await fsp13.readFile(file2, "utf8");
+  const rawSource = opts?.source ?? await fsp14.readFile(file2, "utf8");
   return {
     source: rawSource,
     sup
@@ -20962,7 +21279,7 @@ var init_angularjs = __esm({
 });
 
 // dist/graphs/angularjs.js
-import fsp14 from "node:fs/promises";
+import fsp15 from "node:fs/promises";
 async function collectAngularJsFrameworkEdges(projectRoot, files, workspaceConfig, parsed) {
   const jsFiles = files.filter((file2) => file2.toLowerCase().endsWith(".js"));
   if (!jsFiles.length)
@@ -20975,7 +21292,7 @@ async function collectAngularJsFrameworkEdges(projectRoot, files, workspaceConfi
       continue;
     }
     try {
-      const source = await fsp14.readFile(file2, "utf8");
+      const source = await fsp15.readFile(file2, "utf8");
       contexts.push({ file: file2, source });
     } catch {
       continue;
@@ -24725,7 +25042,7 @@ var init_extractFacts = __esm({
 
 // dist/sql/sourceGraph.js
 import crypto2 from "node:crypto";
-import fsp15 from "node:fs/promises";
+import fsp16 from "node:fs/promises";
 function isSqlFile(filePath, languageExtensions) {
   return supportForFile(filePath, languageExtensions)?.id === "sql";
 }
@@ -24854,7 +25171,7 @@ function buildSqlModuleIndex(filePath, source) {
   };
 }
 async function readSqlFacts(filePath) {
-  return extractSqlFactsFromSource(filePath, await fsp15.readFile(filePath, "utf8"));
+  return extractSqlFactsFromSource(filePath, await fsp16.readFile(filePath, "utf8"));
 }
 async function buildSqlFactCache(allFiles, languageExtensions) {
   const sqlFiles2 = Array.from(new Set(allFiles.map(normalizePath).filter((file2) => isSqlFile(file2, languageExtensions)))).sort((left, right) => left.localeCompare(right));
@@ -25290,7 +25607,7 @@ var init_adjacency = __esm({
 });
 
 // dist/worker/nativeExtractWorker.js
-import fsp16 from "node:fs/promises";
+import fsp17 from "node:fs/promises";
 import { createRequire as createRequire3 } from "node:module";
 import path32 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -25493,9 +25810,9 @@ var init_nativeExtractWorker = __esm({
     localNativePackageRoot2 = path32.resolve(path32.dirname(fileURLToPath3(import.meta.url)), "../../packages/codegraph-native");
     runExtraction = createNativeExtractor({
       loadBinding: loadProductionBinding,
-      readFile: fsp16.readFile,
+      readFile: fsp17.readFile,
       statFile: async (filePath) => {
-        const stat = await fsp16.stat(filePath);
+        const stat = await fsp17.stat(filePath);
         return { size: stat.size };
       }
     });
@@ -29805,7 +30122,7 @@ var init_reports = __esm({
 // dist/indexer/build-cache/location.js
 import crypto4 from "node:crypto";
 import fs16 from "node:fs";
-import os3 from "node:os";
+import os4 from "node:os";
 import path35 from "node:path";
 function isWritableDirectory(candidate) {
   try {
@@ -29816,7 +30133,7 @@ function isWritableDirectory(candidate) {
 }
 function isForbiddenAnchor(candidate) {
   const resolved = path35.resolve(candidate);
-  const home = path35.resolve(os3.homedir());
+  const home = path35.resolve(os4.homedir());
   const parsed = path35.parse(resolved);
   return fileIdentityKey(resolved) === fileIdentityKey(home) || fileIdentityKey(resolved) === fileIdentityKey(parsed.root);
 }
@@ -29840,7 +30157,7 @@ function findRepositoryAnchor(projectRoot) {
   return { anchor: start, layer: "project" };
 }
 function resolveCodegraphUserCacheRoot2() {
-  const base = process.platform === "win32" ? process.env.LOCALAPPDATA?.trim() || path35.join(os3.homedir(), "AppData", "Local") : process.env.XDG_CACHE_HOME?.trim() || path35.join(os3.homedir(), ".cache");
+  const base = process.platform === "win32" ? process.env.LOCALAPPDATA?.trim() || path35.join(os4.homedir(), "AppData", "Local") : process.env.XDG_CACHE_HOME?.trim() || path35.join(os4.homedir(), ".cache");
   return path35.join(base, "codegraph");
 }
 function projectCacheNamespace(projectRoot, anchor) {
@@ -29874,7 +30191,33 @@ function assertAnchorNotForbidden(resolution) {
     return;
   if (!isForbiddenAnchor(resolution.anchor))
     return;
-  throw new Error(`Cache anchor "${resolution.anchor}" (from ${CONFIGURED_ANCHOR_LAYER_LABELS[resolution.layer]}) is the home directory or a filesystem root. codegraph refuses to use it as a cache root. Use a subdirectory instead, e.g. "${path35.join(resolution.anchor, ".codegraph-cache")}".`);
+  throw new Error(`Cache anchor "${resolution.anchor}" (from ${CONFIGURED_ANCHOR_LAYER_LABELS[resolution.layer]}) is the home directory or a filesystem root. codegraph refuses to use it as a cache root. Use a subdirectory instead, e.g. "${path35.join(resolution.anchor, PROJECT_CACHE_DIRECTORY)}".`);
+}
+function migrateLegacyProjectCache(candidate, legacyCandidates, logLevel) {
+  if (fs16.existsSync(candidate))
+    return;
+  const legacy = legacyCandidates.find(({ path: legacyPath }) => fs16.existsSync(legacyPath));
+  if (!legacy)
+    return;
+  try {
+    fs16.mkdirSync(path35.dirname(candidate), { recursive: true });
+    fs16.renameSync(legacy.path, candidate);
+  } catch (error51) {
+    if (logLevel === "debug")
+      console.debug(`Unable to migrate legacy cache from ${legacy.path}:`, error51);
+    return;
+  }
+  let current = path35.dirname(legacy.path);
+  for (; ; ) {
+    try {
+      fs16.rmdirSync(current);
+    } catch {
+      break;
+    }
+    if (fileIdentityKey(current) === fileIdentityKey(legacy.cleanupBoundary))
+      break;
+    current = path35.dirname(current);
+  }
 }
 function resolveCacheLocation(projectRoot, opts) {
   const root = path35.resolve(projectRoot);
@@ -29885,34 +30228,57 @@ function resolveCacheLocation(projectRoot, opts) {
   const anchor = anchorWritable ? resolution.anchor : root;
   const effectiveLayer = anchorWritable ? resolution.layer : "project";
   const sameRoot2 = fileIdentityKey(anchor) === fileIdentityKey(root);
-  if (sameRoot2 && !opts?.cacheDir && !process.env.CODEGRAPH_CACHE_DIR?.trim() && (!opts?.cacheLocation || opts.cacheLocation === "project")) {
-    return { path: path35.join(root, ".codegraph-cache", "index-v1"), anchor, layer: effectiveLayer };
+  const explicitBase = opts?.cacheDir?.trim() || process.env.CODEGRAPH_CACHE_DIR?.trim();
+  if (sameRoot2 && !explicitBase && (!opts?.cacheLocation || opts.cacheLocation === "project")) {
+    const candidate2 = path35.join(root, PROJECT_CACHE_RELATIVE_PATH);
+    migrateLegacyProjectCache(candidate2, [
+      {
+        path: path35.join(root, LEGACY_PROJECT_CACHE_RELATIVE_PATH),
+        cleanupBoundary: path35.join(root, ".codegraph-cache")
+      }
+    ], opts?.logLevel);
+    return { path: candidate2, anchor, layer: effectiveLayer };
   }
   const namespace = projectCacheNamespace(root, effectiveLayer === "git" || effectiveLayer === "manifest" ? anchor : void 0);
-  const explicitBase = opts?.cacheDir?.trim() || process.env.CODEGRAPH_CACHE_DIR?.trim();
   if (explicitBase) {
     const configured = path35.resolve(explicitBase);
     const configuredPath = path35.basename(configured) === namespace ? configured : path35.join(configured, namespace);
     return { path: configuredPath, anchor, layer: effectiveLayer };
   }
-  const base = opts?.cacheLocation === "user" ? resolveCodegraphUserCacheRoot2() : path35.join(anchor, ".codegraph-cache");
-  const candidate = path35.join(path35.resolve(base), "index-v1", namespace);
-  if (!sameRoot2 && !opts?.cacheLocation) {
-    const legacy = path35.join(root, ".codegraph-cache", "index-v1");
-    if (!fs16.existsSync(candidate) && fs16.existsSync(legacy)) {
-      return { path: legacy, anchor: root, layer: "project" };
+  if (opts?.cacheLocation === "user") {
+    return {
+      path: path35.join(resolveCodegraphUserCacheRoot2(), "index-v1", namespace),
+      anchor,
+      layer: effectiveLayer
+    };
+  }
+  const candidate = path35.join(anchor, PROJECT_CACHE_RELATIVE_PATH, namespace);
+  const legacyCandidates = [
+    {
+      path: path35.join(anchor, LEGACY_PROJECT_CACHE_RELATIVE_PATH, namespace),
+      cleanupBoundary: path35.join(anchor, ".codegraph-cache")
     }
+  ];
+  if (!sameRoot2 && !opts?.cacheLocation) {
+    legacyCandidates.push({
+      path: path35.join(root, LEGACY_PROJECT_CACHE_RELATIVE_PATH),
+      cleanupBoundary: path35.join(root, ".codegraph-cache")
+    });
   }
+  migrateLegacyProjectCache(candidate, legacyCandidates, opts?.logLevel);
   return { path: candidate, anchor, layer: effectiveLayer };
 }
 function cacheRoot(projectRoot, opts) {
   return resolveCacheLocation(projectRoot, opts).path;
 }
-var CONFIGURED_ANCHOR_LAYER_LABELS;
+var PROJECT_CACHE_DIRECTORY, PROJECT_CACHE_RELATIVE_PATH, LEGACY_PROJECT_CACHE_RELATIVE_PATH, CONFIGURED_ANCHOR_LAYER_LABELS;
 var init_location = __esm({
   "dist/indexer/build-cache/location.js"() {
     "use strict";
     init_paths();
+    PROJECT_CACHE_DIRECTORY = ".codegraph";
+    PROJECT_CACHE_RELATIVE_PATH = path35.join(PROJECT_CACHE_DIRECTORY, "cache", "index-v1");
+    LEGACY_PROJECT_CACHE_RELATIVE_PATH = path35.join(".codegraph-cache", "index-v1");
     CONFIGURED_ANCHOR_LAYER_LABELS = {
       explicit: "--cache-dir (or an absolute cache.location)",
       environment: "CODEGRAPH_CACHE_DIR",
@@ -30158,7 +30524,7 @@ var init_options2 = __esm({
 import { brotliCompressSync, brotliDecompressSync, constants as zlibConstants } from "node:zlib";
 import crypto6 from "node:crypto";
 import fs17 from "node:fs";
-import fsp17 from "node:fs/promises";
+import fsp18 from "node:fs/promises";
 import path37 from "node:path";
 function memoryCacheKey(projectRoot, file2) {
   return `${normalizePath(projectRoot)}::${file2}`;
@@ -30310,14 +30676,14 @@ function pruneDiskModuleCache(projectRoot, liveFiles, opts) {
   }
 }
 async function fileContentHash(file2) {
-  const buffer = await fsp17.readFile(file2);
+  const buffer = await fsp18.readFile(file2);
   const hash2 = crypto6.createHash("sha1");
   hash2.update(buffer);
   return hash2.digest("hex");
 }
 async function fileStatSignature(file2, strict, opts) {
   try {
-    const stat = await fsp17.stat(file2);
+    const stat = await fsp18.stat(file2);
     const useStrict = strict ?? true;
     const shouldHash = useStrict || !!opts?.includeContentHash;
     const contentHash = shouldHash ? await fileContentHash(file2) : void 0;
@@ -30375,7 +30741,7 @@ async function cacheSignatureForFile(file2, sigInfo, opts) {
 }
 async function buildBloomFilterForFile(file2, opts) {
   try {
-    const source = await fsp17.readFile(file2, "utf8");
+    const source = await fsp18.readFile(file2, "utf8");
     const support = supportForFile(file2, opts?.languageExtensions);
     if (!support)
       return null;
@@ -31085,7 +31451,7 @@ __export(units_exports, {
   shouldKeepUnit: () => shouldKeepUnit
 });
 import crypto7 from "node:crypto";
-import fsp18 from "node:fs/promises";
+import fsp19 from "node:fs/promises";
 import path39 from "node:path";
 function lineSpan(unit) {
   return Math.max(1, unit.endLine - unit.startLine + 1);
@@ -31474,7 +31840,7 @@ async function buildDuplicateUnitsForFile(index, file2, projectRoot, minTokens,
   let source = index.parsed?.get(fileIdentityKey(file2))?.source;
   if (source === void 0) {
     try {
-      source = await fsp18.readFile(file2, "utf8");
+      source = await fsp19.readFile(file2, "utf8");
     } catch {
       return [];
     }
@@ -48363,8 +48729,8 @@ __export(config_exports, {
   mergeDiscoveryOptions: () => mergeDiscoveryOptions,
   mergeGraphOptions: () => mergeGraphOptions
 });
-import fsp19 from "node:fs/promises";
-import os4 from "node:os";
+import fsp20 from "node:fs/promises";
+import os5 from "node:os";
 import path40 from "node:path";
 function uniq(values) {
   return Array.from(new Set(values.map((value) => value.trim().replace(/\\/g, "/")).filter(Boolean)));
@@ -48434,10 +48800,10 @@ function normalizeConfigLanguageExtensions(extensions) {
   return normalizeLanguageExtensions(extensions);
 }
 async function loadUserCacheLocation() {
-  const configRoot = process.platform === "win32" ? process.env.APPDATA?.trim() || path40.join(os4.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME?.trim() || path40.join(os4.homedir(), ".config");
+  const configRoot = process.platform === "win32" ? process.env.APPDATA?.trim() || path40.join(os5.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME?.trim() || path40.join(os5.homedir(), ".config");
   const configPath = path40.join(configRoot, "codegraph", "config.json");
   try {
-    const parsedJson = JSON.parse(await fsp19.readFile(configPath, "utf8"));
+    const parsedJson = JSON.parse(await fsp20.readFile(configPath, "utf8"));
     const parsed = codegraphConfigSchema.safeParse(parsedJson);
     if (!parsed.success)
       throw new Error(external_exports.prettifyError(parsed.error));
@@ -48453,7 +48819,7 @@ async function loadCodegraphConfig(projectRoot) {
   const configPath = path40.join(projectRoot, CODEGRAPH_CONFIG_FILE);
   let raw;
   try {
-    raw = await fsp19.readFile(configPath, "utf8");
+    raw = await fsp20.readFile(configPath, "utf8");
   } catch (error51) {
     if (error51 instanceof Error && "code" in error51 && error51.code === "ENOENT") {
       return userCacheLocation ? { cache: { location: userCacheLocation } } : {};
@@ -48519,7 +48885,7 @@ var init_config = __esm({
 // dist/indexer/build-cache/manifest.js
 import crypto8 from "node:crypto";
 import fs19 from "node:fs";
-import fsp20, {} from "node:fs/promises";
+import fsp21, {} from "node:fs/promises";
 import path41 from "node:path";
 async function collectWorkspaceManifestDependencyEdges(projectRoot, manifestFiles, discovery, logLevel) {
   const manifestPaths = manifestFiles ?? await listProjectFiles(projectRoot, ["**/package.json"], {
@@ -48532,7 +48898,7 @@ async function collectWorkspaceManifestDependencyEdges(projectRoot, manifestFile
   const parsedByPath = /* @__PURE__ */ new Map();
   for (const manifestPath of manifestPaths) {
     try {
-      const raw = await fsp20.readFile(manifestPath, "utf8");
+      const raw = await fsp21.readFile(manifestPath, "utf8");
       const parsed = JSON.parse(raw);
       parsedByPath.set(manifestPath, parsed);
       if (typeof parsed.name === "string" && parsed.name.trim()) {
@@ -48605,7 +48971,7 @@ function normalizeIndexedFileInputs(projectRoot, files, label, realProjectRoot)
   return [...filesByIdentity.values()];
 }
 async function normalizeIndexedFileInputsWithinRoot(projectRoot, files, label) {
-  const realRoot = await fsp20.realpath(projectRoot);
+  const realRoot = await fsp21.realpath(projectRoot);
   const normalized = normalizeIndexedFileInputs(projectRoot, files, label, realRoot);
   await Promise.all(normalized.map(async (file2) => {
     try {
@@ -48673,7 +49039,7 @@ async function computeConfigHash(projectRoot, logLevel) {
     let firstError;
     for (const file2 of configFiles) {
       try {
-        const content = await fsp20.readFile(file2, "utf8");
+        const content = await fsp21.readFile(file2, "utf8");
         const relative = path41.relative(projectRoot, file2).replace(/\\/g, "/");
         hash2.update(relative);
         hash2.update(content);
@@ -48719,7 +49085,7 @@ function isManifestTempName(name, manifestName) {
 async function cleanupStaleManifestTemps(manifestPath) {
   let entries;
   try {
-    entries = await fsp20.readdir(path41.dirname(manifestPath), { withFileTypes: true });
+    entries = await fsp21.readdir(path41.dirname(manifestPath), { withFileTypes: true });
   } catch {
     return;
   }
@@ -48730,15 +49096,15 @@ async function cleanupStaleManifestTemps(manifestPath) {
       continue;
     const candidate = path41.join(path41.dirname(manifestPath), entry.name);
     try {
-      const stat = await fsp20.lstat(candidate);
+      const stat = await fsp21.lstat(candidate);
       if (stat.mtimeMs <= cutoff)
-        await fsp20.rm(candidate, { force: true });
+        await fsp21.rm(candidate, { force: true });
     } catch {
     }
   }
 }
 async function fsyncManifestFile(filePath) {
-  const handle = await fsp20.open(filePath, "r+");
+  const handle = await fsp21.open(filePath, "r+");
   try {
     await handle.sync();
   } finally {
@@ -48748,7 +49114,7 @@ async function fsyncManifestFile(filePath) {
 async function syncManifestDirectory(directoryPath) {
   let directory;
   try {
-    directory = await fsp20.open(directoryPath, "r");
+    directory = await fsp21.open(directoryPath, "r");
     await directory.sync();
   } catch {
   } finally {
@@ -48771,14 +49137,14 @@ async function writeManifestAtomically(manifestPath, payload) {
   for (let attempt = 0; attempt <= retryDelays.length; attempt += 1) {
     const tempPath = manifestTempFilePath(manifestPath);
     try {
-      await fsp20.writeFile(tempPath, payload, "utf8");
+      await fsp21.writeFile(tempPath, payload, "utf8");
       await fsyncManifestFile(tempPath);
-      await fsp20.rename(tempPath, manifestPath);
+      await fsp21.rename(tempPath, manifestPath);
       await syncManifestDirectory(path41.dirname(manifestPath));
       return;
     } catch (error51) {
       try {
-        await fsp20.rm(tempPath, { force: true });
+        await fsp21.rm(tempPath, { force: true });
       } catch {
       }
       const canRetry = attempt < retryDelays.length && isTransientFileContentionError(error51);
@@ -48801,7 +49167,7 @@ function recordManifestCorruption(report, artifact, reason, logLevel) {
 async function loadManifest(projectRoot, opts, report) {
   const manifestPath = manifestFilePath(projectRoot, opts);
   try {
-    const raw = await fsp20.readFile(manifestPath, "utf8");
+    const raw = await fsp21.readFile(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     let invalidReason;
     if (parsed.version !== MANIFEST_VERSION && parsed.version !== 4 && parsed.version !== 3) {
@@ -48837,7 +49203,7 @@ async function loadManifest(projectRoot, opts, report) {
 async function writeManifest2(projectRoot, opts, manifest) {
   try {
     const manifestPath = manifestFilePath(projectRoot, opts);
-    await fsp20.mkdir(path41.dirname(manifestPath), { recursive: true });
+    await fsp21.mkdir(path41.dirname(manifestPath), { recursive: true });
     await writeManifestAtomically(manifestPath, JSON.stringify(manifest, null, 2));
     return true;
   } catch (error51) {
@@ -49612,7 +49978,7 @@ var init_symbol_graph = __esm({
 });
 
 // dist/indexer/build-cache/project-snapshot.js
-import fsp21 from "node:fs/promises";
+import fsp22 from "node:fs/promises";
 import { createHash as createHash3, randomUUID } from "node:crypto";
 import { brotliCompressSync as brotliCompressSync3, brotliDecompressSync as brotliDecompressSync3, constants as zlibConstants3 } from "node:zlib";
 import path43 from "node:path";
@@ -49763,7 +50129,7 @@ function sameSnapshotFileIdentity(left, right) {
   return left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
 }
 async function snapshotFileIdentity(snapshotPath) {
-  const stat = await fsp21.stat(snapshotPath);
+  const stat = await fsp22.stat(snapshotPath);
   return {
     size: stat.size,
     mtimeMs: stat.mtimeMs,
@@ -49771,7 +50137,7 @@ async function snapshotFileIdentity(snapshotPath) {
   };
 }
 async function fsyncSnapshotFile(snapshotPath) {
-  const handle = await fsp21.open(snapshotPath, "r+");
+  const handle = await fsp22.open(snapshotPath, "r+");
   try {
     await handle.sync();
   } finally {
@@ -49788,7 +50154,7 @@ function isSnapshotTempName(name, snapshotName) {
 async function cleanupStaleSnapshotTemps(snapshotPath) {
   let entries;
   try {
-    entries = await fsp21.readdir(path43.dirname(snapshotPath), { withFileTypes: true });
+    entries = await fsp22.readdir(path43.dirname(snapshotPath), { withFileTypes: true });
   } catch {
     return;
   }
@@ -49799,26 +50165,26 @@ async function cleanupStaleSnapshotTemps(snapshotPath) {
       continue;
     const candidate = path43.join(path43.dirname(snapshotPath), entry.name);
     try {
-      const stat = await fsp21.lstat(candidate);
+      const stat = await fsp22.lstat(candidate);
       if (stat.mtimeMs > cutoff)
         continue;
-      await fsp21.rm(candidate, { force: true });
+      await fsp22.rm(candidate, { force: true });
     } catch {
     }
   }
 }
 async function writeSnapshotAtomically(snapshotPath, data) {
-  await fsp21.mkdir(path43.dirname(snapshotPath), { recursive: true });
+  await fsp22.mkdir(path43.dirname(snapshotPath), { recursive: true });
   await cleanupStaleSnapshotTemps(snapshotPath);
   let tempPath = path43.join(path43.dirname(snapshotPath), `.${path43.basename(snapshotPath)}.${process.pid}.${randomUUID()}${SNAPSHOT_TEMP_SUFFIX}`);
   try {
-    await fsp21.writeFile(tempPath, data, { flag: "wx" });
+    await fsp22.writeFile(tempPath, data, { flag: "wx" });
     await fsyncSnapshotFile(tempPath);
-    await fsp21.rename(tempPath, snapshotPath);
+    await fsp22.rename(tempPath, snapshotPath);
     tempPath = void 0;
   } finally {
     if (tempPath) {
-      await fsp21.rm(tempPath, { force: true }).catch(() => void 0);
+      await fsp22.rm(tempPath, { force: true }).catch(() => void 0);
     }
   }
 }
@@ -49873,7 +50239,7 @@ async function readParsedSnapshot(snapshotPath) {
     setBoundedSnapshotCache(parsedSnapshotCache, snapshotPath, cached2);
     return { identity: cached2.identity, payload: cached2.payload };
   }
-  const compressed = Buffer.from(await fsp21.readFile(snapshotPath));
+  const compressed = Buffer.from(await fsp22.readFile(snapshotPath));
   const payload = decodeSnapshotPayload(compressed);
   const after = await snapshotFileIdentity(snapshotPath);
   const entry = { identity: before, compressed, payload };
@@ -50393,11 +50759,11 @@ function sameSymbolEdgeMultiset(expected, actual) {
     return false;
   const counts = /* @__PURE__ */ new Map();
   for (const edge of expected) {
-    const key = serializedSymbolEdge(edge);
+    const key = symbolEdgeKey(edge);
     counts.set(key, (counts.get(key) ?? 0) + 1);
   }
   for (const edge of actual) {
-    const key = serializedSymbolEdge(edge);
+    const key = symbolEdgeKey(edge);
     const remaining = counts.get(key);
     if (remaining === void 0)
       return false;
@@ -50408,27 +50774,30 @@ function sameSymbolEdgeMultiset(expected, actual) {
   }
   return !counts.size;
 }
-function serializedSymbolEdge(edge) {
-  return JSON.stringify({
-    from: edge.from,
-    to: edge.to,
-    label: edge.label,
-    site: edge.site ? {
-      file: edge.site.file,
-      range: {
-        start: {
-          line: edge.site.range.start.line,
-          column: edge.site.range.start.column,
-          ...edge.site.range.start.index !== void 0 ? { index: edge.site.range.start.index } : {}
-        },
-        end: {
-          line: edge.site.range.end.line,
-          column: edge.site.range.end.column,
-          ...edge.site.range.end.index !== void 0 ? { index: edge.site.range.end.index } : {}
-        }
-      }
-    } : void 0
-  });
+function symbolEdgeKey(edge) {
+  const from = lengthPrefixedSymbolEdgeField(edge.from);
+  const to = lengthPrefixedSymbolEdgeField(edge.to);
+  const label = edge.label === void 0 ? "u" : `s${lengthPrefixedSymbolEdgeField(edge.label)}`;
+  if (!edge.site)
+    return `f${from}t${to}l${label}s`;
+  const { file: file2, range } = edge.site;
+  const startIndex = range.start.index === void 0 ? "u" : `n${range.start.index}`;
+  const endIndex = range.end.index === void 0 ? "u" : `n${range.end.index}`;
+  return [
+    `f${from}`,
+    `t${to}`,
+    `l${label}`,
+    `s${lengthPrefixedSymbolEdgeField(file2)}`,
+    `sl${range.start.line}`,
+    `sc${range.start.column}`,
+    `si${startIndex}`,
+    `el${range.end.line}`,
+    `ec${range.end.column}`,
+    `ei${endIndex}`
+  ].join("");
+}
+function lengthPrefixedSymbolEdgeField(value) {
+  return `${value.length}:${value}`;
 }
 function normalizedSnapshotNativeMode(nativeMode) {
   if (nativeMode === void 0 || nativeMode === "auto")
@@ -50735,21 +51104,21 @@ var init_build_cache = __esm({
 
 // dist/indexer/build-cache/resolver-environment.js
 import crypto9 from "node:crypto";
-import fsp22 from "node:fs/promises";
+import fsp23 from "node:fs/promises";
 import path44 from "node:path";
 function normalizedRelativePath(projectRoot, target) {
   return path44.relative(projectRoot, target).replace(/\\/g, "/");
 }
 async function statInput(projectRoot, target) {
   try {
-    const stat = await fsp22.stat(target);
+    const stat = await fsp23.stat(target);
     if (!stat.isFile())
       return null;
     const sampleBytes = Math.min(stat.size, RESOLUTION_INPUT_SAMPLE_BYTES);
     const hash2 = crypto9.createHash("sha256");
     if (sampleBytes) {
       const first = Buffer.allocUnsafe(sampleBytes);
-      const handle = await fsp22.open(target, "r");
+      const handle = await fsp23.open(target, "r");
       try {
         const firstRead = await handle.read(first, 0, sampleBytes, 0);
         hash2.update(first.subarray(0, firstRead.bytesRead));
@@ -50797,7 +51166,7 @@ async function activeNodeModulesRoots(projectRoot, files) {
     return null;
   const roots = await Promise.all(candidates.map(async (candidate) => {
     try {
-      return (await fsp22.stat(candidate)).isDirectory() ? candidate : null;
+      return (await fsp23.stat(candidate)).isDirectory() ? candidate : null;
     } catch {
       return null;
     }
@@ -50807,7 +51176,7 @@ async function activeNodeModulesRoots(projectRoot, files) {
 async function installedPackageManifests(projectRoot, root) {
   let entries;
   try {
-    entries = await fsp22.readdir(root, { withFileTypes: true });
+    entries = await fsp23.readdir(root, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -50818,7 +51187,7 @@ async function installedPackageManifests(projectRoot, root) {
     const entryPath = path44.join(root, entry.name);
     if (entry.name.startsWith("@")) {
       try {
-        const scopedEntries = await fsp22.readdir(entryPath, { withFileTypes: true });
+        const scopedEntries = await fsp23.readdir(entryPath, { withFileTypes: true });
         for (const scopedEntry of scopedEntries) {
           if (scopedEntry.isDirectory())
             packageDirectories.push(path44.join(entryPath, scopedEntry.name));
@@ -50969,7 +51338,7 @@ var init_finalize = __esm({
 });
 
 // dist/indexer/build-manifest.js
-import fsp23 from "node:fs/promises";
+import fsp24 from "node:fs/promises";
 import path45 from "node:path";
 import { performance as performance3 } from "node:perf_hooks";
 function toManifestFileEntry(entry) {
@@ -50989,7 +51358,7 @@ async function writeIndexManifestSnapshot(args) {
   const writeManifestStart = performance3.now();
   const lastCommit = await getGitHead(args.projectRoot);
   const configHashResult = await computeConfigHash(args.projectRoot, args.opts?.logLevel);
-  const projectRootMtimeMs = args.symlinkDirectories !== void 0 ? (await fsp23.stat(args.projectRoot)).mtimeMs : void 0;
+  const projectRootMtimeMs = args.symlinkDirectories !== void 0 ? (await fsp24.stat(args.projectRoot)).mtimeMs : void 0;
   const configHash = recordConfigHashResult(args.manifestReport, configHashResult, args.opts?.logLevel);
   const manifestData = {
     version: MANIFEST_VERSION,
@@ -52617,10 +52986,10 @@ var init_build_workers = __esm({
 
 // dist/indexer/incremental-plan.js
 import fs22 from "node:fs";
-import fsp24 from "node:fs/promises";
+import fsp25 from "node:fs/promises";
 async function pathExists2(filePath) {
   try {
-    await fsp24.access(filePath);
+    await fsp25.access(filePath);
     return true;
   } catch {
     return false;
@@ -52797,7 +53166,7 @@ __export(build_index_exports, {
 });
 import crypto10 from "node:crypto";
 import fs23 from "node:fs";
-import fsp25 from "node:fs/promises";
+import fsp26 from "node:fs/promises";
 import path47 from "node:path";
 import { performance as performance5 } from "node:perf_hooks";
 function initParserBackendDegradationReport(report) {
@@ -53151,7 +53520,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
   const shouldWriteManifest = manifestMode === "read-write";
   const projectFiles = helperOpts?.projectFiles;
   initManifestReport(report, useManifest, false);
-  const confinedRoot = helperOpts?.confineReads ? await fsp25.realpath(projectRoot) : void 0;
+  const confinedRoot = helperOpts?.confineReads ? await fsp26.realpath(projectRoot) : void 0;
   const [trustedSources, normalizedFiles] = [
     confinedRoot ? /* @__PURE__ */ new Map() : void 0,
     Array.from(new Set(normalizeIndexedFileInputs(projectRoot, rawFiles ?? [], "Index file")))
@@ -53529,7 +53898,7 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
     const useDiskCache = (opts?.cache ?? "off") === "disk";
     const wantsMaxSymlinkCorrectness = !!opts?.cacheStrict || !!opts?.cacheVerify;
     const symlinkHintManifest = helperOpts?.ignoreExistingManifest || wantsMaxSymlinkCorrectness || !useDiskCache ? null : await loadManifest(projectRoot, opts);
-    const rootMtime = symlinkHintManifest ? (await fsp25.stat(projectRoot)).mtimeMs : void 0;
+    const rootMtime = symlinkHintManifest ? (await fsp26.stat(projectRoot)).mtimeMs : void 0;
     const symlinkHintIsFresh = symlinkHintManifest?.symlinkDirectoriesRootMtimeMs !== void 0 && rootMtime === symlinkHintManifest.symlinkDirectoriesRootMtimeMs;
     const knownSymlinkDirectories = symlinkHintIsFresh ? symlinkHintManifest?.symlinkDirectories : void 0;
     let discoveredSymlinkDirectories = knownSymlinkDirectories;
@@ -53886,7 +54255,7 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
       if (!entry?.sig)
         return true;
       try {
-        const stat = await fsp25.stat(file2);
+        const stat = await fsp26.stat(file2);
         const prefix = `${stat.mtimeMs}:${stat.size}`;
         return !(entry.sig === prefix || entry.sig.startsWith(`${prefix}:`));
       } catch {
@@ -55467,6 +55836,17 @@ function toolFollowUp(tool, arguments_ = {}, label) {
     ...label !== void 0 ? { label } : {}
   };
 }
+function dedupeAgentFollowUps(followUps) {
+  const seen = /* @__PURE__ */ new Set();
+  return followUps.filter((followUp) => {
+    const serializedArguments = JSON.stringify(followUp.arguments);
+    const key = `${followUp.tool.length}|${followUp.tool}${serializedArguments}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
 function formatAgentFollowUpAsCli(followUp) {
   const args = followUp.arguments;
   switch (followUp.tool) {
@@ -55693,7 +56073,7 @@ var init_sessionLifecycle = __esm({
 });
 
 // dist/agent/session.js
-import fsp26 from "node:fs/promises";
+import fsp27 from "node:fs/promises";
 import path49 from "node:path";
 function assertNoPrebuiltSessionWithBuildOptions(options, consumer) {
   if (options.session && options.buildOptions) {
@@ -55772,7 +56152,7 @@ async function collectAgentFileSignatures(files) {
   await mapLimit([...files], FILE_SIGNATURE_STAT_CONCURRENCY, async (file2) => {
     const resolvedFile = normalizePath(path49.resolve(file2));
     try {
-      const stat = await fsp26.stat(resolvedFile);
+      const stat = await fsp27.stat(resolvedFile);
       if (!stat.isFile())
         return;
       signatures.set(resolvedFile, {
@@ -56133,13 +56513,13 @@ var init_errors4 = __esm({
 });
 
 // dist/lifecycle/gitignore.js
-import fsp27 from "node:fs/promises";
+import fsp28 from "node:fs/promises";
 import path50 from "node:path";
 async function readGitignoreFile(gitignorePath) {
   let existing = "";
   let stats;
   try {
-    stats = await fsp27.lstat(gitignorePath);
+    stats = await fsp28.lstat(gitignorePath);
   } catch (error51) {
     if (!(error51 instanceof Error && "code" in error51 && error51.code === "ENOENT")) {
       const detail = errorMessage(error51);
@@ -56156,7 +56536,7 @@ async function readGitignoreFile(gitignorePath) {
       throw new CodegraphLifecycleUserError(`Cannot update ${gitignorePath}: expected a regular file, but found a ${kind}. Replace it with a regular file or rerun with --no-update-gitignore.`);
     }
     try {
-      existing = await fsp27.readFile(gitignorePath, "utf8");
+      existing = await fsp28.readFile(gitignorePath, "utf8");
     } catch (error51) {
       const detail = errorMessage(error51);
       throw new CodegraphLifecycleUserError(`Unable to read ${gitignorePath}: ${detail}. Check file permissions or rerun with --no-update-gitignore.`);
@@ -56178,43 +56558,38 @@ async function prepareCodegraphLifecycleGitignore(root, options = {}) {
   const manifestTracked = await isGitPathTracked(resolvedRoot, LIFECYCLE_MANIFEST_PATH);
   if (manifestTracked)
     return { status: "tracked", path: GITIGNORE_PATH };
-  const [lifecycleIgnored, diskCacheIgnored] = await Promise.all([
-    isGitPathIgnored(resolvedRoot, LIFECYCLE_MANIFEST_PATH),
-    isGitPathIgnored(resolvedRoot, DISK_CACHE_PROBE_PATH)
-  ]);
-  const missingRules = [
-    ...!lifecycleIgnored ? [LIFECYCLE_GITIGNORE_RULE] : [],
-    ...!diskCacheIgnored ? [DISK_CACHE_GITIGNORE_RULE] : []
-  ];
-  if (!missingRules.length) {
+  const manifestIgnored = await isGitPathIgnored(resolvedRoot, LIFECYCLE_MANIFEST_PATH);
+  const cacheIgnored = await isGitPathIgnored(resolvedRoot, LIFECYCLE_CACHE_PATH);
+  if (manifestIgnored && cacheIgnored) {
     return { status: "already-ignored", path: GITIGNORE_PATH, rules: [...CODEGRAPH_GITIGNORE_RULES] };
   }
+  const missingRules = [LIFECYCLE_GITIGNORE_RULE];
   const gitignorePath = path50.join(resolvedRoot, GITIGNORE_PATH);
   const { existing, newline } = await readGitignoreFile(gitignorePath);
   let suffix = missingRules.map((rule) => `${rule}${newline}`).join("");
   if (existing && !existing.endsWith("\n"))
     suffix = `${newline}${suffix}`;
   try {
-    await fsp27.appendFile(gitignorePath, suffix, "utf8");
+    await fsp28.appendFile(gitignorePath, suffix, "utf8");
   } catch (error51) {
     const detail = errorMessage(error51);
     throw new CodegraphLifecycleUserError(`Unable to update ${gitignorePath}: ${detail}. Check file permissions or rerun with --no-update-gitignore.`);
   }
   return { status: "added", path: GITIGNORE_PATH, rules: missingRules };
 }
-var LIFECYCLE_MANIFEST_PATH, DISK_CACHE_PROBE_PATH, GITIGNORE_PATH, LIFECYCLE_GITIGNORE_RULE, DISK_CACHE_GITIGNORE_RULE, CODEGRAPH_GITIGNORE_RULES;
+var LIFECYCLE_MANIFEST_PATH, LIFECYCLE_CACHE_PATH, GITIGNORE_PATH, LIFECYCLE_GITIGNORE_RULE, CODEGRAPH_GITIGNORE_RULES;
 var init_gitignore = __esm({
   "dist/lifecycle/gitignore.js"() {
     "use strict";
+    init_location();
     init_git();
     init_errors();
     init_errors4();
     LIFECYCLE_MANIFEST_PATH = ".codegraph/manifest.json";
-    DISK_CACHE_PROBE_PATH = ".codegraph-cache/index-v1/manifest.json";
+    LIFECYCLE_CACHE_PATH = PROJECT_CACHE_RELATIVE_PATH.replaceAll(path50.sep, "/");
     GITIGNORE_PATH = ".gitignore";
     LIFECYCLE_GITIGNORE_RULE = ".codegraph/";
-    DISK_CACHE_GITIGNORE_RULE = ".codegraph-cache/";
-    CODEGRAPH_GITIGNORE_RULES = [LIFECYCLE_GITIGNORE_RULE, DISK_CACHE_GITIGNORE_RULE];
+    CODEGRAPH_GITIGNORE_RULES = [LIFECYCLE_GITIGNORE_RULE];
   }
 });
 
@@ -56230,7 +56605,7 @@ __export(manifest_exports, {
   uninitCodegraphLifecycle: () => uninitCodegraphLifecycle
 });
 import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
-import fsp28 from "node:fs/promises";
+import fsp29 from "node:fs/promises";
 import path51 from "node:path";
 function codegraphLifecycleManifestPath(root) {
   return path51.join(root, CODEGRAPH_DIR, MANIFEST_FILE);
@@ -56331,11 +56706,11 @@ async function uninitCodegraphLifecycle(root, options = {}) {
   if (!entries.length) {
     return { schemaVersion: MANIFEST_SCHEMA_VERSION, root, removed: false, manifestPath };
   }
-  const unknownEntries = entries.filter((entry) => !KNOWN_CODEGRAPH_FILES.has(entry));
+  const unknownEntries = entries.filter((entry) => !Object.hasOwn(KNOWN_CODEGRAPH_FILES, entry));
   if (unknownEntries.length && !options.force) {
     throw new CodegraphLifecycleUserError(`Refusing to remove .codegraph with unknown entries: ${unknownEntries.join(", ")}. Use --force to remove them.`);
   }
-  const removableEntries = entries.filter((entry) => entry !== SERVER_REGISTRY_FILE && entry !== SERVER_LOG_FILE);
+  const removableEntries = entries.filter((entry) => entry !== SERVER_REGISTRY_FILE && entry !== SERVER_LOG_FILE && entry !== CACHE_DIRECTORY);
   if (options.force) {
     for (const entry of removableEntries) {
       await removeCodegraphPath(path51.join(dir, entry), { recursive: true });
@@ -56375,7 +56750,7 @@ async function readLifecycleManifest(root, options = {}) {
   const manifestPath = codegraphLifecycleManifestPath(root);
   let raw;
   try {
-    raw = await fsp28.readFile(manifestPath, "utf8");
+    raw = await fsp29.readFile(manifestPath, "utf8");
   } catch (error51) {
     if (error51 instanceof Error && "code" in error51 && error51.code === "ENOENT")
       return null;
@@ -56399,14 +56774,14 @@ function lifecycleManifestTempFilePath(manifestPath) {
 }
 async function writeLifecycleManifest(root, manifest) {
   const manifestPath = codegraphLifecycleManifestPath(root);
-  await fsp28.mkdir(path51.dirname(manifestPath), { recursive: true });
+  await fsp29.mkdir(path51.dirname(manifestPath), { recursive: true });
   const tempPath = lifecycleManifestTempFilePath(manifestPath);
   try {
-    await fsp28.writeFile(tempPath, `${JSON.stringify(manifest, null, 2)}
+    await fsp29.writeFile(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-    await fsp28.rename(tempPath, manifestPath);
+    await fsp29.rename(tempPath, manifestPath);
   } catch (error51) {
-    await fsp28.rm(tempPath, { force: true }).catch(() => {
+    await fsp29.rm(tempPath, { force: true }).catch(() => {
     });
     throw new CodegraphLifecycleUserError(`Unable to write Codegraph lifecycle manifest at ${manifestPath}: ${stringifyError(error51)}`);
   }
@@ -56447,7 +56822,7 @@ async function hashDiscoveredFiles(files, root) {
   const signatures = /* @__PURE__ */ new Map();
   await mapLimit(sorted, FILE_SIGNATURE_STAT_CONCURRENCY2, async (file2) => {
     try {
-      const stat = await fsp28.stat(file2);
+      const stat = await fsp29.stat(file2);
       signatures.set(file2, { size: stat.size, mtimeMs: stat.mtimeMs });
     } catch (error51) {
       if (isMissingStatRace2(error51))
@@ -56506,18 +56881,18 @@ function sha256(value) {
 }
 async function removeCodegraphPath(target, options) {
   try {
-    await fsp28.rm(target, { ...options.recursive ? { recursive: true } : {}, force: true });
+    await fsp29.rm(target, { ...options.recursive ? { recursive: true } : {}, force: true });
   } catch (error51) {
     throw new CodegraphLifecycleUserError(`Unable to remove ${target}: ${stringifyError(error51)}`);
   }
 }
 async function readCodegraphDirEntries(dir) {
   try {
-    const stats = await fsp28.lstat(dir);
+    const stats = await fsp29.lstat(dir);
     if (stats.isSymbolicLink()) {
       throw new CodegraphLifecycleUserError(`Refusing to traverse symbolic link as .codegraph lifecycle directory: ${dir}`);
     }
-    return await fsp28.readdir(dir);
+    return await fsp29.readdir(dir);
   } catch (error51) {
     if (error51 instanceof CodegraphLifecycleUserError)
       throw error51;
@@ -56528,7 +56903,7 @@ async function readCodegraphDirEntries(dir) {
 }
 async function removeDirIfEmpty(dir) {
   try {
-    await fsp28.rmdir(dir);
+    await fsp29.rmdir(dir);
   } catch (error51) {
     if (error51 instanceof Error && "code" in error51 && error51.code === "ENOTEMPTY")
       return;
@@ -56550,7 +56925,7 @@ function isOptionalStringArray(value) {
     return true;
   return Array.isArray(value) && value.every((entry) => typeof entry === "string");
 }
-var MANIFEST_SCHEMA_VERSION, CODEGRAPH_DIR, MANIFEST_FILE, SERVER_REGISTRY_FILE, SERVER_LOG_FILE, KNOWN_CODEGRAPH_FILES, FILE_SIGNATURE_STAT_CONCURRENCY2;
+var MANIFEST_SCHEMA_VERSION, CODEGRAPH_DIR, MANIFEST_FILE, SERVER_REGISTRY_FILE, SERVER_LOG_FILE, CACHE_DIRECTORY, KNOWN_CODEGRAPH_FILES, FILE_SIGNATURE_STAT_CONCURRENCY2;
 var init_manifest2 = __esm({
   "dist/lifecycle/manifest.js"() {
     "use strict";
@@ -56567,7 +56942,13 @@ var init_manifest2 = __esm({
     MANIFEST_FILE = "manifest.json";
     SERVER_REGISTRY_FILE = "server.json";
     SERVER_LOG_FILE = "server.log";
-    KNOWN_CODEGRAPH_FILES = /* @__PURE__ */ new Set([MANIFEST_FILE, SERVER_REGISTRY_FILE, SERVER_LOG_FILE]);
+    CACHE_DIRECTORY = "cache";
+    KNOWN_CODEGRAPH_FILES = {
+      [MANIFEST_FILE]: true,
+      [SERVER_REGISTRY_FILE]: true,
+      [SERVER_LOG_FILE]: true,
+      [CACHE_DIRECTORY]: true
+    };
     FILE_SIGNATURE_STAT_CONCURRENCY2 = 64;
   }
 });
@@ -56620,7 +57001,7 @@ function formatSyncResult(label, result) {
   const summary = `${label} Codegraph at ${result.root}: ${result.manifest.fileCount} files${changeLabel}. Manifest: ${result.manifestPath}`;
   if (result.gitignore?.status === "added") {
     const gitignorePath = path52.join(result.root, result.gitignore.path);
-    const rules = result.gitignore.rules?.length ? result.gitignore.rules.join(", ") : ".codegraph/, .codegraph-cache/";
+    const rules = result.gitignore.rules?.length ? result.gitignore.rules.join(", ") : ".codegraph/";
     return `${summary}
 Updated Git ignore policy at ${gitignorePath}: added ${rules}.`;
   }
@@ -57413,14 +57794,14 @@ __export(skill_exports, {
   getSkillTargetDirForAgent: () => getSkillTargetDirForAgent,
   handleSkillCommand: () => handleSkillCommand
 });
-import fsp29 from "node:fs/promises";
-import os5 from "node:os";
+import fsp30 from "node:fs/promises";
+import os6 from "node:os";
 import path53 from "node:path";
 function getBundledSkillDir(packageRoot) {
   const candidate = path53.join(packageRoot, "codegraph-skill", "codegraph");
   return pathExists(path53.join(candidate, "SKILL.md")) ? candidate : null;
 }
-function getSkillTargetDirForAgent(agent, homeDir = os5.homedir(), env = process.env) {
+function getSkillTargetDirForAgent(agent, homeDir = os6.homedir(), env = process.env) {
   if (agent === "agents") {
     return path53.join(homeDir, ".agents", "skills", "codegraph");
   }
@@ -57481,10 +57862,10 @@ function isCommandAvailableOnPath(command) {
 }
 async function copyDirectoryRecursive(sourceDir, targetDir, overwrite) {
   if (overwrite && pathExists(targetDir)) {
-    await fsp29.rm(targetDir, { recursive: true, force: true });
+    await fsp30.rm(targetDir, { recursive: true, force: true });
   }
-  await fsp29.mkdir(targetDir, { recursive: true });
-  const entries = await fsp29.readdir(sourceDir, { withFileTypes: true });
+  await fsp30.mkdir(targetDir, { recursive: true });
+  const entries = await fsp30.readdir(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
     const sourcePath = path53.join(sourceDir, entry.name);
     const targetPath = path53.join(targetDir, entry.name);
@@ -57495,7 +57876,7 @@ async function copyDirectoryRecursive(sourceDir, targetDir, overwrite) {
     if (!overwrite && pathExists(targetPath)) {
       throw new Error(`Target file already exists: ${normalizePathForDisplay(targetPath)}. Re-run with --force to overwrite.`);
     }
-    await fsp29.copyFile(sourcePath, targetPath);
+    await fsp30.copyFile(sourcePath, targetPath);
   }
 }
 function normalizePathSegmentForComparison(segment) {
@@ -57638,8 +58019,8 @@ var init_skill = __esm({
 
 // dist/installer/locks.js
 import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
-import fsp30, {} from "node:fs/promises";
-import os6 from "node:os";
+import fsp31, {} from "node:fs/promises";
+import os7 from "node:os";
 import path54 from "node:path";
 function opencodeConfigHome(settings) {
   const configHome = settings.env.XDG_CONFIG_HOME?.trim();
@@ -57675,7 +58056,7 @@ function installerTransactionLockScopes(settings) {
 }
 function installerTransactionLockPath(scope) {
   const digest = createHash5("sha256").update(scope).digest("hex");
-  return path54.join(os6.tmpdir(), `codegraph-installer-${digest}.lock`);
+  return path54.join(os7.tmpdir(), `codegraph-installer-${digest}.lock`);
 }
 async function withInstallerLeaseLock(lockPath, resourceName, operation) {
   const lock = await acquireInstallerLeaseLock(lockPath, resourceName);
@@ -57693,14 +58074,14 @@ async function acquireInstallerLeaseLock(lockPath, resourceName) {
     let file2;
     try {
       const owner = randomUUID3();
-      file2 = await fsp30.open(acquisitionPath, "wx", 384);
+      file2 = await fsp31.open(acquisitionPath, "wx", 384);
       await writeInstallerLeaseMetadata(file2, owner);
       await file2.close();
       file2 = void 0;
-      await fsp30.link(acquisitionPath, lockPath);
+      await fsp31.link(acquisitionPath, lockPath);
       published = true;
-      await fsp30.rm(acquisitionPath, { force: true });
-      file2 = await fsp30.open(lockPath, "r+");
+      await fsp31.rm(acquisitionPath, { force: true });
+      file2 = await fsp31.open(lockPath, "r+");
       const lockFile = file2;
       const renewalTimer = setInterval(() => {
         void writeInstallerLeaseMetadata(lockFile, owner).catch(() => void 0);
@@ -57709,9 +58090,9 @@ async function acquireInstallerLeaseLock(lockPath, resourceName) {
       return { file: lockFile, lockPath, metadataPath: lockPath, owner, renewalTimer };
     } catch (error51) {
       await file2?.close().catch(() => void 0);
-      await fsp30.rm(acquisitionPath, { force: true }).catch(() => void 0);
+      await fsp31.rm(acquisitionPath, { force: true }).catch(() => void 0);
       if (published)
-        await fsp30.rm(lockPath, { force: true }).catch(() => void 0);
+        await fsp31.rm(lockPath, { force: true }).catch(() => void 0);
       if (!isInstallerLockPublishConflict(error51, lockPath))
         throw error51;
       const conflict = await resolveInstallerLeaseConflict(lockPath);
@@ -57729,10 +58110,10 @@ async function acquireInstallerLeaseLock(lockPath, resourceName) {
 async function resolveInstallerLeaseConflict(lockPath) {
   let observed;
   try {
-    const stats = await fsp30.lstat(lockPath);
+    const stats = await fsp31.lstat(lockPath);
     if (!stats.isFile())
       return "blocked";
-    observed = { content: await fsp30.readFile(lockPath, "utf8"), mtimeMs: stats.mtimeMs };
+    observed = { content: await fsp31.readFile(lockPath, "utf8"), mtimeMs: stats.mtimeMs };
   } catch (error51) {
     if (isFileSystemErrorCode(error51, "ENOENT"))
       return "absent";
@@ -57754,7 +58135,7 @@ async function resolveInstallerLeaseConflict(lockPath) {
 async function reclaimAbandonedInstallerLease(lockPath, observed) {
   const reclaimPath = `${lockPath}.reclaim-${process.pid}-${randomUUID3()}`;
   try {
-    await fsp30.rename(lockPath, reclaimPath);
+    await fsp31.rename(lockPath, reclaimPath);
   } catch (error51) {
     if (isFileSystemErrorCode(error51, "ENOENT"))
       return "absent";
@@ -57762,20 +58143,20 @@ async function reclaimAbandonedInstallerLease(lockPath, observed) {
   }
   let verified = false;
   try {
-    const stats = await fsp30.lstat(reclaimPath);
-    verified = stats.isFile() && stats.mtimeMs === observed.mtimeMs && await fsp30.readFile(reclaimPath, "utf8") === observed.content;
+    const stats = await fsp31.lstat(reclaimPath);
+    verified = stats.isFile() && stats.mtimeMs === observed.mtimeMs && await fsp31.readFile(reclaimPath, "utf8") === observed.content;
   } catch {
     verified = false;
   }
   if (verified) {
-    await fsp30.rm(reclaimPath, { force: true });
+    await fsp31.rm(reclaimPath, { force: true });
     return "reclaimed";
   }
   try {
-    await fsp30.link(reclaimPath, lockPath);
+    await fsp31.link(reclaimPath, lockPath);
   } catch {
   }
-  await fsp30.rm(reclaimPath, { force: true });
+  await fsp31.rm(reclaimPath, { force: true });
   return "blocked";
 }
 function isInstallerLockPublishConflict(error51, lockPath) {
@@ -57812,9 +58193,9 @@ async function releaseInstallerLeaseLock(lock) {
   clearInterval(lock.renewalTimer);
   await lock.file.close().catch(() => void 0);
   try {
-    const metadata = parseInstallerLeaseMetadata(await fsp30.readFile(lock.metadataPath, "utf8"));
+    const metadata = parseInstallerLeaseMetadata(await fsp31.readFile(lock.metadataPath, "utf8"));
     if (metadata?.owner === lock.owner)
-      await fsp30.rm(lock.lockPath, { force: true });
+      await fsp31.rm(lock.lockPath, { force: true });
   } catch (error51) {
     if (!isFileSystemErrorCode(error51, "ENOENT"))
       throw error51;
@@ -57840,8 +58221,8 @@ var init_locks = __esm({
 
 // dist/installer/registry.js
 import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
-import fsp31 from "node:fs/promises";
-import os7 from "node:os";
+import fsp32 from "node:fs/promises";
+import os8 from "node:os";
 import path55 from "node:path";
 import { applyEdits, modify, parse as parseJsonc2 } from "jsonc-parser";
 function listInstallTargets() {
@@ -57968,7 +58349,7 @@ async function installDefinitions(definitions, options) {
   return await withInstallerTransactionLocks(settings, install);
 }
 async function prepareInstallPlan(definitions, settings, dryRun, force) {
-  const bundledSkill = await fsp31.readFile(bundledSkillFilePath());
+  const bundledSkill = await fsp32.readFile(bundledSkillFilePath());
   const files = [];
   const conflicts = [];
   for (const definition of definitions) {
@@ -58096,7 +58477,7 @@ async function rollbackInstallPlan(plan) {
 }
 async function removePlannedInstallFile(filePath, root) {
   await assertNoSymbolicLinksWithinRoot(filePath, root);
-  await fsp31.rm(filePath, { force: true });
+  await fsp32.rm(filePath, { force: true });
 }
 async function verifyInstallPlan(plan, verifyInstalledConfig) {
   for (const file2 of plan.files) {
@@ -58590,7 +58971,7 @@ function installerSettings(options) {
   if (env === void 0)
     env = options.homeDir === void 0 ? process.env : {};
   return {
-    homeDir: options.homeDir ?? os7.homedir(),
+    homeDir: options.homeDir ?? os8.homedir(),
     env
   };
 }
@@ -58607,14 +58988,14 @@ function bundledSkillFilePath() {
 async function snapshotInstallFile(filePath, root) {
   await assertNoSymbolicLinksWithinRoot(filePath, root);
   try {
-    const stats = await fsp31.lstat(filePath);
+    const stats = await fsp32.lstat(filePath);
     if (stats.isSymbolicLink())
       throw unsafeSymbolicLinkError(filePath);
     if (!stats.isFile()) {
       throw new Error(`Expected a regular file at ${normalizePathForDisplay(filePath)} before running the installer.`);
     }
     return {
-      bytes: await fsp31.readFile(filePath),
+      bytes: await fsp32.readFile(filePath),
       mode: stats.mode & 4095
     };
   } catch (error51) {
@@ -58634,7 +59015,7 @@ async function assertNoSymbolicLinksWithinRoot(filePath, root) {
   }
   for (let current = resolvedFilePath; current !== resolvedRoot; current = path55.dirname(current)) {
     try {
-      const stats = await fsp31.lstat(current);
+      const stats = await fsp32.lstat(current);
       if (stats.isSymbolicLink())
         throw unsafeSymbolicLinkError(current);
     } catch (error51) {
@@ -58649,7 +59030,7 @@ async function confirmMissingPathHasDirectoryAncestors(filePath) {
   let current = path55.dirname(filePath);
   while (true) {
     try {
-      const stats = await fsp31.lstat(current);
+      const stats = await fsp32.lstat(current);
       if (stats.isSymbolicLink())
         throw unsafeSymbolicLinkError(current);
       if (!stats.isDirectory()) {
@@ -58688,7 +59069,7 @@ async function writeTextFileAtomic(filePath, content, options = {}) {
     await assertNoSymbolicLinkAtPath(filePath);
   else
     await assertNoSymbolicLinksWithinRoot(filePath, options.root);
-  await fsp31.mkdir(path55.dirname(filePath), { recursive: true });
+  await fsp32.mkdir(path55.dirname(filePath), { recursive: true });
   await withInstallerLeaseLock(`${filePath}.codegraph-lock`, normalizePathForDisplay(filePath), async () => {
     if (options.root === void 0)
       await assertNoSymbolicLinkAtPath(filePath);
@@ -58700,7 +59081,7 @@ async function writeTextFileAtomic(filePath, content, options = {}) {
       let mode = options.mode ?? 384;
       if (options.mode === void 0) {
         try {
-          const existing = await fsp31.lstat(filePath);
+          const existing = await fsp32.lstat(filePath);
           if (existing.isSymbolicLink())
             throw unsafeSymbolicLinkError(filePath);
           mode = existing.mode & 4095;
@@ -58709,8 +59090,8 @@ async function writeTextFileAtomic(filePath, content, options = {}) {
             throw error51;
         }
       }
-      await fsp31.writeFile(temporaryPath, content, { encoding: "utf8", flag: "wx", mode });
-      await fsp31.chmod(temporaryPath, mode);
+      await fsp32.writeFile(temporaryPath, content, { encoding: "utf8", flag: "wx", mode });
+      await fsp32.chmod(temporaryPath, mode);
       await renameTemporaryFile(temporaryPath, filePath);
     } catch (error51) {
       if (isFileSystemErrorCode(error51, "EACCES") || isFileSystemErrorCode(error51, "EPERM")) {
@@ -58718,13 +59099,13 @@ async function writeTextFileAtomic(filePath, content, options = {}) {
       }
       throw error51;
     } finally {
-      await fsp31.rm(temporaryPath, { force: true }).catch(() => void 0);
+      await fsp32.rm(temporaryPath, { force: true }).catch(() => void 0);
     }
   });
 }
 async function assertNoSymbolicLinkAtPath(filePath) {
   try {
-    const stats = await fsp31.lstat(filePath);
+    const stats = await fsp32.lstat(filePath);
     if (stats.isSymbolicLink())
       throw unsafeSymbolicLinkError(filePath);
   } catch (error51) {
@@ -58739,7 +59120,7 @@ function unsafeSymbolicLinkError(filePath) {
 async function renameTemporaryFile(temporaryPath, filePath) {
   for (let attempt = 0; attempt < 5; attempt += 1) {
     try {
-      await fsp31.rename(temporaryPath, filePath);
+      await fsp32.rename(temporaryPath, filePath);
       return;
     } catch (error51) {
       if (!isFileSystemErrorCode(error51, "EPERM") || attempt === 4)
@@ -58927,7 +59308,7 @@ __export(doctor_exports, {
   formatDoctorSummary: () => formatDoctorSummary
 });
 import fs25 from "node:fs";
-import os8 from "node:os";
+import os9 from "node:os";
 import path57 from "node:path";
 function statIfExists(filePath) {
   try {
@@ -58960,15 +59341,15 @@ function detectIndexedArtifactType(filePath, stats) {
     return "artifactBundle";
   }
   const normalized = normalizePathForDisplay(filePath).toLowerCase();
+  if (normalized.endsWith("/.codegraph/cache") || normalized.includes("/.codegraph/cache/") || normalized.endsWith("/.codegraph-cache") || normalized.includes("/.codegraph-cache/")) {
+    return "diskCache";
+  }
   if (normalized.endsWith("/codegraph.json") || normalized.endsWith(".json")) {
     return "jsonGraph";
   }
   if (normalized.endsWith("/graph.sqlite") || normalized.endsWith(".sqlite")) {
     return "sqliteGraph";
   }
-  if (normalized.endsWith("/.codegraph-cache") || normalized.includes("/.codegraph-cache/")) {
-    return "diskCache";
-  }
   return "unknown";
 }
 function buildIndexedArtifactReport(indexPath) {
@@ -59155,7 +59536,7 @@ function readCacheLocationField(configPath) {
   }
 }
 function readUserCacheLocation() {
-  const configRoot = process.platform === "win32" ? process.env.APPDATA?.trim() || path57.join(os8.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME?.trim() || path57.join(os8.homedir(), ".config");
+  const configRoot = process.platform === "win32" ? process.env.APPDATA?.trim() || path57.join(os9.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME?.trim() || path57.join(os9.homedir(), ".config");
   return readCacheLocationField(path57.join(configRoot, "codegraph", "config.json"));
 }
 function readEffectiveCacheLocation(root) {
@@ -60485,7 +60866,7 @@ async function handleSqlCommand(context) {
   const dbOpt = context.getOpt("--db") ?? context.getOpt("--sqlite") ?? context.positionals[0];
   const queryText = context.getOpt("--query") ?? context.positionals[1];
   if (!dbOpt || !queryText) {
-    context.writeStderrLine('Usage: sql <sqlite-path> "SELECT ..." OR sql --db <sqlite-path> --query "SELECT ..."');
+    context.writeStderrLine(getCliCommandUsage("sql"));
     context.exit(2);
   }
   const dbPath = path60.isAbsolute(dbOpt) ? normalizePath(dbOpt) : normalizePath(resolveFilePathFromRoot(context.cwd(), dbOpt));
@@ -60498,6 +60879,7 @@ var init_sql2 = __esm({
     init_sqlite();
     init_paths();
     init_pretty();
+    init_options();
   }
 });
 
@@ -60668,7 +61050,7 @@ var chunk_exports = {};
 __export(chunk_exports, {
   handleChunkCommand: () => handleChunkCommand
 });
-import fsp32 from "node:fs/promises";
+import fsp33 from "node:fs/promises";
 import path61 from "node:path";
 function normalizeChunkLanguageId(languageId) {
   return chunkLanguageAliases2[languageId] ?? languageId;
@@ -60691,7 +61073,7 @@ function formatChunkSummary(chunks) {
 async function handleChunkCommand(context) {
   const inputFilePath = context.positionals[0];
   if (!inputFilePath) {
-    context.writeStderrLine("Usage: chunk <file-path> [options]");
+    context.writeStderrLine(getCliCommandUsage("chunk"));
     context.writeStderrLine("Options:");
     context.writeStderrLine("  --min-tokens N    Minimum tokens per chunk (default: 150)");
     context.writeStderrLine("  --max-tokens N    Maximum tokens per chunk (default: 400)");
@@ -60699,16 +61081,25 @@ async function handleChunkCommand(context) {
     context.writeStderrLine("  --text            Force text chunking mode");
     context.exit(2);
   }
+  const languageOverride = context.getOpt("--language");
+  if (languageOverride) {
+    const languageId = normalizeChunkLanguageId(languageOverride);
+    const isSupported = supportedChunkLanguageIds.has(languageId);
+    if (!isSupported) {
+      context.writeStderrLine(`Unsupported --language value "${languageId}". Supported languages: ${chunkLanguageHelp}.`);
+      context.exit(2);
+    }
+  }
   try {
     const filePath = path61.resolve(context.cwd(), parseSourceLocationInput(inputFilePath).file);
-    const source = await fsp32.readFile(filePath, "utf8");
+    const source = await fsp33.readFile(filePath, "utf8");
     const ext = path61.extname(filePath).toLowerCase();
-    let languageId = context.getOpt("--language");
-    if (!languageId) {
+    let languageId;
+    if (!languageOverride) {
       const support = supportForFile(filePath);
       languageId = support ? normalizeChunkLanguageId(support.id) : chunkTextLanguageByExtension[ext] || "text";
     } else {
-      languageId = normalizeChunkLanguageId(languageId);
+      languageId = normalizeChunkLanguageId(languageOverride);
     }
     const forceText = context.hasFlag("--text");
     const minTokensRaw = context.getOpt("--min-tokens");
@@ -60755,7 +61146,7 @@ async function handleChunkCommand(context) {
     exitWithError(context, error51, 1, "Chunking failed");
   }
 }
-var chunkLanguageAliases2, chunkTextLanguageByExtension, chunkLanguageHelp;
+var chunkLanguageAliases2, chunkTextLanguageByExtension, supportedChunkLanguageIds, chunkLanguageHelp;
 var init_chunk = __esm({
   "dist/cli/chunk.js"() {
     "use strict";
@@ -60777,7 +61168,8 @@ var init_chunk = __esm({
       ".yaml": "yaml",
       ".yml": "yaml"
     };
-    chunkLanguageHelp = Array.from(/* @__PURE__ */ new Set([...Object.keys(LANG_CONFIGS).sort(), "vue", "svelte", "json", "yaml", "text"])).join(", ");
+    supportedChunkLanguageIds = /* @__PURE__ */ new Set([...Object.keys(LANG_CONFIGS), "vue", "svelte", "json", "yaml", "text"]);
+    chunkLanguageHelp = [...supportedChunkLanguageIds].sort().join(", ");
   }
 });
 
@@ -61791,7 +62183,7 @@ var init_fileView = __esm({
 });
 
 // dist/documentLinks/check.js
-import fsp33 from "node:fs/promises";
+import fsp34 from "node:fs/promises";
 import path64 from "node:path";
 async function checkMarkdownLinks(projectRoot, discovery) {
   const root = path64.resolve(projectRoot);
@@ -61799,14 +62191,14 @@ async function checkMarkdownLinks(projectRoot, discovery) {
 }
 async function checkMarkdownLinksInFiles(projectRoot, files) {
   const root = path64.resolve(projectRoot);
-  const realRoot = await fsp33.realpath(root);
+  const realRoot = await fsp34.realpath(root);
   const markdownFileCandidates = await Promise.all(Array.from(files, async (file2) => {
     const absoluteFile = path64.resolve(root, file2);
     const relativeFile = toProjectRelativePath(root, absoluteFile);
     if (relativeFile !== null)
       return path64.resolve(realRoot, relativeFile);
     try {
-      return await fsp33.realpath(absoluteFile);
+      return await fsp34.realpath(absoluteFile);
     } catch {
       return absoluteFile;
     }
@@ -61875,7 +62267,7 @@ async function recoverDisplayFileCasing(file2) {
   const dir = path64.dirname(file2);
   const base = path64.basename(file2);
   try {
-    const entries = await fsp33.readdir(dir);
+    const entries = await fsp34.readdir(dir);
     const match = entries.find((entry) => entry.toLowerCase() === base.toLowerCase());
     return match ? path64.join(dir, match) : file2;
   } catch {
@@ -61949,8 +62341,8 @@ async function cachedTargetStatus(target, targetStatusByPath) {
 }
 async function readTargetStatus(target) {
   try {
-    const realPath = await fsp33.realpath(target);
-    const stats = await fsp33.stat(realPath);
+    const realPath = await fsp34.realpath(target);
+    const stats = await fsp34.stat(realPath);
     return { status: "found", isDirectory: stats.isDirectory(), realPath };
   } catch (error51) {
     if (isMissingPathError3(error51))
@@ -61971,7 +62363,7 @@ async function cachedMarkdownAnchors(target, anchorsByPath) {
 }
 async function readMarkdownFile(file2) {
   try {
-    return await fsp33.readFile(file2, "utf8");
+    return await fsp34.readFile(file2, "utf8");
   } catch (error51) {
     if (error51 instanceof Error) {
       throw new Error(`Failed to read Markdown file ${normalizePath(file2)}: ${error51.message}`);
@@ -63352,7 +63744,7 @@ var init_navigation_references = __esm({
 });
 
 // dist/sql/navigation.js
-import fsp34 from "node:fs/promises";
+import fsp35 from "node:fs/promises";
 import path65 from "node:path";
 function isSqlFile2(filePath) {
   return path65.extname(filePath).toLowerCase() === ".sql";
@@ -63638,7 +64030,7 @@ async function sourceForFile(filePath, index) {
   if (cached2 !== void 0)
     return cached2;
   const parsed = index.parsed?.get(key);
-  const source = parsed ? parsed.source : await fsp34.readFile(filePath, "utf8");
+  const source = parsed ? parsed.source : await fsp35.readFile(filePath, "utf8");
   cache.sourceByFile.set(key, source);
   return source;
 }
@@ -65342,7 +65734,7 @@ var init_changes = __esm({
 });
 
 // dist/sql/review.js
-import fsp35 from "node:fs/promises";
+import fsp36 from "node:fs/promises";
 import path67 from "node:path";
 function isSqlFile3(filePath) {
   return path67.extname(filePath).toLowerCase() === ".sql";
@@ -65357,7 +65749,7 @@ function sortEntries(left, right) {
 }
 async function readExistingFile(filePath) {
   try {
-    return await fsp35.readFile(filePath, "utf8");
+    return await fsp36.readFile(filePath, "utf8");
   } catch {
     return null;
   }
@@ -68720,7 +69112,7 @@ var init_referenceCache = __esm({
 });
 
 // dist/review/summaries.js
-import fsp36 from "node:fs/promises";
+import fsp37 from "node:fs/promises";
 import path70 from "node:path";
 import { performance as performance9 } from "node:perf_hooks";
 function relativePath2(root, file2) {
@@ -68982,7 +69374,7 @@ function sameRange(left, right) {
 }
 async function summarizeChangedFiles2(input) {
   const { projectRoot, index, changedFileList, diffHunksByFile, diffKindsByFile, diffChangesByFile, explicitFiles, existenceByFile, deletedSnapshots, loadSource: suppliedLoadSource, includeSymbolDetails, includeDiffContext, diffContextLines, maxCallsites, referenceConcurrency, diagnostics, reviewTimings } = input;
-  const readSource = suppliedLoadSource ?? (async (file2) => await fsp36.readFile(file2, "utf8"));
+  const readSource = suppliedLoadSource ?? (async (file2) => await fsp37.readFile(file2, "utf8"));
   const sourceCache = /* @__PURE__ */ new Map();
   const loadSource = (file2) => {
     const key = fileIdentityKey(file2);
@@ -74587,11 +74979,12 @@ function suggestCliCommands(input, limit = 3) {
 function routeForCliIntent(input) {
   return INTENT_ROUTES.find((route) => route.pattern.test(input))?.command;
 }
-function renderCliCommandList() {
-  const width = Math.max(...CLI_COMMAND_CATALOG.map((command) => command.name.length));
-  return CLI_COMMAND_CATALOG.map((command) => `  ${command.name.padEnd(width)}  ${command.summary}`).join("\n");
+function renderCliCommandList(advanced = false) {
+  const commands = advanced ? CLI_COMMAND_CATALOG : CLI_COMMAND_CATALOG.filter((command) => CORE_COMMAND_NAMES[command.name]);
+  const width = Math.max(...commands.map((command) => command.name.length));
+  return commands.map((command) => `  ${command.name.padEnd(width)}  ${command.summary}`).join("\n");
 }
-var CLI_COMMAND_CATALOG, commandByName, aliasToCommand, INTENT_ROUTES;
+var CLI_COMMAND_CATALOG, commandByName, aliasToCommand, INTENT_ROUTES, CORE_COMMAND_NAMES;
 var init_commandCatalog = __esm({
   "dist/cli/commandCatalog.js"() {
     "use strict";
@@ -74663,6 +75056,15 @@ var init_commandCatalog = __esm({
       { pattern: /^(configure|setup|agent)$/i, command: "codegraph install" },
       { pattern: /^(health|diagnose|check)$/i, command: "codegraph doctor" }
     ];
+    CORE_COMMAND_NAMES = {
+      doctor: true,
+      orient: true,
+      explore: true,
+      search: true,
+      file: true,
+      deps: true,
+      review: true
+    };
   }
 });
 
@@ -74765,7 +75167,7 @@ function helpTextForCommand(command, positionals) {
   }
   return void 0;
 }
-var CLI_TASK_HELP_TEXT, CLI_HELP_TEXT, LIFECYCLE_HELP_TEXT, AFFECTED_HELP_TEXT, INSTALL_HELP_TEXT, UNINSTALL_HELP_TEXT, SHARED_INDEX_OPTIONS_HELP, EXPLORE_HELP_TEXT, FILE_HELP_TEXT, SEARCH_HELP_TEXT, GOTO_HELP_TEXT, REFS_HELP_TEXT, GREP_HELP_TEXT, SQL_HELP_TEXT, SYMBOLS_HELP_TEXT, CALLERS_HELP_TEXT, CALLEES_HELP_TEXT, SUPERTYPES_HELP_TEXT, SUBTYPES_HELP_TEXT, IMPLEMENTATIONS_HELP_TEXT, RENAME_PREVIEW_HELP_TEXT, REFACTOR_PLAN_HELP_TEXT, ORIENT_HELP_TEXT, PACKET_HELP_TEXT, EXPLAIN_HELP_TEXT, ARTIFACT_HELP_TEXT, SERVER_HELP_TEXT, MCP_HELP_TEXT, MCP_SERVE_HELP_TEXT, DUPLICATES_HELP_TEXT, DRIFT_HELP_TEXT, VIEWER_HELP_TEXT, INDEX_HELP_TEXT, GRAPH_HELP_TEXT, REVIEW_HELP_TEXT, IMPACT_HELP_TEXT, INSPECT_HELP_TEXT, DEPS_HELP_TEXT, RDEPS_HELP_TEXT, PATH_HELP_TEXT, CYCLES_HELP_TEXT, HOTSPOTS_HELP_TEXT, UNRESOLVED_HELP_TEXT, LINKS_HELP_TEXT, APISURFACE_HELP_TEXT, GRAPH_DELTA_HELP_TEXT, DOCTOR_HELP_TEXT, CHUNK_HELP_TEXT, SKILL_HELP_TEXT, DUMPMOD_HELP_TEXT, VERSION_HELP_TEXT;
+var CLI_TASK_HELP_TEXT, CLI_HELP_TEXT, ADVANCED_HELP_TEXT, LIFECYCLE_HELP_TEXT, AFFECTED_HELP_TEXT, INSTALL_HELP_TEXT, UNINSTALL_HELP_TEXT, SHARED_INDEX_OPTIONS_HELP, EXPLORE_HELP_TEXT, FILE_HELP_TEXT, SEARCH_HELP_TEXT, GOTO_HELP_TEXT, REFS_HELP_TEXT, GREP_HELP_TEXT, SQL_HELP_TEXT, SYMBOLS_HELP_TEXT, CALLERS_HELP_TEXT, CALLEES_HELP_TEXT, SUPERTYPES_HELP_TEXT, SUBTYPES_HELP_TEXT, IMPLEMENTATIONS_HELP_TEXT, RENAME_PREVIEW_HELP_TEXT, REFACTOR_PLAN_HELP_TEXT, ORIENT_HELP_TEXT, PACKET_HELP_TEXT, EXPLAIN_HELP_TEXT, ARTIFACT_HELP_TEXT, SERVER_HELP_TEXT, MCP_HELP_TEXT, MCP_SERVE_HELP_TEXT, DUPLICATES_HELP_TEXT, DRIFT_HELP_TEXT, VIEWER_HELP_TEXT, INDEX_HELP_TEXT, GRAPH_HELP_TEXT, REVIEW_HELP_TEXT, IMPACT_HELP_TEXT, INSPECT_HELP_TEXT, DEPS_HELP_TEXT, RDEPS_HELP_TEXT, PATH_HELP_TEXT, CYCLES_HELP_TEXT, HOTSPOTS_HELP_TEXT, UNRESOLVED_HELP_TEXT, LINKS_HELP_TEXT, APISURFACE_HELP_TEXT, GRAPH_DELTA_HELP_TEXT, DOCTOR_HELP_TEXT, CHUNK_HELP_TEXT, SKILL_HELP_TEXT, DUMPMOD_HELP_TEXT, VERSION_HELP_TEXT;
 var init_help = __esm({
   "dist/cli/help.js"() {
     "use strict";
@@ -74792,9 +75194,11 @@ Start here:
 
 Usage: codegraph <command> [options] [path]
 
-Commands:
+Core commands:
 ${renderCliCommandList()}
 
+For the complete catalog, run: codegraph help advanced
+
 Graph Options:
   --fast-graph                Use text import extraction for plain .js and .ts
                               files. May miss multiline or complex patterns;
@@ -74893,6 +75297,11 @@ Examples:
   codegraph refactor-plan Service --rename RenamedService
   codegraph version
   codegraph -v
+`;
+    ADVANCED_HELP_TEXT = `codegraph - Complete command catalog
+
+Commands:
+${renderCliCommandList(true)}
 `;
     LIFECYCLE_HELP_TEXT = `codegraph init/status/sync/uninit - Initialize, inspect, refresh, or remove project-local Codegraph state
 
@@ -74907,9 +75316,9 @@ Usage:
   codegraph uninit --root <path> [--force] [--json | --pretty]
 
 State:
-  Lifecycle commands own only .codegraph/manifest.json metadata; a shared MCP server separately owns .codegraph/server.json and .codegraph/server.log. In a Git worktree, init and sync --init ensure the manifest is effectively ignored, appending .codegraph/ and .codegraph-cache/ to the resolved root's .gitignore only when needed; opt out with --no-update-gitignore.
-  A tracked manifest is left tracked with a warning. Uninit preserves server.json and server.log even with --force, so stop a shared server explicitly; it leaves the root .gitignore rule, and ordinary sync never changes ignore policy.
-  Init and sync may warm or update the disk cache under .codegraph-cache/index-v1/. Other commands do not depend on the manifest.
+  Lifecycle commands own .codegraph/manifest.json metadata; a shared MCP server owns .codegraph/server.json and .codegraph/server.log. In a Git worktree, init and sync --init ensure the .codegraph/ directory is effectively ignored, appending .codegraph/ to the resolved root's .gitignore only when needed; opt out with --no-update-gitignore.
+  A tracked manifest is left tracked with a warning. Uninit preserves server.json, server.log, and cache even with --force, so stop a shared server explicitly; it leaves the root .gitignore rule, and ordinary sync never changes ignore policy.
+  Init and sync may warm or update the disk cache under .codegraph/cache/index-v1/. Existing .codegraph-cache/ directories migrate automatically on the next run. Other commands do not depend on the manifest.
   Positional paths and --root are alternatives for lifecycle commands; do not combine them.
 `;
     AFFECTED_HELP_TEXT = `codegraph affected - List tests likely affected by changed files
@@ -74989,20 +75398,20 @@ ${SHARED_INDEX_OPTIONS_HELP}
 `;
     GOTO_HELP_TEXT = `codegraph goto - Go to a definition
 
-Usage: codegraph goto <file>::<symbol> [--root <path>] [--json | --pretty]
+Usage: codegraph goto <file|file::symbol|symbol:...> [--root <path>] [--json | --pretty]
        codegraph goto <file>[:line[:column]] [line] [column] [--root <path>] [--json | --pretty]
 
-A qualified symbol path resolves one definition without a location. A file-only target succeeds when the file defines one symbol; otherwise JSON returns bounded candidates. Search-result locations and portable symbol handles can be pasted directly.
+A qualified symbol path or portable symbol handle resolves one definition without a location. A file-only target succeeds when the file defines one symbol; otherwise JSON returns bounded candidates. Search-result locations and portable symbol handles can be pasted directly.
 
 ${SHARED_INDEX_OPTIONS_HELP}
 `;
     REFS_HELP_TEXT = `codegraph refs - Find semantic references
 
-Usage: codegraph refs <file>::<symbol> [--root <path>] [--json | --pretty]
+Usage: codegraph refs <file|file::symbol|symbol:...> [--root <path>] [--json | --pretty]
        codegraph refs <file>[:line[:column]] [line] [column] [--root <path>] [--json | --pretty]
        codegraph refs --file <file> [--line <line> --col <column>] [--root <path>] [--json | --pretty]
 
-A qualified symbol path finds references for one declaration without a location. A file-only target finds references for every symbol defined in that file. Search-result locations and portable symbol handles can be pasted directly.
+A qualified symbol path or portable symbol handle resolves one definition and reports references to it without a location. A file-only target finds references for every definition in the file.
 
 ${SHARED_INDEX_OPTIONS_HELP}
 `;
@@ -75358,7 +75767,9 @@ ${SHARED_INDEX_OPTIONS_HELP}
 `;
     DEPS_HELP_TEXT = `codegraph deps - List file dependencies
 
-Usage: codegraph deps <file|file::symbol|symbol:...> [--root <path>] [--depth <n>] [--json | --pretty]
+Usage: codegraph deps <file|file::symbol|symbol:...> [--root <path>] [--depth <n> | --all] [--json | --pretty]
+
+By default, outputs dependencies through depth 1. Use --depth for another finite output depth, or --all to include every depth.
 
 A qualified symbol path or portable symbol handle uses its declaring file for file-graph traversal. Use callees for symbol-level call relationships.
 
@@ -75366,7 +75777,9 @@ ${SHARED_INDEX_OPTIONS_HELP}
 `;
     RDEPS_HELP_TEXT = `codegraph rdeps - List reverse file dependencies
 
-Usage: codegraph rdeps <file|file::symbol|symbol:...> [--root <path>] [--depth <n>] [--json | --pretty]
+Usage: codegraph rdeps <file|file::symbol|symbol:...> [--root <path>] [--depth <n> | --all] [--json | --pretty]
+
+By default, outputs reverse dependencies through depth 1. Use --depth for another finite output depth, or --all to include every depth.
 
 A qualified symbol path or portable symbol handle uses its declaring file for file-graph traversal. Use callers for symbol-level call relationships.
 
@@ -81458,8 +81871,17 @@ async function handleTypeHierarchyCommand(command, context) {
     context.writeStderrLine(helpText2(command).trimEnd());
     context.exit(2);
   }
+  let limit;
+  let depth;
+  try {
+    limit = parseBoundedIntegerOption(context.getOpt("--limit"), "--limit", DEFAULT_HIERARCHY_LIMIT2, 0, MAX_HIERARCHY_LIMIT2);
+    if (command !== "implementations") {
+      depth = parseBoundedIntegerOption(context.getOpt("--depth"), "--depth", DEFAULT_HIERARCHY_DEPTH, 1, MAX_HIERARCHY_DEPTH2);
+    }
+  } catch (error51) {
+    exitWithError(context, error51, 2);
+  }
   try {
-    const limit = parseBoundedIntegerOption(context.getOpt("--limit"), "--limit", DEFAULT_HIERARCHY_LIMIT2, 0, MAX_HIERARCHY_LIMIT2);
     if (command === "implementations") {
       const response2 = await findImplementations2({
         root: context.root,
@@ -81470,7 +81892,6 @@ async function handleTypeHierarchyCommand(command, context) {
       writeResponse(context, response2, formatImplementationsResponse);
       return;
     }
-    const depth = parseBoundedIntegerOption(context.getOpt("--depth"), "--depth", DEFAULT_HIERARCHY_DEPTH, 1, MAX_HIERARCHY_DEPTH2);
     const request = {
       root: context.root,
       handle,
@@ -81576,6 +81997,9 @@ async function handleExplainCommand(context) {
   } else {
     context.writeStdoutLine(formatAgentExplanation(response));
   }
+  if (response.target.kind === "not_found") {
+    context.exit(1);
+  }
 }
 var init_explain2 = __esm({
   "dist/cli/explain.js"() {
@@ -81863,10 +82287,10 @@ function buildFocusTargets(modules, packets, review) {
         kind: "hotspot",
         file: module2.file,
         why: `graph-central module: fan-in ${module2.fanIn}, fan-out ${module2.fanOut}, score ${module2.score}`,
-        followUps: [
+        followUps: dedupeAgentFollowUps([
           toolFollowUp("packet_get", { target: packet.file }),
           toolFollowUp("packet_get", { target: module2.file })
-        ]
+        ])
       });
       continue;
     }
@@ -98215,7 +98639,7 @@ var init_tools = __esm({
           limit: { type: "integer", minimum: 0, maximum: 50, default: 5 },
           maxPackets: { type: "integer", minimum: 0, maximum: 10, default: 3 },
           maxPaths: { type: "integer", minimum: 0, maximum: 10, default: 3 },
-          includeSource: { type: "boolean", default: true }
+          includeSource: { type: "boolean", default: false }
         }, ["query"]),
         dispatch: { handler: "explore" }
       },
@@ -98830,7 +99254,7 @@ function createCodegraphMcpHandlersForSession(options, session) {
       ...request.limit !== void 0 ? { limit: request.limit } : {},
       ...request.maxPackets !== void 0 ? { maxPackets: request.maxPackets } : {},
       ...request.maxPaths !== void 0 ? { maxPaths: request.maxPaths } : {},
-      ...request.includeSource !== void 0 ? { includeSource: request.includeSource } : {}
+      includeSource: request.includeSource ?? false
     })),
     orient: async (request) => await withFreshness(async () => await orientCodegraphWithSession(session, {
       root,
@@ -101603,7 +102027,7 @@ var init_dist4 = __esm({
 });
 
 // dist/mcp/http.js
-import os9 from "node:os";
+import os10 from "node:os";
 function getRequestPath(request) {
   return new URL(request.url ?? "/", "http://127.0.0.1").pathname;
 }
@@ -101806,11 +102230,11 @@ function isWildcardBindHost(host) {
 }
 function localInterfaceHostnames() {
   const hosts = /* @__PURE__ */ new Set();
-  const hostname3 = os9.hostname().trim().toLowerCase();
+  const hostname3 = os10.hostname().trim().toLowerCase();
   if (hostname3) {
     hosts.add(hostname3);
   }
-  const interfaces = os9.networkInterfaces();
+  const interfaces = os10.networkInterfaces();
   for (const entries of Object.values(interfaces)) {
     for (const entry of entries ?? []) {
       if (entry.internal)
@@ -102399,11 +102823,82 @@ function toToolResult(value) {
     content: [
       {
         type: "text",
-        text: JSON.stringify(value, null, 2)
+        text: JSON.stringify(translateMcpFollowUps(value))
       }
     ]
   };
 }
+function translateMcpFollowUps(value) {
+  if (Array.isArray(value))
+    return translateFollowUpCollection(value);
+  if (typeof value !== "object" || value === null)
+    return value;
+  const source = value;
+  let translated;
+  for (const [key, nestedValue] of Object.entries(source)) {
+    const nestedTranslation = translateMcpFollowUps(nestedValue);
+    if (nestedTranslation === nestedValue)
+      continue;
+    translated ??= { ...source };
+    translated[key] = nestedTranslation;
+  }
+  return translateFollowUps(translated ?? source);
+}
+function translateFollowUpCollection(value) {
+  let translated;
+  for (const [index, entry] of value.entries()) {
+    const entryTranslation = translateMcpFollowUps(entry);
+    if (entryTranslation === entry) {
+      if (translated !== void 0)
+        translated.push(entry);
+      continue;
+    }
+    translated ??= [...value.slice(0, index)];
+    translated.push(entryTranslation);
+  }
+  return translated ?? value;
+}
+function translateFollowUps(value) {
+  const followUps = value.followUps;
+  if (!Array.isArray(followUps) || !followUps.every(isAgentFollowUp))
+    return value;
+  const translatedFollowUps = followUps.map(translateMcpFollowUp);
+  if (translatedFollowUps.every((followUp, index) => followUp === followUps[index]))
+    return value;
+  return { ...value, followUps: translatedFollowUps };
+}
+function isAgentFollowUp(value) {
+  return typeof value === "object" && value !== null && "tool" in value && typeof value.tool === "string" && "arguments" in value && typeof value.arguments === "object" && value.arguments !== null && !Array.isArray(value.arguments);
+}
+function translateMcpFollowUp(followUp) {
+  if (followUp.tool === "chunk")
+    return { ...followUp, tool: "get_file" };
+  if (followUp.tool === "duplicates") {
+    return {
+      ...followUp,
+      tool: "packet_get",
+      arguments: { target: firstDuplicateFile(followUp.arguments) }
+    };
+  }
+  if (followUp.tool === "explore" && followUp.arguments.includeSource === void 0) {
+    return {
+      ...followUp,
+      arguments: { ...followUp.arguments, includeSource: true }
+    };
+  }
+  if (followUp.tool === "impact" && followUp.arguments.provider === "git") {
+    const arguments_ = { ...followUp.arguments };
+    delete arguments_.provider;
+    return { ...followUp, arguments: arguments_ };
+  }
+  return followUp;
+}
+function firstDuplicateFile(arguments_) {
+  const files = arguments_.files;
+  if (!Array.isArray(files))
+    return ".";
+  return files.find((file2) => typeof file2 === "string") ?? ".";
+}
 function toToolErrorResult(error51) {
   const message = errorMessage(error51).replace(/(?:[A-Za-z]:)?[/\\][^'"\n]*?(?=(?:[/\\][^'"\n]*)?['"]|$)/g, "<path>");
   return { isError: true, content: [{ type: "text", text: message }] };
@@ -103067,7 +103562,7 @@ import path86 from "node:path";
 async function handleServerCommand(context) {
   const command = context.positionals[0];
   if (!isServerCommand(command)) {
-    context.writeStderrLine("Usage: codegraph server <start|status|stop> [--root <path>]");
+    context.writeStderrLine(getCliCommandUsage("server"));
     context.exit(2);
   }
   try {
@@ -103897,7 +104392,8 @@ var init_server2 = __esm({
         "--warmup",
         "--warmup-symbols",
         "--workers",
-        "--json"
+        "--json",
+        "--pretty"
       ],
       status: ["--json", "--pretty"],
       stop: []
@@ -103929,7 +104425,7 @@ var graphDelta_exports = {};
 __export(graphDelta_exports, {
   handleGraphDeltaCommand: () => handleGraphDeltaCommand
 });
-import fsp37 from "node:fs/promises";
+import fsp38 from "node:fs/promises";
 function formatGraphDeltaReport(delta) {
   const lines = [];
   lines.push("Graph delta");
@@ -103996,7 +104492,7 @@ async function handleGraphDeltaCommand(context) {
   const outputFile = outputArg ? normalizePath(resolveFilePathFromRoot(context.cwd(), outputArg)) : void 0;
   if (outputFile) {
     const output = context.hasFlag("--json") ? JSON.stringify(delta, null, 2) : formatGraphDeltaReport(delta);
-    await fsp37.writeFile(outputFile, `${output}
+    await fsp38.writeFile(outputFile, `${output}
 `, "utf8");
   } else {
     writeCliOutput(context, delta, formatGraphDeltaReport);
@@ -104296,7 +104792,7 @@ var init_symbol_render = __esm({
 });
 
 // dist/sql/graph.js
-import fsp38 from "node:fs/promises";
+import fsp39 from "node:fs/promises";
 function statementNodeId(fact) {
   return `sql:statement:${fact.filePath}:${fact.startLine}-${fact.endLine}`;
 }
@@ -104451,7 +104947,7 @@ function projectSqlFactsToGraph(facts) {
   };
 }
 async function buildSqlArtifactGraphFromFiles(files) {
-  const factGroups = await Promise.all(files.map(async (filePath) => extractSqlFactsFromSource(filePath, await fsp38.readFile(filePath, "utf8"))));
+  const factGroups = await Promise.all(files.map(async (filePath) => extractSqlFactsFromSource(filePath, await fsp39.readFile(filePath, "utf8"))));
   return projectSqlFactsToGraph(factGroups.flat());
 }
 var init_graph = __esm({
@@ -104482,7 +104978,7 @@ __export(graph_exports, {
   handleGraphCommand: () => handleGraphCommand
 });
 import fs42 from "node:fs";
-import fsp39 from "node:fs/promises";
+import fsp40 from "node:fs/promises";
 import path88 from "node:path";
 import { performance as performance12 } from "node:perf_hooks";
 function resolveGraphCacheMode(cache) {
@@ -104645,7 +105141,7 @@ async function handleGraphCommand(context) {
     ...cacheDir ? { cacheDir } : {},
     ...context.cacheLocation ? { cacheLocation: context.cacheLocation } : {}
   };
-  const stable = context.hasFlag("--stable");
+  const stable = true;
   let format = "mermaid";
   if (context.hasFlag("--json")) {
     format = "json";
@@ -104676,7 +105172,7 @@ async function handleGraphCommand(context) {
   };
   const writeOut = async (text) => {
     if (outputFile) {
-      await fsp39.writeFile(outputFile, `${text}
+      await fsp40.writeFile(outputFile, `${text}
 `, "utf8");
     } else {
       context.writeStdoutLine(text);
@@ -105619,7 +106115,7 @@ var init_report3 = __esm({
 });
 
 // dist/drift/artifact.js
-import fsp40 from "node:fs/promises";
+import fsp41 from "node:fs/promises";
 import path90 from "node:path";
 function readStringRecord2(value) {
   if (!isPlainRecord(value))
@@ -105643,7 +106139,7 @@ function parseManifest(value) {
 }
 async function readJson(filePath, label) {
   try {
-    return JSON.parse(await fsp40.readFile(filePath, "utf8"));
+    return JSON.parse(await fsp41.readFile(filePath, "utf8"));
   } catch (error51) {
     if (error51 instanceof Error && "code" in error51 && error51.code === "ENOENT") {
       throw new Error(`Codegraph artifact ${label} is missing.`);
@@ -105777,8 +106273,8 @@ var init_artifact3 = __esm({
 
 // dist/drift/git.js
 import { execFile } from "node:child_process";
-import fsp41 from "node:fs/promises";
-import os10 from "node:os";
+import fsp42 from "node:fs/promises";
+import os11 from "node:os";
 import path91 from "node:path";
 import { promisify } from "node:util";
 function snapshotOptions(options) {
@@ -105798,7 +106294,7 @@ async function cleanupTempDir(dir) {
   if (!dir)
     return;
   try {
-    await fsp41.rm(dir, { recursive: true, force: true });
+    await fsp42.rm(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -105817,7 +106313,7 @@ async function materializeGitRef(root, ref, prefix) {
   }
   if (checkoutRef === void 0 || checkoutRef === "." || isGitWorktreeSentinel(checkoutRef))
     return { root };
-  const tempRoot = await fsp41.mkdtemp(path91.join(os10.tmpdir(), prefix));
+  const tempRoot = await fsp42.mkdtemp(path91.join(os11.tmpdir(), prefix));
   try {
     await execFileAsync("git", ["clone", "--quiet", "--no-checkout", root, tempRoot], { env: process.env });
     const checkoutCommit = await resolveGitCommit(root, checkoutRef);
@@ -106567,7 +107063,7 @@ function formatGotoOutput(projectRootFs, output) {
 async function handleDumpmodCommand(context) {
   const [fileArg] = context.positionals;
   if (!fileArg) {
-    context.writeStderrLine("Usage: dumpmod <file>");
+    context.writeStderrLine(getCliCommandUsage("dumpmod"));
     context.exit(2);
   }
   const resolvedFile = resolveCliProjectFile(context.projectRootFs, fileArg, "File");
@@ -106689,9 +107185,14 @@ function writePrettyReferences(context, result) {
   }
 }
 async function handleGotoCommand(context) {
-  const input = parseNavigationInput(context, false);
+  let input;
+  try {
+    input = parseNavigationInput(context, false);
+  } catch (error51) {
+    exitWithError(context, error51, 2);
+  }
   if (!input) {
-    context.writeStderrLine("Usage: goto <file>[:line[:column]] [line] [column]");
+    context.writeStderrLine(getCliCommandUsage("goto"));
     context.exit(2);
   }
   const resolvedFile = resolveCliProjectFile(context.projectRootFs, input.file, "File");
@@ -106744,9 +107245,14 @@ async function handleGotoCommand(context) {
     context.exit(1);
 }
 async function handleRefsCommand(context) {
-  const input = parseNavigationInput(context, true);
+  let input;
+  try {
+    input = parseNavigationInput(context, true);
+  } catch (error51) {
+    exitWithError(context, error51, 2);
+  }
   if (!input) {
-    context.writeStderrLine("Usage: refs <file>[:line[:column]] [line] [column] OR refs --file <file> [--line <line> --col <column>]");
+    context.writeStderrLine(getCliCommandUsage("refs"));
     context.exit(2);
   }
   const pretty = !context.hasFlag("--json");
@@ -106832,11 +107338,12 @@ var init_navigation3 = __esm({
     init_location2();
     init_projectFile();
     init_pretty();
+    init_context();
   }
 });
 
 // dist/graphs/grep.js
-import fsp42 from "node:fs/promises";
+import fsp43 from "node:fs/promises";
 async function* streamAstGrep(projectRoot, querySource, patterns = [
   "**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs,py,vue,svelte,go,java,cs,rb,rs,html,htm,css,scss,less,kt,kts,swift,zig,c,h,cc,cpp,cxx,c++,hpp,hh,hxx,ipp,tpp,inl}"
 ], opts) {
@@ -106894,7 +107401,7 @@ async function* streamTextGrep(projectRoot, patternSource, patterns = [
       break;
     let source;
     try {
-      source = await fsp42.readFile(file2, "utf8");
+      source = await fsp43.readFile(file2, "utf8");
     } catch {
       continue;
     }
@@ -106983,7 +107490,7 @@ async function handleGrepCommand(context) {
     exitWithError(context, error51, 2);
   }
   if ((querySource ? 1 : 0) + (patternSource ? 1 : 0) !== 1) {
-    context.writeStderrLine("Usage: grep <regex> [--root <dir>] OR grep --query '<tree-sitter query>' [--root <dir>]");
+    context.writeStderrLine(getCliCommandUsage("grep"));
     context.exit(2);
   }
   if (querySource && maxHits !== void 0) {
@@ -107895,7 +108402,7 @@ function deletedPathsForChange2(change2) {
 async function buildAffectedReportFromContext(context) {
   const inputs = await collectChangedFileInputs(context);
   if (!inputs.files.length) {
-    throw new Error("Usage: codegraph affected <file...> [--stdin] [--base <ref> --head <ref>] [--root <path>]");
+    throw new Error(getCliCommandUsage("affected"));
   }
   const normalizedChangedFiles = Array.from(new Set(inputs.files.map((input) => normalizeChangedFileInput(context.projectRootFs, input)))).sort();
   const normalizedDeletedFiles = Array.from(new Set(inputs.deletedFiles.map((input) => normalizeChangedFileInput(context.projectRootFs, input)))).sort();
@@ -108291,10 +108798,15 @@ async function loadGraph(context) {
 async function handleDepsCommand(context) {
   const [fileArg] = context.positionals;
   if (!fileArg) {
-    context.writeStderrLine(`Usage: ${context.command} <file|file::symbol|symbol:...> [--depth N] [--json]`);
+    context.writeStderrLine(getCliCommandUsage(context.command));
     context.exit(2);
   }
   const depthRaw = context.getOpt("--depth");
+  const all = context.hasFlag("--all");
+  if (all && depthRaw !== void 0) {
+    context.writeStderrLine("--all cannot be combined with --depth.");
+    context.exit(2);
+  }
   let depth;
   try {
     depth = parseOptionalNonNegativeIntegerOption(depthRaw, "--depth");
@@ -108371,18 +108883,21 @@ async function handleDepsCommand(context) {
     context.exit(1);
   }
   targetFile = matchedGraphNode;
-  const results = context.command === "deps" ? getDependencies(loaded.graph, targetFile, {
-    ...depth !== void 0 ? { depth } : {},
-    ...loaded.adjacency ? { adjacency: loaded.adjacency } : {}
-  }) : getReverseDependencies(loaded.graph, targetFile, {
-    ...depth !== void 0 ? { depth } : {},
-    ...loaded.adjacency ? { adjacency: loaded.adjacency } : {}
-  });
+  const effectiveDepth = depth ?? 1;
+  const traversalOptions = {
+    ...loaded.adjacency ? { adjacency: loaded.adjacency } : {},
+    ...json3 && !all ? { depth: effectiveDepth + 1 } : {}
+  };
+  const allResults = context.command === "deps" ? getDependencies(loaded.graph, targetFile, traversalOptions) : getReverseDependencies(loaded.graph, targetFile, traversalOptions);
+  const results = all ? allResults : allResults.filter((result) => result.depth <= effectiveDepth);
+  const truncated = results.length !== allResults.length;
+  const omittedCount = allResults.length - results.length;
   if (json3) {
-    context.writeJSONLine(results);
+    context.writeJSONLine({ items: results, truncated });
     return;
   }
-  context.writeStdoutLine(`${context.command === "deps" ? "Dependencies" : "Reverse dependencies"} for ${fileArg}:`);
+  const depthDescription = all ? "all depths" : `depth ${effectiveDepth}`;
+  context.writeStdoutLine(`${context.command === "deps" ? "Dependencies" : "Reverse dependencies"} for ${fileArg} (${depthDescription}; ${omittedCount} omitted):`);
   for (const result of results) {
     const rel = toProjectDisplayPath(context.projectRootFs, result.file);
     context.writeStdoutLine(`${"  ".repeat(result.depth)} ${rel} (depth ${result.depth})`);
@@ -108391,7 +108906,7 @@ async function handleDepsCommand(context) {
 async function handlePathCommand(context) {
   const [fromArg, toArg] = context.positionals;
   if (!fromArg || !toArg) {
-    context.writeStderrLine("Usage: path <from-file> <to-file> [--json]");
+    context.writeStderrLine(getCliCommandUsage("path"));
     context.exit(2);
   }
   const json3 = context.hasFlag("--json");
@@ -109655,10 +110170,7 @@ function resolveCliRootPolicy(input) {
     if (!isLegacyImpactRoot) {
       return {
         status: "error",
-        messages: [
-          `Unexpected positional argument for impact: ${impactRootArg}`,
-          "Usage: codegraph impact [project-root] [--provider git|github|raw] [options]"
-        ]
+        messages: [`Unexpected positional argument for impact: ${impactRootArg}`, getCliCommandUsage("impact")]
       };
     }
   }
@@ -109751,6 +110263,7 @@ var init_rootPolicy = __esm({
   "dist/cli/rootPolicy.js"() {
     "use strict";
     init_paths();
+    init_options();
     WINDOWS_DRIVE_QUALIFIED_PATTERN = /^[A-Za-z]:[\\/]/;
     WINDOWS_DRIVE_RELATIVE_ROOT_PATTERN = /^[\\/](?![\\/])/;
   }
@@ -110527,6 +111040,10 @@ async function runCliWithActiveRuntime(rawArgs) {
       writeStdoutLine(CLI_HELP_TEXT.trimEnd());
       return;
     }
+    if (command === "advanced") {
+      writeStdoutLine(ADVANCED_HELP_TEXT.trimEnd());
+      return;
+    }
     if (!isKnownCliCommand(command)) {
       writeStderrLine(`Unknown command "${command}".`);
       const suggestions = suggestCliCommands(command);