codebase-snapshot 0.9.4 → 0.9.6

package/dist/index.cjs

@@ -2,13 +2,14 @@
 
 var crypto = require('crypto');
 var async_hooks = require('async_hooks');
-var fs11 = require('fs');
+var fs12 = require('fs');
 var os = require('os');
-var path12 = require('path');
+var path13 = require('path');
 var ts = require('typescript');
 var module$1 = require('module');
 var url = require('url');
 var childProcess = require('child_process');
+var https = require('https');
 var readline = require('readline');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -32,11 +33,12 @@ function _interopNamespace(e) {
 }
 
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
-var fs11__namespace = /*#__PURE__*/_interopNamespace(fs11);
+var fs12__namespace = /*#__PURE__*/_interopNamespace(fs12);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var path12__namespace = /*#__PURE__*/_interopNamespace(path12);
+var path13__namespace = /*#__PURE__*/_interopNamespace(path13);
 var ts__default = /*#__PURE__*/_interopDefault(ts);
 var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
+var https__namespace = /*#__PURE__*/_interopNamespace(https);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
 // src/index.ts
@@ -263,9 +265,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) => {
@@ -718,16 +720,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]}
 `;
@@ -736,7 +738,7 @@ var sfcProfile = {
       script += `${match[1]}
 `;
     }
-    const name = componentName(path13);
+    const name = componentName(path14);
     if (!script.trim()) {
       const summary2 = emptySummary();
       if (name) {
@@ -770,15 +772,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
@@ -949,15 +951,15 @@ var SKIPPED_WALK_DIRS = /* @__PURE__ */ new Set([
 ]);
 function readSmallFile(fullPath) {
   try {
-    const stats = fs11__namespace.statSync(fullPath);
+    const stats = fs12__namespace.statSync(fullPath);
     if (!stats.isFile() || stats.size > MANIFEST_MAX_BYTES) return null;
-    return fs11__namespace.readFileSync(fullPath, "utf8");
+    return fs12__namespace.readFileSync(fullPath, "utf8");
   } catch {
     return null;
   }
 }
 function readManifest(cwd, name) {
-  return readSmallFile(path12__namespace.join(cwd, name));
+  return readSmallFile(path13__namespace.join(cwd, name));
 }
 function dependenciesFromPackageJson(raw) {
   const names = /* @__PURE__ */ new Set();
@@ -1017,7 +1019,7 @@ function pnpmWorkspacePatterns(raw) {
 function childDirectories(cwd, parent) {
   let entries;
   try {
-    entries = fs11__namespace.readdirSync(path12__namespace.join(cwd, parent), { withFileTypes: true });
+    entries = fs12__namespace.readdirSync(path13__namespace.join(cwd, parent), { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1053,12 +1055,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__namespace.join(cwd, relative7);
+    const full = path13__namespace.join(cwd, relative7);
     try {
-      for (const entry of fs11__namespace.readdirSync(full, { withFileTypes: true })) files.add(entry.name);
+      for (const entry of fs12__namespace.readdirSync(full, { withFileTypes: true })) files.add(entry.name);
     } catch {
     }
-    const raw = readSmallFile(path12__namespace.join(full, "package.json"));
+    const raw = readSmallFile(path13__namespace.join(full, "package.json"));
     if (raw !== null) {
       for (const name of dependenciesFromPackageJson(raw)) dependencies.add(name);
     }
@@ -1075,7 +1077,7 @@ function countMarkdownFiles(cwd) {
     directoriesSeen += 1;
     let entries;
     try {
-      entries = fs11__namespace.readdirSync(current.dir, { withFileTypes: true });
+      entries = fs12__namespace.readdirSync(current.dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -1086,7 +1088,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__namespace.join(current.dir, entry.name), depth: current.depth + 1 });
+      queue.push({ dir: path13__namespace.join(current.dir, entry.name), depth: current.depth + 1 });
     }
   }
   return count;
@@ -1095,7 +1097,7 @@ function buildPresetContext(cwd) {
   const files = /* @__PURE__ */ new Set();
   const dirs = /* @__PURE__ */ new Set();
   try {
-    for (const entry of fs11__namespace.readdirSync(cwd, { withFileTypes: true })) {
+    for (const entry of fs12__namespace.readdirSync(cwd, { withFileTypes: true })) {
       if (entry.isDirectory()) dirs.add(entry.name);
       else if (entry.isFile()) files.add(entry.name);
     }
@@ -1112,7 +1114,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__namespace.join(cwd, "pnpm-workspace.yaml")) : null;
+    const pnpmRaw = files.has("pnpm-workspace.yaml") ? readSmallFile(path13__namespace.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);
@@ -2387,14 +2389,14 @@ var PRESET_IGNORES = new Set(
 );
 function readLinkTarget(linkPath, fallback) {
   try {
-    return fs11__namespace.readlinkSync(linkPath);
+    return fs12__namespace.readlinkSync(linkPath);
   } catch {
     return fallback;
   }
 }
 function isInside(root, candidate) {
-  const relative7 = path12__namespace.relative(root, candidate);
-  return relative7 === "" || !relative7.startsWith(`..${path12__namespace.sep}`) && relative7 !== ".." && !path12__namespace.isAbsolute(relative7);
+  const relative7 = path13__namespace.relative(root, candidate);
+  return relative7 === "" || !relative7.startsWith(`..${path13__namespace.sep}`) && relative7 !== ".." && !path13__namespace.isAbsolute(relative7);
 }
 function getGitInfo(cwd, fallbackBranch = "main") {
   try {
@@ -2599,10 +2601,10 @@ function trimUnescapedTrailingSpaces(line) {
   return line.slice(0, end);
 }
 function readGitignoreRules(dir) {
-  const gitignorePath = path12__namespace.join(dir, ".gitignore");
+  const gitignorePath = path13__namespace.join(dir, ".gitignore");
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(gitignorePath, "utf8");
+    raw = fs12__namespace.readFileSync(gitignorePath, "utf8");
   } catch {
     return [];
   }
@@ -2729,7 +2731,7 @@ function isToolOwnedDirName(name) {
 }
 function hasSnapshotMarker(target) {
   try {
-    return fs11__namespace.statSync(target).isDirectory() && fs11__namespace.existsSync(path12__namespace.join(target, ".codebase-snapshot"));
+    return fs12__namespace.statSync(target).isDirectory() && fs12__namespace.existsSync(path13__namespace.join(target, ".codebase-snapshot"));
   } catch {
     return false;
   }
@@ -2743,7 +2745,7 @@ function makeToolOwnedDecider(cwd, toolOwnedPaths) {
       const prefix = parts.slice(0, depth).join("/");
       let hasMarker = markers.get(prefix);
       if (hasMarker === void 0) {
-        hasMarker = fs11__namespace.existsSync(path12__namespace.join(cwd, prefix, ".codebase-snapshot"));
+        hasMarker = fs12__namespace.existsSync(path13__namespace.join(cwd, prefix, ".codebase-snapshot"));
         markers.set(prefix, hasMarker);
       }
       if (hasMarker) return true;
@@ -2758,7 +2760,7 @@ function makeLinkProbe() {
     let known = cache.get(absolutePath);
     if (known === void 0) {
       try {
-        known = fs11__namespace.lstatSync(absolutePath).isSymbolicLink();
+        known = fs12__namespace.lstatSync(absolutePath).isSymbolicLink();
       } catch {
         known = false;
       }
@@ -2771,7 +2773,7 @@ function dropLinkedDirectories(cwd, candidates, skipped) {
   const isLink = makeLinkProbe();
   let rootReal = cwd;
   try {
-    rootReal = fs11__namespace.realpathSync(cwd);
+    rootReal = fs12__namespace.realpathSync(cwd);
   } catch {
   }
   const reported = /* @__PURE__ */ new Set();
@@ -2781,7 +2783,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__namespace.join(cwd, prefix))) {
+      if (isLink(path13__namespace.join(cwd, prefix))) {
         linkedDir = prefix;
         break;
       }
@@ -2792,10 +2794,10 @@ function dropLinkedDirectories(cwd, candidates, skipped) {
     }
     if (reported.has(linkedDir)) continue;
     reported.add(linkedDir);
-    const absolute = path12__namespace.join(cwd, linkedDir);
+    const absolute = path13__namespace.join(cwd, linkedDir);
     let targetReal = absolute;
     try {
-      targetReal = fs11__namespace.realpathSync(absolute);
+      targetReal = fs12__namespace.realpathSync(absolute);
     } catch {
     }
     const target = readLinkTarget(absolute, targetReal);
@@ -2872,7 +2874,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__namespace.existsSync(path12__namespace.join(cwd, ".git"))) {
+      if (fs12__namespace.existsSync(path13__namespace.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."
         );
@@ -2931,7 +2933,7 @@ function collectFiles(cwd, options = {}) {
 }
 function rootRealFor(root) {
   try {
-    return fs11__namespace.realpathSync(root);
+    return fs12__namespace.realpathSync(root);
   } catch {
     return root;
   }
@@ -2939,18 +2941,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__namespace.relative(baseDir, target).replace(/\\/g, "/") || ".";
+  const relativeToBase = (target) => path13__namespace.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__namespace.relative(baseDir, current).replace(/\\/g, "/"), rules: localRules }
+      { prefix: path13__namespace.relative(baseDir, current).replace(/\\/g, "/"), rules: localRules }
     ];
     let entries;
     try {
-      entries = fs11__namespace.readdirSync(current, { withFileTypes: true });
+      entries = fs12__namespace.readdirSync(current, { withFileTypes: true });
     } catch {
       results.skipped.push({
         path: relativeToBase(current),
@@ -2972,8 +2974,8 @@ function walkDirectory(dir, baseDir, rootReal, visited, reservedPaths = /* @__PU
     }
     const entry = frame.entries[frame.index];
     frame.index += 1;
-    const fullPath = path12__namespace.join(frame.dir, entry.name);
-    const relPath = path12__namespace.relative(baseDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path13__namespace.join(frame.dir, entry.name);
+    const relPath = path13__namespace.relative(baseDir, fullPath).replace(/\\/g, "/");
     if (isToolOwnedDirName(entry.name) && reservedPaths.has(relPath)) continue;
     if (DEFAULT_IGNORED_DIRS.includes(entry.name)) {
       results.skipped.push({
@@ -3006,14 +3008,14 @@ function walkDirectory(dir, baseDir, rootReal, visited, reservedPaths = /* @__PU
     if (entry.isSymbolicLink()) {
       let targetReal;
       try {
-        targetReal = fs11__namespace.realpathSync(fullPath);
+        targetReal = fs12__namespace.realpathSync(fullPath);
       } catch {
         results.skipped.push({ path: relPath, reason: "read-error", detail: "broken symlink" });
         continue;
       }
       let stats;
       try {
-        stats = fs11__namespace.statSync(fullPath);
+        stats = fs12__namespace.statSync(fullPath);
       } catch {
         results.skipped.push({ path: relPath, reason: "read-error", detail: "unreadable symlink" });
         continue;
@@ -3311,11 +3313,11 @@ async function loadConfigFileDetailed(cwd) {
   const warnings = [];
   const errors = [];
   for (const filename of CONFIG_FILENAMES) {
-    const fullPath = path12__namespace.join(cwd, filename);
-    if (!fs11__namespace.existsSync(fullPath)) continue;
+    const fullPath = path13__namespace.join(cwd, filename);
+    if (!fs12__namespace.existsSync(fullPath)) continue;
     if (filename.endsWith(".json") || filename === ".snapshotrc") {
       try {
-        const config = parseJsonish(fs11__namespace.readFileSync(fullPath, "utf8"), fullPath);
+        const config = parseJsonish(fs12__namespace.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)}).`
@@ -3349,10 +3351,10 @@ async function loadConfigFileDetailed(cwd) {
       continue;
     }
   }
-  const pkgJsonPath = path12__namespace.join(cwd, "package.json");
-  if (fs11__namespace.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path13__namespace.join(cwd, "package.json");
+  if (fs12__namespace.existsSync(pkgJsonPath)) {
     try {
-      const parsed = parseJsonish(fs11__namespace.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
+      const parsed = parseJsonish(fs12__namespace.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
       const snapshotKey = parsed.snapshot;
       if (snapshotKey && typeof snapshotKey === "object" && !Array.isArray(snapshotKey)) {
         return { config: snapshotKey, file: pkgJsonPath, warnings, errors };
@@ -3375,7 +3377,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__namespace.dirname(loaded.file),
+      value: path13__namespace.dirname(loaded.file),
       enumerable: false,
       configurable: true
     });
@@ -3534,9 +3536,9 @@ function resolveKindRules(value) {
 function outputExcludePatterns(cwd, outDir, tmpDir) {
   const patterns = [];
   for (const dir of [outDir, tmpDir]) {
-    const absolute = path12__namespace.resolve(cwd, dir);
-    const relative7 = path12__namespace.relative(cwd, absolute);
-    if (!relative7 || relative7 === ".." || relative7.startsWith(`..${path12__namespace.sep}`) || path12__namespace.isAbsolute(relative7)) {
+    const absolute = path13__namespace.resolve(cwd, dir);
+    const relative7 = path13__namespace.relative(cwd, absolute);
+    if (!relative7 || relative7 === ".." || relative7.startsWith(`..${path13__namespace.sep}`) || path13__namespace.isAbsolute(relative7)) {
       continue;
     }
     patterns.push(`${relative7.replace(/\\/g, "/")}/**`);
@@ -3655,11 +3657,11 @@ function resolveCandidateCwd(userConfig, cliOptions, baseDir) {
     );
   }
   const candidate = cliOptions?.cwd || userConfig?.cwd || baseDir || process.cwd();
-  const resolved = path12__namespace.resolve(candidate);
-  if (!fs11__namespace.existsSync(resolved)) {
+  const resolved = path13__namespace.resolve(candidate);
+  if (!fs12__namespace.existsSync(resolved)) {
     throw new Error(`Working directory does not exist: ${resolved}`);
   }
-  if (!fs11__namespace.statSync(resolved).isDirectory()) {
+  if (!fs12__namespace.statSync(resolved).isDirectory()) {
     throw new Error(`Working directory is not a directory: ${resolved}`);
   }
   return resolved;
@@ -4683,7 +4685,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".so"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = path12__namespace.extname(filePath).toLowerCase();
+  const ext = path13__namespace.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -4853,13 +4855,13 @@ function isBinaryFile(absolutePath) {
   if (isBinaryExtension(absolutePath)) return true;
   let fd;
   try {
-    fd = fs11__namespace.openSync(absolutePath, "r");
+    fd = fs12__namespace.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__namespace.readSync(fd, buffer, 0, wanted, position);
+      const bytesRead = fs12__namespace.readSync(fd, buffer, 0, wanted, position);
       if (bytesRead === 0) return false;
       const chunk = buffer.subarray(0, bytesRead);
       if (sample === void 0) {
@@ -4877,7 +4879,7 @@ function isBinaryFile(absolutePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        fs11__namespace.closeSync(fd);
+        fs12__namespace.closeSync(fd);
       } catch {
       }
     }
@@ -4937,10 +4939,10 @@ var LANGUAGE_BY_BASENAME = {
 };
 function detectLanguage(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const base = path12__namespace.posix.basename(normalized);
+  const base = path13__namespace.posix.basename(normalized);
   if (LANGUAGE_BY_BASENAME[base]) return LANGUAGE_BY_BASENAME[base];
   if (base === ".env" || base.startsWith(".env.")) return "dotenv";
-  const ext = path12__namespace.posix.extname(base).toLowerCase();
+  const ext = path13__namespace.posix.extname(base).toLowerCase();
   return LANGUAGE_BY_EXTENSION[ext] ?? "text";
 }
 function maskedPath(value, secretRules) {
@@ -4948,33 +4950,33 @@ function maskedPath(value, secretRules) {
 }
 function confineToDirectory(directory, filename) {
   if (filename.includes("\0")) return null;
-  if (path12__namespace.isAbsolute(filename)) return null;
-  const base = path12__namespace.resolve(directory);
-  const resolved = path12__namespace.resolve(base, filename);
+  if (path13__namespace.isAbsolute(filename)) return null;
+  const base = path13__namespace.resolve(directory);
+  const resolved = path13__namespace.resolve(base, filename);
   const caseInsensitive = process.platform === "win32" || process.platform === "darwin";
-  const prefix = caseInsensitive ? `${base}${path12__namespace.sep}`.toLowerCase() : `${base}${path12__namespace.sep}`;
+  const prefix = caseInsensitive ? `${base}${path13__namespace.sep}`.toLowerCase() : `${base}${path13__namespace.sep}`;
   const candidate = caseInsensitive ? resolved.toLowerCase() : resolved;
   return candidate.startsWith(prefix) ? resolved : null;
 }
 function findStagingDirectory(config) {
-  const tmpDir = path12__namespace.resolve(config.cwd, config.tmpDir);
+  const tmpDir = path13__namespace.resolve(config.cwd, config.tmpDir);
   let entries;
   try {
-    entries = fs11__namespace.readdirSync(tmpDir);
+    entries = fs12__namespace.readdirSync(tmpDir);
   } catch {
     return null;
   }
   const runs = entries.filter((name) => name.startsWith("run-")).sort();
   const newest = runs[runs.length - 1];
-  return newest ? path12__namespace.join(tmpDir, newest) : null;
+  return newest ? path13__namespace.join(tmpDir, newest) : null;
 }
 function describeMissingManifest(config, manifestPath) {
-  const outDir = path12__namespace.resolve(config.cwd, config.outDir);
-  const markerPath = path12__namespace.join(outDir, ".codebase-snapshot");
+  const outDir = path13__namespace.resolve(config.cwd, config.outDir);
+  const markerPath = path13__namespace.join(outDir, ".codebase-snapshot");
   let marker2 = null;
   try {
-    if (fs11__namespace.existsSync(markerPath)) {
-      const parsed = JSON.parse(fs11__namespace.readFileSync(markerPath, "utf8"));
+    if (fs12__namespace.existsSync(markerPath)) {
+      const parsed = JSON.parse(fs12__namespace.readFileSync(markerPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         marker2 = parsed;
       }
@@ -5010,14 +5012,14 @@ function sha256Hex(buffer) {
 }
 var VERIFY_SNIFF_MAX_BYTES = 8 * 1024 * 1024;
 function wouldNowBeIncluded(cwd, relativePath, reason) {
-  const absolutePath = path12__namespace.join(cwd, relativePath);
+  const absolutePath = path13__namespace.join(cwd, relativePath);
   try {
-    const stats = fs11__namespace.statSync(absolutePath);
+    const stats = fs12__namespace.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__namespace.readFileSync(absolutePath)).binary;
+    return !decodeText(fs12__namespace.readFileSync(absolutePath)).binary;
   } catch {
     return false;
   }
@@ -5075,8 +5077,8 @@ function describeManifestShapeProblem(value) {
 function validateSnapshot(configInput) {
   assertUsableConfigInput(configInput);
   const config = isResolvedConfig(configInput) ? normalizeResolvedConfig(configInput) : resolveConfig(configInput);
-  const manifestPath = path12__namespace.resolve(config.cwd, config.outDir, "manifest.json");
-  if (!fs11__namespace.existsSync(manifestPath)) {
+  const manifestPath = path13__namespace.resolve(config.cwd, config.outDir, "manifest.json");
+  if (!fs12__namespace.existsSync(manifestPath)) {
     return {
       valid: false,
       manifestPresent: false,
@@ -5087,7 +5089,7 @@ function validateSnapshot(configInput) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs11__namespace.readFileSync(manifestPath, "utf8"));
+    manifest = JSON.parse(fs12__namespace.readFileSync(manifestPath, "utf8"));
   } catch (err) {
     return {
       valid: false,
@@ -5109,7 +5111,7 @@ function validateSnapshot(configInput) {
   }
   const drift = emptyDrift();
   const warnings = [];
-  const snapshotDir = path12__namespace.resolve(config.cwd, config.outDir);
+  const snapshotDir = path13__namespace.resolve(config.cwd, config.outDir);
   const manifestFileMap = /* @__PURE__ */ new Map();
   for (const file of manifest.files) {
     if (file && typeof file.relativePath === "string") {
@@ -5143,7 +5145,7 @@ function validateSnapshot(configInput) {
     }
     let diskHash;
     try {
-      diskHash = sha256Hex(fs11__namespace.readFileSync(path12__namespace.join(config.cwd, diskFile)));
+      diskHash = sha256Hex(fs12__namespace.readFileSync(path13__namespace.join(config.cwd, diskFile)));
     } catch (err) {
       if (err.code === "ENOENT") {
         drift.missingOnDisk.push(diskFile);
@@ -5167,7 +5169,7 @@ function validateSnapshot(configInput) {
     }
     let statFailure = null;
     try {
-      fs11__namespace.statSync(confined);
+      fs12__namespace.statSync(confined);
     } catch (err) {
       statFailure = err;
     }
@@ -5187,7 +5189,7 @@ function validateSnapshot(configInput) {
     ...Object.values(config.budgets.byLayer)
   );
   const partNames = /* @__PURE__ */ new Set();
-  const partsDir = path12__namespace.join(snapshotDir, "parts");
+  const partsDir = path13__namespace.join(snapshotDir, "parts");
   for (const part of manifest.parts) {
     if (!part || typeof part.filename !== "string") continue;
     partNames.add(part.filename);
@@ -5202,7 +5204,7 @@ function validateSnapshot(configInput) {
     }
     let buffer;
     try {
-      buffer = fs11__namespace.readFileSync(partPath);
+      buffer = fs12__namespace.readFileSync(partPath);
     } catch {
       drift.partIssues.push({ part: part.filename, issue: "missing from snapshot/parts" });
       continue;
@@ -5416,9 +5418,9 @@ function validateSnapshot(configInput) {
     ["full-codebase.md", manifest.artifacts?.fullMarkdown]
   ]) {
     if (!artifact) continue;
-    const artifactPath = path12__namespace.join(snapshotDir, key);
+    const artifactPath = path13__namespace.join(snapshotDir, key);
     try {
-      const buffer = fs11__namespace.readFileSync(artifactPath);
+      const buffer = fs12__namespace.readFileSync(artifactPath);
       if (sha256Hex(buffer) !== artifact.sha256 || buffer.length !== artifact.byteSize) {
         drift.partIssues.push({ part: key, issue: "artifact does not match its recorded digest" });
       }
@@ -5488,12 +5490,168 @@ function validateSnapshot(configInput) {
 
 // src/version.ts
 var GENERATOR_NAME = "codebase-snapshot";
-var GENERATOR_VERSION = "0.9.4";
+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__namespace.join(os__namespace.homedir(), "AppData", "Local");
+    return path13__namespace.join(base2, "codebase-snapshot");
+  }
+  if (platform === "darwin") {
+    return path13__namespace.join(os__namespace.homedir(), "Library", "Caches", "codebase-snapshot");
+  }
+  const base = env.XDG_CACHE_HOME ?? path13__namespace.join(os__namespace.homedir(), ".cache");
+  return path13__namespace.join(base, "codebase-snapshot");
+}
+function cacheFilePath(env = process.env) {
+  return path13__namespace.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__namespace.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__namespace.mkdirSync(path13__namespace.dirname(file), { recursive: true });
+    fs12__namespace.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__namespace.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);
@@ -5503,10 +5661,10 @@ function describeMatcher(matcher) {
   return String(matcher);
 }
 function normalizeTarget(cwd, target) {
-  const absolute = path12__namespace.resolve(cwd, target);
-  const relative7 = path12__namespace.relative(cwd, absolute);
-  if (relative7.startsWith("..") || path12__namespace.isAbsolute(relative7)) return target;
-  return relative7.split(path12__namespace.sep).join("/");
+  const absolute = path13__namespace.resolve(cwd, target);
+  const relative7 = path13__namespace.relative(cwd, absolute);
+  if (relative7.startsWith("..") || path13__namespace.isAbsolute(relative7)) return target;
+  return relative7.split(path13__namespace.sep).join("/");
 }
 function findRuleMatch(rules, relativePath) {
   return rules.find(
@@ -5525,20 +5683,20 @@ function findRecordedAncestor(skipped, relative7, maskedPath2) {
   return nearest;
 }
 function readManifest2(config) {
-  const manifestPath = path12__namespace.resolve(config.cwd, config.outDir, "manifest.json");
+  const manifestPath = path13__namespace.resolve(config.cwd, config.outDir, "manifest.json");
   try {
-    return JSON.parse(fs11__namespace.readFileSync(manifestPath, "utf8"));
+    return JSON.parse(fs12__namespace.readFileSync(manifestPath, "utf8"));
   } catch {
     return null;
   }
 }
 function explainPath(config, target) {
   const relative7 = normalizeTarget(config.cwd, target);
-  const absolute = path12__namespace.join(config.cwd, relative7);
+  const absolute = path13__namespace.join(config.cwd, relative7);
   const maskedPath2 = findSecretInPath(relative7, config.secretRules)?.masked ?? relative7;
   const result = {
     path: maskedPath2,
-    exists: fs11__namespace.existsSync(absolute),
+    exists: fs12__namespace.existsSync(absolute),
     included: false
   };
   const collection = collectFiles(config.cwd, {
@@ -5549,7 +5707,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__namespace.relative(config.cwd, path12__namespace.resolve(config.cwd, directory)).replace(/\\/g, "/")
+      (directory) => path13__namespace.relative(config.cwd, path13__namespace.resolve(config.cwd, directory)).replace(/\\/g, "/")
     ).filter((relative8) => relative8.length > 0 && !relative8.startsWith(".."))
   });
   if (!collection.files.includes(relative7)) {
@@ -5588,8 +5746,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__namespace.existsSync(absolute) && fs11__namespace.statSync(absolute).isFile()) {
-    const buffer = fs11__namespace.readFileSync(absolute);
+  if (fs12__namespace.existsSync(absolute) && fs12__namespace.statSync(absolute).isFile()) {
+    const buffer = fs12__namespace.readFileSync(absolute);
     const decoded = decodeText(buffer);
     if (decoded.binary) {
       result.included = false;
@@ -5837,14 +5995,14 @@ function compareManifests(before, after) {
 function loadManifest(target) {
   let isDirectory;
   try {
-    isDirectory = fs11__namespace.statSync(target).isDirectory();
+    isDirectory = fs12__namespace.statSync(target).isDirectory();
   } catch {
     throw new Error(`No snapshot found at ${target}: the path does not exist.`);
   }
-  const manifestPath = isDirectory ? path12__namespace.join(target, "manifest.json") : target;
+  const manifestPath = isDirectory ? path13__namespace.join(target, "manifest.json") : target;
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(manifestPath, "utf8");
+    raw = fs12__namespace.readFileSync(manifestPath, "utf8");
   } catch {
     throw new Error(`Could not read a manifest at ${manifestPath}.`);
   }
@@ -5901,15 +6059,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__namespace.join(cwd, ".gitignore");
+  const ignorePath = path13__namespace.join(cwd, ".gitignore");
   const manual = `Add ${wanted.map((entry) => `"${entry}"`).join(" and ")} to your .gitignore yourself.`;
   let existing = "";
   try {
-    if (fs11__namespace.existsSync(ignorePath)) {
-      if (fs11__namespace.statSync(ignorePath).isDirectory()) {
+    if (fs12__namespace.existsSync(ignorePath)) {
+      if (fs12__namespace.statSync(ignorePath).isDirectory()) {
         return { added: [], note: `${ignorePath} is a directory, so it was not updated. ${manual}` };
       }
-      existing = fs11__namespace.readFileSync(ignorePath, "utf8");
+      existing = fs12__namespace.readFileSync(ignorePath, "utf8");
     }
   } catch (err) {
     return {
@@ -5922,7 +6080,7 @@ function appendGitignoreEntries(cwd, entries) {
   if (added.length === 0) return { added: [], note: null };
   const prefix = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
   try {
-    fs11__namespace.writeFileSync(ignorePath, `${existing}${prefix}${added.join("\n")}
+    fs12__namespace.writeFileSync(ignorePath, `${existing}${prefix}${added.join("\n")}
 `, "utf8");
   } catch (err) {
     return { added: [], note: `${err.message}. ${manual}` };
@@ -6061,6 +6219,12 @@ var PromptCancelled = class extends Error {
     this.name = "PromptCancelled";
   }
 };
+var PromptBack = class extends Error {
+  constructor() {
+    super("Prompt back");
+    this.name = "PromptBack";
+  }
+};
 function defaultIO() {
   return { input: process.stdin, output: process.stdout };
 }
@@ -6084,35 +6248,40 @@ function choiceLine(choice, active) {
   const hint = choice.hint ? `  ${choice.hint}` : "";
   return `  ${marker(active)} ${choice.label}${hint}`;
 }
-function renderSelect(message, choices, index) {
+function listFooter(base, allowBack) {
+  return allowBack ? `${base} \xB7 \u2190 back` : base;
+}
+function renderSelect(message, choices, index, allowBack = false) {
   const lines = [`\u25C6 ${message}`, ""];
   choices.forEach((choice, position) => lines.push(choiceLine(choice, position === index)));
-  lines.push("", "  \u2191\u2193 move \xB7 enter select");
+  lines.push("", `  ${listFooter("\u2191\u2193 move \xB7 enter select", allowBack)}`);
   return lines.join("\n");
 }
-function renderMultiSelect(message, choices, index, selected) {
+function renderMultiSelect(message, choices, index, selected, allowBack = false) {
   const lines = [`\u25C6 ${message}`, ""];
   choices.forEach((choice, position) => {
     const box = selected.has(position) ? "\u25FC" : "\u25FB";
     const hint = choice.hint ? `  ${choice.hint}` : "";
     lines.push(`  ${marker(position === index)} ${box} ${choice.label}${hint}`);
   });
-  lines.push("", "  \u2191\u2193 move \xB7 space toggle \xB7 enter confirm");
+  lines.push("", `  ${listFooter("\u2191\u2193 move \xB7 space toggle \xB7 enter confirm", allowBack)}`);
   return lines.join("\n");
 }
-function renderConfirm(message, value) {
+function renderConfirm(message, value, allowBack = false) {
+  const footer = allowBack ? "\u2190\u2192 or y/n \xB7 enter confirm \xB7 b back" : "\u2190\u2192 or y/n \xB7 enter confirm";
   return [
     `\u25C6 ${message}`,
     "",
     `  ${marker(value)} Yes`,
     `  ${marker(!value)} No`,
     "",
-    "  \u2190\u2192 or y/n \xB7 enter confirm"
+    `  ${footer}`
   ].join("\n");
 }
-function renderText(message, value, error) {
+function renderText(message, value, error, allowBack = false) {
   const lines = [`\u25C6 ${message}`, "", `  ${value || "\u258F"}`];
   if (error) lines.push("", `  \u2716 ${error}`);
+  if (allowBack) lines.push("", "  enter confirm \xB7 \u2190 back");
   return lines.join("\n");
 }
 function keyReader(input) {
@@ -6161,14 +6330,18 @@ var Frame = class {
 function isCancel(key) {
   return key.ctrl === true && key.name === "c" || key.ctrl === true && key.name === "d";
 }
+function isListBack(key, allowBack) {
+  return allowBack && (key.name === "left" || key.name === "b");
+}
 async function select(io, message, choices, options = {}) {
   if (choices.length === 0) throw new Error("select() requires at least one choice.");
+  const allowBack = options.allowBack === true;
   const fallbackIndex = Math.max(
     0,
     choices.findIndex((choice) => choice.value === options.defaultValue)
   );
   if (!isInteractive(io)) {
-    io.output.write(`${renderSelect(message, choices, fallbackIndex)}
+    io.output.write(`${renderSelect(message, choices, fallbackIndex, allowBack)}
 `);
     return choices[fallbackIndex].value;
   }
@@ -6177,9 +6350,10 @@ async function select(io, message, choices, options = {}) {
   let index = fallbackIndex;
   try {
     for (; ; ) {
-      frame.draw(renderSelect(message, choices, index));
+      frame.draw(renderSelect(message, choices, index, allowBack));
       const key = await reader.next();
       if (isCancel(key)) throw new PromptCancelled();
+      if (isListBack(key, allowBack)) throw new PromptBack();
       if (key.name === "up") index = moveSelection(index, -1, choices.length);
       else if (key.name === "down") index = moveSelection(index, 1, choices.length);
       else if (key.name === "return" || key.name === "enter") {
@@ -6188,18 +6362,22 @@ async function select(io, message, choices, options = {}) {
       } else if (key.name === "j") index = moveSelection(index, 1, choices.length);
       else if (key.name === "k") index = moveSelection(index, -1, choices.length);
     }
+  } catch (error) {
+    frame.erase();
+    throw error;
   } finally {
     reader.close();
   }
 }
 async function multiSelect(io, message, choices, options = {}) {
+  const allowBack = options.allowBack === true;
   const selected = /* @__PURE__ */ new Set();
   choices.forEach((choice, position) => {
     if (options.defaults?.includes(choice.value)) selected.add(position);
   });
   const result = () => choices.filter((_, position) => selected.has(position)).map((choice) => choice.value);
   if (!isInteractive(io)) {
-    io.output.write(`${renderMultiSelect(message, choices, 0, selected)}
+    io.output.write(`${renderMultiSelect(message, choices, 0, selected, allowBack)}
 `);
     return result();
   }
@@ -6208,9 +6386,10 @@ async function multiSelect(io, message, choices, options = {}) {
   let index = 0;
   try {
     for (; ; ) {
-      frame.draw(renderMultiSelect(message, choices, index, selected));
+      frame.draw(renderMultiSelect(message, choices, index, selected, allowBack));
       const key = await reader.next();
       if (isCancel(key)) throw new PromptCancelled();
+      if (isListBack(key, allowBack)) throw new PromptBack();
       if (key.name === "up") index = moveSelection(index, -1, choices.length);
       else if (key.name === "down") index = moveSelection(index, 1, choices.length);
       else if (key.name === "space") {
@@ -6225,14 +6404,18 @@ async function multiSelect(io, message, choices, options = {}) {
         return result();
       }
     }
+  } catch (error) {
+    frame.erase();
+    throw error;
   } finally {
     reader.close();
   }
 }
 async function confirm(io, message, options = {}) {
+  const allowBack = options.allowBack === true;
   let value = options.defaultValue ?? true;
   if (!isInteractive(io)) {
-    io.output.write(`${renderConfirm(message, value)}
+    io.output.write(`${renderConfirm(message, value, allowBack)}
 `);
     return value;
   }
@@ -6240,9 +6423,10 @@ async function confirm(io, message, options = {}) {
   const reader = keyReader(io.input);
   try {
     for (; ; ) {
-      frame.draw(renderConfirm(message, value));
+      frame.draw(renderConfirm(message, value, allowBack));
       const key = await reader.next();
       if (isCancel(key)) throw new PromptCancelled();
+      if (allowBack && key.name === "b") throw new PromptBack();
       if (key.name === "up" || key.name === "left") value = true;
       else if (key.name === "down" || key.name === "right") value = false;
       else if (key.name === "y") value = true;
@@ -6252,14 +6436,18 @@ async function confirm(io, message, options = {}) {
         return value;
       }
     }
+  } catch (error) {
+    frame.erase();
+    throw error;
   } finally {
     reader.close();
   }
 }
 async function text(io, message, options = {}) {
+  const allowBack = options.allowBack === true;
   const fallback = options.defaultValue ?? "";
   if (!isInteractive(io)) {
-    io.output.write(`${renderText(message, fallback)}
+    io.output.write(`${renderText(message, fallback, void 0, allowBack)}
 `);
     return fallback;
   }
@@ -6269,9 +6457,10 @@ async function text(io, message, options = {}) {
   let error;
   try {
     for (; ; ) {
-      frame.draw(renderText(message, value, error));
+      frame.draw(renderText(message, value, error, allowBack));
       const key = await reader.next();
       if (isCancel(key)) throw new PromptCancelled();
+      if (allowBack && key.name === "left") throw new PromptBack();
       error = void 0;
       if (key.name === "return" || key.name === "enter") {
         const problem = options.validate ? options.validate(value) : null;
@@ -6292,6 +6481,9 @@ async function text(io, message, options = {}) {
       }
       if (_isPrintable(key)) value += _keyText(key);
     }
+  } catch (error_) {
+    frame.erase();
+    throw error_;
   } finally {
     reader.close();
   }
@@ -6315,10 +6507,10 @@ var CONFIG_CANDIDATES = [
 ];
 function chooseConfigFileName(cwd) {
   if (!supportsTypeScriptImports()) return "snapshot.config.mjs";
-  const pkgPath = path12__namespace.join(cwd, "package.json");
-  if (!fs11__namespace.existsSync(pkgPath)) return "snapshot.config.mjs";
+  const pkgPath = path13__namespace.join(cwd, "package.json");
+  if (!fs12__namespace.existsSync(pkgPath)) return "snapshot.config.mjs";
   try {
-    const parsed = JSON.parse(fs11__namespace.readFileSync(pkgPath, "utf8"));
+    const parsed = JSON.parse(fs12__namespace.readFileSync(pkgPath, "utf8"));
     return parsed.type === "module" ? "snapshot.config.ts" : "snapshot.config.mjs";
   } catch {
     return "snapshot.config.mjs";
@@ -6332,7 +6524,7 @@ var SIZE_CHOICES = [
 ];
 function packageJsonHasConfig(cwd) {
   try {
-    const parsed = JSON.parse(fs11__namespace.readFileSync(path12__namespace.join(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(fs12__namespace.readFileSync(path13__namespace.join(cwd, "package.json"), "utf8"));
     return typeof parsed.snapshot === "object" && parsed.snapshot !== null && !Array.isArray(parsed.snapshot);
   } catch {
     return false;
@@ -6353,7 +6545,7 @@ function artifactAnswers(options) {
 }
 function topLevelDirs(cwd) {
   try {
-    return fs11__namespace.readdirSync(cwd, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => entry.name).sort();
+    return fs12__namespace.readdirSync(cwd, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => entry.name).sort();
   } catch {
     return [];
   }
@@ -6366,7 +6558,7 @@ function describeJsonValue(value) {
 }
 function writeFileOrExplain(target, content) {
   try {
-    fs11__namespace.writeFileSync(target, content, "utf8");
+    fs12__namespace.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}`;
@@ -6377,7 +6569,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__namespace.readFileSync(path12__namespace.join(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(fs12__namespace.readFileSync(path13__namespace.join(cwd, "package.json"), "utf8"));
     return parsed.type === "module";
   } catch {
     return false;
@@ -6412,19 +6604,19 @@ function serializePackageJson(raw, value) {
   return `${text2}${raw.endsWith("\n") ? crlf ? "\r\n" : "\n" : ""}`;
 }
 function updatePackageJson(cwd, notes) {
-  const packagePath = path12__namespace.join(cwd, "package.json");
+  const packagePath = path13__namespace.join(cwd, "package.json");
   const unchanged = {
     scripts: [],
     dependency: { name: GENERATOR_NAME, range: null, added: false }
   };
-  if (!fs11__namespace.existsSync(packagePath)) {
+  if (!fs12__namespace.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__namespace.readFileSync(packagePath, "utf8");
+    raw = fs12__namespace.readFileSync(packagePath, "utf8");
     parsed = JSON.parse(raw);
   } catch {
     notes.push("Could not parse package.json; npm scripts and the devDependency were not added.");
@@ -6548,98 +6740,108 @@ async function runInit(options) {
       { value: "walk", label: "Go through each setting", hint: "every question starts on its default" },
       { value: "choose", label: "Pick a different preset", hint: "everything else stays at the defaults" }
     ];
-    const pace = await select(io, "How should I set this up?", paceChoices, {
-      defaultValue: fallback ? "choose" : "recommended"
-    });
-    if (pace === "choose") {
-      answers.preset = await select(
-        io,
-        "What kind of project is this?",
-        listPresetNames().map(
-          (name) => resolvePresetChoice(fallback ? null : detected.presetName, name)
-        ),
-        { defaultValue: answers.preset }
-      );
-      const chosen = detectPreset(options.cwd, answers.preset);
-      answers.preset = chosen.presetName;
-      reason = null;
-      fallback = false;
-    }
-    if (pace === "walk") {
-      const scope = await select(
-        io,
-        "What should go into the snapshot?",
-        [
-          { value: "all", label: "Everything the scanner finds", hint: "recommended \xB7 respects .gitignore" },
-          { value: "folders", label: "Only specific folders\u2026" },
-          { value: "no-tests", label: "Everything, but skip tests" },
-          { value: "custom", label: "Let me write glob patterns" }
-        ],
-        { defaultValue: "all" }
-      );
-      if (scope === "folders") {
-        const dirs = topLevelDirs(options.cwd).slice(0, 40);
-        if (dirs.length === 0) {
-          notes.push("No top-level directories found; the snapshot will include everything.");
-        } else {
-          const chosen = await multiSelect(
-            io,
-            "Select folders",
-            dirs.map((name) => ({ value: name, label: `${name}/` })),
-            { defaults: dirs }
-          );
-          answers.include = chosen.map((name) => `${name}/**`);
+    const baseInclude = [...answers.include];
+    const baseExclude = [...answers.excludePatterns];
+    let lastScope = "all";
+    const artifactChoices = [
+      { value: "readme", label: "README.md", hint: "orientation page" },
+      { value: "manifest", label: "manifest.json", hint: "required by validate and report" },
+      { value: "parts", label: "parts/", hint: "the code payload" },
+      { value: "navigation", label: "reports/navigation.md", hint: "file \u2192 part index" },
+      { value: "projectTree", label: "reports/project-tree.md", hint: "ASCII tree" },
+      { value: "audit", label: "reports/audit.md", hint: "security and health findings" },
+      { value: "monolith", label: "full-codebase.json + .md", hint: "roughly doubles output" }
+    ];
+    const scopeStep = async () => {
+      for (; ; ) {
+        const scope = await select(
+          io,
+          "What should go into the snapshot?",
+          [
+            { value: "all", label: "Everything the scanner finds", hint: "recommended \xB7 respects .gitignore" },
+            { value: "folders", label: "Only specific folders\u2026" },
+            { value: "no-tests", label: "Everything, but skip tests" },
+            { value: "custom", label: "Let me write glob patterns" }
+          ],
+          { defaultValue: lastScope, allowBack: true }
+        );
+        lastScope = scope;
+        answers.include = [...baseInclude];
+        answers.excludePatterns = [...baseExclude];
+        try {
+          if (scope === "folders") {
+            const dirs = topLevelDirs(options.cwd).slice(0, 40);
+            if (dirs.length === 0) {
+              notes.push("No top-level directories found; the snapshot will include everything.");
+            } else {
+              const chosen = await multiSelect(
+                io,
+                "Select folders",
+                dirs.map((name) => ({ value: name, label: `${name}/` })),
+                { defaults: dirs, allowBack: true }
+              );
+              answers.include = chosen.map((name) => `${name}/**`);
+            }
+          } else if (scope === "no-tests") {
+            answers.excludePatterns = [...baseExclude, "**/*.test.*", "**/*.spec.*", "tests", "test"];
+          } else if (scope === "custom") {
+            const raw = await text(io, "Glob patterns to include (comma separated)", {
+              defaultValue: baseInclude.join(", "),
+              allowBack: true
+            });
+            answers.include = raw.split(",").map((value) => value.trim()).filter(Boolean);
+          }
+          return;
+        } catch (error) {
+          if (error instanceof PromptBack) continue;
+          throw error;
         }
-      } else if (scope === "no-tests") {
-        answers.excludePatterns = [
-          ...answers.excludePatterns,
-          "**/*.test.*",
-          "**/*.spec.*",
-          "tests",
-          "test"
-        ];
-      } else if (scope === "custom") {
-        const raw = await text(io, "Glob patterns to include (comma separated)", {
-          defaultValue: ""
-        });
-        answers.include = raw.split(",").map((value) => value.trim()).filter(Boolean);
       }
-      const currentBudget = String(answers.maxPartBytes);
-      const sizeChoice = await select(io, "How large should each part be?", SIZE_CHOICES, {
-        defaultValue: SIZE_CHOICES.some((choice) => choice.value === currentBudget) ? currentBudget : "120k"
-      });
-      if (sizeChoice === "custom") {
-        const raw = await text(io, "Part size (e.g. 150k, 1.5mb, 900000)", {
-          defaultValue: String(answers.maxPartBytes),
-          validate: (value) => parseByteSize(value) === void 0 ? "Not a valid size." : null
+    };
+    const sizeStep = async () => {
+      for (; ; ) {
+        const currentBudget = String(answers.maxPartBytes);
+        const sizeChoice = await select(io, "How large should each part be?", SIZE_CHOICES, {
+          defaultValue: SIZE_CHOICES.some((choice) => choice.value === currentBudget) ? currentBudget : "custom",
+          allowBack: true
         });
-        answers.maxPartBytes = parseByteSize(raw) ?? answers.maxPartBytes;
-      } else {
-        answers.maxPartBytes = sizeChoice;
-      }
-      const artifactChoices = [
-        { value: "readme", label: "README.md", hint: "orientation page" },
-        { value: "manifest", label: "manifest.json", hint: "required by validate and report" },
-        { value: "parts", label: "parts/", hint: "the code payload" },
-        { value: "navigation", label: "reports/navigation.md", hint: "file \u2192 part index" },
-        { value: "projectTree", label: "reports/project-tree.md", hint: "ASCII tree" },
-        { value: "audit", label: "reports/audit.md", hint: "security and health findings" },
-        { value: "monolith", label: "full-codebase.json + .md", hint: "roughly doubles output" }
-      ];
-      const presetEnabled = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]);
+        if (sizeChoice !== "custom") {
+          answers.maxPartBytes = sizeChoice;
+          return;
+        }
+        try {
+          const raw = await text(io, "Part size (e.g. 150k, 1.5mb, 900000)", {
+            defaultValue: currentBudget,
+            validate: (value) => parseByteSize(value) === void 0 ? "Not a valid size." : null,
+            allowBack: true
+          });
+          answers.maxPartBytes = parseByteSize(raw) ?? answers.maxPartBytes;
+          return;
+        } catch (error) {
+          if (error instanceof PromptBack) continue;
+          throw error;
+        }
+      }
+    };
+    const artifactsStep = async () => {
+      const enabled = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]);
       const selectedArtifacts = await multiSelect(
         io,
         "Which artifacts should be generated?",
         artifactChoices,
-        { defaults: presetEnabled }
+        { defaults: enabled, allowBack: true }
       );
       for (const name of ARTIFACT_NAMES) answers.artifacts[name] = selectedArtifacts.includes(name);
-      const enabledCount = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]).length;
+    };
+    const credentialsStep = async () => {
       answers.includeSensitiveFiles = await confirm(
         io,
-        "Include credential files (.env, *.pem, .npmrc, .ssh/)?",
-        { defaultValue: false }
+        "Include credential files (.env, *.pem, *.npmrc, *.ssh/)?",
+        { defaultValue: answers.includeSensitiveFiles, allowBack: true }
       );
+    };
+    const reviewStep = async () => {
+      const enabledCount = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]).length;
       io.output.write("\n  Review\n\n");
       io.output.write(`  project          ${answers.preset}
 `);
@@ -6654,14 +6856,59 @@ async function runInit(options) {
 `);
       io.output.write("  Will write snapshot.config with your answers, plus every other setting\n");
       io.output.write("  at its default \u2014 so nothing is hidden behind the docs.\n\n");
-      const proceed = await confirm(io, "Write this and continue?", { defaultValue: true });
-      if (!proceed) throw new PromptCancelled();
+      const proceed = await confirm(io, "Write this and continue?", {
+        defaultValue: true,
+        allowBack: true
+      });
+      if (!proceed) throw new PromptBack();
+    };
+    const walk = async () => {
+      const steps = [scopeStep, sizeStep, artifactsStep, credentialsStep, reviewStep];
+      let index = 0;
+      while (index < steps.length) {
+        try {
+          await steps[index]();
+          index += 1;
+        } catch (error) {
+          if (!(error instanceof PromptBack)) throw error;
+          if (index === 0) return false;
+          index -= 1;
+          io.output.write("\n");
+        }
+      }
+      return true;
+    };
+    for (; ; ) {
+      const pace = await select(io, "How should I set this up?", paceChoices, {
+        defaultValue: fallback ? "choose" : "recommended"
+      });
+      if (pace === "choose") {
+        try {
+          answers.preset = await select(
+            io,
+            "What kind of project is this?",
+            listPresetNames().map(
+              (name) => resolvePresetChoice(fallback ? null : detected.presetName, name)
+            ),
+            { defaultValue: answers.preset, allowBack: true }
+          );
+        } catch (error) {
+          if (error instanceof PromptBack) continue;
+          throw error;
+        }
+        const chosen = detectPreset(options.cwd, answers.preset);
+        answers.preset = chosen.presetName;
+        reason = null;
+        fallback = false;
+      }
+      if (pace === "walk" && !await walk()) continue;
+      break;
     }
   }
   const configText = renderConfig(answers);
   const preferredName = chooseConfigFileName(options.cwd);
   const presentConfigs = CONFIG_CANDIDATES.filter(
-    (name) => fs11__namespace.existsSync(path12__namespace.join(options.cwd, name))
+    (name) => fs12__namespace.existsSync(path13__namespace.join(options.cwd, name))
   );
   const present = presentConfigs[0] ?? null;
   if (presentConfigs.length > 1) {
@@ -6670,7 +6917,7 @@ async function runInit(options) {
     );
   }
   const configName = present !== null && options.force ? present : preferredName;
-  const configPath = path12__namespace.join(options.cwd, configName);
+  const configPath = path13__namespace.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) {
@@ -6703,7 +6950,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__namespace.existsSync(configPath) && !options.force && !reused) {
+  if (fs12__namespace.existsSync(configPath) && !options.force && !reused) {
     throw new Error(`${configName} already exists. Re-run with --force to replace it.`);
   }
   if (!reused) writeFileOrExplain(configPath, configText);
@@ -6725,9 +6972,9 @@ async function runInit(options) {
   };
 }
 function describeTarget(cwd) {
-  const relative7 = path12__namespace.relative(process.cwd(), cwd);
+  const relative7 = path13__namespace.relative(process.cwd(), cwd);
   if (relative7 === "") return "this directory";
-  if (relative7.startsWith("..") || path12__namespace.isAbsolute(relative7)) return cwd;
+  if (relative7.startsWith("..") || path13__namespace.isAbsolute(relative7)) return cwd;
   return relative7;
 }
 function firstRunMessage(reason, cwd) {
@@ -6751,7 +6998,7 @@ function planFirstRun(facts) {
 var NOT_CONTENT = /* @__PURE__ */ new Set([".git", ".hg", ".svn", ".bzr", ".DS_Store", "Thumbs.db"]);
 function isEffectivelyEmpty(cwd) {
   try {
-    return fs11__namespace.readdirSync(cwd).every((entry) => NOT_CONTENT.has(entry));
+    return fs12__namespace.readdirSync(cwd).every((entry) => NOT_CONTENT.has(entry));
   } catch {
     return false;
   }
@@ -6759,7 +7006,7 @@ function isEffectivelyEmpty(cwd) {
 function hasPriorSnapshot(cwd, outDir) {
   let parsed;
   try {
-    parsed = JSON.parse(fs11__namespace.readFileSync(path12__namespace.join(cwd, outDir, ".codebase-snapshot"), "utf8"));
+    parsed = JSON.parse(fs12__namespace.readFileSync(path13__namespace.join(cwd, outDir, ".codebase-snapshot"), "utf8"));
   } catch {
     return false;
   }
@@ -6847,13 +7094,13 @@ function buildImportResolver(files) {
     const relativePath = file.relativePath;
     remember(byPath, relativePath, relativePath);
     remember(byPathFolded, relativePath.toLowerCase(), relativePath);
-    const extension = path12__namespace.posix.extname(relativePath);
+    const extension = path13__namespace.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__namespace.posix.basename(stem) === "index") {
-      const directory = path12__namespace.posix.dirname(stem);
+    if (path13__namespace.posix.basename(stem) === "index") {
+      const directory = path13__namespace.posix.dirname(stem);
       remember(byStem, directory, relativePath);
       remember(byStemFolded, directory.toLowerCase(), relativePath);
     }
@@ -6862,8 +7109,8 @@ function buildImportResolver(files) {
 }
 function resolveSpecifier(fromFile, specifier, resolver) {
   if (!RELATIVE_SPECIFIER.test(specifier)) return null;
-  const joined = path12__namespace.posix.normalize(
-    path12__namespace.posix.join(path12__namespace.posix.dirname(fromFile), specifier)
+  const joined = path13__namespace.posix.normalize(
+    path13__namespace.posix.join(path13__namespace.posix.dirname(fromFile), specifier)
   );
   const exact = (key) => resolver.byPath.get(key) ?? resolver.byPathFolded.get(key.toLowerCase()) ?? null;
   const direct = exact(joined);
@@ -6956,11 +7203,11 @@ function verifyInMemory(files, parts, maxPartBytes) {
   return errors;
 }
 function resolveSafeOutputDirs(config) {
-  const cwd = path12__namespace.resolve(config.cwd);
-  const outDir = path12__namespace.resolve(cwd, config.outDir);
-  const tmpDir = path12__namespace.resolve(cwd, config.tmpDir);
-  const root = path12__namespace.parse(cwd).root;
-  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path12__namespace.sep}`);
+  const cwd = path13__namespace.resolve(config.cwd);
+  const outDir = path13__namespace.resolve(cwd, config.outDir);
+  const tmpDir = path13__namespace.resolve(cwd, config.tmpDir);
+  const root = path13__namespace.parse(cwd).root;
+  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path13__namespace.sep}`);
   const reject = (reason) => {
     throw new Error(
       `Refusing to generate: ${reason}. outDir=${outDir} tmpDir=${tmpDir} cwd=${cwd}`
@@ -7016,14 +7263,14 @@ function listEntries(dir) {
   const walk = (absolute, prefix) => {
     let children;
     try {
-      children = fs11__namespace.readdirSync(absolute, { withFileTypes: true });
+      children = fs12__namespace.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__namespace.join(absolute, child.name), relative7);
+      if (child.isDirectory()) walk(path13__namespace.join(absolute, child.name), relative7);
     }
   };
   walk(dir, "");
@@ -7040,28 +7287,28 @@ function markerPayload(dir, state, id, createdAt) {
     pid: process.pid,
     entries: listEntries(dir)
   };
-  const manifestPath = path12__namespace.join(dir, "manifest.json");
-  if (fs11__namespace.existsSync(manifestPath)) {
-    marker2.manifestSha256 = sha256Hex2(fs11__namespace.readFileSync(manifestPath));
+  const manifestPath = path13__namespace.join(dir, "manifest.json");
+  if (fs12__namespace.existsSync(manifestPath)) {
+    marker2.manifestSha256 = sha256Hex2(fs12__namespace.readFileSync(manifestPath));
   }
   return marker2;
 }
 function writeOwnershipMarker(dir, marker2) {
-  fs11__namespace.writeFileSync(
-    path12__namespace.join(dir, OWNERSHIP_MARKER),
+  fs12__namespace.writeFileSync(
+    path13__namespace.join(dir, OWNERSHIP_MARKER),
     `${JSON.stringify(marker2, null, 2)}
 `,
     "utf8"
   );
 }
 function readOwnershipMarker(dir) {
-  const markerPath = path12__namespace.join(dir, OWNERSHIP_MARKER);
-  if (!fs11__namespace.existsSync(markerPath)) {
+  const markerPath = path13__namespace.join(dir, OWNERSHIP_MARKER);
+  if (!fs12__namespace.existsSync(markerPath)) {
     return { marker: null, problem: "it holds no .codebase-snapshot marker" };
   }
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(markerPath, "utf8");
+    raw = fs12__namespace.readFileSync(markerPath, "utf8");
   } catch {
     return { marker: null, problem: "its .codebase-snapshot marker could not be read" };
   }
@@ -7129,11 +7376,11 @@ function assessSnapshotDirectory(dir) {
       marker: marker2
     };
   }
-  const manifestPath = path12__namespace.join(dir, "manifest.json");
-  if (fs11__namespace.existsSync(manifestPath)) {
+  const manifestPath = path13__namespace.join(dir, "manifest.json");
+  if (fs12__namespace.existsSync(manifestPath)) {
     let raw;
     try {
-      raw = fs11__namespace.readFileSync(manifestPath, "utf8");
+      raw = fs12__namespace.readFileSync(manifestPath, "utf8");
     } catch {
       return {
         owned: false,
@@ -7215,13 +7462,13 @@ function containsNoFiles(dir) {
     const current = pending.pop();
     let entries;
     try {
-      entries = fs11__namespace.readdirSync(current, { withFileTypes: true });
+      entries = fs12__namespace.readdirSync(current, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        pending.push(path12__namespace.join(current, entry.name));
+        pending.push(path13__namespace.join(current, entry.name));
       } else if (!IGNORABLE_ENTRIES.has(entry.name)) {
         return false;
       }
@@ -7230,13 +7477,13 @@ function containsNoFiles(dir) {
   return true;
 }
 function assertReplaceable(target, label, secretRules) {
-  if (!fs11__namespace.existsSync(target)) return;
-  if (!fs11__namespace.statSync(target).isDirectory()) {
+  if (!fs12__namespace.existsSync(target)) return;
+  if (!fs12__namespace.statSync(target).isDirectory()) {
     throw new Error(
       `Refusing to write into ${label} ${target}: it exists but is not a directory.`
     );
   }
-  const entries = fs11__namespace.readdirSync(target);
+  const entries = fs12__namespace.readdirSync(target);
   if (entries.length === 0) return;
   if (entries.every((name) => IGNORABLE_ENTRIES.has(name))) return;
   if (containsNoFiles(target)) return;
@@ -7256,18 +7503,18 @@ function assertReplaceable(target, label, secretRules) {
   );
 }
 function assertStagingRootUsable(tmpDir, secretRules) {
-  if (!fs11__namespace.existsSync(tmpDir)) return;
-  if (!fs11__namespace.statSync(tmpDir).isDirectory()) {
+  if (!fs12__namespace.existsSync(tmpDir)) return;
+  if (!fs12__namespace.statSync(tmpDir).isDirectory()) {
     throw new Error(`Refusing to write into tmpDir ${tmpDir}: it exists but is not a directory.`);
   }
-  const entries = fs11__namespace.readdirSync(tmpDir);
+  const entries = fs12__namespace.readdirSync(tmpDir);
   if (entries.length === 0) return;
   const foreign = entries.filter((name) => {
-    const full = path12__namespace.join(tmpDir, name);
+    const full = path13__namespace.join(tmpDir, name);
     if (!name.startsWith(RUN_DIR_PREFIX)) return true;
     let stats;
     try {
-      stats = fs11__namespace.statSync(full);
+      stats = fs12__namespace.statSync(full);
     } catch {
       return true;
     }
@@ -7275,7 +7522,7 @@ function assertStagingRootUsable(tmpDir, secretRules) {
     const { marker: marker2 } = readOwnershipMarker(full);
     if (marker2) return false;
     try {
-      return fs11__namespace.readdirSync(full).length > 0;
+      return fs12__namespace.readdirSync(full).length > 0;
     } catch {
       return true;
     }
@@ -7290,13 +7537,13 @@ function assertStagingRootUsable(tmpDir, secretRules) {
 function cleanStaleRunDirs(tmpDir) {
   let entries;
   try {
-    entries = fs11__namespace.readdirSync(tmpDir);
+    entries = fs12__namespace.readdirSync(tmpDir);
   } catch {
     return;
   }
   for (const name of entries) {
     if (!name.startsWith(RUN_DIR_PREFIX)) continue;
-    const full = path12__namespace.join(tmpDir, name);
+    const full = path13__namespace.join(tmpDir, name);
     const { marker: marker2 } = readOwnershipMarker(full);
     if (marker2) {
       const created = Date.parse(marker2.createdAt);
@@ -7304,33 +7551,33 @@ function cleanStaleRunDirs(tmpDir) {
       const abandoned = typeof marker2.pid === "number" && !isProcessAlive(marker2.pid);
       if (aged || abandoned) {
         try {
-          fs11__namespace.rmSync(full, { recursive: true, force: true });
+          fs12__namespace.rmSync(full, { recursive: true, force: true });
         } catch {
         }
       }
       continue;
     }
     try {
-      if (fs11__namespace.readdirSync(full).length === 0) fs11__namespace.rmSync(full, { recursive: true, force: true });
+      if (fs12__namespace.readdirSync(full).length === 0) fs12__namespace.rmSync(full, { recursive: true, force: true });
     } catch {
     }
   }
 }
 function removeIfEmpty(dir) {
   try {
-    if (fs11__namespace.readdirSync(dir).length === 0) fs11__namespace.rmSync(dir, { recursive: true, force: true });
+    if (fs12__namespace.readdirSync(dir).length === 0) fs12__namespace.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function ensureParentDirectory(target, label) {
-  const parent = path12__namespace.dirname(target);
-  if (fs11__namespace.existsSync(parent) && !fs11__namespace.statSync(parent).isDirectory()) {
+  const parent = path13__namespace.dirname(target);
+  if (fs12__namespace.existsSync(parent) && !fs12__namespace.statSync(parent).isDirectory()) {
     throw new Error(
       `Refusing to create ${label} ${target}: ${parent} exists but is not a directory.`
     );
   }
   try {
-    fs11__namespace.mkdirSync(parent, { recursive: true });
+    fs12__namespace.mkdirSync(parent, { recursive: true });
   } catch (err) {
     throw new Error(
       `Refusing to create ${label} ${target}: its parent ${parent} could not be created (${err.message}).`
@@ -7339,7 +7586,7 @@ function ensureParentDirectory(target, label) {
 }
 function acquireRunLock(stagingRoot) {
   const key = lockKeyFor(stagingRoot);
-  const lockPath = path12__namespace.join(os__namespace.tmpdir(), `codebase-snapshot-${key}.lock`);
+  const lockPath = path13__namespace.join(os__namespace.tmpdir(), `codebase-snapshot-${key}.lock`);
   const payload = `${JSON.stringify({
     pid: process.pid,
     stagingRoot,
@@ -7348,22 +7595,22 @@ function acquireRunLock(stagingRoot) {
 `;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const handle = fs11__namespace.openSync(lockPath, "wx");
+      const handle = fs12__namespace.openSync(lockPath, "wx");
       try {
-        fs11__namespace.writeSync(handle, payload);
+        fs12__namespace.writeSync(handle, payload);
       } finally {
-        fs11__namespace.closeSync(handle);
+        fs12__namespace.closeSync(handle);
       }
       return () => {
         try {
-          fs11__namespace.rmSync(lockPath, { force: true });
+          fs12__namespace.rmSync(lockPath, { force: true });
         } catch {
         }
       };
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       if (attempt === 0 && lockOwnerIsGone(lockPath)) {
-        fs11__namespace.rmSync(lockPath, { force: true });
+        fs12__namespace.rmSync(lockPath, { force: true });
         continue;
       }
       throw new Error(
@@ -7376,7 +7623,7 @@ function acquireRunLock(stagingRoot) {
 function lockKeyFor(stagingRoot) {
   let key = stagingRoot;
   try {
-    key = fs11__namespace.realpathSync(stagingRoot);
+    key = fs12__namespace.realpathSync(stagingRoot);
   } catch {
   }
   if (process.platform === "win32" || process.platform === "darwin") key = key.toLowerCase();
@@ -7385,7 +7632,7 @@ function lockKeyFor(stagingRoot) {
 function lockOwnerIsGone(lockPath) {
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(lockPath, "utf8");
+    raw = fs12__namespace.readFileSync(lockPath, "utf8");
   } catch {
     return false;
   }
@@ -7405,12 +7652,12 @@ function lockOwnerIsGone(lockPath) {
 }
 function writeManifestAtomically(manifestPath, manifest) {
   const tempPath = `${manifestPath}.${process.pid}.tmp`;
-  fs11__namespace.writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf8");
+  fs12__namespace.writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf8");
   try {
-    fs11__namespace.renameSync(tempPath, manifestPath);
+    fs12__namespace.renameSync(tempPath, manifestPath);
   } catch (err) {
     try {
-      fs11__namespace.rmSync(tempPath, { force: true });
+      fs12__namespace.rmSync(tempPath, { force: true });
     } catch {
     }
     throw err;
@@ -7433,31 +7680,31 @@ function swapIntoPlace(stagingDir, outDir) {
 }
 function swapOnce(stagingDir, outDir) {
   const backupDir = `${outDir}.backup-${process.pid}-${Date.now()}`;
-  const hadPrevious = fs11__namespace.existsSync(outDir);
-  if (hadPrevious) fs11__namespace.renameSync(outDir, backupDir);
+  const hadPrevious = fs12__namespace.existsSync(outDir);
+  if (hadPrevious) fs12__namespace.renameSync(outDir, backupDir);
   try {
     try {
-      fs11__namespace.renameSync(stagingDir, outDir);
+      fs12__namespace.renameSync(stagingDir, outDir);
     } catch (err) {
       if (err.code !== "EXDEV") throw err;
       const partialDir = `${outDir}.partial-${process.pid}-${Date.now()}`;
       try {
-        fs11__namespace.cpSync(stagingDir, partialDir, { recursive: true });
-        fs11__namespace.renameSync(partialDir, outDir);
-        fs11__namespace.rmSync(stagingDir, { recursive: true, force: true });
+        fs12__namespace.cpSync(stagingDir, partialDir, { recursive: true });
+        fs12__namespace.renameSync(partialDir, outDir);
+        fs12__namespace.rmSync(stagingDir, { recursive: true, force: true });
       } catch (copyErr) {
         try {
-          fs11__namespace.rmSync(partialDir, { recursive: true, force: true });
+          fs12__namespace.rmSync(partialDir, { recursive: true, force: true });
         } catch {
         }
         throw copyErr;
       }
     }
-    if (hadPrevious) fs11__namespace.rmSync(backupDir, { recursive: true, force: true });
+    if (hadPrevious) fs12__namespace.rmSync(backupDir, { recursive: true, force: true });
   } catch (err) {
-    if (hadPrevious && fs11__namespace.existsSync(backupDir)) {
-      if (fs11__namespace.existsSync(outDir)) fs11__namespace.rmSync(outDir, { recursive: true, force: true });
-      fs11__namespace.renameSync(backupDir, outDir);
+    if (hadPrevious && fs12__namespace.existsSync(backupDir)) {
+      if (fs12__namespace.existsSync(outDir)) fs12__namespace.rmSync(outDir, { recursive: true, force: true });
+      fs12__namespace.renameSync(backupDir, outDir);
     }
     throw err;
   }
@@ -7552,7 +7799,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__namespace.relative(config.cwd, path12__namespace.resolve(config.cwd, directory)).replace(/\\/g, "/")
+      (directory) => path13__namespace.relative(config.cwd, path13__namespace.resolve(config.cwd, directory)).replace(/\\/g, "/")
     ).filter((relative7) => relative7.length > 0 && !relative7.startsWith(".."))
   });
   const files = [];
@@ -7573,12 +7820,12 @@ function generateSnapshot(configInput, options) {
   let totalSizeBytes = 0;
   let largeFileCount = 0;
   for (const relativePath of collection.files) {
-    const absolutePath = path12__namespace.join(config.cwd, relativePath);
+    const absolutePath = path13__namespace.join(config.cwd, relativePath);
     let stats;
     try {
-      stats = fs11__namespace.statSync(absolutePath);
+      stats = fs12__namespace.statSync(absolutePath);
       if (!stats.isFile()) {
-        const nestedRepository = stats.isDirectory() && fs11__namespace.existsSync(path12__namespace.join(absolutePath, ".git"));
+        const nestedRepository = stats.isDirectory() && fs12__namespace.existsSync(path13__namespace.join(absolutePath, ".git"));
         skipped.push(
           nestedRepository ? {
             path: relativePath,
@@ -7598,7 +7845,7 @@ function generateSnapshot(configInput, options) {
     }
     let buffer;
     try {
-      buffer = fs11__namespace.readFileSync(absolutePath);
+      buffer = fs12__namespace.readFileSync(absolutePath);
     } catch {
       skipped.push({ path: relativePath, reason: "read-error" });
       continue;
@@ -7928,12 +8175,12 @@ function generateSnapshot(configInput, options) {
   let stagingDir = null;
   try {
     ensureParentDirectory(outDir, "outDir");
-    fs11__namespace.mkdirSync(tmpDir, { recursive: true });
+    fs12__namespace.mkdirSync(tmpDir, { recursive: true });
     cleanStaleRunDirs(tmpDir);
     const snapshotId = crypto__namespace.randomUUID();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    stagingDir = path12__namespace.join(tmpDir, `${RUN_DIR_PREFIX}${process.pid}-${snapshotId.slice(0, 8)}`);
-    fs11__namespace.mkdirSync(stagingDir);
+    stagingDir = path13__namespace.join(tmpDir, `${RUN_DIR_PREFIX}${process.pid}-${snapshotId.slice(0, 8)}`);
+    fs12__namespace.mkdirSync(stagingDir);
     writeOwnershipMarker(stagingDir, {
       generator: GENERATOR_NAME,
       version: GENERATOR_VERSION,
@@ -7943,41 +8190,41 @@ function generateSnapshot(configInput, options) {
       id: snapshotId,
       pid: process.pid
     });
-    const partsDir = path12__namespace.join(stagingDir, "parts");
-    const reportsDir = path12__namespace.join(stagingDir, "reports");
-    if (artifacts.parts) fs11__namespace.mkdirSync(partsDir, { recursive: true });
+    const partsDir = path13__namespace.join(stagingDir, "parts");
+    const reportsDir = path13__namespace.join(stagingDir, "reports");
+    if (artifacts.parts) fs12__namespace.mkdirSync(partsDir, { recursive: true });
     if (artifacts.navigation || artifacts.projectTree || artifacts.audit) {
-      fs11__namespace.mkdirSync(reportsDir, { recursive: true });
+      fs12__namespace.mkdirSync(reportsDir, { recursive: true });
     }
     if (artifacts.parts) {
       for (const part of parts) {
-        fs11__namespace.writeFileSync(path12__namespace.join(partsDir, part.filename), part.markdown, "utf8");
+        fs12__namespace.writeFileSync(path13__namespace.join(partsDir, part.filename), part.markdown, "utf8");
       }
     }
     if (projectTree !== null) {
-      fs11__namespace.writeFileSync(path12__namespace.join(reportsDir, "project-tree.md"), projectTree, "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(reportsDir, "project-tree.md"), projectTree, "utf8");
     }
     if (artifacts.navigation) {
-      fs11__namespace.writeFileSync(path12__namespace.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
     }
     if (artifacts.audit) {
-      fs11__namespace.writeFileSync(
-        path12__namespace.join(reportsDir, "audit.md"),
+      fs12__namespace.writeFileSync(
+        path13__namespace.join(reportsDir, "audit.md"),
         generateAuditReport(manifest, secretFindings, config.secretRules),
         "utf8"
       );
     }
     if (artifacts.readme) {
-      fs11__namespace.writeFileSync(path12__namespace.join(stagingDir, "README.md"), generateReadme(manifest, artifacts), "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(stagingDir, "README.md"), generateReadme(manifest, artifacts), "utf8");
     }
     if (artifacts.manifest) {
-      fs11__namespace.writeFileSync(path12__namespace.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
     }
     if (monolithJson !== null) {
-      fs11__namespace.writeFileSync(path12__namespace.join(stagingDir, "full-codebase.json"), monolithJson, "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(stagingDir, "full-codebase.json"), monolithJson, "utf8");
     }
     if (monolithMarkdown !== null) {
-      fs11__namespace.writeFileSync(path12__namespace.join(stagingDir, "full-codebase.md"), monolithMarkdown, "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(stagingDir, "full-codebase.md"), monolithMarkdown, "utf8");
     }
     writeOwnershipMarker(stagingDir, markerPayload(stagingDir, "complete", snapshotId, createdAt));
     swapIntoPlace(stagingDir, outDir);
@@ -7986,7 +8233,7 @@ function generateSnapshot(configInput, options) {
     const pendingHook = runAfterGenerate(config, manifest);
     const shipHookState = () => {
       if (artifacts.manifest && manifest.warnings.length !== warningsBeforeHook) {
-        writeManifestAtomically(path12__namespace.join(outDir, "manifest.json"), manifest);
+        writeManifestAtomically(path13__namespace.join(outDir, "manifest.json"), manifest);
       }
       writeOwnershipMarker(outDir, markerPayload(outDir, "complete", snapshotId, createdAt));
     };
@@ -8009,7 +8256,7 @@ function generateSnapshot(configInput, options) {
   } catch (err) {
     if (stagingDir !== null) {
       try {
-        fs11__namespace.rmSync(stagingDir, { recursive: true, force: true });
+        fs12__namespace.rmSync(stagingDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -8024,18 +8271,25 @@ async function generateSnapshotAsync(configInput, options) {
 }
 
 exports.ARTIFACT_NAMES = ARTIFACT_NAMES;
+exports.CHECK_INTERVAL_MS = CHECK_INTERVAL_MS;
 exports.DEFAULT_ANSWERS = DEFAULT_ANSWERS;
 exports.DEFAULT_SECRET_PATTERNS = DEFAULT_SECRET_PATTERNS;
+exports.FAILURE_INTERVAL_MS = FAILURE_INTERVAL_MS;
 exports.GENERATOR_NAME = GENERATOR_NAME;
 exports.GENERATOR_VERSION = GENERATOR_VERSION;
 exports.LANGUAGE_PROFILES = LANGUAGE_PROFILES;
 exports.MIN_MAX_PART_BYTES = MIN_MAX_PART_BYTES;
+exports.PACKAGE_LATEST_URL = PACKAGE_LATEST_URL;
 exports.PRESETS = PRESETS;
 exports.PromptCancelled = PromptCancelled;
+exports.REQUEST_TIMEOUT_MS = REQUEST_TIMEOUT_MS;
 exports.SCHEMA_VERSION = SCHEMA_VERSION;
 exports.anchorForPath = anchorForPath;
 exports.assertReplaceable = assertReplaceable;
 exports.assertUsableConfigInput = assertUsableConfigInput;
+exports.cacheDirectory = cacheDirectory;
+exports.cacheFilePath = cacheFilePath;
+exports.checkForUpdate = checkForUpdate;
 exports.collectFiles = collectFiles;
 exports.compareManifests = compareManifests;
 exports.countInvalidUtf8Bytes = countInvalidUtf8Bytes;
@@ -8047,7 +8301,9 @@ exports.detectPreset = detectPreset;
 exports.explainPath = explainPath;
 exports.fenceForContent = fenceForContent;
 exports.fenceForText = fenceForText;
+exports.fetchLatestVersion = fetchLatestVersion;
 exports.firstRunMessage = firstRunMessage;
+exports.formatUpdateNotice = formatUpdateNotice;
 exports.generateProjectTree = generateProjectTree;
 exports.generateSnapshot = generateSnapshot;
 exports.generateSnapshotAsync = generateSnapshotAsync;
@@ -8059,6 +8315,7 @@ exports.isBinaryExtension = isBinaryExtension;
 exports.isBinaryFile = isBinaryFile;
 exports.isEffectivelyEmpty = isEffectivelyEmpty;
 exports.isInteractive = isInteractive;
+exports.isNewer = isNewer;
 exports.isResolvedConfig = isResolvedConfig;
 exports.isSensitivePath = isSensitivePath;
 exports.listPresetNames = listPresetNames;
@@ -8081,6 +8338,7 @@ exports.resolveConfig = resolveConfig;
 exports.resolveSafeOutputDirs = resolveSafeOutputDirs;
 exports.runInit = runInit;
 exports.scanAndRedactSecrets = scanAndRedactSecrets;
+exports.shouldCheck = shouldCheck;
 exports.stripJsonComments = stripJsonComments;
 exports.summarizeJson = summarizeJson;
 exports.summarizeMarkdown = summarizeMarkdown;