codebase-snapshot 0.9.5 → 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.5";
+var GENERATOR_VERSION = "0.9.6";
 var LEGACY_GENERATOR_NAMES = ["@ankurhalder/codebase-snapshot"];
 function isOurGeneratorName(name) {
   if (typeof name !== "string") return false;
@@ -5289,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;
@@ -5515,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) => {
@@ -5973,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]}
 `;
@@ -5991,7 +5991,7 @@ var sfcProfile = {
       script += `${match[1]}
 `;
     }
-    const name = componentName(path18);
+    const name = componentName(path19);
     if (!script.trim()) {
       const summary2 = emptySummary();
       if (name) {
@@ -6025,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
@@ -6882,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;
@@ -6963,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);
     }
@@ -6978,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);
@@ -7072,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}`
@@ -7132,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, "");
@@ -7156,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" };
   }
@@ -7245,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,
@@ -7331,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;
       }
@@ -7346,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;
@@ -7372,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;
     }
@@ -7391,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;
     }
@@ -7406,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);
@@ -7420,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}).`
@@ -7455,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,
@@ -7464,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(
@@ -7492,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();
@@ -7501,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;
   }
@@ -7521,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;
@@ -7549,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;
   }
@@ -7668,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 = [];
@@ -7689,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,
@@ -7714,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;
@@ -8044,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,
@@ -8059,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);
@@ -8102,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));
     };
@@ -8125,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 {
       }
     }
@@ -8137,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: ";
@@ -8224,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;
   }
@@ -8240,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.` };
   }
@@ -8301,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,
@@ -8322,7 +8484,7 @@ function readManifest3(workspace) {
   }
   let raw;
   try {
-    raw = fs12.readFileSync(file, "utf8");
+    raw = fs13.readFileSync(file, "utf8");
   } catch (error) {
     return {
       ok: false,
@@ -8380,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) };
@@ -8399,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;
@@ -8615,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")}`,
@@ -8880,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.`
@@ -9145,6 +9307,7 @@ var VALIDATE_OPTIONS = [
   "no-config",
   "discovery",
   "format",
+  "no-update-check",
   "mode",
   "help",
   "version"
@@ -9168,6 +9331,7 @@ var COMMAND_OPTION_SCOPE = {
     "watch",
     "autopilot",
     "no-install",
+    "no-update-check",
     "help",
     "version"
   ],
@@ -9183,6 +9347,7 @@ var COMMAND_OPTION_SCOPE = {
     "skip-artifacts",
     "only-artifacts",
     "no-config",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9200,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",
@@ -9220,6 +9386,7 @@ var COMMAND_OPTION_SCOPE = {
     "yes",
     "force",
     "dry-run",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9243,6 +9410,7 @@ var COMMAND_OPTION_SCOPE = {
     "force",
     "no-install",
     "dry-run",
+    "no-update-check",
     "format",
     "mode",
     "help",
@@ -9675,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) => ({
@@ -9807,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";
@@ -9966,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;
   }
@@ -9992,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;
   }
@@ -10029,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));
@@ -10166,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 [];
   }
@@ -10225,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() {
@@ -10313,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,
@@ -10325,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);
@@ -10494,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([
@@ -10529,7 +10717,7 @@ async function workspaceFor(context) {
 }
 function readFileIfPresent(file) {
   try {
-    return fs15.readFileSync(file, "utf8");
+    return fs16.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -10608,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 };
@@ -10627,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 };
@@ -10865,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" }
 };
@@ -10939,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
 
@@ -11003,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}`);
     }
   }
@@ -11152,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,
@@ -11209,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) {
@@ -11256,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}`);
@@ -11276,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"] };
@@ -11365,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}`);
@@ -11377,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) {
@@ -11487,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) {
@@ -11551,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);
@@ -11583,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);
@@ -11600,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,
     {
@@ -11622,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;
       }
@@ -11638,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}`);
     }
@@ -11808,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));
@@ -11838,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;
@@ -11904,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
@@ -11936,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(