@stanco323/oh-my-claude-code 4.10.3

package/dist/installer/index.js

@@ -0,0 +1,1258 @@
+/**
+ * Installer Module
+ *
+ * Handles installation of OMC agents, commands, and configuration
+ * into the Claude Code config directory (~/.claude/).
+ *
+ * Cross-platform support via Node.js-based hook scripts (.mjs).
+ * Bash hook scripts were removed in v3.9.0.
+ */
+import { existsSync, mkdirSync, writeFileSync, readFileSync, copyFileSync, chmodSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+import { isWindows, MIN_NODE_VERSION, getHooksSettingsConfig, } from './hooks.js';
+import { getRuntimePackageVersion } from '../lib/version.js';
+import { getConfigDir } from '../utils/config-dir.js';
+import { resolveNodeBinary } from '../utils/resolve-node.js';
+import { syncUnifiedMcpRegistryTargets } from './mcp-registry.js';
+/** Claude Code configuration directory */
+export const CLAUDE_CONFIG_DIR = getConfigDir();
+export const AGENTS_DIR = join(CLAUDE_CONFIG_DIR, 'agents');
+export const COMMANDS_DIR = join(CLAUDE_CONFIG_DIR, 'commands');
+export const SKILLS_DIR = join(CLAUDE_CONFIG_DIR, 'skills');
+export const HOOKS_DIR = join(CLAUDE_CONFIG_DIR, 'hooks');
+export const HUD_DIR = join(CLAUDE_CONFIG_DIR, 'hud');
+export const SETTINGS_FILE = join(CLAUDE_CONFIG_DIR, 'settings.json');
+export const VERSION_FILE = join(CLAUDE_CONFIG_DIR, '.omc-version.json');
+/**
+ * Core commands - DISABLED for v3.0+
+ * All commands are now plugin-scoped skills managed by Claude Code.
+ * The installer no longer copies commands to ~/.claude/commands/
+ */
+export const CORE_COMMANDS = [];
+/** Current version */
+export const VERSION = getRuntimePackageVersion();
+const OMC_VERSION_MARKER_PATTERN = /<!-- OMC:VERSION:([^\s]+) -->/;
+/**
+ * Detects the newest installed OMC version from persistent metadata or
+ * existing CLAUDE.md markers so an older CLI package cannot overwrite a
+ * newer installation during `omc setup`.
+ */
+function isComparableVersion(version) {
+    return !!version && /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(version);
+}
+function compareVersions(a, b) {
+    const partsA = a.replace(/^v/, '').split('.').map(part => parseInt(part, 10) || 0);
+    const partsB = b.replace(/^v/, '').split('.').map(part => parseInt(part, 10) || 0);
+    const maxLength = Math.max(partsA.length, partsB.length);
+    for (let i = 0; i < maxLength; i++) {
+        const valueA = partsA[i] || 0;
+        const valueB = partsB[i] || 0;
+        if (valueA < valueB)
+            return -1;
+        if (valueA > valueB)
+            return 1;
+    }
+    return 0;
+}
+function extractOmcVersionMarker(content) {
+    const match = content.match(OMC_VERSION_MARKER_PATTERN);
+    return match?.[1] ?? null;
+}
+function getNewestInstalledVersionHint() {
+    const candidates = [];
+    if (existsSync(VERSION_FILE)) {
+        try {
+            const metadata = JSON.parse(readFileSync(VERSION_FILE, 'utf-8'));
+            if (isComparableVersion(metadata.version)) {
+                candidates.push(metadata.version);
+            }
+        }
+        catch {
+            // Ignore unreadable metadata and fall back to CLAUDE.md markers.
+        }
+    }
+    const claudeCandidates = [
+        join(CLAUDE_CONFIG_DIR, 'CLAUDE.md'),
+        join(homedir(), 'CLAUDE.md'),
+    ];
+    for (const candidatePath of claudeCandidates) {
+        if (!existsSync(candidatePath))
+            continue;
+        try {
+            const detectedVersion = extractOmcVersionMarker(readFileSync(candidatePath, 'utf-8'));
+            if (isComparableVersion(detectedVersion)) {
+                candidates.push(detectedVersion);
+            }
+        }
+        catch {
+            // Ignore unreadable CLAUDE.md candidates.
+        }
+    }
+    if (candidates.length === 0) {
+        return null;
+    }
+    return candidates.reduce((highest, candidate) => compareVersions(candidate, highest) > 0 ? candidate : highest);
+}
+/**
+ * Find a marker that appears at the start of a line (line-anchored).
+ * This prevents matching markers inside code blocks.
+ * @param content - The content to search in
+ * @param marker - The marker string to find
+ * @param fromEnd - If true, finds the LAST occurrence instead of first
+ * @returns The index of the marker, or -1 if not found
+ */
+function findLineAnchoredMarker(content, marker, fromEnd = false) {
+    // Escape special regex characters in marker
+    const escapedMarker = marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`^${escapedMarker}$`, 'gm');
+    if (fromEnd) {
+        // Find the last occurrence
+        let lastIndex = -1;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            lastIndex = match.index;
+        }
+        return lastIndex;
+    }
+    else {
+        // Find the first occurrence
+        const match = regex.exec(content);
+        return match ? match.index : -1;
+    }
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, '/').replace(/\/+$/, '');
+}
+function isDefaultClaudeConfigDirPath(configDir) {
+    return normalizePath(configDir) === normalizePath(join(homedir(), '.claude'));
+}
+function quoteShellArg(value) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function buildStatusLineCommand(nodeBin, hudScriptPath, findNodePath) {
+    if (isWindows()) {
+        return `${quoteShellArg(nodeBin)} ${quoteShellArg(hudScriptPath)}`;
+    }
+    if (isDefaultClaudeConfigDirPath(CLAUDE_CONFIG_DIR)) {
+        if (findNodePath) {
+            return 'sh $HOME/.claude/hud/find-node.sh $HOME/.claude/hud/omc-hud.mjs';
+        }
+        return 'node $HOME/.claude/hud/omc-hud.mjs';
+    }
+    const normalizedHudScriptPath = hudScriptPath.replace(/\\/g, '/');
+    if (findNodePath) {
+        return `sh ${quoteShellArg(findNodePath.replace(/\\/g, '/'))} ${quoteShellArg(normalizedHudScriptPath)}`;
+    }
+    return `node ${quoteShellArg(normalizedHudScriptPath)}`;
+}
+function createLineAnchoredMarkerRegex(marker, flags = 'gm') {
+    return new RegExp(`^${escapeRegex(marker)}$`, flags);
+}
+function stripGeneratedUserCustomizationHeaders(content) {
+    return content.replace(/^<!-- User customizations(?: \([^)]+\))? -->\r?\n?/gm, '');
+}
+function trimClaudeUserContent(content) {
+    if (content.trim().length === 0) {
+        return '';
+    }
+    return content
+        .replace(/^(?:[ \t]*\r?\n)+/, '')
+        .replace(/(?:\r?\n[ \t]*)+$/, '')
+        .replace(/(?:\r?\n){3,}/g, '\n\n');
+}
+/**
+ * Read hudEnabled from .omc-config.json without importing auto-update
+ * (avoids circular dependency since auto-update imports from installer)
+ */
+export function isHudEnabledInConfig() {
+    const configPath = join(CLAUDE_CONFIG_DIR, '.omc-config.json');
+    if (!existsSync(configPath)) {
+        return true; // default: enabled
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        // Only disable if explicitly set to false
+        return config.hudEnabled !== false;
+    }
+    catch {
+        return true; // default: enabled on parse error
+    }
+}
+/**
+ * Detect whether a statusLine config belongs to oh-my-claudecode.
+ *
+ * Checks the command string for known OMC HUD paths so that custom
+ * (non-OMC) statusLine configurations are preserved during forced
+ * updates/reconciliation.
+ *
+ * @param statusLine - The statusLine setting object from settings.json
+ * @returns true if the statusLine was set by OMC
+ */
+export function isOmcStatusLine(statusLine) {
+    if (!statusLine)
+        return false;
+    // Legacy string format (pre-v4.5): "~/.claude/hud/omc-hud.mjs"
+    if (typeof statusLine === 'string') {
+        return statusLine.includes('omc-hud');
+    }
+    // Current object format: { type: "command", command: "node ...omc-hud.mjs" }
+    if (typeof statusLine === 'object') {
+        const sl = statusLine;
+        if (typeof sl.command === 'string') {
+            return sl.command.includes('omc-hud');
+        }
+    }
+    return false;
+}
+/**
+ * Known OMC hook script filenames installed into .claude/hooks/.
+ * Must be kept in sync with HOOKS_SETTINGS_CONFIG_NODE command entries.
+ */
+const OMC_HOOK_FILENAMES = new Set([
+    'keyword-detector.mjs',
+    'session-start.mjs',
+    'pre-tool-use.mjs',
+    'post-tool-use.mjs',
+    'post-tool-use-failure.mjs',
+    'persistent-mode.mjs',
+    'code-simplifier.mjs',
+    'stop-continuation.mjs',
+]);
+/**
+ * Detect whether a hook command belongs to oh-my-claudecode.
+ *
+ * Recognition strategy (any match is sufficient):
+ * 1. Command path contains "omc" as a path/word segment (e.g. `omc-hook.mjs`, `/omc/`)
+ * 2. Command path contains "oh-my-claudecode"
+ * 3. Command references a known OMC hook filename inside .claude/hooks/
+ *
+ * @param command - The hook command string
+ * @returns true if the command belongs to OMC
+ */
+export function isOmcHook(command) {
+    const lowerCommand = command.toLowerCase();
+    // Match "omc" as a path segment or word boundary
+    // Matches: /omc/, /omc-, omc/, -omc, _omc, omc_
+    const omcPattern = /(?:^|[\/\\_-])omc(?:$|[\/\\_-])/;
+    const fullNamePattern = /oh-my-claudecode/;
+    if (omcPattern.test(lowerCommand) || fullNamePattern.test(lowerCommand)) {
+        return true;
+    }
+    // Check for known OMC hook filenames in .claude/hooks/ path.
+    // Handles both Unix (.claude/hooks/) and Windows (.claude\hooks\) paths.
+    const containsHooksDir = /hooks[/\\]/.test(lowerCommand);
+    const hookFilenameMatch = lowerCommand.match(/([a-z0-9-]+\.mjs)(?:$|["'\s])/);
+    if (containsHooksDir && hookFilenameMatch && OMC_HOOK_FILENAMES.has(hookFilenameMatch[1])) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if the current Node.js version meets the minimum requirement
+ */
+export function checkNodeVersion() {
+    const current = parseInt(process.versions.node.split('.')[0], 10);
+    return {
+        valid: current >= MIN_NODE_VERSION,
+        current,
+        required: MIN_NODE_VERSION
+    };
+}
+/**
+ * Check if Claude Code is installed
+ * Uses 'where' on Windows, 'which' on Unix
+ */
+export function isClaudeInstalled() {
+    try {
+        const command = isWindows() ? 'where claude' : 'which claude';
+        execSync(command, { encoding: 'utf-8', stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if we're running in Claude Code plugin context
+ *
+ * When installed as a plugin, we should NOT copy files to ~/.claude/
+ * because the plugin system already handles file access via ${CLAUDE_PLUGIN_ROOT}.
+ *
+ * Detection method:
+ * - Check if CLAUDE_PLUGIN_ROOT environment variable is set (primary method)
+ * - This env var is set by the Claude Code plugin system when running plugin hooks
+ *
+ * @returns true if running in plugin context, false otherwise
+ */
+export function isRunningAsPlugin() {
+    // Check for CLAUDE_PLUGIN_ROOT env var (set by plugin system)
+    // This is the most reliable indicator that we're running as a plugin
+    return !!process.env.CLAUDE_PLUGIN_ROOT;
+}
+/**
+ * Check if we're running as a project-scoped plugin (not global)
+ *
+ * Project-scoped plugins are installed in the project's .claude/plugins/ directory,
+ * while global plugins are installed in ~/.claude/plugins/.
+ *
+ * When project-scoped, we should NOT modify global settings (like ~/.claude/settings.json)
+ * because the user explicitly chose project-level installation.
+ *
+ * @returns true if running as a project-scoped plugin, false otherwise
+ */
+export function isProjectScopedPlugin() {
+    const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
+    if (!pluginRoot) {
+        return false;
+    }
+    // Global plugins are installed under ~/.claude/plugins/
+    const globalPluginBase = join(CLAUDE_CONFIG_DIR, 'plugins');
+    // If the plugin root is NOT under the global plugin directory, it's project-scoped
+    // Normalize paths for comparison (resolve symlinks, trailing slashes, etc.)
+    const normalizedPluginRoot = pluginRoot.replace(/\\/g, '/').replace(/\/$/, '');
+    const normalizedGlobalBase = globalPluginBase.replace(/\\/g, '/').replace(/\/$/, '');
+    return !normalizedPluginRoot.startsWith(normalizedGlobalBase);
+}
+const STANDALONE_HOOK_TEMPLATE_FILES = [
+    'keyword-detector.mjs',
+    'session-start.mjs',
+    'pre-tool-use.mjs',
+    'post-tool-use.mjs',
+    'post-tool-use-failure.mjs',
+    'persistent-mode.mjs',
+    'code-simplifier.mjs',
+];
+function ensureStandaloneHookScripts(log) {
+    const packageDir = getPackageDir();
+    const templatesDir = join(packageDir, 'templates', 'hooks');
+    if (!existsSync(HOOKS_DIR)) {
+        mkdirSync(HOOKS_DIR, { recursive: true });
+    }
+    for (const filename of STANDALONE_HOOK_TEMPLATE_FILES) {
+        const sourcePath = join(templatesDir, filename);
+        const targetPath = join(HOOKS_DIR, filename);
+        copyFileSync(sourcePath, targetPath);
+        if (!isWindows()) {
+            chmodSync(targetPath, 0o755);
+        }
+    }
+    if (!isWindows()) {
+        const findNodeSrc = join(packageDir, 'scripts', 'find-node.sh');
+        const findNodeDest = join(HOOKS_DIR, 'find-node.sh');
+        copyFileSync(findNodeSrc, findNodeDest);
+        chmodSync(findNodeDest, 0o755);
+    }
+    log('  Installed standalone hook scripts');
+}
+function mergeHookGroups(eventType, existingGroups, newOmcGroups, options, log, result) {
+    const nonOmcGroups = existingGroups.filter(group => group.hooks.some(h => h.type === 'command' && !isOmcHook(h.command)));
+    const hasNonOmcHook = nonOmcGroups.length > 0;
+    const nonOmcCommand = hasNonOmcHook
+        ? nonOmcGroups[0].hooks.find(h => h.type === 'command' && !isOmcHook(h.command))?.command ?? ''
+        : '';
+    if (options.forceHooks && !options.allowPluginHookRefresh) {
+        if (hasNonOmcHook) {
+            log(`  Warning: Overwriting non-OMC ${eventType} hook with --force-hooks: ${nonOmcCommand}`);
+            result.hookConflicts.push({ eventType, existingCommand: nonOmcCommand });
+        }
+        log(`  Updated ${eventType} hook (--force-hooks)`);
+        return newOmcGroups;
+    }
+    if (options.force) {
+        if (hasNonOmcHook) {
+            log(`  Merged ${eventType} hooks (updated OMC hooks, preserved non-OMC hook: ${nonOmcCommand})`);
+            result.hookConflicts.push({ eventType, existingCommand: nonOmcCommand });
+        }
+        else {
+            log(`  Updated ${eventType} hook (--force)`);
+        }
+        return [...nonOmcGroups, ...newOmcGroups];
+    }
+    if (hasNonOmcHook) {
+        log(`  Warning: ${eventType} hook has non-OMC hook. Skipping. Use --force-hooks to override.`);
+        result.hookConflicts.push({ eventType, existingCommand: nonOmcCommand });
+    }
+    else {
+        log(`  ${eventType} hook already configured, skipping`);
+    }
+    return existingGroups;
+}
+function directoryHasMarkdownFiles(directory) {
+    if (!existsSync(directory)) {
+        return false;
+    }
+    try {
+        return readdirSync(directory).some(file => file.endsWith('.md'));
+    }
+    catch {
+        return false;
+    }
+}
+export function getInstalledOmcPluginRoots() {
+    const pluginRoots = new Set();
+    const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT?.trim();
+    if (pluginRoot) {
+        pluginRoots.add(pluginRoot);
+    }
+    const installedPluginsPath = join(CLAUDE_CONFIG_DIR, 'plugins', 'installed_plugins.json');
+    if (!existsSync(installedPluginsPath)) {
+        return Array.from(pluginRoots);
+    }
+    try {
+        const raw = JSON.parse(readFileSync(installedPluginsPath, 'utf-8'));
+        const plugins = raw.plugins ?? raw;
+        for (const [pluginId, entries] of Object.entries(plugins)) {
+            if (!pluginId.toLowerCase().includes('oh-my-claudecode') || !Array.isArray(entries)) {
+                continue;
+            }
+            for (const entry of entries) {
+                if (typeof entry?.installPath === 'string' && entry.installPath.trim().length > 0) {
+                    pluginRoots.add(entry.installPath.trim());
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore unreadable plugin registry and fall back to env-based detection.
+    }
+    return Array.from(pluginRoots);
+}
+/**
+ * Detect whether an installed Claude Code plugin already provides OMC agent
+ * markdown files, so the legacy ~/.claude/agents copy can be skipped.
+ */
+export function hasPluginProvidedAgentFiles() {
+    return getInstalledOmcPluginRoots().some(pluginRoot => directoryHasMarkdownFiles(join(pluginRoot, 'agents')));
+}
+/**
+ * Get the package root directory.
+ * Works for both ESM (dist/installer/) and CJS bundles (bridge/).
+ * When esbuild bundles to CJS, import.meta is replaced with {} so we
+ * fall back to __dirname which is natively available in CJS.
+ */
+function getPackageDir() {
+    const resolveFromDir = (baseDir) => {
+        const candidates = [
+            join(baseDir, '..'),
+            join(baseDir, '..', '..'),
+            join(baseDir, '..', '..', '..'),
+        ];
+        for (const candidate of candidates) {
+            if (existsSync(join(candidate, 'package.json'))) {
+                return candidate;
+            }
+        }
+        return candidates[0];
+    };
+    // CJS bundle path (bridge/cli.cjs) and test/dev source imports.
+    if (typeof __dirname !== 'undefined') {
+        return resolveFromDir(__dirname);
+    }
+    // ESM path (works in dev via ts/dist)
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const currentDir = dirname(__filename);
+        return resolveFromDir(currentDir);
+    }
+    catch {
+        // import.meta.url unavailable — last resort
+        return process.cwd();
+    }
+}
+export function getRuntimePackageRoot() {
+    return getPackageDir();
+}
+/**
+ * Load agent definitions from /agents/*.md files
+ */
+function loadAgentDefinitions() {
+    const agentsDir = join(getPackageDir(), 'agents');
+    const definitions = {};
+    if (!existsSync(agentsDir)) {
+        console.error(`FATAL: agents directory not found: ${agentsDir}`);
+        process.exit(1);
+    }
+    for (const file of readdirSync(agentsDir)) {
+        if (file.endsWith('.md')) {
+            definitions[file] = readFileSync(join(agentsDir, file), 'utf-8');
+        }
+    }
+    return definitions;
+}
+/**
+ * Load command definitions from /commands/*.md files
+ *
+ * NOTE: The commands/ directory was removed in v4.1.16 (#582).
+ * All commands are now plugin-scoped skills. This function returns
+ * an empty object for backward compatibility.
+ */
+function loadCommandDefinitions() {
+    const commandsDir = join(getPackageDir(), 'commands');
+    if (!existsSync(commandsDir)) {
+        return {};
+    }
+    const definitions = {};
+    for (const file of readdirSync(commandsDir)) {
+        if (file.endsWith('.md')) {
+            definitions[file] = readFileSync(join(commandsDir, file), 'utf-8');
+        }
+    }
+    return definitions;
+}
+/**
+ * Load CLAUDE.md content from /docs/CLAUDE.md
+ */
+function loadBundledSkillContent(skillName) {
+    const skillPath = join(getPackageDir(), 'skills', skillName, 'SKILL.md');
+    if (!existsSync(skillPath)) {
+        return null;
+    }
+    return readFileSync(skillPath, 'utf-8');
+}
+function loadClaudeMdContent() {
+    const claudeMdPath = join(getPackageDir(), 'docs', 'CLAUDE.md');
+    if (!existsSync(claudeMdPath)) {
+        console.error(`FATAL: CLAUDE.md not found: ${claudeMdPath}`);
+        process.exit(1);
+    }
+    return readFileSync(claudeMdPath, 'utf-8');
+}
+/**
+ * Extract the embedded OMC version from a CLAUDE.md file.
+ *
+ * Primary source of truth is the injected `<!-- OMC:VERSION:x.y.z -->` marker.
+ * Falls back to legacy headings that may include a version string inline.
+ */
+export function extractOmcVersionFromClaudeMd(content) {
+    const versionMarkerMatch = content.match(/<!--\s*OMC:VERSION:([^\s]+)\s*-->/i);
+    if (versionMarkerMatch?.[1]) {
+        const markerVersion = versionMarkerMatch[1].trim();
+        return markerVersion.startsWith('v') ? markerVersion : `v${markerVersion}`;
+    }
+    const headingMatch = content.match(/^#\s+oh-my-claudecode.*?\b(v?\d+\.\d+\.\d+(?:[-+][^\s]+)?)\b/m);
+    if (headingMatch?.[1]) {
+        const headingVersion = headingMatch[1].trim();
+        return headingVersion.startsWith('v') ? headingVersion : `v${headingVersion}`;
+    }
+    return null;
+}
+/**
+ * Keep persisted setup metadata in sync with the installed OMC runtime version.
+ *
+ * This intentionally updates only already-configured users by default so
+ * installer/reconciliation flows do not accidentally mark fresh installs as if
+ * the interactive setup wizard had been completed.
+ */
+export function syncPersistedSetupVersion(options) {
+    const configPath = options?.configPath ?? join(CLAUDE_CONFIG_DIR, '.omc-config.json');
+    let config = {};
+    if (existsSync(configPath)) {
+        const rawConfig = readFileSync(configPath, 'utf-8').trim();
+        if (rawConfig.length > 0) {
+            config = JSON.parse(rawConfig);
+        }
+    }
+    const onlyIfConfigured = options?.onlyIfConfigured ?? true;
+    const isConfigured = typeof config.setupCompleted === 'string' || typeof config.setupVersion === 'string';
+    if (onlyIfConfigured && !isConfigured) {
+        return false;
+    }
+    let detectedVersion = options?.version?.trim();
+    if (!detectedVersion) {
+        const claudeMdPath = options?.claudeMdPath ?? join(CLAUDE_CONFIG_DIR, 'CLAUDE.md');
+        if (existsSync(claudeMdPath)) {
+            detectedVersion = extractOmcVersionFromClaudeMd(readFileSync(claudeMdPath, 'utf-8')) ?? undefined;
+        }
+    }
+    const normalizedVersion = (() => {
+        const candidate = (detectedVersion && detectedVersion !== 'unknown') ? detectedVersion : VERSION;
+        return candidate.startsWith('v') ? candidate : `v${candidate}`;
+    })();
+    if (config.setupVersion === normalizedVersion) {
+        return false;
+    }
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, JSON.stringify({ ...config, setupVersion: normalizedVersion }, null, 2));
+    return true;
+}
+/**
+ * Merge OMC content into existing CLAUDE.md using markers
+ * @param existingContent - Existing CLAUDE.md content (null if file doesn't exist)
+ * @param omcContent - New OMC content to inject
+ * @returns Merged content with markers
+ */
+export function mergeClaudeMd(existingContent, omcContent, version) {
+    const START_MARKER = '<!-- OMC:START -->';
+    const END_MARKER = '<!-- OMC:END -->';
+    const USER_CUSTOMIZATIONS = '<!-- User customizations -->';
+    const OMC_BLOCK_PATTERN = new RegExp(`^${escapeRegex(START_MARKER)}\\r?\\n[\\s\\S]*?^${escapeRegex(END_MARKER)}(?:\\r?\\n)?`, 'gm');
+    const markerStartRegex = createLineAnchoredMarkerRegex(START_MARKER);
+    const markerEndRegex = createLineAnchoredMarkerRegex(END_MARKER);
+    // Idempotency guard: strip markers from omcContent if already present
+    // This handles the case where docs/CLAUDE.md ships with markers
+    let cleanOmcContent = omcContent;
+    const omcStartIdx = findLineAnchoredMarker(omcContent, START_MARKER);
+    const omcEndIdx = findLineAnchoredMarker(omcContent, END_MARKER, true);
+    if (omcStartIdx !== -1 && omcEndIdx !== -1 && omcStartIdx < omcEndIdx) {
+        // Extract content between markers, trimming any surrounding whitespace
+        cleanOmcContent = omcContent
+            .substring(omcStartIdx + START_MARKER.length, omcEndIdx)
+            .trim();
+    }
+    // Strip any existing version marker from content and inject current version
+    cleanOmcContent = cleanOmcContent.replace(/<!-- OMC:VERSION:[^\s]*? -->\n?/, '');
+    const versionMarker = version ? `<!-- OMC:VERSION:${version} -->\n` : '';
+    // Case 1: No existing content - wrap omcContent in markers
+    if (!existingContent) {
+        return `${START_MARKER}\n${versionMarker}${cleanOmcContent}\n${END_MARKER}\n`;
+    }
+    const strippedExistingContent = existingContent.replace(OMC_BLOCK_PATTERN, '');
+    const hasResidualStartMarker = markerStartRegex.test(strippedExistingContent);
+    const hasResidualEndMarker = markerEndRegex.test(strippedExistingContent);
+    // Case 2: Corrupted markers (unmatched markers remain after removing complete blocks)
+    if (hasResidualStartMarker || hasResidualEndMarker) {
+        // Handle corrupted state - backup will be created by caller
+        // Strip unmatched OMC markers from recovered content to prevent unbounded
+        // growth on repeated calls (each call would re-detect corruption and append again)
+        const recoveredContent = strippedExistingContent
+            .replace(markerStartRegex, '')
+            .replace(markerEndRegex, '')
+            .trim();
+        return `${START_MARKER}\n${versionMarker}${cleanOmcContent}\n${END_MARKER}\n\n<!-- User customizations (recovered from corrupted markers) -->\n${recoveredContent}`;
+    }
+    const preservedUserContent = trimClaudeUserContent(stripGeneratedUserCustomizationHeaders(strippedExistingContent));
+    if (!preservedUserContent) {
+        return `${START_MARKER}\n${versionMarker}${cleanOmcContent}\n${END_MARKER}\n`;
+    }
+    // Case 3: Preserve only user-authored content that lives outside OMC markers
+    return `${START_MARKER}\n${versionMarker}${cleanOmcContent}\n${END_MARKER}\n\n${USER_CUSTOMIZATIONS}\n${preservedUserContent}`;
+}
+/**
+ * Install OMC agents, commands, skills, and hooks
+ */
+export function install(options = {}) {
+    const result = {
+        success: false,
+        message: '',
+        installedAgents: [],
+        installedCommands: [],
+        installedSkills: [],
+        hooksConfigured: false,
+        hookConflicts: [],
+        errors: []
+    };
+    const log = (msg) => {
+        if (options.verbose) {
+            console.log(msg);
+        }
+    };
+    // Check Node.js version (required for Node.js hooks)
+    const nodeCheck = checkNodeVersion();
+    if (!nodeCheck.valid) {
+        result.errors.push(`Node.js ${nodeCheck.required}+ is required. Found: ${nodeCheck.current}`);
+        result.message = `Installation failed: Node.js ${nodeCheck.required}+ required`;
+        return result;
+    }
+    const targetVersion = options.version ?? VERSION;
+    const installedVersionHint = getNewestInstalledVersionHint();
+    if (isComparableVersion(targetVersion)
+        && isComparableVersion(installedVersionHint)
+        && compareVersions(targetVersion, installedVersionHint) < 0) {
+        const message = `Skipping install: installed OMC ${installedVersionHint} is newer than CLI package ${targetVersion}. Run "omc update" to update the CLI package, then rerun "omc setup".`;
+        log(message);
+        result.success = true;
+        result.message = message;
+        return result;
+    }
+    // Log platform info
+    log(`Platform: ${process.platform} (Node.js hooks)`);
+    // Check if running as a plugin
+    const runningAsPlugin = isRunningAsPlugin();
+    const projectScoped = isProjectScopedPlugin();
+    const pluginProvidesAgentFiles = hasPluginProvidedAgentFiles();
+    const shouldInstallLegacyAgents = !runningAsPlugin && !pluginProvidesAgentFiles;
+    const allowPluginHookRefresh = runningAsPlugin && options.refreshHooksInPlugin && !projectScoped;
+    if (runningAsPlugin) {
+        log('Detected Claude Code plugin context - skipping agent/command file installation');
+        log('Plugin files are managed by Claude Code plugin system');
+        if (projectScoped) {
+            log('Detected project-scoped plugin - skipping global HUD/settings modifications');
+        }
+        else {
+            log('Will still install HUD statusline...');
+            if (allowPluginHookRefresh) {
+                log('Will refresh global hooks/settings for plugin runtime reconciliation');
+            }
+        }
+        // Don't return early - continue to install HUD (unless project-scoped)
+    }
+    else if (pluginProvidesAgentFiles) {
+        log('Detected installed OMC plugin agent definitions - skipping legacy ~/.claude/agents sync');
+    }
+    // Check Claude installation (optional)
+    if (!options.skipClaudeCheck && !isClaudeInstalled()) {
+        log('Warning: Claude Code not found. Install it first:');
+        if (isWindows()) {
+            log('  Visit https://docs.anthropic.com/claude-code for Windows installation');
+        }
+        else {
+            log('  curl -fsSL https://claude.ai/install.sh | bash');
+        }
+        // Continue anyway - user might be installing ahead of time
+    }
+    try {
+        // Ensure base config directory exists (skip for project-scoped plugins)
+        if (!projectScoped && !existsSync(CLAUDE_CONFIG_DIR)) {
+            mkdirSync(CLAUDE_CONFIG_DIR, { recursive: true });
+        }
+        // Skip agent/command/hook file installation when running as plugin
+        // Plugin system handles these via ${CLAUDE_PLUGIN_ROOT}
+        if (!runningAsPlugin) {
+            // Create directories
+            log('Creating directories...');
+            if (shouldInstallLegacyAgents && !existsSync(AGENTS_DIR)) {
+                mkdirSync(AGENTS_DIR, { recursive: true });
+            }
+            // NOTE: COMMANDS_DIR creation removed - commands/ deprecated in v4.1.16 (#582)
+            if (!existsSync(SKILLS_DIR)) {
+                mkdirSync(SKILLS_DIR, { recursive: true });
+            }
+            if (!existsSync(HOOKS_DIR)) {
+                mkdirSync(HOOKS_DIR, { recursive: true });
+            }
+            // Install agents
+            if (shouldInstallLegacyAgents) {
+                log('Installing agent definitions...');
+                for (const [filename, content] of Object.entries(loadAgentDefinitions())) {
+                    const filepath = join(AGENTS_DIR, filename);
+                    if (existsSync(filepath) && !options.force) {
+                        log(`  Skipping ${filename} (already exists)`);
+                    }
+                    else {
+                        writeFileSync(filepath, content);
+                        result.installedAgents.push(filename);
+                        log(`  Installed ${filename}`);
+                    }
+                }
+            }
+            else {
+                log('Skipping legacy agent file installation (plugin-provided agents are available)');
+            }
+            // Skip command installation - all commands are now plugin-scoped skills
+            // Commands are accessible via the plugin system (${CLAUDE_PLUGIN_ROOT}/commands/)
+            // and are managed by Claude Code's skill discovery mechanism.
+            log('Skipping slash command installation (all commands are now plugin-scoped skills)');
+            // The command installation loop is disabled - CORE_COMMANDS is empty
+            for (const [filename, content] of Object.entries(loadCommandDefinitions())) {
+                // All commands are skipped - they're managed by the plugin system
+                if (!CORE_COMMANDS.includes(filename)) {
+                    log(`  Skipping ${filename} (plugin-scoped skill)`);
+                    continue;
+                }
+                const filepath = join(COMMANDS_DIR, filename);
+                // Create command directory if needed (only for nested paths like 'ultrawork/skill.md')
+                // Handle both Unix (/) and Windows (\) path separators
+                if (filename.includes('/') || filename.includes('\\')) {
+                    const segments = filename.split(/[/\\]/);
+                    const commandDir = join(COMMANDS_DIR, segments[0]);
+                    if (!existsSync(commandDir)) {
+                        mkdirSync(commandDir, { recursive: true });
+                    }
+                }
+                if (existsSync(filepath) && !options.force) {
+                    log(`  Skipping ${filename} (already exists)`);
+                }
+                else {
+                    writeFileSync(filepath, content);
+                    result.installedCommands.push(filename);
+                    log(`  Installed ${filename}`);
+                }
+            }
+            // NOTE: SKILL_DEFINITIONS removed - skills now only installed via COMMAND_DEFINITIONS
+            // to avoid duplicate entries in Claude Code's available skills list
+            const omcReferenceSkillContent = loadBundledSkillContent('omc-reference');
+            if (omcReferenceSkillContent) {
+                const omcReferenceDir = join(SKILLS_DIR, 'omc-reference');
+                const omcReferencePath = join(omcReferenceDir, 'SKILL.md');
+                if (!existsSync(omcReferenceDir)) {
+                    mkdirSync(omcReferenceDir, { recursive: true });
+                }
+                if (existsSync(omcReferencePath) && !options.force) {
+                    log('  Skipping omc-reference/SKILL.md (already exists)');
+                }
+                else {
+                    writeFileSync(omcReferencePath, omcReferenceSkillContent);
+                    result.installedSkills.push('omc-reference/SKILL.md');
+                    log('  Installed omc-reference/SKILL.md');
+                }
+            }
+            // Standalone installs still need ~/.claude/hooks/* scripts because their
+            // settings.json hook entries execute those local paths directly. Plugin installs
+            // keep using hooks/hooks.json + scripts/ under CLAUDE_PLUGIN_ROOT.
+            ensureStandaloneHookScripts(log);
+            result.hooksConfigured = true; // Will be set properly after consolidated settings.json write
+        }
+        else {
+            log('Skipping agent/command/hook files (managed by plugin system)');
+        }
+        // Install CLAUDE.md with merge support.
+        // This runs regardless of plugin context so that `omc update` (which re-execs
+        // as `update-reconcile` with CLAUDE_PLUGIN_ROOT still set) always keeps the
+        // version marker and OMC instructions in ~/.claude/CLAUDE.md up to date.
+        // Skipped only for project-scoped plugins to avoid mutating global config.
+        if (!projectScoped) {
+            const claudeMdPath = join(CLAUDE_CONFIG_DIR, 'CLAUDE.md');
+            const homeMdPath = join(homedir(), 'CLAUDE.md');
+            if (!existsSync(homeMdPath)) {
+                const omcContent = loadClaudeMdContent();
+                // Read existing content if it exists
+                let existingContent = null;
+                if (existsSync(claudeMdPath)) {
+                    existingContent = readFileSync(claudeMdPath, 'utf-8');
+                }
+                // Always create backup before modification (if file exists)
+                if (existingContent !== null) {
+                    const timestamp = new Date().toISOString().replace(/:/g, '-').split('.')[0]; // YYYY-MM-DDTHH-MM-SS
+                    const backupPath = join(CLAUDE_CONFIG_DIR, `CLAUDE.md.backup.${timestamp}`);
+                    writeFileSync(backupPath, existingContent);
+                    log(`Backed up existing CLAUDE.md to ${backupPath}`);
+                }
+                // Merge OMC content with existing content
+                const mergedContent = mergeClaudeMd(existingContent, omcContent, targetVersion);
+                writeFileSync(claudeMdPath, mergedContent);
+                if (existingContent) {
+                    log('Updated CLAUDE.md (merged with existing content)');
+                }
+                else {
+                    log('Created CLAUDE.md');
+                }
+            }
+            else {
+                log('CLAUDE.md exists in home directory, skipping');
+            }
+        }
+        // Install HUD statusline (skip for project-scoped plugins, skipHud option, or hudEnabled config)
+        let hudScriptPath = null;
+        const hudDisabledByOption = options.skipHud === true;
+        const hudDisabledByConfig = !isHudEnabledInConfig();
+        const skipHud = projectScoped || hudDisabledByOption || hudDisabledByConfig;
+        if (projectScoped) {
+            log('Skipping HUD statusline (project-scoped plugin should not modify global settings)');
+        }
+        else if (hudDisabledByOption) {
+            log('Skipping HUD statusline (user opted out)');
+        }
+        else if (hudDisabledByConfig) {
+            log('Skipping HUD statusline (hudEnabled is false in .omc-config.json)');
+        }
+        else {
+            log('Installing HUD statusline...');
+        }
+        if (!skipHud)
+            try {
+                if (!existsSync(HUD_DIR)) {
+                    mkdirSync(HUD_DIR, { recursive: true });
+                }
+                // Build the HUD script content (compiled from src/hud/index.ts)
+                // Create a wrapper that checks multiple locations for the HUD module
+                hudScriptPath = join(HUD_DIR, 'omc-hud.mjs').replace(/\\/g, '/');
+                const hudScriptLines = [
+                    '#!/usr/bin/env node',
+                    '/**',
+                    ' * OMC HUD - Statusline Script',
+                    ' * Wrapper that imports from dev paths, plugin cache, or npm package',
+                    ' */',
+                    '',
+                    'import { execFileSync } from "node:child_process";',
+                    'import { existsSync, readdirSync } from "node:fs";',
+                    'import { createRequire } from "node:module";',
+                    'import { homedir } from "node:os";',
+                    'import { dirname, join, resolve } from "node:path";',
+                    'import { pathToFileURL } from "node:url";',
+                    '',
+                    'function uniquePaths(paths) {',
+                    '  return [...new Set(paths.filter(Boolean).map((candidate) => resolve(candidate)))];',
+                    '}',
+                    '',
+                    'function getGlobalNodeModuleRoots() {',
+                    '  const roots = [];',
+                    '  const addPrefixRoots = (prefix) => {',
+                    '    if (!prefix) return;',
+                    '    if (process.platform === "win32") {',
+                    '      roots.push(join(prefix, "node_modules"));',
+                    '      return;',
+                    '    }',
+                    '    roots.push(join(prefix, "lib", "node_modules"));',
+                    '    roots.push(join(prefix, "node_modules"));',
+                    '  };',
+                    '',
+                    '  addPrefixRoots(process.env.npm_config_prefix);',
+                    '  addPrefixRoots(process.env.PREFIX);',
+                    '',
+                    '  const nodeBinDir = dirname(process.execPath);',
+                    '  roots.push(join(nodeBinDir, "node_modules"));',
+                    '  roots.push(join(nodeBinDir, "..", "node_modules"));',
+                    '  roots.push(join(nodeBinDir, "..", "lib", "node_modules"));',
+                    '',
+                    '  if (process.platform === "win32" && process.env.APPDATA) {',
+                    '    roots.push(join(process.env.APPDATA, "npm", "node_modules"));',
+                    '  }',
+                    '',
+                    '  try {',
+                    '    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";',
+                    '    const npmRoot = String(execFileSync(npmCommand, ["root", "-g"], {',
+                    '      encoding: "utf8",',
+                    '      stdio: ["ignore", "pipe", "ignore"],',
+                    '      timeout: 1500,',
+                    '    })).trim();',
+                    '    if (npmRoot) roots.unshift(npmRoot);',
+                    '  } catch { /* continue */ }',
+                    '',
+                    '  return uniquePaths(roots);',
+                    '}',
+                    '',
+                    'async function importHudPackage(hudPackage) {',
+                    '  try {',
+                    '    const wrapperRequire = createRequire(import.meta.url);',
+                    '    const resolvedHudPath = wrapperRequire.resolve(hudPackage);',
+                    '    await import(pathToFileURL(resolvedHudPath).href);',
+                    '    return true;',
+                    '  } catch { /* continue */ }',
+                    '',
+                    '  try {',
+                    '    const cwdRequire = createRequire(join(process.cwd(), "__omc_hud__.cjs"));',
+                    '    const resolvedHudPath = cwdRequire.resolve(hudPackage);',
+                    '    await import(pathToFileURL(resolvedHudPath).href);',
+                    '    return true;',
+                    '  } catch { /* continue */ }',
+                    '',
+                    '  for (const nodeModulesRoot of getGlobalNodeModuleRoots()) {',
+                    '    const resolvedHudPath = join(nodeModulesRoot, hudPackage);',
+                    '    if (!existsSync(resolvedHudPath)) continue;',
+                    '    try {',
+                    '      await import(pathToFileURL(resolvedHudPath).href);',
+                    '      return true;',
+                    '    } catch { /* continue */ }',
+                    '  }',
+                    '',
+                    '  return false;',
+                    '}',
+                    '',
+                    'async function main() {',
+                    '  const home = homedir();',
+                    '  let pluginCacheVersion = null;',
+                    '  let pluginCacheDir = null;',
+                    '  ',
+                    '  // 1. Development paths (only when OMC_DEV=1)',
+                    '  if (process.env.OMC_DEV === "1") {',
+                    '    const devPaths = [',
+                    '      join(home, "Workspace/oh-my-claudecode/dist/hud/index.js"),',
+                    '      join(home, "workspace/oh-my-claudecode/dist/hud/index.js"),',
+                    '      join(home, "projects/oh-my-claudecode/dist/hud/index.js"),',
+                    '    ];',
+                    '    ',
+                    '    for (const devPath of devPaths) {',
+                    '      if (existsSync(devPath)) {',
+                    '        try {',
+                    '          await import(pathToFileURL(devPath).href);',
+                    '          return;',
+                    '        } catch { /* continue */ }',
+                    '      }',
+                    '    }',
+                    '  }',
+                    '  ',
+                    '  // 2. Plugin cache (for production installs)',
+                    '  // Respect CLAUDE_CONFIG_DIR so installs under a custom config dir are found',
+                    '  const configDir = process.env.CLAUDE_CONFIG_DIR || join(home, ".claude");',
+                    '  const pluginCacheBase = join(configDir, "plugins", "cache", "omc", "oh-my-claudecode");',
+                    '  if (existsSync(pluginCacheBase)) {',
+                    '    try {',
+                    '      const versions = readdirSync(pluginCacheBase);',
+                    '      if (versions.length > 0) {',
+                    '        const sortedVersions = versions.sort((a, b) => a.localeCompare(b, undefined, { numeric: true })).reverse();',
+                    '        const latestInstalledVersion = sortedVersions[0];',
+                    '        pluginCacheVersion = latestInstalledVersion;',
+                    '        pluginCacheDir = join(pluginCacheBase, latestInstalledVersion);',
+                    '        ',
+                    '        // Filter to only versions with built dist/hud/index.js',
+                    '        // This prevents picking an unbuilt new version after plugin update',
+                    '        const builtVersions = sortedVersions.filter(version => {',
+                    '          const pluginPath = join(pluginCacheBase, version, "dist/hud/index.js");',
+                    '          return existsSync(pluginPath);',
+                    '        });',
+                    '        ',
+                    '        if (builtVersions.length > 0) {',
+                    '          const latestVersion = builtVersions[0];',
+                    '          pluginCacheVersion = latestVersion;',
+                    '          pluginCacheDir = join(pluginCacheBase, latestVersion);',
+                    '          const pluginPath = join(pluginCacheDir, "dist/hud/index.js");',
+                    '          await import(pathToFileURL(pluginPath).href);',
+                    '          return;',
+                    '        }',
+                    '      }',
+                    '    } catch { /* continue */ }',
+                    '  }',
+                    '  ',
+                    '  // 3. Marketplace clone (for marketplace installs without a populated cache)',
+                    '  const marketplaceHudPath = join(configDir, "plugins", "marketplaces", "omc", "dist/hud/index.js");',
+                    '  if (existsSync(marketplaceHudPath)) {',
+                    '    try {',
+                    '      await import(pathToFileURL(marketplaceHudPath).href);',
+                    '      return;',
+                    '    } catch { /* continue */ }',
+                    '  }',
+                    '  ',
+                    '  // 4. npm package (current project, global install, or branded fallback)',
+                    '  const npmHudPackages = [',
+                    '    "oh-my-claude-sisyphus/dist/hud/index.js",',
+                    '    "oh-my-claudecode/dist/hud/index.js",',
+                    '  ];',
+                    '  for (const hudPackage of npmHudPackages) {',
+                    '    if (await importHudPackage(hudPackage)) {',
+                    '      return;',
+                    '    }',
+                    '  }',
+                    '  ',
+                    '  // 5. Fallback: provide detailed error message with fix instructions',
+                    '  if (pluginCacheDir && existsSync(pluginCacheDir)) {',
+                    '    // Plugin exists but HUD could not be loaded',
+                    '    const distDir = join(pluginCacheDir, "dist");',
+                    '    if (!existsSync(distDir)) {',
+                    '      console.log(`[OMC HUD] Plugin installed but not built. Run: cd "${pluginCacheDir}" && npm install && npm run build`);',
+                    '    } else {',
+                    '      console.log(`[OMC HUD] Plugin HUD load failed. Run: cd "${pluginCacheDir}" && npm install && npm run build`);',
+                    '    }',
+                    '  } else if (existsSync(pluginCacheBase)) {',
+                    '    // Plugin cache directory exists but no versions',
+                    '    console.log(`[OMC HUD] Plugin cache found but no versions installed. Run: /oh-my-claudecode:omc-setup`);',
+                    '  } else {',
+                    '    // No plugin installation found at all',
+                    '    console.log("[OMC HUD] Plugin not installed. Run: /oh-my-claudecode:omc-setup");',
+                    '  }',
+                    '}',
+                    '',
+                    'main();',
+                ];
+                const hudScript = hudScriptLines.join('\n');
+                writeFileSync(hudScriptPath, hudScript);
+                if (!isWindows()) {
+                    chmodSync(hudScriptPath, 0o755);
+                }
+                log('  Installed omc-hud.mjs');
+            }
+            catch (_e) {
+                log('  Warning: Could not install HUD statusline script (non-fatal)');
+                hudScriptPath = null;
+            }
+        // Consolidated settings.json write (atomic: read once, modify, write once)
+        // Skip for project-scoped plugins to avoid affecting global settings
+        if (projectScoped) {
+            log('Skipping settings.json configuration (project-scoped plugin)');
+        }
+        else {
+            log('Configuring settings.json...');
+        }
+        if (!projectScoped)
+            try {
+                let existingSettings = {};
+                if (existsSync(SETTINGS_FILE)) {
+                    const settingsContent = readFileSync(SETTINGS_FILE, 'utf-8');
+                    existingSettings = JSON.parse(settingsContent);
+                }
+                // 1. Remove legacy ~/.claude/hooks/ entries from settings.json, then restore
+                // standalone settings hooks or refresh plugin-safe merged hooks as needed.
+                {
+                    const existingHooks = { ...(existingSettings.hooks || {}) };
+                    let legacyRemoved = 0;
+                    for (const [eventType, groups] of Object.entries(existingHooks)) {
+                        const groupList = groups;
+                        const filtered = groupList.filter(group => {
+                            const isLegacy = group.hooks.every(h => h.type === 'command'
+                                && (h.command.includes('/.claude/hooks/') || h.command.includes('\\.claude\\hooks\\'))
+                                && isOmcHook(h.command));
+                            if (isLegacy)
+                                legacyRemoved++;
+                            return !isLegacy;
+                        });
+                        if (filtered.length === 0) {
+                            delete existingHooks[eventType];
+                        }
+                        else {
+                            existingHooks[eventType] = filtered;
+                        }
+                    }
+                    if (legacyRemoved > 0) {
+                        log(`  Cleaned up ${legacyRemoved} legacy hook entries from settings.json`);
+                    }
+                    const shouldConfigureSettingsHooks = !runningAsPlugin || allowPluginHookRefresh;
+                    if (shouldConfigureSettingsHooks) {
+                        const desiredHooks = getHooksSettingsConfig().hooks;
+                        for (const [eventType, newOmcGroups] of Object.entries(desiredHooks)) {
+                            const currentGroups = existingHooks[eventType] ?? [];
+                            existingHooks[eventType] = mergeHookGroups(eventType, currentGroups, newOmcGroups, options, log, result);
+                        }
+                    }
+                    existingSettings.hooks = Object.keys(existingHooks).length > 0 ? existingHooks : undefined;
+                    result.hooksConfigured = true;
+                }
+                // 2. Configure statusLine (always, even in plugin mode)
+                if (hudScriptPath) {
+                    const nodeBin = resolveNodeBinary();
+                    const absoluteCommand = '"' + nodeBin + '" "' + hudScriptPath.replace(/\\/g, '/') + '"';
+                    // On Unix, use find-node.sh for portable $HOME paths (multi-machine sync)
+                    // and robust node discovery (nvm/fnm in non-interactive shells).
+                    // Copy find-node.sh into the HUD directory so statusLine can reference it
+                    // without depending on CLAUDE_PLUGIN_ROOT (which is only set for hooks).
+                    let statusLineCommand = absoluteCommand;
+                    if (!isWindows()) {
+                        try {
+                            const findNodeSrc = join(__dirname, '..', '..', 'scripts', 'find-node.sh');
+                            const findNodeDest = join(HUD_DIR, 'find-node.sh');
+                            copyFileSync(findNodeSrc, findNodeDest);
+                            chmodSync(findNodeDest, 0o755);
+                            statusLineCommand = buildStatusLineCommand(nodeBin, hudScriptPath.replace(/\\/g, '/'), findNodeDest);
+                        }
+                        catch {
+                            // Fallback to bare node if find-node.sh copy fails
+                            statusLineCommand = buildStatusLineCommand(nodeBin, hudScriptPath.replace(/\\/g, '/'));
+                        }
+                    }
+                    else {
+                        statusLineCommand = buildStatusLineCommand(nodeBin, hudScriptPath);
+                    }
+                    // Auto-migrate legacy string format (pre-v4.5) to object format
+                    const needsMigration = typeof existingSettings.statusLine === 'string'
+                        && isOmcStatusLine(existingSettings.statusLine);
+                    if (!existingSettings.statusLine || needsMigration) {
+                        existingSettings.statusLine = {
+                            type: 'command',
+                            command: statusLineCommand
+                        };
+                        log(needsMigration
+                            ? '  Migrated statusLine from legacy string to object format'
+                            : '  Configured statusLine');
+                    }
+                    else if (options.force && isOmcStatusLine(existingSettings.statusLine)) {
+                        existingSettings.statusLine = {
+                            type: 'command',
+                            command: statusLineCommand
+                        };
+                        log('  Updated statusLine (--force)');
+                    }
+                    else if (options.force) {
+                        log('  statusLine owned by another tool, preserving (use manual edit to override)');
+                    }
+                    else {
+                        log('  statusLine already configured, skipping (use --force to override)');
+                    }
+                }
+                // 3. Persist the detected node binary path into .omc-config.json so that
+                //    find-node.sh (used in hooks/hooks.json) can locate it at hook runtime
+                //    even when node is not on PATH (nvm/fnm users, issue #892).
+                try {
+                    const configPath = join(CLAUDE_CONFIG_DIR, '.omc-config.json');
+                    let omcConfig = {};
+                    if (existsSync(configPath)) {
+                        omcConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+                    }
+                    const detectedNode = resolveNodeBinary();
+                    if (detectedNode !== 'node') {
+                        omcConfig.nodeBinary = detectedNode;
+                        writeFileSync(configPath, JSON.stringify(omcConfig, null, 2));
+                        log(`  Saved node binary path to .omc-config.json: ${detectedNode}`);
+                    }
+                }
+                catch {
+                    log('  Warning: Could not save node binary path (non-fatal)');
+                }
+                // 4. Sync unified MCP registry into Claude + Codex config surfaces
+                const mcpSync = syncUnifiedMcpRegistryTargets(existingSettings);
+                existingSettings = mcpSync.settings;
+                if (mcpSync.result.bootstrappedFromClaude) {
+                    log(`  Bootstrapped unified MCP registry: ${mcpSync.result.registryPath}`);
+                }
+                if (mcpSync.result.claudeChanged) {
+                    log(`  Synced ${mcpSync.result.serverNames.length} MCP server(s) into Claude MCP config: ${mcpSync.result.claudeConfigPath}`);
+                }
+                if (mcpSync.result.codexChanged) {
+                    log(`  Synced ${mcpSync.result.serverNames.length} MCP server(s) into Codex config: ${mcpSync.result.codexConfigPath}`);
+                }
+                // 5. Single atomic write
+                writeFileSync(SETTINGS_FILE, JSON.stringify(existingSettings, null, 2));
+                log('  settings.json updated');
+            }
+            catch (_e) {
+                log('  Warning: Could not configure settings.json (non-fatal)');
+                result.hooksConfigured = false;
+            }
+        // Save version metadata (skip for project-scoped plugins)
+        if (!projectScoped) {
+            const versionMetadata = {
+                version: targetVersion,
+                installedAt: new Date().toISOString(),
+                installMethod: 'npm',
+                lastCheckAt: new Date().toISOString()
+            };
+            writeFileSync(VERSION_FILE, JSON.stringify(versionMetadata, null, 2));
+            log('Saved version metadata');
+        }
+        else {
+            log('Skipping version metadata (project-scoped plugin)');
+        }
+        try {
+            const setupVersionSynced = syncPersistedSetupVersion({
+                version: options.version ?? VERSION,
+                onlyIfConfigured: true,
+            });
+            if (setupVersionSynced) {
+                log('Updated persisted setupVersion');
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log(`  Warning: Could not refresh setupVersion metadata (non-fatal): ${message}`);
+        }
+        result.success = true;
+        result.message = `Successfully installed ${result.installedAgents.length} agents, ${result.installedCommands.length} commands, ${result.installedSkills.length} skills`;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        result.errors.push(errorMessage);
+        result.message = `Installation failed: ${errorMessage}`;
+    }
+    return result;
+}
+/**
+ * Check if OMC is already installed
+ */
+export function isInstalled() {
+    return existsSync(VERSION_FILE) && (existsSync(AGENTS_DIR) || hasPluginProvidedAgentFiles());
+}
+/**
+ * Get installation info
+ */
+export function getInstallInfo() {
+    if (!existsSync(VERSION_FILE)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(VERSION_FILE, 'utf-8');
+        const data = JSON.parse(content);
+        return {
+            version: data.version,
+            installedAt: data.installedAt,
+            method: data.installMethod
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=index.js.map