codebase-snapshot 0.9.5 → 0.9.6

package/dist/{chunk-B336MMNC.js → chunk-3KUL3QRH.js}

@@ -1,13 +1,14 @@
 import * as crypto from 'crypto';
 import { createHash } from 'crypto';
 import { AsyncLocalStorage } from 'async_hooks';
-import * as fs11 from 'fs';
+import * as fs12 from 'fs';
 import * as os from 'os';
-import * as path12 from 'path';
+import * as path13 from 'path';
 import ts from 'typescript';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
 import * as childProcess from 'child_process';
+import * as https from 'https';
 import * as readline from 'readline';
 
 // src/index.ts
@@ -234,9 +235,9 @@ var JAVA_METHOD = /^\s+(?:public|private|protected)\s+(?:static\s+)?(?:final\s+)
 var jvmProfile = {
   id: "jvm",
   extensions: [".java", ".kt", ".kts", ".scala"],
-  summarize(path13, content) {
+  summarize(path14, content) {
     const summary = emptySummary();
-    const lower = path13.toLowerCase();
+    const lower = path14.toLowerCase();
     const isJava = lower.endsWith(".java");
     const isKotlin = lower.endsWith(".kt") || lower.endsWith(".kts");
     eachLine(content, (line) => {
@@ -689,16 +690,16 @@ function summarizeTypeScriptSource(relativePath, content) {
 // src/ast/profiles/sfc.ts
 var SCRIPT_BLOCK = /<script[^>]*>([\s\S]*?)<\/script>/gi;
 var ASTRO_FRONTMATTER = /^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?=\r?\n|$)/;
-function componentName(path13) {
-  const base = path13.split("/").pop() ?? path13;
+function componentName(path14) {
+  const base = path14.split("/").pop() ?? path14;
   return base.replace(/\.[^.]+$/, "");
 }
 var sfcProfile = {
   id: "sfc",
   extensions: [".vue", ".svelte", ".astro"],
-  summarize(path13, content) {
+  summarize(path14, content) {
     let script = "";
-    if (path13.toLowerCase().endsWith(".astro")) {
+    if (path14.toLowerCase().endsWith(".astro")) {
       const frontmatter = ASTRO_FRONTMATTER.exec(content);
       if (frontmatter) script += `${frontmatter[1]}
 `;
@@ -707,7 +708,7 @@ var sfcProfile = {
       script += `${match[1]}
 `;
     }
-    const name = componentName(path13);
+    const name = componentName(path14);
     if (!script.trim()) {
       const summary2 = emptySummary();
       if (name) {
@@ -741,15 +742,15 @@ for (const profile of LANGUAGE_PROFILES) {
     BY_EXTENSION.set(extension.toLowerCase(), profile);
   }
 }
-function profileForPath(path13) {
-  const lower = path13.toLowerCase();
+function profileForPath(path14) {
+  const lower = path14.toLowerCase();
   const dot = lower.lastIndexOf(".");
   if (dot === -1) return null;
   return BY_EXTENSION.get(lower.slice(dot)) ?? null;
 }
-function summarizeWithProfile(path13, content) {
-  const profile = profileForPath(path13);
-  return profile ? profile.summarize(path13, content) : null;
+function summarizeWithProfile(path14, content) {
+  const profile = profileForPath(path14);
+  return profile ? profile.summarize(path14, content) : null;
 }
 
 // src/ast/structured.ts
@@ -920,15 +921,15 @@ var SKIPPED_WALK_DIRS = /* @__PURE__ */ new Set([
 ]);
 function readSmallFile(fullPath) {
   try {
-    const stats = fs11.statSync(fullPath);
+    const stats = fs12.statSync(fullPath);
     if (!stats.isFile() || stats.size > MANIFEST_MAX_BYTES) return null;
-    return fs11.readFileSync(fullPath, "utf8");
+    return fs12.readFileSync(fullPath, "utf8");
   } catch {
     return null;
   }
 }
 function readManifest(cwd, name) {
-  return readSmallFile(path12.join(cwd, name));
+  return readSmallFile(path13.join(cwd, name));
 }
 function dependenciesFromPackageJson(raw) {
   const names = /* @__PURE__ */ new Set();
@@ -988,7 +989,7 @@ function pnpmWorkspacePatterns(raw) {
 function childDirectories(cwd, parent) {
   let entries;
   try {
-    entries = fs11.readdirSync(path12.join(cwd, parent), { withFileTypes: true });
+    entries = fs12.readdirSync(path13.join(cwd, parent), { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1024,12 +1025,12 @@ function scanWorkspacePackages(cwd, patterns) {
   const files = /* @__PURE__ */ new Set();
   const dependencies = /* @__PURE__ */ new Set();
   for (const relative7 of workspacePackageDirs(cwd, patterns)) {
-    const full = path12.join(cwd, relative7);
+    const full = path13.join(cwd, relative7);
     try {
-      for (const entry of fs11.readdirSync(full, { withFileTypes: true })) files.add(entry.name);
+      for (const entry of fs12.readdirSync(full, { withFileTypes: true })) files.add(entry.name);
     } catch {
     }
-    const raw = readSmallFile(path12.join(full, "package.json"));
+    const raw = readSmallFile(path13.join(full, "package.json"));
     if (raw !== null) {
       for (const name of dependenciesFromPackageJson(raw)) dependencies.add(name);
     }
@@ -1046,7 +1047,7 @@ function countMarkdownFiles(cwd) {
     directoriesSeen += 1;
     let entries;
     try {
-      entries = fs11.readdirSync(current.dir, { withFileTypes: true });
+      entries = fs12.readdirSync(current.dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -1057,7 +1058,7 @@ function countMarkdownFiles(cwd) {
       }
       if (!entry.isDirectory() || current.depth >= 2) continue;
       if (entry.name.startsWith(".") || SKIPPED_WALK_DIRS.has(entry.name)) continue;
-      queue.push({ dir: path12.join(current.dir, entry.name), depth: current.depth + 1 });
+      queue.push({ dir: path13.join(current.dir, entry.name), depth: current.depth + 1 });
     }
   }
   return count;
@@ -1066,7 +1067,7 @@ function buildPresetContext(cwd) {
   const files = /* @__PURE__ */ new Set();
   const dirs = /* @__PURE__ */ new Set();
   try {
-    for (const entry of fs11.readdirSync(cwd, { withFileTypes: true })) {
+    for (const entry of fs12.readdirSync(cwd, { withFileTypes: true })) {
       if (entry.isDirectory()) dirs.add(entry.name);
       else if (entry.isFile()) files.add(entry.name);
     }
@@ -1083,7 +1084,7 @@ function buildPresetContext(cwd) {
   const isWorkspace = files.has("pnpm-workspace.yaml") || files.has("nx.json") || files.has("turbo.json") || files.has("lerna.json") || packageJson !== void 0 && packageJson.includes('"workspaces"') || declaredWorkspaces.length > 0;
   let workspace = { files: /* @__PURE__ */ new Set(), dependencies: /* @__PURE__ */ new Set() };
   if (isWorkspace) {
-    const pnpmRaw = files.has("pnpm-workspace.yaml") ? readSmallFile(path12.join(cwd, "pnpm-workspace.yaml")) : null;
+    const pnpmRaw = files.has("pnpm-workspace.yaml") ? readSmallFile(path13.join(cwd, "pnpm-workspace.yaml")) : null;
     const declared = pnpmRaw === null ? [] : pnpmWorkspacePatterns(pnpmRaw);
     const patterns = declared.length > 0 ? declared : declaredWorkspaces.length > 0 ? declaredWorkspaces : DEFAULT_WORKSPACE_PATTERNS;
     workspace = scanWorkspacePackages(cwd, patterns);
@@ -2358,14 +2359,14 @@ var PRESET_IGNORES = new Set(
 );
 function readLinkTarget(linkPath, fallback) {
   try {
-    return fs11.readlinkSync(linkPath);
+    return fs12.readlinkSync(linkPath);
   } catch {
     return fallback;
   }
 }
 function isInside(root, candidate) {
-  const relative7 = path12.relative(root, candidate);
-  return relative7 === "" || !relative7.startsWith(`..${path12.sep}`) && relative7 !== ".." && !path12.isAbsolute(relative7);
+  const relative7 = path13.relative(root, candidate);
+  return relative7 === "" || !relative7.startsWith(`..${path13.sep}`) && relative7 !== ".." && !path13.isAbsolute(relative7);
 }
 function getGitInfo(cwd, fallbackBranch = "main") {
   try {
@@ -2570,10 +2571,10 @@ function trimUnescapedTrailingSpaces(line) {
   return line.slice(0, end);
 }
 function readGitignoreRules(dir) {
-  const gitignorePath2 = path12.join(dir, ".gitignore");
+  const gitignorePath2 = path13.join(dir, ".gitignore");
   let raw;
   try {
-    raw = fs11.readFileSync(gitignorePath2, "utf8");
+    raw = fs12.readFileSync(gitignorePath2, "utf8");
   } catch {
     return [];
   }
@@ -2700,7 +2701,7 @@ function isToolOwnedDirName(name) {
 }
 function hasSnapshotMarker(target) {
   try {
-    return fs11.statSync(target).isDirectory() && fs11.existsSync(path12.join(target, ".codebase-snapshot"));
+    return fs12.statSync(target).isDirectory() && fs12.existsSync(path13.join(target, ".codebase-snapshot"));
   } catch {
     return false;
   }
@@ -2714,7 +2715,7 @@ function makeToolOwnedDecider(cwd, toolOwnedPaths) {
       const prefix = parts.slice(0, depth).join("/");
       let hasMarker = markers.get(prefix);
       if (hasMarker === void 0) {
-        hasMarker = fs11.existsSync(path12.join(cwd, prefix, ".codebase-snapshot"));
+        hasMarker = fs12.existsSync(path13.join(cwd, prefix, ".codebase-snapshot"));
         markers.set(prefix, hasMarker);
       }
       if (hasMarker) return true;
@@ -2729,7 +2730,7 @@ function makeLinkProbe() {
     let known = cache.get(absolutePath);
     if (known === void 0) {
       try {
-        known = fs11.lstatSync(absolutePath).isSymbolicLink();
+        known = fs12.lstatSync(absolutePath).isSymbolicLink();
       } catch {
         known = false;
       }
@@ -2742,7 +2743,7 @@ function dropLinkedDirectories(cwd, candidates, skipped) {
   const isLink = makeLinkProbe();
   let rootReal = cwd;
   try {
-    rootReal = fs11.realpathSync(cwd);
+    rootReal = fs12.realpathSync(cwd);
   } catch {
   }
   const reported = /* @__PURE__ */ new Set();
@@ -2752,7 +2753,7 @@ function dropLinkedDirectories(cwd, candidates, skipped) {
     let linkedDir = null;
     for (let depth = 1; depth <= parts.length; depth += 1) {
       const prefix = parts.slice(0, depth).join("/");
-      if (isLink(path12.join(cwd, prefix))) {
+      if (isLink(path13.join(cwd, prefix))) {
         linkedDir = prefix;
         break;
       }
@@ -2763,10 +2764,10 @@ function dropLinkedDirectories(cwd, candidates, skipped) {
     }
     if (reported.has(linkedDir)) continue;
     reported.add(linkedDir);
-    const absolute = path12.join(cwd, linkedDir);
+    const absolute = path13.join(cwd, linkedDir);
     let targetReal = absolute;
     try {
-      targetReal = fs11.realpathSync(absolute);
+      targetReal = fs12.realpathSync(absolute);
     } catch {
     }
     const target = readLinkTarget(absolute, targetReal);
@@ -2843,7 +2844,7 @@ function collectFiles(cwd, options = {}) {
           "Discovery mode is `git`, but git could not list this directory's files. Run inside a working repository, or pass --discovery walk (or auto) to scan the tree directly."
         );
       }
-      if (fs11.existsSync(path12.join(cwd, ".git"))) {
+      if (fs12.existsSync(path13.join(cwd, ".git"))) {
         throw new Error(
           "This directory is a git repository, but git could not list its files. A plain walk honours .gitignore files, but git also applies .git/info/exclude and your global excludes file, includes files that are tracked although a .gitignore now matches them, and treats a submodule as a single entry. Fix the repository (git status should work), run outside git, or pass --discovery walk to accept those differences."
         );
@@ -2902,7 +2903,7 @@ function collectFiles(cwd, options = {}) {
 }
 function rootRealFor(root) {
   try {
-    return fs11.realpathSync(root);
+    return fs12.realpathSync(root);
   } catch {
     return root;
   }
@@ -2910,18 +2911,18 @@ function rootRealFor(root) {
 function walkDirectory(dir, baseDir, rootReal, visited, reservedPaths = /* @__PURE__ */ new Set(), parentGitignoreLayers = []) {
   const results = { files: [], skipped: [] };
   const stack = [];
-  const relativeToBase = (target) => path12.relative(baseDir, target).replace(/\\/g, "/") || ".";
+  const relativeToBase = (target) => path13.relative(baseDir, target).replace(/\\/g, "/") || ".";
   const enter = (current, layers) => {
     if (visited.has(current)) return false;
     visited.add(current);
     const localRules = readGitignoreRules(current);
     const gitignoreLayers = localRules.length === 0 ? layers : [
       ...layers,
-      { prefix: path12.relative(baseDir, current).replace(/\\/g, "/"), rules: localRules }
+      { prefix: path13.relative(baseDir, current).replace(/\\/g, "/"), rules: localRules }
     ];
     let entries;
     try {
-      entries = fs11.readdirSync(current, { withFileTypes: true });
+      entries = fs12.readdirSync(current, { withFileTypes: true });
     } catch {
       results.skipped.push({
         path: relativeToBase(current),
@@ -2943,8 +2944,8 @@ function walkDirectory(dir, baseDir, rootReal, visited, reservedPaths = /* @__PU
     }
     const entry = frame.entries[frame.index];
     frame.index += 1;
-    const fullPath = path12.join(frame.dir, entry.name);
-    const relPath = path12.relative(baseDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path13.join(frame.dir, entry.name);
+    const relPath = path13.relative(baseDir, fullPath).replace(/\\/g, "/");
     if (isToolOwnedDirName(entry.name) && reservedPaths.has(relPath)) continue;
     if (DEFAULT_IGNORED_DIRS.includes(entry.name)) {
       results.skipped.push({
@@ -2977,14 +2978,14 @@ function walkDirectory(dir, baseDir, rootReal, visited, reservedPaths = /* @__PU
     if (entry.isSymbolicLink()) {
       let targetReal;
       try {
-        targetReal = fs11.realpathSync(fullPath);
+        targetReal = fs12.realpathSync(fullPath);
       } catch {
         results.skipped.push({ path: relPath, reason: "read-error", detail: "broken symlink" });
         continue;
       }
       let stats;
       try {
-        stats = fs11.statSync(fullPath);
+        stats = fs12.statSync(fullPath);
       } catch {
         results.skipped.push({ path: relPath, reason: "read-error", detail: "unreadable symlink" });
         continue;
@@ -3039,13 +3040,13 @@ var CONFIG_FILENAMES = [
 ];
 function findConfigFile(cwd) {
   for (const filename of CONFIG_FILENAMES) {
-    const fullPath = path12.join(cwd, filename);
-    if (fs11.existsSync(fullPath)) return fullPath;
+    const fullPath = path13.join(cwd, filename);
+    if (fs12.existsSync(fullPath)) return fullPath;
   }
-  const pkgJsonPath = path12.join(cwd, "package.json");
-  if (!fs11.existsSync(pkgJsonPath)) return null;
+  const pkgJsonPath = path13.join(cwd, "package.json");
+  if (!fs12.existsSync(pkgJsonPath)) return null;
   try {
-    const parsed = JSON.parse(fs11.readFileSync(pkgJsonPath, "utf8"));
+    const parsed = JSON.parse(fs12.readFileSync(pkgJsonPath, "utf8"));
     return parsed.snapshot === void 0 ? null : pkgJsonPath;
   } catch {
     return null;
@@ -3296,11 +3297,11 @@ async function loadConfigFileDetailed(cwd) {
   const warnings = [];
   const errors = [];
   for (const filename of CONFIG_FILENAMES) {
-    const fullPath = path12.join(cwd, filename);
-    if (!fs11.existsSync(fullPath)) continue;
+    const fullPath = path13.join(cwd, filename);
+    if (!fs12.existsSync(fullPath)) continue;
     if (filename.endsWith(".json") || filename === ".snapshotrc") {
       try {
-        const config = parseJsonish(fs11.readFileSync(fullPath, "utf8"), fullPath);
+        const config = parseJsonish(fs12.readFileSync(fullPath, "utf8"), fullPath);
         if (config === null || typeof config !== "object" || Array.isArray(config)) {
           throw new Error(
             `${fullPath} does not hold a configuration object (received ${describeValue2(config)}).`
@@ -3334,10 +3335,10 @@ async function loadConfigFileDetailed(cwd) {
       continue;
     }
   }
-  const pkgJsonPath = path12.join(cwd, "package.json");
-  if (fs11.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path13.join(cwd, "package.json");
+  if (fs12.existsSync(pkgJsonPath)) {
     try {
-      const parsed = parseJsonish(fs11.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
+      const parsed = parseJsonish(fs12.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
       const snapshotKey = parsed.snapshot;
       if (snapshotKey && typeof snapshotKey === "object" && !Array.isArray(snapshotKey)) {
         return { config: snapshotKey, file: pkgJsonPath, warnings, errors };
@@ -3360,7 +3361,7 @@ async function loadConfigFile(cwd) {
   const loaded = await loadConfigFileDetailed(cwd);
   if (loaded.config && loaded.file && typeof loaded.config === "object") {
     Object.defineProperty(loaded.config, CONFIG_DIR_SYMBOL, {
-      value: path12.dirname(loaded.file),
+      value: path13.dirname(loaded.file),
       enumerable: false,
       configurable: true
     });
@@ -3519,9 +3520,9 @@ function resolveKindRules(value) {
 function outputExcludePatterns(cwd, outDir, tmpDir) {
   const patterns = [];
   for (const dir of [outDir, tmpDir]) {
-    const absolute = path12.resolve(cwd, dir);
-    const relative7 = path12.relative(cwd, absolute);
-    if (!relative7 || relative7 === ".." || relative7.startsWith(`..${path12.sep}`) || path12.isAbsolute(relative7)) {
+    const absolute = path13.resolve(cwd, dir);
+    const relative7 = path13.relative(cwd, absolute);
+    if (!relative7 || relative7 === ".." || relative7.startsWith(`..${path13.sep}`) || path13.isAbsolute(relative7)) {
       continue;
     }
     patterns.push(`${relative7.replace(/\\/g, "/")}/**`);
@@ -3640,11 +3641,11 @@ function resolveCandidateCwd(userConfig, cliOptions, baseDir) {
     );
   }
   const candidate = cliOptions?.cwd || userConfig?.cwd || baseDir || process.cwd();
-  const resolved = path12.resolve(candidate);
-  if (!fs11.existsSync(resolved)) {
+  const resolved = path13.resolve(candidate);
+  if (!fs12.existsSync(resolved)) {
     throw new Error(`Working directory does not exist: ${resolved}`);
   }
-  if (!fs11.statSync(resolved).isDirectory()) {
+  if (!fs12.statSync(resolved).isDirectory()) {
     throw new Error(`Working directory is not a directory: ${resolved}`);
   }
   return resolved;
@@ -4668,7 +4669,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".so"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = path12.extname(filePath).toLowerCase();
+  const ext = path13.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -4838,13 +4839,13 @@ function isBinaryFile(absolutePath) {
   if (isBinaryExtension(absolutePath)) return true;
   let fd;
   try {
-    fd = fs11.openSync(absolutePath, "r");
+    fd = fs12.openSync(absolutePath, "r");
     const buffer = Buffer.alloc(CHUNK);
     let sample;
     let position = 0;
     while (position < BINARY_SCAN_BYTES) {
       const wanted = Math.min(CHUNK, BINARY_SCAN_BYTES - position);
-      const bytesRead = fs11.readSync(fd, buffer, 0, wanted, position);
+      const bytesRead = fs12.readSync(fd, buffer, 0, wanted, position);
       if (bytesRead === 0) return false;
       const chunk = buffer.subarray(0, bytesRead);
       if (sample === void 0) {
@@ -4862,7 +4863,7 @@ function isBinaryFile(absolutePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        fs11.closeSync(fd);
+        fs12.closeSync(fd);
       } catch {
       }
     }
@@ -4922,10 +4923,10 @@ var LANGUAGE_BY_BASENAME = {
 };
 function detectLanguage(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const base = path12.posix.basename(normalized);
+  const base = path13.posix.basename(normalized);
   if (LANGUAGE_BY_BASENAME[base]) return LANGUAGE_BY_BASENAME[base];
   if (base === ".env" || base.startsWith(".env.")) return "dotenv";
-  const ext = path12.posix.extname(base).toLowerCase();
+  const ext = path13.posix.extname(base).toLowerCase();
   return LANGUAGE_BY_EXTENSION[ext] ?? "text";
 }
 function maskedPath(value, secretRules) {
@@ -4933,33 +4934,33 @@ function maskedPath(value, secretRules) {
 }
 function confineToDirectory(directory, filename) {
   if (filename.includes("\0")) return null;
-  if (path12.isAbsolute(filename)) return null;
-  const base = path12.resolve(directory);
-  const resolved = path12.resolve(base, filename);
+  if (path13.isAbsolute(filename)) return null;
+  const base = path13.resolve(directory);
+  const resolved = path13.resolve(base, filename);
   const caseInsensitive = process.platform === "win32" || process.platform === "darwin";
-  const prefix = caseInsensitive ? `${base}${path12.sep}`.toLowerCase() : `${base}${path12.sep}`;
+  const prefix = caseInsensitive ? `${base}${path13.sep}`.toLowerCase() : `${base}${path13.sep}`;
   const candidate = caseInsensitive ? resolved.toLowerCase() : resolved;
   return candidate.startsWith(prefix) ? resolved : null;
 }
 function findStagingDirectory(config) {
-  const tmpDir = path12.resolve(config.cwd, config.tmpDir);
+  const tmpDir = path13.resolve(config.cwd, config.tmpDir);
   let entries;
   try {
-    entries = fs11.readdirSync(tmpDir);
+    entries = fs12.readdirSync(tmpDir);
   } catch {
     return null;
   }
   const runs = entries.filter((name) => name.startsWith("run-")).sort();
   const newest = runs[runs.length - 1];
-  return newest ? path12.join(tmpDir, newest) : null;
+  return newest ? path13.join(tmpDir, newest) : null;
 }
 function describeMissingManifest(config, manifestPath) {
-  const outDir = path12.resolve(config.cwd, config.outDir);
-  const markerPath = path12.join(outDir, ".codebase-snapshot");
+  const outDir = path13.resolve(config.cwd, config.outDir);
+  const markerPath = path13.join(outDir, ".codebase-snapshot");
   let marker2 = null;
   try {
-    if (fs11.existsSync(markerPath)) {
-      const parsed = JSON.parse(fs11.readFileSync(markerPath, "utf8"));
+    if (fs12.existsSync(markerPath)) {
+      const parsed = JSON.parse(fs12.readFileSync(markerPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         marker2 = parsed;
       }
@@ -4995,14 +4996,14 @@ function sha256Hex(buffer) {
 }
 var VERIFY_SNIFF_MAX_BYTES = 8 * 1024 * 1024;
 function wouldNowBeIncluded(cwd, relativePath, reason) {
-  const absolutePath = path12.join(cwd, relativePath);
+  const absolutePath = path13.join(cwd, relativePath);
   try {
-    const stats = fs11.statSync(absolutePath);
+    const stats = fs12.statSync(absolutePath);
     if (!stats.isFile()) return false;
     if (isBinaryFile(absolutePath)) return false;
     if (reason !== "binary") return true;
     if (stats.size > VERIFY_SNIFF_MAX_BYTES) return false;
-    return !decodeText(fs11.readFileSync(absolutePath)).binary;
+    return !decodeText(fs12.readFileSync(absolutePath)).binary;
   } catch {
     return false;
   }
@@ -5060,8 +5061,8 @@ function describeManifestShapeProblem(value) {
 function validateSnapshot(configInput) {
   assertUsableConfigInput(configInput);
   const config = isResolvedConfig(configInput) ? normalizeResolvedConfig(configInput) : resolveConfig(configInput);
-  const manifestPath = path12.resolve(config.cwd, config.outDir, "manifest.json");
-  if (!fs11.existsSync(manifestPath)) {
+  const manifestPath = path13.resolve(config.cwd, config.outDir, "manifest.json");
+  if (!fs12.existsSync(manifestPath)) {
     return {
       valid: false,
       manifestPresent: false,
@@ -5072,7 +5073,7 @@ function validateSnapshot(configInput) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs11.readFileSync(manifestPath, "utf8"));
+    manifest = JSON.parse(fs12.readFileSync(manifestPath, "utf8"));
   } catch (err) {
     return {
       valid: false,
@@ -5094,7 +5095,7 @@ function validateSnapshot(configInput) {
   }
   const drift = emptyDrift();
   const warnings = [];
-  const snapshotDir = path12.resolve(config.cwd, config.outDir);
+  const snapshotDir = path13.resolve(config.cwd, config.outDir);
   const manifestFileMap = /* @__PURE__ */ new Map();
   for (const file of manifest.files) {
     if (file && typeof file.relativePath === "string") {
@@ -5128,7 +5129,7 @@ function validateSnapshot(configInput) {
     }
     let diskHash;
     try {
-      diskHash = sha256Hex(fs11.readFileSync(path12.join(config.cwd, diskFile)));
+      diskHash = sha256Hex(fs12.readFileSync(path13.join(config.cwd, diskFile)));
     } catch (err) {
       if (err.code === "ENOENT") {
         drift.missingOnDisk.push(diskFile);
@@ -5152,7 +5153,7 @@ function validateSnapshot(configInput) {
     }
     let statFailure = null;
     try {
-      fs11.statSync(confined);
+      fs12.statSync(confined);
     } catch (err) {
       statFailure = err;
     }
@@ -5172,7 +5173,7 @@ function validateSnapshot(configInput) {
     ...Object.values(config.budgets.byLayer)
   );
   const partNames = /* @__PURE__ */ new Set();
-  const partsDir = path12.join(snapshotDir, "parts");
+  const partsDir = path13.join(snapshotDir, "parts");
   for (const part of manifest.parts) {
     if (!part || typeof part.filename !== "string") continue;
     partNames.add(part.filename);
@@ -5187,7 +5188,7 @@ function validateSnapshot(configInput) {
     }
     let buffer;
     try {
-      buffer = fs11.readFileSync(partPath);
+      buffer = fs12.readFileSync(partPath);
     } catch {
       drift.partIssues.push({ part: part.filename, issue: "missing from snapshot/parts" });
       continue;
@@ -5401,9 +5402,9 @@ function validateSnapshot(configInput) {
     ["full-codebase.md", manifest.artifacts?.fullMarkdown]
   ]) {
     if (!artifact) continue;
-    const artifactPath = path12.join(snapshotDir, key);
+    const artifactPath = path13.join(snapshotDir, key);
     try {
-      const buffer = fs11.readFileSync(artifactPath);
+      const buffer = fs12.readFileSync(artifactPath);
       if (sha256Hex(buffer) !== artifact.sha256 || buffer.length !== artifact.byteSize) {
         drift.partIssues.push({ part: key, issue: "artifact does not match its recorded digest" });
       }
@@ -5473,12 +5474,168 @@ function validateSnapshot(configInput) {
 
 // src/version.ts
 var GENERATOR_NAME = "codebase-snapshot";
-var GENERATOR_VERSION = "0.9.5";
+var GENERATOR_VERSION = "0.9.6";
 var LEGACY_GENERATOR_NAMES = ["@ankurhalder/codebase-snapshot"];
 function isOurGeneratorName(name) {
   if (typeof name !== "string") return false;
   return name === GENERATOR_NAME || LEGACY_GENERATOR_NAMES.includes(name);
 }
+var PACKAGE_LATEST_URL = "https://registry.npmjs.org/codebase-snapshot/latest";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FAILURE_INTERVAL_MS = 60 * 60 * 1e3;
+var REQUEST_TIMEOUT_MS = 1200;
+function versionParts(value) {
+  const core = value.trim().replace(/^v/i, "").split("-")[0];
+  return core.split(".").map((part) => {
+    const parsed = Number(part);
+    return Number.isFinite(parsed) ? parsed : 0;
+  });
+}
+function isNewer(candidate, current) {
+  const left = versionParts(candidate);
+  const right = versionParts(current);
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const a = left[index] ?? 0;
+    const b = right[index] ?? 0;
+    if (a !== b) return a > b;
+  }
+  return false;
+}
+function cacheDirectory(env = process.env, platform = process.platform) {
+  if (platform === "win32") {
+    const base2 = env.LOCALAPPDATA ?? path13.join(os.homedir(), "AppData", "Local");
+    return path13.join(base2, "codebase-snapshot");
+  }
+  if (platform === "darwin") {
+    return path13.join(os.homedir(), "Library", "Caches", "codebase-snapshot");
+  }
+  const base = env.XDG_CACHE_HOME ?? path13.join(os.homedir(), ".cache");
+  return path13.join(base, "codebase-snapshot");
+}
+function cacheFilePath(env = process.env) {
+  return path13.join(cacheDirectory(env), "update-check.json");
+}
+function shouldCheck(argv, env) {
+  const disabled = ["1", "true", "yes"].includes(
+    String(env.CODEBASE_SNAPSHOT_NO_UPDATE_CHECK ?? "").toLowerCase()
+  );
+  if (disabled) return false;
+  if (env.CI !== void 0 && env.CI !== "" && env.CI !== "false" && env.CI !== "0") return false;
+  const args = argv.map((argument) => argument.toLowerCase());
+  if (args.includes("--no-update-check")) return false;
+  for (const skip of ["mcp", "describe", "skill", "--version", "-v", "--help", "-h"]) {
+    if (args.includes(skip)) return false;
+  }
+  if (args.some((argument) => argument.includes("json"))) return false;
+  return true;
+}
+function readCache(file) {
+  let raw;
+  try {
+    raw = fs12.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const candidate = parsed;
+    if (typeof candidate.checkedAt !== "number") return null;
+    const latest = typeof candidate.latest === "string" ? candidate.latest : null;
+    return { checkedAt: candidate.checkedAt, latest };
+  } catch {
+    return null;
+  }
+}
+function writeCache(file, entry) {
+  try {
+    fs12.mkdirSync(path13.dirname(file), { recursive: true });
+    fs12.writeFileSync(file, `${JSON.stringify(entry)}
+`, "utf8");
+  } catch {
+  }
+}
+function fetchLatestVersion(url = PACKAGE_LATEST_URL, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve5) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve5(value);
+    };
+    const request = https.get(
+      url,
+      {
+        headers: {
+          accept: "application/json",
+          "user-agent": "codebase-snapshot (update check)"
+        }
+      },
+      (response) => {
+        if (response.statusCode !== 200) {
+          response.resume();
+          finish(null);
+          return;
+        }
+        let body = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          body += chunk;
+          if (body.length > 64 * 1024) {
+            request.destroy();
+            finish(null);
+          }
+        });
+        response.on("end", () => {
+          try {
+            const parsed = JSON.parse(body);
+            finish(typeof parsed.version === "string" ? parsed.version : null);
+          } catch {
+            finish(null);
+          }
+        });
+      }
+    );
+    request.on("error", () => finish(null));
+    request.setTimeout(timeoutMs, () => {
+      request.destroy();
+      finish(null);
+    });
+  });
+}
+async function checkForUpdate(options) {
+  if (options.enabled === false) return null;
+  const now = options.now ?? (() => Date.now());
+  const fetchLatest = options.fetchLatest ?? fetchLatestVersion;
+  let latest = null;
+  try {
+    const cached = readCache(options.cacheFile);
+    let needsFetch = cached === null;
+    if (cached) {
+      const age = now() - cached.checkedAt;
+      if (cached.latest === null) {
+        needsFetch = age >= FAILURE_INTERVAL_MS;
+      } else {
+        latest = cached.latest;
+        needsFetch = age >= CHECK_INTERVAL_MS;
+      }
+    }
+    if (needsFetch) {
+      const fetched = await fetchLatest(PACKAGE_LATEST_URL, REQUEST_TIMEOUT_MS);
+      writeCache(options.cacheFile, { checkedAt: now(), latest: fetched });
+      latest = fetched;
+    }
+  } catch {
+    return null;
+  }
+  if (!latest) return null;
+  return isNewer(latest, options.current) ? { current: options.current, latest } : null;
+}
+function formatUpdateNotice(notice) {
+  return `\u2191 codebase-snapshot ${notice.latest} is available \u2014 you have ${notice.current}.
+  npm install -g codebase-snapshot`;
+}
 function describeMatcher(matcher) {
   if (typeof matcher === "string") return matcher;
   if (matcher instanceof RegExp) return String(matcher);
@@ -5488,10 +5645,10 @@ function describeMatcher(matcher) {
   return String(matcher);
 }
 function normalizeTarget(cwd, target) {
-  const absolute = path12.resolve(cwd, target);
-  const relative7 = path12.relative(cwd, absolute);
-  if (relative7.startsWith("..") || path12.isAbsolute(relative7)) return target;
-  return relative7.split(path12.sep).join("/");
+  const absolute = path13.resolve(cwd, target);
+  const relative7 = path13.relative(cwd, absolute);
+  if (relative7.startsWith("..") || path13.isAbsolute(relative7)) return target;
+  return relative7.split(path13.sep).join("/");
 }
 function findRuleMatch(rules, relativePath) {
   return rules.find(
@@ -5510,20 +5667,20 @@ function findRecordedAncestor(skipped, relative7, maskedPath2) {
   return nearest;
 }
 function readManifest2(config) {
-  const manifestPath = path12.resolve(config.cwd, config.outDir, "manifest.json");
+  const manifestPath = path13.resolve(config.cwd, config.outDir, "manifest.json");
   try {
-    return JSON.parse(fs11.readFileSync(manifestPath, "utf8"));
+    return JSON.parse(fs12.readFileSync(manifestPath, "utf8"));
   } catch {
     return null;
   }
 }
 function explainPath(config, target) {
   const relative7 = normalizeTarget(config.cwd, target);
-  const absolute = path12.join(config.cwd, relative7);
+  const absolute = path13.join(config.cwd, relative7);
   const maskedPath2 = findSecretInPath(relative7, config.secretRules)?.masked ?? relative7;
   const result = {
     path: maskedPath2,
-    exists: fs11.existsSync(absolute),
+    exists: fs12.existsSync(absolute),
     included: false
   };
   const collection = collectFiles(config.cwd, {
@@ -5534,7 +5691,7 @@ function explainPath(config, target) {
     // Same exclusion `generate` applies, so `explain` never says "not-discovered" about a file
     // that is only missing because the walker dropped the tool's own output directory.
     toolOwnedPaths: [config.outDir, config.tmpDir].map(
-      (directory) => path12.relative(config.cwd, path12.resolve(config.cwd, directory)).replace(/\\/g, "/")
+      (directory) => path13.relative(config.cwd, path13.resolve(config.cwd, directory)).replace(/\\/g, "/")
     ).filter((relative8) => relative8.length > 0 && !relative8.startsWith(".."))
   });
   if (!collection.files.includes(relative7)) {
@@ -5573,8 +5730,8 @@ function explainPath(config, target) {
   if (layerRule) result.layerMatch = describeMatcher(layerRule.match);
   const kindRule = findRuleMatch(config.kinds, relative7);
   if (kindRule) result.kindMatch = describeMatcher(kindRule.match);
-  if (fs11.existsSync(absolute) && fs11.statSync(absolute).isFile()) {
-    const buffer = fs11.readFileSync(absolute);
+  if (fs12.existsSync(absolute) && fs12.statSync(absolute).isFile()) {
+    const buffer = fs12.readFileSync(absolute);
     const decoded = decodeText(buffer);
     if (decoded.binary) {
       result.included = false;
@@ -5822,14 +5979,14 @@ function compareManifests(before, after) {
 function loadManifest(target) {
   let isDirectory;
   try {
-    isDirectory = fs11.statSync(target).isDirectory();
+    isDirectory = fs12.statSync(target).isDirectory();
   } catch {
     throw new Error(`No snapshot found at ${target}: the path does not exist.`);
   }
-  const manifestPath = isDirectory ? path12.join(target, "manifest.json") : target;
+  const manifestPath = isDirectory ? path13.join(target, "manifest.json") : target;
   let raw;
   try {
-    raw = fs11.readFileSync(manifestPath, "utf8");
+    raw = fs12.readFileSync(manifestPath, "utf8");
   } catch {
     throw new Error(`Could not read a manifest at ${manifestPath}.`);
   }
@@ -5886,15 +6043,15 @@ function renderDiffText(diff) {
 function appendGitignoreEntries(cwd, entries) {
   const wanted = [...new Set(entries)].filter((entry) => entry.trim().length > 0);
   if (wanted.length === 0) return { added: [], note: null };
-  const ignorePath = path12.join(cwd, ".gitignore");
+  const ignorePath = path13.join(cwd, ".gitignore");
   const manual = `Add ${wanted.map((entry) => `"${entry}"`).join(" and ")} to your .gitignore yourself.`;
   let existing = "";
   try {
-    if (fs11.existsSync(ignorePath)) {
-      if (fs11.statSync(ignorePath).isDirectory()) {
+    if (fs12.existsSync(ignorePath)) {
+      if (fs12.statSync(ignorePath).isDirectory()) {
         return { added: [], note: `${ignorePath} is a directory, so it was not updated. ${manual}` };
       }
-      existing = fs11.readFileSync(ignorePath, "utf8");
+      existing = fs12.readFileSync(ignorePath, "utf8");
     }
   } catch (err) {
     return {
@@ -5907,7 +6064,7 @@ function appendGitignoreEntries(cwd, entries) {
   if (added.length === 0) return { added: [], note: null };
   const prefix = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
   try {
-    fs11.writeFileSync(ignorePath, `${existing}${prefix}${added.join("\n")}
+    fs12.writeFileSync(ignorePath, `${existing}${prefix}${added.join("\n")}
 `, "utf8");
   } catch (err) {
     return { added: [], note: `${err.message}. ${manual}` };
@@ -5915,7 +6072,7 @@ function appendGitignoreEntries(cwd, entries) {
   return { added, note: null };
 }
 function gitignorePath(cwd, filePath) {
-  return path12.relative(cwd, filePath).split(path12.sep).join("/");
+  return path13.relative(cwd, filePath).split(path13.sep).join("/");
 }
 
 // src/wizard/config-template.ts
@@ -6337,10 +6494,10 @@ var CONFIG_CANDIDATES = [
 ];
 function chooseConfigFileName(cwd) {
   if (!supportsTypeScriptImports()) return "snapshot.config.mjs";
-  const pkgPath = path12.join(cwd, "package.json");
-  if (!fs11.existsSync(pkgPath)) return "snapshot.config.mjs";
+  const pkgPath = path13.join(cwd, "package.json");
+  if (!fs12.existsSync(pkgPath)) return "snapshot.config.mjs";
   try {
-    const parsed = JSON.parse(fs11.readFileSync(pkgPath, "utf8"));
+    const parsed = JSON.parse(fs12.readFileSync(pkgPath, "utf8"));
     return parsed.type === "module" ? "snapshot.config.ts" : "snapshot.config.mjs";
   } catch {
     return "snapshot.config.mjs";
@@ -6354,7 +6511,7 @@ var SIZE_CHOICES = [
 ];
 function packageJsonHasConfig(cwd) {
   try {
-    const parsed = JSON.parse(fs11.readFileSync(path12.join(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(fs12.readFileSync(path13.join(cwd, "package.json"), "utf8"));
     return typeof parsed.snapshot === "object" && parsed.snapshot !== null && !Array.isArray(parsed.snapshot);
   } catch {
     return false;
@@ -6375,7 +6532,7 @@ function artifactAnswers(options) {
 }
 function topLevelDirs(cwd) {
   try {
-    return fs11.readdirSync(cwd, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => entry.name).sort();
+    return fs12.readdirSync(cwd, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => entry.name).sort();
   } catch {
     return [];
   }
@@ -6388,7 +6545,7 @@ function describeJsonValue(value) {
 }
 function writeFileOrExplain(target, content) {
   try {
-    fs11.writeFileSync(target, content, "utf8");
+    fs12.writeFileSync(target, content, "utf8");
   } catch (err) {
     const code = err.code;
     const reason = code === "EACCES" || code === "EPERM" || code === "EROFS" ? `permission denied (${code})` : code === "EISDIR" ? "it is a directory" : `${err.message}`;
@@ -6399,7 +6556,7 @@ function canWriteModuleConfig(name, cwd) {
   if (name.endsWith(".mjs") || name.endsWith(".ts")) return true;
   if (!name.endsWith(".js")) return false;
   try {
-    const parsed = JSON.parse(fs11.readFileSync(path12.join(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(fs12.readFileSync(path13.join(cwd, "package.json"), "utf8"));
     return parsed.type === "module";
   } catch {
     return false;
@@ -6434,19 +6591,19 @@ function serializePackageJson(raw, value) {
   return `${text2}${raw.endsWith("\n") ? crlf ? "\r\n" : "\n" : ""}`;
 }
 function updatePackageJson(cwd, notes) {
-  const packagePath = path12.join(cwd, "package.json");
+  const packagePath = path13.join(cwd, "package.json");
   const unchanged = {
     scripts: [],
     dependency: { name: GENERATOR_NAME, range: null, added: false }
   };
-  if (!fs11.existsSync(packagePath)) {
+  if (!fs12.existsSync(packagePath)) {
     notes.push("No package.json found, so npm scripts and the devDependency were not added.");
     return unchanged;
   }
   let raw;
   let parsed;
   try {
-    raw = fs11.readFileSync(packagePath, "utf8");
+    raw = fs12.readFileSync(packagePath, "utf8");
     parsed = JSON.parse(raw);
   } catch {
     notes.push("Could not parse package.json; npm scripts and the devDependency were not added.");
@@ -6738,7 +6895,7 @@ async function runInit(options) {
   const configText = renderConfig(answers);
   const preferredName = chooseConfigFileName(options.cwd);
   const presentConfigs = CONFIG_CANDIDATES.filter(
-    (name) => fs11.existsSync(path12.join(options.cwd, name))
+    (name) => fs12.existsSync(path13.join(options.cwd, name))
   );
   const present = presentConfigs[0] ?? null;
   if (presentConfigs.length > 1) {
@@ -6747,7 +6904,7 @@ async function runInit(options) {
     );
   }
   const configName = present !== null && options.force ? present : preferredName;
-  const configPath = path12.join(options.cwd, configName);
+  const configPath = path13.join(options.cwd, configName);
   const reused = present !== null && options.force !== true && options.reuseConfig === true;
   if (reused) notes.push(`Kept the existing ${present} instead of writing a new one.`);
   if (options.dryRun) {
@@ -6780,7 +6937,7 @@ async function runInit(options) {
       'package.json already defines a "snapshot" config. Remove that key, or re-run with --force to write a config file that takes precedence over it.'
     );
   }
-  if (fs11.existsSync(configPath) && !options.force && !reused) {
+  if (fs12.existsSync(configPath) && !options.force && !reused) {
     throw new Error(`${configName} already exists. Re-run with --force to replace it.`);
   }
   if (!reused) writeFileOrExplain(configPath, configText);
@@ -6802,9 +6959,9 @@ async function runInit(options) {
   };
 }
 function describeTarget(cwd) {
-  const relative7 = path12.relative(process.cwd(), cwd);
+  const relative7 = path13.relative(process.cwd(), cwd);
   if (relative7 === "") return "this directory";
-  if (relative7.startsWith("..") || path12.isAbsolute(relative7)) return cwd;
+  if (relative7.startsWith("..") || path13.isAbsolute(relative7)) return cwd;
   return relative7;
 }
 function firstRunMessage(reason, cwd) {
@@ -6828,7 +6985,7 @@ function planFirstRun(facts) {
 var NOT_CONTENT = /* @__PURE__ */ new Set([".git", ".hg", ".svn", ".bzr", ".DS_Store", "Thumbs.db"]);
 function isEffectivelyEmpty(cwd) {
   try {
-    return fs11.readdirSync(cwd).every((entry) => NOT_CONTENT.has(entry));
+    return fs12.readdirSync(cwd).every((entry) => NOT_CONTENT.has(entry));
   } catch {
     return false;
   }
@@ -6836,7 +6993,7 @@ function isEffectivelyEmpty(cwd) {
 function hasPriorSnapshot(cwd, outDir) {
   let parsed;
   try {
-    parsed = JSON.parse(fs11.readFileSync(path12.join(cwd, outDir, ".codebase-snapshot"), "utf8"));
+    parsed = JSON.parse(fs12.readFileSync(path13.join(cwd, outDir, ".codebase-snapshot"), "utf8"));
   } catch {
     return false;
   }
@@ -6924,13 +7081,13 @@ function buildImportResolver(files) {
     const relativePath = file.relativePath;
     remember(byPath, relativePath, relativePath);
     remember(byPathFolded, relativePath.toLowerCase(), relativePath);
-    const extension = path12.posix.extname(relativePath);
+    const extension = path13.posix.extname(relativePath);
     if (!SOURCE_EXTENSIONS.has(extension)) continue;
     const stem = relativePath.slice(0, -extension.length);
     remember(byStem, stem, relativePath);
     remember(byStemFolded, stem.toLowerCase(), relativePath);
-    if (path12.posix.basename(stem) === "index") {
-      const directory = path12.posix.dirname(stem);
+    if (path13.posix.basename(stem) === "index") {
+      const directory = path13.posix.dirname(stem);
       remember(byStem, directory, relativePath);
       remember(byStemFolded, directory.toLowerCase(), relativePath);
     }
@@ -6939,8 +7096,8 @@ function buildImportResolver(files) {
 }
 function resolveSpecifier(fromFile, specifier, resolver) {
   if (!RELATIVE_SPECIFIER.test(specifier)) return null;
-  const joined = path12.posix.normalize(
-    path12.posix.join(path12.posix.dirname(fromFile), specifier)
+  const joined = path13.posix.normalize(
+    path13.posix.join(path13.posix.dirname(fromFile), specifier)
   );
   const exact = (key) => resolver.byPath.get(key) ?? resolver.byPathFolded.get(key.toLowerCase()) ?? null;
   const direct = exact(joined);
@@ -7033,11 +7190,11 @@ function verifyInMemory(files, parts, maxPartBytes) {
   return errors;
 }
 function resolveSafeOutputDirs(config) {
-  const cwd = path12.resolve(config.cwd);
-  const outDir = path12.resolve(cwd, config.outDir);
-  const tmpDir = path12.resolve(cwd, config.tmpDir);
-  const root = path12.parse(cwd).root;
-  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path12.sep}`);
+  const cwd = path13.resolve(config.cwd);
+  const outDir = path13.resolve(cwd, config.outDir);
+  const tmpDir = path13.resolve(cwd, config.tmpDir);
+  const root = path13.parse(cwd).root;
+  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path13.sep}`);
   const reject = (reason) => {
     throw new Error(
       `Refusing to generate: ${reason}. outDir=${outDir} tmpDir=${tmpDir} cwd=${cwd}`
@@ -7093,14 +7250,14 @@ function listEntries(dir) {
   const walk = (absolute, prefix) => {
     let children;
     try {
-      children = fs11.readdirSync(absolute, { withFileTypes: true });
+      children = fs12.readdirSync(absolute, { withFileTypes: true });
     } catch {
       return;
     }
     for (const child of children) {
       const relative7 = prefix === "" ? child.name : `${prefix}/${child.name}`;
       entries.push(relative7);
-      if (child.isDirectory()) walk(path12.join(absolute, child.name), relative7);
+      if (child.isDirectory()) walk(path13.join(absolute, child.name), relative7);
     }
   };
   walk(dir, "");
@@ -7117,28 +7274,28 @@ function markerPayload(dir, state, id, createdAt) {
     pid: process.pid,
     entries: listEntries(dir)
   };
-  const manifestPath = path12.join(dir, "manifest.json");
-  if (fs11.existsSync(manifestPath)) {
-    marker2.manifestSha256 = sha256Hex2(fs11.readFileSync(manifestPath));
+  const manifestPath = path13.join(dir, "manifest.json");
+  if (fs12.existsSync(manifestPath)) {
+    marker2.manifestSha256 = sha256Hex2(fs12.readFileSync(manifestPath));
   }
   return marker2;
 }
 function writeOwnershipMarker(dir, marker2) {
-  fs11.writeFileSync(
-    path12.join(dir, OWNERSHIP_MARKER),
+  fs12.writeFileSync(
+    path13.join(dir, OWNERSHIP_MARKER),
     `${JSON.stringify(marker2, null, 2)}
 `,
     "utf8"
   );
 }
 function readOwnershipMarker(dir) {
-  const markerPath = path12.join(dir, OWNERSHIP_MARKER);
-  if (!fs11.existsSync(markerPath)) {
+  const markerPath = path13.join(dir, OWNERSHIP_MARKER);
+  if (!fs12.existsSync(markerPath)) {
     return { marker: null, problem: "it holds no .codebase-snapshot marker" };
   }
   let raw;
   try {
-    raw = fs11.readFileSync(markerPath, "utf8");
+    raw = fs12.readFileSync(markerPath, "utf8");
   } catch {
     return { marker: null, problem: "its .codebase-snapshot marker could not be read" };
   }
@@ -7206,11 +7363,11 @@ function assessSnapshotDirectory(dir) {
       marker: marker2
     };
   }
-  const manifestPath = path12.join(dir, "manifest.json");
-  if (fs11.existsSync(manifestPath)) {
+  const manifestPath = path13.join(dir, "manifest.json");
+  if (fs12.existsSync(manifestPath)) {
     let raw;
     try {
-      raw = fs11.readFileSync(manifestPath, "utf8");
+      raw = fs12.readFileSync(manifestPath, "utf8");
     } catch {
       return {
         owned: false,
@@ -7292,13 +7449,13 @@ function containsNoFiles(dir) {
     const current = pending.pop();
     let entries;
     try {
-      entries = fs11.readdirSync(current, { withFileTypes: true });
+      entries = fs12.readdirSync(current, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        pending.push(path12.join(current, entry.name));
+        pending.push(path13.join(current, entry.name));
       } else if (!IGNORABLE_ENTRIES.has(entry.name)) {
         return false;
       }
@@ -7307,13 +7464,13 @@ function containsNoFiles(dir) {
   return true;
 }
 function assertReplaceable(target, label, secretRules) {
-  if (!fs11.existsSync(target)) return;
-  if (!fs11.statSync(target).isDirectory()) {
+  if (!fs12.existsSync(target)) return;
+  if (!fs12.statSync(target).isDirectory()) {
     throw new Error(
       `Refusing to write into ${label} ${target}: it exists but is not a directory.`
     );
   }
-  const entries = fs11.readdirSync(target);
+  const entries = fs12.readdirSync(target);
   if (entries.length === 0) return;
   if (entries.every((name) => IGNORABLE_ENTRIES.has(name))) return;
   if (containsNoFiles(target)) return;
@@ -7333,18 +7490,18 @@ function assertReplaceable(target, label, secretRules) {
   );
 }
 function assertStagingRootUsable(tmpDir, secretRules) {
-  if (!fs11.existsSync(tmpDir)) return;
-  if (!fs11.statSync(tmpDir).isDirectory()) {
+  if (!fs12.existsSync(tmpDir)) return;
+  if (!fs12.statSync(tmpDir).isDirectory()) {
     throw new Error(`Refusing to write into tmpDir ${tmpDir}: it exists but is not a directory.`);
   }
-  const entries = fs11.readdirSync(tmpDir);
+  const entries = fs12.readdirSync(tmpDir);
   if (entries.length === 0) return;
   const foreign = entries.filter((name) => {
-    const full = path12.join(tmpDir, name);
+    const full = path13.join(tmpDir, name);
     if (!name.startsWith(RUN_DIR_PREFIX)) return true;
     let stats;
     try {
-      stats = fs11.statSync(full);
+      stats = fs12.statSync(full);
     } catch {
       return true;
     }
@@ -7352,7 +7509,7 @@ function assertStagingRootUsable(tmpDir, secretRules) {
     const { marker: marker2 } = readOwnershipMarker(full);
     if (marker2) return false;
     try {
-      return fs11.readdirSync(full).length > 0;
+      return fs12.readdirSync(full).length > 0;
     } catch {
       return true;
     }
@@ -7367,13 +7524,13 @@ function assertStagingRootUsable(tmpDir, secretRules) {
 function cleanStaleRunDirs(tmpDir) {
   let entries;
   try {
-    entries = fs11.readdirSync(tmpDir);
+    entries = fs12.readdirSync(tmpDir);
   } catch {
     return;
   }
   for (const name of entries) {
     if (!name.startsWith(RUN_DIR_PREFIX)) continue;
-    const full = path12.join(tmpDir, name);
+    const full = path13.join(tmpDir, name);
     const { marker: marker2 } = readOwnershipMarker(full);
     if (marker2) {
       const created = Date.parse(marker2.createdAt);
@@ -7381,33 +7538,33 @@ function cleanStaleRunDirs(tmpDir) {
       const abandoned = typeof marker2.pid === "number" && !isProcessAlive(marker2.pid);
       if (aged || abandoned) {
         try {
-          fs11.rmSync(full, { recursive: true, force: true });
+          fs12.rmSync(full, { recursive: true, force: true });
         } catch {
         }
       }
       continue;
     }
     try {
-      if (fs11.readdirSync(full).length === 0) fs11.rmSync(full, { recursive: true, force: true });
+      if (fs12.readdirSync(full).length === 0) fs12.rmSync(full, { recursive: true, force: true });
     } catch {
     }
   }
 }
 function removeIfEmpty(dir) {
   try {
-    if (fs11.readdirSync(dir).length === 0) fs11.rmSync(dir, { recursive: true, force: true });
+    if (fs12.readdirSync(dir).length === 0) fs12.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function ensureParentDirectory(target, label) {
-  const parent = path12.dirname(target);
-  if (fs11.existsSync(parent) && !fs11.statSync(parent).isDirectory()) {
+  const parent = path13.dirname(target);
+  if (fs12.existsSync(parent) && !fs12.statSync(parent).isDirectory()) {
     throw new Error(
       `Refusing to create ${label} ${target}: ${parent} exists but is not a directory.`
     );
   }
   try {
-    fs11.mkdirSync(parent, { recursive: true });
+    fs12.mkdirSync(parent, { recursive: true });
   } catch (err) {
     throw new Error(
       `Refusing to create ${label} ${target}: its parent ${parent} could not be created (${err.message}).`
@@ -7416,7 +7573,7 @@ function ensureParentDirectory(target, label) {
 }
 function acquireRunLock(stagingRoot) {
   const key = lockKeyFor(stagingRoot);
-  const lockPath = path12.join(os.tmpdir(), `codebase-snapshot-${key}.lock`);
+  const lockPath = path13.join(os.tmpdir(), `codebase-snapshot-${key}.lock`);
   const payload = `${JSON.stringify({
     pid: process.pid,
     stagingRoot,
@@ -7425,22 +7582,22 @@ function acquireRunLock(stagingRoot) {
 `;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const handle = fs11.openSync(lockPath, "wx");
+      const handle = fs12.openSync(lockPath, "wx");
       try {
-        fs11.writeSync(handle, payload);
+        fs12.writeSync(handle, payload);
       } finally {
-        fs11.closeSync(handle);
+        fs12.closeSync(handle);
       }
       return () => {
         try {
-          fs11.rmSync(lockPath, { force: true });
+          fs12.rmSync(lockPath, { force: true });
         } catch {
         }
       };
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       if (attempt === 0 && lockOwnerIsGone(lockPath)) {
-        fs11.rmSync(lockPath, { force: true });
+        fs12.rmSync(lockPath, { force: true });
         continue;
       }
       throw new Error(
@@ -7453,7 +7610,7 @@ function acquireRunLock(stagingRoot) {
 function lockKeyFor(stagingRoot) {
   let key = stagingRoot;
   try {
-    key = fs11.realpathSync(stagingRoot);
+    key = fs12.realpathSync(stagingRoot);
   } catch {
   }
   if (process.platform === "win32" || process.platform === "darwin") key = key.toLowerCase();
@@ -7462,7 +7619,7 @@ function lockKeyFor(stagingRoot) {
 function lockOwnerIsGone(lockPath) {
   let raw;
   try {
-    raw = fs11.readFileSync(lockPath, "utf8");
+    raw = fs12.readFileSync(lockPath, "utf8");
   } catch {
     return false;
   }
@@ -7482,12 +7639,12 @@ function lockOwnerIsGone(lockPath) {
 }
 function writeManifestAtomically(manifestPath, manifest) {
   const tempPath = `${manifestPath}.${process.pid}.tmp`;
-  fs11.writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf8");
+  fs12.writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf8");
   try {
-    fs11.renameSync(tempPath, manifestPath);
+    fs12.renameSync(tempPath, manifestPath);
   } catch (err) {
     try {
-      fs11.rmSync(tempPath, { force: true });
+      fs12.rmSync(tempPath, { force: true });
     } catch {
     }
     throw err;
@@ -7510,31 +7667,31 @@ function swapIntoPlace(stagingDir, outDir) {
 }
 function swapOnce(stagingDir, outDir) {
   const backupDir = `${outDir}.backup-${process.pid}-${Date.now()}`;
-  const hadPrevious = fs11.existsSync(outDir);
-  if (hadPrevious) fs11.renameSync(outDir, backupDir);
+  const hadPrevious = fs12.existsSync(outDir);
+  if (hadPrevious) fs12.renameSync(outDir, backupDir);
   try {
     try {
-      fs11.renameSync(stagingDir, outDir);
+      fs12.renameSync(stagingDir, outDir);
     } catch (err) {
       if (err.code !== "EXDEV") throw err;
       const partialDir = `${outDir}.partial-${process.pid}-${Date.now()}`;
       try {
-        fs11.cpSync(stagingDir, partialDir, { recursive: true });
-        fs11.renameSync(partialDir, outDir);
-        fs11.rmSync(stagingDir, { recursive: true, force: true });
+        fs12.cpSync(stagingDir, partialDir, { recursive: true });
+        fs12.renameSync(partialDir, outDir);
+        fs12.rmSync(stagingDir, { recursive: true, force: true });
       } catch (copyErr) {
         try {
-          fs11.rmSync(partialDir, { recursive: true, force: true });
+          fs12.rmSync(partialDir, { recursive: true, force: true });
         } catch {
         }
         throw copyErr;
       }
     }
-    if (hadPrevious) fs11.rmSync(backupDir, { recursive: true, force: true });
+    if (hadPrevious) fs12.rmSync(backupDir, { recursive: true, force: true });
   } catch (err) {
-    if (hadPrevious && fs11.existsSync(backupDir)) {
-      if (fs11.existsSync(outDir)) fs11.rmSync(outDir, { recursive: true, force: true });
-      fs11.renameSync(backupDir, outDir);
+    if (hadPrevious && fs12.existsSync(backupDir)) {
+      if (fs12.existsSync(outDir)) fs12.rmSync(outDir, { recursive: true, force: true });
+      fs12.renameSync(backupDir, outDir);
     }
     throw err;
   }
@@ -7629,7 +7786,7 @@ function generateSnapshot(configInput, options) {
     // first run cannot have marked them yet, so the name alone keeps a run from recording its own
     // output — but only at these exact paths, not at every directory that shares the name.
     toolOwnedPaths: [config.outDir, config.tmpDir].map(
-      (directory) => path12.relative(config.cwd, path12.resolve(config.cwd, directory)).replace(/\\/g, "/")
+      (directory) => path13.relative(config.cwd, path13.resolve(config.cwd, directory)).replace(/\\/g, "/")
     ).filter((relative7) => relative7.length > 0 && !relative7.startsWith(".."))
   });
   const files = [];
@@ -7650,12 +7807,12 @@ function generateSnapshot(configInput, options) {
   let totalSizeBytes = 0;
   let largeFileCount = 0;
   for (const relativePath of collection.files) {
-    const absolutePath = path12.join(config.cwd, relativePath);
+    const absolutePath = path13.join(config.cwd, relativePath);
     let stats;
     try {
-      stats = fs11.statSync(absolutePath);
+      stats = fs12.statSync(absolutePath);
       if (!stats.isFile()) {
-        const nestedRepository = stats.isDirectory() && fs11.existsSync(path12.join(absolutePath, ".git"));
+        const nestedRepository = stats.isDirectory() && fs12.existsSync(path13.join(absolutePath, ".git"));
         skipped.push(
           nestedRepository ? {
             path: relativePath,
@@ -7675,7 +7832,7 @@ function generateSnapshot(configInput, options) {
     }
     let buffer;
     try {
-      buffer = fs11.readFileSync(absolutePath);
+      buffer = fs12.readFileSync(absolutePath);
     } catch {
       skipped.push({ path: relativePath, reason: "read-error" });
       continue;
@@ -8005,12 +8162,12 @@ function generateSnapshot(configInput, options) {
   let stagingDir = null;
   try {
     ensureParentDirectory(outDir, "outDir");
-    fs11.mkdirSync(tmpDir, { recursive: true });
+    fs12.mkdirSync(tmpDir, { recursive: true });
     cleanStaleRunDirs(tmpDir);
     const snapshotId = crypto.randomUUID();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    stagingDir = path12.join(tmpDir, `${RUN_DIR_PREFIX}${process.pid}-${snapshotId.slice(0, 8)}`);
-    fs11.mkdirSync(stagingDir);
+    stagingDir = path13.join(tmpDir, `${RUN_DIR_PREFIX}${process.pid}-${snapshotId.slice(0, 8)}`);
+    fs12.mkdirSync(stagingDir);
     writeOwnershipMarker(stagingDir, {
       generator: GENERATOR_NAME,
       version: GENERATOR_VERSION,
@@ -8020,41 +8177,41 @@ function generateSnapshot(configInput, options) {
       id: snapshotId,
       pid: process.pid
     });
-    const partsDir = path12.join(stagingDir, "parts");
-    const reportsDir = path12.join(stagingDir, "reports");
-    if (artifacts.parts) fs11.mkdirSync(partsDir, { recursive: true });
+    const partsDir = path13.join(stagingDir, "parts");
+    const reportsDir = path13.join(stagingDir, "reports");
+    if (artifacts.parts) fs12.mkdirSync(partsDir, { recursive: true });
     if (artifacts.navigation || artifacts.projectTree || artifacts.audit) {
-      fs11.mkdirSync(reportsDir, { recursive: true });
+      fs12.mkdirSync(reportsDir, { recursive: true });
     }
     if (artifacts.parts) {
       for (const part of parts) {
-        fs11.writeFileSync(path12.join(partsDir, part.filename), part.markdown, "utf8");
+        fs12.writeFileSync(path13.join(partsDir, part.filename), part.markdown, "utf8");
       }
     }
     if (projectTree !== null) {
-      fs11.writeFileSync(path12.join(reportsDir, "project-tree.md"), projectTree, "utf8");
+      fs12.writeFileSync(path13.join(reportsDir, "project-tree.md"), projectTree, "utf8");
     }
     if (artifacts.navigation) {
-      fs11.writeFileSync(path12.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
+      fs12.writeFileSync(path13.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
     }
     if (artifacts.audit) {
-      fs11.writeFileSync(
-        path12.join(reportsDir, "audit.md"),
+      fs12.writeFileSync(
+        path13.join(reportsDir, "audit.md"),
         generateAuditReport(manifest, secretFindings, config.secretRules),
         "utf8"
       );
     }
     if (artifacts.readme) {
-      fs11.writeFileSync(path12.join(stagingDir, "README.md"), generateReadme(manifest, artifacts), "utf8");
+      fs12.writeFileSync(path13.join(stagingDir, "README.md"), generateReadme(manifest, artifacts), "utf8");
     }
     if (artifacts.manifest) {
-      fs11.writeFileSync(path12.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+      fs12.writeFileSync(path13.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
     }
     if (monolithJson !== null) {
-      fs11.writeFileSync(path12.join(stagingDir, "full-codebase.json"), monolithJson, "utf8");
+      fs12.writeFileSync(path13.join(stagingDir, "full-codebase.json"), monolithJson, "utf8");
     }
     if (monolithMarkdown !== null) {
-      fs11.writeFileSync(path12.join(stagingDir, "full-codebase.md"), monolithMarkdown, "utf8");
+      fs12.writeFileSync(path13.join(stagingDir, "full-codebase.md"), monolithMarkdown, "utf8");
     }
     writeOwnershipMarker(stagingDir, markerPayload(stagingDir, "complete", snapshotId, createdAt));
     swapIntoPlace(stagingDir, outDir);
@@ -8063,7 +8220,7 @@ function generateSnapshot(configInput, options) {
     const pendingHook = runAfterGenerate(config, manifest);
     const shipHookState = () => {
       if (artifacts.manifest && manifest.warnings.length !== warningsBeforeHook) {
-        writeManifestAtomically(path12.join(outDir, "manifest.json"), manifest);
+        writeManifestAtomically(path13.join(outDir, "manifest.json"), manifest);
       }
       writeOwnershipMarker(outDir, markerPayload(outDir, "complete", snapshotId, createdAt));
     };
@@ -8086,7 +8243,7 @@ function generateSnapshot(configInput, options) {
   } catch (err) {
     if (stagingDir !== null) {
       try {
-        fs11.rmSync(stagingDir, { recursive: true, force: true });
+        fs12.rmSync(stagingDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -8100,6 +8257,6 @@ async function generateSnapshotAsync(configInput, options) {
   return generateSnapshot(configInput, options);
 }
 
-export { ARTIFACT_NAMES, DEFAULT_ANSWERS, DEFAULT_SECRET_PATTERNS, GENERATOR_NAME, GENERATOR_VERSION, LANGUAGE_PROFILES, MIN_MAX_PART_BYTES, PRESETS, PromptCancelled, SCHEMA_VERSION, anchorForPath, appendGitignoreEntries, assertReplaceable, assertUsableConfigInput, collectFiles, compareManifests, countInvalidUtf8Bytes, countLines, decodeText, defaultIO, defineConfig, describeManifestShapeProblem, detectLanguage, detectPreset, escapeControls, explainPath, fenceForContent, fenceForText, findConfigFile, firstRunMessage, formatNumber, generateProjectTree, generateSnapshot, generateSnapshotAsync, getPreset, gitignorePath, globToRegExp, hasPriorSnapshot, isBinaryBuffer, isBinaryExtension, isBinaryFile, isDiscoveryMode, isEffectivelyEmpty, isInteractive, isResolvedConfig, isSensitivePath, listPresetNames, loadConfigFile, loadConfigFileDetailed, loadManifest, markResolvedConfig, matchRule, matchesExclude, normalizeResolvedConfig, parseByteSize, partitionFiles, planFirstRun, profileForPath, renderConfig, renderDiffText, renderExplainText, renumberParts, resolveConfig, resolveSafeOutputDirs, runInit, scanAndRedactSecrets, stripJsonComments, summarizeJson, summarizeMarkdown, summarizeTypeScriptSource, summarizeWithProfile, supportsTypeScriptImports, truncatePreview, truncateToBytes, unknownPresetMessage, validateSnapshot };
-//# sourceMappingURL=chunk-B336MMNC.js.map
-//# sourceMappingURL=chunk-B336MMNC.js.map
+export { ARTIFACT_NAMES, CHECK_INTERVAL_MS, DEFAULT_ANSWERS, DEFAULT_SECRET_PATTERNS, FAILURE_INTERVAL_MS, GENERATOR_NAME, GENERATOR_VERSION, LANGUAGE_PROFILES, MIN_MAX_PART_BYTES, PACKAGE_LATEST_URL, PRESETS, PromptCancelled, REQUEST_TIMEOUT_MS, SCHEMA_VERSION, anchorForPath, appendGitignoreEntries, assertReplaceable, assertUsableConfigInput, cacheDirectory, cacheFilePath, checkForUpdate, collectFiles, compareManifests, countInvalidUtf8Bytes, countLines, decodeText, defaultIO, defineConfig, describeManifestShapeProblem, detectLanguage, detectPreset, escapeControls, explainPath, fenceForContent, fenceForText, fetchLatestVersion, findConfigFile, firstRunMessage, formatNumber, formatUpdateNotice, generateProjectTree, generateSnapshot, generateSnapshotAsync, getPreset, gitignorePath, globToRegExp, hasPriorSnapshot, isBinaryBuffer, isBinaryExtension, isBinaryFile, isDiscoveryMode, isEffectivelyEmpty, isInteractive, isNewer, isResolvedConfig, isSensitivePath, listPresetNames, loadConfigFile, loadConfigFileDetailed, loadManifest, markResolvedConfig, matchRule, matchesExclude, normalizeResolvedConfig, parseByteSize, partitionFiles, planFirstRun, profileForPath, renderConfig, renderDiffText, renderExplainText, renumberParts, resolveConfig, resolveSafeOutputDirs, runInit, scanAndRedactSecrets, shouldCheck, stripJsonComments, summarizeJson, summarizeMarkdown, summarizeTypeScriptSource, summarizeWithProfile, supportsTypeScriptImports, truncatePreview, truncateToBytes, unknownPresetMessage, validateSnapshot };
+//# sourceMappingURL=chunk-3KUL3QRH.js.map
+//# sourceMappingURL=chunk-3KUL3QRH.js.map