kynjal-cli 4.0.0 → 4.0.1

package/dist/src/mcp-tools/hive-mind-tools.js

@@ -3,64 +3,16 @@
  *
  * Tool definitions for collective intelligence and swarm coordination.
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
-var STORAGE_DIR = '.claude-flow';
-var HIVE_DIR = 'hive-mind';
-var HIVE_FILE = 'state.json';
+const STORAGE_DIR = '.claude-flow';
+const HIVE_DIR = 'hive-mind';
+const HIVE_FILE = 'state.json';
 /**
  * Calculate required votes for a given strategy and total node count.
  */
-function calculateRequiredVotes(strategy, totalNodes, quorumPreset) {
-    if (quorumPreset === void 0) { quorumPreset = 'majority'; }
+function calculateRequiredVotes(strategy, totalNodes, quorumPreset = 'majority') {
     if (totalNodes <= 0)
         return 1;
     switch (strategy) {
@@ -93,8 +45,7 @@ function calculateRequiredVotes(strategy, totalNodes, quorumPreset) {
  */
 function detectByzantineVoters(pending, currentProposal, voterId, newVote) {
     // Check if voter cast opposite votes on proposals of the same type
-    for (var _i = 0, pending_1 = pending; _i < pending_1.length; _i++) {
-        var p = pending_1[_i];
+    for (const p of pending) {
         if (p.proposalId === currentProposal.proposalId)
             continue;
         if (p.type !== currentProposal.type)
@@ -110,9 +61,9 @@ function detectByzantineVoters(pending, currentProposal, voterId, newVote) {
  * Returns 'approved', 'rejected', or null if still pending.
  */
 function tryResolveProposal(proposal, totalNodes) {
-    var votesFor = Object.values(proposal.votes).filter(function (v) { return v; }).length;
-    var votesAgainst = Object.values(proposal.votes).filter(function (v) { return !v; }).length;
-    var required = calculateRequiredVotes(proposal.strategy, totalNodes, proposal.quorumPreset);
+    const votesFor = Object.values(proposal.votes).filter(v => v).length;
+    const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
+    const required = calculateRequiredVotes(proposal.strategy, totalNodes, proposal.quorumPreset);
     if (votesFor >= required)
         return 'approved';
     if (votesAgainst >= required)
@@ -122,8 +73,8 @@ function tryResolveProposal(proposal, totalNodes) {
         return 'rejected';
     }
     // Check if it's impossible to reach quorum (remaining potential votes can't tip it)
-    var totalVotes = Object.keys(proposal.votes).length;
-    var remaining = totalNodes - totalVotes;
+    const totalVotes = Object.keys(proposal.votes).length;
+    const remaining = totalNodes - totalVotes;
     if (votesFor + remaining < required && votesAgainst + remaining < required) {
         // Deadlock: neither side can win -- reject
         return 'rejected';
@@ -137,20 +88,20 @@ function getHivePath() {
     return join(getHiveDir(), HIVE_FILE);
 }
 function ensureHiveDir() {
-    var dir = getHiveDir();
+    const dir = getHiveDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadHiveState() {
     try {
-        var path = getHivePath();
+        const path = getHivePath();
         if (existsSync(path)) {
-            var data = readFileSync(path, 'utf-8');
+            const data = readFileSync(path, 'utf-8');
             return JSON.parse(data);
         }
     }
-    catch (_a) {
+    catch {
         // Return default state on error
     }
     return {
@@ -160,7 +111,7 @@ function loadHiveState() {
         consensus: { pending: [], history: [] },
         sharedMemory: {},
         createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
     };
 }
 function saveHiveState(state) {
@@ -171,23 +122,23 @@ function saveHiveState(state) {
 // Import agent store helpers for spawn functionality
 import { existsSync as agentStoreExists, readFileSync as readAgentStore, writeFileSync as writeAgentStore, mkdirSync as mkdirAgentStore } from 'node:fs';
 function loadAgentStore() {
-    var storePath = join(process.cwd(), '.claude-flow', 'agents.json');
+    const storePath = join(process.cwd(), '.claude-flow', 'agents.json');
     try {
         if (agentStoreExists(storePath)) {
             return JSON.parse(readAgentStore(storePath, 'utf-8'));
         }
     }
-    catch ( /* ignore */_a) { /* ignore */ }
+    catch { /* ignore */ }
     return { agents: {} };
 }
 function saveAgentStore(store) {
-    var storeDir = join(process.cwd(), '.claude-flow');
+    const storeDir = join(process.cwd(), '.claude-flow');
     if (!agentStoreExists(storeDir)) {
         mkdirAgentStore(storeDir, { recursive: true });
     }
     writeAgentStore(join(storeDir, 'agents.json'), JSON.stringify(store, null, 2), 'utf-8');
 }
-export var hiveMindTools = [
+export const hiveMindTools = [
     {
         name: 'hive-mind_spawn',
         description: 'Spawn workers and automatically join them to the hive-mind (combines agent/spawn + hive-mind/join)',
@@ -195,60 +146,57 @@ export var hiveMindTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                count: { type: 'number', description: 'Number of workers to spawn (default: 1)', "default": 1 },
-                role: { type: 'string', "enum": ['worker', 'specialist', 'scout'], description: 'Worker role in hive', "default": 'worker' },
-                agentType: { type: 'string', description: 'Agent type for spawned workers', "default": 'worker' },
-                prefix: { type: 'string', description: 'Prefix for worker IDs', "default": 'hive-worker' }
-            }
+                count: { type: 'number', description: 'Number of workers to spawn (default: 1)', default: 1 },
+                role: { type: 'string', enum: ['worker', 'specialist', 'scout'], description: 'Worker role in hive', default: 'worker' },
+                agentType: { type: 'string', description: 'Agent type for spawned workers', default: 'worker' },
+                prefix: { type: 'string', description: 'Prefix for worker IDs', default: 'hive-worker' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, count, role, agentType, prefix, agentStore, spawnedWorkers, i, agentId;
-            return __generator(this, function (_a) {
-                state = loadHiveState();
-                if (!state.initialized) {
-                    return [2 /*return*/, { success: false, error: 'Hive-mind not initialized. Run hive-mind/init first.' }];
-                }
-                count = Math.min(Math.max(1, input.count || 1), 20);
-                role = input.role || 'worker';
-                agentType = input.agentType || 'worker';
-                prefix = input.prefix || 'hive-worker';
-                agentStore = loadAgentStore();
-                spawnedWorkers = [];
-                for (i = 0; i < count; i++) {
-                    agentId = prefix + "-" + Date.now() + "-" + Math.random().toString(36).slice(2, 6);
-                    // Create agent record (like agent/spawn)
-                    agentStore.agents[agentId] = {
-                        agentId: agentId,
-                        agentType: agentType,
-                        status: 'idle',
-                        health: 1.0,
-                        taskCount: 0,
-                        config: { role: role, hiveRole: role },
-                        createdAt: new Date().toISOString(),
-                        domain: 'hive-mind'
-                    };
-                    // Join to hive-mind (like hive-mind/join)
-                    if (!state.workers.includes(agentId)) {
-                        state.workers.push(agentId);
-                    }
-                    spawnedWorkers.push({
-                        agentId: agentId,
-                        role: role,
-                        joinedAt: new Date().toISOString()
-                    });
+        handler: async (input) => {
+            const state = loadHiveState();
+            if (!state.initialized) {
+                return { success: false, error: 'Hive-mind not initialized. Run hive-mind/init first.' };
+            }
+            const count = Math.min(Math.max(1, input.count || 1), 20); // Cap at 20
+            const role = input.role || 'worker';
+            const agentType = input.agentType || 'worker';
+            const prefix = input.prefix || 'hive-worker';
+            const agentStore = loadAgentStore();
+            const spawnedWorkers = [];
+            for (let i = 0; i < count; i++) {
+                const agentId = `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+                // Create agent record (like agent/spawn)
+                agentStore.agents[agentId] = {
+                    agentId,
+                    agentType,
+                    status: 'idle',
+                    health: 1.0,
+                    taskCount: 0,
+                    config: { role, hiveRole: role },
+                    createdAt: new Date().toISOString(),
+                    domain: 'hive-mind',
+                };
+                // Join to hive-mind (like hive-mind/join)
+                if (!state.workers.includes(agentId)) {
+                    state.workers.push(agentId);
                 }
-                saveAgentStore(agentStore);
-                saveHiveState(state);
-                return [2 /*return*/, {
-                        success: true,
-                        spawned: count,
-                        workers: spawnedWorkers,
-                        totalWorkers: state.workers.length,
-                        hiveStatus: 'active',
-                        message: "Spawned " + count + " worker(s) and joined them to the hive-mind"
-                    }];
-            });
-        }); }
+                spawnedWorkers.push({
+                    agentId,
+                    role,
+                    joinedAt: new Date().toISOString(),
+                });
+            }
+            saveAgentStore(agentStore);
+            saveHiveState(state);
+            return {
+                success: true,
+                spawned: count,
+                workers: spawnedWorkers,
+                totalWorkers: state.workers.length,
+                hiveStatus: 'active',
+                message: `Spawned ${count} worker(s) and joined them to the hive-mind`,
+            };
+        },
     },
     {
         name: 'hive-mind_init',
@@ -257,43 +205,40 @@ export var hiveMindTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                topology: { type: 'string', "enum": ['mesh', 'hierarchical', 'ring', 'star'], description: 'Network topology' },
-                queenId: { type: 'string', description: 'Initial queen agent ID' }
-            }
+                topology: { type: 'string', enum: ['mesh', 'hierarchical', 'ring', 'star'], description: 'Network topology' },
+                queenId: { type: 'string', description: 'Initial queen agent ID' },
+            },
+        },
+        handler: async (input) => {
+            const state = loadHiveState();
+            const hiveId = `hive-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const queenId = input.queenId || `queen-${Date.now()}`;
+            state.initialized = true;
+            state.topology = input.topology || 'mesh';
+            state.createdAt = new Date().toISOString();
+            state.queen = {
+                agentId: queenId,
+                electedAt: new Date().toISOString(),
+                term: 1,
+            };
+            saveHiveState(state);
+            return {
+                success: true,
+                hiveId,
+                topology: state.topology,
+                consensus: input.consensus || 'byzantine',
+                queenId,
+                status: 'initialized',
+                config: {
+                    topology: state.topology,
+                    consensus: input.consensus || 'byzantine',
+                    maxAgents: input.maxAgents || 15,
+                    persist: input.persist !== false,
+                    memoryBackend: input.memoryBackend || 'hybrid',
+                },
+                createdAt: state.createdAt,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, hiveId, queenId;
-            return __generator(this, function (_a) {
-                state = loadHiveState();
-                hiveId = "hive-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
-                queenId = input.queenId || "queen-" + Date.now();
-                state.initialized = true;
-                state.topology = input.topology || 'mesh';
-                state.createdAt = new Date().toISOString();
-                state.queen = {
-                    agentId: queenId,
-                    electedAt: new Date().toISOString(),
-                    term: 1
-                };
-                saveHiveState(state);
-                return [2 /*return*/, {
-                        success: true,
-                        hiveId: hiveId,
-                        topology: state.topology,
-                        consensus: input.consensus || 'byzantine',
-                        queenId: queenId,
-                        status: 'initialized',
-                        config: {
-                            topology: state.topology,
-                            consensus: input.consensus || 'byzantine',
-                            maxAgents: input.maxAgents || 15,
-                            persist: input.persist !== false,
-                            memoryBackend: input.memoryBackend || 'hybrid'
-                        },
-                        createdAt: state.createdAt
-                    }];
-            });
-        }); }
     },
     {
         name: 'hive-mind_status',
@@ -302,93 +247,96 @@ export var hiveMindTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                verbose: { type: 'boolean', description: 'Include detailed information' }
-            }
+                verbose: { type: 'boolean', description: 'Include detailed information' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, uptime, agentStore, taskStorePath, pendingTaskCount, activeTaskCount, completedTaskCount, taskStore, _i, _a, task, workerCount, realLoad, status;
-            return __generator(this, function (_b) {
-                state = loadHiveState();
-                uptime = state.createdAt ? Date.now() - new Date(state.createdAt).getTime() : 0;
-                agentStore = loadAgentStore();
-                taskStorePath = join(process.cwd(), '.claude-flow', 'tasks', 'store.json');
-                pendingTaskCount = 0;
-                activeTaskCount = 0;
-                completedTaskCount = 0;
-                try {
-                    if (existsSync(taskStorePath)) {
-                        taskStore = JSON.parse(readFileSync(taskStorePath, 'utf-8'));
-                        for (_i = 0, _a = Object.values(taskStore.tasks || {}); _i < _a.length; _i++) {
-                            task = _a[_i];
-                            if (task.status === 'pending')
-                                pendingTaskCount++;
-                            else if (task.status === 'in_progress')
-                                activeTaskCount++;
-                            else if (task.status === 'completed')
-                                completedTaskCount++;
-                        }
+        handler: async (input) => {
+            const state = loadHiveState();
+            const uptime = state.createdAt ? Date.now() - new Date(state.createdAt).getTime() : 0;
+            // Load agent store once for all workers
+            const agentStore = loadAgentStore();
+            // Compute real task metrics from task store
+            const taskStorePath = join(process.cwd(), '.claude-flow', 'tasks', 'store.json');
+            let pendingTaskCount = 0;
+            let activeTaskCount = 0;
+            let completedTaskCount = 0;
+            try {
+                if (existsSync(taskStorePath)) {
+                    const taskStore = JSON.parse(readFileSync(taskStorePath, 'utf-8'));
+                    for (const task of Object.values(taskStore.tasks || {})) {
+                        if (task.status === 'pending')
+                            pendingTaskCount++;
+                        else if (task.status === 'in_progress')
+                            activeTaskCount++;
+                        else if (task.status === 'completed')
+                            completedTaskCount++;
                     }
                 }
-                catch ( /* ignore */_c) { /* ignore */ }
-                workerCount = Math.max(1, state.workers.length);
-                realLoad = activeTaskCount / workerCount;
-                status = {
-                    // CLI expected fields
-                    hiveId: "hive-" + (state.createdAt ? new Date(state.createdAt).getTime() : Date.now()),
-                    status: state.initialized ? 'active' : 'offline',
-                    topology: state.topology,
-                    consensus: 'byzantine',
-                    queen: state.queen ? {
-                        id: state.queen.agentId,
-                        agentId: state.queen.agentId,
-                        status: 'active',
-                        load: Math.round(realLoad * 1000) / 1000,
-                        tasksQueued: pendingTaskCount,
-                        electedAt: state.queen.electedAt,
-                        term: state.queen.term
-                    } : { id: 'N/A', status: 'offline', load: 0, tasksQueued: 0 },
-                    workers: state.workers.map(function (w) {
-                        var agent = agentStore.agents[w];
-                        return {
-                            id: w,
-                            type: (agent === null || agent === void 0 ? void 0 : agent.agentType) || 'worker',
-                            status: (agent === null || agent === void 0 ? void 0 : agent.status) || 'unknown',
-                            currentTask: (agent === null || agent === void 0 ? void 0 : agent.currentTask) || null,
-                            tasksCompleted: (agent === null || agent === void 0 ? void 0 : agent.taskCount) || 0
-                        };
-                    }),
-                    metrics: {
-                        totalTasks: pendingTaskCount + activeTaskCount + completedTaskCount,
-                        completedTasks: completedTaskCount,
-                        activeTasks: activeTaskCount,
-                        pendingTasks: pendingTaskCount,
-                        failedTasks: 0,
-                        consensusRounds: state.consensus.history.length,
-                        memoryUsage: Object.keys(state.sharedMemory).length * 2 + " KB"
-                    },
-                    health: {
-                        overall: 'healthy',
-                        queen: state.queen ? 'healthy' : 'unhealthy',
-                        workers: state.workers.length > 0 ? 'healthy' : 'degraded',
-                        consensus: 'healthy',
-                        memory: 'healthy'
-                    },
-                    // Additional fields
-                    id: "hive-" + (state.createdAt ? new Date(state.createdAt).getTime() : Date.now()),
-                    initialized: state.initialized,
-                    workerCount: state.workers.length,
-                    pendingConsensus: state.consensus.pending.length,
-                    sharedMemoryKeys: Object.keys(state.sharedMemory).length,
-                    uptime: uptime,
-                    createdAt: state.createdAt,
-                    updatedAt: state.updatedAt
+            }
+            catch { /* ignore */ }
+            const workerCount = Math.max(1, state.workers.length);
+            const realLoad = activeTaskCount / workerCount;
+            const status = {
+                // CLI expected fields
+                hiveId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
+                status: state.initialized ? 'active' : 'offline',
+                topology: state.topology,
+                consensus: 'byzantine', // Default consensus type
+                queen: state.queen ? {
+                    id: state.queen.agentId,
+                    agentId: state.queen.agentId,
+                    status: 'active',
+                    load: Math.round(realLoad * 1000) / 1000,
+                    tasksQueued: pendingTaskCount,
+                    electedAt: state.queen.electedAt,
+                    term: state.queen.term,
+                } : { id: 'N/A', status: 'offline', load: 0, tasksQueued: 0 },
+                workers: state.workers.map(w => {
+                    const agent = agentStore.agents[w];
+                    return {
+                        id: w,
+                        type: agent?.agentType || 'worker',
+                        status: agent?.status || 'unknown',
+                        currentTask: agent?.currentTask || null,
+                        tasksCompleted: agent?.taskCount || 0,
+                    };
+                }),
+                metrics: {
+                    totalTasks: pendingTaskCount + activeTaskCount + completedTaskCount,
+                    completedTasks: completedTaskCount,
+                    activeTasks: activeTaskCount,
+                    pendingTasks: pendingTaskCount,
+                    failedTasks: 0,
+                    consensusRounds: state.consensus.history.length,
+                    memoryUsage: `${Object.keys(state.sharedMemory).length * 2} KB`,
+                },
+                health: {
+                    overall: 'healthy',
+                    queen: state.queen ? 'healthy' : 'unhealthy',
+                    workers: state.workers.length > 0 ? 'healthy' : 'degraded',
+                    consensus: 'healthy',
+                    memory: 'healthy',
+                },
+                // Additional fields
+                id: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
+                initialized: state.initialized,
+                workerCount: state.workers.length,
+                pendingConsensus: state.consensus.pending.length,
+                sharedMemoryKeys: Object.keys(state.sharedMemory).length,
+                uptime,
+                createdAt: state.createdAt,
+                updatedAt: state.updatedAt,
+            };
+            if (input.verbose) {
+                return {
+                    ...status,
+                    workerDetails: state.workers,
+                    consensusHistory: state.consensus.history.slice(-10),
+                    sharedMemory: state.sharedMemory,
                 };
-                if (input.verbose) {
-                    return [2 /*return*/, __assign(__assign({}, status), { workerDetails: state.workers, consensusHistory: state.consensus.history.slice(-10), sharedMemory: state.sharedMemory })];
-                }
-                return [2 /*return*/, status];
-            });
-        }); }
+            }
+            return status;
+        },
     },
     {
         name: 'hive-mind_join',
@@ -398,31 +346,28 @@ export var hiveMindTools = [
             type: 'object',
             properties: {
                 agentId: { type: 'string', description: 'Agent ID to join' },
-                role: { type: 'string', "enum": ['worker', 'specialist', 'scout'], description: 'Agent role in hive' }
+                role: { type: 'string', enum: ['worker', 'specialist', 'scout'], description: 'Agent role in hive' },
             },
-            required: ['agentId']
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const state = loadHiveState();
+            const agentId = input.agentId;
+            if (!state.initialized) {
+                return { success: false, error: 'Hive-mind not initialized' };
+            }
+            if (!state.workers.includes(agentId)) {
+                state.workers.push(agentId);
+                saveHiveState(state);
+            }
+            return {
+                success: true,
+                agentId,
+                role: input.role || 'worker',
+                totalWorkers: state.workers.length,
+                joinedAt: new Date().toISOString(),
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, agentId;
-            return __generator(this, function (_a) {
-                state = loadHiveState();
-                agentId = input.agentId;
-                if (!state.initialized) {
-                    return [2 /*return*/, { success: false, error: 'Hive-mind not initialized' }];
-                }
-                if (!state.workers.includes(agentId)) {
-                    state.workers.push(agentId);
-                    saveHiveState(state);
-                }
-                return [2 /*return*/, {
-                        success: true,
-                        agentId: agentId,
-                        role: input.role || 'worker',
-                        totalWorkers: state.workers.length,
-                        joinedAt: new Date().toISOString()
-                    }];
-            });
-        }); }
     },
     {
         name: 'hive-mind_leave',
@@ -431,29 +376,26 @@ export var hiveMindTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                agentId: { type: 'string', description: 'Agent ID to remove' }
+                agentId: { type: 'string', description: 'Agent ID to remove' },
             },
-            required: ['agentId']
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const state = loadHiveState();
+            const agentId = input.agentId;
+            const index = state.workers.indexOf(agentId);
+            if (index > -1) {
+                state.workers.splice(index, 1);
+                saveHiveState(state);
+                return {
+                    success: true,
+                    agentId,
+                    leftAt: new Date().toISOString(),
+                    remainingWorkers: state.workers.length,
+                };
+            }
+            return { success: false, agentId, error: 'Agent not in hive' };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, agentId, index;
-            return __generator(this, function (_a) {
-                state = loadHiveState();
-                agentId = input.agentId;
-                index = state.workers.indexOf(agentId);
-                if (index > -1) {
-                    state.workers.splice(index, 1);
-                    saveHiveState(state);
-                    return [2 /*return*/, {
-                            success: true,
-                            agentId: agentId,
-                            leftAt: new Date().toISOString(),
-                            remainingWorkers: state.workers.length
-                        }];
-                }
-                return [2 /*return*/, { success: false, agentId: agentId, error: 'Agent not in hive' }];
-            });
-        }); }
     },
     {
         name: 'hive-mind_consensus',
@@ -462,250 +404,249 @@ export var hiveMindTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['propose', 'vote', 'status', 'list'], description: 'Consensus action' },
+                action: { type: 'string', enum: ['propose', 'vote', 'status', 'list'], description: 'Consensus action' },
                 proposalId: { type: 'string', description: 'Proposal ID (for vote/status)' },
                 type: { type: 'string', description: 'Proposal type (for propose)' },
                 value: { description: 'Proposal value (for propose)' },
                 vote: { type: 'boolean', description: 'Vote (true=for, false=against)' },
                 voterId: { type: 'string', description: 'Voter agent ID' },
-                strategy: { type: 'string', "enum": ['bft', 'raft', 'quorum'], description: 'Consensus strategy (default: raft)' },
-                quorumPreset: { type: 'string', "enum": ['unanimous', 'majority', 'supermajority'], description: 'Quorum threshold preset (for quorum strategy, default: majority)' },
+                strategy: { type: 'string', enum: ['bft', 'raft', 'quorum'], description: 'Consensus strategy (default: raft)' },
+                quorumPreset: { type: 'string', enum: ['unanimous', 'majority', 'supermajority'], description: 'Quorum threshold preset (for quorum strategy, default: majority)' },
                 term: { type: 'number', description: 'Term number (for raft strategy)' },
-                timeoutMs: { type: 'number', description: 'Timeout in ms for raft re-proposal (default: 30000)' }
+                timeoutMs: { type: 'number', description: 'Timeout in ms for raft re-proposal (default: 30000)' },
             },
-            required: ['action']
+            required: ['action'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, action, strategy, totalNodes, proposalId, quorumPreset, term_1, timeoutMs, existingTermProposal, required, proposal, proposal_1, voterId, voteValue, proposalStrategy, required, previousVote, isByzantine, votesFor, votesAgainst, resolution, resolved, proposal, historical, votesFor, votesAgainst, proposalStrategy, required, timedOut;
-            var _a, _b, _c, _d, _e;
-            return __generator(this, function (_f) {
-                state = loadHiveState();
-                action = input.action;
-                strategy = input.strategy || 'raft';
-                totalNodes = state.workers.length || 1;
-                if (action === 'propose') {
-                    proposalId = "proposal-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
-                    quorumPreset = input.quorumPreset || 'majority';
-                    term_1 = input.term || ((_b = (_a = state.queen) === null || _a === void 0 ? void 0 : _a.term) !== null && _b !== void 0 ? _b : 1);
-                    timeoutMs = input.timeoutMs || 30000;
-                    // Raft: check if there's already a pending proposal for this term
-                    if (strategy === 'raft') {
-                        existingTermProposal = state.consensus.pending.find(function (p) { return p.strategy === 'raft' && p.term === term_1 && p.status === 'pending'; });
-                        if (existingTermProposal) {
-                            return [2 /*return*/, {
-                                    action: action,
-                                    error: "Raft term " + term_1 + " already has a pending proposal: " + existingTermProposal.proposalId + ". Wait for resolution or use a higher term.",
-                                    existingProposalId: existingTermProposal.proposalId,
-                                    term: term_1
-                                }];
-                        }
+        handler: async (input) => {
+            const state = loadHiveState();
+            const action = input.action;
+            const strategy = input.strategy || 'raft';
+            const totalNodes = state.workers.length || 1;
+            if (action === 'propose') {
+                const proposalId = `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const quorumPreset = input.quorumPreset || 'majority';
+                const term = input.term || (state.queen?.term ?? 1);
+                const timeoutMs = input.timeoutMs || 30000;
+                // Raft: check if there's already a pending proposal for this term
+                if (strategy === 'raft') {
+                    const existingTermProposal = state.consensus.pending.find(p => p.strategy === 'raft' && p.term === term && p.status === 'pending');
+                    if (existingTermProposal) {
+                        return {
+                            action,
+                            error: `Raft term ${term} already has a pending proposal: ${existingTermProposal.proposalId}. Wait for resolution or use a higher term.`,
+                            existingProposalId: existingTermProposal.proposalId,
+                            term,
+                        };
                     }
-                    required = calculateRequiredVotes(strategy, totalNodes, quorumPreset);
-                    proposal = {
-                        proposalId: proposalId,
-                        type: input.type || 'general',
-                        value: input.value,
-                        proposedBy: input.voterId || 'system',
-                        proposedAt: new Date().toISOString(),
-                        votes: {},
-                        status: 'pending',
-                        strategy: strategy,
-                        term: strategy === 'raft' ? term_1 : undefined,
-                        quorumPreset: strategy === 'quorum' ? quorumPreset : undefined,
-                        byzantineVoters: strategy === 'bft' ? [] : undefined,
-                        timeoutAt: strategy === 'raft' ? new Date(Date.now() + timeoutMs).toISOString() : undefined
-                    };
-                    state.consensus.pending.push(proposal);
-                    saveHiveState(state);
-                    return [2 /*return*/, {
-                            action: action,
-                            proposalId: proposalId,
-                            type: proposal.type,
-                            strategy: strategy,
-                            status: 'pending',
-                            required: required,
-                            totalNodes: totalNodes,
-                            term: proposal.term,
-                            quorumPreset: proposal.quorumPreset,
-                            timeoutAt: proposal.timeoutAt
-                        }];
                 }
-                if (action === 'vote') {
-                    proposal_1 = state.consensus.pending.find(function (p) { return p.proposalId === input.proposalId; });
-                    if (!proposal_1) {
-                        return [2 /*return*/, { action: action, error: 'Proposal not found or already resolved' }];
-                    }
-                    voterId = input.voterId;
-                    if (!voterId) {
-                        return [2 /*return*/, { action: action, error: 'voterId is required for voting' }];
-                    }
-                    voteValue = input.vote;
-                    proposalStrategy = proposal_1.strategy || 'raft';
-                    required = calculateRequiredVotes(proposalStrategy, totalNodes, proposal_1.quorumPreset);
-                    // Prevent double-voting
-                    if (voterId in proposal_1.votes) {
-                        previousVote = proposal_1.votes[voterId];
-                        if (previousVote === voteValue) {
-                            return [2 /*return*/, {
-                                    action: action,
-                                    error: "Voter " + voterId + " has already cast the same vote on this proposal",
-                                    proposalId: proposal_1.proposalId,
-                                    existingVote: previousVote
-                                }];
-                        }
-                        // Conflicting vote from same voter
-                        if (proposalStrategy === 'bft') {
-                            // BFT: detect as Byzantine behavior
-                            if (!proposal_1.byzantineVoters)
-                                proposal_1.byzantineVoters = [];
-                            if (!proposal_1.byzantineVoters.includes(voterId)) {
-                                proposal_1.byzantineVoters.push(voterId);
-                            }
-                            // Remove their vote entirely -- Byzantine voter is excluded
-                            delete proposal_1.votes[voterId];
-                            saveHiveState(state);
-                            return [2 /*return*/, {
-                                    action: action,
-                                    proposalId: proposal_1.proposalId,
-                                    voterId: voterId,
-                                    byzantineDetected: true,
-                                    message: "Byzantine behavior detected: voter " + voterId + " attempted conflicting vote. Vote invalidated.",
-                                    byzantineVoters: proposal_1.byzantineVoters,
-                                    status: proposal_1.status
-                                }];
-                        }
-                        if (proposalStrategy === 'raft') {
-                            // Raft: only one vote per node per term, reject the change
-                            return [2 /*return*/, {
-                                    action: action,
-                                    error: "Raft: voter " + voterId + " already voted in term " + proposal_1.term + ". Cannot change vote.",
-                                    proposalId: proposal_1.proposalId,
-                                    term: proposal_1.term
-                                }];
-                        }
-                        // Quorum: reject double-vote
-                        return [2 /*return*/, {
-                                action: action,
-                                error: "Voter " + voterId + " has already voted on this proposal",
-                                proposalId: proposal_1.proposalId
-                            }];
+                const required = calculateRequiredVotes(strategy, totalNodes, quorumPreset);
+                const proposal = {
+                    proposalId,
+                    type: input.type || 'general',
+                    value: input.value,
+                    proposedBy: input.voterId || 'system',
+                    proposedAt: new Date().toISOString(),
+                    votes: {},
+                    status: 'pending',
+                    strategy,
+                    term: strategy === 'raft' ? term : undefined,
+                    quorumPreset: strategy === 'quorum' ? quorumPreset : undefined,
+                    byzantineVoters: strategy === 'bft' ? [] : undefined,
+                    timeoutAt: strategy === 'raft' ? new Date(Date.now() + timeoutMs).toISOString() : undefined,
+                };
+                state.consensus.pending.push(proposal);
+                saveHiveState(state);
+                return {
+                    action,
+                    proposalId,
+                    type: proposal.type,
+                    strategy,
+                    status: 'pending',
+                    required,
+                    totalNodes,
+                    term: proposal.term,
+                    quorumPreset: proposal.quorumPreset,
+                    timeoutAt: proposal.timeoutAt,
+                };
+            }
+            if (action === 'vote') {
+                const proposal = state.consensus.pending.find(p => p.proposalId === input.proposalId);
+                if (!proposal) {
+                    return { action, error: 'Proposal not found or already resolved' };
+                }
+                const voterId = input.voterId;
+                if (!voterId) {
+                    return { action, error: 'voterId is required for voting' };
+                }
+                const voteValue = input.vote;
+                const proposalStrategy = proposal.strategy || 'raft';
+                const required = calculateRequiredVotes(proposalStrategy, totalNodes, proposal.quorumPreset);
+                // Prevent double-voting
+                if (voterId in proposal.votes) {
+                    const previousVote = proposal.votes[voterId];
+                    if (previousVote === voteValue) {
+                        return {
+                            action,
+                            error: `Voter ${voterId} has already cast the same vote on this proposal`,
+                            proposalId: proposal.proposalId,
+                            existingVote: previousVote,
+                        };
                     }
-                    // BFT: check for cross-proposal Byzantine behavior
+                    // Conflicting vote from same voter
                     if (proposalStrategy === 'bft') {
-                        isByzantine = detectByzantineVoters(state.consensus.pending, proposal_1, voterId, voteValue);
-                        if (isByzantine) {
-                            if (!proposal_1.byzantineVoters)
-                                proposal_1.byzantineVoters = [];
-                            if (!proposal_1.byzantineVoters.includes(voterId)) {
-                                proposal_1.byzantineVoters.push(voterId);
-                            }
-                            saveHiveState(state);
-                            return [2 /*return*/, {
-                                    action: action,
-                                    proposalId: proposal_1.proposalId,
-                                    voterId: voterId,
-                                    byzantineDetected: true,
-                                    message: "Byzantine behavior detected: voter " + voterId + " cast conflicting votes across proposals of same type. Vote rejected.",
-                                    byzantineVoters: proposal_1.byzantineVoters,
-                                    status: proposal_1.status
-                                }];
+                        // BFT: detect as Byzantine behavior
+                        if (!proposal.byzantineVoters)
+                            proposal.byzantineVoters = [];
+                        if (!proposal.byzantineVoters.includes(voterId)) {
+                            proposal.byzantineVoters.push(voterId);
                         }
+                        // Remove their vote entirely -- Byzantine voter is excluded
+                        delete proposal.votes[voterId];
+                        saveHiveState(state);
+                        return {
+                            action,
+                            proposalId: proposal.proposalId,
+                            voterId,
+                            byzantineDetected: true,
+                            message: `Byzantine behavior detected: voter ${voterId} attempted conflicting vote. Vote invalidated.`,
+                            byzantineVoters: proposal.byzantineVoters,
+                            status: proposal.status,
+                        };
                     }
-                    // Record the vote
-                    proposal_1.votes[voterId] = voteValue;
-                    votesFor = Object.values(proposal_1.votes).filter(function (v) { return v; }).length;
-                    votesAgainst = Object.values(proposal_1.votes).filter(function (v) { return !v; }).length;
-                    resolution = tryResolveProposal(proposal_1, totalNodes);
-                    resolved = false;
-                    if (resolution !== null) {
-                        resolved = true;
-                        proposal_1.status = resolution;
-                        state.consensus.history.push({
-                            proposalId: proposal_1.proposalId,
-                            type: proposal_1.type,
-                            result: resolution,
-                            votes: { "for": votesFor, against: votesAgainst },
-                            decidedAt: new Date().toISOString(),
-                            strategy: proposalStrategy,
-                            term: proposal_1.term,
-                            byzantineDetected: ((_c = proposal_1.byzantineVoters) === null || _c === void 0 ? void 0 : _c.length) ? proposal_1.byzantineVoters : undefined
-                        });
-                        state.consensus.pending = state.consensus.pending.filter(function (p) { return p.proposalId !== proposal_1.proposalId; });
+                    if (proposalStrategy === 'raft') {
+                        // Raft: only one vote per node per term, reject the change
+                        return {
+                            action,
+                            error: `Raft: voter ${voterId} already voted in term ${proposal.term}. Cannot change vote.`,
+                            proposalId: proposal.proposalId,
+                            term: proposal.term,
+                        };
                     }
-                    saveHiveState(state);
-                    return [2 /*return*/, {
-                            action: action,
-                            proposalId: proposal_1.proposalId,
-                            voterId: voterId,
-                            vote: voteValue,
-                            strategy: proposalStrategy,
-                            votesFor: votesFor,
-                            votesAgainst: votesAgainst,
-                            required: required,
-                            totalNodes: totalNodes,
-                            resolved: resolved,
-                            result: resolved ? resolution : undefined,
-                            status: proposal_1.status,
-                            term: proposal_1.term,
-                            byzantineVoters: ((_d = proposal_1.byzantineVoters) === null || _d === void 0 ? void 0 : _d.length) ? proposal_1.byzantineVoters : undefined
-                        }];
+                    // Quorum: reject double-vote
+                    return {
+                        action,
+                        error: `Voter ${voterId} has already voted on this proposal`,
+                        proposalId: proposal.proposalId,
+                    };
                 }
-                if (action === 'status') {
-                    proposal = state.consensus.pending.find(function (p) { return p.proposalId === input.proposalId; });
-                    if (!proposal) {
-                        historical = state.consensus.history.find(function (h) { return h.proposalId === input.proposalId; });
-                        if (historical) {
-                            return [2 /*return*/, __assign(__assign({ action: action }, historical), { historical: true, resolved: true })];
+                // BFT: check for cross-proposal Byzantine behavior
+                if (proposalStrategy === 'bft') {
+                    const isByzantine = detectByzantineVoters(state.consensus.pending, proposal, voterId, voteValue);
+                    if (isByzantine) {
+                        if (!proposal.byzantineVoters)
+                            proposal.byzantineVoters = [];
+                        if (!proposal.byzantineVoters.includes(voterId)) {
+                            proposal.byzantineVoters.push(voterId);
                         }
-                        return [2 /*return*/, { action: action, error: 'Proposal not found' }];
-                    }
-                    votesFor = Object.values(proposal.votes).filter(function (v) { return v; }).length;
-                    votesAgainst = Object.values(proposal.votes).filter(function (v) { return !v; }).length;
-                    proposalStrategy = proposal.strategy || 'raft';
-                    required = calculateRequiredVotes(proposalStrategy, totalNodes, proposal.quorumPreset);
-                    timedOut = false;
-                    if (proposalStrategy === 'raft' && proposal.timeoutAt) {
-                        timedOut = new Date().getTime() > new Date(proposal.timeoutAt).getTime();
-                    }
-                    return [2 /*return*/, {
-                            action: action,
+                        saveHiveState(state);
+                        return {
+                            action,
                             proposalId: proposal.proposalId,
-                            type: proposal.type,
-                            strategy: proposalStrategy,
+                            voterId,
+                            byzantineDetected: true,
+                            message: `Byzantine behavior detected: voter ${voterId} cast conflicting votes across proposals of same type. Vote rejected.`,
+                            byzantineVoters: proposal.byzantineVoters,
                             status: proposal.status,
-                            votesFor: votesFor,
-                            votesAgainst: votesAgainst,
-                            totalVotes: Object.keys(proposal.votes).length,
-                            required: required,
-                            totalNodes: totalNodes,
-                            resolved: false,
-                            term: proposal.term,
-                            quorumPreset: proposal.quorumPreset,
-                            byzantineVoters: ((_e = proposal.byzantineVoters) === null || _e === void 0 ? void 0 : _e.length) ? proposal.byzantineVoters : undefined,
-                            timedOut: timedOut,
-                            timeoutAt: proposal.timeoutAt,
-                            hint: timedOut ? "Raft timeout reached. Re-propose with term " + ((proposal.term || 1) + 1) + "." : undefined
-                        }];
+                        };
+                    }
                 }
-                if (action === 'list') {
-                    return [2 /*return*/, {
-                            action: action,
-                            pending: state.consensus.pending.map(function (p) { return ({
-                                proposalId: p.proposalId,
-                                type: p.type,
-                                strategy: p.strategy || 'raft',
-                                proposedAt: p.proposedAt,
-                                totalVotes: Object.keys(p.votes).length,
-                                required: calculateRequiredVotes(p.strategy || 'raft', totalNodes, p.quorumPreset),
-                                term: p.term,
-                                status: p.status
-                            }); }),
-                            recentHistory: state.consensus.history.slice(-5)
-                        }];
+                // Record the vote
+                proposal.votes[voterId] = voteValue;
+                const votesFor = Object.values(proposal.votes).filter(v => v).length;
+                const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
+                // Try to resolve
+                const resolution = tryResolveProposal(proposal, totalNodes);
+                let resolved = false;
+                if (resolution !== null) {
+                    resolved = true;
+                    proposal.status = resolution;
+                    state.consensus.history.push({
+                        proposalId: proposal.proposalId,
+                        type: proposal.type,
+                        result: resolution,
+                        votes: { for: votesFor, against: votesAgainst },
+                        decidedAt: new Date().toISOString(),
+                        strategy: proposalStrategy,
+                        term: proposal.term,
+                        byzantineDetected: proposal.byzantineVoters?.length ? proposal.byzantineVoters : undefined,
+                    });
+                    state.consensus.pending = state.consensus.pending.filter(p => p.proposalId !== proposal.proposalId);
                 }
-                return [2 /*return*/, { action: action, error: 'Unknown action' }];
-            });
-        }); }
+                saveHiveState(state);
+                return {
+                    action,
+                    proposalId: proposal.proposalId,
+                    voterId,
+                    vote: voteValue,
+                    strategy: proposalStrategy,
+                    votesFor,
+                    votesAgainst,
+                    required,
+                    totalNodes,
+                    resolved,
+                    result: resolved ? resolution : undefined,
+                    status: proposal.status,
+                    term: proposal.term,
+                    byzantineVoters: proposal.byzantineVoters?.length ? proposal.byzantineVoters : undefined,
+                };
+            }
+            if (action === 'status') {
+                const proposal = state.consensus.pending.find(p => p.proposalId === input.proposalId);
+                if (!proposal) {
+                    // Check history
+                    const historical = state.consensus.history.find(h => h.proposalId === input.proposalId);
+                    if (historical) {
+                        return { action, ...historical, historical: true, resolved: true };
+                    }
+                    return { action, error: 'Proposal not found' };
+                }
+                const votesFor = Object.values(proposal.votes).filter(v => v).length;
+                const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
+                const proposalStrategy = proposal.strategy || 'raft';
+                const required = calculateRequiredVotes(proposalStrategy, totalNodes, proposal.quorumPreset);
+                // Raft: check timeout
+                let timedOut = false;
+                if (proposalStrategy === 'raft' && proposal.timeoutAt) {
+                    timedOut = new Date().getTime() > new Date(proposal.timeoutAt).getTime();
+                }
+                return {
+                    action,
+                    proposalId: proposal.proposalId,
+                    type: proposal.type,
+                    strategy: proposalStrategy,
+                    status: proposal.status,
+                    votesFor,
+                    votesAgainst,
+                    totalVotes: Object.keys(proposal.votes).length,
+                    required,
+                    totalNodes,
+                    resolved: false,
+                    term: proposal.term,
+                    quorumPreset: proposal.quorumPreset,
+                    byzantineVoters: proposal.byzantineVoters?.length ? proposal.byzantineVoters : undefined,
+                    timedOut,
+                    timeoutAt: proposal.timeoutAt,
+                    hint: timedOut ? `Raft timeout reached. Re-propose with term ${(proposal.term || 1) + 1}.` : undefined,
+                };
+            }
+            if (action === 'list') {
+                return {
+                    action,
+                    pending: state.consensus.pending.map(p => ({
+                        proposalId: p.proposalId,
+                        type: p.type,
+                        strategy: p.strategy || 'raft',
+                        proposedAt: p.proposedAt,
+                        totalVotes: Object.keys(p.votes).length,
+                        required: calculateRequiredVotes(p.strategy || 'raft', totalNodes, p.quorumPreset),
+                        term: p.term,
+                        status: p.status,
+                    })),
+                    recentHistory: state.consensus.history.slice(-5),
+                };
+            }
+            return { action, error: 'Unknown action' };
+        },
     },
     {
         name: 'hive-mind_broadcast',
@@ -715,39 +656,37 @@ export var hiveMindTools = [
             type: 'object',
             properties: {
                 message: { type: 'string', description: 'Message to broadcast' },
-                priority: { type: 'string', "enum": ['low', 'normal', 'high', 'critical'], description: 'Message priority' },
-                fromId: { type: 'string', description: 'Sender agent ID' }
+                priority: { type: 'string', enum: ['low', 'normal', 'high', 'critical'], description: 'Message priority' },
+                fromId: { type: 'string', description: 'Sender agent ID' },
             },
-            required: ['message']
+            required: ['message'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, messageId, messages;
-            return __generator(this, function (_a) {
-                state = loadHiveState();
-                if (!state.initialized) {
-                    return [2 /*return*/, { success: false, error: 'Hive-mind not initialized' }];
-                }
-                messageId = "msg-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
-                messages = state.sharedMemory.broadcasts || [];
-                messages.push({
-                    messageId: messageId,
-                    message: input.message,
-                    priority: input.priority || 'normal',
-                    fromId: input.fromId || 'system',
-                    timestamp: new Date().toISOString()
-                });
-                // Keep only last 100 broadcasts
-                state.sharedMemory.broadcasts = messages.slice(-100);
-                saveHiveState(state);
-                return [2 /*return*/, {
-                        success: true,
-                        messageId: messageId,
-                        recipients: state.workers.length,
-                        priority: input.priority || 'normal',
-                        broadcastAt: new Date().toISOString()
-                    }];
+        handler: async (input) => {
+            const state = loadHiveState();
+            if (!state.initialized) {
+                return { success: false, error: 'Hive-mind not initialized' };
+            }
+            const messageId = `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            // Store in shared memory
+            const messages = state.sharedMemory.broadcasts || [];
+            messages.push({
+                messageId,
+                message: input.message,
+                priority: input.priority || 'normal',
+                fromId: input.fromId || 'system',
+                timestamp: new Date().toISOString(),
             });
-        }); }
+            // Keep only last 100 broadcasts
+            state.sharedMemory.broadcasts = messages.slice(-100);
+            saveHiveState(state);
+            return {
+                success: true,
+                messageId,
+                recipients: state.workers.length,
+                priority: input.priority || 'normal',
+                broadcastAt: new Date().toISOString(),
+            };
+        },
     },
     {
         name: 'hive-mind_shutdown',
@@ -756,59 +695,56 @@ export var hiveMindTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                graceful: { type: 'boolean', description: 'Graceful shutdown (wait for pending tasks)', "default": true },
-                force: { type: 'boolean', description: 'Force immediate shutdown', "default": false }
-            }
+                graceful: { type: 'boolean', description: 'Graceful shutdown (wait for pending tasks)', default: true },
+                force: { type: 'boolean', description: 'Force immediate shutdown', default: false },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, graceful, force, workerCount, pendingConsensus, agentStore, _i, _a, workerId, shutdownTime, previousQueen;
-            var _b;
-            return __generator(this, function (_c) {
-                state = loadHiveState();
-                if (!state.initialized) {
-                    return [2 /*return*/, { success: false, error: 'Hive-mind not initialized or already shut down' }];
-                }
-                graceful = input.graceful !== false;
-                force = input.force === true;
-                workerCount = state.workers.length;
-                pendingConsensus = state.consensus.pending.length;
-                // If graceful and there are pending consensus items, warn (unless forced)
-                if (graceful && pendingConsensus > 0 && !force) {
-                    return [2 /*return*/, {
-                            success: false,
-                            error: "Cannot gracefully shutdown with " + pendingConsensus + " pending consensus items. Use force: true to override.",
-                            pendingConsensus: pendingConsensus,
-                            workerCount: workerCount
-                        }];
-                }
-                agentStore = loadAgentStore();
-                for (_i = 0, _a = state.workers; _i < _a.length; _i++) {
-                    workerId = _a[_i];
-                    if (agentStore.agents[workerId]) {
-                        delete agentStore.agents[workerId];
-                    }
+        handler: async (input) => {
+            const state = loadHiveState();
+            if (!state.initialized) {
+                return { success: false, error: 'Hive-mind not initialized or already shut down' };
+            }
+            const graceful = input.graceful !== false;
+            const force = input.force === true;
+            const workerCount = state.workers.length;
+            const pendingConsensus = state.consensus.pending.length;
+            // If graceful and there are pending consensus items, warn (unless forced)
+            if (graceful && pendingConsensus > 0 && !force) {
+                return {
+                    success: false,
+                    error: `Cannot gracefully shutdown with ${pendingConsensus} pending consensus items. Use force: true to override.`,
+                    pendingConsensus,
+                    workerCount,
+                };
+            }
+            // Clear workers from agent store
+            const agentStore = loadAgentStore();
+            for (const workerId of state.workers) {
+                if (agentStore.agents[workerId]) {
+                    delete agentStore.agents[workerId];
                 }
-                saveAgentStore(agentStore);
-                shutdownTime = new Date().toISOString();
-                previousQueen = (_b = state.queen) === null || _b === void 0 ? void 0 : _b.agentId;
-                state.initialized = false;
-                state.queen = undefined;
-                state.workers = [];
-                state.consensus.pending = [];
-                // Keep history for reference
-                state.sharedMemory = {};
-                saveHiveState(state);
-                return [2 /*return*/, {
-                        success: true,
-                        shutdownAt: shutdownTime,
-                        graceful: graceful,
-                        workersTerminated: workerCount,
-                        previousQueen: previousQueen,
-                        consensusCleared: pendingConsensus,
-                        message: "Hive-mind shutdown complete. " + workerCount + " workers terminated."
-                    }];
-            });
-        }); }
+            }
+            saveAgentStore(agentStore);
+            // Reset hive state
+            const shutdownTime = new Date().toISOString();
+            const previousQueen = state.queen?.agentId;
+            state.initialized = false;
+            state.queen = undefined;
+            state.workers = [];
+            state.consensus.pending = [];
+            // Keep history for reference
+            state.sharedMemory = {};
+            saveHiveState(state);
+            return {
+                success: true,
+                shutdownAt: shutdownTime,
+                graceful,
+                workersTerminated: workerCount,
+                previousQueen,
+                consensusCleared: pendingConsensus,
+                message: `Hive-mind shutdown complete. ${workerCount} workers terminated.`,
+            };
+        },
     },
     {
         name: 'hive-mind_memory',
@@ -817,62 +753,59 @@ export var hiveMindTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['get', 'set', 'delete', 'list'], description: 'Memory action' },
+                action: { type: 'string', enum: ['get', 'set', 'delete', 'list'], description: 'Memory action' },
                 key: { type: 'string', description: 'Memory key' },
-                value: { description: 'Value to store (for set)' }
+                value: { description: 'Value to store (for set)' },
             },
-            required: ['action']
+            required: ['action'],
+        },
+        handler: async (input) => {
+            const state = loadHiveState();
+            const action = input.action;
+            const key = input.key;
+            if (action === 'get') {
+                if (!key)
+                    return { action, error: 'Key required' };
+                return {
+                    action,
+                    key,
+                    value: state.sharedMemory[key],
+                    exists: key in state.sharedMemory,
+                };
+            }
+            if (action === 'set') {
+                if (!key)
+                    return { action, error: 'Key required' };
+                state.sharedMemory[key] = input.value;
+                saveHiveState(state);
+                return {
+                    action,
+                    key,
+                    success: true,
+                    updatedAt: new Date().toISOString(),
+                };
+            }
+            if (action === 'delete') {
+                if (!key)
+                    return { action, error: 'Key required' };
+                const existed = key in state.sharedMemory;
+                delete state.sharedMemory[key];
+                saveHiveState(state);
+                return {
+                    action,
+                    key,
+                    deleted: existed,
+                };
+            }
+            if (action === 'list') {
+                return {
+                    action,
+                    keys: Object.keys(state.sharedMemory),
+                    count: Object.keys(state.sharedMemory).length,
+                };
+            }
+            return { action, error: 'Unknown action' };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var state, action, key, existed;
-            return __generator(this, function (_a) {
-                state = loadHiveState();
-                action = input.action;
-                key = input.key;
-                if (action === 'get') {
-                    if (!key)
-                        return [2 /*return*/, { action: action, error: 'Key required' }];
-                    return [2 /*return*/, {
-                            action: action,
-                            key: key,
-                            value: state.sharedMemory[key],
-                            exists: key in state.sharedMemory
-                        }];
-                }
-                if (action === 'set') {
-                    if (!key)
-                        return [2 /*return*/, { action: action, error: 'Key required' }];
-                    state.sharedMemory[key] = input.value;
-                    saveHiveState(state);
-                    return [2 /*return*/, {
-                            action: action,
-                            key: key,
-                            success: true,
-                            updatedAt: new Date().toISOString()
-                        }];
-                }
-                if (action === 'delete') {
-                    if (!key)
-                        return [2 /*return*/, { action: action, error: 'Key required' }];
-                    existed = key in state.sharedMemory;
-                    delete state.sharedMemory[key];
-                    saveHiveState(state);
-                    return [2 /*return*/, {
-                            action: action,
-                            key: key,
-                            deleted: existed
-                        }];
-                }
-                if (action === 'list') {
-                    return [2 /*return*/, {
-                            action: action,
-                            keys: Object.keys(state.sharedMemory),
-                            count: Object.keys(state.sharedMemory).length
-                        }];
-                }
-                return [2 /*return*/, { action: action, error: 'Unknown action' }];
-            });
-        }); }
     },
 ];
 //# sourceMappingURL=hive-mind-tools.js.map