oh-my-customcode 1.1.100 → 1.1.101

package/dist/cli/index.js

@@ -49,7 +49,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/utils/home.ts
 import { realpathSync } from "node:fs";
 import { homedir, userInfo } from "node:os";
-import { isAbsolute, parse, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, parse, sep } from "node:path";
 function readEnvHome() {
   return process.env.HOME;
 }
@@ -99,11 +99,18 @@ function realpathOrSelf(p) {
   if (p === "" || !isAbsolute(p)) {
     return p;
   }
-  try {
-    return realpathSync(p);
-  } catch {
-    return p;
+  const tail = [];
+  let current = p;
+  let parent = dirname(current);
+  while (parent !== current) {
+    try {
+      return join(realpathSync(current), ...tail);
+    } catch {}
+    tail.unshift(basename(current));
+    current = parent;
+    parent = dirname(current);
   }
+  return p;
 }
 function isUnderHome(path, home) {
   const base = home ?? resolveHomeDir();
@@ -149,7 +156,7 @@ var init_home = () => {};
 import { realpathSync as realpathSync2 } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, join, resolve, sep as sep2 } from "node:path";
+import { basename as basename2, join as join2, resolve, sep as sep2 } from "node:path";
 function isTempPath(projectPath) {
   const normalized = resolve(projectPath);
   const candidates = new Set;
@@ -184,10 +191,10 @@ function registryDir(home) {
   if (resolved === "") {
     throw new Error("Could not determine the home directory for the project registry");
   }
-  return join(resolved, ".oh-my-customcode");
+  return join2(resolved, ".oh-my-customcode");
 }
 function registryPath() {
-  return join(registryDir(), "projects.json");
+  return join2(registryDir(), "projects.json");
 }
 function emptyRegistry() {
   return { projects: {} };
@@ -288,14 +295,14 @@ async function migrateFromLockfiles(searchDirs) {
     } catch {
       return;
     }
-    const entry = await parseLockFile(join(dir, ".omcustom.lock.json"));
+    const entry = await parseLockFile(join2(dir, ".omcustom.lock.json"));
     if (entry !== null) {
       discovered.set(resolve(dir), entry);
       return;
     }
     if (depth < MAX_DEPTH) {
       const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SCAN_SKIP_DIRS.has(e.name));
-      await Promise.all(subdirs.map((sub) => scan(join(dir, sub.name), depth + 1)));
+      await Promise.all(subdirs.map((sub) => scan(join2(dir, sub.name), depth + 1)));
     }
   }
   await Promise.all(searchDirs.map((dir) => scan(dir, 0).catch(() => {})));
@@ -328,7 +335,7 @@ var init_package = __esm(() => {
     workspaces: [
       "packages/*"
     ],
-    version: "1.1.100",
+    version: "1.1.101",
     description: "Batteries-included agent harness for Claude Code",
     type: "module",
     bin: {
@@ -7324,7 +7331,7 @@ var require_public_api = __commonJS(function(exports) {
 });
 
 // src/utils/fs.ts
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3, relative, resolve as resolve2, sep as sep3 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve2, sep as sep3 } from "node:path";
 import { fileURLToPath } from "node:url";
 function validatePreserveFilePath(filePath, projectRoot) {
   if (!filePath || filePath.trim() === "") {
@@ -7483,17 +7490,17 @@ async function readTextFile(path) {
 }
 async function writeTextFile(path, content) {
   const fs = await import("node:fs/promises");
-  await ensureDirectory(dirname2(path));
+  await ensureDirectory(dirname3(path));
   await fs.writeFile(path, content, "utf-8");
 }
 function getPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname2(currentFile);
+  const currentDir = dirname3(currentFile);
   return resolve2(currentDir, "..", "..");
 }
 function resolveTemplatePath(relativePath) {
   const packageRoot = getPackageRoot();
-  return join3(packageRoot, "templates", relativePath);
+  return join4(packageRoot, "templates", relativePath);
 }
 async function listFiles(dir, options = {}) {
   const fs = await import("node:fs/promises");
@@ -7515,7 +7522,7 @@ async function listFiles(dir, options = {}) {
 }
 async function copyFile(src, dest) {
   const fs = await import("node:fs/promises");
-  await ensureDirectory(dirname2(dest));
+  await ensureDirectory(dirname3(dest));
   await fs.copyFile(src, dest);
 }
 async function createTempDir(prefix = "omcustom-") {
@@ -7536,9 +7543,9 @@ var UTF8_BOM = "\uFEFF";
 var init_fs = () => {};
 
 // src/cli/projects.ts
-import { basename as basename4, join as join11, resolve as resolve3 } from "node:path";
+import { basename as basename5, join as join12, resolve as resolve3 } from "node:path";
 async function readLockFile(projectDir) {
-  const lockFilePath = join11(projectDir, ".omcustom.lock.json");
+  const lockFilePath = join12(projectDir, ".omcustom.lock.json");
   try {
     const fs = await import("node:fs/promises");
     const content = await fs.readFile(lockFilePath, "utf-8");
@@ -7608,7 +7615,7 @@ async function findProjects(options = {}) {
     if (!isUnderHome(projectPath, home))
       continue;
     results.push({
-      name: basename4(projectPath),
+      name: basename5(projectPath),
       path: projectPath,
       version: entry.version || null,
       installedAt: entry.installedAt || null,
@@ -7634,7 +7641,7 @@ async function _scanDirForLockfiles(dir, depth, seen, results, home, currentVers
     if (isUnderHome(dir, home)) {
       const version = lockFile.version || lockFile.templateVersion || null;
       results.push({
-        name: basename4(dir),
+        name: basename5(dir),
         path: dir,
         version,
         installedAt: lockFile.installedAt || null,
@@ -7647,7 +7654,7 @@ async function _scanDirForLockfiles(dir, depth, seen, results, home, currentVers
   }
   if (depth < 3) {
     const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SCAN_SKIP_DIRS2.has(e.name));
-    await Promise.all(subdirs.map((sub) => _scanDirForLockfiles(join11(dir, sub.name), depth + 1, seen, results, home, currentVersion, fs).catch(() => {})));
+    await Promise.all(subdirs.map((sub) => _scanDirForLockfiles(join12(dir, sub.name), depth + 1, seen, results, home, currentVersion, fs).catch(() => {})));
   }
 }
 async function _findProjectsFromLockfiles(options, currentVersion) {
@@ -7671,7 +7678,7 @@ async function _findProjectsFromLockfiles(options, currentVersion) {
 }
 async function writeLockFile(projectDir, version, existing) {
   const fs = await import("node:fs/promises");
-  const lockFilePath = join11(projectDir, ".omcustom.lock.json");
+  const lockFilePath = join12(projectDir, ".omcustom.lock.json");
   const now = new Date().toISOString();
   const merged = {
     ...existing || {},
@@ -7730,7 +7737,7 @@ oh-my-customcode 적용 프로젝트 (${projects.length}개):`);
 현재 설치 버전: v${currentVersion}`);
 }
 function buildMigrationSearchDirs(home, extraPaths = []) {
-  return [...home ? DEFAULT_SEARCH_DIRS.map((d) => join11(home, d)) : [], ...extraPaths];
+  return [...home ? DEFAULT_SEARCH_DIRS.map((d) => join12(home, d)) : [], ...extraPaths];
 }
 async function runMigration(options) {
   await Promise.resolve().then(() => init_registry());
@@ -11966,7 +11973,7 @@ init_package();
 import { execSync as execSync2, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // node_modules/.bun/i18next@26.0.2+ff0372d108591aba/node_modules/i18next/dist/esm/i18next.js
@@ -15264,7 +15271,7 @@ var i18n = {
 // src/core/self-update.ts
 var DEFAULT_PACKAGE_NAME = "oh-my-customcode";
 var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-var DEFAULT_CACHE_PATH = join2(homedir2(), ".oh-my-customcode", "self-update-cache.json");
+var DEFAULT_CACHE_PATH = join3(homedir2(), ".oh-my-customcode", "self-update-cache.json");
 var MS_EPOCH_THRESHOLD = 1000000000000;
 function normalizeVersion(version) {
   return version.trim().replace(/^v/i, "").split("-")[0] || "";
@@ -15361,7 +15368,7 @@ function readSelfUpdateCache(cachePath) {
   return null;
 }
 function writeCache(cachePath, latestVersion, now) {
-  const dir = dirname(cachePath);
+  const dir = dirname2(cachePath);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
@@ -16118,7 +16125,7 @@ function installCodex(deps = defaultDeps) {
 
 // src/core/config.ts
 init_fs();
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 var CONFIG_FILE = ".omcustomrc.json";
 var CURRENT_CONFIG_VERSION = 1;
 function getDefaultConfig() {
@@ -16158,7 +16165,7 @@ function getDefaultPreferences() {
   };
 }
 function getConfigPath(targetDir) {
-  return join4(targetDir, CONFIG_FILE);
+  return join5(targetDir, CONFIG_FILE);
 }
 async function loadConfig(targetDir) {
   const configPath = getConfigPath(targetDir);
@@ -16256,9 +16263,9 @@ function migrateConfig(config) {
 // src/core/doctor-framework.ts
 init_fs();
 import { readFile as readFile2 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function getInstalledVersion(targetDir) {
-  const rcPath = join5(targetDir, ".omcustomrc.json");
+  const rcPath = join6(targetDir, ".omcustomrc.json");
   if (!await fileExists(rcPath))
     return null;
   try {
@@ -16330,7 +16337,7 @@ init_fs();
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
-import { join as join6, relative as relative2 } from "node:path";
+import { join as join7, relative as relative2 } from "node:path";
 var LOCKFILE_NAME = ".omcustom.lock.json";
 var LOCKFILE_VERSION = 1;
 var LOCKFILE_COMPONENTS = [
@@ -16359,7 +16366,7 @@ function computeFileHash(filePath) {
   });
 }
 async function readLockfile(targetDir) {
-  const lockfilePath = join6(targetDir, LOCKFILE_NAME);
+  const lockfilePath = join7(targetDir, LOCKFILE_NAME);
   const exists = await fileExists(lockfilePath);
   if (!exists) {
     debug("lockfile.not_found", { path: lockfilePath });
@@ -16383,7 +16390,7 @@ async function readLockfile(targetDir) {
   }
 }
 async function writeLockfile(targetDir, lockfile) {
-  const lockfilePath = join6(targetDir, LOCKFILE_NAME);
+  const lockfilePath = join7(targetDir, LOCKFILE_NAME);
   await writeJsonFile(lockfilePath, lockfile);
   debug("lockfile.written", { path: lockfilePath });
 }
@@ -16408,7 +16415,7 @@ async function collectFiles(dir, projectRoot, isTopLevel) {
     if (isTopLevel && entry.startsWith(".") && entry !== ".claude") {
       continue;
     }
-    const fullPath = join6(dir, entry);
+    const fullPath = join7(dir, entry);
     let fileStat;
     try {
       fileStat = await stat(fullPath);
@@ -16426,7 +16433,7 @@ async function collectFiles(dir, projectRoot, isTopLevel) {
 }
 async function generateLockfile(targetDir, generatorVersion, templateVersion) {
   const files = {};
-  const componentRoots = COMPONENT_PATHS.map(([prefix]) => join6(targetDir, prefix));
+  const componentRoots = COMPONENT_PATHS.map(([prefix]) => join7(targetDir, prefix));
   for (const componentRoot of componentRoots) {
     const exists = await fileExists(componentRoot);
     if (!exists) {
@@ -16466,8 +16473,8 @@ async function generateLockfile(targetDir, generatorVersion, templateVersion) {
 async function generateAndWriteLockfileForDir(targetDir) {
   try {
     const packageRoot = getPackageRoot();
-    const manifest = await readJsonFile(join6(packageRoot, "templates", "manifest.json"));
-    const { version: generatorVersion } = await readJsonFile(join6(packageRoot, "package.json"));
+    const manifest = await readJsonFile(join7(packageRoot, "templates", "manifest.json"));
+    const { version: generatorVersion } = await readJsonFile(join7(packageRoot, "package.json"));
     const lockfile = await generateLockfile(targetDir, generatorVersion, manifest.version);
     await writeLockfile(targetDir, lockfile);
     return { fileCount: Object.keys(lockfile.files).length };
@@ -17217,7 +17224,7 @@ async function doctorCommand(options = {}) {
 
 // src/cli/init.ts
 init_package();
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 
 // src/core/installer.ts
 init_fs();
@@ -17228,11 +17235,11 @@ import {
   rename,
   stat as stat2
 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname4, join as join8 } from "node:path";
+import { basename as basename4, dirname as dirname5, join as join9 } from "node:path";
 
 // src/core/file-preservation.ts
 init_fs();
-import { basename as basename2, join as join7 } from "node:path";
+import { basename as basename3, join as join8 } from "node:path";
 
 // src/core/hook-group-merge.ts
 var LEGACY_OMCUSTOM_DESCRIPTIONS = [
@@ -17366,8 +17373,8 @@ function matchesGlobPattern(filePath, pattern) {
   return regex.test(filePath);
 }
 async function extractSingleFile(fileName, rootDir, tempDir, result) {
-  const srcPath = join7(rootDir, fileName);
-  const destPath = join7(tempDir, fileName);
+  const srcPath = join8(rootDir, fileName);
+  const destPath = join8(tempDir, fileName);
   try {
     if (await fileExists(srcPath)) {
       await copyFile(srcPath, destPath);
@@ -17381,8 +17388,8 @@ async function extractSingleFile(fileName, rootDir, tempDir, result) {
   }
 }
 async function extractSingleDir(dirName, rootDir, tempDir, result) {
-  const srcPath = join7(rootDir, dirName);
-  const destPath = join7(tempDir, dirName);
+  const srcPath = join8(rootDir, dirName);
+  const destPath = join8(tempDir, dirName);
   try {
     if (await fileExists(srcPath)) {
       await copyDirectory(srcPath, destPath, { overwrite: true, preserveTimestamps: true });
@@ -17419,8 +17426,8 @@ async function restoreCriticalFiles(rootDir, preservation) {
     failures: []
   };
   for (const fileName of preservation.extractedFiles) {
-    const preservedPath = join7(preservation.tempDir, fileName);
-    const targetPath = join7(rootDir, fileName);
+    const preservedPath = join8(preservation.tempDir, fileName);
+    const targetPath = join8(rootDir, fileName);
     try {
       if (fileName.endsWith(".json")) {
         await mergeJsonFile(preservedPath, targetPath);
@@ -17436,8 +17443,8 @@ async function restoreCriticalFiles(rootDir, preservation) {
     }
   }
   for (const dirName of preservation.extractedDirs) {
-    const preservedPath = join7(preservation.tempDir, dirName);
-    const targetPath = join7(rootDir, dirName);
+    const preservedPath = join8(preservation.tempDir, dirName);
+    const targetPath = join8(rootDir, dirName);
     try {
       await copyDirectory(preservedPath, targetPath, {
         overwrite: false,
@@ -17462,14 +17469,14 @@ async function mergeJsonFile(preservedPath, targetPath) {
   if (await fileExists(targetPath)) {
     const { data: targetData } = parseJsonText(await readTextFile(targetPath));
     const merged = deepMerge(targetData, preservedData);
-    if (HOOKS_MERGE_FILES.has(basename2(targetPath)) && isGeneratedHookBlock(targetData.hooks)) {
+    if (HOOKS_MERGE_FILES.has(basename3(targetPath)) && isGeneratedHookBlock(targetData.hooks)) {
       merged.hooks = mergeHookBlocks(preservedData.hooks, targetData.hooks);
     }
     await writeTextFile(targetPath, stringifyJson(merged, format));
-    debug("preserve.merged_json", { file: basename2(targetPath) });
+    debug("preserve.merged_json", { file: basename3(targetPath) });
   } else {
     await copyFile(preservedPath, targetPath);
-    debug("preserve.copied_json", { file: basename2(targetPath) });
+    debug("preserve.copied_json", { file: basename3(targetPath) });
   }
 }
 function deepMerge(target, source) {
@@ -17807,7 +17814,7 @@ function migrateHookCommands(settings) {
 
 // src/core/hooks-settings.ts
 init_fs();
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname4 } from "node:path";
 var IDENT_CHAR = /[A-Za-z0-9_.]/;
 var IDENT_START = /[A-Za-z_]/;
 function consumeSingleCharOp(input, i) {
@@ -18311,7 +18318,7 @@ async function mergeHooksIntoSettings(settingsPath, hooksJsonPath, options = {})
   }
   const settings = existing.ok ? existing.settings : {};
   settings.hooks = preserve ? mergeHookBlocks(settings.hooks, hooks) : hooks;
-  await ensureDirectory(dirname3(settingsPath));
+  await ensureDirectory(dirname4(settingsPath));
   await writeTextFile(settingsPath, stringifyJson(settings, { bom: existing.bom, trailingNewline: true }));
   return { warnings };
 }
@@ -18348,7 +18355,7 @@ function shouldInstallAgent(agentDomain, filterDomain) {
 var DEFAULT_LANGUAGE2 = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
-  return join8(packageRoot, "templates");
+  return join9(packageRoot, "templates");
 }
 function createInstallResult(targetDir) {
   return {
@@ -18370,7 +18377,7 @@ async function handleBackup(targetDir, shouldBackup, result) {
   if (!shouldBackup)
     return null;
   const layout = getProviderLayout();
-  const rootDir = join8(targetDir, layout.rootDir);
+  const rootDir = join9(targetDir, layout.rootDir);
   let preservation = null;
   if (await fileExists(rootDir)) {
     await Promise.resolve().then(() => init_fs());
@@ -18427,8 +18434,8 @@ async function installSingleComponent(targetDir, component, options, result) {
 }
 async function installStatusline(targetDir, options, _result) {
   const layout = getProviderLayout();
-  const srcPath = resolveTemplatePath(join8(layout.rootDir, "statusline.sh"));
-  const destPath = join8(targetDir, layout.rootDir, "statusline.sh");
+  const srcPath = resolveTemplatePath(join9(layout.rootDir, "statusline.sh"));
+  const destPath = join9(targetDir, layout.rootDir, "statusline.sh");
   if (!await fileExists(srcPath)) {
     debug("install.statusline_not_found", { path: srcPath });
     return;
@@ -18446,9 +18453,9 @@ async function installStatusline(targetDir, options, _result) {
 }
 async function installSchemas(targetDir, options, _result) {
   const layout = getProviderLayout();
-  const relPath = join8(layout.rootDir, "schemas", "tool-inputs.json");
+  const relPath = join9(layout.rootDir, "schemas", "tool-inputs.json");
   const srcPath = resolveTemplatePath(relPath);
-  const destPath = join8(targetDir, relPath);
+  const destPath = join9(targetDir, relPath);
   if (!await fileExists(srcPath)) {
     debug("install.schemas_not_found", { path: srcPath });
     return;
@@ -18459,13 +18466,13 @@ async function installSchemas(targetDir, options, _result) {
       return;
     }
   }
-  await ensureDirectory(dirname4(destPath));
+  await ensureDirectory(dirname5(destPath));
   await copyFile(srcPath, destPath);
   debug("install.schemas_installed", {});
 }
 async function installTestsConfig(targetDir, options, _result) {
-  const srcPath = resolveTemplatePath(join8("tests", "tsconfig.json"));
-  const destPath = join8(targetDir, "tests", "tsconfig.json");
+  const srcPath = resolveTemplatePath(join9("tests", "tsconfig.json"));
+  const destPath = join9(targetDir, "tests", "tsconfig.json");
   if (!await fileExists(srcPath)) {
     debug("install.tests_config_not_found", { path: srcPath });
     return;
@@ -18515,7 +18522,7 @@ async function mergeStatusLineIntoExisting(settingsPath, existing, format, defau
 }
 async function installSettingsLocal(targetDir, result) {
   const layout = getProviderLayout();
-  const settingsPath = join8(targetDir, layout.rootDir, "settings.local.json");
+  const settingsPath = join9(targetDir, layout.rootDir, "settings.local.json");
   const statusLineConfig = {
     statusLine: {
       type: "command",
@@ -18538,8 +18545,8 @@ async function installSettingsLocal(targetDir, result) {
 }
 async function installHooksSettings(targetDir, _options, result) {
   const layout = getProviderLayout();
-  const hooksJsonPath = join8(targetDir, getComponentPath("hooks"), "hooks.json");
-  const settingsPath = join8(targetDir, layout.rootDir, "settings.local.json");
+  const hooksJsonPath = join9(targetDir, getComponentPath("hooks"), "hooks.json");
+  const settingsPath = join9(targetDir, layout.rootDir, "settings.local.json");
   if (!await fileExists(hooksJsonPath)) {
     debug("install.hooks_settings_skipped", { reason: "hooks.json not installed" });
     return;
@@ -18561,7 +18568,7 @@ async function installHooksSettings(targetDir, _options, result) {
 var BOM = "\uFEFF";
 async function migrateRestoredHookCommands(targetDir, result) {
   const layout = getProviderLayout();
-  const settingsPath = join8(targetDir, layout.rootDir, "settings.local.json");
+  const settingsPath = join9(targetDir, layout.rootDir, "settings.local.json");
   if (!await fileExists(settingsPath)) {
     return;
   }
@@ -18647,7 +18654,7 @@ async function install(options) {
     await installEntryDocWithTracking(options.targetDir, options, result);
     if (preservation) {
       const layout = getProviderLayout();
-      const rootDir = join8(options.targetDir, layout.rootDir);
+      const rootDir = join9(options.targetDir, layout.rootDir);
       const restoration = await restoreCriticalFiles(rootDir, preservation);
       if (restoration.restoredFiles.length > 0 || restoration.restoredDirs.length > 0) {
         info("install.restored", {
@@ -18685,7 +18692,7 @@ async function install(options) {
 async function getTemplateManifest() {
   const packageRoot = getPackageRoot();
   const layout = getProviderLayout();
-  const manifestPath = join8(packageRoot, "templates", layout.manifestFile);
+  const manifestPath = join9(packageRoot, "templates", layout.manifestFile);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }
@@ -18708,10 +18715,10 @@ async function installSkillsWithScopeFilter(srcPath, destPath, options) {
   await ensureDirectory(destPath);
   const entries = await readdir2(srcPath);
   for (const entry of entries) {
-    const entrySrcPath = join8(srcPath, entry);
+    const entrySrcPath = join9(srcPath, entry);
     if (!(await stat2(entrySrcPath)).isDirectory())
       continue;
-    const skillMdPath = join8(entrySrcPath, "SKILL.md");
+    const skillMdPath = join9(entrySrcPath, "SKILL.md");
     if (await fileExists(skillMdPath)) {
       const content = await fsReadFile(skillMdPath, "utf-8");
       const scope = getSkillScope(content);
@@ -18720,7 +18727,7 @@ async function installSkillsWithScopeFilter(srcPath, destPath, options) {
         continue;
       }
     }
-    await copyDirectory(entrySrcPath, join8(destPath, entry), {
+    await copyDirectory(entrySrcPath, join9(destPath, entry), {
       overwrite: !!(options.force || options.backup),
       preserveSymlinks: true,
       preserveTimestamps: true
@@ -18731,10 +18738,10 @@ async function installAgentsWithDomainFilter(srcPath, destPath, options) {
   await ensureDirectory(destPath);
   const entries = await readdir2(srcPath);
   for (const entry of entries) {
-    const entrySrcPath = join8(srcPath, entry);
+    const entrySrcPath = join9(srcPath, entry);
     const entryStat = await stat2(entrySrcPath);
     if (entryStat.isDirectory()) {
-      await copyDirectory(entrySrcPath, join8(destPath, entry), {
+      await copyDirectory(entrySrcPath, join9(destPath, entry), {
         overwrite: !!(options.force || options.backup),
         preserveSymlinks: true,
         preserveTimestamps: true
@@ -18751,7 +18758,7 @@ async function installAgentsWithDomainFilter(srcPath, destPath, options) {
         continue;
       }
     }
-    await copyFile(entrySrcPath, join8(destPath, entry));
+    await copyFile(entrySrcPath, join9(destPath, entry));
   }
 }
 async function installComponent(targetDir, component, options) {
@@ -18759,7 +18766,7 @@ async function installComponent(targetDir, component, options) {
     return false;
   }
   const templatePath = getComponentPath(component);
-  const destPath = join8(targetDir, templatePath);
+  const destPath = join9(targetDir, templatePath);
   const destExists = await fileExists(destPath);
   if (destExists && !options.force && !options.backup) {
     debug("install.component_skipped", { component });
@@ -18793,7 +18800,7 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
   const layout = getProviderLayout();
   const templateFile = getEntryTemplateName(language);
   const srcPath = resolveTemplatePath(templateFile);
-  const destPath = join8(targetDir, layout.entryFile);
+  const destPath = join9(targetDir, layout.entryFile);
   if (!await fileExists(srcPath)) {
     warn("install.entry_md_not_found", { language, path: srcPath, entry: layout.entryFile });
     return false;
@@ -18813,8 +18820,8 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
   return true;
 }
 async function backupExisting(sourcePath, backupDir) {
-  const name = basename3(sourcePath);
-  const backupPath = join8(backupDir, name);
+  const name = basename4(sourcePath);
+  const backupPath = join9(backupDir, name);
   await rename(sourcePath, backupPath);
   return backupPath;
 }
@@ -18823,7 +18830,7 @@ async function checkExistingPaths(targetDir) {
   const pathsToCheck = [layout.entryFile, layout.rootDir, "guides"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
-    const fullPath = join8(targetDir, relativePath);
+    const fullPath = join9(targetDir, relativePath);
     if (await fileExists(fullPath)) {
       existingPaths.push(relativePath);
     }
@@ -18837,11 +18844,11 @@ async function backupExistingInstallation(targetDir) {
     return [];
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join8(targetDir, `${layout.backupDirPrefix}${timestamp}`);
+  const backupDir = join9(targetDir, `${layout.backupDirPrefix}${timestamp}`);
   await ensureDirectory(backupDir);
   const backedUpPaths = [];
   for (const relativePath of existingPaths) {
-    const fullPath = join8(targetDir, relativePath);
+    const fullPath = join9(targetDir, relativePath);
     try {
       const backupPath = await backupExisting(fullPath, backupDir);
       backedUpPaths.push(backupPath);
@@ -18857,12 +18864,12 @@ async function backupExistingInstallation(targetDir) {
 // src/core/mcp-config.ts
 init_fs();
 import { writeFile as writeFile2 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 async function generateMCPConfig(targetDir) {
   const layout = getProviderLayout();
-  const mcpConfigPath = join9(targetDir, ".mcp.json");
-  const ontologyDir = join9(layout.rootDir, "ontology");
-  const ontologyExists = await fileExists(join9(targetDir, ontologyDir));
+  const mcpConfigPath = join10(targetDir, ".mcp.json");
+  const ontologyDir = join10(layout.rootDir, "ontology");
+  const ontologyExists = await fileExists(join10(targetDir, ontologyDir));
   if (!ontologyExists) {
     return;
   }
@@ -18904,7 +18911,7 @@ async function generateMCPConfig(targetDir) {
 // src/core/ontology-rag-setup.ts
 init_fs();
 import { execSync as execSync5 } from "node:child_process";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 var MIN_PYTHON_MINOR = 10;
 var DETECTION_TIMEOUT_MS = 3000;
 var INSTALL_TIMEOUT_MS = 90000;
@@ -18955,7 +18962,7 @@ function createVenvWithPython3(targetDir) {
 }
 function installOntologyRagEditable(targetDir, useUv) {
   const packageRoot = getPackageRoot();
-  const ontologyPkgPath = join10(packageRoot, "packages", "ontology-rag");
+  const ontologyPkgPath = join11(packageRoot, "packages", "ontology-rag");
   if (useUv) {
     execSync5(`uv pip install --python .venv/bin/python -e "${ontologyPkgPath}"`, {
       cwd: targetDir,
@@ -19028,7 +19035,7 @@ async function setupOntologyRag(targetDir) {
       reason
     };
   }
-  const venvPython = join10(targetDir, ".venv", "bin", "python");
+  const venvPython = join11(targetDir, ".venv", "bin", "python");
   const venvReady = await fileExists(venvPython);
   if (!venvReady) {
     const reason = ".venv/bin/python missing after install — environment may be incomplete. " + "Run `uv pip install -e packages/ontology-rag` manually to complete setup.";
@@ -19054,12 +19061,12 @@ init_package();
 init_projects();
 import { existsSync as existsSync2 } from "node:fs";
 import { copyFile as copyFile2, cp } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 init_fs();
 init_registry();
 async function checkExistingInstallation(targetDir) {
   const layout = getProviderLayout();
-  const rootDir = join12(targetDir, layout.rootDir);
+  const rootDir = join13(targetDir, layout.rootDir);
   return fileExists(rootDir);
 }
 async function installFromSnapshot(targetDir, snapshotPath, options) {
@@ -19071,7 +19078,7 @@ async function installFromSnapshot(targetDir, snapshotPath, options) {
     };
   }
   const layout = getProviderLayout();
-  const snapshotClaude = join12(snapshotPath, layout.rootDir);
+  const snapshotClaude = join13(snapshotPath, layout.rootDir);
   if (!existsSync2(snapshotClaude)) {
     return {
       success: false,
@@ -19085,24 +19092,24 @@ async function installFromSnapshot(targetDir, snapshotPath, options) {
     if (exists && !options.force) {
       console.log(i18n.t("cli.init.exists", { rootDir: layout.rootDir }));
       console.log(i18n.t("cli.init.backing_up"));
-      const backupDir = join12(targetDir, `.claude-backup-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, -1)}`);
-      await cp(join12(targetDir, layout.rootDir), backupDir, { recursive: true });
+      const backupDir = join13(targetDir, `.claude-backup-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, -1)}`);
+      await cp(join13(targetDir, layout.rootDir), backupDir, { recursive: true });
       console.log(`  Backed up to: ${backupDir}`);
     }
-    await cp(snapshotClaude, join12(targetDir, layout.rootDir), {
+    await cp(snapshotClaude, join13(targetDir, layout.rootDir), {
       recursive: true,
       force: true
     });
-    const snapshotGuides = join12(snapshotPath, "guides");
+    const snapshotGuides = join13(snapshotPath, "guides");
     if (existsSync2(snapshotGuides)) {
-      await cp(snapshotGuides, join12(targetDir, "guides"), {
+      await cp(snapshotGuides, join13(targetDir, "guides"), {
         recursive: true,
         force: true
       });
     }
-    const snapshotEntry = join12(snapshotPath, layout.entryFile);
+    const snapshotEntry = join13(snapshotPath, layout.entryFile);
     if (existsSync2(snapshotEntry)) {
-      await copyFile2(snapshotEntry, join12(targetDir, layout.entryFile));
+      await copyFile2(snapshotEntry, join13(targetDir, layout.entryFile));
     }
     try {
       const existing = await readLockFile(targetDir);
@@ -19985,7 +19992,7 @@ async function runInitWizard(options) {
 // src/cli/init.ts
 async function checkExistingInstallation2(targetDir) {
   const layout = getProviderLayout();
-  const rootDir = join13(targetDir, layout.rootDir);
+  const rootDir = join14(targetDir, layout.rootDir);
   return fileExists(rootDir);
 }
 var PROVIDER_SUBDIR_COMPONENTS = new Set([
@@ -19999,13 +20006,13 @@ var PROVIDER_SUBDIR_COMPONENTS = new Set([
 function componentToPath(targetDir, component) {
   if (component === "entry-md") {
     const layout = getProviderLayout();
-    return join13(targetDir, layout.entryFile);
+    return join14(targetDir, layout.entryFile);
   }
   if (PROVIDER_SUBDIR_COMPONENTS.has(component)) {
     const layout = getProviderLayout();
-    return join13(targetDir, layout.rootDir, component);
+    return join14(targetDir, layout.rootDir, component);
   }
-  return join13(targetDir, component);
+  return join14(targetDir, component);
 }
 function buildInstalledPaths(targetDir, components) {
   return components.map((component) => componentToPath(targetDir, component));
@@ -20128,7 +20135,7 @@ async function initCommand(options) {
 }
 
 // src/cli/list.ts
-import { basename as basename5, dirname as dirname5, join as join14, relative as relative3 } from "node:path";
+import { basename as basename6, dirname as dirname6, join as join15, relative as relative3 } from "node:path";
 init_fs();
 var ALLOWED_TOP_LEVEL_KEYS = new Set(["name", "type", "description", "version", "category"]);
 function parseKeyValue(line) {
@@ -20175,7 +20182,7 @@ function parseYamlMetadata(content) {
   return result;
 }
 function extractAgentTypeFromFilename(filename) {
-  const name = basename5(filename, ".md");
+  const name = basename6(filename, ".md");
   const prefixMap = {
     lang: "language",
     be: "backend",
@@ -20193,17 +20200,17 @@ function extractAgentTypeFromFilename(filename) {
   return prefixMap[prefix] || "unknown";
 }
 function extractSkillCategoryFromPath(skillPath, baseDir, rootDir) {
-  const relativePath = relative3(join14(baseDir, rootDir, "skills"), skillPath);
+  const relativePath = relative3(join15(baseDir, rootDir, "skills"), skillPath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
 function extractGuideCategoryFromPath(guidePath, baseDir) {
-  const relativePath = relative3(join14(baseDir, "guides"), guidePath);
+  const relativePath = relative3(join15(baseDir, "guides"), guidePath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
 function extractRulePriorityFromFilename(filename) {
-  const name = basename5(filename, ".md");
+  const name = basename6(filename, ".md");
   const parts = name.split("-");
   return parts[0] || "unknown";
 }
@@ -20292,7 +20299,7 @@ async function tryExtractMarkdownDescription(mdPath, options = {}) {
   }
 }
 async function getAgents(targetDir, rootDir = ".claude", config) {
-  const agentsDir = join14(targetDir, rootDir, "agents");
+  const agentsDir = join15(targetDir, rootDir, "agents");
   if (!await fileExists(agentsDir))
     return [];
   try {
@@ -20301,8 +20308,8 @@ async function getAgents(targetDir, rootDir = ".claude", config) {
     const customAgentPaths = new Set(customComponents.filter((c) => c.type === "agent").map((c) => c.path));
     const agentMdFiles = await listFiles(agentsDir, { recursive: false, pattern: "*.md" });
     const agents = await Promise.all(agentMdFiles.map(async (agentMdPath) => {
-      const filename = basename5(agentMdPath);
-      const name = basename5(filename, ".md");
+      const filename = basename6(agentMdPath);
+      const name = basename6(filename, ".md");
       const description = await tryExtractMarkdownDescription(agentMdPath);
       const relativePath = relative3(targetDir, agentMdPath);
       return {
@@ -20320,7 +20327,7 @@ async function getAgents(targetDir, rootDir = ".claude", config) {
   }
 }
 async function getSkills(targetDir, rootDir = ".claude", config) {
-  const skillsDir = join14(targetDir, rootDir, "skills");
+  const skillsDir = join15(targetDir, rootDir, "skills");
   if (!await fileExists(skillsDir))
     return [];
   try {
@@ -20329,12 +20336,12 @@ async function getSkills(targetDir, rootDir = ".claude", config) {
     const customSkillPaths = new Set(customComponents.filter((c) => c.type === "skill").map((c) => c.path));
     const skillMdFiles = await listFiles(skillsDir, { recursive: true, pattern: "SKILL.md" });
     const skills = await Promise.all(skillMdFiles.map(async (skillMdPath) => {
-      const skillDir = dirname5(skillMdPath);
-      const indexYamlPath = join14(skillDir, "index.yaml");
+      const skillDir = dirname6(skillMdPath);
+      const indexYamlPath = join15(skillDir, "index.yaml");
       const { description, version } = await tryReadIndexYamlMetadata(indexYamlPath);
       const relativePath = relative3(targetDir, skillDir);
       return {
-        name: basename5(skillDir),
+        name: basename6(skillDir),
         type: "skill",
         category: extractSkillCategoryFromPath(skillDir, targetDir, rootDir),
         path: relativePath,
@@ -20349,7 +20356,7 @@ async function getSkills(targetDir, rootDir = ".claude", config) {
   }
 }
 async function getGuides(targetDir, config) {
-  const guidesDir = join14(targetDir, "guides");
+  const guidesDir = join15(targetDir, "guides");
   if (!await fileExists(guidesDir))
     return [];
   try {
@@ -20361,7 +20368,7 @@ async function getGuides(targetDir, config) {
       const description = await tryExtractMarkdownDescription(guideMdPath, { maxLength: 100 });
       const relativePath = relative3(targetDir, guideMdPath);
       return {
-        name: basename5(guideMdPath, ".md"),
+        name: basename6(guideMdPath, ".md"),
         type: "guide",
         category: extractGuideCategoryFromPath(guideMdPath, targetDir),
         path: relativePath,
@@ -20376,7 +20383,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 = join14(targetDir, rootDir, "rules");
+  const rulesDir = join15(targetDir, rootDir, "rules");
   if (!await fileExists(rulesDir))
     return [];
   try {
@@ -20385,13 +20392,13 @@ async function getRules(targetDir, rootDir = ".claude", config) {
     const customRulePaths = new Set(customComponents.filter((c) => c.type === "rule").map((c) => c.path));
     const ruleMdFiles = await listFiles(rulesDir, { recursive: false, pattern: "*.md" });
     const rules = await Promise.all(ruleMdFiles.map(async (ruleMdPath) => {
-      const filename = basename5(ruleMdPath);
+      const filename = basename6(ruleMdPath);
       const description = await tryExtractMarkdownDescription(ruleMdPath, {
         cleanFormatting: true
       });
       const relativePath = relative3(targetDir, ruleMdPath);
       return {
-        name: basename5(ruleMdPath, ".md"),
+        name: basename6(ruleMdPath, ".md"),
         type: extractRulePriorityFromFilename(filename),
         path: relativePath,
         description,
@@ -20448,7 +20455,7 @@ function formatAsJson(components) {
   console.log(JSON.stringify(components, null, 2));
 }
 async function getHooks(targetDir, rootDir = ".claude") {
-  const hooksDir = join14(targetDir, rootDir, "hooks");
+  const hooksDir = join15(targetDir, rootDir, "hooks");
   if (!await fileExists(hooksDir))
     return [];
   try {
@@ -20457,7 +20464,7 @@ async function getHooks(targetDir, rootDir = ".claude") {
     const hookYamls = await listFiles(hooksDir, { recursive: true, pattern: "*.yaml" });
     const allFiles = [...hookFiles, ...hookConfigs, ...hookYamls];
     return allFiles.map((hookPath) => ({
-      name: basename5(hookPath),
+      name: basename6(hookPath),
       type: "hook",
       path: relative3(targetDir, hookPath)
     })).sort((a, b) => a.name.localeCompare(b.name));
@@ -20466,7 +20473,7 @@ async function getHooks(targetDir, rootDir = ".claude") {
   }
 }
 async function getContexts(targetDir, rootDir = ".claude") {
-  const contextsDir = join14(targetDir, rootDir, "contexts");
+  const contextsDir = join15(targetDir, rootDir, "contexts");
   if (!await fileExists(contextsDir))
     return [];
   try {
@@ -20477,7 +20484,7 @@ async function getContexts(targetDir, rootDir = ".claude") {
       const ext = ctxPath.endsWith(".md") ? ".md" : ".yaml";
       const description = ext === ".md" ? await tryExtractMarkdownDescription(ctxPath, { maxLength: 100 }) : undefined;
       return {
-        name: basename5(ctxPath, ext),
+        name: basename6(ctxPath, ext),
         type: "context",
         path: relative3(targetDir, ctxPath),
         description
@@ -20859,22 +20866,22 @@ async function securityCommand(_options = {}) {
 
 // src/cli/serve-commands.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/cli/serve.ts
 import { spawn } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile3, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 var DEFAULT_PORT = 4321;
-var PID_FILE = join15(process.env.HOME ?? "~", ".omcustom-serve.pid");
+var PID_FILE = join16(process.env.HOME ?? "~", ".omcustom-serve.pid");
 function findServeBuildDir(projectRoot, options) {
-  const localBuild = join15(projectRoot, "packages", "serve", "build");
-  if (existsSync3(join15(localBuild, "index.js")))
+  const localBuild = join16(projectRoot, "packages", "serve", "build");
+  if (existsSync3(join16(localBuild, "index.js")))
     return localBuild;
   if (options?.skipNpmFallback !== true) {
-    const npmBuild = join15(import.meta.dirname, "..", "..", "packages", "serve", "build");
-    if (existsSync3(join15(npmBuild, "index.js")))
+    const npmBuild = join16(import.meta.dirname, "..", "..", "packages", "serve", "build");
+    if (existsSync3(join16(npmBuild, "index.js")))
       return npmBuild;
   }
   return null;
@@ -20902,7 +20909,7 @@ async function startServeBackground(projectRoot, port = DEFAULT_PORT, buildDirOp
   if (buildDir === null) {
     return;
   }
-  const child = spawn("node", [join15(buildDir, "index.js")], {
+  const child = spawn("node", [join16(buildDir, "index.js")], {
     env: {
       ...process.env,
       OMCUSTOM_PORT: String(port),
@@ -20979,7 +20986,7 @@ function runForeground(projectRoot, port, buildDirOpts) {
     process.exit(1);
   }
   console.log(`Web UI: http://localhost:${port}`);
-  spawnSync2("node", [join16(buildDir, "index.js")], {
+  spawnSync2("node", [join17(buildDir, "index.js")], {
     env: {
       ...process.env,
       OMCUSTOM_PORT: String(port),
@@ -20998,12 +21005,12 @@ import { resolve as resolve4 } from "node:path";
 init_fs();
 import { existsSync as existsSync4 } from "node:fs";
 import { cp as cp2, mkdir as mkdir2 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 async function loadVersions() {
   try {
     const packageRoot = getPackageRoot();
-    const manifest = await readJsonFile(join17(packageRoot, "templates", "manifest.json"));
-    const pkg = await readJsonFile(join17(packageRoot, "package.json"));
+    const manifest = await readJsonFile(join18(packageRoot, "templates", "manifest.json"));
+    const pkg = await readJsonFile(join18(packageRoot, "package.json"));
     return { generatorVersion: pkg.version, templateVersion: manifest.version };
   } catch {
     return { generatorVersion: "0.0.0", templateVersion: "0.0.0" };
@@ -21073,7 +21080,7 @@ async function countFiles(dir) {
       return 0;
     }
     for (const entry of entries) {
-      const full = join17(current, entry);
+      const full = join18(current, entry);
       try {
         const s = await stat(full);
         if (s.isDirectory()) {
@@ -21088,19 +21095,19 @@ async function countFiles(dir) {
   return walk(dir);
 }
 async function exportSnapshot(targetDir, outputPath) {
-  const claudeDir = join17(targetDir, ".claude");
-  const guidesDir = join17(targetDir, "guides");
+  const claudeDir = join18(targetDir, ".claude");
+  const guidesDir = join18(targetDir, "guides");
   if (!existsSync4(claudeDir)) {
     return { success: false, exportPath: outputPath, fileCount: 0 };
   }
   await mkdir2(outputPath, { recursive: true });
-  const destClaude = join17(outputPath, ".claude");
+  const destClaude = join18(outputPath, ".claude");
   await cp2(claudeDir, destClaude, {
     recursive: true,
     filter: isExportable
   });
   if (existsSync4(guidesDir)) {
-    await cp2(guidesDir, join17(outputPath, "guides"), { recursive: true });
+    await cp2(guidesDir, join18(outputPath, "guides"), { recursive: true });
   }
   const lockfile = await generateCurrentLockfile(targetDir);
   if (lockfile) {
@@ -21184,7 +21191,7 @@ import { constants as osConstants } from "node:os";
 
 // src/core/updater.ts
 init_package();
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 init_fs();
 
 // src/core/entry-merger.ts
@@ -21439,7 +21446,7 @@ function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
 }
 async function updateEntryDoc(targetDir, config, options) {
   const layout = getProviderLayout();
-  const entryPath = join18(targetDir, layout.entryFile);
+  const entryPath = join19(targetDir, layout.entryFile);
   const templateName = getEntryTemplateName2(config.language);
   const templatePath = resolveTemplatePath(templateName);
   if (!await fileExists(templatePath)) {
@@ -21477,7 +21484,7 @@ async function backfillStatusLineRefreshInterval(targetDir, options) {
     return;
   }
   const layout = getProviderLayout();
-  const settingsPath = join18(targetDir, layout.rootDir, "settings.local.json");
+  const settingsPath = join19(targetDir, layout.rootDir, "settings.local.json");
   if (!await fileExists(settingsPath)) {
     return;
   }
@@ -21503,7 +21510,7 @@ async function migrateHookCommandsInSettingsLocal(targetDir, options) {
     return;
   }
   const layout = getProviderLayout();
-  const settingsPath = join18(targetDir, layout.rootDir, "settings.local.json");
+  const settingsPath = join19(targetDir, layout.rootDir, "settings.local.json");
   if (!await fileExists(settingsPath)) {
     return;
   }
@@ -21598,7 +21605,7 @@ async function regenerateLockfile(targetDir, result) {
   }
 }
 async function shouldSkipSelfUpdate2(targetDir, result) {
-  const targetPkgPath = join18(targetDir, "package.json");
+  const targetPkgPath = join19(targetDir, "package.json");
   if (await fileExists(targetPkgPath)) {
     const targetPkg = await readJsonFile(targetPkgPath);
     if (targetPkg.name === "oh-my-customcode") {
@@ -21737,11 +21744,11 @@ async function collectProtectedSkipPaths(srcPath, destPath, componentPath, force
   const warnedPaths = [];
   const updatedPaths = [];
   for (const p of protectedRelative) {
-    const targetFilePath = join18(targetDir, componentPath, p);
+    const targetFilePath = join19(targetDir, componentPath, p);
     const lockfileKey = `${componentPath}/${p}`.replace(/\\/g, "/");
     const shouldSkip = await shouldSkipProtectedFile(targetFilePath, lockfileKey, lockfile);
     if (shouldSkip) {
-      skipPaths.push(path.relative(destPath, join18(destPath, p)));
+      skipPaths.push(path.relative(destPath, join19(destPath, p)));
       warnedPaths.push(p);
     } else {
       updatedPaths.push(p);
@@ -21787,7 +21794,7 @@ async function updateComponent(targetDir, component, customizations, options, co
   const preservedFiles = [];
   const componentPath = getComponentPath2(component);
   const srcPath = resolveTemplatePath(componentPath);
-  const destPath = join18(targetDir, componentPath);
+  const destPath = join19(targetDir, componentPath);
   const customComponents = config.customComponents || [];
   const skipPaths = [];
   if (customizations && !options.forceOverwriteAll) {
@@ -21829,7 +21836,7 @@ async function updateComponent(targetDir, component, customizations, options, co
   }
   skipPaths.push(...protectedSkipPaths);
   const path = await import("node:path");
-  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join18(targetDir, p)));
+  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join19(targetDir, p)));
   const uniqueSkipPaths = [...new Set(normalizedSkipPaths)];
   await copyDirectory(srcPath, destPath, {
     overwrite: true,
@@ -21858,7 +21865,7 @@ async function syncRootLevelFiles(targetDir, options, customizations) {
   const preserved = [];
   const preserveSet = new Set(customizations && !options.forceOverwriteAll ? customizations.preserveFiles : []);
   for (const fileName of ROOT_LEVEL_FILES) {
-    const srcPath = resolveTemplatePath(join18(layout.rootDir, fileName));
+    const srcPath = resolveTemplatePath(join19(layout.rootDir, fileName));
     if (!await fileExists(srcPath)) {
       continue;
     }
@@ -21867,8 +21874,8 @@ async function syncRootLevelFiles(targetDir, options, customizations) {
       preserved.push(relPath);
       continue;
     }
-    const destPath = join18(targetDir, layout.rootDir, fileName);
-    await ensureDirectory(join18(destPath, ".."));
+    const destPath = join19(targetDir, layout.rootDir, fileName);
+    await ensureDirectory(join19(destPath, ".."));
     await fs.copyFile(srcPath, destPath);
     if (fileName.endsWith(".sh")) {
       await fs.chmod(destPath, 493);
@@ -21903,7 +21910,7 @@ async function removeDeprecatedFiles(targetDir, options) {
       });
       continue;
     }
-    const fullPath = join18(targetDir, entry.path);
+    const fullPath = join19(targetDir, entry.path);
     if (await fileExists(fullPath)) {
       await fs.unlink(fullPath);
       removed.push(entry.path);
@@ -21944,7 +21951,7 @@ async function syncNamespaceInFile(targetFilePath, upstreamFilePath) {
 async function processNamespaceSyncEntry(entry, relPath, fullSrcPath, destPath, componentPath, lockfile) {
   if (!entry.isFile() || !entry.name.endsWith(".md"))
     return null;
-  const targetFilePath = join18(destPath, relPath);
+  const targetFilePath = join19(destPath, relPath);
   const lockfileKey = `${componentPath}/${relPath}`.replace(/\\/g, "/");
   const shouldSkip = await shouldSkipProtectedFile(targetFilePath, lockfileKey, lockfile);
   if (shouldSkip)
@@ -21959,7 +21966,7 @@ async function applyNamespaceSync(targetDir, component, lockfile) {
     return [];
   const componentPath = getComponentPath2(component);
   const srcPath = resolveTemplatePath(componentPath);
-  const destPath = join18(targetDir, componentPath);
+  const destPath = join19(targetDir, componentPath);
   const fs = await import("node:fs/promises");
   const synced = [];
   const queue = [{ dir: srcPath, relDir: "" }];
@@ -21973,7 +21980,7 @@ async function applyNamespaceSync(targetDir, component, lockfile) {
     }
     for (const entry of entries) {
       const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
-      const fullSrcPath = join18(dir, entry.name);
+      const fullSrcPath = join19(dir, entry.name);
       if (entry.isDirectory()) {
         queue.push({ dir: fullSrcPath, relDir: relPath });
         continue;
@@ -21996,26 +22003,26 @@ function getComponentPath2(component) {
 }
 async function backupInstallation(targetDir) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join18(targetDir, `.omcustom-backup-${timestamp}`);
+  const backupDir = join19(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 = join18(targetDir, dir);
+    const srcPath = join19(targetDir, dir);
     if (await fileExists(srcPath)) {
-      const destPath = join18(backupDir, dir);
+      const destPath = join19(backupDir, dir);
       await copyDirectory(srcPath, destPath, { overwrite: true });
     }
   }
-  const entryPath = join18(targetDir, layout.entryFile);
+  const entryPath = join19(targetDir, layout.entryFile);
   if (await fileExists(entryPath)) {
-    await fs.copyFile(entryPath, join18(backupDir, layout.entryFile));
+    await fs.copyFile(entryPath, join19(backupDir, layout.entryFile));
   }
   return backupDir;
 }
 async function loadCustomizationManifest(targetDir) {
-  const manifestPath = join18(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  const manifestPath = join19(targetDir, CUSTOMIZATION_MANIFEST_FILE);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }