@monoes/monomindcli 2.9.23 → 2.9.24

package/dist/src/mcp-tools/monoswarm-tools.js

@@ -12,11 +12,11 @@
  * `.monomind/hive-mind/` state files are abandoned in place (a later cleanup
  * phase purges them) rather than imported here.
  */
-import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
 import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { getProjectCwd, getMonomindDataRoot } from './types.js';
 import { agentTools, loadAgentStore, loadAgentStoreOrNull } from './agent-tools.js';
+import { getMonomindDataRoot, getProjectCwd } from './types.js';
 // ---------------------------------------------------------------------------
 // State persistence — single file under the git-safe data root.
 // ---------------------------------------------------------------------------
@@ -96,7 +96,9 @@ function getOrCreateAuditKey() {
                 return existing;
         }
     }
-    catch { /* fall through to regeneration */ }
+    catch {
+        /* fall through to regeneration */
+    }
     try {
         ensureMonoswarmDir();
         const key = randomBytes(32).toString('hex');
@@ -122,7 +124,13 @@ function saveAgentStore(store) {
 }
 const RESERVED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 const VALID_TOPOLOGIES = new Set([
-    'hierarchical', 'mesh', 'hierarchical-mesh', 'ring', 'star', 'hybrid', 'adaptive',
+    'hierarchical',
+    'mesh',
+    'hierarchical-mesh',
+    'ring',
+    'star',
+    'hybrid',
+    'adaptive',
 ]);
 // ---------------------------------------------------------------------------
 // Vote-threshold math
@@ -138,7 +146,6 @@ function calculateRequiredVotes(strategy, totalVoters, minVotes) {
             return totalVoters;
         case 'threshold':
             return Math.min(Math.max(1, minVotes ?? Math.floor(totalVoters / 2) + 1), totalVoters);
-        case 'majority':
         default:
             return Math.floor(totalVoters / 2) + 1;
     }
@@ -164,8 +171,8 @@ function detectDuplicateVotes(pending, currentProposal, voterId, newVote) {
  * 'rejected', or null if still pending.
  */
 function tryResolveProposal(proposal, totalVoters) {
-    const votesFor = Object.values(proposal.votes).filter(v => v).length;
-    const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
+    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, totalVoters, proposal.minVotes);
     if (votesFor >= required)
         return 'approved';
@@ -187,16 +194,29 @@ function tryResolveProposal(proposal, totalVoters) {
 export const monoswarmTools = [
     {
         name: 'monoswarm_init',
-        description: 'Record a coordination topology, agent roster, and vote strategy in a JSON state file. Starts no process — agents are dispatched separately via Claude Code\'s Task tool.',
+        description: "Record a coordination topology, agent roster, and vote strategy in a JSON state file. Starts no process — agents are dispatched separately via Claude Code's Task tool.",
         category: 'monoswarm',
         inputSchema: {
             type: 'object',
             properties: {
-                topology: { type: 'string', description: 'Topology label (hierarchical, mesh, hierarchical-mesh, ring, star, hybrid, adaptive)' },
+                topology: {
+                    type: 'string',
+                    description: 'Topology label (hierarchical, mesh, hierarchical-mesh, ring, star, hybrid, adaptive)',
+                },
                 maxAgents: { type: 'number', description: 'Maximum number of agents (1-50)' },
-                strategy: { type: 'string', description: 'Agent role strategy (specialized, balanced, adaptive)' },
-                coordinatorId: { type: 'string', description: 'Initial coordinator agent ID (formerly "queen")' },
-                voteStrategy: { type: 'string', enum: ['majority', 'supermajority', 'unanimous', 'threshold'], description: 'Default vote strategy for monoswarm_vote. Default: majority.' },
+                strategy: {
+                    type: 'string',
+                    description: 'Agent role strategy (specialized, balanced, adaptive)',
+                },
+                coordinatorId: {
+                    type: 'string',
+                    description: 'Initial coordinator agent ID (formerly "queen")',
+                },
+                voteStrategy: {
+                    type: 'string',
+                    enum: ['majority', 'supermajority', 'unanimous', 'threshold'],
+                    description: 'Default vote strategy for monoswarm_vote. Default: majority.',
+                },
             },
         },
         handler: async (input) => {
@@ -205,21 +225,28 @@ export const monoswarmTools = [
             const MAX_FIELD_LEN = 256;
             const rawStrategy = input.strategy || 'specialized';
             const strategy = typeof rawStrategy === 'string' && rawStrategy.length > MAX_FIELD_LEN
-                ? rawStrategy.slice(0, MAX_FIELD_LEN) : rawStrategy;
+                ? rawStrategy.slice(0, MAX_FIELD_LEN)
+                : rawStrategy;
             if (!VALID_TOPOLOGIES.has(topology)) {
                 return {
                     success: false,
                     error: `Invalid topology: ${topology}. Valid: ${[...VALID_TOPOLOGIES].join(', ')}`,
                 };
             }
-            const VALID_VOTE_STRATEGIES = ['majority', 'supermajority', 'unanimous', 'threshold'];
+            const VALID_VOTE_STRATEGIES = [
+                'majority',
+                'supermajority',
+                'unanimous',
+                'threshold',
+            ];
             const rawVoteStrategy = input.voteStrategy || 'majority';
             const voteStrategy = VALID_VOTE_STRATEGIES.includes(rawVoteStrategy)
                 ? rawVoteStrategy
                 : 'majority';
             const rawCoordinatorId = input.coordinatorId || undefined;
             const coordinatorId = typeof rawCoordinatorId === 'string' && rawCoordinatorId.length > MAX_FIELD_LEN
-                ? rawCoordinatorId.slice(0, MAX_FIELD_LEN) : rawCoordinatorId;
+                ? rawCoordinatorId.slice(0, MAX_FIELD_LEN)
+                : rawCoordinatorId;
             const monoswarmId = `monoswarm-${Date.now()}-${randomBytes(6).toString('hex')}`;
             const now = new Date().toISOString();
             const state = {
@@ -229,7 +256,9 @@ export const monoswarmTools = [
                 maxAgents,
                 status: 'running',
                 agents: [],
-                coordinator: coordinatorId ? { agentId: coordinatorId, electedAt: now, term: 1 } : undefined,
+                coordinator: coordinatorId
+                    ? { agentId: coordinatorId, electedAt: now, term: 1 }
+                    : undefined,
                 tasks: [],
                 config: { topology, maxAgents, strategy },
                 voteStrategy,
@@ -261,7 +290,10 @@ export const monoswarmTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                verbose: { type: 'boolean', description: 'Include worker details, vote history, and shared memory contents' },
+                verbose: {
+                    type: 'boolean',
+                    description: 'Include worker details, vote history, and shared memory contents',
+                },
             },
         },
         handler: async (input) => {
@@ -280,7 +312,9 @@ export const monoswarmTools = [
                 if (existsSync(path))
                     stateBytes = statSync(path).size;
             }
-            catch { /* best-effort */ }
+            catch {
+                /* best-effort */
+            }
             const summary = {
                 monoswarmId: state.monoswarmId,
                 status: state.status,
@@ -289,12 +323,14 @@ export const monoswarmTools = [
                 agentCount: state.agents.length,
                 taskCount: state.tasks.length,
                 voteStrategy: state.voteStrategy ?? 'majority',
-                coordinator: state.coordinator ? {
-                    agentId: state.coordinator.agentId,
-                    electedAt: state.coordinator.electedAt,
-                    term: state.coordinator.term,
-                } : undefined,
-                agents: state.agents.map(id => {
+                coordinator: state.coordinator
+                    ? {
+                        agentId: state.coordinator.agentId,
+                        electedAt: state.coordinator.electedAt,
+                        term: state.coordinator.term,
+                    }
+                    : undefined,
+                agents: state.agents.map((id) => {
                     const agent = agentStore.agents[id];
                     return {
                         id,
@@ -331,7 +367,10 @@ export const monoswarmTools = [
             type: 'object',
             properties: {
                 targetAgents: { type: 'number', description: 'Target number of agents' },
-                agentType: { type: 'string', description: 'Agent type for newly spawned agent records (default: worker)' },
+                agentType: {
+                    type: 'string',
+                    description: 'Agent type for newly spawned agent records (default: worker)',
+                },
             },
             required: ['targetAgents'],
         },
@@ -347,13 +386,13 @@ export const monoswarmTools = [
             }
             const currentCount = state.agents.length;
             const delta = targetAgents - currentCount;
-            const spawnTool = agentTools.find(t => t.name === 'agent_spawn');
-            const terminateTool = agentTools.find(t => t.name === 'agent_terminate');
+            const spawnTool = agentTools.find((t) => t.name === 'agent_spawn');
+            const terminateTool = agentTools.find((t) => t.name === 'agent_terminate');
             const spawned = [];
             const terminated = [];
             if (delta > 0) {
                 for (let i = 0; i < delta; i++) {
-                    const result = await spawnTool.handler({ agentType });
+                    const result = (await spawnTool.handler({ agentType }));
                     if (result.success && result.agentId) {
                         state.agents.push(result.agentId);
                         spawned.push(result.agentId);
@@ -363,12 +402,12 @@ export const monoswarmTools = [
             else if (delta < 0) {
                 const toRemove = state.agents.slice(0, -delta);
                 for (const agentId of toRemove) {
-                    const result = await terminateTool.handler({ agentId });
+                    const result = (await terminateTool.handler({ agentId }));
                     if (result.success) {
                         terminated.push(agentId);
                     }
                 }
-                state.agents = state.agents.filter(id => !terminated.includes(id));
+                state.agents = state.agents.filter((id) => !terminated.includes(id));
             }
             state.maxAgents = Math.max(state.maxAgents, state.agents.length);
             saveMonoswarmState(state);
@@ -410,7 +449,11 @@ export const monoswarmTools = [
             const isRunning = state.status === 'running';
             const stateFileExists = existsSync(getMonoswarmStatePath());
             const checks = [
-                { name: 'monoswarm_exists', status: 'ok', message: `Monoswarm ${state.monoswarmId} recorded` },
+                {
+                    name: 'monoswarm_exists',
+                    status: 'ok',
+                    message: `Monoswarm ${state.monoswarmId} recorded`,
+                },
                 {
                     name: 'coordinator',
                     status: isRunning ? 'ok' : 'warn',
@@ -451,7 +494,10 @@ export const monoswarmTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                graceful: { type: 'boolean', description: 'Refuse to shut down while votes are pending unless force is set (default: true)' },
+                graceful: {
+                    type: 'boolean',
+                    description: 'Refuse to shut down while votes are pending unless force is set (default: true)',
+                },
                 force: { type: 'boolean', description: 'Force immediate shutdown even with pending votes' },
             },
         },
@@ -461,7 +507,11 @@ export const monoswarmTools = [
                 return { success: false, error: 'Monoswarm not initialized or already shut down' };
             }
             if (state.status === 'terminated') {
-                return { success: false, monoswarmId: state.monoswarmId, error: 'Monoswarm already terminated' };
+                return {
+                    success: false,
+                    monoswarmId: state.monoswarmId,
+                    error: 'Monoswarm already terminated',
+                };
             }
             const graceful = input.graceful !== false;
             const force = input.force === true;
@@ -480,7 +530,12 @@ export const monoswarmTools = [
             // that back would wipe every real agent, not just this roster.
             const agentStore = loadAgentStoreOrNull();
             if (!agentStore) {
-                return { success: false, error: 'Agent store is unreadable/corrupt — refusing to shut down to avoid overwriting real agent data.', pendingVotes, agentCount: state.agents.length };
+                return {
+                    success: false,
+                    error: 'Agent store is unreadable/corrupt — refusing to shut down to avoid overwriting real agent data.',
+                    pendingVotes,
+                    agentCount: state.agents.length,
+                };
             }
             for (const agentId of state.agents) {
                 if (agentStore.agents[agentId])
@@ -516,9 +571,22 @@ export const monoswarmTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                count: { type: 'number', description: 'Number of agent records to add (default: 1)', default: 1 },
-                role: { type: 'string', enum: ['worker', 'specialist', 'scout'], description: 'Agent role', default: 'worker' },
-                agentType: { type: 'string', description: 'Agent type for added agents', default: 'worker' },
+                count: {
+                    type: 'number',
+                    description: 'Number of agent records to add (default: 1)',
+                    default: 1,
+                },
+                role: {
+                    type: 'string',
+                    enum: ['worker', 'specialist', 'scout'],
+                    description: 'Agent role',
+                    default: 'worker',
+                },
+                agentType: {
+                    type: 'string',
+                    description: 'Agent type for added agents',
+                    default: 'worker',
+                },
                 prefix: { type: 'string', description: 'Prefix for agent IDs', default: 'monoswarm-agent' },
             },
         },
@@ -532,16 +600,22 @@ export const monoswarmTools = [
             const MAX_PREFIX_LEN = 128;
             const rawRole = input.role || 'worker';
             const role = typeof rawRole === 'string' && rawRole.length > MAX_ROLE_LEN
-                ? rawRole.slice(0, MAX_ROLE_LEN) : rawRole;
+                ? rawRole.slice(0, MAX_ROLE_LEN)
+                : rawRole;
             const rawAgentType = input.agentType || 'worker';
             const agentType = typeof rawAgentType === 'string' && rawAgentType.length > MAX_ROLE_LEN
-                ? rawAgentType.slice(0, MAX_ROLE_LEN) : rawAgentType;
+                ? rawAgentType.slice(0, MAX_ROLE_LEN)
+                : rawAgentType;
             const rawPrefix = input.prefix || 'monoswarm-agent';
             const prefix = typeof rawPrefix === 'string' && rawPrefix.length > MAX_PREFIX_LEN
-                ? rawPrefix.slice(0, MAX_PREFIX_LEN) : rawPrefix;
+                ? rawPrefix.slice(0, MAX_PREFIX_LEN)
+                : rawPrefix;
             const agentStore = loadAgentStoreOrNull();
             if (!agentStore) {
-                return { success: false, error: 'Agent store is unreadable/corrupt — refusing to add agents to avoid overwriting real agent data.' };
+                return {
+                    success: false,
+                    error: 'Agent store is unreadable/corrupt — refusing to add agents to avoid overwriting real agent data.',
+                };
             }
             const added = [];
             for (let i = 0; i < count; i++) {
@@ -561,7 +635,10 @@ export const monoswarmTools = [
                 const MAX_AGENTS = 100;
                 if (!state.agents.includes(agentId)) {
                     if (state.agents.length >= MAX_AGENTS) {
-                        return { success: false, error: `Monoswarm has reached max agent capacity (${MAX_AGENTS})` };
+                        return {
+                            success: false,
+                            error: `Monoswarm has reached max agent capacity (${MAX_AGENTS})`,
+                        };
                     }
                     state.agents.push(agentId);
                 }
@@ -586,15 +663,22 @@ export const monoswarmTools = [
             type: 'object',
             properties: {
                 agentId: { type: 'string', description: 'Agent ID to add to the roster' },
-                role: { type: 'string', enum: ['worker', 'specialist', 'scout'], description: 'Agent role' },
+                role: {
+                    type: 'string',
+                    enum: ['worker', 'specialist', 'scout'],
+                    description: 'Agent role',
+                },
             },
             required: ['agentId'],
         },
         handler: async (input) => {
             const state = loadMonoswarmState();
             const agentId = input.agentId;
-            if (typeof agentId !== 'string' || agentId.length === 0 || agentId.length > 128 ||
-                RESERVED_KEYS.has(agentId) || !/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+            if (typeof agentId !== 'string' ||
+                agentId.length === 0 ||
+                agentId.length > 128 ||
+                RESERVED_KEYS.has(agentId) ||
+                !/^[a-zA-Z0-9_-]+$/.test(agentId)) {
                 return { success: false, error: 'Invalid agentId' };
             }
             if (!state.initialized) {
@@ -603,7 +687,10 @@ export const monoswarmTools = [
             const MAX_AGENTS = 100;
             if (!state.agents.includes(agentId)) {
                 if (state.agents.length >= MAX_AGENTS) {
-                    return { success: false, error: `Monoswarm has reached max agent capacity (${MAX_AGENTS})` };
+                    return {
+                        success: false,
+                        error: `Monoswarm has reached max agent capacity (${MAX_AGENTS})`,
+                    };
                 }
                 state.agents.push(agentId);
                 saveMonoswarmState(state);
@@ -631,8 +718,11 @@ export const monoswarmTools = [
         handler: async (input) => {
             const state = loadMonoswarmState();
             const agentId = input.agentId;
-            if (typeof agentId !== 'string' || agentId.length === 0 || agentId.length > 128 ||
-                RESERVED_KEYS.has(agentId) || !/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+            if (typeof agentId !== 'string' ||
+                agentId.length === 0 ||
+                agentId.length > 128 ||
+                RESERVED_KEYS.has(agentId) ||
+                !/^[a-zA-Z0-9_-]+$/.test(agentId)) {
                 return { success: false, error: 'Invalid agentId' };
             }
             const index = state.agents.indexOf(agentId);
@@ -651,20 +741,34 @@ export const monoswarmTools = [
     },
     {
         name: 'monoswarm_vote',
-        description: 'Create or vote on a proposal; passes when the vote count meets the chosen strategy\'s threshold (majority / supermajority / unanimous / a custom threshold) — single in-process tally, not a distributed consensus protocol.',
+        description: "Create or vote on a proposal; passes when the vote count meets the chosen strategy's threshold (majority / supermajority / unanimous / a custom threshold) — single in-process tally, not a distributed consensus protocol.",
         category: 'monoswarm',
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', enum: ['propose', 'vote', 'status', 'list'], description: 'Vote action' },
+                action: {
+                    type: 'string',
+                    enum: ['propose', 'vote', 'status', 'list'],
+                    description: 'Vote 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: ['majority', 'supermajority', 'unanimous', 'threshold'], description: 'Vote strategy (default: the strategy chosen at monoswarm_init, else majority)' },
-                minVotes: { type: 'number', description: 'Explicit vote count required (for threshold strategy)' },
-                minDivergenceRounds: { type: 'number', description: 'Anti-groupthink delay: minimum rounds with divergent votes required before resolution. Default: 0 (disabled).' },
+                strategy: {
+                    type: 'string',
+                    enum: ['majority', 'supermajority', 'unanimous', 'threshold'],
+                    description: 'Vote strategy (default: the strategy chosen at monoswarm_init, else majority)',
+                },
+                minVotes: {
+                    type: 'number',
+                    description: 'Explicit vote count required (for threshold strategy)',
+                },
+                minDivergenceRounds: {
+                    type: 'number',
+                    description: 'Anti-groupthink delay: minimum rounds with divergent votes required before resolution. Default: 0 (disabled).',
+                },
             },
             required: ['action'],
         },
@@ -672,7 +776,12 @@ export const monoswarmTools = [
             const state = loadMonoswarmState();
             const action = input.action;
             const rawStrategy = input.strategy || state.voteStrategy || 'majority';
-            const VALID_STRATEGIES = ['majority', 'supermajority', 'unanimous', 'threshold'];
+            const VALID_STRATEGIES = [
+                'majority',
+                'supermajority',
+                'unanimous',
+                'threshold',
+            ];
             if (!VALID_STRATEGIES.includes(rawStrategy)) {
                 return {
                     action,
@@ -694,13 +803,16 @@ export const monoswarmTools = [
                 const MAX_VALUE_BYTES = 64 * 1024;
                 const rawType = input.type || 'general';
                 const proposalType = typeof rawType === 'string' && rawType.length > MAX_TYPE_LEN
-                    ? rawType.slice(0, MAX_TYPE_LEN) : rawType;
+                    ? rawType.slice(0, MAX_TYPE_LEN)
+                    : rawType;
                 const rawVoterId = input.voterId || 'system';
                 const proposedBy = typeof rawVoterId === 'string' && rawVoterId.length > MAX_VOTER_ID_LEN
-                    ? rawVoterId.slice(0, MAX_VOTER_ID_LEN) : rawVoterId;
+                    ? rawVoterId.slice(0, MAX_VOTER_ID_LEN)
+                    : rawVoterId;
                 const rawValue = input.value;
                 const cappedValue = typeof rawValue === 'string' && rawValue.length > MAX_VALUE_BYTES
-                    ? rawValue.slice(0, MAX_VALUE_BYTES) : rawValue;
+                    ? rawValue.slice(0, MAX_VALUE_BYTES)
+                    : rawValue;
                 const proposal = {
                     proposalId,
                     type: proposalType,
@@ -730,7 +842,7 @@ export const monoswarmTools = [
                 };
             }
             if (action === 'vote') {
-                const proposal = state.votes.pending.find(p => p.proposalId === input.proposalId);
+                const proposal = state.votes.pending.find((p) => p.proposalId === input.proposalId);
                 if (!proposal) {
                     return { action, error: 'Proposal not found or already resolved' };
                 }
@@ -795,18 +907,18 @@ export const monoswarmTools = [
                     };
                 }
                 proposal.votes[voterId] = voteValue;
-                const votesFor = Object.values(proposal.votes).filter(v => v).length;
-                const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
+                const votesFor = Object.values(proposal.votes).filter((v) => v).length;
+                const votesAgainst = Object.values(proposal.votes).filter((v) => !v).length;
                 const allVotes = Object.values(proposal.votes);
-                const isUnanimous = allVotes.every(v => v) || allVotes.every(v => !v);
+                const isUnanimous = allVotes.every((v) => v) || allVotes.every((v) => !v);
                 if (!isUnanimous && allVotes.length >= 2) {
                     proposal.divergenceRoundsSeen = (proposal.divergenceRoundsSeen ?? 0) + 1;
                 }
                 const totalVotesCast = Object.keys(proposal.votes).length;
                 const electorateExhausted = totalVoters > 0 && totalVotesCast >= totalVoters;
-                const divergenceGateOpen = !proposal.minDivergenceRounds
-                    || (proposal.divergenceRoundsSeen ?? 0) >= proposal.minDivergenceRounds
-                    || electorateExhausted;
+                const divergenceGateOpen = !proposal.minDivergenceRounds ||
+                    (proposal.divergenceRoundsSeen ?? 0) >= proposal.minDivergenceRounds ||
+                    electorateExhausted;
                 const resolution = divergenceGateOpen ? tryResolveProposal(proposal, totalVoters) : null;
                 let resolved = false;
                 if (resolution !== null) {
@@ -819,12 +931,14 @@ export const monoswarmTools = [
                         votes: { for: votesFor, against: votesAgainst },
                         decidedAt: new Date().toISOString(),
                         strategy: proposalStrategy,
-                        duplicateVotersDetected: proposal.duplicateVoters?.length ? proposal.duplicateVoters : undefined,
+                        duplicateVotersDetected: proposal.duplicateVoters?.length
+                            ? proposal.duplicateVoters
+                            : undefined,
                     });
                     if (state.votes.history.length > 1000) {
                         state.votes.history = state.votes.history.slice(-1000);
                     }
-                    state.votes.pending = state.votes.pending.filter(p => p.proposalId !== proposal.proposalId);
+                    state.votes.pending = state.votes.pending.filter((p) => p.proposalId !== proposal.proposalId);
                 }
                 saveMonoswarmState(state);
                 if (resolved) {
@@ -844,7 +958,9 @@ export const monoswarmTools = [
                             tags: [proposal.type, proposalStrategy, proposal.status],
                         });
                     }
-                    catch { /* SQLite memory backend not available — JSON store is primary */ }
+                    catch {
+                        /* SQLite memory backend not available — JSON store is primary */
+                    }
                     const hk = getOrCreateAuditKey();
                     try {
                         const { AuditWriter } = await import('../consensus/audit-writer.js');
@@ -901,16 +1017,16 @@ export const monoswarmTools = [
                 };
             }
             if (action === 'status') {
-                const proposal = state.votes.pending.find(p => p.proposalId === input.proposalId);
+                const proposal = state.votes.pending.find((p) => p.proposalId === input.proposalId);
                 if (!proposal) {
-                    const historical = state.votes.history.find(h => h.proposalId === input.proposalId);
+                    const historical = state.votes.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 votesFor = Object.values(proposal.votes).filter((v) => v).length;
+                const votesAgainst = Object.values(proposal.votes).filter((v) => !v).length;
                 const proposalStrategy = proposal.strategy || 'majority';
                 const required = calculateRequiredVotes(proposalStrategy, totalVoters, proposal.minVotes);
                 return {
@@ -932,7 +1048,7 @@ export const monoswarmTools = [
             if (action === 'list') {
                 return {
                     action,
-                    pending: state.votes.pending.map(p => ({
+                    pending: state.votes.pending.map((p) => ({
                         proposalId: p.proposalId,
                         type: p.type,
                         strategy: p.strategy || 'majority',
@@ -955,7 +1071,11 @@ export const monoswarmTools = [
             type: 'object',
             properties: {
                 message: { type: 'string', description: 'Notice text' },
-                priority: { type: 'string', enum: ['low', 'normal', 'high', 'critical'], description: 'Notice priority' },
+                priority: {
+                    type: 'string',
+                    enum: ['low', 'normal', 'high', 'critical'],
+                    description: 'Notice priority',
+                },
                 fromId: { type: 'string', description: 'Sender agent ID' },
             },
             required: ['message'],
@@ -970,15 +1090,24 @@ export const monoswarmTools = [
             const MAX_PRIORITY_LEN = 16;
             const rawMessage = input.message;
             const message = typeof rawMessage === 'string' && rawMessage.length > MAX_MSG_LEN
-                ? rawMessage.slice(0, MAX_MSG_LEN) : rawMessage;
+                ? rawMessage.slice(0, MAX_MSG_LEN)
+                : rawMessage;
             const rawFromId = input.fromId || 'system';
             const fromId = typeof rawFromId === 'string' && rawFromId.length > MAX_FROM_ID_LEN
-                ? rawFromId.slice(0, MAX_FROM_ID_LEN) : rawFromId;
+                ? rawFromId.slice(0, MAX_FROM_ID_LEN)
+                : rawFromId;
             const rawPriority = input.priority || 'normal';
             const priority = typeof rawPriority === 'string' && rawPriority.length > MAX_PRIORITY_LEN
-                ? rawPriority.slice(0, MAX_PRIORITY_LEN) : rawPriority;
+                ? rawPriority.slice(0, MAX_PRIORITY_LEN)
+                : rawPriority;
             const noticeId = `notice-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            state.notices.push({ noticeId, message, priority, fromId, timestamp: new Date().toISOString() });
+            state.notices.push({
+                noticeId,
+                message,
+                priority,
+                fromId,
+                timestamp: new Date().toISOString(),
+            });
             state.notices = state.notices.slice(-100); // Keep only the last 100 notices
             saveMonoswarmState(state);
             return {
@@ -997,7 +1126,11 @@ export const monoswarmTools = [
         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)' },
             },
@@ -1031,7 +1164,8 @@ export const monoswarmTools = [
                 }
                 const rawValue = input.value;
                 const cappedValue = typeof rawValue === 'string' && rawValue.length > MAX_VALUE_BYTES
-                    ? rawValue.slice(0, MAX_VALUE_BYTES) : rawValue;
+                    ? rawValue.slice(0, MAX_VALUE_BYTES)
+                    : rawValue;
                 const keyCount = Object.keys(state.sharedMemory).length;
                 if (!Object.hasOwn(state.sharedMemory, key) && keyCount >= MAX_KEYS) {
                     return { action, error: `Shared memory full (max ${MAX_KEYS} keys)` };
@@ -1046,7 +1180,9 @@ export const monoswarmTools = [
                         namespace: 'monoswarm-memory',
                     });
                 }
-                catch { /* SQLite memory backend not available */ }
+                catch {
+                    /* SQLite memory backend not available */
+                }
                 return { action, key, success: true, updatedAt: new Date().toISOString() };
             }
             if (action === 'delete') {
@@ -1092,7 +1228,7 @@ export const monoswarmTools = [
                 return {
                     success: true,
                     count: records.length,
-                    records: records.map(r => ({
+                    records: records.map((r) => ({
                         decisionId: r.decisionId,
                         swarmId: r.swarmId,
                         protocol: r.protocol,