monomind 2.7.4 → 2.7.6

package/packages/@monomind/cli/dist/src/commands/hive-mind-helpers.js

@@ -1,203 +0,0 @@
-/**
- * Hive Mind shared types, constants, and format helpers
- */
-import { output } from '../output.js';
-// Input length caps
-export const MAX_OBJECTIVE_LEN = 2_000;
-export const MAX_TASK_DESC_LEN = 4_000;
-export const MAX_MESSAGE_LEN = 2_000;
-export const MAX_KEY_LEN = 256;
-export const MAX_VALUE_LEN = 65_536;
-export const MAX_AGENT_ID_LEN = 128;
-export const TOPOLOGIES = [
-    { value: 'hierarchical', label: 'Hierarchical', hint: 'Queen-led with worker agents' },
-    { value: 'mesh', label: 'Mesh', hint: 'Peer-to-peer coordination' },
-    { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'Queen + peer communication (recommended)' },
-    { value: 'adaptive', label: 'Adaptive', hint: 'Dynamic topology based on task' }
-];
-export const CONSENSUS_STRATEGIES = [
-    { value: 'byzantine', label: 'Byzantine Fault Tolerant', hint: '2/3 majority, handles malicious actors' },
-    { value: 'raft', label: 'Raft', hint: 'Leader-based consensus' },
-    { value: 'gossip', label: 'Gossip', hint: 'Eventually consistent, scalable (planned — not yet implemented)' },
-    { value: 'crdt', label: 'CRDT', hint: 'Conflict-free replicated data (planned — not yet implemented)' },
-    { value: 'quorum', label: 'Quorum', hint: 'Simple majority voting' }
-];
-export function groupWorkersByType(workers) {
-    const groups = {};
-    for (const worker of workers) {
-        const type = worker.type || worker.role || 'worker';
-        if (!groups[type]) {
-            groups[type] = [];
-        }
-        groups[type].push(worker);
-    }
-    return groups;
-}
-export function generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGroups, flags) {
-    const currentTime = new Date().toISOString();
-    const workerTypes = Object.keys(workerGroups);
-    const queenType = flags.queenType || 'strategic';
-    const consensusAlgorithm = flags.consensus || 'byzantine';
-    const topology = flags.topology || 'hierarchical-mesh';
-    return `🧠 HIVE MIND COLLECTIVE INTELLIGENCE SYSTEM
-═══════════════════════════════════════════════
-
-You are the Queen coordinator of a Hive Mind swarm with collective intelligence capabilities.
-
-HIVE MIND CONFIGURATION:
-📌 Swarm ID: ${swarmId}
-📌 Swarm Name: ${swarmName}
-🎯 Objective: ${objective}
-👑 Queen Type: ${queenType}
-🐝 Worker Count: ${workers.length}
-🔗 Topology: ${topology}
-🤝 Consensus Algorithm: ${consensusAlgorithm}
-⏰ Initialized: ${currentTime}
-
-WORKER DISTRIBUTION:
-${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).join('\n')}
-
-🔧 AVAILABLE MCP TOOLS FOR HIVE MIND COORDINATION:
-
-1️⃣ **COLLECTIVE INTELLIGENCE**
-   mcp__monomind__hive-mind_consensus    - Democratic decision making
-   mcp__monomind__hive-mind_memory       - Share knowledge across the hive
-   mcp__monomind__hive-mind_broadcast    - Broadcast to all workers
-   mcp__monomind__neural_patterns        - Neural pattern recognition
-
-2️⃣ **QUEEN COORDINATION**
-   mcp__monomind__hive-mind_status       - Monitor swarm health
-   mcp__monomind__task_create            - Create and delegate tasks
-   mcp__monomind__coordination_orchestrate - Orchestrate task distribution
-   mcp__monomind__agent_spawn            - Spawn additional workers
-
-3️⃣ **WORKER MANAGEMENT**
-   mcp__monomind__agent_list             - List all active agents
-   mcp__monomind__agent_status           - Check agent status
-   mcp__monomind__agent_health           - Check worker health
-   mcp__monomind__hive-mind_join         - Add agent to hive
-   mcp__monomind__hive-mind_leave        - Remove agent from hive
-
-4️⃣ **TASK ORCHESTRATION**
-   mcp__monomind__task_assign            - Assign tasks to workers
-   mcp__monomind__task_status            - Track task progress
-   mcp__monomind__task_complete          - Mark tasks complete
-   mcp__monomind__workflow_create        - Create workflows
-
-5️⃣ **MEMORY & LEARNING**
-   mcp__monomind__memory_store           - Store collective knowledge
-   mcp__monomind__memory_retrieve        - Access shared memory
-   mcp__monomind__memory_search          - Search memory patterns
-   mcp__monomind__neural_train           - Learn from experiences
-   mcp__monomind__hooks_intelligence_pattern-store - Store patterns
-
-📋 HIVE MIND EXECUTION PROTOCOL:
-
-1. **INITIALIZATION PHASE**
-   - Verify all workers are online and responsive
-   - Establish communication channels
-   - Load previous session state if available
-   - Initialize shared memory space
-
-2. **TASK DISTRIBUTION PHASE**
-   - Analyze the objective and decompose into subtasks
-   - Assign tasks based on worker specializations
-   - Set up task dependencies and ordering
-   - Monitor parallel execution
-
-3. **COORDINATION PHASE**
-   - Use consensus for critical decisions
-   - Aggregate results from workers
-   - Resolve conflicts using ${consensusAlgorithm} consensus
-   - Share learnings across the hive
-
-4. **COMPLETION PHASE**
-   - Verify all subtasks are complete
-   - Consolidate results
-   - Store learnings in collective memory
-   - Report final status
-
-🎯 YOUR OBJECTIVE:
-${objective}
-
-⚠️ CRITICAL — TOOL PREFERENCE RULES (#1422):
-• You MUST use Monomind MCP tools (mcp__monomind__*) for ALL orchestration tasks
-• Do NOT use Claude native Task/Agent tools for swarm coordination — use mcp__monomind__agent_spawn, mcp__monomind__task_assign, etc.
-• Native Claude tools (Read, Write, Edit, Bash, Grep, Glob) should ONLY be used for file operations and shell commands
-• All agent spawning, task assignment, memory, and coordination MUST go through mcp__monomind__* tools
-• If a Monomind MCP tool exists for an operation, always prefer it over any native equivalent
-
-💡 COORDINATION TIPS:
-• Use mcp__monomind__hive-mind_broadcast for swarm-wide announcements
-• Check worker status regularly with mcp__monomind__hive-mind_status
-• Store important decisions in shared memory for persistence
-• Use consensus for any decisions affecting multiple workers
-• Use mcp__monomind__task_assign to assign tasks to workers, then mcp__monomind__task_complete when done
-
-🚀 BEGIN HIVE MIND COORDINATION NOW!
-Start by checking the current hive status and then proceed with the objective.
-`;
-}
-export function formatAgentStatus(status) {
-    const statusStr = String(status);
-    switch (statusStr) {
-        case 'active':
-        case 'ready':
-        case 'running':
-            return output.success(statusStr);
-        case 'idle':
-        case 'waiting':
-            return output.dim(statusStr);
-        case 'busy':
-            return output.highlight(statusStr);
-        case 'error':
-        case 'failed':
-            return output.error(statusStr);
-        default:
-            return statusStr;
-    }
-}
-export function formatHiveStatus(status) {
-    switch (status) {
-        case 'active':
-            return output.success(status);
-        case 'idle':
-            return output.dim(status);
-        case 'degraded':
-            return output.warning(status);
-        case 'offline':
-            return output.error(status);
-        default:
-            return status;
-    }
-}
-export function formatHealth(health) {
-    switch (health) {
-        case 'healthy':
-        case 'good':
-            return output.success(health);
-        case 'warning':
-        case 'degraded':
-            return output.warning(health);
-        case 'critical':
-        case 'unhealthy':
-            return output.error(health);
-        default:
-            return health;
-    }
-}
-export function formatPriority(priority) {
-    switch (priority) {
-        case 'critical':
-            return output.error(priority.toUpperCase());
-        case 'high':
-            return output.warning(priority);
-        case 'normal':
-            return priority;
-        case 'low':
-            return output.dim(priority);
-        default:
-            return priority;
-    }
-}
-//# sourceMappingURL=hive-mind-helpers.js.map

package/packages/@monomind/cli/dist/src/commands/hive-mind-ops.d.ts

@@ -1,6 +0,0 @@
-/**
- * Hive Mind operational subcommands — status
- */
-import type { Command } from '../types.js';
-export declare const statusCommand: Command;
-//# sourceMappingURL=hive-mind-ops.d.ts.map

package/packages/@monomind/cli/dist/src/commands/hive-mind-ops.js

@@ -1,119 +0,0 @@
-/**
- * Hive Mind operational subcommands — status
- */
-import { output } from '../output.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { formatAgentStatus, formatHiveStatus, formatHealth, } from './hive-mind-helpers.js';
-export const statusCommand = {
-    name: 'status',
-    description: 'Show hive mind status',
-    options: [
-        { name: 'detailed', short: 'd', description: 'Show detailed metrics', type: 'boolean', default: false },
-        { name: 'watch', short: 'w', description: 'Watch for changes', type: 'boolean', default: false }
-    ],
-    action: async (ctx) => {
-        const detailed = ctx.flags.detailed;
-        try {
-            const result = await callMCPTool('hive-mind_status', {
-                includeMetrics: detailed,
-                includeWorkers: true,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            const flexResult = result;
-            const hiveId = result.hiveId ?? flexResult.id ?? 'default';
-            const status = result.status ?? (flexResult.initialized ? 'running' : 'stopped');
-            const queen = result.queen ?? { id: 'N/A', status: 'unknown', load: 0, tasksQueued: 0 };
-            const flexQueen = queen;
-            const queenId = typeof queen === 'object' ? (queen.id ?? flexQueen.agentId ?? 'N/A') : String(queen);
-            const queenLoad = typeof queen === 'object' ? (queen.load ?? 0) : 0;
-            const queenTasks = typeof queen === 'object' ? (queen.tasksQueued ?? 0) : 0;
-            const queenStatus = typeof queen === 'object' ? (queen.status ?? 'active') : 'active';
-            output.writeln();
-            output.printBox([
-                `Hive ID: ${hiveId}`,
-                `Status: ${formatHiveStatus(String(status))}`,
-                `Topology: ${result.topology ?? 'mesh'}`,
-                `Consensus: ${result.consensus ?? 'byzantine'}`,
-                '',
-                `Queen: ${queenId}`,
-                `  Status: ${formatAgentStatus(queenStatus)}`,
-                `  Load: ${(queenLoad * 100).toFixed(1)}%`,
-                `  Queued Tasks: ${queenTasks}`
-            ].join('\n'), 'Hive Mind Status');
-            const workers = result.workers ?? [];
-            const workerData = Array.isArray(workers) ? workers.map(w => {
-                if (typeof w === 'string') {
-                    return { id: w, type: 'worker', status: 'idle', currentTask: '-', tasksCompleted: 0 };
-                }
-                const flexWorker = w;
-                return {
-                    id: w.id ?? flexWorker.agentId ?? 'unknown',
-                    type: w.type ?? flexWorker.agentType ?? 'worker',
-                    status: w.status ?? 'idle',
-                    currentTask: w.currentTask ?? '-',
-                    tasksCompleted: w.tasksCompleted ?? 0
-                };
-            }) : [];
-            output.writeln();
-            output.writeln(output.bold('Worker Agents'));
-            if (workerData.length === 0) {
-                output.printInfo('No workers in hive. Use "monomind hive-mind spawn" to add workers.');
-            }
-            else {
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'ID', width: 20 },
-                        { key: 'type', header: 'Type', width: 12 },
-                        { key: 'status', header: 'Status', width: 10, format: formatAgentStatus },
-                        { key: 'currentTask', header: 'Current Task', width: 20, format: (v) => String(v || '-') },
-                        { key: 'tasksCompleted', header: 'Completed', width: 10, align: 'right' }
-                    ],
-                    data: workerData
-                });
-            }
-            if (detailed) {
-                const metrics = result.metrics ?? { totalTasks: 0, completedTasks: 0, failedTasks: 0, avgTaskTime: 0, consensusRounds: 0, memoryUsage: '0 MB' };
-                output.writeln();
-                output.writeln(output.bold('Metrics'));
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 20 },
-                        { key: 'value', header: 'Value', width: 15, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Total Tasks', value: metrics.totalTasks ?? 0 },
-                        { metric: 'Completed', value: metrics.completedTasks ?? 0 },
-                        { metric: 'Failed', value: metrics.failedTasks ?? 0 },
-                        { metric: 'Avg Task Time', value: `${(metrics.avgTaskTime ?? 0).toFixed(1)}ms` },
-                        { metric: 'Consensus Rounds', value: metrics.consensusRounds ?? 0 },
-                        { metric: 'Memory Usage', value: metrics.memoryUsage ?? '0 MB' }
-                    ]
-                });
-                const health = result.health ?? { overall: 'healthy', queen: 'healthy', workers: 'healthy', consensus: 'healthy', memory: 'healthy' };
-                output.writeln();
-                output.writeln(output.bold('Health'));
-                output.printList([
-                    `Overall: ${formatHealth(health.overall ?? 'healthy')}`,
-                    `Queen: ${formatHealth(health.queen ?? 'healthy')}`,
-                    `Workers: ${formatHealth(health.workers ?? 'healthy')}`,
-                    `Consensus: ${formatHealth(health.consensus ?? 'healthy')}`,
-                    `Memory: ${formatHealth(health.memory ?? 'healthy')}`
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Status error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-//# sourceMappingURL=hive-mind-ops.js.map

package/packages/@monomind/cli/dist/src/commands/hive-mind-spawn.d.ts

@@ -1,12 +0,0 @@
-/**
- * Hive Mind spawn infrastructure — spawnClaudeCodeInstance and spawnCommand
- */
-import type { Command } from '../types.js';
-import { type HiveWorker } from './hive-mind-helpers.js';
-export declare function spawnClaudeCodeInstance(swarmId: string, swarmName: string, objective: string, workers: HiveWorker[], flags: Record<string, unknown>): Promise<{
-    success: boolean;
-    promptFile?: string;
-    error?: string;
-}>;
-export declare const spawnCommand: Command;
-//# sourceMappingURL=hive-mind-spawn.d.ts.map

package/packages/@monomind/cli/dist/src/commands/hive-mind-spawn.js

@@ -1,274 +0,0 @@
-/**
- * Hive Mind spawn infrastructure — spawnClaudeCodeInstance and spawnCommand
- */
-import { output } from '../output.js';
-import { input } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { spawn as childSpawn, execSync } from 'child_process';
-import { mkdir, writeFile } from 'fs/promises';
-import { join, resolve as resolvePath, sep } from 'path';
-import { MAX_OBJECTIVE_LEN, groupWorkersByType, generateHiveMindPrompt, formatAgentStatus, } from './hive-mind-helpers.js';
-export async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, flags) {
-    output.writeln();
-    output.writeln(output.bold('🚀 Launching Claude Code with Hive Mind Coordination'));
-    output.writeln(output.dim('─'.repeat(60)));
-    const spinner = output.createSpinner({ text: 'Preparing Hive Mind coordination prompt...', spinner: 'dots' });
-    spinner.start();
-    try {
-        const workerGroups = groupWorkersByType(workers);
-        const hiveMindPrompt = generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGroups, flags);
-        spinner.succeed('Hive Mind coordination prompt ready!');
-        output.writeln();
-        output.writeln(output.bold('🧠 Hive Mind Configuration'));
-        output.writeln(output.dim('─'.repeat(60)));
-        output.printList([
-            `Swarm ID: ${output.highlight(swarmId)}`,
-            `Objective: ${output.highlight(objective)}`,
-            `Queen Type: ${output.highlight(flags.queenType || 'strategic')}`,
-            `Worker Count: ${output.highlight(String(workers.length))}`,
-            `Worker Types: ${output.highlight(Object.keys(workerGroups).join(', '))}`,
-            `Consensus: ${output.highlight(flags.consensus || 'byzantine')}`,
-            `MCP Tools: ${output.success('Full Monomind integration enabled')}`
-        ]);
-        // Ensure sessions directory exists, anchored to cwd to prevent traversal
-        const baseDir = resolvePath(process.cwd());
-        const sessionsDir = resolvePath(baseDir, '.hive-mind', 'sessions');
-        if (!sessionsDir.startsWith(baseDir + sep) && sessionsDir !== baseDir) {
-            throw new Error('Sessions directory path traversal detected');
-        }
-        await mkdir(sessionsDir, { recursive: true });
-        const safeSwarmId = swarmId.replace(/[^a-zA-Z0-9_-]/g, '_');
-        const promptFile = join(sessionsDir, `hive-mind-prompt-${safeSwarmId}.txt`);
-        if (!resolvePath(promptFile).startsWith(sessionsDir + sep)) {
-            throw new Error('Prompt file path traversal detected');
-        }
-        await writeFile(promptFile, hiveMindPrompt, 'utf8');
-        output.writeln();
-        output.printSuccess(`Hive Mind prompt saved to: ${promptFile}`);
-        let claudeAvailable = false;
-        try {
-            execSync('which claude', { stdio: 'ignore' });
-            claudeAvailable = true;
-        }
-        catch {
-            output.writeln();
-            output.printWarning('Claude Code CLI not found in PATH');
-            output.writeln(output.dim('Install it with: npm install -g @anthropic-ai/claude-code'));
-            output.writeln(output.dim('Falling back to displaying instructions...'));
-        }
-        const dryRun = flags.dryRun || flags['dry-run'];
-        if (claudeAvailable && !dryRun) {
-            const claudeArgs = [];
-            const isNonInteractive = flags['non-interactive'] || flags.nonInteractive;
-            if (isNonInteractive) {
-                claudeArgs.push('-p');
-                claudeArgs.push('--output-format', 'stream-json');
-                claudeArgs.push('--verbose');
-                output.printInfo('Running in non-interactive mode');
-            }
-            const skipPermissions = flags['dangerously-skip-permissions'] === true && !flags['no-auto-permissions'];
-            if (skipPermissions) {
-                claudeArgs.push('--dangerously-skip-permissions');
-                output.writeln(output.warning('WARNING: Running with --dangerously-skip-permissions: all file and shell operations will execute without prompts.'));
-            }
-            claudeArgs.push('--');
-            claudeArgs.push(hiveMindPrompt);
-            output.writeln();
-            output.printInfo('Launching Claude Code...');
-            output.writeln(output.dim('Press Ctrl+C to pause the session'));
-            const claudeProcess = childSpawn('claude', claudeArgs, {
-                stdio: 'inherit',
-                shell: false,
-            });
-            let isExiting = false;
-            const sigintHandler = () => {
-                if (isExiting)
-                    return;
-                isExiting = true;
-                output.writeln();
-                output.writeln();
-                output.printWarning('Pausing session and terminating Claude Code...');
-                if (claudeProcess && !claudeProcess.killed) {
-                    claudeProcess.kill('SIGTERM');
-                }
-                output.writeln();
-                output.printSuccess('Session paused');
-                output.writeln(output.dim(`Prompt file saved at: ${promptFile}`));
-                output.writeln(output.dim('To resume, run claude with the saved prompt file'));
-                process.exit(0);
-            };
-            process.on('SIGINT', sigintHandler);
-            process.on('SIGTERM', sigintHandler);
-            claudeProcess.on('exit', (code) => {
-                process.removeListener('SIGINT', sigintHandler);
-                process.removeListener('SIGTERM', sigintHandler);
-                if (code === 0) {
-                    output.writeln();
-                    output.printSuccess('Claude Code completed successfully');
-                }
-                else if (code !== null) {
-                    output.writeln();
-                    output.printError(`Claude Code exited with code ${code}`);
-                }
-            });
-            output.writeln();
-            output.printSuccess('Claude Code launched with Hive Mind coordination');
-            output.printInfo('The Queen coordinator will orchestrate all worker agents');
-            output.writeln(output.dim(`Prompt file saved at: ${promptFile}`));
-            return { success: true, promptFile };
-        }
-        else if (dryRun) {
-            output.writeln();
-            output.printInfo('Dry run - would execute Claude Code with prompt:');
-            output.writeln(output.dim(`Prompt length: ${hiveMindPrompt.length} characters`));
-            output.writeln();
-            output.writeln(output.dim('First 500 characters of prompt:'));
-            output.writeln(output.highlight(hiveMindPrompt.substring(0, 500) + '...'));
-            output.writeln();
-            output.writeln(output.dim(`Full prompt saved to: ${promptFile}`));
-            return { success: true, promptFile };
-        }
-        else {
-            output.writeln();
-            output.writeln(output.bold('📋 Manual Execution Instructions:'));
-            output.writeln(output.dim('─'.repeat(50)));
-            output.printList([
-                'Install Claude Code: npm install -g @anthropic-ai/claude-code',
-                `Run with saved prompt: claude < ${promptFile}`,
-                `Or copy manually: cat ${promptFile} | claude`,
-                `With auto-permissions: claude --dangerously-skip-permissions < ${promptFile}`
-            ]);
-            return { success: true, promptFile };
-        }
-    }
-    catch (error) {
-        spinner.fail('Failed to prepare Claude Code coordination');
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        output.printError(`Error: ${errorMessage}`);
-        try {
-            const safeSwarmIdFallback = swarmId.replace(/[^a-zA-Z0-9_-]/g, '_');
-            const fallbackDir = resolvePath(process.cwd());
-            const promptFile = join(fallbackDir, `hive-mind-prompt-${safeSwarmIdFallback}-fallback.txt`);
-            if (!resolvePath(promptFile).startsWith(fallbackDir + sep)) {
-                throw new Error('Fallback path traversal');
-            }
-            const workerGroups = groupWorkersByType(workers);
-            const hiveMindPrompt = generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGroups, flags);
-            await writeFile(promptFile, hiveMindPrompt, 'utf8');
-            output.writeln();
-            output.printSuccess(`Prompt saved to: ${promptFile}`);
-            output.writeln(output.dim('You can run Claude Code manually with the saved prompt'));
-            return { success: false, promptFile, error: errorMessage };
-        }
-        catch {
-            return { success: false, error: errorMessage };
-        }
-    }
-}
-export const spawnCommand = {
-    name: 'spawn',
-    description: 'Spawn worker agents into the hive (use --claude to launch Claude Code)',
-    options: [
-        { name: 'count', short: 'n', description: 'Number of workers to spawn', type: 'number', default: 1 },
-        { name: 'role', short: 'r', description: 'Worker role (worker, specialist, scout)', type: 'string', choices: ['worker', 'specialist', 'scout'], default: 'worker' },
-        { name: 'type', short: 't', description: 'Agent type', type: 'string', default: 'worker' },
-        { name: 'prefix', short: 'p', description: 'Prefix for worker IDs', type: 'string', default: 'hive-worker' },
-        { name: 'claude', description: 'Launch Claude Code with hive-mind coordination prompt', type: 'boolean', default: false },
-        { name: 'objective', short: 'o', description: 'Objective for the hive mind (used with --claude)', type: 'string' },
-        { name: 'dangerously-skip-permissions', description: 'Skip permission prompts in Claude Code (use with caution)', type: 'boolean', default: false },
-        { name: 'no-auto-permissions', description: 'Disable automatic permission skipping', type: 'boolean', default: false },
-        { name: 'dry-run', description: 'Show what would be done without launching Claude Code', type: 'boolean', default: false },
-        { name: 'non-interactive', description: 'Run Claude Code in non-interactive mode', type: 'boolean', default: false }
-    ],
-    examples: [
-        { command: 'monomind hive-mind spawn -n 5', description: 'Spawn 5 workers' },
-        { command: 'monomind hive-mind spawn -n 3 -r specialist', description: 'Spawn 3 specialists' },
-        { command: 'monomind hive-mind spawn -t coder -p my-coder', description: 'Spawn coder with custom prefix' },
-        { command: 'monomind hive-mind spawn --claude -o "Build a REST API"', description: 'Launch Claude Code with objective' },
-        { command: 'monomind hive-mind spawn -n 5 --claude -o "Research AI patterns"', description: 'Spawn workers and launch Claude Code' }
-    ],
-    action: async (ctx) => {
-        const rawCount = ctx.flags.count || 1;
-        const count = Number.isFinite(rawCount) ? Math.max(1, Math.min(rawCount, 50)) : 1;
-        const role = ctx.flags.role || 'worker';
-        const agentType = ctx.flags.type || 'worker';
-        const prefix = ctx.flags.prefix || 'hive-worker';
-        const launchClaude = ctx.flags.claude;
-        let objective = (ctx.flags.objective || ctx.args.join(' ')).slice(0, MAX_OBJECTIVE_LEN);
-        output.printInfo(`Spawning ${count} ${role} agent(s)...`);
-        try {
-            const result = await callMCPTool('hive-mind_spawn', { count, role, agentType, prefix });
-            if (!result.success) {
-                output.printError(result.error || 'Failed to spawn workers');
-                return { success: false, exitCode: 1 };
-            }
-            if (ctx.flags.format === 'json' && !launchClaude) {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            const displayData = (result.workers || []).map(w => ({
-                id: w.agentId,
-                role: w.role,
-                status: 'idle',
-                joinedAt: new Date(w.joinedAt).toLocaleTimeString()
-            }));
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'Agent ID', width: 30 },
-                    { key: 'role', header: 'Role', width: 12 },
-                    { key: 'status', header: 'Status', width: 10, format: formatAgentStatus },
-                    { key: 'joinedAt', header: 'Joined', width: 12 }
-                ],
-                data: displayData
-            });
-            output.writeln();
-            output.printSuccess(`Spawned ${result.spawned} agent(s)`);
-            output.writeln(output.dim(`  Total workers in hive: ${result.totalWorkers}`));
-            if (launchClaude) {
-                if (!objective && ctx.interactive) {
-                    objective = await input({
-                        message: 'Enter the objective for the hive mind:',
-                        validate: (v) => v.length > 0 || 'Objective is required when using --claude'
-                    });
-                }
-                if (!objective) {
-                    output.writeln();
-                    output.printWarning('No objective provided. Using default objective.');
-                    objective = 'Coordinate the hive mind workers to complete tasks efficiently.';
-                }
-                let swarmId = result.hiveId || 'default';
-                const swarmName = 'Hive Mind Swarm';
-                try {
-                    const statusResult = await callMCPTool('hive-mind_status', { includeWorkers: false });
-                    swarmId = statusResult.hiveId || swarmId;
-                }
-                catch {
-                    // Use defaults if status call fails
-                }
-                const workers = (result.workers || []).map(w => ({
-                    agentId: w.agentId,
-                    role: w.role,
-                    type: agentType,
-                    joinedAt: w.joinedAt
-                }));
-                const claudeResult = await spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, ctx.flags);
-                if (!claudeResult.success) {
-                    return { success: false, exitCode: 1, data: { spawn: result, claude: claudeResult } };
-                }
-                return { success: true, data: { spawn: result, claude: claudeResult } };
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Spawn error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-//# sourceMappingURL=hive-mind-spawn.js.map

package/packages/@monomind/cli/dist/src/commands/hive-mind.d.ts

@@ -1,11 +0,0 @@
-/**
- * CLI Hive Mind Command
- * Single-process vote-counting coordination for multi-agent decisions.
- * Consensus strategies (BFT, Raft, Quorum) implement threshold arithmetic
- * with Ed25519 vote signing — not distributed networking protocols.
- * Gossip and CRDT strategies are planned but not yet implemented.
- */
-import type { Command } from '../types.js';
-export declare const hiveMindCommand: Command;
-export default hiveMindCommand;
-//# sourceMappingURL=hive-mind.d.ts.map