oh-my-customcode 0.9.2 → 0.9.4

package/dist/cli/index.js

@@ -9033,6 +9033,214 @@ var {
   Help
 } = import__.default;
 
+// src/core/preflight.ts
+import { execSync } from "node:child_process";
+function isCI() {
+  const ciEnvVars = ["CI", "GITHUB_ACTIONS", "OMCUSTOM_SKIP_PREFLIGHT"];
+  return ciEnvVars.some((envVar) => process.env[envVar] === "true");
+}
+function hasHomebrew() {
+  try {
+    execSync("which brew", { encoding: "utf-8", stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getToolInfoFromBrew(toolName) {
+  const tool = {
+    name: toolName,
+    installed: false,
+    currentVersion: null,
+    latestVersion: null,
+    updateAvailable: false,
+    installMethod: "homebrew"
+  };
+  try {
+    const infoOutput = execSync(`brew info --json=v2 ${toolName}`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 3000
+    });
+    const info = JSON.parse(infoOutput);
+    if (info.casks && info.casks.length > 0) {
+      const cask = info.casks[0];
+      tool.latestVersion = cask.version;
+      tool.currentVersion = cask.installed || null;
+      tool.installed = cask.installed !== null;
+    }
+    if (!tool.installed && info.formulae && info.formulae.length > 0) {
+      const formula = info.formulae[0];
+      tool.latestVersion = formula.versions.stable;
+      if (formula.installed && formula.installed.length > 0) {
+        tool.currentVersion = formula.installed[0].version;
+        tool.installed = true;
+      }
+    }
+    if (tool.installed && tool.currentVersion && tool.latestVersion) {
+      tool.updateAvailable = tool.currentVersion !== tool.latestVersion;
+    }
+  } catch {}
+  return tool;
+}
+function getToolInfoFromNpm(toolName) {
+  const tool = {
+    name: toolName,
+    installed: false,
+    currentVersion: null,
+    latestVersion: null,
+    updateAvailable: false,
+    installMethod: "npm"
+  };
+  try {
+    const versionOutput = execSync(`npx ${toolName} --version`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 3000
+    });
+    const version = versionOutput.trim();
+    if (version) {
+      tool.installed = true;
+      tool.currentVersion = version;
+    }
+  } catch {}
+  return tool;
+}
+function getToolInfo(toolName) {
+  if (hasHomebrew()) {
+    const brewTool = getToolInfoFromBrew(toolName);
+    if (brewTool.installed) {
+      return brewTool;
+    }
+  }
+  const npmTool = getToolInfoFromNpm(toolName);
+  if (npmTool.installed) {
+    return npmTool;
+  }
+  return {
+    name: toolName,
+    installed: false,
+    currentVersion: null,
+    latestVersion: null,
+    updateAvailable: false,
+    installMethod: "unknown"
+  };
+}
+function checkOutdated(tools) {
+  if (!hasHomebrew())
+    return;
+  try {
+    const toolNames = tools.map((t) => t.name).join(" ");
+    const outdatedOutput = execSync(`brew outdated --json=v2 ${toolNames}`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 3000
+    });
+    const outdated = JSON.parse(outdatedOutput);
+    const outdatedCasks = outdated.casks || [];
+    const outdatedFormulae = outdated.formulae || [];
+    for (const tool of tools) {
+      const outdatedCask = outdatedCasks.find((c) => c.name === tool.name);
+      const outdatedFormula = outdatedFormulae.find((f) => f.name === tool.name);
+      if (outdatedCask) {
+        tool.latestVersion = outdatedCask.current_version;
+        tool.updateAvailable = true;
+      } else if (outdatedFormula) {
+        tool.latestVersion = outdatedFormula.current_version;
+        tool.updateAvailable = true;
+      }
+    }
+  } catch {}
+}
+async function runPreflightCheck(options = {}) {
+  const { skip = false, tools: toolNames = ["claude-code", "codex"], timeout = 5000 } = options;
+  if (skip) {
+    return {
+      tools: [],
+      hasUpdates: false,
+      warnings: [],
+      skipped: true,
+      skipReason: "Skipped by --skip-version-check flag"
+    };
+  }
+  if (isCI()) {
+    return {
+      tools: [],
+      hasUpdates: false,
+      warnings: [],
+      skipped: true,
+      skipReason: "CI environment detected"
+    };
+  }
+  if (!hasHomebrew()) {
+    return {
+      tools: [],
+      hasUpdates: false,
+      warnings: ["Homebrew not found, skipping version check"],
+      skipped: true,
+      skipReason: "Homebrew not available"
+    };
+  }
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(() => {
+      resolve({
+        tools: [],
+        hasUpdates: false,
+        warnings: ["Version check timed out"],
+        skipped: true,
+        skipReason: "Timeout"
+      });
+    }, timeout);
+    try {
+      const tools = [];
+      for (const toolName of toolNames) {
+        const tool = getToolInfo(toolName);
+        tools.push(tool);
+      }
+      checkOutdated(tools);
+      const hasUpdates = tools.some((t) => t.updateAvailable);
+      const warnings = [];
+      clearTimeout(timeoutId);
+      resolve({
+        tools,
+        hasUpdates,
+        warnings,
+        skipped: false
+      });
+    } catch (error) {
+      clearTimeout(timeoutId);
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      resolve({
+        tools: [],
+        hasUpdates: false,
+        warnings: [`Pre-flight check failed: ${errorMessage}`],
+        skipped: true,
+        skipReason: "Error during check"
+      });
+    }
+  });
+}
+function formatPreflightWarnings(result) {
+  if (!result.hasUpdates) {
+    return "";
+  }
+  const lines = [];
+  const updatesAvailable = result.tools.filter((t) => t.updateAvailable);
+  if (updatesAvailable.length === 1) {
+    const tool = updatesAvailable[0];
+    lines.push(`⚠ ${tool.name} ${tool.latestVersion} is available (current: ${tool.currentVersion})`);
+    lines.push(`  Run: brew upgrade ${tool.name}`);
+  } else if (updatesAvailable.length > 1) {
+    lines.push("Run the following to upgrade:");
+    for (const tool of updatesAvailable) {
+      lines.push(`  brew upgrade ${tool.name}  # ${tool.latestVersion} available (current: ${tool.currentVersion})`);
+    }
+  }
+  lines.push("  Use --skip-version-check to skip this check");
+  return lines.join(`
+`);
+}
+
 // node_modules/i18next/dist/esm/i18next.js
 var isString = (obj) => typeof obj === "string";
 var defer = () => {
@@ -11461,6 +11669,17 @@ var en_default = {
     error: {
       unexpected: "An unexpected error occurred:"
     },
+    preflight: {
+      checking: "Checking CLI tool versions...",
+      updateAvailable: "⚠ {{name}} {{latest}} is available (current: {{current}})",
+      upgradeCommand: "  Run: brew upgrade {{name}}",
+      multipleUpdates: "Run the following to upgrade:",
+      skipFlag: "  Use --skip-version-check to skip this check",
+      skippedCi: "Skipping version check (CI environment detected)",
+      skippedFlag: "Skipping version check (--skip-version-check)",
+      homebrewNotFound: "Homebrew not found, skipping version check",
+      timeout: "Version check timed out, continuing..."
+    },
     init: {
       description: "Initialize oh-my-customcode in the current directory",
       langOption: "Language for templates (en or ko)",
@@ -11503,7 +11722,25 @@ var en_default = {
       latestVersion: "Latest version: {{version}}",
       changelog: "Changelog",
       promptUpdate: "Do you want to update?",
-      skipped: "Update skipped"
+      skipped: "Update skipped",
+      dryRunOption: "Show what would be updated without making changes",
+      forceOption: "Force update even if already at latest version",
+      backupOption: "Create backup before updating",
+      agentsOption: "Update only agents",
+      skillsOption: "Update only skills",
+      rulesOption: "Update only rules",
+      guidesOption: "Update only guides",
+      hooksOption: "Update only hooks",
+      contextsOption: "Update only contexts",
+      providerOption: "Provider to update (auto, claude, codex)",
+      dryRunHeader: "Dry run - no changes will be made:",
+      componentUpdated: "✓ {{component}} updated",
+      componentSkipped: "- {{component}} skipped (no changes)",
+      componentFailed: "✗ {{component}} failed: {{error}}",
+      preservedFiles: "Preserved {{count}} user-customized files",
+      backupCreated: "Backup created at {{path}}",
+      summary: "Update complete: {{updated}} updated, {{skipped}} skipped",
+      summaryFailed: "Update failed: {{error}}"
     },
     list: {
       description: "List installed components",
@@ -11715,6 +11952,17 @@ var ko_default = {
     error: {
       unexpected: "예기치 않은 오류가 발생했습니다:"
     },
+    preflight: {
+      checking: "CLI 도구 버전 확인 중...",
+      updateAvailable: "⚠ {{name}} {{latest}} 사용 가능 (현재: {{current}})",
+      upgradeCommand: "  실행: brew upgrade {{name}}",
+      multipleUpdates: "다음을 실행하여 업그레이드하세요:",
+      skipFlag: "  --skip-version-check 옵션으로 이 검사를 건너뛸 수 있습니다",
+      skippedCi: "버전 확인 건너뜀 (CI 환경 감지)",
+      skippedFlag: "버전 확인 건너뜀 (--skip-version-check)",
+      homebrewNotFound: "Homebrew를 찾을 수 없어 버전 확인을 건너뜁니다",
+      timeout: "버전 확인 시간 초과, 계속 진행합니다..."
+    },
     init: {
       description: "현재 디렉토리에 oh-my-customcode 초기화",
       langOption: "템플릿 언어 (en 또는 ko)",
@@ -11757,7 +12005,25 @@ var ko_default = {
       latestVersion: "최신 버전: {{version}}",
       changelog: "변경 내역",
       promptUpdate: "업데이트하시겠습니까?",
-      skipped: "업데이트 건너뜀"
+      skipped: "업데이트 건너뜀",
+      dryRunOption: "변경 없이 업데이트할 내용 표시",
+      forceOption: "이미 최신 버전이어도 강제 업데이트",
+      backupOption: "업데이트 전 백업 생성",
+      agentsOption: "에이전트만 업데이트",
+      skillsOption: "스킬만 업데이트",
+      rulesOption: "규칙만 업데이트",
+      guidesOption: "가이드만 업데이트",
+      hooksOption: "훅만 업데이트",
+      contextsOption: "컨텍스트만 업데이트",
+      providerOption: "업데이트할 제공자 (auto, claude, codex)",
+      dryRunHeader: "드라이 런 - 변경사항 없음:",
+      componentUpdated: "✓ {{component}} 업데이트됨",
+      componentSkipped: "- {{component}} 건너뜀 (변경사항 없음)",
+      componentFailed: "✗ {{component}} 실패: {{error}}",
+      preservedFiles: "사용자 커스터마이징 파일 {{count}}개 보존됨",
+      backupCreated: "백업 생성됨: {{path}}",
+      summary: "업데이트 완료: {{updated}}개 업데이트, {{skipped}}개 건너뜀",
+      summaryFailed: "업데이트 실패: {{error}}"
     },
     list: {
       description: "설치된 컴포넌트 목록 표시",
@@ -12029,69 +12295,11 @@ var $stringify = publicApi.stringify;
 var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
-// src/core/layout.ts
-var PROVIDER_LAYOUTS = {
-  claude: {
-    provider: "claude",
-    rootDir: ".claude",
-    entryFile: "CLAUDE.md",
-    entryTemplatePrefix: "CLAUDE.md",
-    manifestFile: "manifest.json",
-    backupDirPrefix: ".claude-backup-",
-    directoryStructure: [
-      ".claude",
-      ".claude/rules",
-      ".claude/hooks",
-      ".claude/contexts",
-      ".claude/agents",
-      ".claude/skills",
-      "guides"
-    ]
-  },
-  codex: {
-    provider: "codex",
-    rootDir: ".codex",
-    entryFile: "AGENTS.md",
-    entryTemplatePrefix: "AGENTS.md",
-    manifestFile: "manifest.codex.json",
-    backupDirPrefix: ".codex-backup-",
-    directoryStructure: [
-      ".codex",
-      ".codex/rules",
-      ".codex/hooks",
-      ".codex/contexts",
-      ".codex/agents",
-      ".codex/skills",
-      "guides"
-    ]
-  }
-};
-function getProviderLayout(provider) {
-  return PROVIDER_LAYOUTS[provider];
-}
-function getEntryTemplateName(provider, language) {
-  const layout = getProviderLayout(provider);
-  return `${layout.entryTemplatePrefix}.${language}`;
-}
-function getComponentPath(provider, component) {
-  const layout = getProviderLayout(provider);
-  if (component === "entry-md") {
-    return layout.entryFile;
-  }
-  if (component === "guides") {
-    return "guides";
-  }
-  return `${layout.rootDir}/${component}`;
-}
-function getDefaultProvider() {
-  return "claude";
-}
-
-// src/core/provider.ts
+// src/core/config.ts
 import { join as join2 } from "node:path";
 
 // src/utils/fs.ts
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 async function fileExists(path) {
   const fs = await import("node:fs/promises");
@@ -12156,6 +12364,25 @@ async function handleFile(srcPath, destPath, options, fs) {
     await fs.utimes(destPath, stats.atime, stats.mtime);
   }
 }
+function shouldSkipPath(destPath, destRoot, skipPaths) {
+  if (!skipPaths || skipPaths.length === 0) {
+    return false;
+  }
+  const relativePath = relative(destRoot, destPath);
+  for (const skipPath of skipPaths) {
+    if (skipPath.endsWith("/")) {
+      const dirPath = skipPath.slice(0, -1);
+      if (relativePath === dirPath || relativePath.startsWith(dirPath + sep)) {
+        return true;
+      }
+    } else {
+      if (relativePath === skipPath) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 async function copyDirectory(src, dest, options = {}) {
   const fs = await import("node:fs/promises");
   const path = await import("node:path");
@@ -12167,6 +12394,9 @@ async function copyDirectory(src, dest, options = {}) {
     }
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
+    if (shouldSkipPath(destPath, dest, options.skipPaths)) {
+      continue;
+    }
     if (entry.isSymbolicLink()) {
       await handleSymlink(srcPath, destPath, options, fs);
     } else if (entry.isDirectory()) {
@@ -12190,6 +12420,11 @@ async function readTextFile(path) {
   const fs = await import("node:fs/promises");
   return fs.readFile(path, "utf-8");
 }
+async function writeTextFile(path, content) {
+  const fs = await import("node:fs/promises");
+  await ensureDirectory(dirname(path));
+  await fs.writeFile(path, content, "utf-8");
+}
 function getPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentFile);
@@ -12223,124 +12458,479 @@ function matchesPattern(filename, pattern) {
   return regex.test(filename);
 }
 
-// src/core/provider.ts
-var ENV_SIGNALS = {
-  claude: [
-    "ANTHROPIC_API_KEY",
-    "CLAUDE_CODE",
-    "CLAUDE_CODE_EFFORT_LEVEL",
-    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
-    "CLAUDE_CODE_ENABLE_TELEMETRY"
-  ],
-  codex: ["OPENAI_API_KEY", "OPENAI_ORG_ID", "OPENAI_PROJECT", "CODEX_HOME", "CODEX_PROJECT"]
+// src/utils/logger.ts
+var currentOptions = {
+  level: "info",
+  colors: true,
+  locale: "en",
+  timestamps: false
 };
-var PROVIDER_ENV_OVERRIDES = ["OMCUSTOM_PROVIDER", "LLM_SERVICE"];
-function normalizeProvider(value) {
-  if (!value)
-    return null;
-  const normalized = value.toLowerCase().trim();
-  if (normalized === "claude" || normalized === "codex" || normalized === "auto") {
-    return normalized;
-  }
-  return null;
-}
-function detectFromEnv(env) {
-  for (const key of PROVIDER_ENV_OVERRIDES) {
-    const override = normalizeProvider(env[key]);
-    if (override && override !== "auto") {
-      return {
-        provider: override,
-        source: "override",
-        confidence: "high",
-        reason: `env:${key}`
-      };
-    }
-  }
-  const claudeSignals = ENV_SIGNALS.claude.filter((key) => Boolean(env[key]));
-  const codexSignals = ENV_SIGNALS.codex.filter((key) => Boolean(env[key]));
-  const hasClaude = claudeSignals.length > 0;
-  const hasCodex = codexSignals.length > 0;
-  if (hasClaude && !hasCodex) {
-    return {
-      provider: "claude",
-      source: "env",
-      confidence: "medium",
-      reason: `env:${claudeSignals[0]}`
-    };
-  }
-  if (hasCodex && !hasClaude) {
-    return {
-      provider: "codex",
-      source: "env",
-      confidence: "medium",
-      reason: `env:${codexSignals[0]}`
-    };
-  }
-  return null;
-}
-async function detectFromProject(targetDir) {
-  const claudeMarkers = [join2(targetDir, "CLAUDE.md"), join2(targetDir, ".claude")];
-  const codexMarkers = [join2(targetDir, "AGENTS.md"), join2(targetDir, ".codex")];
-  const claudeFound = await Promise.all(claudeMarkers.map((path) => fileExists(path)));
-  const codexFound = await Promise.all(codexMarkers.map((path) => fileExists(path)));
-  const hasClaude = claudeFound.some(Boolean);
-  const hasCodex = codexFound.some(Boolean);
-  if (hasClaude && !hasCodex) {
-    return {
-      provider: "claude",
-      source: "project",
-      confidence: "medium",
-      reason: "project:claude"
-    };
-  }
-  if (hasCodex && !hasClaude) {
-    return {
-      provider: "codex",
-      source: "project",
-      confidence: "medium",
-      reason: "project:codex"
-    };
-  }
-  return null;
-}
-async function detectFromConfig(targetDir) {
-  const configPath = join2(targetDir, ".omcustomrc.json");
-  if (!await fileExists(configPath)) {
-    return null;
-  }
-  try {
-    const config = await readJsonFile(configPath);
-    const provider = normalizeProvider(config.provider);
-    if (provider && provider !== "auto") {
-      return {
-        provider,
-        source: "config",
-        confidence: "high",
-        reason: "config:provider"
-      };
-    }
-  } catch {}
-  return null;
-}
-async function detectProvider(options = {}) {
-  const env = options.env ?? process.env;
-  const override = options.override;
-  const normalizedOverride = normalizeProvider(override);
-  if (normalizedOverride && normalizedOverride !== "auto") {
-    return {
-      provider: normalizedOverride,
-      source: "override",
-      confidence: "high",
-      reason: "override:option"
-    };
-  }
-  if (options.targetDir) {
-    const fromConfig = await detectFromConfig(options.targetDir);
-    if (fromConfig) {
-      return fromConfig;
-    }
-  }
-  if (options.targetDir && options.preferProject) {
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m"
+};
+var LEVEL_COLORS = {
+  debug: COLORS.dim,
+  info: COLORS.blue,
+  warn: COLORS.yellow,
+  error: COLORS.red
+};
+var LEVEL_ICONS = {
+  debug: "\uD83D\uDD0D",
+  info: "ℹ️",
+  warn: "⚠️",
+  error: "❌"
+};
+var MESSAGES = {
+  en: {
+    "install.start": "Initializing oh-my-customcode...",
+    "install.success": "Successfully initialized!",
+    "install.failed": "Installation failed: {{error}}",
+    "install.exists": "Existing {{rootDir}} directory found",
+    "install.backup": "Backed up existing files to: {{path}}",
+    "install.directories_created": "Directory structure created",
+    "install.component_skipped": "Skipped {{component}} (already exists)",
+    "install.component_installed": "Installed {{component}}",
+    "install.template_not_found": "Template not found for {{component}}: {{path}}",
+    "install.claude_md_installed": "CLAUDE.md installed ({{language}})",
+    "install.claude_md_not_found": "CLAUDE.md template not found for {{language}}",
+    "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}})",
+    "update.start": "Checking for updates...",
+    "update.success": "Updated from {{from}} to {{to}}",
+    "update.failed": "Update failed: {{error}}",
+    "update.no_updates": "Already up to date",
+    "update.backup_created": "Backup created at: {{path}}",
+    "update.dry_run": "Would update {{component}}",
+    "update.component_updated": "Updated {{component}}",
+    "update.file_applied": "Applied update to {{path}}",
+    "config.load_failed": "Failed to load config: {{error}}",
+    "config.not_found": "Config not found at {{path}}, using defaults",
+    "config.saved": "Config saved to {{path}}",
+    "config.deleted": "Config deleted from {{path}}",
+    "general.done": "Done!",
+    "general.failed": "Failed",
+    "general.skipped": "Skipped"
+  },
+  ko: {
+    "install.start": "oh-my-customcode 초기화 중...",
+    "install.success": "초기화 완료!",
+    "install.failed": "설치 실패: {{error}}",
+    "install.exists": "기존 {{rootDir}} 디렉토리 발견",
+    "install.backup": "기존 파일 백업 완료: {{path}}",
+    "install.directories_created": "디렉토리 구조 생성 완료",
+    "install.component_skipped": "{{component}} 건너뜀 (이미 존재)",
+    "install.component_installed": "{{component}} 설치 완료",
+    "install.template_not_found": "{{component}} 템플릿 없음: {{path}}",
+    "install.claude_md_installed": "CLAUDE.md 설치 완료 ({{language}})",
+    "install.claude_md_not_found": "{{language}}용 CLAUDE.md 템플릿 없음",
+    "install.entry_md_installed": "{{entry}} 설치 완료 ({{language}})",
+    "install.entry_md_not_found": "{{language}}용 {{entry}} 템플릿 없음",
+    "install.entry_md_skipped": "{{entry}} 건너뜀 ({{reason}})",
+    "update.start": "업데이트 확인 중...",
+    "update.success": "{{from}}에서 {{to}}로 업데이트 완료",
+    "update.failed": "업데이트 실패: {{error}}",
+    "update.no_updates": "이미 최신 버전입니다",
+    "update.backup_created": "백업 생성됨: {{path}}",
+    "update.dry_run": "{{component}} 업데이트 예정",
+    "update.component_updated": "{{component}} 업데이트 완료",
+    "update.file_applied": "{{path}} 업데이트 적용",
+    "config.load_failed": "설정 로드 실패: {{error}}",
+    "config.not_found": "{{path}}에 설정 없음, 기본값 사용",
+    "config.saved": "설정 저장: {{path}}",
+    "config.deleted": "설정 삭제: {{path}}",
+    "general.done": "완료!",
+    "general.failed": "실패",
+    "general.skipped": "건너뜀"
+  }
+};
+function getMessage(key, params) {
+  const messages = MESSAGES[currentOptions.locale] || MESSAGES.en;
+  let message = messages[key] || key;
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      message = message.replace(new RegExp(`{{${k}}}`, "g"), v);
+    }
+  }
+  return message;
+}
+function formatMessage(level, message) {
+  const parts = [];
+  if (currentOptions.timestamps) {
+    const timestamp = new Date().toISOString().slice(11, 19);
+    if (currentOptions.colors) {
+      parts.push(`${COLORS.dim}[${timestamp}]${COLORS.reset}`);
+    } else {
+      parts.push(`[${timestamp}]`);
+    }
+  }
+  if (currentOptions.prefix) {
+    if (currentOptions.colors) {
+      parts.push(`${COLORS.cyan}[${currentOptions.prefix}]${COLORS.reset}`);
+    } else {
+      parts.push(`[${currentOptions.prefix}]`);
+    }
+  }
+  if (currentOptions.colors) {
+    const color = LEVEL_COLORS[level];
+    const icon = LEVEL_ICONS[level];
+    parts.push(`${color}${icon}${COLORS.reset}`);
+  } else {
+    parts.push(`[${level.toUpperCase()}]`);
+  }
+  if (currentOptions.colors && level === "error") {
+    parts.push(`${COLORS.red}${message}${COLORS.reset}`);
+  } else if (currentOptions.colors && level === "warn") {
+    parts.push(`${COLORS.yellow}${message}${COLORS.reset}`);
+  } else {
+    parts.push(message);
+  }
+  return parts.join(" ");
+}
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[currentOptions.level];
+}
+function debug(messageKey, params) {
+  if (shouldLog("debug")) {
+    const message = getMessage(messageKey, params);
+    console.debug(formatMessage("debug", message));
+  }
+}
+function info(messageKey, params) {
+  if (shouldLog("info")) {
+    const message = getMessage(messageKey, params);
+    console.info(formatMessage("info", message));
+  }
+}
+function warn(messageKey, params) {
+  if (shouldLog("warn")) {
+    const message = getMessage(messageKey, params);
+    console.warn(formatMessage("warn", message));
+  }
+}
+function error(messageKey, params) {
+  if (shouldLog("error")) {
+    const message = getMessage(messageKey, params);
+    console.error(formatMessage("error", message));
+  }
+}
+function success(messageKey, params) {
+  if (shouldLog("info")) {
+    const message = getMessage(messageKey, params);
+    if (currentOptions.colors) {
+      console.info(`${COLORS.green}✓${COLORS.reset} ${message}`);
+    } else {
+      console.info(`[SUCCESS] ${message}`);
+    }
+  }
+}
+
+// src/core/config.ts
+var CONFIG_FILE = ".omcustomrc.json";
+var CURRENT_CONFIG_VERSION = 1;
+function getDefaultConfig() {
+  return {
+    configVersion: CURRENT_CONFIG_VERSION,
+    version: "0.0.0",
+    language: "en",
+    provider: "auto",
+    installedAt: "",
+    lastUpdated: "",
+    installedComponents: [],
+    componentVersions: {},
+    agents: {},
+    preferences: getDefaultPreferences(),
+    sourceRepo: "https://github.com/baekenough/oh-my-customcode",
+    autoUpdate: {
+      enabled: false,
+      checkIntervalHours: 24,
+      autoApplyMinor: false
+    },
+    preserveFiles: [],
+    customComponents: []
+  };
+}
+function getDefaultPreferences() {
+  return {
+    logLevel: "info",
+    colors: true,
+    showProgress: true,
+    confirmPrompts: true,
+    autoBackup: true
+  };
+}
+function getConfigPath(targetDir) {
+  return join2(targetDir, CONFIG_FILE);
+}
+async function loadConfig(targetDir) {
+  const configPath = getConfigPath(targetDir);
+  if (await fileExists(configPath)) {
+    try {
+      const config = await readJsonFile(configPath);
+      const merged = mergeConfig(getDefaultConfig(), config);
+      if (merged.configVersion < CURRENT_CONFIG_VERSION) {
+        const migrated = migrateConfig(merged);
+        await saveConfig(targetDir, migrated);
+        return migrated;
+      }
+      return merged;
+    } catch (err) {
+      warn("config.load_failed", { error: String(err) });
+      return getDefaultConfig();
+    }
+  }
+  debug("config.not_found", { path: configPath });
+  return getDefaultConfig();
+}
+async function saveConfig(targetDir, config) {
+  const configPath = getConfigPath(targetDir);
+  await ensureDirectory(targetDir);
+  config.lastUpdated = new Date().toISOString();
+  await writeJsonFile(configPath, config);
+  debug("config.saved", { path: configPath });
+}
+function deduplicateCustomComponents(components) {
+  const seen = new Map;
+  for (const c of components) {
+    seen.set(c.path, c);
+  }
+  return [...seen.values()];
+}
+function mergeConfig(defaults, overrides) {
+  return {
+    ...defaults,
+    ...overrides,
+    preferences: overrides.preferences ? { ...defaults.preferences, ...overrides.preferences } : defaults.preferences,
+    autoUpdate: overrides.autoUpdate ? { ...defaults.autoUpdate, ...overrides.autoUpdate } : defaults.autoUpdate,
+    componentVersions: {
+      ...defaults.componentVersions,
+      ...overrides.componentVersions
+    },
+    agents: {
+      ...defaults.agents,
+      ...overrides.agents
+    },
+    preserveFiles: overrides.preserveFiles ? [...new Set([...defaults.preserveFiles || [], ...overrides.preserveFiles])] : defaults.preserveFiles,
+    customComponents: overrides.customComponents ? deduplicateCustomComponents([
+      ...defaults.customComponents || [],
+      ...overrides.customComponents
+    ]) : defaults.customComponents
+  };
+}
+function migrateConfig(config) {
+  const migrated = { ...config };
+  if (config.configVersion < 1) {
+    migrated.configVersion = 1;
+    migrated.preferences = getDefaultPreferences();
+    migrated.autoUpdate = {
+      enabled: false,
+      checkIntervalHours: 24,
+      autoApplyMinor: false
+    };
+  }
+  migrated.configVersion = CURRENT_CONFIG_VERSION;
+  return migrated;
+}
+
+// src/core/layout.ts
+var PROVIDER_LAYOUTS = {
+  claude: {
+    provider: "claude",
+    rootDir: ".claude",
+    entryFile: "CLAUDE.md",
+    entryTemplatePrefix: "CLAUDE.md",
+    manifestFile: "manifest.json",
+    backupDirPrefix: ".claude-backup-",
+    directoryStructure: [
+      ".claude",
+      ".claude/rules",
+      ".claude/hooks",
+      ".claude/contexts",
+      ".claude/agents",
+      ".claude/skills",
+      "guides"
+    ]
+  },
+  codex: {
+    provider: "codex",
+    rootDir: ".codex",
+    entryFile: "AGENTS.md",
+    entryTemplatePrefix: "AGENTS.md",
+    manifestFile: "manifest.codex.json",
+    backupDirPrefix: ".codex-backup-",
+    directoryStructure: [
+      ".codex",
+      ".codex/rules",
+      ".codex/hooks",
+      ".codex/contexts",
+      ".codex/agents",
+      ".codex/skills",
+      "guides"
+    ]
+  }
+};
+function getProviderLayout(provider) {
+  return PROVIDER_LAYOUTS[provider];
+}
+function getEntryTemplateName(provider, language) {
+  const layout = getProviderLayout(provider);
+  return `${layout.entryTemplatePrefix}.${language}`;
+}
+function getComponentPath(provider, component) {
+  const layout = getProviderLayout(provider);
+  if (component === "entry-md") {
+    return layout.entryFile;
+  }
+  if (component === "guides") {
+    return "guides";
+  }
+  return `${layout.rootDir}/${component}`;
+}
+function getDefaultProvider() {
+  return "claude";
+}
+
+// src/core/provider.ts
+import { join as join3 } from "node:path";
+var ENV_SIGNALS = {
+  claude: [
+    "ANTHROPIC_API_KEY",
+    "CLAUDE_CODE",
+    "CLAUDE_CODE_EFFORT_LEVEL",
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
+    "CLAUDE_CODE_ENABLE_TELEMETRY"
+  ],
+  codex: ["OPENAI_API_KEY", "OPENAI_ORG_ID", "OPENAI_PROJECT", "CODEX_HOME", "CODEX_PROJECT"]
+};
+var PROVIDER_ENV_OVERRIDES = ["OMCUSTOM_PROVIDER", "LLM_SERVICE"];
+function normalizeProvider(value) {
+  if (!value)
+    return null;
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "claude" || normalized === "codex" || normalized === "auto") {
+    return normalized;
+  }
+  return null;
+}
+function detectFromEnv(env) {
+  for (const key of PROVIDER_ENV_OVERRIDES) {
+    const override = normalizeProvider(env[key]);
+    if (override && override !== "auto") {
+      return {
+        provider: override,
+        source: "override",
+        confidence: "high",
+        reason: `env:${key}`
+      };
+    }
+  }
+  const claudeSignals = ENV_SIGNALS.claude.filter((key) => Boolean(env[key]));
+  const codexSignals = ENV_SIGNALS.codex.filter((key) => Boolean(env[key]));
+  const hasClaude = claudeSignals.length > 0;
+  const hasCodex = codexSignals.length > 0;
+  if (hasClaude && !hasCodex) {
+    return {
+      provider: "claude",
+      source: "env",
+      confidence: "medium",
+      reason: `env:${claudeSignals[0]}`
+    };
+  }
+  if (hasCodex && !hasClaude) {
+    return {
+      provider: "codex",
+      source: "env",
+      confidence: "medium",
+      reason: `env:${codexSignals[0]}`
+    };
+  }
+  return null;
+}
+async function detectFromProject(targetDir) {
+  const claudeMarkers = [join3(targetDir, "CLAUDE.md"), join3(targetDir, ".claude")];
+  const codexMarkers = [join3(targetDir, "AGENTS.md"), join3(targetDir, ".codex")];
+  const claudeFound = await Promise.all(claudeMarkers.map((path) => fileExists(path)));
+  const codexFound = await Promise.all(codexMarkers.map((path) => fileExists(path)));
+  const hasClaude = claudeFound.some(Boolean);
+  const hasCodex = codexFound.some(Boolean);
+  if (hasClaude && !hasCodex) {
+    return {
+      provider: "claude",
+      source: "project",
+      confidence: "medium",
+      reason: "project:claude"
+    };
+  }
+  if (hasCodex && !hasClaude) {
+    return {
+      provider: "codex",
+      source: "project",
+      confidence: "medium",
+      reason: "project:codex"
+    };
+  }
+  return null;
+}
+async function detectFromConfig(targetDir) {
+  const configPath = join3(targetDir, ".omcustomrc.json");
+  if (!await fileExists(configPath)) {
+    return null;
+  }
+  try {
+    const config = await readJsonFile(configPath);
+    const provider = normalizeProvider(config.provider);
+    if (provider && provider !== "auto") {
+      return {
+        provider,
+        source: "config",
+        confidence: "high",
+        reason: "config:provider"
+      };
+    }
+  } catch {}
+  return null;
+}
+async function detectProvider(options = {}) {
+  const env = options.env ?? process.env;
+  const override = options.override;
+  const normalizedOverride = normalizeProvider(override);
+  if (normalizedOverride && normalizedOverride !== "auto") {
+    return {
+      provider: normalizedOverride,
+      source: "override",
+      confidence: "high",
+      reason: "override:option"
+    };
+  }
+  if (options.targetDir) {
+    const fromConfig = await detectFromConfig(options.targetDir);
+    if (fromConfig) {
+      return fromConfig;
+    }
+  }
+  if (options.targetDir && options.preferProject) {
     const fromProject = await detectFromProject(options.targetDir);
     if (fromProject) {
       return fromProject;
@@ -12690,6 +13280,49 @@ async function checkContexts(targetDir, rootDir = ".claude") {
     fixable: false
   };
 }
+async function checkCustomComponents(targetDir, _rootDir = ".claude") {
+  try {
+    const config = await loadConfig(targetDir);
+    const customComponents = config.customComponents || [];
+    if (customComponents.length === 0) {
+      return {
+        name: "Custom components",
+        status: "pass",
+        message: "No custom components configured",
+        fixable: false
+      };
+    }
+    const missing = [];
+    for (const component of customComponents) {
+      const fullPath = path.join(targetDir, component.path);
+      if (!await pathExists(fullPath)) {
+        missing.push(component.path);
+      }
+    }
+    if (missing.length > 0) {
+      return {
+        name: "Custom components",
+        status: "warn",
+        message: `Custom components: ${customComponents.length} items (${missing.length} missing)`,
+        fixable: false,
+        details: missing
+      };
+    }
+    return {
+      name: "Custom components",
+      status: "pass",
+      message: `Custom components: ${customComponents.length} items (managed: false)`,
+      fixable: false
+    };
+  } catch {
+    return {
+      name: "Custom components",
+      status: "pass",
+      message: "No config file found",
+      fixable: false
+    };
+  }
+}
 async function fixBrokenSymlinks(_targetDir, brokenSymlinks) {
   let fixed = 0;
   for (const symlink of brokenSymlinks) {
@@ -12777,7 +13410,8 @@ async function doctorCommand(options = {}) {
     checkIndexFiles(targetDir),
     checkGuides(targetDir),
     checkHooks(targetDir, layout.rootDir),
-    checkContexts(targetDir, layout.rootDir)
+    checkContexts(targetDir, layout.rootDir),
+    checkCustomComponents(targetDir, layout.rootDir)
   ]);
   if (options.fix) {
     const hasFixableIssues = checks.some((c) => c.status === "fail" && c.fixable);
@@ -12790,332 +13424,47 @@ async function doctorCommand(options = {}) {
   }
   for (const check of checks) {
     if (!options.quiet || check.status !== "pass") {
-      printCheck(check);
-    }
-  }
-  const passCount = checks.filter((c) => c.status === "pass" || c.fixed).length;
-  const warnCount = checks.filter((c) => c.status === "warn").length;
-  const failCount = checks.filter((c) => c.status === "fail" && !c.fixed).length;
-  const fixedCount = checks.filter((c) => c.fixed).length;
-  console.log("");
-  if (failCount === 0) {
-    console.log(i18n.t("cli.doctor.passed"));
-  } else {
-    console.log(i18n.t("cli.doctor.failed"));
-    if (!options.fix) {
-      const fixableCount = checks.filter((c) => c.status === "fail" && c.fixable).length;
-      if (fixableCount > 0) {
-        console.log(i18n.t("cli.doctor.runWithFix", { count: fixableCount }));
-      }
-    }
-  }
-  console.log(i18n.t("cli.doctor.summary", {
-    pass: passCount,
-    warn: warnCount,
-    fail: failCount,
-    fixed: fixedCount
-  }));
-  return {
-    success: failCount === 0,
-    checks,
-    passCount,
-    warnCount,
-    failCount,
-    fixedCount
-  };
-}
-
-// src/cli/init.ts
-import { join as join5 } from "node:path";
-
-// src/core/installer.ts
-import { copyFile as fsCopyFile, rename } from "node:fs/promises";
-import { basename, join as join4 } from "node:path";
-
-// src/utils/logger.ts
-var currentOptions = {
-  level: "info",
-  colors: true,
-  locale: "en",
-  timestamps: false
-};
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var COLORS = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  black: "\x1B[30m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m",
-  brightRed: "\x1B[91m",
-  brightGreen: "\x1B[92m",
-  brightYellow: "\x1B[93m",
-  brightBlue: "\x1B[94m",
-  brightMagenta: "\x1B[95m",
-  brightCyan: "\x1B[96m"
-};
-var LEVEL_COLORS = {
-  debug: COLORS.dim,
-  info: COLORS.blue,
-  warn: COLORS.yellow,
-  error: COLORS.red
-};
-var LEVEL_ICONS = {
-  debug: "\uD83D\uDD0D",
-  info: "ℹ️",
-  warn: "⚠️",
-  error: "❌"
-};
-var MESSAGES = {
-  en: {
-    "install.start": "Initializing oh-my-customcode...",
-    "install.success": "Successfully initialized!",
-    "install.failed": "Installation failed: {{error}}",
-    "install.exists": "Existing {{rootDir}} directory found",
-    "install.backup": "Backed up existing files to: {{path}}",
-    "install.directories_created": "Directory structure created",
-    "install.component_skipped": "Skipped {{component}} (already exists)",
-    "install.component_installed": "Installed {{component}}",
-    "install.template_not_found": "Template not found for {{component}}: {{path}}",
-    "install.claude_md_installed": "CLAUDE.md installed ({{language}})",
-    "install.claude_md_not_found": "CLAUDE.md template not found for {{language}}",
-    "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}})",
-    "update.start": "Checking for updates...",
-    "update.success": "Updated from {{from}} to {{to}}",
-    "update.failed": "Update failed: {{error}}",
-    "update.no_updates": "Already up to date",
-    "update.backup_created": "Backup created at: {{path}}",
-    "update.dry_run": "Would update {{component}}",
-    "update.component_updated": "Updated {{component}}",
-    "update.file_applied": "Applied update to {{path}}",
-    "config.load_failed": "Failed to load config: {{error}}",
-    "config.not_found": "Config not found at {{path}}, using defaults",
-    "config.saved": "Config saved to {{path}}",
-    "config.deleted": "Config deleted from {{path}}",
-    "general.done": "Done!",
-    "general.failed": "Failed",
-    "general.skipped": "Skipped"
-  },
-  ko: {
-    "install.start": "oh-my-customcode 초기화 중...",
-    "install.success": "초기화 완료!",
-    "install.failed": "설치 실패: {{error}}",
-    "install.exists": "기존 {{rootDir}} 디렉토리 발견",
-    "install.backup": "기존 파일 백업 완료: {{path}}",
-    "install.directories_created": "디렉토리 구조 생성 완료",
-    "install.component_skipped": "{{component}} 건너뜀 (이미 존재)",
-    "install.component_installed": "{{component}} 설치 완료",
-    "install.template_not_found": "{{component}} 템플릿 없음: {{path}}",
-    "install.claude_md_installed": "CLAUDE.md 설치 완료 ({{language}})",
-    "install.claude_md_not_found": "{{language}}용 CLAUDE.md 템플릿 없음",
-    "install.entry_md_installed": "{{entry}} 설치 완료 ({{language}})",
-    "install.entry_md_not_found": "{{language}}용 {{entry}} 템플릿 없음",
-    "install.entry_md_skipped": "{{entry}} 건너뜀 ({{reason}})",
-    "update.start": "업데이트 확인 중...",
-    "update.success": "{{from}}에서 {{to}}로 업데이트 완료",
-    "update.failed": "업데이트 실패: {{error}}",
-    "update.no_updates": "이미 최신 버전입니다",
-    "update.backup_created": "백업 생성됨: {{path}}",
-    "update.dry_run": "{{component}} 업데이트 예정",
-    "update.component_updated": "{{component}} 업데이트 완료",
-    "update.file_applied": "{{path}} 업데이트 적용",
-    "config.load_failed": "설정 로드 실패: {{error}}",
-    "config.not_found": "{{path}}에 설정 없음, 기본값 사용",
-    "config.saved": "설정 저장: {{path}}",
-    "config.deleted": "설정 삭제: {{path}}",
-    "general.done": "완료!",
-    "general.failed": "실패",
-    "general.skipped": "건너뜀"
-  }
-};
-function getMessage(key, params) {
-  const messages = MESSAGES[currentOptions.locale] || MESSAGES.en;
-  let message = messages[key] || key;
-  if (params) {
-    for (const [k, v] of Object.entries(params)) {
-      message = message.replace(new RegExp(`{{${k}}}`, "g"), v);
-    }
-  }
-  return message;
-}
-function formatMessage(level, message) {
-  const parts = [];
-  if (currentOptions.timestamps) {
-    const timestamp = new Date().toISOString().slice(11, 19);
-    if (currentOptions.colors) {
-      parts.push(`${COLORS.dim}[${timestamp}]${COLORS.reset}`);
-    } else {
-      parts.push(`[${timestamp}]`);
-    }
-  }
-  if (currentOptions.prefix) {
-    if (currentOptions.colors) {
-      parts.push(`${COLORS.cyan}[${currentOptions.prefix}]${COLORS.reset}`);
-    } else {
-      parts.push(`[${currentOptions.prefix}]`);
-    }
-  }
-  if (currentOptions.colors) {
-    const color = LEVEL_COLORS[level];
-    const icon = LEVEL_ICONS[level];
-    parts.push(`${color}${icon}${COLORS.reset}`);
-  } else {
-    parts.push(`[${level.toUpperCase()}]`);
-  }
-  if (currentOptions.colors && level === "error") {
-    parts.push(`${COLORS.red}${message}${COLORS.reset}`);
-  } else if (currentOptions.colors && level === "warn") {
-    parts.push(`${COLORS.yellow}${message}${COLORS.reset}`);
-  } else {
-    parts.push(message);
-  }
-  return parts.join(" ");
-}
-function shouldLog(level) {
-  return LOG_LEVELS[level] >= LOG_LEVELS[currentOptions.level];
-}
-function debug(messageKey, params) {
-  if (shouldLog("debug")) {
-    const message = getMessage(messageKey, params);
-    console.debug(formatMessage("debug", message));
-  }
-}
-function info(messageKey, params) {
-  if (shouldLog("info")) {
-    const message = getMessage(messageKey, params);
-    console.info(formatMessage("info", message));
-  }
-}
-function warn(messageKey, params) {
-  if (shouldLog("warn")) {
-    const message = getMessage(messageKey, params);
-    console.warn(formatMessage("warn", message));
-  }
-}
-function error(messageKey, params) {
-  if (shouldLog("error")) {
-    const message = getMessage(messageKey, params);
-    console.error(formatMessage("error", message));
-  }
-}
-function success(messageKey, params) {
-  if (shouldLog("info")) {
-    const message = getMessage(messageKey, params);
-    if (currentOptions.colors) {
-      console.info(`${COLORS.green}✓${COLORS.reset} ${message}`);
-    } else {
-      console.info(`[SUCCESS] ${message}`);
-    }
-  }
-}
-
-// src/core/config.ts
-import { join as join3 } from "node:path";
-var CONFIG_FILE = ".omcustomrc.json";
-var CURRENT_CONFIG_VERSION = 1;
-function getDefaultConfig() {
-  return {
-    configVersion: CURRENT_CONFIG_VERSION,
-    version: "0.0.0",
-    language: "en",
-    provider: "auto",
-    installedAt: "",
-    lastUpdated: "",
-    installedComponents: [],
-    componentVersions: {},
-    agents: {},
-    preferences: getDefaultPreferences(),
-    sourceRepo: "https://github.com/baekenough/oh-my-customcode",
-    autoUpdate: {
-      enabled: false,
-      checkIntervalHours: 24,
-      autoApplyMinor: false
+      printCheck(check);
     }
-  };
-}
-function getDefaultPreferences() {
-  return {
-    logLevel: "info",
-    colors: true,
-    showProgress: true,
-    confirmPrompts: true,
-    autoBackup: true
-  };
-}
-function getConfigPath(targetDir) {
-  return join3(targetDir, CONFIG_FILE);
-}
-async function loadConfig(targetDir) {
-  const configPath = getConfigPath(targetDir);
-  if (await fileExists(configPath)) {
-    try {
-      const config = await readJsonFile(configPath);
-      const merged = mergeConfig(getDefaultConfig(), config);
-      if (merged.configVersion < CURRENT_CONFIG_VERSION) {
-        const migrated = migrateConfig(merged);
-        await saveConfig(targetDir, migrated);
-        return migrated;
+  }
+  const passCount = checks.filter((c) => c.status === "pass" || c.fixed).length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  const failCount = checks.filter((c) => c.status === "fail" && !c.fixed).length;
+  const fixedCount = checks.filter((c) => c.fixed).length;
+  console.log("");
+  if (failCount === 0) {
+    console.log(i18n.t("cli.doctor.passed"));
+  } else {
+    console.log(i18n.t("cli.doctor.failed"));
+    if (!options.fix) {
+      const fixableCount = checks.filter((c) => c.status === "fail" && c.fixable).length;
+      if (fixableCount > 0) {
+        console.log(i18n.t("cli.doctor.runWithFix", { count: fixableCount }));
       }
-      return merged;
-    } catch (err) {
-      warn("config.load_failed", { error: String(err) });
-      return getDefaultConfig();
     }
   }
-  debug("config.not_found", { path: configPath });
-  return getDefaultConfig();
-}
-async function saveConfig(targetDir, config) {
-  const configPath = getConfigPath(targetDir);
-  await ensureDirectory(targetDir);
-  config.lastUpdated = new Date().toISOString();
-  await writeJsonFile(configPath, config);
-  debug("config.saved", { path: configPath });
-}
-function mergeConfig(defaults, overrides) {
+  console.log(i18n.t("cli.doctor.summary", {
+    pass: passCount,
+    warn: warnCount,
+    fail: failCount,
+    fixed: fixedCount
+  }));
   return {
-    ...defaults,
-    ...overrides,
-    preferences: overrides.preferences ? { ...defaults.preferences, ...overrides.preferences } : defaults.preferences,
-    autoUpdate: overrides.autoUpdate ? { ...defaults.autoUpdate, ...overrides.autoUpdate } : defaults.autoUpdate,
-    componentVersions: {
-      ...defaults.componentVersions,
-      ...overrides.componentVersions
-    },
-    agents: {
-      ...defaults.agents,
-      ...overrides.agents
-    }
+    success: failCount === 0,
+    checks,
+    passCount,
+    warnCount,
+    failCount,
+    fixedCount
   };
 }
-function migrateConfig(config) {
-  const migrated = { ...config };
-  if (config.configVersion < 1) {
-    migrated.configVersion = 1;
-    migrated.preferences = getDefaultPreferences();
-    migrated.autoUpdate = {
-      enabled: false,
-      checkIntervalHours: 24,
-      autoApplyMinor: false
-    };
-  }
-  migrated.configVersion = CURRENT_CONFIG_VERSION;
-  return migrated;
-}
+
+// src/cli/init.ts
+import { join as join5 } from "node:path";
 
 // src/core/installer.ts
+import { copyFile as fsCopyFile, rename } from "node:fs/promises";
+import { basename, join as join4 } from "node:path";
 var DEFAULT_LANGUAGE2 = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
@@ -13397,7 +13746,7 @@ async function initCommand(options) {
 }
 
 // src/cli/list.ts
-import { basename as basename2, dirname as dirname2, join as join6, relative } from "node:path";
+import { basename as basename2, dirname as dirname2, join as join6, relative as relative2 } from "node:path";
 var ALLOWED_TOP_LEVEL_KEYS = new Set(["name", "type", "description", "version", "category"]);
 function parseKeyValue(line) {
   const colonIndex = line.indexOf(":");
@@ -13461,12 +13810,12 @@ function extractAgentTypeFromFilename(filename) {
   return prefixMap[prefix] || "unknown";
 }
 function extractSkillCategoryFromPath(skillPath, baseDir, rootDir) {
-  const relativePath = relative(join6(baseDir, rootDir, "skills"), skillPath);
+  const relativePath = relative2(join6(baseDir, rootDir, "skills"), skillPath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
 function extractGuideCategoryFromPath(guidePath, baseDir) {
-  const relativePath = relative(join6(baseDir, "guides"), guidePath);
+  const relativePath = relative2(join6(baseDir, "guides"), guidePath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
@@ -13564,17 +13913,22 @@ async function getAgents(targetDir, rootDir = ".claude") {
   if (!await fileExists(agentsDir))
     return [];
   try {
+    const config = await loadConfig(targetDir);
+    const customComponents = config.customComponents || [];
+    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 = basename2(agentMdPath);
       const name = basename2(filename, ".md");
       const description = await tryExtractMarkdownDescription(agentMdPath);
+      const relativePath = relative2(targetDir, agentMdPath);
       return {
         name,
         type: extractAgentTypeFromFilename(filename),
-        path: relative(targetDir, agentMdPath),
+        path: relativePath,
         description,
-        version: undefined
+        version: undefined,
+        managed: !customAgentPaths.has(relativePath)
       };
     }));
     return agents.sort((a, b) => a.name.localeCompare(b.name));
@@ -13587,18 +13941,23 @@ async function getSkills(targetDir, rootDir = ".claude") {
   if (!await fileExists(skillsDir))
     return [];
   try {
+    const config = await loadConfig(targetDir);
+    const customComponents = config.customComponents || [];
+    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 = dirname2(skillMdPath);
       const indexYamlPath = join6(skillDir, "index.yaml");
       const { description, version } = await tryReadIndexYamlMetadata(indexYamlPath);
+      const relativePath = relative2(targetDir, skillDir);
       return {
         name: basename2(skillDir),
         type: "skill",
         category: extractSkillCategoryFromPath(skillDir, targetDir, rootDir),
-        path: relative(targetDir, skillDir),
+        path: relativePath,
         description,
-        version
+        version,
+        managed: !customSkillPaths.has(relativePath)
       };
     }));
     return skills.sort((a, b) => a.name.localeCompare(b.name));
@@ -13611,15 +13970,20 @@ async function getGuides(targetDir) {
   if (!await fileExists(guidesDir))
     return [];
   try {
+    const config = await loadConfig(targetDir);
+    const customComponents = config.customComponents || [];
+    const customGuidePaths = new Set(customComponents.filter((c) => c.type === "guide").map((c) => c.path));
     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);
       return {
         name: basename2(guideMdPath, ".md"),
         type: "guide",
         category: extractGuideCategoryFromPath(guideMdPath, targetDir),
-        path: relative(targetDir, guideMdPath),
-        description
+        path: relativePath,
+        description,
+        managed: !customGuidePaths.has(relativePath)
       };
     }));
     return guides.sort((a, b) => a.name.localeCompare(b.name));
@@ -13633,17 +13997,22 @@ async function getRules(targetDir, rootDir = ".claude") {
   if (!await fileExists(rulesDir))
     return [];
   try {
+    const config = await loadConfig(targetDir);
+    const customComponents = config.customComponents || [];
+    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 = basename2(ruleMdPath);
       const description = await tryExtractMarkdownDescription(ruleMdPath, {
         cleanFormatting: true
       });
+      const relativePath = relative2(targetDir, ruleMdPath);
       return {
         name: basename2(ruleMdPath, ".md"),
         type: extractRulePriorityFromFilename(filename),
-        path: relative(targetDir, ruleMdPath),
-        description
+        path: relativePath,
+        description,
+        managed: !customRulePaths.has(relativePath)
       };
     }));
     return rules.sort((a, b) => {
@@ -13669,7 +14038,8 @@ function formatAsTable(components, type) {
   console.log(`  ${nameHeader}  ${typeHeader}  Description`);
   console.log(`  ${"─".repeat(nameWidth)}  ${"─".repeat(typeWidth)}  ${"─".repeat(40)}`);
   for (const component of components) {
-    const name = component.name.padEnd(nameWidth);
+    const managedTag = component.managed === false ? " [custom]" : "";
+    const name = `${component.name}${managedTag}`.padEnd(nameWidth);
     const typeOrCategory = (component.category || component.type).padEnd(typeWidth);
     const description = component.description ? component.description.substring(0, 40) : "";
     console.log(`  ${name}  ${typeOrCategory}  ${description}`);
@@ -13687,7 +14057,8 @@ function formatAsSimple(components, type) {
 ${type} (${components.length}):`);
   for (const component of components) {
     const typeInfo = component.category || component.type;
-    console.log(`  ${component.name} [${typeInfo}]`);
+    const managedTag = component.managed === false ? " [custom]" : "";
+    console.log(`  ${component.name}${managedTag} [${typeInfo}]`);
   }
 }
 function formatAsJson(components) {
@@ -13705,7 +14076,7 @@ async function getHooks(targetDir, rootDir = ".claude") {
     return allFiles.map((hookPath) => ({
       name: basename2(hookPath),
       type: "hook",
-      path: relative(targetDir, hookPath)
+      path: relative2(targetDir, hookPath)
     })).sort((a, b) => a.name.localeCompare(b.name));
   } catch {
     return [];
@@ -13725,7 +14096,7 @@ async function getContexts(targetDir, rootDir = ".claude") {
       return {
         name: basename2(ctxPath, ext),
         type: "context",
-        path: relative(targetDir, ctxPath),
+        path: relative2(targetDir, ctxPath),
         description
       };
     }));
@@ -13795,73 +14166,439 @@ async function listCommand(type = "all", options = {}) {
   }
 }
 
-// src/cli/update.ts
-async function getCurrentVersion() {
-  return null;
+// src/core/updater.ts
+import { join as join7 } from "node:path";
+
+// src/core/entry-merger.ts
+var MANAGED_START = "<!-- omcustom:start -->";
+var MANAGED_END = "<!-- omcustom:end -->";
+function parseEntryDoc(content) {
+  const sections = [];
+  const lines = content.split(`
+`);
+  let currentSection = null;
+  let currentLines = [];
+  for (const line of lines) {
+    if (line.trim() === MANAGED_START) {
+      if (currentLines.length > 0) {
+        sections.push({
+          type: "custom",
+          content: currentLines.join(`
+`)
+        });
+        currentLines = [];
+      }
+      currentSection = { type: "managed", content: "" };
+      continue;
+    }
+    if (line.trim() === MANAGED_END) {
+      if (currentSection && currentSection.type === "managed") {
+        currentSection.content = currentLines.join(`
+`);
+        sections.push(currentSection);
+        currentSection = null;
+        currentLines = [];
+      }
+      continue;
+    }
+    currentLines.push(line);
+  }
+  if (currentLines.length > 0) {
+    sections.push({
+      type: "custom",
+      content: currentLines.join(`
+`)
+    });
+  }
+  return { sections };
 }
-async function getLatestVersion() {
+function mergeEntryDoc(existingContent, templateContent) {
+  const warnings = [];
+  const { sections } = parseEntryDoc(existingContent);
+  const hasManagedSections = sections.some((s) => s.type === "managed");
+  if (!hasManagedSections) {
+    const wrapped = wrapInManagedMarkers(templateContent);
+    return {
+      content: wrapped,
+      managedSections: 1,
+      customSections: 0,
+      warnings: ["No managed sections found in existing content, wrapping template entirely"]
+    };
+  }
+  const mergedSections = [];
+  let managedCount = 0;
+  let customCount = 0;
+  let templateInserted = false;
+  for (const section of sections) {
+    if (section.type === "managed") {
+      if (!templateInserted) {
+        mergedSections.push(MANAGED_START);
+        mergedSections.push(templateContent);
+        mergedSections.push(MANAGED_END);
+        templateInserted = true;
+        managedCount++;
+      } else {
+        warnings.push("Multiple managed sections found, keeping only the first one");
+      }
+    } else {
+      mergedSections.push(section.content);
+      customCount++;
+    }
+  }
   return {
-    version: "0.0.0",
-    lastUpdated: new Date().toISOString(),
-    source: "https://github.com/baekenough/oh-my-customcode"
+    content: mergedSections.join(`
+`),
+    managedSections: managedCount,
+    customSections: customCount,
+    warnings
   };
 }
-async function checkUpdateAvailable() {
-  const current = await getCurrentVersion();
-  const latest = await getLatestVersion();
-  if (!current) {
+function wrapInManagedMarkers(content) {
+  return `${MANAGED_START}
+${content}
+${MANAGED_END}`;
+}
+
+// src/core/updater.ts
+var CUSTOMIZATION_MANIFEST_FILE = ".omcustom-customizations.json";
+function createUpdateResult() {
+  return {
+    success: false,
+    updatedComponents: [],
+    skippedComponents: [],
+    preservedFiles: [],
+    backedUpPaths: [],
+    previousVersion: "",
+    newVersion: "",
+    warnings: []
+  };
+}
+async function handleBackupIfRequested(targetDir, provider, backup, result) {
+  if (!backup)
+    return;
+  const backupPath = await backupInstallation(targetDir, provider);
+  result.backedUpPaths.push(backupPath);
+  info("update.backup_created", { path: backupPath });
+}
+async function processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result) {
+  const componentUpdate = updateCheck.updatableComponents.find((c) => c.name === component);
+  if (!componentUpdate && !options.force) {
+    result.skippedComponents.push(component);
+    return;
+  }
+  if (options.dryRun) {
+    debug("update.dry_run", { component });
+    result.updatedComponents.push(component);
+    return;
+  }
+  try {
+    const preserved = await updateComponent(targetDir, provider, component, customizations, options);
+    result.updatedComponents.push(component);
+    result.preservedFiles.push(...preserved);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    result.warnings.push(`Failed to update ${component}: ${message}`);
+    result.skippedComponents.push(component);
+  }
+}
+async function updateAllComponents(targetDir, provider, components, updateCheck, customizations, options, result) {
+  for (const component of components) {
+    await processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result);
+  }
+}
+function getEntryTemplateName2(provider, language) {
+  const layout = getProviderLayout(provider);
+  const baseName = layout.entryFile.replace(".md", "");
+  return language === "ko" ? `${baseName}.md.ko` : `${baseName}.md.en`;
+}
+async function backupFile(filePath) {
+  const fs2 = await import("node:fs/promises");
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  if (await fileExists(filePath)) {
+    await fs2.copyFile(filePath, backupPath);
+    debug("update.file_backed_up", { path: filePath, backup: backupPath });
+  }
+}
+function resolveCustomizations(customizations, configPreserveFiles) {
+  if (!customizations && configPreserveFiles.length === 0) {
+    return null;
+  }
+  if (customizations && configPreserveFiles.length > 0) {
+    customizations.preserveFiles = [
+      ...new Set([...customizations.preserveFiles, ...configPreserveFiles])
+    ];
+    return customizations;
+  }
+  if (configPreserveFiles.length > 0) {
+    return {
+      modifiedFiles: [],
+      preserveFiles: configPreserveFiles,
+      customComponents: [],
+      lastUpdated: new Date().toISOString()
+    };
+  }
+  return customizations;
+}
+async function updateEntryDoc(targetDir, provider, config, options) {
+  const layout = getProviderLayout(provider);
+  const entryPath = join7(targetDir, layout.entryFile);
+  const templateName = getEntryTemplateName2(provider, config.language);
+  const templatePath = resolveTemplatePath(templateName);
+  if (!await fileExists(templatePath)) {
+    warn("update.entry_template_not_found", { template: templateName });
+    return;
+  }
+  const templateContent = await readTextFile(templatePath);
+  if (await fileExists(entryPath)) {
+    if (options.force) {
+      await backupFile(entryPath);
+      await writeTextFile(entryPath, templateContent);
+      info("update.entry_doc_force_updated", { path: layout.entryFile });
+    } else {
+      const existingContent = await readTextFile(entryPath);
+      const mergeResult = mergeEntryDoc(existingContent, templateContent);
+      await writeTextFile(entryPath, mergeResult.content);
+      debug("update.entry_doc_merged", {
+        path: layout.entryFile,
+        managed: String(mergeResult.managedSections),
+        custom: String(mergeResult.customSections)
+      });
+      if (mergeResult.warnings.length > 0) {
+        for (const warning of mergeResult.warnings) {
+          warn("update.entry_merge_warning", { warning });
+        }
+      }
+    }
+  } else {
+    await writeTextFile(entryPath, wrapInManagedMarkers(templateContent));
+    info("update.entry_doc_created", { path: layout.entryFile });
+  }
+}
+async function update(options) {
+  const result = createUpdateResult();
+  try {
+    info("update.start", { targetDir: options.targetDir });
+    const config = await loadConfig(options.targetDir);
+    const provider = options.provider ?? (config.provider === "codex" ? "codex" : "claude");
+    result.previousVersion = config.version;
+    const updateCheck = await checkForUpdates(options.targetDir, provider);
+    result.newVersion = updateCheck.latestVersion;
+    if (!updateCheck.hasUpdates && !options.force) {
+      info("update.no_updates");
+      result.success = true;
+      result.skippedComponents = options.components || getAllUpdateComponents();
+      return result;
+    }
+    await handleBackupIfRequested(options.targetDir, provider, !!options.backup, result);
+    const manifestCustomizations = options.preserveCustomizations !== false ? await loadCustomizationManifest(options.targetDir) : null;
+    const configPreserveFiles = config.preserveFiles || [];
+    const customizations = resolveCustomizations(manifestCustomizations, configPreserveFiles);
+    const components = options.components || getAllUpdateComponents();
+    await updateAllComponents(options.targetDir, provider, components, updateCheck, customizations, options, result);
+    if (!options.components || options.components.length === 0) {
+      await updateEntryDoc(options.targetDir, provider, config, options);
+    }
+    config.version = result.newVersion;
+    config.lastUpdated = new Date().toISOString();
+    await saveConfig(options.targetDir, config);
+    result.success = true;
+    success("update.success", { from: result.previousVersion, to: result.newVersion });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    result.error = message;
+    error("update.failed", { error: message });
+  }
+  return result;
+}
+async function checkForUpdates(targetDir, provider = "claude") {
+  const config = await loadConfig(targetDir);
+  const currentVersion = config.version;
+  const latestVersion = await getLatestVersion(provider);
+  const updatableComponents = [];
+  for (const component of getAllUpdateComponents()) {
+    const hasUpdate = await componentHasUpdate(targetDir, provider, component, config);
+    if (hasUpdate) {
+      updatableComponents.push({
+        name: component,
+        currentVersion: config.componentVersions?.[component] || "0.0.0",
+        latestVersion
+      });
+    }
+  }
+  return {
+    hasUpdates: updatableComponents.length > 0 || currentVersion !== latestVersion,
+    currentVersion,
+    latestVersion,
+    updatableComponents,
+    checkedAt: new Date().toISOString()
+  };
+}
+function getAllUpdateComponents() {
+  return ["rules", "agents", "skills", "guides", "hooks", "contexts"];
+}
+async function getLatestVersion(provider) {
+  const layout = getProviderLayout(provider);
+  const manifestPath = resolveTemplatePath(layout.manifestFile);
+  if (await fileExists(manifestPath)) {
+    const manifest = await readJsonFile(manifestPath);
+    return manifest.version;
+  }
+  return "0.0.0";
+}
+async function componentHasUpdate(_targetDir, provider, component, config) {
+  const installedVersion = config.componentVersions?.[component];
+  if (!installedVersion) {
     return true;
   }
-  return current.version !== latest.version;
+  const latestVersion = await getLatestVersion(provider);
+  return installedVersion !== latestVersion;
+}
+async function updateComponent(targetDir, provider, component, customizations, options) {
+  const preservedFiles = [];
+  const componentPath = getComponentPath2(provider, component);
+  const srcPath = resolveTemplatePath(componentPath);
+  const destPath = join7(targetDir, componentPath);
+  const config = await loadConfig(targetDir);
+  const customComponents = config.customComponents || [];
+  const skipPaths = [];
+  if (customizations && options.preserveCustomizations !== false) {
+    const toPreserve = customizations.preserveFiles.filter((f) => f.startsWith(componentPath));
+    preservedFiles.push(...toPreserve);
+    skipPaths.push(...toPreserve);
+  }
+  for (const cc of customComponents) {
+    if (cc.path.startsWith(componentPath)) {
+      skipPaths.push(cc.path);
+    }
+  }
+  const path2 = await import("node:path");
+  const normalizedSkipPaths = skipPaths.map((p) => path2.relative(destPath, join7(targetDir, p)));
+  await copyDirectory(srcPath, destPath, {
+    overwrite: true,
+    skipPaths: normalizedSkipPaths.length > 0 ? normalizedSkipPaths : undefined
+  });
+  debug("update.component_updated", {
+    component,
+    skippedPaths: String(normalizedSkipPaths.length)
+  });
+  return preservedFiles;
+}
+function getComponentPath2(provider, component) {
+  const layout = getProviderLayout(provider);
+  if (component === "guides") {
+    return "guides";
+  }
+  return `${layout.rootDir}/${component}`;
+}
+async function backupInstallation(targetDir, provider) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupDir = join7(targetDir, `.omcustom-backup-${timestamp}`);
+  const fs2 = await import("node:fs/promises");
+  await ensureDirectory(backupDir);
+  const layout = getProviderLayout(provider);
+  const dirsToBackup = [layout.rootDir, "guides"];
+  for (const dir2 of dirsToBackup) {
+    const srcPath = join7(targetDir, dir2);
+    if (await fileExists(srcPath)) {
+      const destPath = join7(backupDir, dir2);
+      await copyDirectory(srcPath, destPath, { overwrite: true });
+    }
+  }
+  const entryPath = join7(targetDir, layout.entryFile);
+  if (await fileExists(entryPath)) {
+    await fs2.copyFile(entryPath, join7(backupDir, layout.entryFile));
+  }
+  return backupDir;
 }
-async function applyUpdates(_options) {
-  const updatedComponents = [];
-  return updatedComponents;
+async function loadCustomizationManifest(targetDir) {
+  const manifestPath = join7(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  if (await fileExists(manifestPath)) {
+    return readJsonFile(manifestPath);
+  }
+  return null;
 }
+
+// src/cli/update.ts
 async function updateCommand(options = {}) {
-  console.log(i18n.t("cli.update.checking"));
   try {
-    const currentVersion = await getCurrentVersion();
-    const latestVersion = await getLatestVersion();
-    if (!currentVersion) {
-      console.log(i18n.t("cli.update.notInstalled"));
-      return {
-        success: false,
-        message: i18n.t("cli.update.notInstalled"),
-        errors: [i18n.t("cli.update.runInitFirst")]
-      };
-    }
-    const updateAvailable = await checkUpdateAvailable();
-    if (!updateAvailable && !options.force) {
-      console.log(i18n.t("cli.update.alreadyLatest"));
-      return {
-        success: true,
-        message: i18n.t("cli.update.alreadyLatest"),
-        currentVersion: currentVersion.version,
-        newVersion: latestVersion.version
-      };
+    const targetDir = process.cwd();
+    const detection = await detectProvider({
+      targetDir,
+      override: options.provider
+    });
+    const provider = detection.provider;
+    const components = buildComponentsList(options);
+    if (options.dryRun) {
+      console.log(i18n.t("cli.update.dryRunHeader"));
     }
-    console.log(i18n.t("cli.update.updating", {
-      from: currentVersion.version,
-      to: latestVersion.version
-    }));
-    const updatedComponents = await applyUpdates(options);
-    console.log(i18n.t("cli.update.success"));
-    return {
-      success: true,
-      message: i18n.t("cli.update.success"),
-      updatedComponents,
-      currentVersion: currentVersion.version,
-      newVersion: latestVersion.version
+    const updateOptions = {
+      targetDir,
+      provider,
+      components,
+      force: options.force,
+      preserveCustomizations: true,
+      dryRun: options.dryRun,
+      backup: options.backup
     };
+    const result = await update(updateOptions);
+    printUpdateResults(result);
+    if (!result.success) {
+      process.exit(1);
+    }
   } catch (error2) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-    console.error(i18n.t("cli.update.failed"), errorMessage);
-    return {
-      success: false,
-      message: i18n.t("cli.update.failed"),
-      errors: [errorMessage]
-    };
+    console.error(i18n.t("cli.update.summaryFailed", { error: errorMessage }));
+    process.exit(1);
+  }
+}
+function buildComponentsList(options) {
+  const components = [];
+  if (options.agents) {
+    components.push("agents");
+  }
+  if (options.skills) {
+    components.push("skills");
+  }
+  if (options.rules) {
+    components.push("rules");
+  }
+  if (options.guides) {
+    components.push("guides");
+  }
+  if (options.hooks) {
+    components.push("hooks");
+  }
+  if (options.contexts) {
+    components.push("contexts");
+  }
+  return components.length > 0 ? components : undefined;
+}
+function printUpdateResults(result) {
+  for (const component of result.updatedComponents) {
+    console.log(i18n.t("cli.update.componentUpdated", { component }));
+  }
+  for (const component of result.skippedComponents) {
+    console.log(i18n.t("cli.update.componentSkipped", { component }));
+  }
+  if (result.preservedFiles.length > 0) {
+    console.log(i18n.t("cli.update.preservedFiles", { count: result.preservedFiles.length }));
+  }
+  if (result.backedUpPaths.length > 0) {
+    for (const path2 of result.backedUpPaths) {
+      console.log(i18n.t("cli.update.backupCreated", { path: path2 }));
+    }
+  }
+  for (const warning of result.warnings) {
+    console.warn(warning);
+  }
+  if (result.success) {
+    console.log(i18n.t("cli.update.summary", {
+      updated: result.updatedComponents.length,
+      skipped: result.skippedComponents.length
+    }));
+  } else if (result.error) {
+    console.error(i18n.t("cli.update.summaryFailed", { error: result.error }));
   }
 }
 
@@ -13870,12 +14607,12 @@ var require2 = createRequire2(import.meta.url);
 var packageJson = require2("../../package.json");
 function createProgram() {
   const program2 = new Command;
-  program2.name("omcustom").description(i18n.t("cli.description")).version(packageJson.version, "-v, --version", i18n.t("cli.versionOption"));
+  program2.name("omcustom").description(i18n.t("cli.description")).version(packageJson.version, "-v, --version", i18n.t("cli.versionOption")).option("--skip-version-check", "Skip CLI version pre-flight check");
   program2.command("init").description(i18n.t("cli.init.description")).option("-l, --lang <language>", i18n.t("cli.init.langOption"), "en").option("-p, --provider <provider>", i18n.t("cli.init.providerOption"), "auto").action(async (options) => {
     await initCommand(options);
   });
-  program2.command("update").description(i18n.t("cli.update.description")).action(async () => {
-    await updateCommand();
+  program2.command("update").description(i18n.t("cli.update.description")).option("--dry-run", i18n.t("cli.update.dryRunOption")).option("--force", i18n.t("cli.update.forceOption")).option("--backup", i18n.t("cli.update.backupOption")).option("--agents", i18n.t("cli.update.agentsOption")).option("--skills", i18n.t("cli.update.skillsOption")).option("--rules", i18n.t("cli.update.rulesOption")).option("--guides", i18n.t("cli.update.guidesOption")).option("--hooks", i18n.t("cli.update.hooksOption")).option("--contexts", i18n.t("cli.update.contextsOption")).option("-p, --provider <provider>", i18n.t("cli.update.providerOption"), "auto").action(async (options) => {
+    await updateCommand(options);
   });
   program2.command("list").description(i18n.t("cli.list.description")).argument("[type]", i18n.t("cli.list.typeArgument"), "all").option("-f, --format <format>", "Output format: table, json, or simple", "table").option("--verbose", "Show detailed information").option("-p, --provider <provider>", i18n.t("cli.list.providerOption"), "auto").action(async (type, options) => {
     await listCommand(type, {
@@ -13887,6 +14624,16 @@ function createProgram() {
   program2.command("doctor").description(i18n.t("cli.doctor.description")).option("--fix", i18n.t("cli.doctor.fixOption")).option("-p, --provider <provider>", i18n.t("cli.doctor.providerOption"), "auto").action(async (options) => {
     await doctorCommand(options);
   });
+  program2.hook("preAction", async (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    const skipCheck = opts.skipVersionCheck || false;
+    const result = await runPreflightCheck({ skip: skipCheck });
+    if (result.hasUpdates) {
+      const warnings = formatPreflightWarnings(result);
+      console.warn(warnings);
+      console.warn("");
+    }
+  });
   return program2;
 }
 async function main() {