monomind 1.17.0 → 1.17.1

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

@@ -0,0 +1,11 @@
+/**
+ * Hive Mind communication subcommands — join, leave, consensus, broadcast, memory, shutdown
+ */
+import type { Command } from '../types.js';
+export declare const joinCommand: Command;
+export declare const leaveCommand: Command;
+export declare const consensusCommand: Command;
+export declare const broadcastCommand: Command;
+export declare const memorySubCommand: Command;
+export declare const shutdownCommand: Command;
+//# sourceMappingURL=hive-mind-comms.d.ts.map

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

@@ -0,0 +1,242 @@
+/**
+ * Hive Mind communication subcommands — join, leave, consensus, broadcast, memory, shutdown
+ */
+import { output } from '../output.js';
+import { confirm } from '../prompt.js';
+import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import { MAX_MESSAGE_LEN, MAX_KEY_LEN, MAX_VALUE_LEN, MAX_AGENT_ID_LEN, } from './hive-mind-helpers.js';
+export const joinCommand = {
+    name: 'join',
+    description: 'Join an agent to the hive mind',
+    options: [
+        { name: 'agent-id', short: 'a', description: 'Agent ID to join', type: 'string' },
+        { name: 'role', short: 'r', description: 'Agent role (worker, specialist, scout)', type: 'string', default: 'worker' }
+    ],
+    action: async (ctx) => {
+        const agentId = (ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId || '').slice(0, MAX_AGENT_ID_LEN);
+        if (!agentId) {
+            output.printError('Agent ID is required. Use --agent-id or -a flag, or provide as argument.');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const result = await callMCPTool('hive-mind_join', { agentId, role: ctx.flags.role });
+            if (!result.success) {
+                output.printError(result.error || 'Failed');
+                return { success: false, exitCode: 1 };
+            }
+            output.printSuccess(`Agent ${agentId} joined hive (${result.totalWorkers} workers)`);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            output.printError(`Join error: ${error instanceof MCPClientError ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
+};
+export const leaveCommand = {
+    name: 'leave',
+    description: 'Remove an agent from the hive mind',
+    options: [
+        { name: 'agent-id', short: 'a', description: 'Agent ID to remove', type: 'string' }
+    ],
+    action: async (ctx) => {
+        const agentId = (ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId || '').slice(0, MAX_AGENT_ID_LEN);
+        if (!agentId) {
+            output.printError('Agent ID required.');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const result = await callMCPTool('hive-mind_leave', { agentId });
+            if (!result.success) {
+                output.printError(result.error || 'Failed');
+                return { success: false, exitCode: 1 };
+            }
+            output.printSuccess(`Agent ${agentId} left hive (${result.remainingWorkers} remaining)`);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            output.printError(`Leave error: ${error instanceof MCPClientError ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
+};
+export const consensusCommand = {
+    name: 'consensus',
+    description: 'Manage consensus proposals and voting',
+    options: [
+        { name: 'action', short: 'a', description: 'Consensus action', type: 'string', choices: ['propose', 'vote', 'status', 'list'], default: 'list' },
+        { name: 'proposal-id', short: 'p', description: 'Proposal ID', type: 'string' },
+        { name: 'type', short: 't', description: 'Proposal type', type: 'string' },
+        { name: 'value', description: 'Proposal value', type: 'string' },
+        { name: 'vote', short: 'v', description: 'Vote (yes/no)', type: 'string' },
+        { name: 'voter-id', description: 'Voter agent ID', type: 'string' }
+    ],
+    action: async (ctx) => {
+        const action = ctx.flags.action || 'list';
+        try {
+            const result = await callMCPTool('hive-mind_consensus', {
+                action,
+                proposalId: ctx.flags['proposal-id'],
+                type: ctx.flags.type,
+                value: ctx.flags.value,
+                vote: ctx.flags.vote === 'yes',
+                voterId: ctx.flags['voter-id']
+            });
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
+            }
+            if (action === 'list') {
+                output.writeln(output.bold('\nPending Proposals'));
+                const pending = result.pending || [];
+                if (pending.length === 0)
+                    output.printInfo('No pending proposals');
+                else
+                    output.printTable({ columns: [{ key: 'proposalId', header: 'ID', width: 30 }, { key: 'type', header: 'Type', width: 12 }], data: pending });
+            }
+            else if (action === 'propose') {
+                output.printSuccess(`Proposal created: ${result.proposalId}`);
+            }
+            else if (action === 'vote') {
+                output.printSuccess(`Vote recorded (For: ${result.votesFor}, Against: ${result.votesAgainst})`);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            output.printError(`Consensus error: ${error instanceof MCPClientError ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
+};
+export const broadcastCommand = {
+    name: 'broadcast',
+    description: 'Broadcast a message to all workers in the hive',
+    options: [
+        { name: 'message', short: 'm', description: 'Message to broadcast', type: 'string', required: true },
+        { name: 'priority', short: 'p', description: 'Message priority', type: 'string', choices: ['low', 'normal', 'high', 'critical'], default: 'normal' },
+        { name: 'from', short: 'f', description: 'Sender agent ID', type: 'string' }
+    ],
+    action: async (ctx) => {
+        const message = (ctx.args.join(' ') || ctx.flags.message || '').slice(0, MAX_MESSAGE_LEN);
+        if (!message) {
+            output.printError('Message required. Use --message or -m flag.');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const result = await callMCPTool('hive-mind_broadcast', {
+                message,
+                priority: ctx.flags.priority,
+                fromId: typeof ctx.flags.from === 'string' ? ctx.flags.from.slice(0, MAX_AGENT_ID_LEN) : undefined
+            });
+            if (!result.success) {
+                output.printError(result.error || 'Failed');
+                return { success: false, exitCode: 1 };
+            }
+            output.printSuccess(`Message broadcast to ${result.recipients} workers (ID: ${result.messageId})`);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            output.printError(`Broadcast error: ${error instanceof MCPClientError ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
+};
+export const memorySubCommand = {
+    name: 'memory',
+    description: 'Access hive shared memory',
+    options: [
+        { name: 'action', short: 'a', description: 'Memory action', type: 'string', choices: ['get', 'set', 'delete', 'list'], default: 'list' },
+        { name: 'key', short: 'k', description: 'Memory key', type: 'string' },
+        { name: 'value', short: 'v', description: 'Value to store', type: 'string' }
+    ],
+    action: async (ctx) => {
+        const action = ctx.flags.action || 'list';
+        const key = typeof ctx.flags.key === 'string' ? ctx.flags.key.slice(0, MAX_KEY_LEN) : undefined;
+        const value = typeof ctx.flags.value === 'string' ? ctx.flags.value.slice(0, MAX_VALUE_LEN) : undefined;
+        if ((action === 'get' || action === 'delete') && !key) {
+            output.printError('Key required for get/delete.');
+            return { success: false, exitCode: 1 };
+        }
+        if (action === 'set' && (!key || value === undefined)) {
+            output.printError('Key and value required for set.');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const result = await callMCPTool('hive-mind_memory', { action, key, value });
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
+            }
+            if (action === 'list') {
+                const keys = result.keys || [];
+                output.writeln(output.bold(`\nShared Memory (${result.count} keys)`));
+                if (keys.length === 0)
+                    output.printInfo('No keys in shared memory');
+                else
+                    output.printList(keys.map(k => output.highlight(k)));
+            }
+            else if (action === 'get') {
+                output.writeln(output.bold(`\nKey: ${key}`));
+                output.writeln(result.exists ? `Value: ${JSON.stringify(result.value, null, 2)}` : 'Key not found');
+            }
+            else if (action === 'set') {
+                output.printSuccess(`Set ${key} in shared memory`);
+            }
+            else if (action === 'delete') {
+                output.printSuccess(result.deleted ? `Deleted ${key}` : `Key ${key} did not exist`);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            output.printError(`Memory error: ${error instanceof MCPClientError ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
+};
+export const shutdownCommand = {
+    name: 'shutdown',
+    description: 'Shutdown the hive mind',
+    options: [
+        { name: 'force', short: 'f', description: 'Force shutdown', type: 'boolean', default: false },
+        { name: 'save-state', short: 's', description: 'Save state before shutdown', type: 'boolean', default: true }
+    ],
+    action: async (ctx) => {
+        const force = ctx.flags.force;
+        const saveState = ctx.flags['save-state'];
+        if (!force && ctx.interactive) {
+            const confirmed = await confirm({
+                message: 'Shutdown the hive mind? All agents will be terminated.',
+                default: false
+            });
+            if (!confirmed) {
+                output.printInfo('Operation cancelled');
+                return { success: true };
+            }
+        }
+        output.printInfo('Shutting down hive mind...');
+        const spinner = output.createSpinner({ text: 'Graceful shutdown in progress...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const result = await callMCPTool('hive-mind_shutdown', { force, saveState });
+            spinner.succeed('Hive mind shutdown complete');
+            output.writeln();
+            output.printList([
+                `Agents terminated: ${result.agentsTerminated}`,
+                `State saved: ${result.stateSaved ? 'Yes' : 'No'}`,
+                `Shutdown time: ${result.shutdownTime}`
+            ]);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            spinner.fail('Shutdown failed');
+            if (error instanceof MCPClientError) {
+                output.printError(`Shutdown error: ${error.message}`);
+            }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
+};
+//# sourceMappingURL=hive-mind-comms.js.map

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

@@ -0,0 +1,35 @@
+/**
+ * Hive Mind shared types, constants, and format helpers
+ */
+export declare const MAX_OBJECTIVE_LEN = 2000;
+export declare const MAX_TASK_DESC_LEN = 4000;
+export declare const MAX_MESSAGE_LEN = 2000;
+export declare const MAX_KEY_LEN = 256;
+export declare const MAX_VALUE_LEN = 65536;
+export declare const MAX_AGENT_ID_LEN = 128;
+export interface HiveWorker {
+    agentId: string;
+    role: string;
+    type?: string;
+    joinedAt?: string;
+}
+export interface WorkerGroups {
+    [key: string]: HiveWorker[];
+}
+export declare const TOPOLOGIES: {
+    value: string;
+    label: string;
+    hint: string;
+}[];
+export declare const CONSENSUS_STRATEGIES: {
+    value: string;
+    label: string;
+    hint: string;
+}[];
+export declare function groupWorkersByType(workers: HiveWorker[]): WorkerGroups;
+export declare function generateHiveMindPrompt(swarmId: string, swarmName: string, objective: string, workers: HiveWorker[], workerGroups: WorkerGroups, flags: Record<string, unknown>): string;
+export declare function formatAgentStatus(status: unknown): string;
+export declare function formatHiveStatus(status: string): string;
+export declare function formatHealth(health: string): string;
+export declare function formatPriority(priority: string): string;
+//# sourceMappingURL=hive-mind-helpers.d.ts.map

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

@@ -0,0 +1,203 @@
+/**
+ * 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' },
+    { value: 'crdt', label: 'CRDT', hint: 'Conflict-free replicated data' },
+    { 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

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