codebase-snapshot 0.9.4 → 0.9.6

package/dist/bin.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { spawnSync } from "child_process";
-import * as fs16 from "fs";
-import * as path17 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 import { parseArgs } from "util";
 
 // src/diff.ts
@@ -4346,7 +4346,7 @@ function gitignorePath(cwd, filePath) {
 
 // src/version.ts
 var GENERATOR_NAME = "codebase-snapshot";
-var GENERATOR_VERSION = "0.9.4";
+var GENERATOR_VERSION = "0.9.6";
 var LEGACY_GENERATOR_NAMES = ["@ankurhalder/codebase-snapshot"];
 function isOurGeneratorName(name) {
   if (typeof name !== "string") return false;
@@ -4487,6 +4487,12 @@ var PromptCancelled = class extends Error {
     this.name = "PromptCancelled";
   }
 };
+var PromptBack = class extends Error {
+  constructor() {
+    super("Prompt back");
+    this.name = "PromptBack";
+  }
+};
 function defaultIO() {
   return { input: process.stdin, output: process.stdout };
 }
@@ -4510,35 +4516,40 @@ function choiceLine(choice, active) {
   const hint = choice.hint ? `  ${choice.hint}` : "";
   return `  ${marker(active)} ${choice.label}${hint}`;
 }
-function renderSelect(message, choices, index) {
+function listFooter(base, allowBack) {
+  return allowBack ? `${base} \xB7 \u2190 back` : base;
+}
+function renderSelect(message, choices, index, allowBack = false) {
   const lines = [`\u25C6 ${message}`, ""];
   choices.forEach((choice, position) => lines.push(choiceLine(choice, position === index)));
-  lines.push("", "  \u2191\u2193 move \xB7 enter select");
+  lines.push("", `  ${listFooter("\u2191\u2193 move \xB7 enter select", allowBack)}`);
   return lines.join("\n");
 }
-function renderMultiSelect(message, choices, index, selected) {
+function renderMultiSelect(message, choices, index, selected, allowBack = false) {
   const lines = [`\u25C6 ${message}`, ""];
   choices.forEach((choice, position) => {
     const box = selected.has(position) ? "\u25FC" : "\u25FB";
     const hint = choice.hint ? `  ${choice.hint}` : "";
     lines.push(`  ${marker(position === index)} ${box} ${choice.label}${hint}`);
   });
-  lines.push("", "  \u2191\u2193 move \xB7 space toggle \xB7 enter confirm");
+  lines.push("", `  ${listFooter("\u2191\u2193 move \xB7 space toggle \xB7 enter confirm", allowBack)}`);
   return lines.join("\n");
 }
-function renderConfirm(message, value) {
+function renderConfirm(message, value, allowBack = false) {
+  const footer = allowBack ? "\u2190\u2192 or y/n \xB7 enter confirm \xB7 b back" : "\u2190\u2192 or y/n \xB7 enter confirm";
   return [
     `\u25C6 ${message}`,
     "",
     `  ${marker(value)} Yes`,
     `  ${marker(!value)} No`,
     "",
-    "  \u2190\u2192 or y/n \xB7 enter confirm"
+    `  ${footer}`
   ].join("\n");
 }
-function renderText(message, value, error) {
+function renderText(message, value, error, allowBack = false) {
   const lines = [`\u25C6 ${message}`, "", `  ${value || "\u258F"}`];
   if (error) lines.push("", `  \u2716 ${error}`);
+  if (allowBack) lines.push("", "  enter confirm \xB7 \u2190 back");
   return lines.join("\n");
 }
 function keyReader(input) {
@@ -4587,14 +4598,18 @@ var Frame = class {
 function isCancel(key) {
   return key.ctrl === true && key.name === "c" || key.ctrl === true && key.name === "d";
 }
+function isListBack(key, allowBack) {
+  return allowBack && (key.name === "left" || key.name === "b");
+}
 async function select(io, message, choices, options = {}) {
   if (choices.length === 0) throw new Error("select() requires at least one choice.");
+  const allowBack = options.allowBack === true;
   const fallbackIndex = Math.max(
     0,
     choices.findIndex((choice) => choice.value === options.defaultValue)
   );
   if (!isInteractive(io)) {
-    io.output.write(`${renderSelect(message, choices, fallbackIndex)}
+    io.output.write(`${renderSelect(message, choices, fallbackIndex, allowBack)}
 `);
     return choices[fallbackIndex].value;
   }
@@ -4603,9 +4618,10 @@ async function select(io, message, choices, options = {}) {
   let index = fallbackIndex;
   try {
     for (; ; ) {
-      frame.draw(renderSelect(message, choices, index));
+      frame.draw(renderSelect(message, choices, index, allowBack));
       const key = await reader.next();
       if (isCancel(key)) throw new PromptCancelled();
+      if (isListBack(key, allowBack)) throw new PromptBack();
       if (key.name === "up") index = moveSelection(index, -1, choices.length);
       else if (key.name === "down") index = moveSelection(index, 1, choices.length);
       else if (key.name === "return" || key.name === "enter") {
@@ -4614,18 +4630,22 @@ async function select(io, message, choices, options = {}) {
       } else if (key.name === "j") index = moveSelection(index, 1, choices.length);
       else if (key.name === "k") index = moveSelection(index, -1, choices.length);
     }
+  } catch (error) {
+    frame.erase();
+    throw error;
   } finally {
     reader.close();
   }
 }
 async function multiSelect(io, message, choices, options = {}) {
+  const allowBack = options.allowBack === true;
   const selected = /* @__PURE__ */ new Set();
   choices.forEach((choice, position) => {
     if (options.defaults?.includes(choice.value)) selected.add(position);
   });
   const result = () => choices.filter((_, position) => selected.has(position)).map((choice) => choice.value);
   if (!isInteractive(io)) {
-    io.output.write(`${renderMultiSelect(message, choices, 0, selected)}
+    io.output.write(`${renderMultiSelect(message, choices, 0, selected, allowBack)}
 `);
     return result();
   }
@@ -4634,9 +4654,10 @@ async function multiSelect(io, message, choices, options = {}) {
   let index = 0;
   try {
     for (; ; ) {
-      frame.draw(renderMultiSelect(message, choices, index, selected));
+      frame.draw(renderMultiSelect(message, choices, index, selected, allowBack));
       const key = await reader.next();
       if (isCancel(key)) throw new PromptCancelled();
+      if (isListBack(key, allowBack)) throw new PromptBack();
       if (key.name === "up") index = moveSelection(index, -1, choices.length);
       else if (key.name === "down") index = moveSelection(index, 1, choices.length);
       else if (key.name === "space") {
@@ -4651,14 +4672,18 @@ async function multiSelect(io, message, choices, options = {}) {
         return result();
       }
     }
+  } catch (error) {
+    frame.erase();
+    throw error;
   } finally {
     reader.close();
   }
 }
 async function confirm(io, message, options = {}) {
+  const allowBack = options.allowBack === true;
   let value = options.defaultValue ?? true;
   if (!isInteractive(io)) {
-    io.output.write(`${renderConfirm(message, value)}
+    io.output.write(`${renderConfirm(message, value, allowBack)}
 `);
     return value;
   }
@@ -4666,9 +4691,10 @@ async function confirm(io, message, options = {}) {
   const reader = keyReader(io.input);
   try {
     for (; ; ) {
-      frame.draw(renderConfirm(message, value));
+      frame.draw(renderConfirm(message, value, allowBack));
       const key = await reader.next();
       if (isCancel(key)) throw new PromptCancelled();
+      if (allowBack && key.name === "b") throw new PromptBack();
       if (key.name === "up" || key.name === "left") value = true;
       else if (key.name === "down" || key.name === "right") value = false;
       else if (key.name === "y") value = true;
@@ -4678,14 +4704,18 @@ async function confirm(io, message, options = {}) {
         return value;
       }
     }
+  } catch (error) {
+    frame.erase();
+    throw error;
   } finally {
     reader.close();
   }
 }
 async function text(io, message, options = {}) {
+  const allowBack = options.allowBack === true;
   const fallback = options.defaultValue ?? "";
   if (!isInteractive(io)) {
-    io.output.write(`${renderText(message, fallback)}
+    io.output.write(`${renderText(message, fallback, void 0, allowBack)}
 `);
     return fallback;
   }
@@ -4695,9 +4725,10 @@ async function text(io, message, options = {}) {
   let error;
   try {
     for (; ; ) {
-      frame.draw(renderText(message, value, error));
+      frame.draw(renderText(message, value, error, allowBack));
       const key = await reader.next();
       if (isCancel(key)) throw new PromptCancelled();
+      if (allowBack && key.name === "left") throw new PromptBack();
       error = void 0;
       if (key.name === "return" || key.name === "enter") {
         const problem = options.validate ? options.validate(value) : null;
@@ -4718,6 +4749,9 @@ async function text(io, message, options = {}) {
       }
       if (_isPrintable(key)) value += _keyText(key);
     }
+  } catch (error_) {
+    frame.erase();
+    throw error_;
   } finally {
     reader.close();
   }
@@ -4974,98 +5008,108 @@ async function runInit(options) {
       { value: "walk", label: "Go through each setting", hint: "every question starts on its default" },
       { value: "choose", label: "Pick a different preset", hint: "everything else stays at the defaults" }
     ];
-    const pace = await select(io, "How should I set this up?", paceChoices, {
-      defaultValue: fallback ? "choose" : "recommended"
-    });
-    if (pace === "choose") {
-      answers.preset = await select(
-        io,
-        "What kind of project is this?",
-        listPresetNames().map(
-          (name) => resolvePresetChoice(fallback ? null : detected.presetName, name)
-        ),
-        { defaultValue: answers.preset }
-      );
-      const chosen = detectPreset(options.cwd, answers.preset);
-      answers.preset = chosen.presetName;
-      reason = null;
-      fallback = false;
-    }
-    if (pace === "walk") {
-      const scope = await select(
-        io,
-        "What should go into the snapshot?",
-        [
-          { value: "all", label: "Everything the scanner finds", hint: "recommended \xB7 respects .gitignore" },
-          { value: "folders", label: "Only specific folders\u2026" },
-          { value: "no-tests", label: "Everything, but skip tests" },
-          { value: "custom", label: "Let me write glob patterns" }
-        ],
-        { defaultValue: "all" }
-      );
-      if (scope === "folders") {
-        const dirs = topLevelDirs(options.cwd).slice(0, 40);
-        if (dirs.length === 0) {
-          notes.push("No top-level directories found; the snapshot will include everything.");
-        } else {
-          const chosen = await multiSelect(
-            io,
-            "Select folders",
-            dirs.map((name) => ({ value: name, label: `${name}/` })),
-            { defaults: dirs }
-          );
-          answers.include = chosen.map((name) => `${name}/**`);
+    const baseInclude = [...answers.include];
+    const baseExclude = [...answers.excludePatterns];
+    let lastScope = "all";
+    const artifactChoices = [
+      { value: "readme", label: "README.md", hint: "orientation page" },
+      { value: "manifest", label: "manifest.json", hint: "required by validate and report" },
+      { value: "parts", label: "parts/", hint: "the code payload" },
+      { value: "navigation", label: "reports/navigation.md", hint: "file \u2192 part index" },
+      { value: "projectTree", label: "reports/project-tree.md", hint: "ASCII tree" },
+      { value: "audit", label: "reports/audit.md", hint: "security and health findings" },
+      { value: "monolith", label: "full-codebase.json + .md", hint: "roughly doubles output" }
+    ];
+    const scopeStep = async () => {
+      for (; ; ) {
+        const scope = await select(
+          io,
+          "What should go into the snapshot?",
+          [
+            { value: "all", label: "Everything the scanner finds", hint: "recommended \xB7 respects .gitignore" },
+            { value: "folders", label: "Only specific folders\u2026" },
+            { value: "no-tests", label: "Everything, but skip tests" },
+            { value: "custom", label: "Let me write glob patterns" }
+          ],
+          { defaultValue: lastScope, allowBack: true }
+        );
+        lastScope = scope;
+        answers.include = [...baseInclude];
+        answers.excludePatterns = [...baseExclude];
+        try {
+          if (scope === "folders") {
+            const dirs = topLevelDirs(options.cwd).slice(0, 40);
+            if (dirs.length === 0) {
+              notes.push("No top-level directories found; the snapshot will include everything.");
+            } else {
+              const chosen = await multiSelect(
+                io,
+                "Select folders",
+                dirs.map((name) => ({ value: name, label: `${name}/` })),
+                { defaults: dirs, allowBack: true }
+              );
+              answers.include = chosen.map((name) => `${name}/**`);
+            }
+          } else if (scope === "no-tests") {
+            answers.excludePatterns = [...baseExclude, "**/*.test.*", "**/*.spec.*", "tests", "test"];
+          } else if (scope === "custom") {
+            const raw = await text(io, "Glob patterns to include (comma separated)", {
+              defaultValue: baseInclude.join(", "),
+              allowBack: true
+            });
+            answers.include = raw.split(",").map((value) => value.trim()).filter(Boolean);
+          }
+          return;
+        } catch (error) {
+          if (error instanceof PromptBack) continue;
+          throw error;
         }
-      } else if (scope === "no-tests") {
-        answers.excludePatterns = [
-          ...answers.excludePatterns,
-          "**/*.test.*",
-          "**/*.spec.*",
-          "tests",
-          "test"
-        ];
-      } else if (scope === "custom") {
-        const raw = await text(io, "Glob patterns to include (comma separated)", {
-          defaultValue: ""
-        });
-        answers.include = raw.split(",").map((value) => value.trim()).filter(Boolean);
       }
-      const currentBudget = String(answers.maxPartBytes);
-      const sizeChoice = await select(io, "How large should each part be?", SIZE_CHOICES, {
-        defaultValue: SIZE_CHOICES.some((choice) => choice.value === currentBudget) ? currentBudget : "120k"
-      });
-      if (sizeChoice === "custom") {
-        const raw = await text(io, "Part size (e.g. 150k, 1.5mb, 900000)", {
-          defaultValue: String(answers.maxPartBytes),
-          validate: (value) => parseByteSize(value) === void 0 ? "Not a valid size." : null
+    };
+    const sizeStep = async () => {
+      for (; ; ) {
+        const currentBudget = String(answers.maxPartBytes);
+        const sizeChoice = await select(io, "How large should each part be?", SIZE_CHOICES, {
+          defaultValue: SIZE_CHOICES.some((choice) => choice.value === currentBudget) ? currentBudget : "custom",
+          allowBack: true
         });
-        answers.maxPartBytes = parseByteSize(raw) ?? answers.maxPartBytes;
-      } else {
-        answers.maxPartBytes = sizeChoice;
-      }
-      const artifactChoices = [
-        { value: "readme", label: "README.md", hint: "orientation page" },
-        { value: "manifest", label: "manifest.json", hint: "required by validate and report" },
-        { value: "parts", label: "parts/", hint: "the code payload" },
-        { value: "navigation", label: "reports/navigation.md", hint: "file \u2192 part index" },
-        { value: "projectTree", label: "reports/project-tree.md", hint: "ASCII tree" },
-        { value: "audit", label: "reports/audit.md", hint: "security and health findings" },
-        { value: "monolith", label: "full-codebase.json + .md", hint: "roughly doubles output" }
-      ];
-      const presetEnabled = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]);
+        if (sizeChoice !== "custom") {
+          answers.maxPartBytes = sizeChoice;
+          return;
+        }
+        try {
+          const raw = await text(io, "Part size (e.g. 150k, 1.5mb, 900000)", {
+            defaultValue: currentBudget,
+            validate: (value) => parseByteSize(value) === void 0 ? "Not a valid size." : null,
+            allowBack: true
+          });
+          answers.maxPartBytes = parseByteSize(raw) ?? answers.maxPartBytes;
+          return;
+        } catch (error) {
+          if (error instanceof PromptBack) continue;
+          throw error;
+        }
+      }
+    };
+    const artifactsStep = async () => {
+      const enabled = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]);
       const selectedArtifacts = await multiSelect(
         io,
         "Which artifacts should be generated?",
         artifactChoices,
-        { defaults: presetEnabled }
+        { defaults: enabled, allowBack: true }
       );
       for (const name of ARTIFACT_NAMES) answers.artifacts[name] = selectedArtifacts.includes(name);
-      const enabledCount = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]).length;
+    };
+    const credentialsStep = async () => {
       answers.includeSensitiveFiles = await confirm(
         io,
-        "Include credential files (.env, *.pem, .npmrc, .ssh/)?",
-        { defaultValue: false }
+        "Include credential files (.env, *.pem, *.npmrc, *.ssh/)?",
+        { defaultValue: answers.includeSensitiveFiles, allowBack: true }
       );
+    };
+    const reviewStep = async () => {
+      const enabledCount = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]).length;
       io.output.write("\n  Review\n\n");
       io.output.write(`  project          ${answers.preset}
 `);
@@ -5080,8 +5124,53 @@ async function runInit(options) {
 `);
       io.output.write("  Will write snapshot.config with your answers, plus every other setting\n");
       io.output.write("  at its default \u2014 so nothing is hidden behind the docs.\n\n");
-      const proceed = await confirm(io, "Write this and continue?", { defaultValue: true });
-      if (!proceed) throw new PromptCancelled();
+      const proceed = await confirm(io, "Write this and continue?", {
+        defaultValue: true,
+        allowBack: true
+      });
+      if (!proceed) throw new PromptBack();
+    };
+    const walk = async () => {
+      const steps = [scopeStep, sizeStep, artifactsStep, credentialsStep, reviewStep];
+      let index = 0;
+      while (index < steps.length) {
+        try {
+          await steps[index]();
+          index += 1;
+        } catch (error) {
+          if (!(error instanceof PromptBack)) throw error;
+          if (index === 0) return false;
+          index -= 1;
+          io.output.write("\n");
+        }
+      }
+      return true;
+    };
+    for (; ; ) {
+      const pace = await select(io, "How should I set this up?", paceChoices, {
+        defaultValue: fallback ? "choose" : "recommended"
+      });
+      if (pace === "choose") {
+        try {
+          answers.preset = await select(
+            io,
+            "What kind of project is this?",
+            listPresetNames().map(
+              (name) => resolvePresetChoice(fallback ? null : detected.presetName, name)
+            ),
+            { defaultValue: answers.preset, allowBack: true }
+          );
+        } catch (error) {
+          if (error instanceof PromptBack) continue;
+          throw error;
+        }
+        const chosen = detectPreset(options.cwd, answers.preset);
+        answers.preset = chosen.presetName;
+        reason = null;
+        fallback = false;
+      }
+      if (pace === "walk" && !await walk()) continue;
+      break;
     }
   }
   const configText = renderConfig(answers);
@@ -5200,9 +5289,9 @@ function hasPriorSnapshot(cwd, outDir) {
 // src/index.ts
 import * as crypto3 from "crypto";
 import { AsyncLocalStorage } from "async_hooks";
-import * as fs11 from "fs";
-import * as os from "os";
-import * as path12 from "path";
+import * as fs12 from "fs";
+import * as os2 from "os";
+import * as path13 from "path";
 
 // src/ast/profiles/shared.ts
 var MAX_SUMMARY_CHARS = 1e6;
@@ -5426,9 +5515,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) => {
@@ -5884,16 +5973,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]}
 `;
@@ -5902,7 +5991,7 @@ var sfcProfile = {
       script += `${match[1]}
 `;
     }
-    const name = componentName(path18);
+    const name = componentName(path19);
     if (!script.trim()) {
       const summary2 = emptySummary();
       if (name) {
@@ -5936,15 +6025,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
@@ -6793,6 +6882,168 @@ function generateProjectTree(filePaths) {
   return ["# Project Tree", "", `${fence}text`, ...lines, fence, ""].join("\n");
 }
 
+// src/update-check.ts
+import * as fs11 from "fs";
+import * as https from "https";
+import * as os from "os";
+import * as path12 from "path";
+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 ?? path12.join(os.homedir(), "AppData", "Local");
+    return path12.join(base2, "codebase-snapshot");
+  }
+  if (platform === "darwin") {
+    return path12.join(os.homedir(), "Library", "Caches", "codebase-snapshot");
+  }
+  const base = env.XDG_CACHE_HOME ?? path12.join(os.homedir(), ".cache");
+  return path12.join(base, "codebase-snapshot");
+}
+function cacheFilePath(env = process.env) {
+  return path12.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 = fs11.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 {
+    fs11.mkdirSync(path12.dirname(file), { recursive: true });
+    fs11.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.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";
 var SUMMARY_MAX_SOURCE_BYTES = 2 * 1024 * 1024;
@@ -6874,13 +7125,13 @@ function buildImportResolver(files) {
     const relativePath = file.relativePath;
     remember(byPath, relativePath, relativePath);
     remember(byPathFolded, relativePath.toLowerCase(), relativePath);
-    const extension = path12.posix.extname(relativePath);
+    const extension = path13.posix.extname(relativePath);
     if (!SOURCE_EXTENSIONS.has(extension)) continue;
     const stem = relativePath.slice(0, -extension.length);
     remember(byStem, stem, relativePath);
     remember(byStemFolded, stem.toLowerCase(), relativePath);
-    if (path12.posix.basename(stem) === "index") {
-      const directory = path12.posix.dirname(stem);
+    if (path13.posix.basename(stem) === "index") {
+      const directory = path13.posix.dirname(stem);
       remember(byStem, directory, relativePath);
       remember(byStemFolded, directory.toLowerCase(), relativePath);
     }
@@ -6889,8 +7140,8 @@ function buildImportResolver(files) {
 }
 function resolveSpecifier(fromFile, specifier, resolver) {
   if (!RELATIVE_SPECIFIER.test(specifier)) return null;
-  const joined = path12.posix.normalize(
-    path12.posix.join(path12.posix.dirname(fromFile), specifier)
+  const joined = path13.posix.normalize(
+    path13.posix.join(path13.posix.dirname(fromFile), specifier)
   );
   const exact = (key) => resolver.byPath.get(key) ?? resolver.byPathFolded.get(key.toLowerCase()) ?? null;
   const direct = exact(joined);
@@ -6983,11 +7234,11 @@ function verifyInMemory(files, parts, maxPartBytes) {
   return errors;
 }
 function resolveSafeOutputDirs(config) {
-  const cwd = path12.resolve(config.cwd);
-  const outDir = path12.resolve(cwd, config.outDir);
-  const tmpDir = path12.resolve(cwd, config.tmpDir);
-  const root = path12.parse(cwd).root;
-  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path12.sep}`);
+  const cwd = path13.resolve(config.cwd);
+  const outDir = path13.resolve(cwd, config.outDir);
+  const tmpDir = path13.resolve(cwd, config.tmpDir);
+  const root = path13.parse(cwd).root;
+  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path13.sep}`);
   const reject = (reason) => {
     throw new Error(
       `Refusing to generate: ${reason}. outDir=${outDir} tmpDir=${tmpDir} cwd=${cwd}`
@@ -7043,14 +7294,14 @@ function listEntries(dir) {
   const walk = (absolute, prefix) => {
     let children;
     try {
-      children = fs11.readdirSync(absolute, { withFileTypes: true });
+      children = fs12.readdirSync(absolute, { withFileTypes: true });
     } catch {
       return;
     }
     for (const child of children) {
       const relative11 = prefix === "" ? child.name : `${prefix}/${child.name}`;
       entries.push(relative11);
-      if (child.isDirectory()) walk(path12.join(absolute, child.name), relative11);
+      if (child.isDirectory()) walk(path13.join(absolute, child.name), relative11);
     }
   };
   walk(dir, "");
@@ -7067,28 +7318,28 @@ function markerPayload(dir, state, id, createdAt) {
     pid: process.pid,
     entries: listEntries(dir)
   };
-  const manifestPath = path12.join(dir, "manifest.json");
-  if (fs11.existsSync(manifestPath)) {
-    marker2.manifestSha256 = sha256Hex2(fs11.readFileSync(manifestPath));
+  const manifestPath = path13.join(dir, "manifest.json");
+  if (fs12.existsSync(manifestPath)) {
+    marker2.manifestSha256 = sha256Hex2(fs12.readFileSync(manifestPath));
   }
   return marker2;
 }
 function writeOwnershipMarker(dir, marker2) {
-  fs11.writeFileSync(
-    path12.join(dir, OWNERSHIP_MARKER),
+  fs12.writeFileSync(
+    path13.join(dir, OWNERSHIP_MARKER),
     `${JSON.stringify(marker2, null, 2)}
 `,
     "utf8"
   );
 }
 function readOwnershipMarker(dir) {
-  const markerPath = path12.join(dir, OWNERSHIP_MARKER);
-  if (!fs11.existsSync(markerPath)) {
+  const markerPath = path13.join(dir, OWNERSHIP_MARKER);
+  if (!fs12.existsSync(markerPath)) {
     return { marker: null, problem: "it holds no .codebase-snapshot marker" };
   }
   let raw;
   try {
-    raw = fs11.readFileSync(markerPath, "utf8");
+    raw = fs12.readFileSync(markerPath, "utf8");
   } catch {
     return { marker: null, problem: "its .codebase-snapshot marker could not be read" };
   }
@@ -7156,11 +7407,11 @@ function assessSnapshotDirectory(dir) {
       marker: marker2
     };
   }
-  const manifestPath = path12.join(dir, "manifest.json");
-  if (fs11.existsSync(manifestPath)) {
+  const manifestPath = path13.join(dir, "manifest.json");
+  if (fs12.existsSync(manifestPath)) {
     let raw;
     try {
-      raw = fs11.readFileSync(manifestPath, "utf8");
+      raw = fs12.readFileSync(manifestPath, "utf8");
     } catch {
       return {
         owned: false,
@@ -7242,13 +7493,13 @@ function containsNoFiles(dir) {
     const current = pending.pop();
     let entries;
     try {
-      entries = fs11.readdirSync(current, { withFileTypes: true });
+      entries = fs12.readdirSync(current, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        pending.push(path12.join(current, entry.name));
+        pending.push(path13.join(current, entry.name));
       } else if (!IGNORABLE_ENTRIES.has(entry.name)) {
         return false;
       }
@@ -7257,13 +7508,13 @@ function containsNoFiles(dir) {
   return true;
 }
 function assertReplaceable(target, label, secretRules) {
-  if (!fs11.existsSync(target)) return;
-  if (!fs11.statSync(target).isDirectory()) {
+  if (!fs12.existsSync(target)) return;
+  if (!fs12.statSync(target).isDirectory()) {
     throw new Error(
       `Refusing to write into ${label} ${target}: it exists but is not a directory.`
     );
   }
-  const entries = fs11.readdirSync(target);
+  const entries = fs12.readdirSync(target);
   if (entries.length === 0) return;
   if (entries.every((name) => IGNORABLE_ENTRIES.has(name))) return;
   if (containsNoFiles(target)) return;
@@ -7283,18 +7534,18 @@ function assertReplaceable(target, label, secretRules) {
   );
 }
 function assertStagingRootUsable(tmpDir, secretRules) {
-  if (!fs11.existsSync(tmpDir)) return;
-  if (!fs11.statSync(tmpDir).isDirectory()) {
+  if (!fs12.existsSync(tmpDir)) return;
+  if (!fs12.statSync(tmpDir).isDirectory()) {
     throw new Error(`Refusing to write into tmpDir ${tmpDir}: it exists but is not a directory.`);
   }
-  const entries = fs11.readdirSync(tmpDir);
+  const entries = fs12.readdirSync(tmpDir);
   if (entries.length === 0) return;
   const foreign = entries.filter((name) => {
-    const full = path12.join(tmpDir, name);
+    const full = path13.join(tmpDir, name);
     if (!name.startsWith(RUN_DIR_PREFIX)) return true;
     let stats;
     try {
-      stats = fs11.statSync(full);
+      stats = fs12.statSync(full);
     } catch {
       return true;
     }
@@ -7302,7 +7553,7 @@ function assertStagingRootUsable(tmpDir, secretRules) {
     const { marker: marker2 } = readOwnershipMarker(full);
     if (marker2) return false;
     try {
-      return fs11.readdirSync(full).length > 0;
+      return fs12.readdirSync(full).length > 0;
     } catch {
       return true;
     }
@@ -7317,13 +7568,13 @@ function assertStagingRootUsable(tmpDir, secretRules) {
 function cleanStaleRunDirs(tmpDir) {
   let entries;
   try {
-    entries = fs11.readdirSync(tmpDir);
+    entries = fs12.readdirSync(tmpDir);
   } catch {
     return;
   }
   for (const name of entries) {
     if (!name.startsWith(RUN_DIR_PREFIX)) continue;
-    const full = path12.join(tmpDir, name);
+    const full = path13.join(tmpDir, name);
     const { marker: marker2 } = readOwnershipMarker(full);
     if (marker2) {
       const created = Date.parse(marker2.createdAt);
@@ -7331,33 +7582,33 @@ function cleanStaleRunDirs(tmpDir) {
       const abandoned = typeof marker2.pid === "number" && !isProcessAlive(marker2.pid);
       if (aged || abandoned) {
         try {
-          fs11.rmSync(full, { recursive: true, force: true });
+          fs12.rmSync(full, { recursive: true, force: true });
         } catch {
         }
       }
       continue;
     }
     try {
-      if (fs11.readdirSync(full).length === 0) fs11.rmSync(full, { recursive: true, force: true });
+      if (fs12.readdirSync(full).length === 0) fs12.rmSync(full, { recursive: true, force: true });
     } catch {
     }
   }
 }
 function removeIfEmpty(dir) {
   try {
-    if (fs11.readdirSync(dir).length === 0) fs11.rmSync(dir, { recursive: true, force: true });
+    if (fs12.readdirSync(dir).length === 0) fs12.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function ensureParentDirectory(target, label) {
-  const parent = path12.dirname(target);
-  if (fs11.existsSync(parent) && !fs11.statSync(parent).isDirectory()) {
+  const parent = path13.dirname(target);
+  if (fs12.existsSync(parent) && !fs12.statSync(parent).isDirectory()) {
     throw new Error(
       `Refusing to create ${label} ${target}: ${parent} exists but is not a directory.`
     );
   }
   try {
-    fs11.mkdirSync(parent, { recursive: true });
+    fs12.mkdirSync(parent, { recursive: true });
   } catch (err) {
     throw new Error(
       `Refusing to create ${label} ${target}: its parent ${parent} could not be created (${err.message}).`
@@ -7366,7 +7617,7 @@ function ensureParentDirectory(target, label) {
 }
 function acquireRunLock(stagingRoot) {
   const key = lockKeyFor(stagingRoot);
-  const lockPath = path12.join(os.tmpdir(), `codebase-snapshot-${key}.lock`);
+  const lockPath = path13.join(os2.tmpdir(), `codebase-snapshot-${key}.lock`);
   const payload = `${JSON.stringify({
     pid: process.pid,
     stagingRoot,
@@ -7375,22 +7626,22 @@ function acquireRunLock(stagingRoot) {
 `;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const handle = fs11.openSync(lockPath, "wx");
+      const handle = fs12.openSync(lockPath, "wx");
       try {
-        fs11.writeSync(handle, payload);
+        fs12.writeSync(handle, payload);
       } finally {
-        fs11.closeSync(handle);
+        fs12.closeSync(handle);
       }
       return () => {
         try {
-          fs11.rmSync(lockPath, { force: true });
+          fs12.rmSync(lockPath, { force: true });
         } catch {
         }
       };
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       if (attempt === 0 && lockOwnerIsGone(lockPath)) {
-        fs11.rmSync(lockPath, { force: true });
+        fs12.rmSync(lockPath, { force: true });
         continue;
       }
       throw new Error(
@@ -7403,7 +7654,7 @@ function acquireRunLock(stagingRoot) {
 function lockKeyFor(stagingRoot) {
   let key = stagingRoot;
   try {
-    key = fs11.realpathSync(stagingRoot);
+    key = fs12.realpathSync(stagingRoot);
   } catch {
   }
   if (process.platform === "win32" || process.platform === "darwin") key = key.toLowerCase();
@@ -7412,7 +7663,7 @@ function lockKeyFor(stagingRoot) {
 function lockOwnerIsGone(lockPath) {
   let raw;
   try {
-    raw = fs11.readFileSync(lockPath, "utf8");
+    raw = fs12.readFileSync(lockPath, "utf8");
   } catch {
     return false;
   }
@@ -7432,12 +7683,12 @@ function lockOwnerIsGone(lockPath) {
 }
 function writeManifestAtomically(manifestPath, manifest) {
   const tempPath = `${manifestPath}.${process.pid}.tmp`;
-  fs11.writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf8");
+  fs12.writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf8");
   try {
-    fs11.renameSync(tempPath, manifestPath);
+    fs12.renameSync(tempPath, manifestPath);
   } catch (err) {
     try {
-      fs11.rmSync(tempPath, { force: true });
+      fs12.rmSync(tempPath, { force: true });
     } catch {
     }
     throw err;
@@ -7460,31 +7711,31 @@ function swapIntoPlace(stagingDir, outDir) {
 }
 function swapOnce(stagingDir, outDir) {
   const backupDir = `${outDir}.backup-${process.pid}-${Date.now()}`;
-  const hadPrevious = fs11.existsSync(outDir);
-  if (hadPrevious) fs11.renameSync(outDir, backupDir);
+  const hadPrevious = fs12.existsSync(outDir);
+  if (hadPrevious) fs12.renameSync(outDir, backupDir);
   try {
     try {
-      fs11.renameSync(stagingDir, outDir);
+      fs12.renameSync(stagingDir, outDir);
     } catch (err) {
       if (err.code !== "EXDEV") throw err;
       const partialDir = `${outDir}.partial-${process.pid}-${Date.now()}`;
       try {
-        fs11.cpSync(stagingDir, partialDir, { recursive: true });
-        fs11.renameSync(partialDir, outDir);
-        fs11.rmSync(stagingDir, { recursive: true, force: true });
+        fs12.cpSync(stagingDir, partialDir, { recursive: true });
+        fs12.renameSync(partialDir, outDir);
+        fs12.rmSync(stagingDir, { recursive: true, force: true });
       } catch (copyErr) {
         try {
-          fs11.rmSync(partialDir, { recursive: true, force: true });
+          fs12.rmSync(partialDir, { recursive: true, force: true });
         } catch {
         }
         throw copyErr;
       }
     }
-    if (hadPrevious) fs11.rmSync(backupDir, { recursive: true, force: true });
+    if (hadPrevious) fs12.rmSync(backupDir, { recursive: true, force: true });
   } catch (err) {
-    if (hadPrevious && fs11.existsSync(backupDir)) {
-      if (fs11.existsSync(outDir)) fs11.rmSync(outDir, { recursive: true, force: true });
-      fs11.renameSync(backupDir, outDir);
+    if (hadPrevious && fs12.existsSync(backupDir)) {
+      if (fs12.existsSync(outDir)) fs12.rmSync(outDir, { recursive: true, force: true });
+      fs12.renameSync(backupDir, outDir);
     }
     throw err;
   }
@@ -7579,7 +7830,7 @@ function generateSnapshot(configInput, options) {
     // first run cannot have marked them yet, so the name alone keeps a run from recording its own
     // output — but only at these exact paths, not at every directory that shares the name.
     toolOwnedPaths: [config.outDir, config.tmpDir].map(
-      (directory) => path12.relative(config.cwd, path12.resolve(config.cwd, directory)).replace(/\\/g, "/")
+      (directory) => path13.relative(config.cwd, path13.resolve(config.cwd, directory)).replace(/\\/g, "/")
     ).filter((relative11) => relative11.length > 0 && !relative11.startsWith(".."))
   });
   const files = [];
@@ -7600,12 +7851,12 @@ function generateSnapshot(configInput, options) {
   let totalSizeBytes = 0;
   let largeFileCount = 0;
   for (const relativePath of collection.files) {
-    const absolutePath = path12.join(config.cwd, relativePath);
+    const absolutePath = path13.join(config.cwd, relativePath);
     let stats;
     try {
-      stats = fs11.statSync(absolutePath);
+      stats = fs12.statSync(absolutePath);
       if (!stats.isFile()) {
-        const nestedRepository = stats.isDirectory() && fs11.existsSync(path12.join(absolutePath, ".git"));
+        const nestedRepository = stats.isDirectory() && fs12.existsSync(path13.join(absolutePath, ".git"));
         skipped.push(
           nestedRepository ? {
             path: relativePath,
@@ -7625,7 +7876,7 @@ function generateSnapshot(configInput, options) {
     }
     let buffer;
     try {
-      buffer = fs11.readFileSync(absolutePath);
+      buffer = fs12.readFileSync(absolutePath);
     } catch {
       skipped.push({ path: relativePath, reason: "read-error" });
       continue;
@@ -7955,12 +8206,12 @@ function generateSnapshot(configInput, options) {
   let stagingDir = null;
   try {
     ensureParentDirectory(outDir, "outDir");
-    fs11.mkdirSync(tmpDir, { recursive: true });
+    fs12.mkdirSync(tmpDir, { recursive: true });
     cleanStaleRunDirs(tmpDir);
     const snapshotId = crypto3.randomUUID();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    stagingDir = path12.join(tmpDir, `${RUN_DIR_PREFIX}${process.pid}-${snapshotId.slice(0, 8)}`);
-    fs11.mkdirSync(stagingDir);
+    stagingDir = path13.join(tmpDir, `${RUN_DIR_PREFIX}${process.pid}-${snapshotId.slice(0, 8)}`);
+    fs12.mkdirSync(stagingDir);
     writeOwnershipMarker(stagingDir, {
       generator: GENERATOR_NAME,
       version: GENERATOR_VERSION,
@@ -7970,41 +8221,41 @@ function generateSnapshot(configInput, options) {
       id: snapshotId,
       pid: process.pid
     });
-    const partsDir = path12.join(stagingDir, "parts");
-    const reportsDir = path12.join(stagingDir, "reports");
-    if (artifacts.parts) fs11.mkdirSync(partsDir, { recursive: true });
+    const partsDir = path13.join(stagingDir, "parts");
+    const reportsDir = path13.join(stagingDir, "reports");
+    if (artifacts.parts) fs12.mkdirSync(partsDir, { recursive: true });
     if (artifacts.navigation || artifacts.projectTree || artifacts.audit) {
-      fs11.mkdirSync(reportsDir, { recursive: true });
+      fs12.mkdirSync(reportsDir, { recursive: true });
     }
     if (artifacts.parts) {
       for (const part of parts) {
-        fs11.writeFileSync(path12.join(partsDir, part.filename), part.markdown, "utf8");
+        fs12.writeFileSync(path13.join(partsDir, part.filename), part.markdown, "utf8");
       }
     }
     if (projectTree !== null) {
-      fs11.writeFileSync(path12.join(reportsDir, "project-tree.md"), projectTree, "utf8");
+      fs12.writeFileSync(path13.join(reportsDir, "project-tree.md"), projectTree, "utf8");
     }
     if (artifacts.navigation) {
-      fs11.writeFileSync(path12.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
+      fs12.writeFileSync(path13.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
     }
     if (artifacts.audit) {
-      fs11.writeFileSync(
-        path12.join(reportsDir, "audit.md"),
+      fs12.writeFileSync(
+        path13.join(reportsDir, "audit.md"),
         generateAuditReport(manifest, secretFindings, config.secretRules),
         "utf8"
       );
     }
     if (artifacts.readme) {
-      fs11.writeFileSync(path12.join(stagingDir, "README.md"), generateReadme(manifest, artifacts), "utf8");
+      fs12.writeFileSync(path13.join(stagingDir, "README.md"), generateReadme(manifest, artifacts), "utf8");
     }
     if (artifacts.manifest) {
-      fs11.writeFileSync(path12.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+      fs12.writeFileSync(path13.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
     }
     if (monolithJson !== null) {
-      fs11.writeFileSync(path12.join(stagingDir, "full-codebase.json"), monolithJson, "utf8");
+      fs12.writeFileSync(path13.join(stagingDir, "full-codebase.json"), monolithJson, "utf8");
     }
     if (monolithMarkdown !== null) {
-      fs11.writeFileSync(path12.join(stagingDir, "full-codebase.md"), monolithMarkdown, "utf8");
+      fs12.writeFileSync(path13.join(stagingDir, "full-codebase.md"), monolithMarkdown, "utf8");
     }
     writeOwnershipMarker(stagingDir, markerPayload(stagingDir, "complete", snapshotId, createdAt));
     swapIntoPlace(stagingDir, outDir);
@@ -8013,7 +8264,7 @@ function generateSnapshot(configInput, options) {
     const pendingHook = runAfterGenerate(config, manifest);
     const shipHookState = () => {
       if (artifacts.manifest && manifest.warnings.length !== warningsBeforeHook) {
-        writeManifestAtomically(path12.join(outDir, "manifest.json"), manifest);
+        writeManifestAtomically(path13.join(outDir, "manifest.json"), manifest);
       }
       writeOwnershipMarker(outDir, markerPayload(outDir, "complete", snapshotId, createdAt));
     };
@@ -8036,7 +8287,7 @@ function generateSnapshot(configInput, options) {
   } catch (err) {
     if (stagingDir !== null) {
       try {
-        fs11.rmSync(stagingDir, { recursive: true, force: true });
+        fs12.rmSync(stagingDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -8048,8 +8299,8 @@ function generateSnapshot(configInput, options) {
 }
 
 // src/mcp/tools.ts
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 
 // src/mcp/part.ts
 var FILE_HEADING = "### FILE: ";
@@ -8135,15 +8386,15 @@ function windowText(body, fromLine, lineCount) {
 }
 
 // src/mcp/workspace.ts
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 function foldForComparison(value) {
   return process.platform === "win32" || process.platform === "darwin" ? value.toLowerCase() : value;
 }
 function canonicalPath(value) {
-  const absolute = path13.resolve(value);
+  const absolute = path14.resolve(value);
   try {
-    return fs12.realpathSync(absolute);
+    return fs13.realpathSync(absolute);
   } catch {
     return absolute;
   }
@@ -8151,17 +8402,17 @@ function canonicalPath(value) {
 function isInside2(parent, child) {
   const foldedParent = foldForComparison(parent);
   const foldedChild = foldForComparison(child);
-  return foldedChild === foldedParent || foldedChild.startsWith(`${foldedParent}${path13.sep}`);
+  return foldedChild === foldedParent || foldedChild.startsWith(`${foldedParent}${path14.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 = path13.resolve(context.cwd, wanted);
+  const absolute = path14.resolve(context.cwd, wanted);
   let stats;
   try {
-    stats = fs12.statSync(absolute);
+    stats = fs13.statSync(absolute);
   } catch {
     return { ok: false, message: `"${wanted}" does not exist, so it cannot be a repository root.` };
   }
@@ -8212,14 +8463,14 @@ async function openWorkspace(root, overrides = {}) {
 }
 var manifestCache = /* @__PURE__ */ new Map();
 function manifestPathFor(workspace) {
-  return path13.resolve(workspace.root, workspace.config.outDir, "manifest.json");
+  return path14.resolve(workspace.root, workspace.config.outDir, "manifest.json");
 }
 function readManifest3(workspace) {
   const file = manifestPathFor(workspace);
-  const shown = path13.relative(workspace.root, file).split(path13.sep).join("/") || file;
+  const shown = path14.relative(workspace.root, file).split(path14.sep).join("/") || file;
   let stats;
   try {
-    stats = fs12.statSync(file);
+    stats = fs13.statSync(file);
   } catch {
     return {
       ok: false,
@@ -8233,7 +8484,7 @@ function readManifest3(workspace) {
   }
   let raw;
   try {
-    raw = fs12.readFileSync(file, "utf8");
+    raw = fs13.readFileSync(file, "utf8");
   } catch (error) {
     return {
       ok: false,
@@ -8291,7 +8542,7 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 function relativeFor(workspace, absolute) {
-  return path14.relative(workspace.root, absolute).split(path14.sep).join("/");
+  return path15.relative(workspace.root, absolute).split(path15.sep).join("/");
 }
 function capped(values, limit = 20) {
   return { count: values.length, sample: values.slice(0, limit) };
@@ -8310,12 +8561,12 @@ function summarizeDrift(drift) {
 function toRelativePath(root, value) {
   const cleaned = value.trim();
   if (cleaned.length === 0) return null;
-  if (!path14.isAbsolute(cleaned)) {
+  if (!path15.isAbsolute(cleaned)) {
     return cleaned.replace(/\\/g, "/").replace(/^\.\//, "");
   }
-  const relative11 = path14.relative(root, cleaned);
-  if (relative11.startsWith("..") || path14.isAbsolute(relative11)) return null;
-  return relative11.split(path14.sep).join("/");
+  const relative11 = path15.relative(root, cleaned);
+  if (relative11.startsWith("..") || path15.isAbsolute(relative11)) return null;
+  return relative11.split(path15.sep).join("/");
 }
 function symbolsOf(entry) {
   const summary = entry.summary;
@@ -8526,7 +8777,7 @@ var generateTool = {
       return failure(error instanceof Error ? error.message : String(error));
     }
     forgetManifest(manifestPathFor(workspace));
-    const written = relativeFor(workspace, path14.resolve(workspace.root, workspace.config.outDir));
+    const written = relativeFor(workspace, path15.resolve(workspace.root, workspace.config.outDir));
     const lines = [
       `Wrote ${written}/`,
       `Files: ${manifest.counts.totalFiles} included, ${manifest.counts.skippedCount} skipped, ${plural(manifest.counts.partsCount, "part")}`,
@@ -8791,10 +9042,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 = path14.resolve(workspace.root, workspace.config.outDir, "parts", entry.part);
+    const partPath = path15.resolve(workspace.root, workspace.config.outDir, "parts", entry.part);
     let partText;
     try {
-      partText = fs13.readFileSync(partPath, "utf8");
+      partText = fs14.readFileSync(partPath, "utf8");
     } catch {
       return failure(
         `${entry.part} could not be read, so the snapshot is damaged. Run snapshot_generate to rebuild it.`
@@ -9056,6 +9307,7 @@ var VALIDATE_OPTIONS = [
   "no-config",
   "discovery",
   "format",
+  "no-update-check",
   "mode",
   "help",
   "version"
@@ -9079,6 +9331,7 @@ var COMMAND_OPTION_SCOPE = {
     "watch",
     "autopilot",
     "no-install",
+    "no-update-check",
     "help",
     "version"
   ],
@@ -9094,6 +9347,7 @@ var COMMAND_OPTION_SCOPE = {
     "skip-artifacts",
     "only-artifacts",
     "no-config",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9111,12 +9365,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",
@@ -9131,6 +9386,7 @@ var COMMAND_OPTION_SCOPE = {
     "yes",
     "force",
     "dry-run",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9154,6 +9410,7 @@ var COMMAND_OPTION_SCOPE = {
     "force",
     "no-install",
     "dry-run",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9586,6 +9843,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) => ({
@@ -9718,8 +9982,8 @@ function buildAgentContract() {
 }
 
 // src/agent/install-skill.ts
-import * as fs14 from "fs";
-import * as path15 from "path";
+import * as fs15 from "fs";
+import * as path16 from "path";
 
 // src/agent/skill.ts
 var PACKAGE_NAME2 = "codebase-snapshot";
@@ -9877,17 +10141,17 @@ var LEGACY_AGENTS_MARKER = "<!-- codebase-snapshot:skill:start -->";
 function targetPath(cwd, target) {
   switch (target) {
     case "claude":
-      return path15.join(cwd, ".claude", "skills", SKILL_NAME, "SKILL.md");
+      return path16.join(cwd, ".claude", "skills", SKILL_NAME, "SKILL.md");
     case "cursor":
-      return path15.join(cwd, ".cursor", "rules", `${SKILL_NAME}.mdc`);
+      return path16.join(cwd, ".cursor", "rules", `${SKILL_NAME}.mdc`);
   }
 }
 function assertWritableInsideRepository(cwd, filePath) {
-  const root = fs14.realpathSync(cwd);
-  const shown = path15.relative(root, filePath) || filePath;
+  const root = fs15.realpathSync(cwd);
+  const shown = path16.relative(root, filePath) || filePath;
   let stat = null;
   try {
-    stat = fs14.lstatSync(filePath);
+    stat = fs15.lstatSync(filePath);
   } catch {
     stat = null;
   }
@@ -9903,32 +10167,32 @@ function assertWritableInsideRepository(cwd, filePath) {
   }
   let existing = filePath;
   const missing = [];
-  while (!fs14.existsSync(existing)) {
-    missing.unshift(path15.basename(existing));
-    const parent = path15.dirname(existing);
+  while (!fs15.existsSync(existing)) {
+    missing.unshift(path16.basename(existing));
+    const parent = path16.dirname(existing);
     if (parent === existing) break;
     existing = parent;
   }
-  const realAncestor = fs14.realpathSync(existing);
-  const resolved = missing.length === 0 ? realAncestor : path15.join(realAncestor, ...missing);
-  if (resolved !== root && !resolved.startsWith(`${root}${path15.sep}`)) {
+  const realAncestor = fs15.realpathSync(existing);
+  const resolved = missing.length === 0 ? realAncestor : path16.join(realAncestor, ...missing);
+  if (resolved !== root && !resolved.startsWith(`${root}${path16.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 = fs14.existsSync(filePath) ? fs14.readFileSync(filePath, "utf8") : null;
+  const existing = fs15.existsSync(filePath) ? fs15.readFileSync(filePath, "utf8") : null;
   if (existing === content) return { target, path: filePath, action: "unchanged" };
-  fs14.mkdirSync(path15.dirname(filePath), { recursive: true });
-  fs14.writeFileSync(filePath, content, "utf8");
+  fs15.mkdirSync(path16.dirname(filePath), { recursive: true });
+  fs15.writeFileSync(filePath, content, "utf8");
   return { target, path: filePath, action: existing === null ? "created" : "updated" };
 }
 function legacyAgentsNote(cwd) {
-  const filePath = path15.join(cwd, "AGENTS.md");
+  const filePath = path16.join(cwd, "AGENTS.md");
   try {
-    if (!fs14.existsSync(filePath)) return null;
-    if (!fs14.readFileSync(filePath, "utf8").includes(LEGACY_AGENTS_MARKER)) return null;
+    if (!fs15.existsSync(filePath)) return null;
+    if (!fs15.readFileSync(filePath, "utf8").includes(LEGACY_AGENTS_MARKER)) return null;
   } catch {
     return null;
   }
@@ -9940,9 +10204,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) => !fs14.existsSync(targetPath(cwd, item)));
+  const createsSomething = wanted.some((item) => !fs15.existsSync(targetPath(cwd, item)));
   if (createsSomething) {
-    assertWritableInsideRepository(cwd, path15.join(cwd, ".gitignore"));
+    assertWritableInsideRepository(cwd, path16.join(cwd, ".gitignore"));
   }
   for (const item of wanted) {
     written.push(writeIfChanged(item, targetPath(cwd, item), skill));
@@ -10077,52 +10341,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 [];
   }
@@ -10136,6 +10400,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() {
@@ -10224,7 +10500,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,
@@ -10236,7 +10513,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);
@@ -10405,8 +10682,8 @@ function createMcpServer(options) {
 }
 
 // src/mcp/resources.ts
-import * as fs15 from "fs";
-import * as path16 from "path";
+import * as fs16 from "fs";
+import * as path17 from "path";
 var MAX_RESOURCE_BYTES = 512 * 1024;
 var PART_URI = /^snapshot:\/\/parts\/(\d+)$/;
 var REPORT_URIS = /* @__PURE__ */ new Map([
@@ -10440,7 +10717,7 @@ async function workspaceFor(context) {
 }
 function readFileIfPresent(file) {
   try {
-    return fs15.readFileSync(file, "utf8");
+    return fs16.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -10519,7 +10796,7 @@ function buildResourceProvider() {
       const report = REPORT_URIS.get(uri);
       if (report) {
         const text2 = readFileIfPresent(
-          path16.resolve(workspace.root, workspace.config.outDir, "reports", report.file)
+          path17.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 };
@@ -10538,7 +10815,7 @@ function buildResourceProvider() {
         const part = read.manifest.parts.find((candidate) => candidate.index === index);
         if (!part) return null;
         const text2 = readFileIfPresent(
-          path16.resolve(workspace.root, workspace.config.outDir, "parts", part.filename)
+          path17.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 };
@@ -10776,6 +11053,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" }
 };
@@ -10850,6 +11128,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
 
@@ -10914,10 +11194,10 @@ function parseCliArgs(argv) {
   }
   if (values.cwd !== void 0) {
     const target = String(values.cwd);
-    if (!fs16.existsSync(target)) {
+    if (!fs17.existsSync(target)) {
       throw new UsageError(`--cwd directory does not exist: ${target}`);
     }
-    if (!fs16.statSync(target).isDirectory()) {
+    if (!fs17.statSync(target).isDirectory()) {
       throw new UsageError(`--cwd is not a directory: ${target}`);
     }
   }
@@ -11063,7 +11343,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() : path17.resolve(String(values.cwd)),
+    cwd: values.cwd === void 0 ? process.cwd() : path18.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,
@@ -11120,24 +11400,24 @@ function splitList(value) {
   return value.split(",").map((entry) => entry.trim()).filter(Boolean);
 }
 function displayOutPath(cwd, outDir, ...segments) {
-  const absolute = path17.resolve(cwd, outDir, ...segments);
-  const relative11 = path17.relative(cwd, absolute);
-  if (relative11 && !relative11.startsWith("..") && !path17.isAbsolute(relative11)) return relative11;
+  const absolute = path18.resolve(cwd, outDir, ...segments);
+  const relative11 = path18.relative(cwd, absolute);
+  if (relative11 && !relative11.startsWith("..") && !path18.isAbsolute(relative11)) return relative11;
   return absolute;
 }
 function nextStepHint(cwd, scriptsAddedNow) {
   let hasScript = scriptsAddedNow;
   if (!hasScript) {
     try {
-      const parsed = JSON.parse(fs16.readFileSync(path17.join(cwd, "package.json"), "utf8"));
+      const parsed = JSON.parse(fs17.readFileSync(path18.join(cwd, "package.json"), "utf8"));
       hasScript = typeof parsed.scripts?.snapshot === "string";
     } catch {
       hasScript = false;
     }
   }
   if (!hasScript) return `npx ${GENERATOR_NAME} generate`;
-  const bin = path17.join(cwd, "node_modules", ".bin", "codebase-snapshot");
-  const installed = fs16.existsSync(bin) || fs16.existsSync(`${bin}.cmd`);
+  const bin = path18.join(cwd, "node_modules", ".bin", "codebase-snapshot");
+  const installed = fs17.existsSync(bin) || fs17.existsSync(`${bin}.cmd`);
   return installed ? "npm run snapshot" : "npm install && npm run snapshot";
 }
 function presetSummary(init) {
@@ -11167,7 +11447,7 @@ async function runInitCommand(invocation) {
       info(result.configText);
       return 0;
     }
-    info(`\u2705 Created ${path17.basename(result.configPath)} (${presetSummary(result)})`);
+    info(`\u2705 Created ${path18.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}`);
@@ -11187,7 +11467,7 @@ async function runInitCommand(invocation) {
   }
 }
 function detectPackageManager(cwd) {
-  const has = (name) => fs16.existsSync(path17.join(cwd, name));
+  const has = (name) => fs17.existsSync(path18.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"] };
@@ -11206,14 +11486,13 @@ function installDependencies(cwd) {
   const manager = detectPackageManager(cwd);
   const command = `${manager.command} ${manager.args.join(" ")}`;
   const started = performance.now();
-  const result = spawnSync(manager.command, manager.args, {
+  const spawnOptions = {
     cwd,
     encoding: "utf8",
-    // npm, pnpm and yarn ship as `.cmd` shims on Windows, which spawnSync cannot exec directly.
-    shell: process.platform === "win32",
     timeout: INSTALL_TIMEOUT_MS,
     env: cleanInstallEnv()
-  });
+  };
+  const result = process.platform === "win32" ? spawnSync(command, { ...spawnOptions, shell: true }) : spawnSync(manager.command, manager.args, spawnOptions);
   const seconds = `${((performance.now() - started) / 1e3).toFixed(1)}s`;
   if (result.error) {
     return { manager: manager.name, command, ok: false, detail: `${result.error.message} (${seconds})` };
@@ -11277,7 +11556,7 @@ async function runSetupCommand(invocation, options = {}) {
       }
       info("\n\u{1F9EA} Dry run \u2014 setup would:");
       info(
-        `   1. ${init.reused ? `keep ${path17.basename(init.configPath)}` : `write ${path17.basename(init.configPath)} (preset: ${init.preset})`}`
+        `   1. ${init.reused ? `keep ${path18.basename(init.configPath)}` : `write ${path18.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}`);
@@ -11289,9 +11568,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 ${path17.basename(init.configPath)} (${presetSummary(init)})`);
+        info(`\u267B  Keeping ${path18.basename(init.configPath)} (${presetSummary(init)})`);
       } else {
-        info(`\u2705 Created ${path17.basename(init.configPath)} (${presetSummary(init)})`);
+        info(`\u2705 Created ${path18.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) {
@@ -11399,7 +11678,7 @@ function runSkillCommand(invocation) {
     }
     info(`\u2705 Agent skill installed (${SKILL_NAME}):`);
     for (const item of result.written) {
-      const shown = path17.relative(invocation.cwd, item.path) || item.path;
+      const shown = path18.relative(invocation.cwd, item.path) || item.path;
       info(`   - ${item.action.padEnd(9)} ${shown}`);
     }
     if (result.gitignored.length > 0) {
@@ -11463,6 +11742,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);
@@ -11495,7 +11785,7 @@ ${USAGE}
     return runSkillCommand(invocation);
   }
   if (invocation.command === "mcp") {
-    return await runStdioServer({ cwd: path17.resolve(invocation.cwd) });
+    return await runStdioServer({ cwd: path18.resolve(invocation.cwd) });
   }
   if (invocation.command === "setup") {
     return runSetupCommand(invocation);
@@ -11512,7 +11802,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 ${path17.relative(process.cwd(), loaded.file) || loaded.file}`);
+  if (loaded.file) info(`\u2699  Using config ${path18.relative(process.cwd(), loaded.file) || loaded.file}`);
   const resolved = resolveConfig(
     loaded.config,
     {
@@ -11534,10 +11824,10 @@ ${USAGE}
   if (invocation.command === "validate") {
     const result = validateSnapshot(resolved);
     if (result.valid) {
-      const manifestPath = path17.resolve(resolved.cwd, resolved.outDir, "manifest.json");
+      const manifestPath = path18.resolve(resolved.cwd, resolved.outDir, "manifest.json");
       let manifest;
       try {
-        manifest = JSON.parse(fs16.readFileSync(manifestPath, "utf8"));
+        manifest = JSON.parse(fs17.readFileSync(manifestPath, "utf8"));
       } catch {
         manifest = void 0;
       }
@@ -11550,13 +11840,13 @@ ${USAGE}
     return result.valid ? 0 : 1;
   }
   if (invocation.command === "report") {
-    const manifestPath = path17.resolve(resolved.cwd, resolved.outDir, "manifest.json");
-    if (!fs16.existsSync(manifestPath)) {
+    const manifestPath = path18.resolve(resolved.cwd, resolved.outDir, "manifest.json");
+    if (!fs17.existsSync(manifestPath)) {
       return fail(invocation.format, `Manifest not found at ${manifestPath}. Run generate first.`);
     }
     let manifest;
     try {
-      manifest = JSON.parse(fs16.readFileSync(manifestPath, "utf8"));
+      manifest = JSON.parse(fs17.readFileSync(manifestPath, "utf8"));
     } catch (err) {
       return fail(invocation.format, `Could not read ${manifestPath}: ${err.message}`);
     }
@@ -11720,20 +12010,20 @@ function finishWatchRun(state, now) {
   };
 }
 function comparablePath(value) {
-  const absolute = path17.resolve(value);
+  const absolute = path18.resolve(value);
   return process.platform === "win32" ? absolute.toLowerCase() : absolute;
 }
 function isSameOrInside(parent, candidate) {
-  const relative11 = path17.relative(parent, candidate);
-  return relative11 === "" || relative11 !== ".." && !relative11.startsWith(`..${path17.sep}`) && !path17.isAbsolute(relative11);
+  const relative11 = path18.relative(parent, candidate);
+  return relative11 === "" || relative11 !== ".." && !relative11.startsWith(`..${path18.sep}`) && !path18.isAbsolute(relative11);
 }
 function isGeneratedWatchPath(candidate, paths) {
-  const absolute = comparablePath(path17.resolve(paths.cwd, candidate));
-  const outDir = comparablePath(path17.resolve(paths.cwd, paths.outDir));
-  const tmpDir = comparablePath(path17.resolve(paths.cwd, paths.tmpDir));
+  const absolute = comparablePath(path18.resolve(paths.cwd, candidate));
+  const outDir = comparablePath(path18.resolve(paths.cwd, paths.outDir));
+  const tmpDir = comparablePath(path18.resolve(paths.cwd, paths.tmpDir));
   if (isSameOrInside(outDir, absolute) || isSameOrInside(tmpDir, absolute)) return true;
-  const parent = path17.dirname(absolute);
-  if (parent === path17.dirname(outDir) && path17.basename(absolute).startsWith(`${path17.basename(outDir)}.backup-`)) {
+  const parent = path18.dirname(absolute);
+  if (parent === path18.dirname(outDir) && path18.basename(absolute).startsWith(`${path18.basename(outDir)}.backup-`)) {
     return true;
   }
   return absolute.split(/[\\/]+/).some((segment) => VCS_SEGMENTS.has(segment));
@@ -11750,8 +12040,8 @@ function decideWatchEvent(state, event, paths) {
   return { state, action: "schedule" };
 }
 async function runWatchLoop(invocation, resolved) {
-  const outDir = path17.resolve(resolved.cwd, resolved.outDir);
-  const tmpDir = path17.resolve(resolved.cwd, resolved.tmpDir);
+  const outDir = path18.resolve(resolved.cwd, resolved.outDir);
+  const tmpDir = path18.resolve(resolved.cwd, resolved.tmpDir);
   const paths = { cwd: resolved.cwd, outDir, tmpDir };
   let state = initialWatchState();
   let timer = null;
@@ -11816,11 +12106,11 @@ async function runWatchLoop(invocation, resolved) {
   };
   info("\u{1F440} Watching for changes. Press Ctrl+C to stop.");
   void regenerate();
-  const watcher = fs16.watch(resolved.cwd, { recursive: true }, (_event, filename) => {
+  const watcher = fs17.watch(resolved.cwd, { recursive: true }, (_event, filename) => {
     const decision = decideWatchEvent(
       state,
       {
-        path: filename ? path17.resolve(resolved.cwd, filename.toString()) : null,
+        path: filename ? path18.resolve(resolved.cwd, filename.toString()) : null,
         now: performance.now()
       },
       paths
@@ -11848,7 +12138,7 @@ async function runWatchLoop(invocation, resolved) {
   return 0;
 }
 var entryFile = process.argv[1] ?? "";
-var entryName = path17.basename(entryFile).toLowerCase();
+var entryName = path18.basename(entryFile).toLowerCase();
 var invokedDirectly = entryName === "cli.js" || entryName === "cli.cjs";
 if (invokedDirectly) {
   void main().then(