monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/commands/init-wizard.js

@@ -1,244 +0,0 @@
-/**
- * Init wizard subcommand — interactive setup
- */
-import { output } from '../output.js';
-import { confirm, select, multiSelect, input } from '../prompt.js';
-import { executeInit, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
-export const wizardCommand = {
-    name: 'wizard',
-    description: 'Interactive setup wizard for comprehensive configuration',
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('Monomind Setup Wizard'));
-        output.writeln(output.dim('Answer questions to configure your project'));
-        output.writeln();
-        try {
-            const options = { ...DEFAULT_INIT_OPTIONS, targetDir: ctx.cwd };
-            const preset = await select({
-                message: 'Select configuration preset:',
-                options: [
-                    { value: 'default', label: 'Default', hint: 'Recommended settings for most projects' },
-                    { value: 'minimal', label: 'Minimal', hint: 'Core features only' },
-                    { value: 'full', label: 'Full', hint: 'All features enabled' },
-                    { value: 'custom', label: 'Custom', hint: 'Choose each component' },
-                ],
-            });
-            if (preset === 'minimal') {
-                Object.assign(options, MINIMAL_INIT_OPTIONS);
-                options.targetDir = ctx.cwd;
-            }
-            else if (preset === 'full') {
-                Object.assign(options, FULL_INIT_OPTIONS);
-                options.targetDir = ctx.cwd;
-            }
-            else if (preset === 'custom') {
-                const components = await multiSelect({
-                    message: 'Select components to initialize:',
-                    options: [
-                        { value: 'claudeMd', label: 'CLAUDE.md', hint: 'Swarm guidance and project configuration', selected: true },
-                        { value: 'settings', label: 'settings.json', hint: 'Claude Code hooks configuration', selected: true },
-                        { value: 'skills', label: 'Skills', hint: 'Claude Code skills in .claude/skills/', selected: true },
-                        { value: 'commands', label: 'Commands', hint: 'Claude Code commands in .claude/commands/', selected: true },
-                        { value: 'agents', label: 'Agents', hint: 'Agent definitions in .claude/agents/', selected: true },
-                        { value: 'helpers', label: 'Helpers', hint: 'Utility scripts in .claude/helpers/', selected: true },
-                        { value: 'statusline', label: 'Statusline', hint: 'Shell statusline integration', selected: false },
-                        { value: 'mcp', label: 'MCP', hint: '.mcp.json for MCP server configuration', selected: true },
-                        { value: 'runtime', label: 'Runtime', hint: '.monomind/ directory for v1 runtime', selected: true },
-                    ],
-                });
-                options.components.claudeMd = components.includes('claudeMd');
-                options.components.settings = components.includes('settings');
-                options.components.skills = components.includes('skills');
-                options.components.commands = components.includes('commands');
-                options.components.agents = components.includes('agents');
-                options.components.helpers = components.includes('helpers');
-                options.components.statusline = components.includes('statusline');
-                options.components.mcp = components.includes('mcp');
-                options.components.runtime = components.includes('runtime');
-                if (options.components.skills) {
-                    const skillSets = await multiSelect({
-                        message: 'Select skill sets:',
-                        options: [
-                            { value: 'core', label: 'Core', hint: 'Swarm, memory skills', selected: true },
-                            { value: 'memory', label: 'Memory (SQLite)', hint: 'Vector database skills', selected: true },
-                            { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
-                        ],
-                    });
-                    options.skills.core = skillSets.includes('core');
-                    options.skills.memory = skillSets.includes('memory');
-                    options.skills.github = skillSets.includes('github');
-                }
-                if (options.components.settings) {
-                    const hooks = await multiSelect({
-                        message: 'Select hooks to enable:',
-                        options: [
-                            { value: 'preToolUse', label: 'PreToolUse', hint: 'Before tool execution', selected: true },
-                            { value: 'postToolUse', label: 'PostToolUse', hint: 'After tool execution', selected: true },
-                            { value: 'userPromptSubmit', label: 'UserPromptSubmit', hint: 'Task routing', selected: true },
-                            { value: 'sessionStart', label: 'SessionStart', hint: 'Session initialization', selected: true },
-                            { value: 'stop', label: 'Stop', hint: 'Task completion evaluation', selected: true },
-                            { value: 'notification', label: 'Notification', hint: 'Swarm notifications', selected: true },
-                            { value: 'permissionRequest', label: 'PermissionRequest', hint: 'Auto-allow monomind tools', selected: true },
-                        ],
-                    });
-                    options.hooks.preToolUse = hooks.includes('preToolUse');
-                    options.hooks.postToolUse = hooks.includes('postToolUse');
-                    options.hooks.userPromptSubmit = hooks.includes('userPromptSubmit');
-                    options.hooks.sessionStart = hooks.includes('sessionStart');
-                    options.hooks.stop = hooks.includes('stop');
-                    options.hooks.notification = hooks.includes('notification');
-                }
-            }
-            const topology = await select({
-                message: 'Select swarm topology:',
-                options: [
-                    { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'Best for complex projects (recommended)' },
-                    { value: 'mesh', label: 'Mesh', hint: 'Peer-to-peer coordination' },
-                    { value: 'hierarchical', label: 'Hierarchical', hint: 'Tree-based coordination' },
-                    { value: 'adaptive', label: 'Adaptive', hint: 'Dynamic topology switching' },
-                ],
-            });
-            options.runtime.topology = topology;
-            const maxAgents = await input({
-                message: 'Maximum concurrent agents:',
-                default: String(options.runtime.maxAgents),
-                validate: (v) => {
-                    const n = parseInt(v);
-                    return (!isNaN(n) && n > 0 && n <= 50) || 'Enter a number between 1 and 50';
-                },
-            });
-            options.runtime.maxAgents = parseInt(maxAgents);
-            const memoryBackend = await select({
-                message: 'Select memory backend:',
-                options: [
-                    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite with vector search (recommended)' },
-                    { value: 'lancedb', label: 'LanceDB (legacy alias)', hint: 'Historical name — now backed by SQLite' },
-                    { value: 'sqlite', label: 'SQLite', hint: 'Standard SQL storage' },
-                    { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' },
-                ],
-            });
-            options.runtime.memoryBackend = memoryBackend;
-            if (memoryBackend === 'lancedb' || memoryBackend === 'hybrid') {
-                const enableHNSW = await confirm({
-                    message: 'Enable HNSW indexing for faster vector search?',
-                    default: true,
-                });
-                options.runtime.enableHNSW = enableHNSW;
-            }
-            const enableNeural = await confirm({
-                message: 'Enable neural pattern learning?',
-                default: options.runtime.enableNeural,
-            });
-            options.runtime.enableNeural = enableNeural;
-            if (memoryBackend === 'lancedb' || memoryBackend === 'hybrid') {
-                const enableSelfLearning = await confirm({
-                    message: 'Enable self-learning memory? (Knowledge Graph + Agent Scopes)',
-                    default: true,
-                });
-                options.runtime.enableLearningBridge = enableSelfLearning && enableNeural;
-                options.runtime.enableAgentScopes = enableSelfLearning;
-            }
-            else {
-                options.runtime.enableLearningBridge = false;
-                options.runtime.enableAgentScopes = false;
-            }
-            const enableEmbeddings = await confirm({
-                message: 'Enable ONNX embedding system with hyperbolic support?',
-                default: true,
-            });
-            let embeddingModel = 'Xenova/all-MiniLM-L6-v2';
-            if (enableEmbeddings) {
-                embeddingModel = await select({
-                    message: 'Select embedding model:',
-                    options: [
-                        { value: 'Xenova/all-MiniLM-L6-v2', label: 'MiniLM L6 (384d)', hint: 'Fast, good quality (recommended)' },
-                        { value: 'Xenova/all-mpnet-base-v2', label: 'MPNet Base (768d)', hint: 'Higher quality, more memory' },
-                    ],
-                });
-            }
-            output.writeln();
-            const spinner = output.createSpinner({ text: 'Initializing...' });
-            spinner.start();
-            const result = await executeInit(options);
-            if (!result.success) {
-                spinner.fail('Initialization failed');
-                for (const error of result.errors) {
-                    output.printError(error);
-                }
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed('Setup complete!');
-            let embeddingsInitialized = false;
-            if (enableEmbeddings) {
-                output.writeln();
-                output.printInfo('Initializing ONNX embedding subsystem...');
-                const ALLOWED_MODELS = /^[\w\-./]+$/;
-                if (!ALLOWED_MODELS.test(embeddingModel)) {
-                    output.writeln(output.error('Invalid model identifier. Only alphanumeric characters, hyphens, dots, and slashes are allowed.'));
-                    return { success: false, exitCode: 1 };
-                }
-                const { execFileSync } = await import('child_process');
-                try {
-                    execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['monomind@latest', 'embeddings', 'init', '--model', embeddingModel, '--no-download', '--force'], {
-                        stdio: 'pipe',
-                        cwd: ctx.cwd,
-                        timeout: 30000
-                    });
-                    output.writeln(output.success('  ✓ Embeddings configured'));
-                    embeddingsInitialized = true;
-                }
-                catch {
-                    output.writeln(output.dim('  Embeddings will be configured on first use'));
-                }
-            }
-            const enableGates = await confirm({
-                message: 'Enable enforcement gates? (blocks destructive commands + secrets in writes)',
-                default: true,
-            });
-            let gatesEnabled = false;
-            if (enableGates) {
-                try {
-                    const { execFileSync } = await import('child_process');
-                    execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['monomind@latest', 'guidance', 'setup', '--project-dir', ctx.cwd], { stdio: 'pipe', cwd: ctx.cwd, timeout: 10000 });
-                    gatesEnabled = true;
-                    output.writeln(output.success('  ✓ Enforcement gates wired'));
-                }
-                catch {
-                    output.writeln(output.dim('  Gates setup skipped (run `monomind guidance setup` manually)'));
-                }
-            }
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'setting', header: 'Setting', width: 20 },
-                    { key: 'value', header: 'Value', width: 40 },
-                ],
-                data: [
-                    { setting: 'Preset', value: preset },
-                    { setting: 'Topology', value: options.runtime.topology },
-                    { setting: 'Max Agents', value: String(options.runtime.maxAgents) },
-                    { setting: 'Memory Backend', value: options.runtime.memoryBackend },
-                    { setting: 'HNSW Indexing', value: options.runtime.enableHNSW ? 'Enabled' : 'Disabled' },
-                    { setting: 'Neural Learning', value: options.runtime.enableNeural ? 'Enabled' : 'Disabled' },
-                    { setting: 'Self-Learning', value: options.runtime.enableLearningBridge ? 'Graph + Scopes' : 'Disabled' },
-                    { setting: 'Embeddings', value: enableEmbeddings ? `${embeddingModel} (hyperbolic)` : 'Disabled' },
-                    { setting: 'Skills', value: `${result.summary.skillsCount} installed` },
-                    { setting: 'Commands', value: `${result.summary.commandsCount} installed` },
-                    { setting: 'Agents', value: `${result.summary.agentsCount} installed` },
-                    { setting: 'Hooks', value: `${result.summary.hooksEnabled} enabled` },
-                    { setting: 'Enforcement Gates', value: gatesEnabled ? 'Enabled' : 'Disabled' },
-                ],
-            });
-            void embeddingsInitialized;
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof Error && error.message === 'User cancelled') {
-                output.printInfo('Setup cancelled');
-                return { success: true };
-            }
-            throw error;
-        }
-    },
-};
-//# sourceMappingURL=init-wizard.js.map

package/packages/@monomind/cli/dist/src/commands/init.d.ts

@@ -1,8 +0,0 @@
-/**
- * CLI Init Command
- * Comprehensive initialization for Monomind with Claude Code integration
- */
-import type { Command } from '../types.js';
-export declare const initCommand: Command;
-export default initCommand;
-//# sourceMappingURL=init.d.ts.map

package/packages/@monomind/cli/dist/src/commands/init.js

@@ -1,411 +0,0 @@
-/**
- * CLI Init Command
- * Comprehensive initialization for Monomind with Claude Code integration
- */
-import { output } from '../output.js';
-import { confirm } from '../prompt.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { executeInit, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
-import { wizardCommand } from './init-wizard.js';
-import { upgradeCommand } from './init-upgrade.js';
-import { checkCommand, skillsCommand, hooksCommand } from './init-subcommands.js';
-import { initializeMemoryDatabase } from '../memory/memory-initializer.js';
-function isInitialized(cwd) {
-    const claudePath = path.join(cwd, '.claude', 'settings.json');
-    const monomindPath = path.join(cwd, '.monomind', 'config.yaml');
-    return {
-        claude: fs.existsSync(claudePath),
-        monomind: fs.existsSync(monomindPath),
-    };
-}
-const initAction = async (ctx) => {
-    const force = ctx.flags.force;
-    const minimal = ctx.flags.minimal;
-    const full = ctx.flags.full;
-    const skipClaude = ctx.flags['skip-claude'];
-    const onlyClaude = ctx.flags['only-claude'];
-    const cwd = ctx.cwd;
-    const initialized = isInitialized(cwd);
-    const hasExisting = initialized.claude || initialized.monomind;
-    if (hasExisting && !force) {
-        output.printWarning('MonoMind appears to be already initialized');
-        if (initialized.claude)
-            output.printInfo('  Found: .claude/settings.json');
-        if (initialized.monomind)
-            output.printInfo('  Found: .monomind/config.yaml');
-        output.printInfo('Use --force to reinitialize');
-        const yes = ctx.flags.yes || process.env.CI === 'true';
-        if (ctx.interactive && !yes) {
-            const proceed = await confirm({
-                message: 'Do you want to reinitialize? This will overwrite existing configuration.',
-                default: false,
-            });
-            if (!proceed) {
-                return { success: true, message: 'Initialization cancelled' };
-            }
-        }
-        else if (!yes) {
-            return { success: false, exitCode: 1, message: 'Already initialized. Use --force or --yes to reinitialize.' };
-        }
-    }
-    output.writeln();
-    output.writeln(output.bold('Initializing Monomind'));
-    output.writeln();
-    let options;
-    if (minimal) {
-        options = { ...MINIMAL_INIT_OPTIONS, targetDir: cwd, force };
-    }
-    else if (full) {
-        options = { ...FULL_INIT_OPTIONS, targetDir: cwd, force };
-    }
-    else {
-        options = { ...DEFAULT_INIT_OPTIONS, targetDir: cwd, force };
-    }
-    if (skipClaude) {
-        options.components.settings = false;
-        options.components.skills = false;
-        options.components.commands = false;
-        options.components.agents = false;
-        options.components.helpers = false;
-        options.components.statusline = false;
-        options.components.mcp = false;
-        options.components.claudeMd = false;
-    }
-    if (onlyClaude) {
-        options.components.runtime = false;
-    }
-    const spinner = output.createSpinner({ text: 'Initializing...' });
-    spinner.start();
-    try {
-        const result = await executeInit(options);
-        if (!result.success) {
-            spinner.fail('Initialization failed');
-            for (const error of result.errors) {
-                output.printError(error);
-            }
-            return { success: false, exitCode: 1 };
-        }
-        spinner.succeed('Monomind initialized successfully!');
-        // Start monograph watch for ongoing file-change rebuilds, unless --no-watch was passed.
-        // Guard: skip if a watcher PID file already exists and the process is still alive,
-        // preventing duplicate watchers from accumulating on repeated `init --force` runs.
-        // `--no-watch` is the parser's negation of the declared boolean `watch`
-        // option. It used to be declared as its own boolean named 'no-watch', which
-        // the parser never populated: parseFlag strips the `--no-` prefix and looks
-        // up `watch`, which IS a declared boolean (status/agent-ops declare it and
-        // getBooleanFlags() is global across all registered commands). So
-        // `--no-watch` set the unrelated `watch` flag to false and left `no-watch`
-        // at its `false` default — the flag was a silent no-op and the watcher
-        // started anyway. The legacy `no-watch`/`noWatch` keys are still honoured
-        // for programmatic callers that set ctx.flags directly.
-        const noWatch = ctx.flags.watch === false ||
-            ctx.flags['no-watch'] === true ||
-            ctx.flags.noWatch === true;
-        if (!noWatch) {
-            try {
-                const { spawn } = await import('child_process');
-                const pidFile = path.join(ctx.cwd, '.monomind', 'monograph.watch.pid');
-                let alreadyRunning = false;
-                if (fs.existsSync(pidFile) && fs.statSync(pidFile).size <= 32) {
-                    const existingPid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
-                    if (!isNaN(existingPid)) {
-                        try {
-                            process.kill(existingPid, 0);
-                            alreadyRunning = true;
-                        }
-                        catch { /* process gone */ }
-                    }
-                }
-                if (!alreadyRunning) {
-                    const logPath = path.join(ctx.cwd, '.monomind', 'monograph.watch.log');
-                    const { openSync } = fs;
-                    const logFd = openSync(logPath, 'a');
-                    const proc = spawn(process.execPath, [process.argv[1], 'monograph', 'watch'], {
-                        detached: true,
-                        stdio: ['ignore', logFd, logFd],
-                        cwd: ctx.cwd,
-                        env: process.env,
-                    });
-                    fs.writeFileSync(pidFile, String(proc.pid));
-                    proc.unref();
-                    output.printInfo('◈ Knowledge graph watch started in background');
-                }
-                else {
-                    output.printInfo('◈ Knowledge graph watch already running — skipping');
-                }
-            }
-            catch {
-                // non-critical
-            }
-        }
-        output.writeln();
-        const summary = [];
-        if (result.created.directories.length > 0) {
-            summary.push(`Directories: ${result.created.directories.length} created`);
-        }
-        if (result.created.files.length > 0) {
-            summary.push(`Files: ${result.created.files.length} created`);
-        }
-        if (result.skipped.length > 0) {
-            summary.push(`Skipped: ${result.skipped.length} (already exist)`);
-        }
-        output.printBox(summary.join('\n'), 'Summary');
-        output.writeln();
-        if (options.components.claudeMd || options.components.settings || options.components.skills || options.components.commands || options.components.agents) {
-            output.printBox([
-                options.components.claudeMd ? `CLAUDE.md:   Swarm guidance & configuration` : '',
-                options.components.settings ? `Settings:    .claude/settings.json` : '',
-                options.components.skills ? `Skills:      .claude/skills/ (${result.summary.skillsCount} skills)` : '',
-                options.components.commands ? `Commands:    .claude/commands/ (${result.summary.commandsCount} commands)` : '',
-                options.components.agents ? `Agents:      .claude/agents/ (${result.summary.agentsCount} agents)` : '',
-                options.components.helpers ? `Helpers:     .claude/helpers/` : '',
-                options.components.mcp ? `MCP:         .mcp.json` : '',
-            ].filter(Boolean).join('\n'), 'Claude Code Integration');
-            output.writeln();
-        }
-        if (options.components.runtime) {
-            output.printBox([
-                `Config:      .monomind/config.yaml`,
-                `Data:        .monomind/data/`,
-                `Logs:        .monomind/logs/`,
-                `Sessions:    .monomind/sessions/`,
-            ].join('\n'), 'v1 Runtime');
-            output.writeln();
-        }
-        if (result.summary.hooksEnabled > 0) {
-            output.printInfo(`Hooks: ${result.summary.hooksEnabled} hook types enabled in settings.json`);
-            output.writeln();
-        }
-        const noStartAll = ctx.flags['no-start-all'] || ctx.flags.noStartAll;
-        const startAll = noStartAll ? false : (ctx.flags['start-all'] ?? ctx.flags.startAll ?? true);
-        if (startAll) {
-            output.writeln();
-            output.printInfo('Starting services...');
-            const { execSync } = await import('child_process');
-            if (startAll) {
-                // In-process, not a subprocess: `npx @monomind/cli@latest memory init`
-                // (the previous approach) shelled out to a package name that has
-                // never been published — every fresh init silently 404'd here and
-                // fell into the catch block's "already exists" message even when no
-                // database existed at all. initializeMemoryDatabase() is the same
-                // function `monomind memory init` itself calls, run directly.
-                try {
-                    output.writeln(output.dim('  Initializing memory database...'));
-                    const memResult = await initializeMemoryDatabase({ dbPath: path.join(ctx.cwd, '.swarm', 'memory.db') });
-                    if (memResult.success) {
-                        output.writeln(output.success('  ✓ Memory initialized'));
-                    }
-                    else {
-                        output.writeln(output.dim(`  Memory database init skipped (${memResult.error || 'unknown reason'})`));
-                    }
-                }
-                catch (e) {
-                    output.writeln(output.dim(`  Memory database init skipped (${e instanceof Error ? e.message : String(e)})`));
-                }
-            }
-            if (startAll) {
-                try {
-                    output.writeln(output.dim('  Initializing swarm...'));
-                    execSync('npx monomind@latest swarm init --topology hierarchical', {
-                        stdio: 'pipe',
-                        cwd: ctx.cwd,
-                        timeout: 30000
-                    });
-                    output.writeln(output.success('  ✓ Swarm initialized'));
-                }
-                catch {
-                    output.writeln(output.dim('  Swarm initialization skipped'));
-                }
-            }
-            if (startAll) {
-                // Seed .monomind/metrics/ immediately instead of waiting for the
-                // first Claude Code session-restore hook to run these workers —
-                // running `monomind doctor` right after `init` (before ever opening
-                // Claude Code) otherwise always shows "Worker Metrics"/"Security
-                // Audit" as unconfigured, even though nothing is actually broken.
-                try {
-                    output.writeln(output.dim('  Seeding worker metrics...'));
-                    const hooksMod = await import('@monoes/hooks').catch(() => null);
-                    if (hooksMod && hooksMod.createWorkerManager) {
-                        const manager = hooksMod.createWorkerManager(ctx.cwd);
-                        await manager.ensureMetricsDir();
-                        const seeded = [];
-                        for (const workerName of ['map', 'audit']) {
-                            try {
-                                const r = await manager.runWorker(workerName);
-                                if (r.success)
-                                    seeded.push(workerName);
-                            }
-                            catch { /* best-effort — doctor will report if this stays missing */ }
-                        }
-                        if (seeded.length > 0) {
-                            output.writeln(output.success(`  ✓ Worker metrics seeded (${seeded.join(', ')})`));
-                        }
-                        else {
-                            output.writeln(output.dim('  Worker metrics seeding skipped'));
-                        }
-                    }
-                    else {
-                        output.writeln(output.dim('  Worker metrics seeding skipped (@monoes/hooks unavailable)'));
-                    }
-                }
-                catch (e) {
-                    output.writeln(output.dim(`  Worker metrics seeding skipped (${e instanceof Error ? e.message : String(e)})`));
-                }
-            }
-            output.writeln();
-            output.printSuccess('All services started');
-        }
-        const withEmbeddings = ctx.flags['with-embeddings'] || ctx.flags.withEmbeddings;
-        const embeddingModel = (ctx.flags['embedding-model'] || ctx.flags.embeddingModel || 'Xenova/all-MiniLM-L6-v2');
-        if (withEmbeddings) {
-            output.writeln();
-            output.printInfo('Initializing ONNX embedding subsystem...');
-            const ALLOWED_MODELS = /^[\w\-./]+$/;
-            if (!ALLOWED_MODELS.test(embeddingModel)) {
-                output.writeln(output.error('Invalid model identifier. Only alphanumeric characters, hyphens, dots, and slashes are allowed.'));
-                return { success: false, exitCode: 1 };
-            }
-            const { execFileSync } = await import('child_process');
-            try {
-                output.writeln(output.dim(`  Model: ${embeddingModel}`));
-                output.writeln(output.dim('  Hyperbolic: Enabled (Poincaré ball)'));
-                execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['monomind@latest', 'embeddings', 'init', '--model', embeddingModel, '--no-download', '--force'], {
-                    stdio: 'pipe',
-                    cwd: ctx.cwd,
-                    timeout: 30000
-                });
-                output.writeln(output.success('  ✓ Embeddings initialized'));
-                output.writeln(output.dim('    Run "embeddings init --download" to download model'));
-            }
-            catch {
-                output.writeln(output.warning('  Embedding initialization skipped (run manually)'));
-            }
-        }
-        if (!startAll) {
-            output.writeln(output.bold('Next steps:'));
-            output.printList([
-                `Run ${output.highlight('monomind memory init')} to initialize memory database`,
-                `Run ${output.highlight('monomind swarm init')} to initialize a swarm`,
-                `Services auto-start by default; use ${output.highlight('--no-start-all')} to skip`,
-                options.components.settings ? `Review ${output.highlight('.claude/settings.json')} for hook configurations` : '',
-            ].filter(Boolean));
-        }
-        output.writeln('');
-        output.writeln(output.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        output.writeln(output.bold('  Run /mastermind:understand next'));
-        output.writeln('');
-        output.writeln('  In Claude Code, type:  /mastermind:understand');
-        output.writeln('');
-        output.writeln('  This analyzes your project with an LLM and enriches the');
-        output.writeln('  knowledge graph with semantic summaries, tags, and layers.');
-        output.writeln('  Claude Code will have a much richer mental model of your');
-        output.writeln('  codebase from the very first session.');
-        output.writeln(output.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        if (ctx.flags.format === 'json') {
-            output.printJson(result);
-        }
-        return { success: true, data: result };
-    }
-    catch (error) {
-        spinner.fail('Initialization failed');
-        output.printError(`Failed to initialize: ${error instanceof Error ? error.message : String(error)}`);
-        return { success: false, exitCode: 1 };
-    }
-};
-export const initCommand = {
-    name: 'init',
-    description: 'Initialize MonoMind in the current directory',
-    subcommands: [wizardCommand, checkCommand, skillsCommand, hooksCommand, upgradeCommand],
-    options: [
-        {
-            name: 'force',
-            short: 'f',
-            description: 'Overwrite existing configuration',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'yes',
-            short: 'y',
-            description: 'Skip confirmation prompts (also honoured via CI=true env var)',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'minimal',
-            short: 'm',
-            description: 'Create minimal configuration',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'full',
-            description: 'Create full configuration with all components',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'skip-claude',
-            description: 'Skip .claude/ directory creation (runtime only)',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'only-claude',
-            description: 'Only create .claude/ directory (skip runtime)',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'start-all',
-            description: 'Auto-start memory and swarm after init (default: true)',
-            type: 'boolean',
-            default: true,
-        },
-        {
-            // Declared as the positive `watch` so the parser's `--no-X` negation
-            // actually reaches it. Declaring it as `no-watch` made `--no-watch` a
-            // no-op — see the noWatch resolution in initAction.
-            name: 'watch',
-            description: 'Start the monograph knowledge graph watcher after init (default: true; --no-watch skips it)',
-            type: 'boolean',
-            default: true,
-        },
-        {
-            name: 'with-embeddings',
-            description: 'Initialize ONNX embedding subsystem with hyperbolic support',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'embedding-model',
-            description: 'ONNX embedding model to use',
-            type: 'string',
-            default: 'Xenova/all-MiniLM-L6-v2',
-            choices: ['Xenova/all-MiniLM-L6-v2', 'Xenova/all-mpnet-base-v2'],
-        },
-    ],
-    examples: [
-        { command: 'monomind init', description: 'Initialize with default configuration' },
-        { command: 'monomind init --no-start-all', description: 'Initialize without auto-starting services' },
-        { command: 'monomind init --minimal', description: 'Initialize with minimal configuration' },
-        { command: 'monomind init --full', description: 'Initialize with all components' },
-        { command: 'monomind init --force', description: 'Reinitialize and overwrite existing config' },
-        { command: 'monomind init --only-claude', description: 'Only create Claude Code integration' },
-        { command: 'monomind init --skip-claude', description: 'Only create v1 runtime' },
-        { command: 'monomind init wizard', description: 'Interactive setup wizard' },
-        { command: 'monomind init --no-watch', description: 'Initialize without starting the background graph watcher' },
-        { command: 'monomind init --with-embeddings', description: 'Initialize with ONNX embeddings' },
-        { command: 'monomind init --with-embeddings --embedding-model Xenova/all-mpnet-base-v2', description: 'Use larger embedding model' },
-        { command: 'monomind init skills --all', description: 'Install all available skills' },
-        { command: 'monomind init hooks --minimal', description: 'Create minimal hooks configuration' },
-        { command: 'monomind init upgrade', description: 'Update helpers while preserving data' },
-        { command: 'monomind init upgrade --settings', description: 'Update helpers and merge new settings (Agent Teams)' },
-        { command: 'monomind init upgrade --verbose', description: 'Show detailed upgrade info' },
-    ],
-    action: initAction,
-};
-export default initCommand;
-//# sourceMappingURL=init.js.map