@lzehrung/codegraph 2.2.2 → 2.2.3

package/dist/bin/cli.js

@@ -4671,9 +4671,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 +10191,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,554 +13403,12 @@ 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
-});
-import fs6 from "node:fs";
-import fsp4 from "node:fs/promises";
-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);
-  }
-  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;
-    }
-    if (slashCount % 2 === 1) {
-      break;
-    }
-    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)) {
-      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 {
-      continue;
-    }
-  }
-  return rules;
-}
-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));
-  }
-  return rules;
-}
-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;
-    }
-  }
-  return ignored;
-}
-async function ensureDirectoryReadable(directoryPath, label) {
-  const resolvedPath = path8.resolve(directoryPath);
-  let stats;
-  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}`);
-  }
-  return resolvedPath;
-}
-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
-    });
-    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 } : {}
-    };
-    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(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;
-      }
-      const ignoredByDefault = defaultIgnoreMatchers.some((matcher) => matcher(rootRelative));
-      if (ignoredByDefault && !(includeMatchers.length > 0 && matchesInclude)) {
-        return false;
-      }
-      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)}`);
-  }
-}
-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));
-  };
-}
-async function isSafeSymlinkDirectory(root, linkPath, realRoot) {
-  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);
-  } 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);
-    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 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 [...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;
-    }
-  });
-  return filtered.filter((entry) => entry !== null);
-}
-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(path8.dirname(filePath));
-  let name = null;
-  if (def.parseName && def.kind === "file") {
-    try {
-      const raw = await fsp4.readFile(filePath, "utf8");
-      name = def.parseName(raw, filePath);
-    } 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 {
-    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");
-  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);
-    });
-  } catch (error51) {
-    logWithLevel(options?.logLevel, "debug", `discoverProjectFiles failed for ${root}: ${stringifyUnknown(error51)}`);
-    throw new Error(`Failed to discover project files in ${root}: ${stringifyUnknown(error51)}`);
-  }
-}
-var import_fast_glob2, import_picomatch, DEFAULT_PROJECT_FILE_IGNORES, DEFAULT_PROJECT_MANIFESTS, DEFAULT_PROJECT_PATTERNS, REALPATH_FILTER_CONCURRENCY;
-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_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;
-  }
-});
-
 // 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,
@@ -13960,16 +13418,22 @@ __export(git_exports, {
   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 { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
-import path9 from "node:path";
+import fsp4 from "node:fs/promises";
+import os2 from "node:os";
+import path8 from "node:path";
 function decodeGitPath(rawPath) {
   if (!rawPath.startsWith('"') || !rawPath.endsWith('"')) {
     return rawPath;
@@ -14013,6 +13477,10 @@ function setGitExecutableForTests(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);
@@ -14223,7 +13691,7 @@ async function getGitHead(projectRoot) {
   }
 }
 async function isGitRepo(projectRoot) {
-  const resolvedRoot = path9.resolve(projectRoot);
+  const resolvedRoot = path8.resolve(projectRoot);
   const cached2 = gitRepositoryChecks.get(resolvedRoot);
   if (cached2)
     return await cached2;
@@ -14244,6 +13712,15 @@ async function isGitPathTracked(projectRoot, 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);
@@ -14252,180 +13729,930 @@ async function runGitPathPredicate(projectRoot, args) {
     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;
+    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 [];
+  }
+  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);
+  }
+}
+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 Array.from(new Set(out));
+  } catch (error51) {
+    throw createGitError(projectRoot, args, error51);
+  }
+}
+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);
+  }
+}
+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 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 {
+      if ((await fsp4.stat(file2)).isFile())
+        sources.push({ file: file2, baseDir });
+    } catch {
+    }
+  }
+  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);
+  }
+}
+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 {
+    return await runGitCollectStdout(projectRoot, args);
+  } 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;
+  }
+  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";
+    init_ast();
+    init_paths();
+    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/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 fs6 from "node:fs";
+import fsp5 from "node:fs/promises";
+import path9 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(path9.relative(globRoot, scanRoot));
+  if (!relativeScanRoot || !isRelativePathInside(relativeScanRoot)) {
+    return ignoreGlobs.map(normalizeGlobPattern).filter(Boolean);
+  }
+  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;
+    }
+    if (slashCount % 2 === 1) {
+      break;
+    }
+    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;
+    }
+    let raw;
+    try {
+      raw = await fsp5.readFile(file2, "utf8");
+    } catch {
+      continue;
+    }
+    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 gitignoreIndex;
+}
+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
+  });
+}
+async function loadGitignoreIndexForRootAliases(projectRoot) {
+  const roots = [projectRoot];
+  const realRoot = await fsp5.realpath(projectRoot);
+  if (normalizePath(realRoot) !== normalizePath(projectRoot)) {
+    roots.push(realRoot);
+  }
+  const sources = [];
+  for (const root of roots) {
+    for (const file2 of await findGitignoreFiles(root)) {
+      sources.push({ file: file2, baseDir: path9.dirname(file2) });
+    }
+  }
+  return await buildGitignoreIndex(sources);
+}
+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;
+  }
+  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 normalizedRelativePath2 = normalizePath(relativePath3);
+    const hasSeparator = normalizedRelativePath2.includes("/");
+    for (const rule of group.rules) {
+      if (rule.dirOnly && !hasSeparator) {
+        continue;
+      }
+      if (rule.matches(normalizedRelativePath2)) {
+        ignored = !rule.negated;
+      }
+    }
+  }
+  return ignored;
+}
+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 (!stats.isDirectory()) {
+    throw new Error(`${label} is not a directory: ${resolvedPath}`);
+  }
+  return resolvedPath;
+}
+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 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 {
+      return (await fsp5.stat(candidate)).isFile() ? { file: candidate, baseDir: directory } : null;
+    } catch {
+      return null;
+    }
+  });
+  const sources = present.filter((entry) => entry !== null);
+  sources.push(...await listGitExcludeFiles(root));
+  return sources;
+}
+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 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 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) {
+    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;
+    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
-    });
-    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);
-    }
-    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();
+    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 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;
-    }
-    currentBatch.push(absolutePath);
-    currentBatchBytes += pathBytes;
+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 (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));
+  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 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;
   }
-  return hashes;
+  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 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 {
+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 [];
-  }
-  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);
+  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 Array.from(new Set(out));
-  } catch (error51) {
-    throw createGitError(projectRoot, args, error51);
   }
+  return [...filesByPath.values()];
 }
-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);
+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;
     }
-    return Array.from(new Set(out));
-  } catch (error51) {
-    throw createGitError(projectRoot, args, error51);
-  }
+  });
+  return filtered.filter((entry) => entry !== null);
 }
-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 "";
+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;
+    }
   }
-  args.push("--");
-  try {
-    return await runGitCollectStdout(projectRoot, args);
-  } catch (error51) {
-    throw createGitError(projectRoot, args, error51);
+  if (!name && def.nameFromPath) {
+    if (def.nameFromPath === "file") {
+      name = trimToNull(path9.basename(filePath, path9.extname(filePath)));
+    } else {
+      name = trimToNull(path9.basename(projectRoot));
+    }
   }
+  return {
+    path: normalizedPath,
+    kind: def.kind,
+    type: def.type,
+    role: def.role,
+    projectRoot,
+    ...name ? { name } : {}
+  };
 }
-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;
+async function discoverProjectFiles(projectRoot, options) {
+  const root = await ensureDirectoryReadable(projectRoot, "Project root");
+  try {
+    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) {
+    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 +14750,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 +14911,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 +14931,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 +14946,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 +14956,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 +14992,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 +15021,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 +15029,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 +15181,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 +15231,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 +15368,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 +15408,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 +15444,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 +15497,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 +15946,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 +15958,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 +16004,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 +16042,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 +18214,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 +18224,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 +18285,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 +18408,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 +18464,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 +18811,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 +18822,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 +19227,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 +21189,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 +21202,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 +24952,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 +25081,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 +25517,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 +25720,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 +30032,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 +30043,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 +30067,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 +30101,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 +30138,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 +30434,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 +30586,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 +30651,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 +31361,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 +31750,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 +48639,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 +48710,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 +48729,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 +48795,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 +48808,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 +48881,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 +48949,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 +48995,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 +49006,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 +49024,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 +49047,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 +49077,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 +49113,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 +49888,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 +50039,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 +50047,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 +50064,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 +50075,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 +50149,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 };
@@ -50735,21 +51011,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 +51073,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 +51083,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 +51094,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 +51245,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 +51265,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 +52893,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 +53073,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 +53427,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 +53805,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 +54162,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 {
@@ -55693,7 +55969,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 +56048,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 +56409,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 +56432,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 +56454,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 +56501,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 +56602,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 +56646,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 +56670,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 +56718,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 +56777,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 +56799,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 +56821,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 +56838,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 +56897,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 +57690,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 +57758,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 +57772,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 +57915,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 +57952,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 +57970,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 +57986,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 +58006,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 +58031,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 +58039,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 +58089,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 +58117,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 +58245,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 +58373,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 +58867,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 +58884,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 +58911,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 +58926,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 +58965,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 +58977,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 +58986,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 +58995,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 +59016,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 +59204,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 +59237,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 +59432,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) {
@@ -60668,7 +60945,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;
@@ -60701,7 +60978,7 @@ async function handleChunkCommand(context) {
   }
   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) {
@@ -61791,7 +62068,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 +62076,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 +62152,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 +62226,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 +62248,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 +63629,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 +63915,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 +65619,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 +65634,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 +68997,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 +69259,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);
@@ -74907,9 +75184,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
@@ -101603,7 +101880,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 +102083,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)
@@ -103929,7 +104206,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 +104273,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 +104573,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 +104728,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 +104759,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) {
@@ -104676,7 +104953,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 +105896,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 +105920,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 +106054,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 +106075,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 +106094,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);
@@ -106836,7 +107113,7 @@ var init_navigation3 = __esm({
 });
 
 // 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 +107171,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;
     }