codebase-snapshot 0.9.5 → 0.9.7

package/dist/cli.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 var childProcess = require('child_process');
-var fs11 = require('fs');
-var path12 = require('path');
+var fs12 = require('fs');
+var path13 = require('path');
 var util = require('util');
 var crypto2 = require('crypto');
 var module$1 = require('module');
@@ -11,6 +11,7 @@ var readline = require('readline');
 var async_hooks = require('async_hooks');
 var os = require('os');
 var ts = require('typescript');
+var https = require('https');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -33,12 +34,13 @@ function _interopNamespace(e) {
 }
 
 var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
-var fs11__namespace = /*#__PURE__*/_interopNamespace(fs11);
-var path12__namespace = /*#__PURE__*/_interopNamespace(path12);
+var fs12__namespace = /*#__PURE__*/_interopNamespace(fs12);
+var path13__namespace = /*#__PURE__*/_interopNamespace(path13);
 var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var ts__default = /*#__PURE__*/_interopDefault(ts);
+var https__namespace = /*#__PURE__*/_interopNamespace(https);
 
 // src/cli.ts
 var MANIFEST_FILES = [
@@ -87,15 +89,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();
@@ -155,7 +157,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 [];
   }
@@ -191,12 +193,12 @@ function scanWorkspacePackages(cwd, patterns) {
   const files = /* @__PURE__ */ new Set();
   const dependencies = /* @__PURE__ */ new Set();
   for (const relative11 of workspacePackageDirs(cwd, patterns)) {
-    const full = path12__namespace.join(cwd, relative11);
+    const full = path13__namespace.join(cwd, relative11);
     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);
     }
@@ -213,7 +215,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;
     }
@@ -224,7 +226,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;
@@ -233,7 +235,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);
     }
@@ -250,7 +252,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);
@@ -1525,14 +1527,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 relative11 = path12__namespace.relative(root, candidate);
-  return relative11 === "" || !relative11.startsWith(`..${path12__namespace.sep}`) && relative11 !== ".." && !path12__namespace.isAbsolute(relative11);
+  const relative11 = path13__namespace.relative(root, candidate);
+  return relative11 === "" || !relative11.startsWith(`..${path13__namespace.sep}`) && relative11 !== ".." && !path13__namespace.isAbsolute(relative11);
 }
 function getGitInfo(cwd, fallbackBranch = "main") {
   try {
@@ -1737,10 +1739,10 @@ function trimUnescapedTrailingSpaces(line) {
   return line.slice(0, end);
 }
 function readGitignoreRules(dir) {
-  const gitignorePath2 = path12__namespace.join(dir, ".gitignore");
+  const gitignorePath2 = path13__namespace.join(dir, ".gitignore");
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(gitignorePath2, "utf8");
+    raw = fs12__namespace.readFileSync(gitignorePath2, "utf8");
   } catch {
     return [];
   }
@@ -1867,7 +1869,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;
   }
@@ -1881,7 +1883,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;
@@ -1896,7 +1898,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;
       }
@@ -1909,7 +1911,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();
@@ -1919,7 +1921,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;
       }
@@ -1930,10 +1932,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);
@@ -2010,7 +2012,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."
         );
@@ -2069,7 +2071,7 @@ function collectFiles(cwd, options = {}) {
 }
 function rootRealFor(root) {
   try {
-    return fs11__namespace.realpathSync(root);
+    return fs12__namespace.realpathSync(root);
   } catch {
     return root;
   }
@@ -2077,18 +2079,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),
@@ -2110,8 +2112,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({
@@ -2144,14 +2146,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;
@@ -2204,13 +2206,13 @@ var CONFIG_FILENAMES = [
 ];
 function findConfigFile(cwd) {
   for (const filename of CONFIG_FILENAMES) {
-    const fullPath = path12__namespace.join(cwd, filename);
-    if (fs11__namespace.existsSync(fullPath)) return fullPath;
+    const fullPath = path13__namespace.join(cwd, filename);
+    if (fs12__namespace.existsSync(fullPath)) return fullPath;
   }
-  const pkgJsonPath = path12__namespace.join(cwd, "package.json");
-  if (!fs11__namespace.existsSync(pkgJsonPath)) return null;
+  const pkgJsonPath = path13__namespace.join(cwd, "package.json");
+  if (!fs12__namespace.existsSync(pkgJsonPath)) return null;
   try {
-    const parsed = JSON.parse(fs11__namespace.readFileSync(pkgJsonPath, "utf8"));
+    const parsed = JSON.parse(fs12__namespace.readFileSync(pkgJsonPath, "utf8"));
     return parsed.snapshot === void 0 ? null : pkgJsonPath;
   } catch {
     return null;
@@ -2461,11 +2463,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)}).`
@@ -2499,10 +2501,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 };
@@ -2670,9 +2672,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 relative11 = path12__namespace.relative(cwd, absolute);
-    if (!relative11 || relative11 === ".." || relative11.startsWith(`..${path12__namespace.sep}`) || path12__namespace.isAbsolute(relative11)) {
+    const absolute = path13__namespace.resolve(cwd, dir);
+    const relative11 = path13__namespace.relative(cwd, absolute);
+    if (!relative11 || relative11 === ".." || relative11.startsWith(`..${path13__namespace.sep}`) || path13__namespace.isAbsolute(relative11)) {
       continue;
     }
     patterns.push(`${relative11.replace(/\\/g, "/")}/**`);
@@ -2791,11 +2793,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;
@@ -3021,7 +3023,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 countControlBytes(buffer) {
@@ -3188,13 +3190,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) {
@@ -3212,7 +3214,7 @@ function isBinaryFile(absolutePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        fs11__namespace.closeSync(fd);
+        fs12__namespace.closeSync(fd);
       } catch {
       }
     }
@@ -3225,33 +3227,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;
       }
@@ -3287,14 +3289,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;
   }
@@ -3352,8 +3354,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,
@@ -3364,7 +3366,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,
@@ -3386,7 +3388,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") {
@@ -3420,7 +3422,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);
@@ -3444,7 +3446,7 @@ function validateSnapshot(configInput) {
     }
     let statFailure = null;
     try {
-      fs11__namespace.statSync(confined);
+      fs12__namespace.statSync(confined);
     } catch (err) {
       statFailure = err;
     }
@@ -3464,7 +3466,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);
@@ -3479,7 +3481,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;
@@ -3693,9 +3695,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" });
       }
@@ -3956,14 +3958,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}.`);
   }
@@ -4114,10 +4116,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";
 }
 
@@ -4159,10 +4161,10 @@ function describeMatcher(matcher) {
   return String(matcher);
 }
 function normalizeTarget(cwd, target) {
-  const absolute = path12__namespace.resolve(cwd, target);
-  const relative11 = path12__namespace.relative(cwd, absolute);
-  if (relative11.startsWith("..") || path12__namespace.isAbsolute(relative11)) return target;
-  return relative11.split(path12__namespace.sep).join("/");
+  const absolute = path13__namespace.resolve(cwd, target);
+  const relative11 = path13__namespace.relative(cwd, absolute);
+  if (relative11.startsWith("..") || path13__namespace.isAbsolute(relative11)) return target;
+  return relative11.split(path13__namespace.sep).join("/");
 }
 function findRuleMatch(rules, relativePath) {
   return rules.find(
@@ -4181,20 +4183,20 @@ function findRecordedAncestor(skipped, relative11, 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 relative11 = normalizeTarget(config.cwd, target);
-  const absolute = path12__namespace.join(config.cwd, relative11);
+  const absolute = path13__namespace.join(config.cwd, relative11);
   const maskedPath2 = findSecretInPath(relative11, config.secretRules)?.masked ?? relative11;
   const result = {
     path: maskedPath2,
-    exists: fs11__namespace.existsSync(absolute),
+    exists: fs12__namespace.existsSync(absolute),
     included: false
   };
   const collection = collectFiles(config.cwd, {
@@ -4205,7 +4207,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((relative12) => relative12.length > 0 && !relative12.startsWith(".."))
   });
   if (!collection.files.includes(relative11)) {
@@ -4244,8 +4246,8 @@ function explainPath(config, target) {
   if (layerRule) result.layerMatch = describeMatcher(layerRule.match);
   const kindRule = findRuleMatch(config.kinds, relative11);
   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;
@@ -4304,15 +4306,15 @@ function renderExplainText(result) {
 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 {
@@ -4325,7 +4327,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}` };
@@ -4333,12 +4335,12 @@ function appendGitignoreEntries(cwd, entries) {
   return { added, note: null };
 }
 function gitignorePath(cwd, filePath) {
-  return path12__namespace.relative(cwd, filePath).split(path12__namespace.sep).join("/");
+  return path13__namespace.relative(cwd, filePath).split(path13__namespace.sep).join("/");
 }
 
 // src/version.ts
 var GENERATOR_NAME = "codebase-snapshot";
-var GENERATOR_VERSION = "0.9.5";
+var GENERATOR_VERSION = "0.9.7";
 var LEGACY_GENERATOR_NAMES = ["@ankurhalder/codebase-snapshot"];
 function isOurGeneratorName(name) {
   if (typeof name !== "string") return false;
@@ -4494,6 +4496,57 @@ function toggleIndex(selected, index) {
   else next.add(index);
   return next;
 }
+function isWideCodePoint(code) {
+  return code >= 4352 && code <= 4447 || // Hangul Jamo
+  code >= 11904 && code <= 12350 || // CJK radicals, Kangxi, CJK symbols
+  code >= 12353 && code <= 13311 || // kana through CJK compatibility
+  code >= 13312 && code <= 19903 || // CJK extension A
+  code >= 19968 && code <= 40959 || // CJK unified ideographs
+  code >= 40960 && code <= 42191 || // Yi
+  code >= 44032 && code <= 55203 || // Hangul syllables
+  code >= 63744 && code <= 64255 || // CJK compatibility ideographs
+  code >= 65072 && code <= 65135 || // CJK compatibility forms
+  code >= 65280 && code <= 65376 || // fullwidth forms
+  code >= 65504 && code <= 65510 || code >= 127744 && code <= 129535 || // emoji and pictographs
+  code >= 131072 && code <= 262141;
+}
+var ANSI_PATTERN = /\u001b\[[0-9;?]*[A-Za-z]/g;
+function displayWidth(line) {
+  let width = 0;
+  for (const character of line.replace(ANSI_PATTERN, "")) {
+    width += isWideCodePoint(character.codePointAt(0) ?? 0) ? 2 : 1;
+  }
+  return width;
+}
+function wrapOneLine(line, limit) {
+  if (displayWidth(line) <= limit) return [line];
+  const indent = /^[ \t]*/.exec(line)?.[0] ?? "";
+  const continuation = `${indent}  `;
+  const rows = [];
+  let prefix = indent;
+  let rest = line.slice(indent.length).trimEnd();
+  while (rest.length > 0) {
+    const room = limit - displayWidth(prefix);
+    if (room <= 0 || displayWidth(rest) <= room) {
+      rows.push(prefix + rest);
+      break;
+    }
+    let cut = room;
+    const space = rest.slice(0, room).lastIndexOf(" ");
+    if (space > 0) cut = space;
+    const taken = rest.slice(0, cut).trimEnd();
+    rows.push(`${prefix}${taken.length > 0 ? taken : rest.slice(0, cut)}`);
+    rest = rest.slice(cut).trimStart();
+    prefix = continuation;
+  }
+  return rows;
+}
+function wrapLines(text2, limit) {
+  const width = Math.max(8, Math.floor(limit));
+  const rows = [];
+  for (const line of text2.split("\n")) rows.push(...wrapOneLine(line, width));
+  return rows;
+}
 function marker(active) {
   return active ? "\u276F" : " ";
 }
@@ -4571,14 +4624,27 @@ var Frame = class {
   drawn = 0;
   draw(text2) {
     this.erase();
-    this.output.write(`${text2}
+    const rows = wrapLines(text2, this.width());
+    this.output.write(`${rows.join("\n")}
 `);
-    this.drawn = text2.split("\n").length;
+    this.drawn = rows.length;
   }
   erase() {
     if (this.drawn > 0) this.output.write(`\x1B[${this.drawn}A\x1B[0J`);
     this.drawn = 0;
   }
+  /**
+   * The usable width, in cells.
+   *
+   * Two cells of slack: an ambiguous-width glyph (`◆`, `❯`, `←`) renders two cells in some fonts
+   * and one in others, and a row that lands exactly on the last column is the one case a terminal
+   * may or may not wrap. Below that, a line cannot reach the edge to begin with.
+   */
+  width() {
+    const columns = this.output.columns;
+    if (typeof columns !== "number" || !Number.isFinite(columns) || columns <= 0) return 80;
+    return Math.max(8, Math.floor(columns) - 2);
+  }
 };
 function isCancel(key) {
   return key.ctrl === true && key.name === "c" || key.ctrl === true && key.name === "d";
@@ -4760,10 +4826,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";
@@ -4777,7 +4843,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;
@@ -4798,7 +4864,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 [];
   }
@@ -4811,7 +4877,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}`;
@@ -4822,7 +4888,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;
@@ -4857,19 +4923,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.");
@@ -5161,7 +5227,7 @@ async function runInit(options) {
   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) {
@@ -5170,7 +5236,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) {
@@ -5203,7 +5269,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);
@@ -5225,9 +5291,9 @@ async function runInit(options) {
   };
 }
 function describeTarget(cwd) {
-  const relative11 = path12__namespace.relative(process.cwd(), cwd);
+  const relative11 = path13__namespace.relative(process.cwd(), cwd);
   if (relative11 === "") return "this directory";
-  if (relative11.startsWith("..") || path12__namespace.isAbsolute(relative11)) return cwd;
+  if (relative11.startsWith("..") || path13__namespace.isAbsolute(relative11)) return cwd;
   return relative11;
 }
 function firstRunMessage(reason, cwd) {
@@ -5251,7 +5317,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;
   }
@@ -5259,7 +5325,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;
   }
@@ -5489,9 +5555,9 @@ var JAVA_METHOD = /^\s+(?:public|private|protected)\s+(?:static\s+)?(?:final\s+)
 var jvmProfile = {
   id: "jvm",
   extensions: [".java", ".kt", ".kts", ".scala"],
-  summarize(path18, content) {
+  summarize(path19, content) {
     const summary = emptySummary();
-    const lower = path18.toLowerCase();
+    const lower = path19.toLowerCase();
     const isJava = lower.endsWith(".java");
     const isKotlin = lower.endsWith(".kt") || lower.endsWith(".kts");
     eachLine(content, (line) => {
@@ -5944,16 +6010,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(path18) {
-  const base = path18.split("/").pop() ?? path18;
+function componentName(path19) {
+  const base = path19.split("/").pop() ?? path19;
   return base.replace(/\.[^.]+$/, "");
 }
 var sfcProfile = {
   id: "sfc",
   extensions: [".vue", ".svelte", ".astro"],
-  summarize(path18, content) {
+  summarize(path19, content) {
     let script = "";
-    if (path18.toLowerCase().endsWith(".astro")) {
+    if (path19.toLowerCase().endsWith(".astro")) {
       const frontmatter = ASTRO_FRONTMATTER.exec(content);
       if (frontmatter) script += `${frontmatter[1]}
 `;
@@ -5962,7 +6028,7 @@ var sfcProfile = {
       script += `${match[1]}
 `;
     }
-    const name = componentName(path18);
+    const name = componentName(path19);
     if (!script.trim()) {
       const summary2 = emptySummary();
       if (name) {
@@ -5996,15 +6062,15 @@ for (const profile of LANGUAGE_PROFILES) {
     BY_EXTENSION.set(extension.toLowerCase(), profile);
   }
 }
-function profileForPath(path18) {
-  const lower = path18.toLowerCase();
+function profileForPath(path19) {
+  const lower = path19.toLowerCase();
   const dot = lower.lastIndexOf(".");
   if (dot === -1) return null;
   return BY_EXTENSION.get(lower.slice(dot)) ?? null;
 }
-function summarizeWithProfile(path18, content) {
-  const profile = profileForPath(path18);
-  return profile ? profile.summarize(path18, content) : null;
+function summarizeWithProfile(path19, content) {
+  const profile = profileForPath(path19);
+  return profile ? profile.summarize(path19, content) : null;
 }
 
 // src/ast/structured.ts
@@ -6849,6 +6915,162 @@ function generateProjectTree(filePaths) {
   const fence = fenceForText(lines.join("\n"), 3);
   return ["# Project Tree", "", `${fence}text`, ...lines, fence, ""].join("\n");
 }
+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((resolve9) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve9(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`;
+}
 
 // src/index.ts
 var SCHEMA_VERSION = "3.0.0";
@@ -6930,13 +7152,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);
     }
@@ -6945,8 +7167,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);
@@ -7039,11 +7261,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}`
@@ -7099,14 +7321,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 relative11 = prefix === "" ? child.name : `${prefix}/${child.name}`;
       entries.push(relative11);
-      if (child.isDirectory()) walk(path12__namespace.join(absolute, child.name), relative11);
+      if (child.isDirectory()) walk(path13__namespace.join(absolute, child.name), relative11);
     }
   };
   walk(dir, "");
@@ -7123,28 +7345,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" };
   }
@@ -7212,11 +7434,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,
@@ -7298,13 +7520,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;
       }
@@ -7313,13 +7535,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;
@@ -7339,18 +7561,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;
     }
@@ -7358,7 +7580,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;
     }
@@ -7373,13 +7595,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);
@@ -7387,33 +7609,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}).`
@@ -7422,7 +7644,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,
@@ -7431,22 +7653,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(
@@ -7459,7 +7681,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();
@@ -7468,7 +7690,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;
   }
@@ -7488,12 +7710,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;
@@ -7516,31 +7738,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;
   }
@@ -7635,7 +7857,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((relative11) => relative11.length > 0 && !relative11.startsWith(".."))
   });
   const files = [];
@@ -7656,12 +7878,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,
@@ -7681,7 +7903,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;
@@ -8011,12 +8233,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 = crypto2__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,
@@ -8026,41 +8248,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);
@@ -8069,7 +8291,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));
     };
@@ -8092,7 +8314,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 {
       }
     }
@@ -8189,9 +8411,9 @@ function foldForComparison(value) {
   return process.platform === "win32" || process.platform === "darwin" ? value.toLowerCase() : value;
 }
 function canonicalPath(value) {
-  const absolute = path12__namespace.resolve(value);
+  const absolute = path13__namespace.resolve(value);
   try {
-    return fs11__namespace.realpathSync(absolute);
+    return fs12__namespace.realpathSync(absolute);
   } catch {
     return absolute;
   }
@@ -8199,17 +8421,17 @@ function canonicalPath(value) {
 function isInside2(parent, child) {
   const foldedParent = foldForComparison(parent);
   const foldedChild = foldForComparison(child);
-  return foldedChild === foldedParent || foldedChild.startsWith(`${foldedParent}${path12__namespace.sep}`);
+  return foldedChild === foldedParent || foldedChild.startsWith(`${foldedParent}${path13__namespace.sep}`);
 }
 function resolveRoot(requested, context) {
   if (requested !== void 0 && (typeof requested !== "string" || requested.trim().length === 0)) {
     return { ok: false, message: '"root" must be a non-empty string when provided.' };
   }
   const wanted = typeof requested === "string" ? requested.trim() : context.cwd;
-  const absolute = path12__namespace.resolve(context.cwd, wanted);
+  const absolute = path13__namespace.resolve(context.cwd, wanted);
   let stats;
   try {
-    stats = fs11__namespace.statSync(absolute);
+    stats = fs12__namespace.statSync(absolute);
   } catch {
     return { ok: false, message: `"${wanted}" does not exist, so it cannot be a repository root.` };
   }
@@ -8260,14 +8482,14 @@ async function openWorkspace(root, overrides = {}) {
 }
 var manifestCache = /* @__PURE__ */ new Map();
 function manifestPathFor(workspace) {
-  return path12__namespace.resolve(workspace.root, workspace.config.outDir, "manifest.json");
+  return path13__namespace.resolve(workspace.root, workspace.config.outDir, "manifest.json");
 }
 function readManifest3(workspace) {
   const file = manifestPathFor(workspace);
-  const shown = path12__namespace.relative(workspace.root, file).split(path12__namespace.sep).join("/") || file;
+  const shown = path13__namespace.relative(workspace.root, file).split(path13__namespace.sep).join("/") || file;
   let stats;
   try {
-    stats = fs11__namespace.statSync(file);
+    stats = fs12__namespace.statSync(file);
   } catch {
     return {
       ok: false,
@@ -8281,7 +8503,7 @@ function readManifest3(workspace) {
   }
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(file, "utf8");
+    raw = fs12__namespace.readFileSync(file, "utf8");
   } catch (error) {
     return {
       ok: false,
@@ -8339,7 +8561,7 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 function relativeFor(workspace, absolute) {
-  return path12__namespace.relative(workspace.root, absolute).split(path12__namespace.sep).join("/");
+  return path13__namespace.relative(workspace.root, absolute).split(path13__namespace.sep).join("/");
 }
 function capped(values, limit = 20) {
   return { count: values.length, sample: values.slice(0, limit) };
@@ -8358,12 +8580,12 @@ function summarizeDrift(drift) {
 function toRelativePath(root, value) {
   const cleaned = value.trim();
   if (cleaned.length === 0) return null;
-  if (!path12__namespace.isAbsolute(cleaned)) {
+  if (!path13__namespace.isAbsolute(cleaned)) {
     return cleaned.replace(/\\/g, "/").replace(/^\.\//, "");
   }
-  const relative11 = path12__namespace.relative(root, cleaned);
-  if (relative11.startsWith("..") || path12__namespace.isAbsolute(relative11)) return null;
-  return relative11.split(path12__namespace.sep).join("/");
+  const relative11 = path13__namespace.relative(root, cleaned);
+  if (relative11.startsWith("..") || path13__namespace.isAbsolute(relative11)) return null;
+  return relative11.split(path13__namespace.sep).join("/");
 }
 function symbolsOf(entry) {
   const summary = entry.summary;
@@ -8574,7 +8796,7 @@ var generateTool = {
       return failure(error instanceof Error ? error.message : String(error));
     }
     forgetManifest(manifestPathFor(workspace));
-    const written = relativeFor(workspace, path12__namespace.resolve(workspace.root, workspace.config.outDir));
+    const written = relativeFor(workspace, path13__namespace.resolve(workspace.root, workspace.config.outDir));
     const lines = [
       `Wrote ${written}/`,
       `Files: ${manifest.counts.totalFiles} included, ${manifest.counts.skippedCount} skipped, ${plural(manifest.counts.partsCount, "part")}`,
@@ -8839,10 +9061,10 @@ var readTool = {
         `${relativePath} is not in the snapshot. Call snapshot_locate to find the path, or snapshot_explain to learn why it was excluded.`
       );
     }
-    const partPath = path12__namespace.resolve(workspace.root, workspace.config.outDir, "parts", entry.part);
+    const partPath = path13__namespace.resolve(workspace.root, workspace.config.outDir, "parts", entry.part);
     let partText;
     try {
-      partText = fs11__namespace.readFileSync(partPath, "utf8");
+      partText = fs12__namespace.readFileSync(partPath, "utf8");
     } catch {
       return failure(
         `${entry.part} could not be read, so the snapshot is damaged. Run snapshot_generate to rebuild it.`
@@ -9100,6 +9322,7 @@ var VALIDATE_OPTIONS = [
   "no-config",
   "discovery",
   "format",
+  "no-update-check",
   "mode",
   "help",
   "version"
@@ -9123,6 +9346,7 @@ var COMMAND_OPTION_SCOPE = {
     "watch",
     "autopilot",
     "no-install",
+    "no-update-check",
     "help",
     "version"
   ],
@@ -9138,6 +9362,7 @@ var COMMAND_OPTION_SCOPE = {
     "skip-artifacts",
     "only-artifacts",
     "no-config",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9155,12 +9380,13 @@ var COMMAND_OPTION_SCOPE = {
     "only-artifacts",
     "no-config",
     "discovery",
+    "no-update-check",
     "format",
     "mode",
     "help",
     "version"
   ],
-  diff: ["format", "mode", "no-config", "help", "version"],
+  diff: ["format", "mode", "no-config", "no-update-check", "help", "version"],
   describe: ["format", "mode", "help", "version"],
   init: [
     "cwd",
@@ -9175,6 +9401,7 @@ var COMMAND_OPTION_SCOPE = {
     "yes",
     "force",
     "dry-run",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9198,6 +9425,7 @@ var COMMAND_OPTION_SCOPE = {
     "force",
     "no-install",
     "dry-run",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9630,6 +9858,13 @@ function buildAgentContract() {
         default: false,
         appliesTo: optionAppliesTo("no-install"),
         summary: "Skip installing the dependency before generating: `setup`, or `generate --autopilot` (CI, offline, or a lockfile you do not want a package manager to touch)."
+      },
+      {
+        flag: "--no-update-check",
+        type: "boolean",
+        default: false,
+        appliesTo: optionAppliesTo("no-update-check"),
+        summary: "Skip the once-a-day check for a newer published version. The check is already skipped when stdout is not a terminal, in CI, in a JSON invocation, and in `mcp`, which makes no network requests."
       }
     ],
     presets: PRESETS.map((preset) => ({
@@ -9917,17 +10152,17 @@ var LEGACY_AGENTS_MARKER = "<!-- codebase-snapshot:skill:start -->";
 function targetPath(cwd, target) {
   switch (target) {
     case "claude":
-      return path12__namespace.join(cwd, ".claude", "skills", SKILL_NAME, "SKILL.md");
+      return path13__namespace.join(cwd, ".claude", "skills", SKILL_NAME, "SKILL.md");
     case "cursor":
-      return path12__namespace.join(cwd, ".cursor", "rules", `${SKILL_NAME}.mdc`);
+      return path13__namespace.join(cwd, ".cursor", "rules", `${SKILL_NAME}.mdc`);
   }
 }
 function assertWritableInsideRepository(cwd, filePath) {
-  const root = fs11__namespace.realpathSync(cwd);
-  const shown = path12__namespace.relative(root, filePath) || filePath;
+  const root = fs12__namespace.realpathSync(cwd);
+  const shown = path13__namespace.relative(root, filePath) || filePath;
   let stat = null;
   try {
-    stat = fs11__namespace.lstatSync(filePath);
+    stat = fs12__namespace.lstatSync(filePath);
   } catch {
     stat = null;
   }
@@ -9943,32 +10178,32 @@ function assertWritableInsideRepository(cwd, filePath) {
   }
   let existing = filePath;
   const missing = [];
-  while (!fs11__namespace.existsSync(existing)) {
-    missing.unshift(path12__namespace.basename(existing));
-    const parent = path12__namespace.dirname(existing);
+  while (!fs12__namespace.existsSync(existing)) {
+    missing.unshift(path13__namespace.basename(existing));
+    const parent = path13__namespace.dirname(existing);
     if (parent === existing) break;
     existing = parent;
   }
-  const realAncestor = fs11__namespace.realpathSync(existing);
-  const resolved = missing.length === 0 ? realAncestor : path12__namespace.join(realAncestor, ...missing);
-  if (resolved !== root && !resolved.startsWith(`${root}${path12__namespace.sep}`)) {
+  const realAncestor = fs12__namespace.realpathSync(existing);
+  const resolved = missing.length === 0 ? realAncestor : path13__namespace.join(realAncestor, ...missing);
+  if (resolved !== root && !resolved.startsWith(`${root}${path13__namespace.sep}`)) {
     throw new Error(
       `${REFUSED}: ${shown} resolves outside the repository (${resolved}). Move it back inside ${root}, or remove the link, and run again.`
     );
   }
 }
 function writeIfChanged(target, filePath, content) {
-  const existing = fs11__namespace.existsSync(filePath) ? fs11__namespace.readFileSync(filePath, "utf8") : null;
+  const existing = fs12__namespace.existsSync(filePath) ? fs12__namespace.readFileSync(filePath, "utf8") : null;
   if (existing === content) return { target, path: filePath, action: "unchanged" };
-  fs11__namespace.mkdirSync(path12__namespace.dirname(filePath), { recursive: true });
-  fs11__namespace.writeFileSync(filePath, content, "utf8");
+  fs12__namespace.mkdirSync(path13__namespace.dirname(filePath), { recursive: true });
+  fs12__namespace.writeFileSync(filePath, content, "utf8");
   return { target, path: filePath, action: existing === null ? "created" : "updated" };
 }
 function legacyAgentsNote(cwd) {
-  const filePath = path12__namespace.join(cwd, "AGENTS.md");
+  const filePath = path13__namespace.join(cwd, "AGENTS.md");
   try {
-    if (!fs11__namespace.existsSync(filePath)) return null;
-    if (!fs11__namespace.readFileSync(filePath, "utf8").includes(LEGACY_AGENTS_MARKER)) return null;
+    if (!fs12__namespace.existsSync(filePath)) return null;
+    if (!fs12__namespace.readFileSync(filePath, "utf8").includes(LEGACY_AGENTS_MARKER)) return null;
   } catch {
     return null;
   }
@@ -9980,9 +10215,9 @@ function installSkill(cwd, target = "all") {
   const notes = [];
   const wanted = target === "all" ? ["claude", "cursor"] : [target];
   for (const item of wanted) assertWritableInsideRepository(cwd, targetPath(cwd, item));
-  const createsSomething = wanted.some((item) => !fs11__namespace.existsSync(targetPath(cwd, item)));
+  const createsSomething = wanted.some((item) => !fs12__namespace.existsSync(targetPath(cwd, item)));
   if (createsSomething) {
-    assertWritableInsideRepository(cwd, path12__namespace.join(cwd, ".gitignore"));
+    assertWritableInsideRepository(cwd, path13__namespace.join(cwd, ".gitignore"));
   }
   for (const item of wanted) {
     written.push(writeIfChanged(item, targetPath(cwd, item), skill));
@@ -10117,52 +10352,52 @@ function validateArguments(schema, value) {
   }
   return problems;
 }
-function checkValue(path18, schema, value) {
+function checkValue(path19, schema, value) {
   if (schema.enum && !schema.enum.includes(value)) {
-    return [`"${path18}" must be one of: ${schema.enum.join(", ")}`];
+    return [`"${path19}" must be one of: ${schema.enum.join(", ")}`];
   }
   switch (schema.type) {
     case "string": {
-      if (typeof value !== "string") return [`"${path18}" must be a string`];
+      if (typeof value !== "string") return [`"${path19}" must be a string`];
       const problems = [];
       if (schema.minLength !== void 0 && value.length < schema.minLength) {
-        problems.push(`"${path18}" must be at least ${schema.minLength} character(s)`);
+        problems.push(`"${path19}" must be at least ${schema.minLength} character(s)`);
       }
       if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
-        problems.push(`"${path18}" must be at most ${schema.maxLength} character(s)`);
+        problems.push(`"${path19}" must be at most ${schema.maxLength} character(s)`);
       }
       return problems;
     }
     case "number":
     case "integer": {
       if (typeof value !== "number" || Number.isNaN(value)) {
-        return [`"${path18}" must be a number`];
+        return [`"${path19}" must be a number`];
       }
       if (schema.type === "integer" && !Number.isInteger(value)) {
-        return [`"${path18}" must be an integer`];
+        return [`"${path19}" must be an integer`];
       }
       const problems = [];
       if (schema.minimum !== void 0 && value < schema.minimum) {
-        problems.push(`"${path18}" must be >= ${schema.minimum}`);
+        problems.push(`"${path19}" must be >= ${schema.minimum}`);
       }
       if (schema.maximum !== void 0 && value > schema.maximum) {
-        problems.push(`"${path18}" must be <= ${schema.maximum}`);
+        problems.push(`"${path19}" must be <= ${schema.maximum}`);
       }
       return problems;
     }
     case "boolean":
-      return typeof value === "boolean" ? [] : [`"${path18}" must be a boolean`];
+      return typeof value === "boolean" ? [] : [`"${path19}" must be a boolean`];
     case "array": {
-      if (!Array.isArray(value)) return [`"${path18}" must be an array`];
+      if (!Array.isArray(value)) return [`"${path19}" must be an array`];
       if (!schema.items) return [];
       const problems = [];
       value.forEach((item, index) => {
-        problems.push(...checkValue(`${path18}[${index}]`, schema.items, item));
+        problems.push(...checkValue(`${path19}[${index}]`, schema.items, item));
       });
       return problems;
     }
     case "object":
-      return isJsonObject(value) ? [] : [`"${path18}" must be an object`];
+      return isJsonObject(value) ? [] : [`"${path19}" must be an object`];
     default:
       return [];
   }
@@ -10176,6 +10411,18 @@ function applyDefaults(schema, value) {
   }
   return out;
 }
+function coerceNumericStrings(schema, value) {
+  const out = { ...value };
+  for (const [key, propertySchema] of Object.entries(schema.properties)) {
+    const raw = out[key];
+    if (typeof raw !== "string") continue;
+    if (propertySchema.type !== "number" && propertySchema.type !== "integer") continue;
+    if (raw.trim().length === 0) continue;
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed)) out[key] = parsed;
+  }
+  return out;
+}
 
 // src/mcp/server.ts
 function capabilities() {
@@ -10264,7 +10511,8 @@ function createMcpServer(options) {
     if (!isJsonObject(rawArguments)) {
       return errorResponse(id, ERROR_CODES.invalidParams, '"arguments" must be a JSON object.');
     }
-    const problems = validateArguments(tool.inputSchema, rawArguments);
+    const supplied = coerceNumericStrings(tool.inputSchema, rawArguments);
+    const problems = validateArguments(tool.inputSchema, supplied);
     if (problems.length > 0) {
       return ok(
         id,
@@ -10276,7 +10524,7 @@ function createMcpServer(options) {
         modern
       );
     }
-    const args = applyDefaults(tool.inputSchema, rawArguments);
+    const args = applyDefaults(tool.inputSchema, supplied);
     let outcome;
     try {
       outcome = await tool.handler(args, options.context);
@@ -10474,7 +10722,7 @@ async function workspaceFor(context) {
 }
 function readFileIfPresent(file) {
   try {
-    return fs11__namespace.readFileSync(file, "utf8");
+    return fs12__namespace.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -10553,7 +10801,7 @@ function buildResourceProvider() {
       const report = REPORT_URIS.get(uri);
       if (report) {
         const text2 = readFileIfPresent(
-          path12__namespace.resolve(workspace.root, workspace.config.outDir, "reports", report.file)
+          path13__namespace.resolve(workspace.root, workspace.config.outDir, "reports", report.file)
         );
         if (text2 === null) return null;
         return { uri, mimeType: "text/markdown", text: capUtf8(text2, MAX_RESOURCE_BYTES).text };
@@ -10572,7 +10820,7 @@ function buildResourceProvider() {
         const part = read.manifest.parts.find((candidate) => candidate.index === index);
         if (!part) return null;
         const text2 = readFileIfPresent(
-          path12__namespace.resolve(workspace.root, workspace.config.outDir, "parts", part.filename)
+          path13__namespace.resolve(workspace.root, workspace.config.outDir, "parts", part.filename)
         );
         if (text2 === null) return null;
         return { uri, mimeType: "text/markdown", text: capUtf8(text2, MAX_RESOURCE_BYTES).text };
@@ -10810,6 +11058,7 @@ var CLI_OPTIONS = {
   install: { type: "boolean" },
   "no-install": { type: "boolean" },
   target: { type: "string" },
+  "no-update-check": { type: "boolean" },
   help: { type: "boolean", short: "h" },
   version: { type: "boolean", short: "v" }
 };
@@ -10884,6 +11133,8 @@ Options:
   --install                     Write the skill into the repository instead of printing
   --target <name>               claude | cursor | all (default: all)
 
+  --no-update-check             Skip the daily check for a newer published version
+
   -h, --help                    Display this help message
   -v, --version                 Display version
 
@@ -10960,10 +11211,10 @@ function parseCliArgs(argv) {
   }
   if (values.cwd !== void 0) {
     const target = String(values.cwd);
-    if (!fs11__namespace.existsSync(target)) {
+    if (!fs12__namespace.existsSync(target)) {
       throw new UsageError(`--cwd directory does not exist: ${target}`);
     }
-    if (!fs11__namespace.statSync(target).isDirectory()) {
+    if (!fs12__namespace.statSync(target).isDirectory()) {
       throw new UsageError(`--cwd is not a directory: ${target}`);
     }
   }
@@ -11109,7 +11360,7 @@ function parseCliArgs(argv) {
     install: values.install === true,
     noInstall: values["no-install"] === true,
     target: values.target === void 0 ? void 0 : String(values.target),
-    cwd: values.cwd === void 0 ? process.cwd() : path12__namespace.resolve(String(values.cwd)),
+    cwd: values.cwd === void 0 ? process.cwd() : path13__namespace.resolve(String(values.cwd)),
     outDir: values["out-dir"] === void 0 ? void 0 : String(values["out-dir"]),
     includeMonolith: values["include-monolith"] === true || onlyNamesMonolith === true ? true : void 0,
     includeSensitiveFiles: values["include-sensitive-files"] === true ? true : void 0,
@@ -11166,24 +11417,24 @@ function splitList(value) {
   return value.split(",").map((entry) => entry.trim()).filter(Boolean);
 }
 function displayOutPath(cwd, outDir, ...segments) {
-  const absolute = path12__namespace.resolve(cwd, outDir, ...segments);
-  const relative11 = path12__namespace.relative(cwd, absolute);
-  if (relative11 && !relative11.startsWith("..") && !path12__namespace.isAbsolute(relative11)) return relative11;
+  const absolute = path13__namespace.resolve(cwd, outDir, ...segments);
+  const relative11 = path13__namespace.relative(cwd, absolute);
+  if (relative11 && !relative11.startsWith("..") && !path13__namespace.isAbsolute(relative11)) return relative11;
   return absolute;
 }
 function nextStepHint(cwd, scriptsAddedNow) {
   let hasScript = scriptsAddedNow;
   if (!hasScript) {
     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"));
       hasScript = typeof parsed.scripts?.snapshot === "string";
     } catch {
       hasScript = false;
     }
   }
   if (!hasScript) return `npx ${GENERATOR_NAME} generate`;
-  const bin = path12__namespace.join(cwd, "node_modules", ".bin", "codebase-snapshot");
-  const installed = fs11__namespace.existsSync(bin) || fs11__namespace.existsSync(`${bin}.cmd`);
+  const bin = path13__namespace.join(cwd, "node_modules", ".bin", "codebase-snapshot");
+  const installed = fs12__namespace.existsSync(bin) || fs12__namespace.existsSync(`${bin}.cmd`);
   return installed ? "npm run snapshot" : "npm install && npm run snapshot";
 }
 function presetSummary(init) {
@@ -11213,7 +11464,7 @@ async function runInitCommand(invocation) {
       info(result.configText);
       return 0;
     }
-    info(`\u2705 Created ${path12__namespace.basename(result.configPath)} (${presetSummary(result)})`);
+    info(`\u2705 Created ${path13__namespace.basename(result.configPath)} (${presetSummary(result)})`);
     if (result.scripts.length > 0) info(`   Added npm scripts: ${result.scripts.join(", ")}`);
     if (result.dependency.added && result.dependency.range !== null) {
       info(`   Added devDependency: ${result.dependency.name} ${result.dependency.range}`);
@@ -11233,7 +11484,7 @@ async function runInitCommand(invocation) {
   }
 }
 function detectPackageManager(cwd) {
-  const has = (name) => fs11__namespace.existsSync(path12__namespace.join(cwd, name));
+  const has = (name) => fs12__namespace.existsSync(path13__namespace.join(cwd, name));
   if (has("bun.lockb") || has("bun.lock")) return { name: "bun", command: "bun", args: ["install"] };
   if (has("pnpm-lock.yaml")) return { name: "pnpm", command: "pnpm", args: ["install"] };
   if (has("yarn.lock")) return { name: "yarn", command: "yarn", args: ["install"] };
@@ -11322,7 +11573,7 @@ async function runSetupCommand(invocation, options = {}) {
       }
       info("\n\u{1F9EA} Dry run \u2014 setup would:");
       info(
-        `   1. ${init.reused ? `keep ${path12__namespace.basename(init.configPath)}` : `write ${path12__namespace.basename(init.configPath)} (preset: ${init.preset})`}`
+        `   1. ${init.reused ? `keep ${path13__namespace.basename(init.configPath)}` : `write ${path13__namespace.basename(init.configPath)} (preset: ${init.preset})`}`
       );
       info("   2. add the npm scripts, the devDependency and the .gitignore entries");
       if (manager !== null) info(`   3. install with ${manager}`);
@@ -11334,9 +11585,9 @@ async function runSetupCommand(invocation, options = {}) {
     if (invocation.format !== "json") {
       if (!interactive) info(`\u{1F680} Setup for: ${invocation.cwd}`);
       if (init.reused) {
-        info(`\u267B  Keeping ${path12__namespace.basename(init.configPath)} (${presetSummary(init)})`);
+        info(`\u267B  Keeping ${path13__namespace.basename(init.configPath)} (${presetSummary(init)})`);
       } else {
-        info(`\u2705 Created ${path12__namespace.basename(init.configPath)} (${presetSummary(init)})`);
+        info(`\u2705 Created ${path13__namespace.basename(init.configPath)} (${presetSummary(init)})`);
       }
       if (init.scripts.length > 0) info(`   Added npm scripts: ${init.scripts.join(", ")}`);
       if (init.dependency.added && init.dependency.range !== null) {
@@ -11444,7 +11695,7 @@ function runSkillCommand(invocation) {
     }
     info(`\u2705 Agent skill installed (${SKILL_NAME}):`);
     for (const item of result.written) {
-      const shown = path12__namespace.relative(invocation.cwd, item.path) || item.path;
+      const shown = path13__namespace.relative(invocation.cwd, item.path) || item.path;
       info(`   - ${item.action.padEnd(9)} ${shown}`);
     }
     if (result.gitignored.length > 0) {
@@ -11508,6 +11759,17 @@ function requestsJsonFormat(argv) {
   return format === "json";
 }
 async function main(argv = process.argv.slice(2)) {
+  const pending = process.stdout.isTTY === true && shouldCheck(argv, process.env) ? checkForUpdate({ current: GENERATOR_VERSION, cacheFile: cacheFilePath() }) : null;
+  const code = await runCommand(argv);
+  if (pending) {
+    const notice = await pending;
+    if (notice) process.stderr.write(`
+${formatUpdateNotice(notice)}
+`);
+  }
+  return code;
+}
+async function runCommand(argv) {
   let invocation;
   try {
     invocation = parseCliArgs(argv);
@@ -11540,7 +11802,7 @@ ${USAGE}
     return runSkillCommand(invocation);
   }
   if (invocation.command === "mcp") {
-    return await runStdioServer({ cwd: path12__namespace.resolve(invocation.cwd) });
+    return await runStdioServer({ cwd: path13__namespace.resolve(invocation.cwd) });
   }
   if (invocation.command === "setup") {
     return runSetupCommand(invocation);
@@ -11557,7 +11819,7 @@ ${USAGE}
     warn("\u274C The config file could not be read. Fix it, or delete it to use the defaults.");
     return 1;
   }
-  if (loaded.file) info(`\u2699  Using config ${path12__namespace.relative(process.cwd(), loaded.file) || loaded.file}`);
+  if (loaded.file) info(`\u2699  Using config ${path13__namespace.relative(process.cwd(), loaded.file) || loaded.file}`);
   const resolved = resolveConfig(
     loaded.config,
     {
@@ -11579,10 +11841,10 @@ ${USAGE}
   if (invocation.command === "validate") {
     const result = validateSnapshot(resolved);
     if (result.valid) {
-      const manifestPath = path12__namespace.resolve(resolved.cwd, resolved.outDir, "manifest.json");
+      const manifestPath = path13__namespace.resolve(resolved.cwd, resolved.outDir, "manifest.json");
       let manifest;
       try {
-        manifest = JSON.parse(fs11__namespace.readFileSync(manifestPath, "utf8"));
+        manifest = JSON.parse(fs12__namespace.readFileSync(manifestPath, "utf8"));
       } catch {
         manifest = void 0;
       }
@@ -11595,13 +11857,13 @@ ${USAGE}
     return result.valid ? 0 : 1;
   }
   if (invocation.command === "report") {
-    const manifestPath = path12__namespace.resolve(resolved.cwd, resolved.outDir, "manifest.json");
-    if (!fs11__namespace.existsSync(manifestPath)) {
+    const manifestPath = path13__namespace.resolve(resolved.cwd, resolved.outDir, "manifest.json");
+    if (!fs12__namespace.existsSync(manifestPath)) {
       return fail(invocation.format, `Manifest not found at ${manifestPath}. Run generate first.`);
     }
     let manifest;
     try {
-      manifest = JSON.parse(fs11__namespace.readFileSync(manifestPath, "utf8"));
+      manifest = JSON.parse(fs12__namespace.readFileSync(manifestPath, "utf8"));
     } catch (err) {
       return fail(invocation.format, `Could not read ${manifestPath}: ${err.message}`);
     }
@@ -11765,20 +12027,20 @@ function finishWatchRun(state, now) {
   };
 }
 function comparablePath(value) {
-  const absolute = path12__namespace.resolve(value);
+  const absolute = path13__namespace.resolve(value);
   return process.platform === "win32" ? absolute.toLowerCase() : absolute;
 }
 function isSameOrInside(parent, candidate) {
-  const relative11 = path12__namespace.relative(parent, candidate);
-  return relative11 === "" || relative11 !== ".." && !relative11.startsWith(`..${path12__namespace.sep}`) && !path12__namespace.isAbsolute(relative11);
+  const relative11 = path13__namespace.relative(parent, candidate);
+  return relative11 === "" || relative11 !== ".." && !relative11.startsWith(`..${path13__namespace.sep}`) && !path13__namespace.isAbsolute(relative11);
 }
 function isGeneratedWatchPath(candidate, paths) {
-  const absolute = comparablePath(path12__namespace.resolve(paths.cwd, candidate));
-  const outDir = comparablePath(path12__namespace.resolve(paths.cwd, paths.outDir));
-  const tmpDir = comparablePath(path12__namespace.resolve(paths.cwd, paths.tmpDir));
+  const absolute = comparablePath(path13__namespace.resolve(paths.cwd, candidate));
+  const outDir = comparablePath(path13__namespace.resolve(paths.cwd, paths.outDir));
+  const tmpDir = comparablePath(path13__namespace.resolve(paths.cwd, paths.tmpDir));
   if (isSameOrInside(outDir, absolute) || isSameOrInside(tmpDir, absolute)) return true;
-  const parent = path12__namespace.dirname(absolute);
-  if (parent === path12__namespace.dirname(outDir) && path12__namespace.basename(absolute).startsWith(`${path12__namespace.basename(outDir)}.backup-`)) {
+  const parent = path13__namespace.dirname(absolute);
+  if (parent === path13__namespace.dirname(outDir) && path13__namespace.basename(absolute).startsWith(`${path13__namespace.basename(outDir)}.backup-`)) {
     return true;
   }
   return absolute.split(/[\\/]+/).some((segment) => VCS_SEGMENTS.has(segment));
@@ -11795,8 +12057,8 @@ function decideWatchEvent(state, event, paths) {
   return { state, action: "schedule" };
 }
 async function runWatchLoop(invocation, resolved) {
-  const outDir = path12__namespace.resolve(resolved.cwd, resolved.outDir);
-  const tmpDir = path12__namespace.resolve(resolved.cwd, resolved.tmpDir);
+  const outDir = path13__namespace.resolve(resolved.cwd, resolved.outDir);
+  const tmpDir = path13__namespace.resolve(resolved.cwd, resolved.tmpDir);
   const paths = { cwd: resolved.cwd, outDir, tmpDir };
   let state = initialWatchState();
   let timer = null;
@@ -11861,11 +12123,11 @@ async function runWatchLoop(invocation, resolved) {
   };
   info("\u{1F440} Watching for changes. Press Ctrl+C to stop.");
   void regenerate();
-  const watcher = fs11__namespace.watch(resolved.cwd, { recursive: true }, (_event, filename) => {
+  const watcher = fs12__namespace.watch(resolved.cwd, { recursive: true }, (_event, filename) => {
     const decision = decideWatchEvent(
       state,
       {
-        path: filename ? path12__namespace.resolve(resolved.cwd, filename.toString()) : null,
+        path: filename ? path13__namespace.resolve(resolved.cwd, filename.toString()) : null,
         now: performance.now()
       },
       paths
@@ -11893,7 +12155,7 @@ async function runWatchLoop(invocation, resolved) {
   return 0;
 }
 var entryFile = process.argv[1] ?? "";
-var entryName = path12__namespace.basename(entryFile).toLowerCase();
+var entryName = path13__namespace.basename(entryFile).toLowerCase();
 var invokedDirectly = entryName === "cli.js" || entryName === "cli.cjs";
 if (invokedDirectly) {
   void main().then(