oh-my-customcode 0.31.1 → 0.32.0

package/dist/cli/index.js

@@ -12097,6 +12097,10 @@ var en_default = {
     doctor: {
       description: "Check and fix configuration issues",
       fixOption: "Automatically fix issues that can be fixed",
+      updatesOption: "Check for oh-my-customcode updates",
+      updateAvailable: "Update available: v{{current}} → v{{latest}}. Run 'omcustom update' to apply.",
+      updateUpToDate: "oh-my-customcode is up to date (v{{version}})",
+      updateCheckFailed: "Update check failed ({{reason}})",
       checking: "Running diagnostic checks...",
       applyingFixes: "Applying fixes...",
       fixing: "Fixing: {{name}}...",
@@ -12413,6 +12417,10 @@ var ko_default = {
     doctor: {
       description: "설정 문제 확인 및 수정",
       fixOption: "자동으로 수정 가능한 문제 수정",
+      updatesOption: "oh-my-customcode 업데이트 확인",
+      updateAvailable: "업데이트 가능: v{{current}} → v{{latest}}. 'omcustom update'를 실행하여 적용하세요.",
+      updateUpToDate: "oh-my-customcode가 최신 상태입니다 (v{{version}})",
+      updateCheckFailed: "업데이트 확인 실패 ({{reason}})",
       checking: "진단 검사 실행 중...",
       applyingFixes: "수정 사항 적용 중...",
       fixing: "수정 중: {{name}}...",
@@ -12865,8 +12873,9 @@ async function maybeHandleSelfUpdateForInit(options) {
 }
 
 // src/cli/doctor.ts
-import { constants, promises as fs } from "node:fs";
+import { constants, promises as fs, readFileSync as readFileSync2 } from "node:fs";
 import path from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -12978,6 +12987,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}}",
@@ -12987,6 +13006,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}}",
@@ -13010,6 +13031,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}}",
@@ -13019,6 +13050,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}}",
@@ -13713,12 +13746,51 @@ function printCheck(check) {
     }
   }
 }
+function readCurrentVersion() {
+  try {
+    const __filename2 = fileURLToPath2(import.meta.url);
+    const packageJsonPath = path.resolve(path.dirname(__filename2), "../../package.json");
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    return packageJson.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function checkUpdateAvailable(currentVersion) {
+  const result = checkSelfUpdate({ currentVersion });
+  if (!result.checked) {
+    return {
+      name: "Update",
+      status: "warn",
+      message: i18n.t("cli.doctor.updateCheckFailed", { reason: result.reason ?? "unknown" }),
+      fixable: false
+    };
+  }
+  if (result.updateAvailable && result.latestVersion !== null) {
+    return {
+      name: "Update",
+      status: "warn",
+      message: i18n.t("cli.doctor.updateAvailable", {
+        current: currentVersion,
+        latest: result.latestVersion
+      }),
+      fixable: false,
+      details: result.usedCache ? ["(checked from cache)"] : ["(checked from npm registry)"]
+    };
+  }
+  return {
+    name: "Update",
+    status: "pass",
+    message: i18n.t("cli.doctor.updateUpToDate", { version: currentVersion }),
+    fixable: false
+  };
+}
 async function doctorCommand(options = {}) {
   const targetDir = process.cwd();
   console.log(i18n.t("cli.doctor.checking"));
   console.log("");
   const layout = getProviderLayout();
-  let checks = await Promise.all([
+  const baseChecks = await Promise.all([
     checkEntryDoc(targetDir, layout.entryFile),
     checkRules(targetDir, layout.rootDir),
     checkAgents(targetDir, layout.rootDir),
@@ -13730,12 +13802,14 @@ async function doctorCommand(options = {}) {
     checkContexts(targetDir, layout.rootDir),
     checkCustomComponents(targetDir, layout.rootDir)
   ]);
+  const checksWithUpdate = options.updates ? [...baseChecks, checkUpdateAvailable(readCurrentVersion())] : baseChecks;
+  let checks = checksWithUpdate;
   if (options.fix) {
-    const hasFixableIssues = checks.some((c) => c.status === "fail" && c.fixable);
+    const hasFixableIssues = checksWithUpdate.some((c) => c.status === "fail" && c.fixable);
     if (hasFixableIssues) {
       console.log(i18n.t("cli.doctor.applyingFixes"));
       console.log("");
-      checks = await fixIssues(checks, targetDir, layout.rootDir);
+      checks = await fixIssues(checksWithUpdate, targetDir, layout.rootDir);
       console.log("");
     }
   }
@@ -13777,18 +13851,37 @@ async function doctorCommand(options = {}) {
 }
 
 // src/cli/init.ts
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/core/installer.ts
 init_fs();
 import { readFile as fsReadFile, writeFile as fsWriteFile, rename } from "node:fs/promises";
-import { basename as basename2, join as join5 } from "node:path";
+import { basename as basename2, join as join6 } from "node:path";
 
 // src/core/file-preservation.ts
 init_fs();
 import { basename, join as join4 } 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 = join4(rootDir, fileName);
   const destPath = join4(tempDir, fileName);
@@ -14160,11 +14253,139 @@ function getDefaultWorkflow() {
   };
 }
 
+// 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 join5, 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 = join5(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(dir2, projectRoot, isTopLevel) {
+  const results = [];
+  let entries;
+  try {
+    entries = await readdir(dir2);
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (isTopLevel && entry.startsWith(".") && entry !== ".claude") {
+      continue;
+    }
+    const fullPath = join5(dir2, 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]) => join5(targetDir, prefix));
+  for (const componentRoot of componentRoots) {
+    const exists2 = await fileExists(componentRoot);
+    if (!exists2) {
+      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(join5(packageRoot, "templates", "manifest.json"));
+    const { version: generatorVersion } = await readJsonFile(join5(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_LANGUAGE2 = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
-  return join5(packageRoot, "templates");
+  return join6(packageRoot, "templates");
 }
 function createInstallResult(targetDir) {
   return {
@@ -14186,7 +14407,7 @@ async function handleBackup(targetDir, shouldBackup, result) {
   if (!shouldBackup)
     return null;
   const layout = getProviderLayout();
-  const rootDir = join5(targetDir, layout.rootDir);
+  const rootDir = join6(targetDir, layout.rootDir);
   let preservation = null;
   if (await fileExists(rootDir)) {
     const { createTempDir: createTempDir2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
@@ -14243,8 +14464,8 @@ async function installSingleComponent(targetDir, component, options, result) {
 }
 async function installStatusline(targetDir, options, _result) {
   const layout = getProviderLayout();
-  const srcPath = resolveTemplatePath(join5(layout.rootDir, "statusline.sh"));
-  const destPath = join5(targetDir, layout.rootDir, "statusline.sh");
+  const srcPath = resolveTemplatePath(join6(layout.rootDir, "statusline.sh"));
+  const destPath = join6(targetDir, layout.rootDir, "statusline.sh");
   if (!await fileExists(srcPath)) {
     debug("install.statusline_not_found", { path: srcPath });
     return;
@@ -14262,7 +14483,7 @@ async function installStatusline(targetDir, options, _result) {
 }
 async function installSettingsLocal(targetDir, result) {
   const layout = getProviderLayout();
-  const settingsPath = join5(targetDir, layout.rootDir, "settings.local.json");
+  const settingsPath = join6(targetDir, layout.rootDir, "settings.local.json");
   const statusLineConfig = {
     statusLine: {
       type: "command",
@@ -14319,7 +14540,7 @@ async function install(options) {
     await installEntryDocWithTracking(options.targetDir, options, result);
     if (preservation) {
       const layout = getProviderLayout();
-      const rootDir = join5(options.targetDir, layout.rootDir);
+      const rootDir = join6(options.targetDir, layout.rootDir);
       const restoration = await restoreCriticalFiles(rootDir, preservation);
       if (restoration.restoredFiles.length > 0 || restoration.restoredDirs.length > 0) {
         info("install.restored", {
@@ -14335,6 +14556,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) {
@@ -14352,7 +14580,7 @@ async function installComponent(targetDir, component, options) {
     return false;
   }
   const templatePath = getComponentPath(component);
-  const destPath = join5(targetDir, templatePath);
+  const destPath = join6(targetDir, templatePath);
   const destExists = await fileExists(destPath);
   if (destExists && !options.force && !options.backup) {
     debug("install.component_skipped", { component });
@@ -14380,7 +14608,7 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
   const layout = getProviderLayout();
   const templateFile = getEntryTemplateName(language);
   const srcPath = resolveTemplatePath(templateFile);
-  const destPath = join5(targetDir, layout.entryFile);
+  const destPath = join6(targetDir, layout.entryFile);
   if (!await fileExists(srcPath)) {
     warn("install.entry_md_not_found", { language, path: srcPath, entry: layout.entryFile });
     return false;
@@ -14401,7 +14629,7 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
 }
 async function backupExisting(sourcePath, backupDir) {
   const name = basename2(sourcePath);
-  const backupPath = join5(backupDir, name);
+  const backupPath = join6(backupDir, name);
   await rename(sourcePath, backupPath);
   return backupPath;
 }
@@ -14410,7 +14638,7 @@ async function checkExistingPaths(targetDir) {
   const pathsToCheck = [layout.entryFile, layout.rootDir, "guides"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
-    const fullPath = join5(targetDir, relativePath);
+    const fullPath = join6(targetDir, relativePath);
     if (await fileExists(fullPath)) {
       existingPaths.push(relativePath);
     }
@@ -14424,11 +14652,11 @@ async function backupExistingInstallation(targetDir) {
     return [];
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join5(targetDir, `${layout.backupDirPrefix}${timestamp}`);
+  const backupDir = join6(targetDir, `${layout.backupDirPrefix}${timestamp}`);
   await ensureDirectory(backupDir);
   const backedUpPaths = [];
   for (const relativePath of existingPaths) {
-    const fullPath = join5(targetDir, relativePath);
+    const fullPath = join6(targetDir, relativePath);
     try {
       const backupPath = await backupExisting(fullPath, backupDir);
       backedUpPaths.push(backupPath);
@@ -14445,12 +14673,12 @@ async function backupExistingInstallation(targetDir) {
 init_fs();
 import { execSync as execSync3 } from "node:child_process";
 import { writeFile } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 async function generateMCPConfig(targetDir) {
   const layout = getProviderLayout();
-  const mcpConfigPath = join6(targetDir, ".mcp.json");
-  const ontologyDir = join6(layout.rootDir, "ontology");
-  const ontologyExists = await fileExists(join6(targetDir, ontologyDir));
+  const mcpConfigPath = join7(targetDir, ".mcp.json");
+  const ontologyDir = join7(layout.rootDir, "ontology");
+  const ontologyExists = await fileExists(join7(targetDir, ontologyDir));
   if (!ontologyExists) {
     return;
   }
@@ -14507,7 +14735,7 @@ async function checkUvAvailable() {
 init_fs();
 async function checkExistingInstallation(targetDir) {
   const layout = getProviderLayout();
-  const rootDir = join7(targetDir, layout.rootDir);
+  const rootDir = join8(targetDir, layout.rootDir);
   return fileExists(rootDir);
 }
 var PROVIDER_SUBDIR_COMPONENTS = new Set([
@@ -14521,13 +14749,13 @@ var PROVIDER_SUBDIR_COMPONENTS = new Set([
 function componentToPath(targetDir, component) {
   if (component === "entry-md") {
     const layout = getProviderLayout();
-    return join7(targetDir, layout.entryFile);
+    return join8(targetDir, layout.entryFile);
   }
   if (PROVIDER_SUBDIR_COMPONENTS.has(component)) {
     const layout = getProviderLayout();
-    return join7(targetDir, layout.rootDir, component);
+    return join8(targetDir, layout.rootDir, component);
   }
-  return join7(targetDir, component);
+  return join8(targetDir, component);
 }
 function buildInstalledPaths(targetDir, components) {
   return components.map((component) => componentToPath(targetDir, component));
@@ -14607,7 +14835,7 @@ async function initCommand(options) {
 }
 
 // src/cli/list.ts
-import { basename as basename3, dirname as dirname3, join as join8, relative as relative2 } from "node:path";
+import { basename as basename3, dirname as dirname3, join as join9, relative as relative3 } from "node:path";
 init_fs();
 var ALLOWED_TOP_LEVEL_KEYS = new Set(["name", "type", "description", "version", "category"]);
 function parseKeyValue(line) {
@@ -14672,12 +14900,12 @@ function extractAgentTypeFromFilename(filename) {
   return prefixMap[prefix] || "unknown";
 }
 function extractSkillCategoryFromPath(skillPath, baseDir, rootDir) {
-  const relativePath = relative2(join8(baseDir, rootDir, "skills"), skillPath);
+  const relativePath = relative3(join9(baseDir, rootDir, "skills"), skillPath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
 function extractGuideCategoryFromPath(guidePath, baseDir) {
-  const relativePath = relative2(join8(baseDir, "guides"), guidePath);
+  const relativePath = relative3(join9(baseDir, "guides"), guidePath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
@@ -14771,7 +14999,7 @@ async function tryExtractMarkdownDescription(mdPath, options = {}) {
   }
 }
 async function getAgents(targetDir, rootDir = ".claude", config) {
-  const agentsDir = join8(targetDir, rootDir, "agents");
+  const agentsDir = join9(targetDir, rootDir, "agents");
   if (!await fileExists(agentsDir))
     return [];
   try {
@@ -14783,7 +15011,7 @@ async function getAgents(targetDir, rootDir = ".claude", config) {
       const filename = basename3(agentMdPath);
       const name = basename3(filename, ".md");
       const description = await tryExtractMarkdownDescription(agentMdPath);
-      const relativePath = relative2(targetDir, agentMdPath);
+      const relativePath = relative3(targetDir, agentMdPath);
       return {
         name,
         type: extractAgentTypeFromFilename(filename),
@@ -14799,7 +15027,7 @@ async function getAgents(targetDir, rootDir = ".claude", config) {
   }
 }
 async function getSkills(targetDir, rootDir = ".claude", config) {
-  const skillsDir = join8(targetDir, rootDir, "skills");
+  const skillsDir = join9(targetDir, rootDir, "skills");
   if (!await fileExists(skillsDir))
     return [];
   try {
@@ -14809,9 +15037,9 @@ async function getSkills(targetDir, rootDir = ".claude", config) {
     const skillMdFiles = await listFiles(skillsDir, { recursive: true, pattern: "SKILL.md" });
     const skills = await Promise.all(skillMdFiles.map(async (skillMdPath) => {
       const skillDir = dirname3(skillMdPath);
-      const indexYamlPath = join8(skillDir, "index.yaml");
+      const indexYamlPath = join9(skillDir, "index.yaml");
       const { description, version } = await tryReadIndexYamlMetadata(indexYamlPath);
-      const relativePath = relative2(targetDir, skillDir);
+      const relativePath = relative3(targetDir, skillDir);
       return {
         name: basename3(skillDir),
         type: "skill",
@@ -14828,7 +15056,7 @@ async function getSkills(targetDir, rootDir = ".claude", config) {
   }
 }
 async function getGuides(targetDir, config) {
-  const guidesDir = join8(targetDir, "guides");
+  const guidesDir = join9(targetDir, "guides");
   if (!await fileExists(guidesDir))
     return [];
   try {
@@ -14838,7 +15066,7 @@ async function getGuides(targetDir, config) {
     const guideMdFiles = await listFiles(guidesDir, { recursive: true, pattern: "*.md" });
     const guides = await Promise.all(guideMdFiles.map(async (guideMdPath) => {
       const description = await tryExtractMarkdownDescription(guideMdPath, { maxLength: 100 });
-      const relativePath = relative2(targetDir, guideMdPath);
+      const relativePath = relative3(targetDir, guideMdPath);
       return {
         name: basename3(guideMdPath, ".md"),
         type: "guide",
@@ -14855,7 +15083,7 @@ async function getGuides(targetDir, config) {
 }
 var RULE_PRIORITY_ORDER = { MUST: 0, SHOULD: 1, MAY: 2 };
 async function getRules(targetDir, rootDir = ".claude", config) {
-  const rulesDir = join8(targetDir, rootDir, "rules");
+  const rulesDir = join9(targetDir, rootDir, "rules");
   if (!await fileExists(rulesDir))
     return [];
   try {
@@ -14868,7 +15096,7 @@ async function getRules(targetDir, rootDir = ".claude", config) {
       const description = await tryExtractMarkdownDescription(ruleMdPath, {
         cleanFormatting: true
       });
-      const relativePath = relative2(targetDir, ruleMdPath);
+      const relativePath = relative3(targetDir, ruleMdPath);
       return {
         name: basename3(ruleMdPath, ".md"),
         type: extractRulePriorityFromFilename(filename),
@@ -14927,7 +15155,7 @@ function formatAsJson(components) {
   console.log(JSON.stringify(components, null, 2));
 }
 async function getHooks(targetDir, rootDir = ".claude") {
-  const hooksDir = join8(targetDir, rootDir, "hooks");
+  const hooksDir = join9(targetDir, rootDir, "hooks");
   if (!await fileExists(hooksDir))
     return [];
   try {
@@ -14938,14 +15166,14 @@ async function getHooks(targetDir, rootDir = ".claude") {
     return allFiles.map((hookPath) => ({
       name: basename3(hookPath),
       type: "hook",
-      path: relative2(targetDir, hookPath)
+      path: relative3(targetDir, hookPath)
     })).sort((a, b) => a.name.localeCompare(b.name));
   } catch {
     return [];
   }
 }
 async function getContexts(targetDir, rootDir = ".claude") {
-  const contextsDir = join8(targetDir, rootDir, "contexts");
+  const contextsDir = join9(targetDir, rootDir, "contexts");
   if (!await fileExists(contextsDir))
     return [];
   try {
@@ -14958,7 +15186,7 @@ async function getContexts(targetDir, rootDir = ".claude") {
       return {
         name: basename3(ctxPath, ext),
         type: "context",
-        path: relative2(targetDir, ctxPath),
+        path: relative3(targetDir, ctxPath),
         description
       };
     }));
@@ -15335,7 +15563,7 @@ async function securityCommand(_options = {}) {
 
 // src/core/updater.ts
 init_fs();
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/core/entry-merger.ts
 var MANAGED_START = "<!-- omcustom:start -->";
@@ -15584,7 +15812,7 @@ function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
 }
 async function updateEntryDoc(targetDir, config, options) {
   const layout = getProviderLayout();
-  const entryPath = join9(targetDir, layout.entryFile);
+  const entryPath = join10(targetDir, layout.entryFile);
   const templateName = getEntryTemplateName2(config.language);
   const templatePath = resolveTemplatePath(templateName);
   if (!await fileExists(templatePath)) {
@@ -15664,6 +15892,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;
@@ -15714,11 +15951,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 path3 = await import("node:path");
+  const skipPaths = protectedRelative.map((p) => path3.relative(destPath, join10(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(dir2, fs3) {
+  try {
+    return await fs3.readdir(dir2, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+async function findProtectedFilesInDir(dirPath, componentRelativePrefix) {
+  const fs3 = await import("node:fs/promises");
+  const path3 = await import("node:path");
+  const protected_ = [];
+  const queue = [{ dir: dirPath, relDir: "" }];
+  while (queue.length > 0) {
+    const { dir: dir2, relDir } = queue.shift();
+    const entries = await safeReaddir(dir2, fs3);
+    for (const entry of entries) {
+      const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+      const fullPath = path3.join(dir2, 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 = join9(targetDir, componentPath);
+  const destPath = join10(targetDir, componentPath);
   const customComponents = config.customComponents || [];
   const skipPaths = [];
   if (customizations && !options.forceOverwriteAll) {
@@ -15731,15 +16012,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 path3 = await import("node:path");
-  const normalizedSkipPaths = skipPaths.map((p) => path3.relative(destPath, join9(targetDir, p)));
+  const normalizedSkipPaths = skipPaths.map((p) => path3.relative(destPath, join10(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;
 }
@@ -15752,12 +16052,12 @@ async function syncRootLevelFiles(targetDir, options) {
   const layout = getProviderLayout();
   const synced = [];
   for (const fileName of ROOT_LEVEL_FILES) {
-    const srcPath = resolveTemplatePath(join9(layout.rootDir, fileName));
+    const srcPath = resolveTemplatePath(join10(layout.rootDir, fileName));
     if (!await fileExists(srcPath)) {
       continue;
     }
-    const destPath = join9(targetDir, layout.rootDir, fileName);
-    await ensureDirectory(join9(destPath, ".."));
+    const destPath = join10(targetDir, layout.rootDir, fileName);
+    await ensureDirectory(join10(destPath, ".."));
     await fs3.copyFile(srcPath, destPath);
     if (fileName.endsWith(".sh")) {
       await fs3.chmod(destPath, 493);
@@ -15792,7 +16092,7 @@ async function removeDeprecatedFiles(targetDir, options) {
       });
       continue;
     }
-    const fullPath = join9(targetDir, entry.path);
+    const fullPath = join10(targetDir, entry.path);
     if (await fileExists(fullPath)) {
       await fs3.unlink(fullPath);
       removed.push(entry.path);
@@ -15816,26 +16116,26 @@ function getComponentPath2(component) {
 }
 async function backupInstallation(targetDir) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join9(targetDir, `.omcustom-backup-${timestamp}`);
+  const backupDir = join10(targetDir, `.omcustom-backup-${timestamp}`);
   const fs3 = await import("node:fs/promises");
   await ensureDirectory(backupDir);
   const layout = getProviderLayout();
   const dirsToBackup = [layout.rootDir, "guides"];
   for (const dir2 of dirsToBackup) {
-    const srcPath = join9(targetDir, dir2);
+    const srcPath = join10(targetDir, dir2);
     if (await fileExists(srcPath)) {
-      const destPath = join9(backupDir, dir2);
+      const destPath = join10(backupDir, dir2);
       await copyDirectory(srcPath, destPath, { overwrite: true });
     }
   }
-  const entryPath = join9(targetDir, layout.entryFile);
+  const entryPath = join10(targetDir, layout.entryFile);
   if (await fileExists(entryPath)) {
-    await fs3.copyFile(entryPath, join9(backupDir, layout.entryFile));
+    await fs3.copyFile(entryPath, join10(backupDir, layout.entryFile));
   }
   return backupDir;
 }
 async function loadCustomizationManifest(targetDir) {
-  const manifestPath = join9(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  const manifestPath = join10(targetDir, CUSTOMIZATION_MANIFEST_FILE);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }
@@ -15938,7 +16238,7 @@ function createProgram() {
       verbose: options.verbose
     });
   });
-  program2.command("doctor").description(i18n.t("cli.doctor.description")).option("--fix", i18n.t("cli.doctor.fixOption")).action(async (options) => {
+  program2.command("doctor").description(i18n.t("cli.doctor.description")).option("--fix", i18n.t("cli.doctor.fixOption")).option("--updates", i18n.t("cli.doctor.updatesOption")).action(async (options) => {
     await doctorCommand(options);
   });
   program2.command("security").description(i18n.t("cli.security.description")).option("--verbose", i18n.t("cli.security.verboseOption")).action(async (options) => {