monomind 2.7.12 → 2.7.13

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

@@ -1,906 +0,0 @@
-/**
- * CLI Swarm Command
- * Swarm coordination and management commands
- */
-import { output } from '../output.js';
-import { select, confirm } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { writeJsonFileAtomic } from '../utils/json-file.js';
-import { getMonomindDataRoot, getProjectCwd, migrateLegacyStoreFile } from '../mcp-tools/types.js';
-// Canonical paths — resolved through getMonomindDataRoot() so the CLI and the MCP
-// tools (agent-tools.ts / swarm-tools.ts / task-tools.ts) read and write the SAME
-// physical files. These used to be `path.join(process.cwd(), '.monomind/...')`,
-// which only coincides with the canonical root when there is no `.git` directory;
-// inside a real repo the canonical root is `<repo>/.git/monomind`, so the CLI read
-// an empty parallel store ("0 agents" with agents on disk) and `swarm init` wrote a
-// second, divergent swarm-state.json no MCP tool ever read.
-const SWARM_STATE_SUBDIR = 'swarm';
-const SWARM_STATE_FILE = 'swarm-state.json';
-const AGENT_STORE_SUBDIR = 'agents';
-const AGENT_STORE_FILE = 'store.json';
-function getSwarmDir() {
-    return path.join(getMonomindDataRoot(), SWARM_STATE_SUBDIR);
-}
-// Canonical swarm-state.json path. Also pulls a pre-existing legacy
-// `<cwd>/.monomind/swarm/swarm-state.json` into place (copy, never move; no-op once
-// the canonical file exists or when the two paths coincide) so state written by an
-// older CLI isn't silently orphaned — same helper the MCP tools use.
-function getSwarmStateFile() {
-    const file = path.join(getSwarmDir(), SWARM_STATE_FILE);
-    migrateLegacyStoreFile(file, path.join(SWARM_STATE_SUBDIR, SWARM_STATE_FILE));
-    return file;
-}
-function getAgentStoreFile() {
-    const file = path.join(getMonomindDataRoot(), AGENT_STORE_SUBDIR, AGENT_STORE_FILE);
-    migrateLegacyStoreFile(file, path.join(AGENT_STORE_SUBDIR, AGENT_STORE_FILE));
-    return file;
-}
-// Get dynamic swarm status from MCP-canonical state files
-function getSwarmStatus(swarmId) {
-    const projectCwd = getProjectCwd();
-    const sessionDir = path.join(projectCwd, '.claude', 'sessions');
-    const memoryPaths = [
-        path.join(projectCwd, '.monomind', 'memory.db'),
-        path.join(projectCwd, '.claude', 'memory.db'),
-    ];
-    // Read swarm state from the MCP-canonical path
-    const swarmStateFile = getSwarmStateFile();
-    let swarmState = null;
-    if (fs.existsSync(swarmStateFile)) {
-        try {
-            const swarmStatSz = fs.statSync(swarmStateFile).size;
-            if (swarmStatSz <= 10_485_760) {
-                const store = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
-                // MCP swarm-tools stores { swarms: { [id]: SwarmState } }
-                if (store?.swarms && typeof store.swarms === 'object') {
-                    const swarms = store.swarms;
-                    if (swarmId && swarms[swarmId]) {
-                        swarmState = swarms[swarmId];
-                    }
-                    else {
-                        // Find latest non-terminated swarm
-                        const running = Object.values(swarms)
-                            .filter((s) => s.status !== 'terminated')
-                            .sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')));
-                        if (running.length > 0)
-                            swarmState = running[0];
-                    }
-                }
-                else if (store?.id || store?.swarmId) {
-                    // Legacy CLI-written format { id, topology, ... }
-                    swarmState = store;
-                }
-            }
-        }
-        catch {
-            // Ignore parse errors
-        }
-    }
-    // Count agents from the MCP-canonical agent store (the same physical file
-    // agent_spawn writes to — see getAgentStoreFile()).
-    let activeAgents = 0;
-    let totalAgents = 0;
-    const agentStoreFile = getAgentStoreFile();
-    if (fs.existsSync(agentStoreFile)) {
-        try {
-            const agentSz = fs.statSync(agentStoreFile).size;
-            if (agentSz <= 52_428_800) {
-                const agentStore = JSON.parse(fs.readFileSync(agentStoreFile, 'utf-8'));
-                if (agentStore?.agents && typeof agentStore.agents === 'object') {
-                    for (const agent of Object.values(agentStore.agents)) {
-                        totalAgents++;
-                        if (agent.status === 'idle' || agent.status === 'busy') {
-                            activeAgents++;
-                        }
-                    }
-                }
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
-    // Get session count
-    let sessionCount = 0;
-    if (fs.existsSync(sessionDir)) {
-        try {
-            sessionCount = fs.readdirSync(sessionDir).filter(f => f.endsWith('.json')).length;
-        }
-        catch {
-            // Ignore
-        }
-    }
-    // Get memory size as rough indicator of activity
-    let memorySize = 0;
-    for (const dbPath of memoryPaths) {
-        if (fs.existsSync(dbPath)) {
-            try {
-                memorySize = fs.statSync(dbPath).size;
-                break;
-            }
-            catch {
-                // Ignore
-            }
-        }
-    }
-    // Count task files if they exist
-    let completedTasks = 0;
-    let inProgressTasks = 0;
-    let pendingTasks = 0;
-    const tasksDir = path.join(getSwarmDir(), 'tasks');
-    if (fs.existsSync(tasksDir)) {
-        try {
-            const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
-            for (const file of taskFiles) {
-                try {
-                    const taskFilePath = path.join(tasksDir, file);
-                    const taskSz = fs.statSync(taskFilePath).size;
-                    if (taskSz <= 524_288) {
-                        const task = JSON.parse(fs.readFileSync(taskFilePath, 'utf-8'));
-                        if (task.status === 'completed' || task.status === 'done') {
-                            completedTasks++;
-                        }
-                        else if (task.status === 'in_progress' || task.status === 'running') {
-                            inProgressTasks++;
-                        }
-                        else {
-                            pendingTasks++;
-                        }
-                    }
-                }
-                catch {
-                    // Ignore
-                }
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
-    // Calculate dynamic progress based on actual state
-    // If no swarm state, show 0%. Otherwise calculate from completed tasks
-    const totalTasks = completedTasks + inProgressTasks + pendingTasks;
-    let progress = 0;
-    if (totalTasks > 0) {
-        progress = Math.round((completedTasks / totalTasks) * 100);
-    }
-    else if (swarmState) {
-        // Swarm initialized but no tasks yet
-        progress = 5;
-    }
-    // Determine status
-    let status = 'idle';
-    if (inProgressTasks > 0 || activeAgents > 0) {
-        status = 'running';
-    }
-    else if (completedTasks > 0 && pendingTasks === 0 && inProgressTasks === 0) {
-        status = 'completed';
-    }
-    else if (swarmState) {
-        status = 'ready';
-    }
-    return {
-        id: swarmId || swarmState?.swarmId || swarmState?.id || 'no-active-swarm',
-        topology: swarmState?.topology || 'none',
-        status,
-        objective: swarmState?.objective || 'No active objective',
-        strategy: swarmState?.strategy || 'none',
-        agents: {
-            total: totalAgents,
-            active: activeAgents,
-            idle: Math.max(0, totalAgents - activeAgents),
-            completed: 0
-        },
-        progress,
-        tasks: {
-            total: totalTasks,
-            completed: completedTasks,
-            inProgress: inProgressTasks,
-            pending: pendingTasks
-        },
-        metrics: {
-            tokensUsed: 0,
-            avgResponseTime: '--',
-            successRate: totalTasks > 0 ? `${Math.round((completedTasks / totalTasks) * 100)}%` : '--',
-            elapsedTime: '--'
-        },
-        coordination: {
-            consensusRounds: 0,
-            messagesSent: 0,
-            conflictsResolved: 0
-        },
-        hasActiveSwarm: !!swarmState || totalAgents > 0
-    };
-}
-// Swarm topologies
-const TOPOLOGIES = [
-    { value: 'hierarchical', label: 'Hierarchical', hint: 'Queen-led coordination with worker agents' },
-    { value: 'mesh', label: 'Mesh', hint: 'Fully connected peer-to-peer network' },
-    { value: 'ring', label: 'Ring', hint: 'Circular communication pattern' },
-    { value: 'star', label: 'Star', hint: 'Central coordinator with spoke agents' },
-    { value: 'hybrid', label: 'Hybrid', hint: 'Hierarchical mesh for maximum flexibility' },
-    { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'v1 15-agent queen + peer communication (recommended)' }
-];
-// Swarm strategies
-const STRATEGIES = [
-    { value: 'specialized', label: 'Specialized', hint: 'Clear roles, no overlap (anti-drift)' },
-    { value: 'balanced', label: 'Balanced', hint: 'Even distribution of work' },
-    { value: 'adaptive', label: 'Adaptive', hint: 'Dynamic strategy based on task' },
-    { value: 'research', label: 'Research', hint: 'Distributed research and analysis' },
-    { value: 'development', label: 'Development', hint: 'Collaborative code development' },
-    { value: 'testing', label: 'Testing', hint: 'Comprehensive test coverage' },
-    { value: 'optimization', label: 'Optimization', hint: 'Performance optimization' },
-    { value: 'maintenance', label: 'Maintenance', hint: 'Codebase maintenance and refactoring' },
-    { value: 'analysis', label: 'Analysis', hint: 'Code analysis and documentation' }
-];
-// Initialize swarm
-const initCommand = {
-    name: 'init',
-    description: 'Initialize a new swarm',
-    options: [
-        {
-            name: 'topology',
-            short: 't',
-            description: 'Swarm topology',
-            type: 'string',
-            choices: TOPOLOGIES.map(t => t.value),
-            default: 'hierarchical'
-        },
-        {
-            name: 'max-agents',
-            short: 'm',
-            description: 'Maximum number of agents',
-            type: 'number',
-            default: 15
-        },
-        {
-            name: 'auto-scale',
-            description: 'Enable automatic scaling',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'strategy',
-            short: 's',
-            description: 'Coordination strategy',
-            type: 'string',
-            choices: STRATEGIES.map(s => s.value)
-        },
-        {
-            name: 'v1-mode',
-            description: 'Enable v1 15-agent hierarchical mesh mode',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    action: async (ctx) => {
-        let topology = ctx.flags.topology;
-        const maxAgents = ctx.flags['max-agents'] || 15;
-        const v1Mode = ctx.flags.v1Mode;
-        // mode enables hierarchical-mesh hybrid
-        if (v1Mode) {
-            topology = 'hierarchical-mesh';
-            output.printInfo('v1 Mode: Using hierarchical-mesh topology with 15-agent coordination');
-        }
-        // Interactive topology selection
-        if (!topology && ctx.interactive) {
-            topology = await select({
-                message: 'Select swarm topology:',
-                options: TOPOLOGIES,
-                default: 'hierarchical'
-            });
-        }
-        output.writeln();
-        output.printInfo('Initializing swarm...');
-        try {
-            // Call MCP tool to initialize swarm
-            const result = await callMCPTool('swarm_init', {
-                topology: topology,
-                maxAgents,
-                config: {
-                    communicationProtocol: 'message-bus',
-                    consensusMechanism: 'majority',
-                    failureHandling: 'retry',
-                    loadBalancing: true,
-                    autoScaling: ctx.flags['auto-scale'] ?? true,
-                },
-                metadata: {
-                    v1Mode,
-                    strategy: ctx.flags.strategy || 'development',
-                },
-            });
-            // Display initialization progress
-            output.writeln(output.dim('  Creating coordination topology...'));
-            output.writeln(output.dim('  Initializing memory namespace...'));
-            output.writeln(output.dim('  Setting up communication channels...'));
-            if (v1Mode) {
-                output.writeln(output.dim('  Configuring SQLite-backed vector search (ANN)....'));
-                output.writeln(output.dim('  Initializing keyword routing + outcome measurement...'));
-            }
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 20 },
-                    { key: 'value', header: 'Value', width: 35 }
-                ],
-                data: [
-                    { property: 'Swarm ID', value: result.swarmId },
-                    { property: 'Topology', value: result.topology },
-                    { property: 'Max Agents', value: result.config.maxAgents },
-                    { property: 'Auto Scale', value: result.config.autoScaling ? 'Enabled' : 'Disabled' },
-                    { property: 'Protocol', value: result.config.communicationProtocol || 'N/A' },
-                    { property: 'v1 Mode', value: v1Mode ? 'Enabled' : 'Disabled' }
-                ]
-            });
-            output.writeln();
-            output.printSuccess('Swarm initialized successfully');
-            // Save swarm state to MCP-canonical path so CLI and MCP share state
-            try {
-                const swarmDir2 = getSwarmDir();
-                if (!fs.existsSync(swarmDir2)) {
-                    fs.mkdirSync(swarmDir2, { recursive: true });
-                }
-                // Read existing store to preserve other swarms
-                const stateFile = path.join(swarmDir2, SWARM_STATE_FILE);
-                let store = { swarms: {}, version: '3.0.0' };
-                if (fs.existsSync(stateFile)) {
-                    try {
-                        store = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
-                    }
-                    catch { /* use default */ }
-                }
-                if (!store.swarms || typeof store.swarms !== 'object')
-                    store.swarms = {};
-                store.swarms[result.swarmId] = {
-                    swarmId: result.swarmId,
-                    topology: result.topology,
-                    maxAgents: result.config.maxAgents,
-                    status: 'running',
-                    agents: [],
-                    tasks: [],
-                    config: { strategy: ctx.flags.strategy || 'development', v1Mode },
-                    createdAt: result.initializedAt || new Date().toISOString(),
-                    updatedAt: new Date().toISOString()
-                };
-                writeJsonFileAtomic(stateFile, store);
-            }
-            catch (e) {
-                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                    console.error('[swarm-init] failed to persist swarm state file:', e);
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to initialize swarm: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Start swarm execution
-const startCommand = {
-    name: 'start',
-    description: 'Start swarm execution',
-    options: [
-        {
-            name: 'objective',
-            short: 'o',
-            description: 'Swarm objective/task',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'strategy',
-            short: 's',
-            description: 'Execution strategy',
-            type: 'string',
-            choices: STRATEGIES.map(s => s.value)
-        },
-        {
-            name: 'parallel',
-            short: 'p',
-            description: 'Enable parallel execution',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'monitor',
-            description: 'Enable real-time monitoring',
-            type: 'boolean',
-            default: true
-        }
-    ],
-    examples: [
-        { command: 'monomind swarm start -o "Build REST API" -s development', description: 'Start development swarm' },
-        { command: 'monomind swarm start -o "Analyze codebase" --parallel', description: 'Parallel analysis' }
-    ],
-    action: async (ctx) => {
-        const objective = ctx.args[0] || ctx.flags.objective;
-        let strategy = ctx.flags.strategy;
-        if (!objective) {
-            output.printError('Objective is required. Use -o or provide as argument.');
-            return { success: false, exitCode: 1 };
-        }
-        // Interactive strategy selection
-        if (!strategy && ctx.interactive) {
-            strategy = await select({
-                message: 'Select execution strategy:',
-                options: STRATEGIES,
-                default: 'development'
-            });
-        }
-        strategy = strategy || 'development';
-        output.writeln();
-        output.printInfo(`Starting swarm with objective: ${output.highlight(objective)}`);
-        output.writeln();
-        // Compute agent deployment plan based on strategy
-        const agentPlan = getAgentPlan(strategy);
-        output.writeln(output.bold('Agent Deployment Plan'));
-        output.printTable({
-            columns: [
-                { key: 'role', header: 'Role', width: 20 },
-                { key: 'type', header: 'Type', width: 15 },
-                { key: 'count', header: 'Count', width: 8, align: 'right' },
-                { key: 'purpose', header: 'Purpose', width: 30 }
-            ],
-            data: agentPlan
-        });
-        // Confirm execution
-        if (ctx.interactive) {
-            const confirmed = await confirm({
-                message: `Deploy ${agentPlan.reduce((sum, a) => sum + a.count, 0)} agents?`,
-                default: true
-            });
-            if (!confirmed) {
-                output.printInfo('Swarm execution cancelled');
-                return { success: true };
-            }
-        }
-        // Initialize swarm via MCP and persist state (#1423: was stub-only, no actual execution)
-        const swarmId = `swarm-${Date.now().toString(36)}`;
-        const totalAgents = agentPlan.reduce((sum, a) => sum + a.count, 0);
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Initializing swarm via MCP...', spinner: 'dots' });
-        spinner.start();
-        let resolvedSwarmId = swarmId;
-        try {
-            // Actually call MCP to initialize the swarm
-            const initResult = await callMCPTool('swarm_init', {
-                topology: 'hierarchical',
-                maxAgents: totalAgents,
-                strategy: strategy === 'development' ? 'specialized' : strategy,
-            });
-            const mcpData = typeof initResult === 'string' ? JSON.parse(initResult) : initResult;
-            // Prefer the canonical ID assigned by the MCP server over the locally generated one
-            resolvedSwarmId = mcpData?.swarmId ?? mcpData?.id ?? swarmId;
-            spinner.succeed('Swarm initialized via MCP');
-        }
-        catch (err) {
-            // swarm_init runs in-process via the local MCP tool registry — there is no
-            // separate MCP server to "start" here. A failure means the handler itself
-            // threw (bad input, filesystem/config issue, etc.), not that a server is down.
-            spinner.fail('swarm_init failed — swarm metadata saved locally only');
-            output.writeln(output.dim(`  Error: ${err instanceof Error ? err.message : String(err)}`));
-            output.writeln(output.dim('  Run with -v/--verbose for more detail, or `monomind doctor` to check config/permission issues.'));
-        }
-        // Persist swarm state to MCP-canonical path so CLI and MCP share state
-        const swarmDir = getSwarmDir();
-        if (!fs.existsSync(swarmDir))
-            fs.mkdirSync(swarmDir, { recursive: true });
-        // Read existing store to preserve other swarms
-        const stateFile2 = path.join(swarmDir, SWARM_STATE_FILE);
-        let startStore = { swarms: {}, version: '3.0.0' };
-        if (fs.existsSync(stateFile2)) {
-            try {
-                startStore = JSON.parse(fs.readFileSync(stateFile2, 'utf-8'));
-            }
-            catch { /* use default */ }
-        }
-        if (!startStore.swarms || typeof startStore.swarms !== 'object')
-            startStore.swarms = {};
-        startStore.swarms[resolvedSwarmId] = {
-            swarmId: resolvedSwarmId,
-            topology: 'hierarchical',
-            maxAgents: totalAgents,
-            status: 'running',
-            agents: [],
-            tasks: [],
-            config: { strategy, objective, agentPlan, parallel: ctx.flags.parallel ?? true },
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString()
-        };
-        writeJsonFileAtomic(stateFile2, startStore);
-        output.writeln();
-        output.printSuccess(`Swarm ${resolvedSwarmId} initialized with ${totalAgents} agent slots`);
-        output.writeln(output.dim('  Note: Agents are registered but actual task execution requires'));
-        output.writeln(output.dim('  Claude Code Task tool or hive-mind spawn --claude to drive work.'));
-        output.writeln(output.dim(`  Monitor: monomind swarm status ${resolvedSwarmId}`));
-        return { success: true, data: { swarmId: resolvedSwarmId, objective, strategy, agents: totalAgents } };
-    }
-};
-// Swarm status
-const statusCommand = {
-    name: 'status',
-    description: 'Show swarm status',
-    action: async (ctx) => {
-        const swarmId = ctx.args[0];
-        // Get dynamic status from actual swarm state files
-        const status = getSwarmStatus(swarmId);
-        if (ctx.flags.format === 'json') {
-            output.printJson(status);
-            return { success: true, data: status };
-        }
-        output.writeln();
-        // Show different message if no active swarm
-        if (!status.hasActiveSwarm) {
-            output.writeln(output.warning('No active swarm'));
-            output.writeln();
-            output.writeln(output.dim('Start a swarm with:'));
-            output.writeln(output.dim('  npx monomind@latest swarm init'));
-            output.writeln(output.dim('  npx monomind@latest swarm start'));
-            output.writeln();
-            return { success: true, data: status };
-        }
-        output.writeln(output.bold(`Swarm Status: ${status.id}`));
-        output.writeln();
-        // Progress bar
-        output.writeln(`Overall Progress: ${output.progressBar(status.progress, 100, 40)}`);
-        output.writeln();
-        // Agent status
-        output.writeln(output.bold('Agents'));
-        output.printTable({
-            columns: [
-                { key: 'status', header: 'Status', width: 12 },
-                { key: 'count', header: 'Count', width: 10, align: 'right' }
-            ],
-            data: [
-                { status: output.success('Active'), count: status.agents.active },
-                { status: output.warning('Idle'), count: status.agents.idle },
-                { status: output.dim('Completed'), count: status.agents.completed },
-                { status: 'Total', count: status.agents.total }
-            ]
-        });
-        output.writeln();
-        // Task status
-        output.writeln(output.bold('Tasks'));
-        output.printTable({
-            columns: [
-                { key: 'status', header: 'Status', width: 12 },
-                { key: 'count', header: 'Count', width: 10, align: 'right' }
-            ],
-            data: [
-                { status: output.success('Completed'), count: status.tasks.completed },
-                { status: output.info('In Progress'), count: status.tasks.inProgress },
-                { status: output.dim('Pending'), count: status.tasks.pending },
-                { status: 'Total', count: status.tasks.total }
-            ]
-        });
-        output.writeln();
-        // Metrics
-        output.writeln(output.bold('Performance Metrics'));
-        output.printList([
-            `Tokens Used: ${status.metrics.tokensUsed.toLocaleString()}`,
-            `Avg Response Time: ${status.metrics.avgResponseTime}`,
-            `Success Rate: ${status.metrics.successRate}`,
-            `Elapsed Time: ${status.metrics.elapsedTime}`
-        ]);
-        output.writeln();
-        // Coordination stats
-        output.writeln(output.bold('Coordination'));
-        output.printList([
-            `Consensus Rounds: ${status.coordination.consensusRounds}`,
-            `Messages Sent: ${status.coordination.messagesSent}`,
-            `Conflicts Resolved: ${status.coordination.conflictsResolved}`
-        ]);
-        return { success: true, data: status };
-    }
-};
-// Stop swarm
-const stopCommand = {
-    name: 'stop',
-    description: 'Stop swarm execution',
-    options: [
-        {
-            name: 'force',
-            short: 'f',
-            description: 'Force immediate stop',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'save-state',
-            description: 'Save current state for resume',
-            type: 'boolean',
-            default: true
-        }
-    ],
-    action: async (ctx) => {
-        const swarmId = ctx.args[0];
-        const force = ctx.flags.force;
-        if (!swarmId) {
-            output.printError('Swarm ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        if (ctx.interactive && !force) {
-            const confirmed = await confirm({
-                message: `Stop swarm ${swarmId}? Progress will be saved.`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        output.printInfo(`Stopping swarm ${swarmId}...`);
-        // Attempt MCP cleanup first — only persist 'stopped' state if it succeeds
-        let mcpStopped = false;
-        try {
-            await callMCPTool('swarm_shutdown', { swarmId, force });
-            output.writeln(output.dim('  MCP swarm stopped'));
-            mcpStopped = true;
-        }
-        catch (err) {
-            output.printWarning(`MCP stop failed: ${String(err)}`);
-            return { success: false, message: `MCP stop failed: ${String(err)}`, exitCode: 1 };
-        }
-        // Only update persisted swarm state if the MCP call succeeded (#1423)
-        if (mcpStopped) {
-            const stopStateFile = getSwarmStateFile();
-            if (fs.existsSync(stopStateFile)) {
-                try {
-                    const stopStatSz = fs.statSync(stopStateFile).size;
-                    if (stopStatSz > 10_485_760)
-                        throw new Error('swarm state file too large');
-                    const store = JSON.parse(fs.readFileSync(stopStateFile, 'utf-8'));
-                    // Update the specific swarm in the MCP store format
-                    if (store?.swarms?.[swarmId]) {
-                        store.swarms[swarmId].status = 'terminated';
-                        store.swarms[swarmId].updatedAt = new Date().toISOString();
-                    }
-                    else if (store?.id || store?.swarmId) {
-                        // Legacy format
-                        store.status = 'stopped';
-                        store.stoppedAt = new Date().toISOString();
-                    }
-                    writeJsonFileAtomic(stopStateFile, store);
-                    output.writeln(output.dim('  Swarm state updated'));
-                }
-                catch {
-                    output.writeln(output.dim('  Could not update swarm state file'));
-                }
-            }
-        }
-        output.printSuccess(`Swarm ${swarmId} stopped`);
-        return { success: true, data: { swarmId, stopped: true, force } };
-    }
-};
-// Scale swarm
-const scaleCommand = {
-    name: 'scale',
-    description: 'Scale swarm agent count',
-    options: [
-        {
-            name: 'agents',
-            short: 'a',
-            description: 'Target number of agents',
-            type: 'number',
-            required: true
-        },
-        {
-            name: 'type',
-            short: 't',
-            description: 'Agent type to scale',
-            type: 'string'
-        }
-    ],
-    action: async (ctx) => {
-        const swarmId = ctx.args[0];
-        const targetAgents = ctx.flags.agents;
-        const agentType = ctx.flags.type;
-        if (!swarmId) {
-            output.printError('Swarm ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        // 0 is a valid target (scale a swarm down to no agents) — check for
-        // presence, not truthiness.
-        if (targetAgents === undefined || Number.isNaN(targetAgents)) {
-            output.printError('Target agent count required. Use --agents or -a');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Scaling swarm ${swarmId} to ${targetAgents} agents...`);
-        try {
-            const result = await callMCPTool('swarm_scale', { swarmId, targetAgents, agentType });
-            if (!result.success) {
-                output.printError(result.error || 'Failed to scale swarm');
-                return { success: false, exitCode: 1 };
-            }
-            if (result.spawned.length === 0 && result.terminated.length === 0) {
-                output.printInfo('Swarm already at target size');
-                return { success: true, data: result };
-            }
-            if (result.spawned.length > 0) {
-                output.printSuccess(`Spawned ${result.spawned.length} agent(s): ${result.spawned.join(', ')}`);
-            }
-            if (result.terminated.length > 0) {
-                output.printSuccess(`Terminated ${result.terminated.length} agent(s): ${result.terminated.join(', ')}`);
-            }
-            output.writeln(output.dim(`  ${result.previousCount} → ${result.currentCount} agents`));
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(`Scale error: ${error instanceof MCPClientError ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Coordinate command (v1 specific)
-const coordinateCommand = {
-    name: 'coordinate',
-    description: 'Execute v1 15-agent hierarchical mesh coordination',
-    options: [
-        {
-            name: 'agents',
-            description: 'Number of agents',
-            type: 'number',
-            default: 15
-        },
-        {
-            name: 'domains',
-            description: 'Domains to activate',
-            type: 'array'
-        }
-    ],
-    action: async (ctx) => {
-        const agentCount = ctx.flags.agents || 15;
-        output.writeln();
-        output.writeln(output.bold('v1 15-Agent Hierarchical Mesh Coordination'));
-        output.writeln();
-        // agent structure
-        const v1Agents = [
-            { id: 1, role: 'Queen Coordinator', domain: 'Orchestration', status: 'primary' },
-            { id: 2, role: 'Security Architect', domain: 'Security', status: 'active' },
-            { id: 3, role: 'Security Auditor', domain: 'Security', status: 'active' },
-            { id: 4, role: 'Test Architect', domain: 'Security', status: 'active' },
-            { id: 5, role: 'Core Architect', domain: 'Core', status: 'active' },
-            { id: 6, role: 'Memory Specialist', domain: 'Core', status: 'active' },
-            { id: 7, role: 'Swarm Specialist', domain: 'Core', status: 'active' },
-            { id: 8, role: 'Integration Architect', domain: 'Integration', status: 'active' },
-            { id: 9, role: 'Performance Engineer', domain: 'Integration', status: 'active' },
-            { id: 10, role: 'CLI Developer', domain: 'Integration', status: 'active' },
-            { id: 11, role: 'Hooks Developer', domain: 'Integration', status: 'active' },
-            { id: 12, role: 'MCP Specialist', domain: 'Integration', status: 'active' },
-            { id: 13, role: 'Project Coordinator', domain: 'Management', status: 'active' },
-            { id: 14, role: 'Documentation Lead', domain: 'Management', status: 'standby' },
-            { id: 15, role: 'DevOps Engineer', domain: 'Management', status: 'standby' }
-        ].slice(0, agentCount);
-        output.printTable({
-            columns: [
-                { key: 'id', header: '#', width: 3, align: 'right' },
-                { key: 'role', header: 'Role', width: 22 },
-                { key: 'domain', header: 'Domain', width: 15 },
-                { key: 'status', header: 'Status', width: 10, format: (v) => {
-                        if (v === 'primary')
-                            return output.highlight(String(v));
-                        if (v === 'active')
-                            return output.success(String(v));
-                        return output.dim(String(v));
-                    } }
-            ],
-            data: v1Agents
-        });
-        // Actually initialize via MCP instead of just displaying (#1423)
-        output.writeln();
-        try {
-            await callMCPTool('swarm_init', {
-                topology: 'hierarchical-mesh',
-                maxAgents: agentCount,
-                strategy: 'specialized',
-            });
-            output.printSuccess(`Swarm coordination initialized with ${agentCount} agent slots via MCP`);
-        }
-        catch {
-            output.printWarning('MCP unavailable — showing agent plan only (no active coordination)');
-        }
-        output.writeln();
-        output.writeln(output.dim('Note: Use Claude Code Task tool or hive-mind spawn --claude to'));
-        output.writeln(output.dim('drive actual agent execution. This command sets up the topology.'));
-        return { success: true, data: { agents: v1Agents, count: agentCount } };
-    }
-};
-// Main swarm command
-export const swarmCommand = {
-    name: 'swarm',
-    description: 'Swarm coordination commands',
-    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand],
-    options: [],
-    examples: [
-        { command: 'monomind swarm init --v1-mode', description: 'Initialize swarm' },
-        { command: 'monomind swarm start -o "Build API" -s development', description: 'Start development swarm' },
-        { command: 'monomind swarm coordinate --agents 15', description: 'v1 coordination' }
-    ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('Swarm Coordination Commands'));
-        output.writeln();
-        output.writeln('Usage: monomind swarm <subcommand> [options]');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('init')}        - Initialize a new swarm`,
-            `${output.highlight('start')}       - Start swarm execution`,
-            `${output.highlight('status')}      - Show swarm status`,
-            `${output.highlight('stop')}        - Stop swarm execution`,
-            `${output.highlight('scale')}       - Scale swarm agent count`,
-            `${output.highlight('coordinate')}  - 15-agent coordination`
-        ]);
-        return { success: true };
-    }
-};
-// Helper function
-function getAgentPlan(strategy) {
-    const plans = {
-        specialized: [
-            { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Central orchestration (anti-drift)' },
-            { role: 'Researcher', type: 'researcher', count: 1, purpose: 'Requirements analysis' },
-            { role: 'Architect', type: 'architect', count: 1, purpose: 'System design' },
-            { role: 'Coder', type: 'coder', count: 2, purpose: 'Implementation' },
-            { role: 'Tester', type: 'tester', count: 1, purpose: 'Quality assurance' },
-            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Code review' }
-        ],
-        balanced: [
-            { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Orchestrate workflow' },
-            { role: 'Worker', type: 'coder', count: 4, purpose: 'General implementation' },
-            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Quality review' }
-        ],
-        adaptive: [
-            { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Dynamic orchestration' },
-            { role: 'Scout', type: 'researcher', count: 1, purpose: 'Task analysis' },
-            { role: 'Worker', type: 'coder', count: 3, purpose: 'Adaptive execution' }
-        ],
-        development: [
-            { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Orchestrate workflow' },
-            { role: 'Architect', type: 'architect', count: 1, purpose: 'System design' },
-            { role: 'Coder', type: 'coder', count: 3, purpose: 'Implementation' },
-            { role: 'Tester', type: 'tester', count: 2, purpose: 'Quality assurance' },
-            { role: 'Reviewer', type: 'reviewer', count: 1, purpose: 'Code review' }
-        ],
-        research: [
-            { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Research coordination' },
-            { role: 'Researcher', type: 'researcher', count: 4, purpose: 'Data gathering' },
-            { role: 'Analyst', type: 'analyst', count: 2, purpose: 'Analysis and synthesis' }
-        ],
-        testing: [
-            { role: 'Test Lead', type: 'tester', count: 1, purpose: 'Test strategy' },
-            { role: 'Unit Tester', type: 'tester', count: 2, purpose: 'Unit tests' },
-            { role: 'Integration Tester', type: 'tester', count: 2, purpose: 'Integration tests' },
-            { role: 'QA Reviewer', type: 'reviewer', count: 1, purpose: 'Quality review' }
-        ],
-        optimization: [
-            { role: 'Performance Lead', type: 'optimizer', count: 1, purpose: 'Performance strategy' },
-            { role: 'Profiler', type: 'analyst', count: 2, purpose: 'Profiling' },
-            { role: 'Optimizer', type: 'coder', count: 2, purpose: 'Optimization' }
-        ],
-        maintenance: [
-            { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Maintenance planning' },
-            { role: 'Refactorer', type: 'coder', count: 2, purpose: 'Code cleanup' },
-            { role: 'Documenter', type: 'researcher', count: 1, purpose: 'Documentation' }
-        ],
-        analysis: [
-            { role: 'Analyst Lead', type: 'analyst', count: 1, purpose: 'Analysis coordination' },
-            { role: 'Code Analyst', type: 'analyst', count: 2, purpose: 'Code analysis' },
-            { role: 'Security Analyst', type: 'reviewer', count: 1, purpose: 'Security review' }
-        ]
-    };
-    return plans[strategy] || plans.development;
-}
-export default swarmCommand;
-//# sourceMappingURL=swarm.js.map