oh-my-customcode 0.31.1 → 0.33.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}}",
@@ -875,14 +899,39 @@ 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 {
+  readFile as fsReadFile,
+  writeFile as fsWriteFile,
+  readdir as readdir2,
+  rename,
+  stat as stat2
+} from "node:fs/promises";
+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 +1090,152 @@ 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/scope-filter.ts
+function getSkillScope(content) {
+  const cleaned = content.replace(/^\uFEFF/, "");
+  const frontmatter = cleaned.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatter)
+    return "core";
+  const match = frontmatter[1].match(/^scope:\s*(core|harness|package)\s*$/m);
+  return match?.[1] ?? "core";
+}
+function shouldInstallSkill(scope) {
+  return scope !== "package";
+}
+
 // 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 +1257,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 +1314,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 +1333,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 +1390,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 +1406,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 +1424,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 +1434,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);
   }
@@ -1263,12 +1460,35 @@ async function getTemplateManifest() {
 function getAllComponents() {
   return ["rules", "agents", "skills", "guides", "hooks", "contexts", "ontology"];
 }
+async function installSkillsWithScopeFilter(srcPath, destPath, options) {
+  await ensureDirectory(destPath);
+  const entries = await readdir2(srcPath);
+  for (const entry of entries) {
+    const entrySrcPath = join5(srcPath, entry);
+    if (!(await stat2(entrySrcPath)).isDirectory())
+      continue;
+    const skillMdPath = join5(entrySrcPath, "SKILL.md");
+    if (await fileExists(skillMdPath)) {
+      const content = await fsReadFile(skillMdPath, "utf-8");
+      const scope = getSkillScope(content);
+      if (!shouldInstallSkill(scope)) {
+        debug("install.skill_scope_excluded", { skill: entry, scope });
+        continue;
+      }
+    }
+    await copyDirectory(entrySrcPath, join5(destPath, entry), {
+      overwrite: !!(options.force || options.backup),
+      preserveSymlinks: true,
+      preserveTimestamps: true
+    });
+  }
+}
 async function installComponent(targetDir, component, options) {
   if (component === "entry-md") {
     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 });
@@ -1279,11 +1499,15 @@ async function installComponent(targetDir, component, options) {
     warn("install.template_not_found", { component, path: srcPath });
     return false;
   }
-  await copyDirectory(srcPath, destPath, {
-    overwrite: !!(options.force || options.backup),
-    preserveSymlinks: true,
-    preserveTimestamps: true
-  });
+  if (component === "skills") {
+    await installSkillsWithScopeFilter(srcPath, destPath, options);
+  } else {
+    await copyDirectory(srcPath, destPath, {
+      overwrite: !!(options.force || options.backup),
+      preserveSymlinks: true,
+      preserveTimestamps: true
+    });
+  }
   debug("install.component_installed", { component });
   return true;
 }
@@ -1296,7 +1520,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 +1541,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 +1550,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 +1564,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 +1591,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 +1840,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 +1920,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 +1962,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 +1972,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 +2000,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 +2061,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 +2101,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 +2141,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 +2165,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.33.0",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {