oh-my-customcode 1.1.92 → 1.1.94

package/dist/index.js

@@ -151,6 +151,19 @@ async function writeJsonFile(path, data) {
   const content = JSON.stringify(data, null, 2);
   await fs.writeFile(path, content, "utf-8");
 }
+function parseJsonText(raw) {
+  const bom = raw.startsWith(UTF8_BOM);
+  const text = bom ? raw.slice(UTF8_BOM.length) : raw;
+  return {
+    data: JSON.parse(text),
+    format: { bom, trailingNewline: text.endsWith(`
+`) }
+  };
+}
+function stringifyJson(data, format) {
+  return `${format.bom ? UTF8_BOM : ""}${JSON.stringify(data, null, 2)}${format.trailingNewline ? `
+` : ""}`;
+}
 async function readTextFile(path) {
   const fs = await import("node:fs/promises");
   return fs.readFile(path, "utf-8");
@@ -188,6 +201,7 @@ function matchesPattern(filename, pattern) {
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(filename);
 }
+var UTF8_BOM = "\uFEFF";
 var init_fs = () => {};
 
 // src/core/registry.ts
@@ -330,7 +344,7 @@ var MESSAGES = {
     "install.entry_md_skipped": "{{entry}} skipped ({{reason}})",
     "install.lockfile_generated": "Lockfile generated ({{files}} files tracked)",
     "install.lockfile_failed": "Failed to generate lockfile: {{error}}",
-    "install.hook_commands_migrated": "Migrated {{rewritten}} hook command(s) in settings.local.json",
+    "install.hook_commands_migrated": "Migrated {{rewritten}} hook/statusLine command(s) in settings.local.json",
     "install.hook_commands_migration_failed": "Failed to migrate hook commands in settings.local.json: {{error}}",
     "lockfile.not_found": "Lockfile not found: {{path}}",
     "lockfile.invalid_version": "Invalid lockfile version: {{path}}",
@@ -353,15 +367,86 @@ var MESSAGES = {
     "update.lockfile_failed": "Failed to regenerate lockfile: {{error}}",
     "update.protected_file_updated": "⟳ Protected file {{file}} in {{component}} updated: {{hint}}",
     "update.namespace_synced": "Namespace synced: {{file}} ({{component}})",
-    "update.hook_commands_migrated": "Migrated {{count}} hook command(s) to CLAUDE_PROJECT_DIR-anchored paths",
+    "update.hook_commands_migrated": "Migrated {{count}} hook/statusLine command(s) to CLAUDE_PROJECT_DIR-anchored paths",
     "update.hook_commands_migration_failed": "Failed to migrate hook commands in {{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}}",
+    "config.invalid_preserve_path": "Ignored invalid preserve path: {{path}} ({{reason}})",
+    "codex.already_installed": "Codex CLI is already installed",
+    "codex.installing_brew": "Installing Codex CLI via Homebrew...",
+    "codex.installing_npm": "Installing Codex CLI via npm...",
+    "codex.install_failed": "Failed to install Codex CLI: {{error}}",
+    "codex.unsupported_os": "Codex CLI auto-install is not supported on {{os}}",
+    "rtk.already_installed": "RTK is already installed",
+    "rtk.installing_brew": "Installing RTK via Homebrew...",
+    "rtk.installing_curl": "Installing RTK via install script...",
+    "rtk.install_failed": "Failed to install RTK: {{error}}",
+    "rtk.unsupported_os": "RTK auto-install is not supported on {{os}}",
+    "mcp.ontology_rag_configured": "ontology-rag MCP server configured successfully",
+    "install.codex_installing": "Installing Codex CLI...",
+    "install.codex_success": "Codex CLI installed successfully",
+    "install.codex_already": "Codex CLI is already installed",
+    "install.rtk_installing": "Installing RTK...",
+    "install.rtk_success": "RTK installed successfully",
+    "install.rtk_already": "RTK is already installed",
+    "install.preserved": "Preserved {{files}} file(s) and {{dirs}} directory(ies) from the existing installation",
+    "install.restored": "Restored {{files}} file(s) and {{dirs}} directory(ies) after installation",
+    "install.backup_failed": "Failed to back up {{path}}: {{error}}",
+    "install.hooks_settings_failed": "Failed to merge hooks into settings.local.json: {{error}}",
+    "preserve.cleanup_failed": "Failed to clean up preservation directory {{dir}}: {{error}}",
+    "preserve.extract_dir_failed": "Failed to preserve directory {{dir}}: {{error}}",
+    "preserve.extract_failed": "Failed to preserve file {{file}}: {{error}}",
+    "preserve.restore_dir_failed": "Failed to restore directory {{dir}}: {{error}}",
+    "preserve.restore_failed": "Failed to restore file {{file}}: {{error}}",
+    "preserve_files.invalid_path": "Ignored invalid preserve_files entry from {{source}}: {{path}} ({{reason}})",
+    "update.codex_missing": "Codex CLI is not installed",
+    "update.rtk_missing": "RTK is not installed",
+    "update.self_update_skipped": "Skipped update: source project cannot update itself",
+    "update.deprecated_file_invalid_path": "Skipped deprecated file with invalid path: {{path}} ({{reason}})",
+    "update.deprecated_file_removed": "Removed deprecated file: {{path}} ({{reason}})",
+    "update.entry_doc_created": "Entry document created: {{path}}",
+    "update.entry_doc_force_updated": "Entry document force-updated: {{path}}",
+    "update.entry_merge_warning": "Entry document merge warning: {{warning}}",
+    "update.entry_template_not_found": "Entry document template not found: {{template}}",
+    "update.protected_file_force_overwrite": "Protected file {{file}} in {{component}} overwritten: {{hint}}",
+    "update.protected_file_skipped": "Protected file {{file}} in {{component}} skipped: {{hint}}",
+    "update.settings_local_backfill_failed": "Failed to backfill statusLine refreshInterval in {{path}}",
     "general.done": "Done!",
     "general.failed": "Failed",
-    "general.skipped": "Skipped"
+    "general.skipped": "Skipped",
+    "install.agent_domain_excluded": "Excluded agent {{agent}} (domain: {{domain}})",
+    "install.backed_up": "Backed up {{from}} to {{to}}",
+    "install.hooks_settings_merged": "Merged hooks wiring into settings.local.json",
+    "install.hooks_settings_skipped": "Skipped hooks wiring in settings.local.json: {{reason}}",
+    "install.schemas_not_found": "schemas/tool-inputs.json template not found: {{path}}",
+    "install.schemas_skipped": "Skipped schemas/tool-inputs.json: {{reason}}",
+    "install.schemas_installed": "Installed schemas/tool-inputs.json",
+    "install.settings_local_created": "Created settings.local.json",
+    "install.settings_local_merged": "Merged statusLine into settings.local.json",
+    "install.settings_local_refreshInterval_added": "Added statusLine refreshInterval to settings.local.json",
+    "install.settings_local_skipped": "Skipped settings.local.json statusLine: {{reason}}",
+    "install.settings_local_statusline_migrated": "Re-anchored default statusLine command in settings.local.json",
+    "install.skill_scope_excluded": "Excluded skill {{skill}} (scope: {{scope}})",
+    "install.statusline_installed": "Installed statusline.sh",
+    "install.statusline_not_found": "statusline.sh template not found: {{path}}",
+    "install.statusline_skipped": "Skipped statusline.sh: {{reason}}",
+    "install.tests_config_installed": "Installed tests/tsconfig.json",
+    "install.tests_config_not_found": "tests/tsconfig.json template not found: {{path}}",
+    "install.tests_config_skipped": "Skipped tests/tsconfig.json: {{reason}}",
+    "preserve.cleanup": "Cleaned up preservation directory: {{dir}}",
+    "preserve.copied_json": "Copied JSON file: {{file}}",
+    "preserve.extracted_dir": "Preserved directory: {{dir}}",
+    "preserve.extracted_file": "Preserved file: {{file}}",
+    "preserve.merged_json": "Merged JSON file: {{file}}",
+    "preserve.restored_dir": "Restored directory: {{dir}}",
+    "preserve.restored_file": "Restored file: {{file}}",
+    "update.deprecated_files_cleaned": "Removed {{count}} deprecated file(s)",
+    "update.entry_doc_merged": "Entry document merged: {{path}} ({{managed}} managed, {{custom}} custom sections)",
+    "update.file_backed_up": "Backed up {{path}} to {{backup}}",
+    "update.root_files_synced": "Root-level files synced: {{files}}",
+    "update.settings_local_refreshInterval_backfilled": "Backfilled statusLine refreshInterval in settings.local.json"
   },
   ko: {
     "install.start": "oh-my-customcode 초기화 중...",
@@ -380,7 +465,7 @@ var MESSAGES = {
     "install.entry_md_skipped": "{{entry}} 건너뜀 ({{reason}})",
     "install.lockfile_generated": "잠금 파일 생성 완료 ({{files}}개 파일 추적)",
     "install.lockfile_failed": "잠금 파일 생성 실패: {{error}}",
-    "install.hook_commands_migrated": "settings.local.json의 훅 명령 {{rewritten}}개를 마이그레이션했습니다",
+    "install.hook_commands_migrated": "settings.local.json의 훅/상태줄 명령 {{rewritten}}개를 마이그레이션했습니다",
     "install.hook_commands_migration_failed": "settings.local.json의 훅 명령 마이그레이션에 실패했습니다: {{error}}",
     "lockfile.not_found": "잠금 파일 없음: {{path}}",
     "lockfile.invalid_version": "잠금 파일 버전 유효하지 않음: {{path}}",
@@ -403,15 +488,86 @@ var MESSAGES = {
     "update.lockfile_failed": "잠금 파일 재생성 실패: {{error}}",
     "update.protected_file_updated": "⟳ 보호 파일 {{file}} ({{component}}) 업데이트됨: {{hint}}",
     "update.namespace_synced": "네임스페이스 동기화: {{file}} ({{component}})",
-    "update.hook_commands_migrated": "CLAUDE_PROJECT_DIR 기준 경로로 훅 명령 {{count}}개를 마이그레이션했습니다",
+    "update.hook_commands_migrated": "CLAUDE_PROJECT_DIR 기준 경로로 훅/상태줄 명령 {{count}}개를 마이그레이션했습니다",
     "update.hook_commands_migration_failed": "{{path}}의 훅 명령 마이그레이션에 실패했습니다",
     "config.load_failed": "설정 로드 실패: {{error}}",
     "config.not_found": "{{path}}에 설정 없음, 기본값 사용",
     "config.saved": "설정 저장: {{path}}",
     "config.deleted": "설정 삭제: {{path}}",
+    "config.invalid_preserve_path": "유효하지 않은 보존 경로를 무시했습니다: {{path}} ({{reason}})",
+    "codex.already_installed": "Codex CLI가 이미 설치되어 있습니다",
+    "codex.installing_brew": "Homebrew로 Codex CLI를 설치합니다...",
+    "codex.installing_npm": "npm으로 Codex CLI를 설치합니다...",
+    "codex.install_failed": "Codex CLI 설치에 실패했습니다: {{error}}",
+    "codex.unsupported_os": "{{os}}에서는 Codex CLI 자동 설치를 지원하지 않습니다",
+    "rtk.already_installed": "RTK가 이미 설치되어 있습니다",
+    "rtk.installing_brew": "Homebrew로 RTK를 설치합니다...",
+    "rtk.installing_curl": "설치 스크립트로 RTK를 설치합니다...",
+    "rtk.install_failed": "RTK 설치에 실패했습니다: {{error}}",
+    "rtk.unsupported_os": "{{os}}에서는 RTK 자동 설치를 지원하지 않습니다",
+    "mcp.ontology_rag_configured": "ontology-rag MCP 서버 구성을 완료했습니다",
+    "install.codex_installing": "Codex CLI를 설치합니다...",
+    "install.codex_success": "Codex CLI를 설치했습니다",
+    "install.codex_already": "Codex CLI가 이미 설치되어 있습니다",
+    "install.rtk_installing": "RTK를 설치합니다...",
+    "install.rtk_success": "RTK를 설치했습니다",
+    "install.rtk_already": "RTK가 이미 설치되어 있습니다",
+    "install.preserved": "기존 설치에서 파일 {{files}}개와 디렉토리 {{dirs}}개를 보존했습니다",
+    "install.restored": "설치 후 파일 {{files}}개와 디렉토리 {{dirs}}개를 복원했습니다",
+    "install.backup_failed": "{{path}} 백업에 실패했습니다: {{error}}",
+    "install.hooks_settings_failed": "settings.local.json에 훅을 병합하지 못했습니다: {{error}}",
+    "preserve.cleanup_failed": "보존 디렉토리 {{dir}} 정리에 실패했습니다: {{error}}",
+    "preserve.extract_dir_failed": "디렉토리 {{dir}} 보존에 실패했습니다: {{error}}",
+    "preserve.extract_failed": "파일 {{file}} 보존에 실패했습니다: {{error}}",
+    "preserve.restore_dir_failed": "디렉토리 {{dir}} 복원에 실패했습니다: {{error}}",
+    "preserve.restore_failed": "파일 {{file}} 복원에 실패했습니다: {{error}}",
+    "preserve_files.invalid_path": "{{source}}의 유효하지 않은 preserve_files 항목을 무시했습니다: {{path}} ({{reason}})",
+    "update.codex_missing": "Codex CLI가 설치되어 있지 않습니다",
+    "update.rtk_missing": "RTK가 설치되어 있지 않습니다",
+    "update.self_update_skipped": "업데이트를 건너뜁니다: 소스 프로젝트는 스스로 업데이트할 수 없습니다",
+    "update.deprecated_file_invalid_path": "경로가 유효하지 않아 지원 중단 파일을 건너뜁니다: {{path}} ({{reason}})",
+    "update.deprecated_file_removed": "지원 중단 파일을 삭제했습니다: {{path}} ({{reason}})",
+    "update.entry_doc_created": "진입 문서를 생성했습니다: {{path}}",
+    "update.entry_doc_force_updated": "진입 문서를 강제로 업데이트했습니다: {{path}}",
+    "update.entry_merge_warning": "진입 문서 병합 경고: {{warning}}",
+    "update.entry_template_not_found": "진입 문서 템플릿을 찾을 수 없습니다: {{template}}",
+    "update.protected_file_force_overwrite": "{{component}}의 보호 파일 {{file}}을(를) 덮어썼습니다: {{hint}}",
+    "update.protected_file_skipped": "{{component}}의 보호 파일 {{file}}을(를) 건너뜁니다: {{hint}}",
+    "update.settings_local_backfill_failed": "{{path}}의 statusLine refreshInterval 보충에 실패했습니다",
     "general.done": "완료!",
     "general.failed": "실패",
-    "general.skipped": "건너뜀"
+    "general.skipped": "건너뜀",
+    "install.agent_domain_excluded": "에이전트 {{agent}}을(를) 제외했습니다 (도메인: {{domain}})",
+    "install.backed_up": "{{from}}을(를) {{to}}(으)로 백업했습니다",
+    "install.hooks_settings_merged": "settings.local.json에 훅 연결을 병합했습니다",
+    "install.hooks_settings_skipped": "settings.local.json의 훅 연결을 건너뜁니다: {{reason}}",
+    "install.schemas_not_found": "schemas/tool-inputs.json 템플릿을 찾을 수 없습니다: {{path}}",
+    "install.schemas_skipped": "schemas/tool-inputs.json 설치를 건너뜁니다: {{reason}}",
+    "install.schemas_installed": "schemas/tool-inputs.json을 설치했습니다",
+    "install.settings_local_created": "settings.local.json을 생성했습니다",
+    "install.settings_local_merged": "settings.local.json에 statusLine을 병합했습니다",
+    "install.settings_local_refreshInterval_added": "settings.local.json에 statusLine refreshInterval을 추가했습니다",
+    "install.settings_local_skipped": "settings.local.json의 statusLine을 건너뜁니다: {{reason}}",
+    "install.settings_local_statusline_migrated": "settings.local.json의 기본 statusLine 명령을 프로젝트 루트 기준으로 변경했습니다",
+    "install.skill_scope_excluded": "스킬 {{skill}}을(를) 제외했습니다 (범위: {{scope}})",
+    "install.statusline_installed": "statusline.sh를 설치했습니다",
+    "install.statusline_not_found": "statusline.sh 템플릿을 찾을 수 없습니다: {{path}}",
+    "install.statusline_skipped": "statusline.sh 설치를 건너뜁니다: {{reason}}",
+    "install.tests_config_installed": "tests/tsconfig.json을 설치했습니다",
+    "install.tests_config_not_found": "tests/tsconfig.json 템플릿을 찾을 수 없습니다: {{path}}",
+    "install.tests_config_skipped": "tests/tsconfig.json 설치를 건너뜁니다: {{reason}}",
+    "preserve.cleanup": "보존 디렉토리를 정리했습니다: {{dir}}",
+    "preserve.copied_json": "JSON 파일을 복사했습니다: {{file}}",
+    "preserve.extracted_dir": "디렉토리를 보존했습니다: {{dir}}",
+    "preserve.extracted_file": "파일을 보존했습니다: {{file}}",
+    "preserve.merged_json": "JSON 파일을 병합했습니다: {{file}}",
+    "preserve.restored_dir": "디렉토리를 복원했습니다: {{dir}}",
+    "preserve.restored_file": "파일을 복원했습니다: {{file}}",
+    "update.deprecated_files_cleaned": "지원 중단 파일 {{count}}개를 삭제했습니다",
+    "update.entry_doc_merged": "진입 문서를 병합했습니다: {{path}} (관리 섹션 {{managed}}개, 사용자 섹션 {{custom}}개)",
+    "update.file_backed_up": "{{path}}을(를) {{backup}}(으)로 백업했습니다",
+    "update.root_files_synced": "루트 수준 파일을 동기화했습니다: {{files}}",
+    "update.settings_local_refreshInterval_backfilled": "settings.local.json의 statusLine refreshInterval을 보충했습니다"
   }
 };
 function createLogger(options = {}) {
@@ -893,7 +1049,7 @@ import {
   rename,
   stat as stat2
 } from "node:fs/promises";
-import { basename as basename2, join as join5 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join5 } from "node:path";
 
 // src/core/codex-installer.ts
 import { execSync } from "node:child_process";
@@ -957,6 +1113,117 @@ function installCodex(deps = defaultDeps) {
 // src/core/file-preservation.ts
 init_fs();
 import { basename, join as join3 } from "node:path";
+
+// src/core/hook-group-merge.ts
+var LEGACY_OMCUSTOM_DESCRIPTIONS = [
+  "Record agent outcomes + auto-continue workflow + R007/R008 drift advisory on subagent completion (autonomous-loop re-entry, #1545)",
+  'Re-inject project CLAUDE.md into model context on session start/resume/clear and compact re-entry — matcher "*" covers all SessionStart sources including "compact" (#1617)'
+];
+var STANDALONE_SCRIPT_COMMAND = /^(?:bash )?(?:"(?:\$\{CLAUDE_PROJECT_DIR:-\.\}\/|\.\/)?\.claude\/hooks\/((?:scripts\/)?[A-Za-z0-9._-]+\.sh)"|(?:\.\/)?\.claude\/hooks\/((?:scripts\/)?[A-Za-z0-9._-]+\.sh))$/;
+var SCRIPT_REFERENCE = /\.claude\/hooks\/((?:scripts\/)?[A-Za-z0-9._-]+\.sh)/g;
+function matcherKey(group) {
+  return typeof group.matcher === "string" ? group.matcher : "";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function addHookOwnership(hook, owned) {
+  if (!isRecord(hook) || typeof hook.command !== "string") {
+    return;
+  }
+  owned.commands.add(hook.command);
+  for (const match of hook.command.matchAll(SCRIPT_REFERENCE)) {
+    owned.scripts.add(match[1]);
+  }
+}
+function addGroupOwnership(group, owned, descriptions) {
+  if (!isRecord(group)) {
+    return;
+  }
+  const key = matcherKey(group);
+  let forMatcher = owned.get(key);
+  if (forMatcher === undefined) {
+    forMatcher = { commands: new Set, scripts: new Set };
+    owned.set(key, forMatcher);
+  }
+  if (typeof group.description === "string") {
+    descriptions.add(group.description);
+  }
+  if (Array.isArray(group.hooks)) {
+    for (const hook of group.hooks) {
+      addHookOwnership(hook, forMatcher);
+    }
+  }
+}
+function collectOwnership(generated) {
+  const descriptions = new Set(LEGACY_OMCUSTOM_DESCRIPTIONS);
+  const events = new Map;
+  for (const [event, groups] of Object.entries(generated)) {
+    const owned = new Map;
+    events.set(event, owned);
+    for (const group of groups) {
+      addGroupOwnership(group, owned, descriptions);
+    }
+  }
+  return { descriptions, events };
+}
+function isOwnedCommand(hook, owned) {
+  if (owned === undefined || !isRecord(hook) || hook.type !== "command") {
+    return false;
+  }
+  const command = hook.command;
+  if (typeof command !== "string") {
+    return false;
+  }
+  if (owned.commands.has(command)) {
+    return true;
+  }
+  const match = STANDALONE_SCRIPT_COMMAND.exec(command);
+  const script = match?.[1] ?? match?.[2];
+  return script !== undefined && owned.scripts.has(script);
+}
+function userResidual(group, owned, ownership) {
+  if (!isRecord(group) || !Array.isArray(group.hooks)) {
+    return [group];
+  }
+  if (typeof group.description === "string" && ownership.descriptions.has(group.description)) {
+    return [];
+  }
+  const ownedForMatcher = owned?.get(matcherKey(group));
+  const remaining = group.hooks.filter((hook) => !isOwnedCommand(hook, ownedForMatcher));
+  if (remaining.length === group.hooks.length) {
+    return [group];
+  }
+  return remaining.length === 0 ? [] : [{ ...group, hooks: remaining }];
+}
+function mergeHookBlocks(existing, generated) {
+  const result = {};
+  for (const [event, groups] of Object.entries(generated)) {
+    result[event] = [...groups];
+  }
+  if (!isRecord(existing)) {
+    return result;
+  }
+  const ownership = collectOwnership(generated);
+  for (const [event, value] of Object.entries(existing)) {
+    if (!Array.isArray(value)) {
+      if (!ownership.events.has(event)) {
+        result[event] = value;
+      }
+      continue;
+    }
+    const owned = ownership.events.get(event);
+    const residual = value.flatMap((group) => userResidual(group, owned, ownership));
+    if (residual.length === 0) {
+      continue;
+    }
+    const current = result[event];
+    result[event] = Array.isArray(current) ? [...current, ...residual] : residual;
+  }
+  return result;
+}
+
+// src/core/file-preservation.ts
 var DEFAULT_CRITICAL_FILES = ["settings.json", "settings.local.json"];
 var DEFAULT_CRITICAL_DIRECTORIES = ["agent-memory", "agent-memory-local"];
 var PROTECTED_FRAMEWORK_FILES = ["CLAUDE.md", "AGENTS.md"];
@@ -1066,12 +1333,19 @@ async function restoreCriticalFiles(rootDir, preservation) {
   }
   return result;
 }
+var HOOKS_MERGE_FILES = new Set(["settings.json", "settings.local.json"]);
+function isGeneratedHookBlock(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((groups) => Array.isArray(groups));
+}
 async function mergeJsonFile(preservedPath, targetPath) {
-  const preservedData = await readJsonFile(preservedPath);
+  const { data: preservedData, format } = parseJsonText(await readTextFile(preservedPath));
   if (await fileExists(targetPath)) {
-    const targetData = await readJsonFile(targetPath);
+    const { data: targetData } = parseJsonText(await readTextFile(targetPath));
     const merged = deepMerge(targetData, preservedData);
-    await writeJsonFile(targetPath, merged);
+    if (HOOKS_MERGE_FILES.has(basename(targetPath)) && isGeneratedHookBlock(targetData.hooks)) {
+      merged.hooks = mergeHookBlocks(preservedData.hooks, targetData.hooks);
+    }
+    await writeTextFile(targetPath, stringifyJson(merged, format));
     debug("preserve.merged_json", { file: basename(targetPath) });
   } else {
     await copyFile(preservedPath, targetPath);
@@ -1112,14 +1386,14 @@ function rewriteRelativeHookCommand(command) {
   const interpreter = match[1] ?? "";
   return `${interpreter}"\${CLAUDE_PROJECT_DIR:-.}/.claude/hooks/${match[2]}"`;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function rewriteNode(node, counter) {
   if (Array.isArray(node)) {
     return node.map((item) => rewriteNode(item, counter));
   }
-  if (!isRecord(node)) {
+  if (!isRecord2(node)) {
     return node;
   }
   const out = {};
@@ -1136,16 +1410,32 @@ function rewriteNode(node, counter) {
   }
   return out;
 }
-function migrateHookCommands(settings) {
-  if (!isRecord(settings.hooks)) {
-    return { settings, rewritten: 0 };
+var OLD_STATUSLINE_COMMAND = ".claude/statusline.sh";
+var NEW_STATUSLINE_COMMAND = `bash "\${CLAUDE_PROJECT_DIR:-.}/.claude/statusline.sh"`;
+function migrateStatusLine(statusLine) {
+  if (!isRecord2(statusLine) || statusLine.command !== OLD_STATUSLINE_COMMAND) {
+    return null;
   }
+  return { ...statusLine, command: NEW_STATUSLINE_COMMAND };
+}
+function migrateHookCommands(settings) {
   const counter = { count: 0 };
-  const hooks = rewriteNode(settings.hooks, counter);
+  const updates = {};
+  if (isRecord2(settings.hooks)) {
+    const hooks = rewriteNode(settings.hooks, counter);
+    if (counter.count > 0) {
+      updates.hooks = hooks;
+    }
+  }
+  const statusLine = migrateStatusLine(settings.statusLine);
+  if (statusLine !== null) {
+    counter.count++;
+    updates.statusLine = statusLine;
+  }
   if (counter.count === 0) {
     return { settings, rewritten: 0 };
   }
-  return { settings: { ...settings, hooks }, rewritten: counter.count };
+  return { settings: { ...settings, ...updates }, rewritten: counter.count };
 }
 
 // src/core/hooks-settings.ts
@@ -1618,20 +1908,44 @@ function convertHooksJson(hooksJson) {
   }
   return { hooks: result, warnings };
 }
-async function mergeHooksIntoSettings(settingsPath, hooksJsonPath) {
-  const hooksJson = await readJsonFile(hooksJsonPath);
-  const { hooks, warnings } = convertHooksJson(hooksJson);
-  let settings = {};
+var UTF8_BOM2 = "\uFEFF";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readExistingSettings(settingsPath) {
+  let raw;
   try {
-    const existingRaw = await readTextFile(settingsPath);
-    settings = JSON.parse(existingRaw);
+    raw = await readTextFile(settingsPath);
   } catch {
-    settings = {};
+    return { ok: true, settings: {}, bom: false };
+  }
+  const bom = raw.startsWith(UTF8_BOM2);
+  if ((bom ? raw.slice(UTF8_BOM2.length) : raw).trim() === "") {
+    return { ok: true, settings: {}, bom };
   }
-  settings.hooks = hooks;
+  try {
+    const { data } = parseJsonText(raw);
+    if (isPlainObject(data)) {
+      return { ok: true, settings: data, bom };
+    }
+    return { ok: false, reason: "the top-level JSON value is not a JSON object", bom };
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : String(err), bom };
+  }
+}
+async function mergeHooksIntoSettings(settingsPath, hooksJsonPath, options = {}) {
+  const hooksJson = await readJsonFile(hooksJsonPath);
+  const { hooks, warnings } = convertHooksJson(hooksJson);
+  const preserve = options.preserveUserHooks === true;
+  const existing = await readExistingSettings(settingsPath);
+  if (!existing.ok && preserve) {
+    warnings.push(`hooks: could not parse existing ${settingsPath} (${existing.reason}); the file was left unchanged and hooks were NOT installed — fix or move the file, then re-run \`omcustom init\``);
+    return { warnings };
+  }
+  const settings = existing.ok ? existing.settings : {};
+  settings.hooks = preserve ? mergeHookBlocks(settings.hooks, hooks) : hooks;
   await ensureDirectory(dirname2(settingsPath));
-  await writeTextFile(settingsPath, `${JSON.stringify(settings, null, 2)}
-`);
+  await writeTextFile(settingsPath, stringifyJson(settings, { bom: existing.bom, trailingNewline: true }));
   return { warnings };
 }
 
@@ -2008,6 +2322,25 @@ async function installStatusline(targetDir, options, _result) {
   await fs.chmod(destPath, 493);
   debug("install.statusline_installed", {});
 }
+async function installSchemas(targetDir, options, _result) {
+  const layout = getProviderLayout();
+  const relPath = join5(layout.rootDir, "schemas", "tool-inputs.json");
+  const srcPath = resolveTemplatePath(relPath);
+  const destPath = join5(targetDir, relPath);
+  if (!await fileExists(srcPath)) {
+    debug("install.schemas_not_found", { path: srcPath });
+    return;
+  }
+  if (await fileExists(destPath)) {
+    if (!options.force && !options.backup) {
+      debug("install.schemas_skipped", { reason: "exists" });
+      return;
+    }
+  }
+  await ensureDirectory(dirname3(destPath));
+  await copyFile(srcPath, destPath);
+  debug("install.schemas_installed", {});
+}
 async function installTestsConfig(targetDir, options, _result) {
   const srcPath = resolveTemplatePath(join5("tests", "tsconfig.json"));
   const destPath = join5(targetDir, "tests", "tsconfig.json");
@@ -2024,34 +2357,55 @@ async function installTestsConfig(targetDir, options, _result) {
   await copyFile(srcPath, destPath);
   debug("install.tests_config_installed", {});
 }
+var STATUSLINE_REFRESH_INTERVAL = 10;
+function updateExistingStatusLine(existing) {
+  const migrated = migrateHookCommands({ statusLine: existing.statusLine });
+  const commandMigrated = migrated.rewritten > 0;
+  if (commandMigrated) {
+    existing.statusLine = migrated.settings.statusLine;
+  }
+  const sl = existing.statusLine;
+  const refreshIntervalAdded = sl.refreshInterval === undefined;
+  if (refreshIntervalAdded) {
+    sl.refreshInterval = STATUSLINE_REFRESH_INTERVAL;
+  }
+  return { commandMigrated, refreshIntervalAdded };
+}
+async function mergeStatusLineIntoExisting(settingsPath, existing, format, defaults) {
+  if (!existing.statusLine) {
+    existing.statusLine = defaults.statusLine;
+    await writeTextFile(settingsPath, stringifyJson(existing, format));
+    debug("install.settings_local_merged", {});
+    return;
+  }
+  const { commandMigrated, refreshIntervalAdded } = updateExistingStatusLine(existing);
+  if (!commandMigrated && !refreshIntervalAdded) {
+    debug("install.settings_local_skipped", { reason: "statusLine exists" });
+    return;
+  }
+  await writeTextFile(settingsPath, stringifyJson(existing, format));
+  if (commandMigrated) {
+    debug("install.settings_local_statusline_migrated", {});
+  }
+  if (refreshIntervalAdded) {
+    debug("install.settings_local_refreshInterval_added", {});
+  }
+}
 async function installSettingsLocal(targetDir, result) {
   const layout = getProviderLayout();
   const settingsPath = join5(targetDir, layout.rootDir, "settings.local.json");
   const statusLineConfig = {
     statusLine: {
       type: "command",
-      command: ".claude/statusline.sh",
+      command: NEW_STATUSLINE_COMMAND,
       padding: 0,
-      refreshInterval: 10
+      refreshInterval: STATUSLINE_REFRESH_INTERVAL
     }
   };
   if (await fileExists(settingsPath)) {
     try {
-      const existing = await readJsonFile(settingsPath);
-      if (!existing.statusLine) {
-        existing.statusLine = statusLineConfig.statusLine;
-        await writeJsonFile(settingsPath, existing);
-        debug("install.settings_local_merged", {});
-      } else {
-        const sl = existing.statusLine;
-        if (sl.refreshInterval === undefined) {
-          sl.refreshInterval = statusLineConfig.statusLine.refreshInterval;
-          await writeJsonFile(settingsPath, existing);
-          debug("install.settings_local_refreshInterval_added", {});
-        } else {
-          debug("install.settings_local_skipped", { reason: "statusLine exists" });
-        }
-      }
+      const { data: existing, format } = parseJsonText(await readTextFile(settingsPath));
+      await mergeStatusLineIntoExisting(settingsPath, existing, format, statusLineConfig);
     } catch {
       result.warnings.push("Failed to parse existing settings.local.json, skipping statusLine config");
     }
@@ -2069,7 +2423,9 @@ async function installHooksSettings(targetDir, _options, result) {
     return;
   }
   try {
-    const mergeResult = await mergeHooksIntoSettings(settingsPath, hooksJsonPath);
+    const mergeResult = await mergeHooksIntoSettings(settingsPath, hooksJsonPath, {
+      preserveUserHooks: true
+    });
     if (mergeResult && Array.isArray(mergeResult.warnings) && mergeResult.warnings.length > 0) {
       result.warnings.push(...mergeResult.warnings);
     }
@@ -2162,6 +2518,7 @@ async function install(options) {
     await verifyTemplateDirectory();
     await installAllComponents(options.targetDir, options, result);
     await installStatusline(options.targetDir, options, result);
+    await installSchemas(options.targetDir, options, result);
     await installTestsConfig(options.targetDir, options, result);
     await installSettingsLocal(options.targetDir, result);
     await installHooksSettings(options.targetDir, options, result);
@@ -2407,7 +2764,7 @@ var package_default = {
   workspaces: [
     "packages/*"
   ],
-  version: "1.1.92",
+  version: "1.1.94",
   description: "Batteries-included agent harness for Claude Code",
   type: "module",
   bin: {
@@ -5270,11 +5627,12 @@ async function migrateHookCommandsInSettingsLocal(targetDir, options) {
     });
   }
 }
-async function runFullUpdatePostProcessing(options, result, config) {
+async function runFullUpdatePostProcessing(options, result, config, customizations) {
   const isFullUpdate = !options.components || options.components.length === 0;
   if (isFullUpdate) {
-    const synced = await syncRootLevelFiles(options.targetDir, options);
+    const { synced, preserved } = await syncRootLevelFiles(options.targetDir, options, customizations);
     result.syncedRootFiles = synced;
+    result.preservedFiles.push(...preserved);
     const removed = await removeDeprecatedFiles(options.targetDir, options);
     result.removedDeprecatedFiles = removed;
     if (!options.dryRun) {
@@ -5391,7 +5749,7 @@ async function update(options) {
     const lockfile = await readLockfile(options.targetDir);
     const components = options.components || getAllUpdateComponents();
     await updateAllComponents(options.targetDir, components, updateCheck, customizations, options, result, config, lockfile);
-    await runFullUpdatePostProcessing(options, result, config);
+    await runFullUpdatePostProcessing(options, result, config, customizations);
     await regenerateLockfile(options.targetDir, result);
     checkAndInstallRtkAfterUpdate();
     checkAndInstallCodexAfterUpdate();
@@ -5603,19 +5961,31 @@ async function updateComponent(targetDir, component, customizations, options, co
   });
   return preservedFiles;
 }
-var ROOT_LEVEL_FILES = ["statusline.sh", "install-hooks.sh", "uninstall-hooks.sh"];
-async function syncRootLevelFiles(targetDir, options) {
+var ROOT_LEVEL_FILES = [
+  "statusline.sh",
+  "install-hooks.sh",
+  "uninstall-hooks.sh",
+  "schemas/tool-inputs.json"
+];
+async function syncRootLevelFiles(targetDir, options, customizations) {
   if (options.dryRun) {
-    return ROOT_LEVEL_FILES;
+    return { synced: ROOT_LEVEL_FILES, preserved: [] };
   }
   const fs = await import("node:fs/promises");
   const layout = getProviderLayout();
   const synced = [];
+  const preserved = [];
+  const preserveSet = new Set(customizations && !options.forceOverwriteAll ? customizations.preserveFiles : []);
   for (const fileName of ROOT_LEVEL_FILES) {
     const srcPath = resolveTemplatePath(join7(layout.rootDir, fileName));
     if (!await fileExists(srcPath)) {
       continue;
     }
+    const relPath = `${layout.rootDir}/${fileName}`;
+    if (preserveSet.has(relPath)) {
+      preserved.push(relPath);
+      continue;
+    }
     const destPath = join7(targetDir, layout.rootDir, fileName);
     await ensureDirectory(join7(destPath, ".."));
     await fs.copyFile(srcPath, destPath);
@@ -5627,7 +5997,7 @@ async function syncRootLevelFiles(targetDir, options) {
   if (synced.length > 0) {
     debug("update.root_files_synced", { files: synced.join(", ") });
   }
-  return synced;
+  return { synced, preserved };
 }
 async function removeDeprecatedFiles(targetDir, options) {
   const manifestPath = resolveTemplatePath("deprecated-files.json");