claudecode-omc 4.9.4 → 5.0.0

package/dist/installer/index.js

@@ -1,1241 +0,0 @@
-/**
- * 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, cpSync } 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 } 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');
-export const GLOBAL_USER_SKILLS_DIR = join(homedir(), '.omc', 'skills');
-export const LEGACY_USER_SKILLS_DIR = join(CLAUDE_CONFIG_DIR, 'skills', 'omc-learned');
-export const PLUGINS_DIR = join(CLAUDE_CONFIG_DIR, 'plugins');
-export const PLUGIN_DIR = join(PLUGINS_DIR, 'oh-my-claudecode');
-export const INSTALLED_PLUGINS_FILE = join(PLUGINS_DIR, 'installed_plugins.json');
-export const KNOWN_MARKETPLACES_FILE = join(PLUGINS_DIR, 'known_marketplaces.json');
-export const MARKETPLACE_DIR = join(PLUGINS_DIR, 'marketplaces', 'omc');
-/**
- * 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 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',
-    '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 hookPathMatch = lowerCommand.match(/\.claude[/\\]hooks[/\\]([a-z0-9-]+\.mjs)/);
-    if (hookPathMatch && OMC_HOOK_FILENAMES.has(hookPathMatch[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);
-}
-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() {
-    // CJS bundle path (bridge/cli.cjs): from bridge/ go up 1 level to package root
-    if (typeof __dirname !== 'undefined') {
-        return join(__dirname, '..');
-    }
-    // ESM path (works in dev via ts/dist)
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        // From dist/installer/index.js, go up to package root
-        return join(__dirname, '..', '..');
-    }
-    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 as a Claude Code plugin to ~/.claude/plugins/oh-my-claudecode/.
- * Copies skills/ directory, generates commands/, writes marketplace.json,
- * and updates installed_plugins.json and known_marketplaces.json.
- */
-function installPlugin(version, log) {
-    const pkgDir = getPackageDir();
-    const skillsSrc = join(pkgDir, 'skills');
-    if (!existsSync(skillsSrc)) {
-        log('  Warning: skills/ directory not found in package, skipping plugin install');
-        return;
-    }
-    // Ensure plugin directory exists
-    if (!existsSync(PLUGIN_DIR)) {
-        mkdirSync(PLUGIN_DIR, { recursive: true });
-    }
-    // Copy skills/ into plugin dir's skills/ subdirectory
-    const pluginSkillsDir = join(PLUGIN_DIR, 'skills');
-    if (!existsSync(pluginSkillsDir)) {
-        mkdirSync(pluginSkillsDir, { recursive: true });
-    }
-    cpSync(skillsSrc, pluginSkillsDir, { recursive: true, force: true });
-    log('  Copied skills/ to plugin directory');
-    // Copy dist/ into plugin dir so the HUD wrapper can resolve the HUD module
-    // from the direct plugin install path (essential for fork/custom npm packages)
-    const distSrc = join(pkgDir, 'dist');
-    if (existsSync(distSrc)) {
-        const pluginDistDir = join(PLUGIN_DIR, 'dist');
-        if (!existsSync(pluginDistDir)) {
-            mkdirSync(pluginDistDir, { recursive: true });
-        }
-        cpSync(distSrc, pluginDistDir, { recursive: true, force: true });
-        log('  Copied dist/ to plugin directory');
-    }
-    // Copy .claude-plugin/ directory to plugin root so Claude Code can discover the plugin manifest
-    const claudePluginSrc = join(pkgDir, '.claude-plugin');
-    const claudePluginDest = join(PLUGIN_DIR, '.claude-plugin');
-    if (existsSync(claudePluginSrc)) {
-        if (!existsSync(claudePluginDest)) {
-            mkdirSync(claudePluginDest, { recursive: true });
-        }
-        cpSync(claudePluginSrc, claudePluginDest, { recursive: true, force: true });
-        log('  Copied .claude-plugin/ to plugin directory');
-    }
-    // Generate commands/ from skills (thin wrappers for Claude Code slash command discovery)
-    const pluginCommandsDir = join(PLUGIN_DIR, 'commands');
-    if (!existsSync(pluginCommandsDir)) {
-        mkdirSync(pluginCommandsDir, { recursive: true });
-    }
-    // Compatibility mirrors for Claude Code variants that only register:
-    // - /oh-my-claudecode <subcommand>
-    // - /oh-my-claudecode:<subcommand>
-    const legacyNamespacedCommandsDir = join(COMMANDS_DIR, 'oh-my-claudecode');
-    if (!existsSync(COMMANDS_DIR)) {
-        mkdirSync(COMMANDS_DIR, { recursive: true });
-    }
-    if (!existsSync(legacyNamespacedCommandsDir)) {
-        mkdirSync(legacyNamespacedCommandsDir, { recursive: true });
-    }
-    let commandCount = 0;
-    let compatCommandCount = 0;
-    for (const skillName of readdirSync(skillsSrc)) {
-        if (skillName === 'AGENTS.md')
-            continue;
-        const skillMdPath = join(skillsSrc, skillName, 'SKILL.md');
-        if (!existsSync(skillMdPath))
-            continue;
-        // Read skill to get description
-        const skillContent = readFileSync(skillMdPath, 'utf-8');
-        const descMatch = skillContent.match(/^description:\s*(.+)$/m);
-        const description = descMatch ? descMatch[1].replace(/^["']|["']$/g, '') : `${skillName} skill`;
-        const escapedDescription = description.replace(/"/g, '\\"');
-        const skillBody = skillContent.replace(/^---[\s\S]*?---\s*/m, '').trim();
-        // Write self-contained command to avoid runtime Skill(...) delegation failures.
-        const commandContent = `---\ndescription: "${escapedDescription}"\n---\n\n${skillBody}\n`;
-        writeFileSync(join(pluginCommandsDir, `${skillName}.md`), commandContent);
-        // Legacy namespaced command: /oh-my-claudecode <subcommand>
-        writeFileSync(join(legacyNamespacedCommandsDir, `${skillName}.md`), commandContent);
-        // Explicit alias command: /oh-my-claudecode:<subcommand>
-        writeFileSync(join(COMMANDS_DIR, `oh-my-claudecode:${skillName}.md`), commandContent);
-        commandCount++;
-        compatCommandCount += 2;
-    }
-    log(`  Generated ${commandCount} command wrappers`);
-    log(`  Generated ${compatCommandCount} compatibility command aliases`);
-    // Create marketplace directory and marketplace.json
-    // Claude Code looks for .claude-plugin/marketplace.json within the marketplace directory
-    const marketplacePluginDir = join(MARKETPLACE_DIR, '.claude-plugin');
-    if (!existsSync(marketplacePluginDir)) {
-        mkdirSync(marketplacePluginDir, { recursive: true });
-    }
-    const marketplaceJson = {
-        '$schema': 'https://anthropic.com/claude-code/marketplace.schema.json',
-        name: 'omc',
-        description: 'oh-my-claudecode multi-agent orchestration system for Claude Code',
-        owner: { name: 'oh-my-claudecode contributors' },
-        plugins: [{
-                name: 'oh-my-claudecode',
-                description: 'Multi-agent orchestration system for Claude Code',
-                source: '.',
-                category: 'development',
-            }],
-    };
-    writeFileSync(join(marketplacePluginDir, 'marketplace.json'), JSON.stringify(marketplaceJson, null, 2));
-    log('  Created .claude-plugin/marketplace.json');
-    // Update known_marketplaces.json to point to the stable marketplace directory
-    if (!existsSync(PLUGINS_DIR)) {
-        mkdirSync(PLUGINS_DIR, { recursive: true });
-    }
-    let knownMarketplaces = {};
-    if (existsSync(KNOWN_MARKETPLACES_FILE)) {
-        try {
-            knownMarketplaces = JSON.parse(readFileSync(KNOWN_MARKETPLACES_FILE, 'utf-8'));
-        }
-        catch { /* use default */ }
-    }
-    knownMarketplaces['omc'] = {
-        source: { source: 'directory', path: MARKETPLACE_DIR },
-        installLocation: MARKETPLACE_DIR,
-        lastUpdated: new Date().toISOString(),
-    };
-    writeFileSync(KNOWN_MARKETPLACES_FILE, JSON.stringify(knownMarketplaces, null, 2));
-    log('  Updated known_marketplaces.json');
-    // Update installed_plugins.json
-    let installedPlugins = { version: 2, plugins: {} };
-    if (existsSync(INSTALLED_PLUGINS_FILE)) {
-        try {
-            installedPlugins = JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, 'utf-8'));
-        }
-        catch { /* use default */ }
-    }
-    const plugins = installedPlugins.plugins ?? {};
-    plugins['oh-my-claudecode@omc'] = [{
-            scope: 'user',
-            installPath: PLUGIN_DIR,
-            version,
-            installedAt: new Date().toISOString(),
-            lastUpdated: new Date().toISOString(),
-        }];
-    installedPlugins.plugins = plugins;
-    writeFileSync(INSTALLED_PLUGINS_FILE, JSON.stringify(installedPlugins, null, 2));
-    log('  Updated installed_plugins.json');
-}
-/**
- * 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(GLOBAL_USER_SKILLS_DIR)) {
-                mkdirSync(GLOBAL_USER_SKILLS_DIR, { recursive: true });
-            }
-            if (!existsSync(LEGACY_USER_SKILLS_DIR)) {
-                mkdirSync(LEGACY_USER_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');
-                }
-            }
-            // Install CLAUDE.md with merge support
-            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');
-            }
-            // Note: hook scripts are no longer installed to ~/.claude/hooks/.
-            // All hooks are delivered via the plugin's hooks/hooks.json + scripts/.
-            // Legacy hook entries are cleaned up from settings.json below.
-            result.hooksConfigured = true; // Will be set properly after consolidated settings.json write
-            // Install plugin to ~/.claude/plugins/oh-my-claudecode/
-            // This ensures Claude Code's plugin system can discover skills.
-            log('Installing plugin to ~/.claude/plugins/oh-my-claudecode/...');
-            try {
-                installPlugin(options.version ?? VERSION, log);
-                log('  Plugin installed successfully');
-            }
-            catch (e) {
-                log(`  Warning: Could not install plugin (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-        else {
-            log('Skipping agent/command/hook files (managed by plugin system)');
-        }
-        // 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 { existsSync, readdirSync } from "node:fs";',
-                    'import { homedir } from "node:os";',
-                    'import { dirname, join } from "node:path";',
-                    'import { pathToFileURL } from "node:url";',
-                    '',
-                    '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. Direct plugin install (for fork/custom npm packages installed via omc setup)',
-                    '  const directPluginHudPath = join(configDir, "plugins", "oh-my-claudecode", "dist/hud/index.js");',
-                    '  if (existsSync(directPluginHudPath)) {',
-                    '    try {',
-                    '      await import(pathToFileURL(directPluginHudPath).href);',
-                    '      return;',
-                    '    } catch { /* continue */ }',
-                    '  }',
-                    '  ',
-                    '  // 5. npm package (global or local install)',
-                    '  try {',
-                    '    await import("oh-my-claudecode/dist/hud/index.js");',
-                    '    return;',
-                    '  } catch { /* continue */ }',
-                    '  ',
-                    '  // 6. 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
-                // These were written by the old installer; hooks are now delivered via the plugin's hooks.json.
-                {
-                    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/'));
-                            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`);
-                    }
-                    existingSettings.hooks = Object.keys(existingHooks).length > 0 ? existingHooks : undefined;
-                    result.hooksConfigured = true;
-                }
-                // 2a. Ensure oh-my-claudecode plugin is enabled
-                {
-                    const enabledPlugins = existingSettings.enabledPlugins ?? {};
-                    enabledPlugins['oh-my-claudecode@omc'] = true;
-                    existingSettings.enabledPlugins = enabledPlugins;
-                }
-                // 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 = 'sh $HOME/.claude/hud/find-node.sh $HOME/.claude/hud/omc-hud.mjs';
-                        }
-                        catch {
-                            // Fallback to bare node if find-node.sh copy fails
-                            statusLineCommand = 'node $HOME/.claude/hud/omc-hud.mjs';
-                        }
-                    }
-                    // 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 (hooks delivered via plugin)`;
-    }
-    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