@monoes/monomindcli 2.9.22 → 2.9.23

package/dist/src/commands/{swarm.js → monoswarm.js}

@@ -1,36 +1,29 @@
 /**
- * CLI Swarm Command
- * Swarm coordination and management commands
+ * CLI Monoswarm Command
+ * Monoswarm 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 '../utils/paths.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';
+// tools (agent-tools.ts / monoswarm-tools.ts / task-tools.ts) read and write the
+// SAME physical files: `.monomind/monoswarm/state.json`. This is a clean break from
+// the pre-rename `.monomind/swarm/swarm-state.json` layout — no migration from that
+// legacy path is performed.
+const SWARM_STATE_SUBDIR = 'monoswarm';
+const SWARM_STATE_FILE = '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.
+// Canonical state.json path — `.monomind/monoswarm/state.json`, shared with the
+// MCP tools.
 function getSwarmStateFile() {
-    const file = path.join(getSwarmDir(), SWARM_STATE_FILE);
-    migrateLegacyStoreFile(file, path.join(SWARM_STATE_SUBDIR, SWARM_STATE_FILE));
-    return file;
+    return path.join(getSwarmDir(), SWARM_STATE_FILE);
 }
 function getAgentStoreFile() {
     const file = path.join(getMonomindDataRoot(), AGENT_STORE_SUBDIR, AGENT_STORE_FILE);
@@ -52,25 +45,12 @@ function getSwarmStatus(swarmId) {
         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;
+                const state = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
+                // monoswarm-tools.ts writes a single flat MonoswarmState object — there
+                // is only one monoswarm per project, so there is no per-id map to look
+                // up (a `swarmId` argument is accepted purely as a display override).
+                if (state?.initialized) {
+                    swarmState = state;
                 }
             }
         }
@@ -181,20 +161,25 @@ function getSwarmStatus(swarmId) {
     else if (swarmState) {
         status = 'ready';
     }
+    const swarmConfig = swarmState?.config;
     return {
         id: swarmId ||
-            swarmState?.swarmId ||
-            swarmState?.id ||
+            swarmState?.monoswarmId ||
             'no-active-swarm',
         topology: swarmState?.topology || 'none',
         status,
-        objective: swarmState?.objective || 'No active objective',
-        strategy: swarmState?.strategy || 'none',
+        // Not tracked in the merged monoswarm state — the state file records
+        // topology/strategy/votes, not a free-text objective.
+        objective: 'No active objective',
+        strategy: swarmConfig?.strategy || 'none',
         agents: {
             total: totalAgents,
             active: activeAgents,
             idle: Math.max(0, totalAgents - activeAgents),
-            completed: 0,
+            // Not tracked anywhere — nothing distinguishes a "completed" agent
+            // from an active/idle one in the agent store. '--' rather than a
+            // fake 0.
+            completed: '--',
         },
         progress,
         tasks: {
@@ -204,16 +189,12 @@ function getSwarmStatus(swarmId) {
             pending: pendingTasks,
         },
         metrics: {
-            tokensUsed: 0,
+            // Token usage isn't tracked here — '--' rather than a fake 0.
+            tokensUsed: '--',
             avgResponseTime: '--',
             successRate: totalTasks > 0 ? `${Math.round((completedTasks / totalTasks) * 100)}%` : '--',
             elapsedTime: '--',
         },
-        coordination: {
-            consensusRounds: 0,
-            messagesSent: 0,
-            conflictsResolved: 0,
-        },
         hasActiveSwarm: !!swarmState || totalAgents > 0,
     };
 }
@@ -254,7 +235,7 @@ const initCommand = {
         {
             name: 'topology',
             short: 't',
-            description: 'Swarm topology',
+            description: 'Monoswarm topology',
             type: 'string',
             choices: TOPOLOGIES.map((t) => t.value),
             default: 'hierarchical',
@@ -266,12 +247,6 @@ const initCommand = {
             type: 'number',
             default: 15,
         },
-        {
-            name: 'auto-scale',
-            description: 'Enable automatic scaling',
-            type: 'boolean',
-            default: true,
-        },
         {
             name: 'strategy',
             short: 's',
@@ -307,15 +282,12 @@ const initCommand = {
         output.printInfo('Initializing swarm...');
         try {
             // Call MCP tool to initialize swarm
-            const result = await callMCPTool('swarm_init', {
+            const result = await callMCPTool('monoswarm_init', {
                 topology: topology,
                 maxAgents,
                 config: {
-                    communicationProtocol: 'message-bus',
-                    consensusMechanism: 'majority',
                     failureHandling: 'retry',
                     loadBalancing: true,
-                    autoScaling: ctx.flags['auto-scale'] ?? true,
                 },
                 metadata: {
                     v1Mode,
@@ -323,7 +295,7 @@ const initCommand = {
                 },
             });
             // Display initialization progress
-            output.writeln(output.dim(`  Wrote swarm config: ${result.swarmId}`));
+            output.writeln(output.dim(`  Wrote swarm config: ${result.monoswarmId}`));
             if (v1Mode) {
                 output.writeln(output.dim('  (v1-mode: topology renamed to hierarchical-mesh; no ANN or keyword routing is performed during init)'));
             }
@@ -334,55 +306,18 @@ const initCommand = {
                     { key: 'value', header: 'Value', width: 35 },
                 ],
                 data: [
-                    { property: 'Swarm ID', value: result.swarmId },
+                    { property: 'Monoswarm ID', value: result.monoswarmId },
                     { 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,
-                    // P0-4: no agents are actually running yet at init time — the
-                    // printed message says so; the persisted state must agree, or
-                    // `swarm status --format json` contradicts the human-readable output.
-                    status: 'configured',
-                    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);
-            }
+            output.printSuccess('Monoswarm initialized successfully');
+            // No further write here: monoswarm_init already persisted the canonical
+            // state to `.monomind/monoswarm/state.json` (a single flat record — the
+            // CLI and the MCP tools share exactly that one file, so writing a second,
+            // differently-shaped copy would overwrite the tool's own record).
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
             }
@@ -407,7 +342,7 @@ const startCommand = {
         {
             name: 'objective',
             short: 'o',
-            description: 'Swarm objective/task',
+            description: 'Monoswarm objective/task',
             type: 'string',
             required: true,
         },
@@ -425,20 +360,14 @@ const startCommand = {
             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',
+            command: 'monomind monoswarm start -o "Build REST API" -s development',
             description: 'Start development swarm',
         },
         {
-            command: 'monomind swarm start -o "Analyze codebase" --parallel',
+            command: 'monomind monoswarm start -o "Analyze codebase" --parallel',
             description: 'Parallel analysis',
         },
     ],
@@ -480,7 +409,7 @@ const startCommand = {
                 default: true,
             });
             if (!confirmed) {
-                output.printInfo('Swarm execution cancelled');
+                output.printInfo('Monoswarm execution cancelled');
                 return { success: true };
             }
         }
@@ -496,58 +425,32 @@ const startCommand = {
         let resolvedSwarmId = swarmId;
         try {
             // Actually call MCP to initialize the swarm
-            const initResult = await callMCPTool('swarm_init', {
+            const initResult = await callMCPTool('monoswarm_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');
+            // Prefer the canonical ID assigned by the MCP tool over the locally generated one
+            resolvedSwarmId = mcpData?.monoswarmId ?? swarmId;
+            spinner.succeed('Monoswarm initialized via MCP');
         }
         catch (err) {
-            // swarm_init runs in-process via the local MCP tool registry — there is no
+            // monoswarm_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');
+            spinner.fail('monoswarm_init failed — monoswarm 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,
-            // P0-4: same fix as swarm init — persisted status must match the
-            // "No agents are running" message below, not claim 'running'.
-            status: 'configured',
-            agents: [],
-            tasks: [],
-            config: { strategy, objective, agentPlan, parallel: ctx.flags.parallel ?? true },
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-        writeJsonFileAtomic(stateFile2, startStore);
+        // No further write here: monoswarm_init (called above) already persisted
+        // the canonical state to `.monomind/monoswarm/state.json` — a single flat
+        // record shared with the MCP tools, not a per-id map. `objective` and
+        // `agentPlan` are display-only for this command; they are not tracked in
+        // the merged monoswarm state (see getSwarmStatus()'s objective field).
         output.writeln();
-        output.printSuccess(`Swarm ${resolvedSwarmId} config written (${totalAgents} agent slots reserved). No agents are running — use 'agent spawn' or hive-mind spawn --claude to dispatch Task-tool agents.`);
-        output.writeln(output.dim(`  Monitor: monomind swarm status ${resolvedSwarmId}`));
+        output.printSuccess(`Monoswarm ${resolvedSwarmId} config written (${totalAgents} agent slots reserved). No agents are running — use 'agent spawn' to dispatch Task-tool agents.`);
+        output.writeln(output.dim(`  Monitor: monomind monoswarm status ${resolvedSwarmId}`));
         return {
             success: true,
             data: { swarmId: resolvedSwarmId, objective, strategy, agents: totalAgents },
@@ -572,12 +475,12 @@ const statusCommand = {
             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(output.dim('  npx monomind@latest monoswarm init'));
+            output.writeln(output.dim('  npx monomind@latest monoswarm start'));
             output.writeln();
             return { success: true, data: status };
         }
-        output.writeln(output.bold(`Swarm Status: ${status.id}`));
+        output.writeln(output.bold(`Monoswarm Status: ${status.id}`));
         output.writeln();
         // Progress bar
         output.writeln(`Overall Progress: ${output.progressBar(status.progress, 100, 40)}`);
@@ -615,19 +518,11 @@ const statusCommand = {
         // Metrics
         output.writeln(output.bold('Performance Metrics'));
         output.printList([
-            `Tokens Used: ${status.metrics.tokensUsed.toLocaleString()}`,
+            `Tokens Used: ${status.metrics.tokensUsed}`,
             `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 };
     },
 };
@@ -654,7 +549,7 @@ const stopCommand = {
         const swarmId = ctx.args[0];
         const force = ctx.flags.force;
         if (!swarmId) {
-            output.printError('Swarm ID is required');
+            output.printError('Monoswarm ID is required');
             return { success: false, exitCode: 1 };
         }
         if (ctx.interactive && !force) {
@@ -668,45 +563,17 @@ const stopCommand = {
             }
         }
         output.printInfo(`Stopping swarm ${swarmId}...`);
-        // Attempt MCP cleanup first — only persist 'stopped' state if it succeeds
-        let mcpStopped = false;
+        // monoswarm_shutdown marks the canonical state file terminated and clears
+        // the roster itself — no further local write is needed here.
         try {
-            await callMCPTool('swarm_shutdown', { swarmId, force });
-            output.writeln(output.dim('  MCP swarm stopped'));
-            mcpStopped = true;
+            await callMCPTool('monoswarm_shutdown', { swarmId, force });
+            output.writeln(output.dim('  Monoswarm state updated'));
         }
         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`);
+        output.printSuccess(`Monoswarm ${swarmId} stopped`);
         return { success: true, data: { swarmId, stopped: true, force } };
     },
 };
@@ -734,7 +601,7 @@ const scaleCommand = {
         const targetAgents = ctx.flags.agents;
         const agentType = ctx.flags.type;
         if (!swarmId) {
-            output.printError('Swarm ID is required');
+            output.printError('Monoswarm ID is required');
             return { success: false, exitCode: 1 };
         }
         // 0 is a valid target (scale a swarm down to no agents) — check for
@@ -745,13 +612,13 @@ const scaleCommand = {
         }
         output.printInfo(`Scaling swarm ${swarmId} to ${targetAgents} agents...`);
         try {
-            const result = await callMCPTool('swarm_scale', { swarmId, targetAgents, agentType });
+            const result = await callMCPTool('monoswarm_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');
+                output.printInfo('Monoswarm already at target size');
                 return { success: true, data: result };
             }
             if (result.spawned.length > 0) {
@@ -769,119 +636,38 @@ const scaleCommand = {
         }
     },
 };
-// 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 config written (${agentCount} agent slots reserved) via MCP. No agents are running.`);
-        }
-        catch {
-            output.printWarning('MCP unavailable — showing agent plan only (no swarm state written)');
-        }
-        output.writeln();
-        output.writeln(output.dim('Use Claude Code Task tool or hive-mind spawn --claude to drive actual agent execution.'));
-        return { success: true, data: { agents: v1Agents, count: agentCount } };
-    },
-};
 // Main swarm command
-export const swarmCommand = {
-    name: 'swarm',
-    description: 'Swarm coordination commands',
+export const monoswarmCommand = {
+    name: 'monoswarm',
+    description: 'Monoswarm coordination commands',
     subcommands: [
         initCommand,
         startCommand,
         statusCommand,
         stopCommand,
         scaleCommand,
-        coordinateCommand,
     ],
     options: [],
     examples: [
-        { command: 'monomind swarm init --v1-mode', description: 'Initialize swarm' },
+        { command: 'monomind monoswarm init --v1-mode', description: 'Initialize monoswarm' },
         {
-            command: 'monomind swarm start -o "Build API" -s development',
-            description: 'Start development swarm',
+            command: 'monomind monoswarm start -o "Build API" -s development',
+            description: 'Start development monoswarm',
         },
-        { command: 'monomind swarm coordinate --agents 15', description: 'v1 coordination' },
     ],
     action: async (ctx) => {
         output.writeln();
-        output.writeln(output.bold('Swarm Coordination Commands'));
+        output.writeln(output.bold('Monoswarm Coordination Commands'));
         output.writeln();
-        output.writeln('Usage: monomind swarm <subcommand> [options]');
+        output.writeln('Usage: monomind monoswarm <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`,
+            `${output.highlight('init')}        - Initialize a new monoswarm`,
+            `${output.highlight('start')}       - Start monoswarm execution`,
+            `${output.highlight('status')}      - Show monoswarm status`,
+            `${output.highlight('stop')}        - Stop monoswarm execution`,
+            `${output.highlight('scale')}       - Scale monoswarm agent count`,
         ]);
         return { success: true };
     },
@@ -948,5 +734,5 @@ function getAgentPlan(strategy) {
     };
     return plans[strategy] || plans.development;
 }
-export default swarmCommand;
-//# sourceMappingURL=swarm.js.map
+export default monoswarmCommand;
+//# sourceMappingURL=monoswarm.js.map