oh-my-customcode 0.31.1 → 0.32.0

package/dist/index.js

@@ -355,6 +355,16 @@ var MESSAGES = {
     "install.entry_md_installed": "{{entry}} installed ({{language}})",
     "install.entry_md_not_found": "{{entry}} template not found for {{language}}",
     "install.entry_md_skipped": "{{entry}} skipped ({{reason}})",
+    "install.lockfile_generated": "Lockfile generated ({{files}} files tracked)",
+    "install.lockfile_failed": "Failed to generate lockfile: {{error}}",
+    "lockfile.not_found": "Lockfile not found: {{path}}",
+    "lockfile.invalid_version": "Invalid lockfile version: {{path}}",
+    "lockfile.invalid_structure": "Invalid lockfile structure: {{path}}",
+    "lockfile.read_failed": "Failed to read lockfile: {{path}} — {{error}}",
+    "lockfile.written": "Lockfile written: {{path}}",
+    "lockfile.component_dir_missing": "Component directory missing: {{path}}",
+    "lockfile.hash_failed": "Failed to hash file: {{path}} — {{error}}",
+    "lockfile.entry_added": "Lockfile entry added: {{path}} ({{component}})",
     "update.start": "Checking for updates...",
     "update.success": "Updated from {{from}} to {{to}}",
     "update.components_synced": "Components synced (version {{version}}): {{components}}",
@@ -364,6 +374,8 @@ var MESSAGES = {
     "update.dry_run": "Would update {{component}}",
     "update.component_updated": "Updated {{component}}",
     "update.file_applied": "Applied update to {{path}}",
+    "update.lockfile_regenerated": "Lockfile regenerated ({{files}} files tracked)",
+    "update.lockfile_failed": "Failed to regenerate lockfile: {{error}}",
     "config.load_failed": "Failed to load config: {{error}}",
     "config.not_found": "Config not found at {{path}}, using defaults",
     "config.saved": "Config saved to {{path}}",
@@ -387,6 +399,16 @@ var MESSAGES = {
     "install.entry_md_installed": "{{entry}} 설치 완료 ({{language}})",
     "install.entry_md_not_found": "{{language}}용 {{entry}} 템플릿 없음",
     "install.entry_md_skipped": "{{entry}} 건너뜀 ({{reason}})",
+    "install.lockfile_generated": "잠금 파일 생성 완료 ({{files}}개 파일 추적)",
+    "install.lockfile_failed": "잠금 파일 생성 실패: {{error}}",
+    "lockfile.not_found": "잠금 파일 없음: {{path}}",
+    "lockfile.invalid_version": "잠금 파일 버전 유효하지 않음: {{path}}",
+    "lockfile.invalid_structure": "잠금 파일 구조 유효하지 않음: {{path}}",
+    "lockfile.read_failed": "잠금 파일 읽기 실패: {{path}} — {{error}}",
+    "lockfile.written": "잠금 파일 기록됨: {{path}}",
+    "lockfile.component_dir_missing": "컴포넌트 디렉토리 없음: {{path}}",
+    "lockfile.hash_failed": "파일 해시 실패: {{path}} — {{error}}",
+    "lockfile.entry_added": "잠금 파일 항목 추가: {{path}} ({{component}})",
     "update.start": "업데이트 확인 중...",
     "update.success": "{{from}}에서 {{to}}로 업데이트 완료",
     "update.components_synced": "컴포넌트 동기화 완료 (버전 {{version}}): {{components}}",
@@ -396,6 +418,8 @@ var MESSAGES = {
     "update.dry_run": "{{component}} 업데이트 예정",
     "update.component_updated": "{{component}} 업데이트 완료",
     "update.file_applied": "{{path}} 업데이트 적용",
+    "update.lockfile_regenerated": "잠금 파일 재생성 완료 ({{files}}개 파일 추적)",
+    "update.lockfile_failed": "잠금 파일 재생성 실패: {{error}}",
     "config.load_failed": "설정 로드 실패: {{error}}",
     "config.not_found": "{{path}}에 설정 없음, 기본값 사용",
     "config.saved": "설정 저장: {{path}}",
@@ -876,13 +900,32 @@ function getDefaultWorkflow() {
 // src/core/installer.ts
 init_fs();
 import { readFile as fsReadFile, writeFile as fsWriteFile, rename } from "node:fs/promises";
-import { basename as basename2, join as join4 } from "node:path";
+import { basename as basename2, join as join5 } from "node:path";
 
 // src/core/file-preservation.ts
 init_fs();
 import { basename, join as join3 } from "node:path";
 var DEFAULT_CRITICAL_FILES = ["settings.json", "settings.local.json"];
 var DEFAULT_CRITICAL_DIRECTORIES = ["agent-memory", "agent-memory-local"];
+var PROTECTED_FRAMEWORK_FILES = ["CLAUDE.md", "AGENTS.md"];
+var PROTECTED_RULE_PATTERNS = ["rules/MUST-*.md"];
+function isProtectedFile(relativePath) {
+  const basename2 = relativePath.split("/").pop() ?? "";
+  if (PROTECTED_FRAMEWORK_FILES.includes(basename2)) {
+    return true;
+  }
+  for (const pattern of PROTECTED_RULE_PATTERNS) {
+    if (matchesGlobPattern(relativePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesGlobPattern(filePath, pattern) {
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*");
+  const regex = new RegExp(`(^|/)${regexStr}$`);
+  return regex.test(filePath);
+}
 async function extractSingleFile(fileName, rootDir, tempDir, result) {
   const srcPath = join3(rootDir, fileName);
   const destPath = join3(tempDir, fileName);
@@ -1041,11 +1084,139 @@ function getComponentPath(component) {
   return `.claude/${component}`;
 }
 
+// src/core/lockfile.ts
+init_fs();
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { join as join4, relative as relative2 } from "node:path";
+var LOCKFILE_NAME = ".omcustom.lock.json";
+var LOCKFILE_VERSION = 1;
+var LOCKFILE_COMPONENTS = [
+  "rules",
+  "agents",
+  "skills",
+  "hooks",
+  "contexts",
+  "ontology",
+  "guides"
+];
+var COMPONENT_PATHS = LOCKFILE_COMPONENTS.map((component) => [getComponentPath(component), component]);
+function computeFileHash(filePath) {
+  return new Promise((resolve2, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("error", (err) => {
+      reject(err);
+    });
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("end", () => {
+      resolve2(hash.digest("hex"));
+    });
+  });
+}
+async function writeLockfile(targetDir, lockfile) {
+  const lockfilePath = join4(targetDir, LOCKFILE_NAME);
+  await writeJsonFile(lockfilePath, lockfile);
+  debug("lockfile.written", { path: lockfilePath });
+}
+function resolveComponent(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  for (const [prefix, component] of COMPONENT_PATHS) {
+    if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
+      return component;
+    }
+  }
+  return "unknown";
+}
+async function collectFiles(dir, projectRoot, isTopLevel) {
+  const results = [];
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (isTopLevel && entry.startsWith(".") && entry !== ".claude") {
+      continue;
+    }
+    const fullPath = join4(dir, entry);
+    let fileStat;
+    try {
+      fileStat = await stat(fullPath);
+    } catch {
+      continue;
+    }
+    if (fileStat.isDirectory()) {
+      const subFiles = await collectFiles(fullPath, projectRoot, false);
+      results.push(...subFiles);
+    } else if (fileStat.isFile()) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function generateLockfile(targetDir, generatorVersion, templateVersion) {
+  const files = {};
+  const componentRoots = COMPONENT_PATHS.map(([prefix]) => join4(targetDir, prefix));
+  for (const componentRoot of componentRoots) {
+    const exists = await fileExists(componentRoot);
+    if (!exists) {
+      debug("lockfile.component_dir_missing", { path: componentRoot });
+      continue;
+    }
+    const allFiles = await collectFiles(componentRoot, targetDir, false);
+    for (const absolutePath of allFiles) {
+      const relativePath = relative2(targetDir, absolutePath).replace(/\\/g, "/");
+      let hash;
+      let size;
+      try {
+        hash = await computeFileHash(absolutePath);
+        const fileStat = await stat(absolutePath);
+        size = fileStat.size;
+      } catch (err) {
+        warn("lockfile.hash_failed", { path: absolutePath, error: String(err) });
+        continue;
+      }
+      const component = resolveComponent(relativePath);
+      files[relativePath] = {
+        templateHash: hash,
+        size,
+        component
+      };
+      debug("lockfile.entry_added", { path: relativePath, component });
+    }
+  }
+  return {
+    lockfileVersion: LOCKFILE_VERSION,
+    generatorVersion,
+    generatedAt: new Date().toISOString(),
+    templateVersion,
+    files
+  };
+}
+async function generateAndWriteLockfileForDir(targetDir) {
+  try {
+    const packageRoot = getPackageRoot();
+    const manifest = await readJsonFile(join4(packageRoot, "templates", "manifest.json"));
+    const { version: generatorVersion } = await readJsonFile(join4(packageRoot, "package.json"));
+    const lockfile = await generateLockfile(targetDir, generatorVersion, manifest.version);
+    await writeLockfile(targetDir, lockfile);
+    return { fileCount: Object.keys(lockfile.files).length };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { fileCount: 0, warning: `Lockfile generation failed: ${msg}` };
+  }
+}
+
 // src/core/installer.ts
 var DEFAULT_LANGUAGE = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
-  return join4(packageRoot, "templates");
+  return join5(packageRoot, "templates");
 }
 function createInstallResult(targetDir) {
   return {
@@ -1067,7 +1238,7 @@ async function handleBackup(targetDir, shouldBackup, result) {
   if (!shouldBackup)
     return null;
   const layout = getProviderLayout();
-  const rootDir = join4(targetDir, layout.rootDir);
+  const rootDir = join5(targetDir, layout.rootDir);
   let preservation = null;
   if (await fileExists(rootDir)) {
     const { createTempDir: createTempDir2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
@@ -1124,8 +1295,8 @@ async function installSingleComponent(targetDir, component, options, result) {
 }
 async function installStatusline(targetDir, options, _result) {
   const layout = getProviderLayout();
-  const srcPath = resolveTemplatePath(join4(layout.rootDir, "statusline.sh"));
-  const destPath = join4(targetDir, layout.rootDir, "statusline.sh");
+  const srcPath = resolveTemplatePath(join5(layout.rootDir, "statusline.sh"));
+  const destPath = join5(targetDir, layout.rootDir, "statusline.sh");
   if (!await fileExists(srcPath)) {
     debug("install.statusline_not_found", { path: srcPath });
     return;
@@ -1143,7 +1314,7 @@ async function installStatusline(targetDir, options, _result) {
 }
 async function installSettingsLocal(targetDir, result) {
   const layout = getProviderLayout();
-  const settingsPath = join4(targetDir, layout.rootDir, "settings.local.json");
+  const settingsPath = join5(targetDir, layout.rootDir, "settings.local.json");
   const statusLineConfig = {
     statusLine: {
       type: "command",
@@ -1200,7 +1371,7 @@ async function install(options) {
     await installEntryDocWithTracking(options.targetDir, options, result);
     if (preservation) {
       const layout = getProviderLayout();
-      const rootDir = join4(options.targetDir, layout.rootDir);
+      const rootDir = join5(options.targetDir, layout.rootDir);
       const restoration = await restoreCriticalFiles(rootDir, preservation);
       if (restoration.restoredFiles.length > 0 || restoration.restoredDirs.length > 0) {
         info("install.restored", {
@@ -1216,6 +1387,13 @@ async function install(options) {
       await cleanupPreservation(preservation.tempDir);
     }
     await updateInstallConfig(options.targetDir, options, result.installedComponents);
+    const lockfileResult = await generateAndWriteLockfileForDir(options.targetDir);
+    if (lockfileResult.warning) {
+      result.warnings.push(lockfileResult.warning);
+      warn("install.lockfile_failed", { error: lockfileResult.warning });
+    } else {
+      info("install.lockfile_generated", { files: String(lockfileResult.fileCount) });
+    }
     result.success = true;
     success("install.success");
   } catch (err) {
@@ -1227,7 +1405,7 @@ async function install(options) {
 }
 async function copyTemplates(targetDir, templatePath, options) {
   const srcPath = resolveTemplatePath(templatePath);
-  const destPath = join4(targetDir, templatePath);
+  const destPath = join5(targetDir, templatePath);
   await copyDirectory(srcPath, destPath, {
     overwrite: options?.overwrite ?? false,
     preserveSymlinks: options?.preserveSymlinks ?? true,
@@ -1237,14 +1415,14 @@ async function copyTemplates(targetDir, templatePath, options) {
 async function createDirectoryStructure(targetDir) {
   const layout = getProviderLayout();
   for (const dir of layout.directoryStructure) {
-    const fullPath = join4(targetDir, dir);
+    const fullPath = join5(targetDir, dir);
     await ensureDirectory(fullPath);
   }
 }
 async function getTemplateManifest() {
   const packageRoot = getPackageRoot();
   const layout = getProviderLayout();
-  const manifestPath = join4(packageRoot, "templates", layout.manifestFile);
+  const manifestPath = join5(packageRoot, "templates", layout.manifestFile);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }
@@ -1268,7 +1446,7 @@ async function installComponent(targetDir, component, options) {
     return false;
   }
   const templatePath = getComponentPath(component);
-  const destPath = join4(targetDir, templatePath);
+  const destPath = join5(targetDir, templatePath);
   const destExists = await fileExists(destPath);
   if (destExists && !options.force && !options.backup) {
     debug("install.component_skipped", { component });
@@ -1296,7 +1474,7 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
   const layout = getProviderLayout();
   const templateFile = getEntryTemplateName(language);
   const srcPath = resolveTemplatePath(templateFile);
-  const destPath = join4(targetDir, layout.entryFile);
+  const destPath = join5(targetDir, layout.entryFile);
   if (!await fileExists(srcPath)) {
     warn("install.entry_md_not_found", { language, path: srcPath, entry: layout.entryFile });
     return false;
@@ -1317,7 +1495,7 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
 }
 async function backupExisting(sourcePath, backupDir) {
   const name = basename2(sourcePath);
-  const backupPath = join4(backupDir, name);
+  const backupPath = join5(backupDir, name);
   await rename(sourcePath, backupPath);
   return backupPath;
 }
@@ -1326,7 +1504,7 @@ async function checkExistingPaths(targetDir) {
   const pathsToCheck = [layout.entryFile, layout.rootDir, "guides"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
-    const fullPath = join4(targetDir, relativePath);
+    const fullPath = join5(targetDir, relativePath);
     if (await fileExists(fullPath)) {
       existingPaths.push(relativePath);
     }
@@ -1340,11 +1518,11 @@ async function backupExistingInstallation(targetDir) {
     return [];
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join4(targetDir, `${layout.backupDirPrefix}${timestamp}`);
+  const backupDir = join5(targetDir, `${layout.backupDirPrefix}${timestamp}`);
   await ensureDirectory(backupDir);
   const backedUpPaths = [];
   for (const relativePath of existingPaths) {
-    const fullPath = join4(targetDir, relativePath);
+    const fullPath = join5(targetDir, relativePath);
     try {
       const backupPath = await backupExisting(fullPath, backupDir);
       backedUpPaths.push(backupPath);
@@ -1367,7 +1545,7 @@ async function detectProvider(_options = {}) {
 }
 // src/core/updater.ts
 init_fs();
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/core/entry-merger.ts
 var MANAGED_START = "<!-- omcustom:start -->";
@@ -1616,7 +1794,7 @@ function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
 }
 async function updateEntryDoc(targetDir, config, options) {
   const layout = getProviderLayout();
-  const entryPath = join5(targetDir, layout.entryFile);
+  const entryPath = join6(targetDir, layout.entryFile);
   const templateName = getEntryTemplateName2(config.language);
   const templatePath = resolveTemplatePath(templateName);
   if (!await fileExists(templatePath)) {
@@ -1696,6 +1874,15 @@ async function update(options) {
     const components = options.components || getAllUpdateComponents();
     await updateAllComponents(options.targetDir, components, updateCheck, customizations, options, result, config);
     await runFullUpdatePostProcessing(options, result, config);
+    const lockfileResult = await generateAndWriteLockfileForDir(options.targetDir);
+    if (lockfileResult.warning) {
+      result.warnings.push(lockfileResult.warning);
+      warn("update.lockfile_failed", { error: lockfileResult.warning });
+    } else {
+      debug("update.lockfile_regenerated", {
+        files: String(lockfileResult.fileCount)
+      });
+    }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     result.error = message;
@@ -1729,8 +1916,8 @@ async function checkForUpdates(targetDir) {
 async function applyUpdates(targetDir, updates) {
   const fs = await import("node:fs/promises");
   for (const update2 of updates) {
-    const fullPath = join5(targetDir, update2.path);
-    await ensureDirectory(join5(fullPath, ".."));
+    const fullPath = join6(targetDir, update2.path);
+    await ensureDirectory(join6(fullPath, ".."));
     await fs.writeFile(fullPath, update2.content, "utf-8");
     debug("update.file_applied", { path: update2.path });
   }
@@ -1739,7 +1926,7 @@ async function preserveCustomizations(targetDir, customizations) {
   const preserved = new Map;
   const fs = await import("node:fs/promises");
   for (const filePath of customizations) {
-    const fullPath = join5(targetDir, filePath);
+    const fullPath = join6(targetDir, filePath);
     if (await fileExists(fullPath)) {
       const content = await fs.readFile(fullPath, "utf-8");
       preserved.set(filePath, content);
@@ -1767,11 +1954,55 @@ async function componentHasUpdate(_targetDir, component, config) {
   const latestVersion = await getLatestVersion();
   return installedVersion !== latestVersion;
 }
+async function collectProtectedSkipPaths(srcPath, destPath, componentPath, forceOverwriteAll) {
+  if (forceOverwriteAll) {
+    const warnedPaths = await findProtectedFilesInDir(srcPath, componentPath);
+    return { skipPaths: [], warnedPaths };
+  }
+  const protectedRelative = await findProtectedFilesInDir(srcPath, componentPath);
+  const path = await import("node:path");
+  const skipPaths = protectedRelative.map((p) => path.relative(destPath, join6(destPath, p)));
+  return { skipPaths, warnedPaths: protectedRelative };
+}
+function isEntryProtected(relPath, componentRelativePrefix) {
+  if (isProtectedFile(relPath)) {
+    return true;
+  }
+  const componentPrefixed = componentRelativePrefix ? `${componentRelativePrefix}/${relPath}` : relPath;
+  return isProtectedFile(componentPrefixed);
+}
+async function safeReaddir(dir, fs) {
+  try {
+    return await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+async function findProtectedFilesInDir(dirPath, componentRelativePrefix) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const protected_ = [];
+  const queue = [{ dir: dirPath, relDir: "" }];
+  while (queue.length > 0) {
+    const { dir, relDir } = queue.shift();
+    const entries = await safeReaddir(dir, fs);
+    for (const entry of entries) {
+      const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        queue.push({ dir: fullPath, relDir: relPath });
+      } else if (entry.isFile() && isEntryProtected(relPath, componentRelativePrefix)) {
+        protected_.push(relPath);
+      }
+    }
+  }
+  return protected_;
+}
 async function updateComponent(targetDir, component, customizations, options, config) {
   const preservedFiles = [];
   const componentPath = getComponentPath2(component);
   const srcPath = resolveTemplatePath(componentPath);
-  const destPath = join5(targetDir, componentPath);
+  const destPath = join6(targetDir, componentPath);
   const customComponents = config.customComponents || [];
   const skipPaths = [];
   if (customizations && !options.forceOverwriteAll) {
@@ -1784,15 +2015,34 @@ async function updateComponent(targetDir, component, customizations, options, co
       skipPaths.push(cc.path);
     }
   }
+  const { skipPaths: protectedSkipPaths, warnedPaths: protectedWarnedPaths } = await collectProtectedSkipPaths(srcPath, destPath, componentPath, !!options.forceOverwriteAll);
+  for (const protectedPath of protectedWarnedPaths) {
+    if (options.forceOverwriteAll) {
+      warn("update.protected_file_force_overwrite", {
+        file: protectedPath,
+        component,
+        hint: "File contains AI behavioral constraints. Overwriting because --force-overwrite-all was set."
+      });
+    } else {
+      warn("update.protected_file_skipped", {
+        file: protectedPath,
+        component,
+        hint: "File contains AI behavioral constraints and was not updated. Use --force-overwrite-all to override."
+      });
+    }
+  }
+  skipPaths.push(...protectedSkipPaths);
   const path = await import("node:path");
-  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join5(targetDir, p)));
+  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join6(targetDir, p)));
+  const uniqueSkipPaths = [...new Set(normalizedSkipPaths)];
   await copyDirectory(srcPath, destPath, {
     overwrite: true,
-    skipPaths: normalizedSkipPaths.length > 0 ? normalizedSkipPaths : undefined
+    skipPaths: uniqueSkipPaths.length > 0 ? uniqueSkipPaths : undefined
   });
   debug("update.component_updated", {
     component,
-    skippedPaths: String(normalizedSkipPaths.length)
+    skippedPaths: String(uniqueSkipPaths.length),
+    protectedSkipped: String(protectedSkipPaths.length)
   });
   return preservedFiles;
 }
@@ -1805,12 +2055,12 @@ async function syncRootLevelFiles(targetDir, options) {
   const layout = getProviderLayout();
   const synced = [];
   for (const fileName of ROOT_LEVEL_FILES) {
-    const srcPath = resolveTemplatePath(join5(layout.rootDir, fileName));
+    const srcPath = resolveTemplatePath(join6(layout.rootDir, fileName));
     if (!await fileExists(srcPath)) {
       continue;
     }
-    const destPath = join5(targetDir, layout.rootDir, fileName);
-    await ensureDirectory(join5(destPath, ".."));
+    const destPath = join6(targetDir, layout.rootDir, fileName);
+    await ensureDirectory(join6(destPath, ".."));
     await fs.copyFile(srcPath, destPath);
     if (fileName.endsWith(".sh")) {
       await fs.chmod(destPath, 493);
@@ -1845,7 +2095,7 @@ async function removeDeprecatedFiles(targetDir, options) {
       });
       continue;
     }
-    const fullPath = join5(targetDir, entry.path);
+    const fullPath = join6(targetDir, entry.path);
     if (await fileExists(fullPath)) {
       await fs.unlink(fullPath);
       removed.push(entry.path);
@@ -1869,26 +2119,26 @@ function getComponentPath2(component) {
 }
 async function backupInstallation(targetDir) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join5(targetDir, `.omcustom-backup-${timestamp}`);
+  const backupDir = join6(targetDir, `.omcustom-backup-${timestamp}`);
   const fs = await import("node:fs/promises");
   await ensureDirectory(backupDir);
   const layout = getProviderLayout();
   const dirsToBackup = [layout.rootDir, "guides"];
   for (const dir of dirsToBackup) {
-    const srcPath = join5(targetDir, dir);
+    const srcPath = join6(targetDir, dir);
     if (await fileExists(srcPath)) {
-      const destPath = join5(backupDir, dir);
+      const destPath = join6(backupDir, dir);
       await copyDirectory(srcPath, destPath, { overwrite: true });
     }
   }
-  const entryPath = join5(targetDir, layout.entryFile);
+  const entryPath = join6(targetDir, layout.entryFile);
   if (await fileExists(entryPath)) {
-    await fs.copyFile(entryPath, join5(backupDir, layout.entryFile));
+    await fs.copyFile(entryPath, join6(backupDir, layout.entryFile));
   }
   return backupDir;
 }
 async function loadCustomizationManifest(targetDir) {
-  const manifestPath = join5(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  const manifestPath = join6(targetDir, CUSTOMIZATION_MANIFEST_FILE);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.31.1",
+  "version": "0.32.0",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.claude/hooks/scripts/session-env-check.sh

@@ -82,6 +82,40 @@ if command -v git >/dev/null 2>&1 && git rev-parse --is-inside-work-tree >/dev/n
   fi
 fi
 
+# Update availability check (local cache only — no network calls)
+OMCUSTOM_UPDATE_STATUS="unknown"
+INSTALLED_VERSION=""
+CACHED_LATEST=""
+
+# Read installed version from .omcustomrc.json
+if [ -f ".omcustomrc.json" ]; then
+  INSTALLED_VERSION=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' .omcustomrc.json 2>/dev/null | head -1 | grep -o '"[^"]*"$' | tr -d '"')
+fi
+
+# Read cached latest version (no network call)
+CACHE_FILE="$HOME/.oh-my-customcode/self-update-cache.json"
+if [ -f "$CACHE_FILE" ]; then
+  CACHED_LATEST=$(grep -o '"latestVersion"[[:space:]]*:[[:space:]]*"[^"]*"' "$CACHE_FILE" 2>/dev/null | grep -o '"[^"]*"$' | tr -d '"')
+fi
+
+if [ -n "$INSTALLED_VERSION" ] && [ -n "$CACHED_LATEST" ]; then
+  if [ "$INSTALLED_VERSION" != "$CACHED_LATEST" ]; then
+    # Simple version comparison using sort -V
+    OLDER=$(printf '%s\n' "$INSTALLED_VERSION" "$CACHED_LATEST" | sort -V | head -1)
+    if [ "$OLDER" = "$INSTALLED_VERSION" ] && [ "$INSTALLED_VERSION" != "$CACHED_LATEST" ]; then
+      OMCUSTOM_UPDATE_STATUS="available"
+    else
+      OMCUSTOM_UPDATE_STATUS="up-to-date"
+    fi
+  else
+    OMCUSTOM_UPDATE_STATUS="up-to-date"
+  fi
+elif [ -n "$INSTALLED_VERSION" ]; then
+  OMCUSTOM_UPDATE_STATUS="no-cache"
+else
+  OMCUSTOM_UPDATE_STATUS="not-installed"
+fi
+
 # Write status to file for other hooks to reference
 STATUS_FILE="/tmp/.claude-env-status-${PPID}"
 cat > "$STATUS_FILE" << ENVEOF
@@ -91,6 +125,7 @@ git_branch=${CURRENT_BRANCH}
 claude_version=${CLAUDE_VERSION}
 compat_status=${COMPAT_STATUS}
 drift_status=${DRIFT_STATUS}
+omcustom_update=${OMCUSTOM_UPDATE_STATUS}
 ENVEOF
 
 # Report to stderr (visible in conversation)
@@ -138,6 +173,23 @@ case "$DRIFT_STATUS" in
 esac
 echo "------------------------------------" >&2
 
+# Update Check report
+echo "" >&2
+echo "  [Update Check]" >&2
+if [ -n "$INSTALLED_VERSION" ] && [ -n "$CACHED_LATEST" ]; then
+  if [ "$OMCUSTOM_UPDATE_STATUS" = "available" ]; then
+    echo "  ⚡ oh-my-customcode v${CACHED_LATEST} available (current: v${INSTALLED_VERSION})" >&2
+    echo "     Run 'omcustom update' to apply" >&2
+  else
+    echo "  ✓ oh-my-customcode is up to date (v${INSTALLED_VERSION})" >&2
+  fi
+elif [ -n "$INSTALLED_VERSION" ]; then
+  echo "  ℹ oh-my-customcode v${INSTALLED_VERSION} (run 'omcustom doctor --updates' to check for updates)" >&2
+else
+  echo "  ℹ oh-my-customcode not detected in this project" >&2
+fi
+echo "------------------------------------" >&2
+
 # Pass through
 echo "$input"
 exit 0

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.31.1",
+  "version": "0.32.0",
   "lastUpdated": "2026-03-09T00:00:00.000Z",
   "components": [
     {