monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/dist/src/commands/security-cve.js

@@ -2,11 +2,12 @@
  * Security CVE command — NVD/OSV lookups and npm audit vulnerability listing
  */
 import { output } from '../output.js';
-import { statSync, readFileSync, mkdirSync, writeFileSync, renameSync } from 'fs';
+import { statSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import * as https from 'https';
+import { writeJsonFileAtomic } from '../utils/json-file.js';
 // ─── CVE helpers ─────────────────────────────────────────────────────────────
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 function getCveCache(cveId, cacheDir) {
@@ -25,11 +26,8 @@ const CVE_ID_RE = /^CVE-\d{4}-\d{4,}$/i;
 function saveCveCache(cveId, cacheDir, data) {
     if (!CVE_ID_RE.test(cveId))
         throw new Error('Invalid CVE ID');
-    mkdirSync(cacheDir, { recursive: true });
     const dest = join(cacheDir, `${cveId.toUpperCase()}.json`);
-    const tmp = dest + '.tmp';
-    writeFileSync(tmp, JSON.stringify(data));
-    renameSync(tmp, dest);
+    writeJsonFileAtomic(dest, data, false);
 }
 function httpsGet(url, timeoutMs = 10_000) {
     return new Promise((resolve, reject) => {

package/packages/@monomind/cli/dist/src/commands/session.js

@@ -456,6 +456,142 @@ const currentCommand = {
         }
     }
 };
+// Replay subcommand (session replay and inspection, merged from `replay` command)
+const replayShowCommand = {
+    name: 'show',
+    description: 'Show replay for a session',
+    options: [
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        // Cap session ID to prevent DoS via oversized string and unbounded output reflection.
+        const sessionId = (ctx.args[0] || '').slice(0, 128);
+        if (!sessionId) {
+            output.printError('Session ID is required: session replay show <sessionId>');
+            return { success: false, message: 'Missing session ID' };
+        }
+        try {
+            const { ReplayReader } = await import('../observability/replay-reader.js');
+            const reader = new ReplayReader();
+            const data = await reader.show(sessionId);
+            if (!data) {
+                output.writeln(`No replay data for session ${sessionId}`);
+                return { success: true, message: 'No replay data' };
+            }
+            if (ctx.flags['json']) {
+                output.writeln(JSON.stringify(data, null, 2));
+                return { success: true, data };
+            }
+            // Human-readable summary derived from the session replay data
+            const started = new Date(data.startedAt);
+            const ended = data.endedAt ? new Date(data.endedAt) : null;
+            const duration = ended && !isNaN(started.getTime()) && !isNaN(ended.getTime())
+                ? formatDuration(ended.getTime() - started.getTime())
+                : 'in progress';
+            output.writeln();
+            output.writeln(output.bold(`Replay: ${data.id}`));
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'property', header: 'Property', width: 18 },
+                    { key: 'value', header: 'Value', width: 45 }
+                ],
+                data: [
+                    { property: 'Started', value: isNaN(started.getTime()) ? data.startedAt : started.toLocaleString() },
+                    { property: 'Ended', value: ended ? ended.toLocaleString() : '-' },
+                    { property: 'Duration', value: duration },
+                    { property: 'Tasks', value: data.taskCount != null ? String(data.taskCount) : '-' },
+                    { property: 'Tokens', value: data.tokenUsage?.total != null ? String(data.tokenUsage.total) : '-' },
+                    { property: 'File', value: data.filePath }
+                ]
+            });
+            // Key steps: surface recorded metrics from the raw session data if present
+            const metrics = data.raw?.metrics;
+            if (metrics && typeof metrics === 'object') {
+                const entries = Object.entries(metrics)
+                    .filter(([, v]) => typeof v === 'number' || typeof v === 'string');
+                if (entries.length > 0) {
+                    output.writeln();
+                    output.writeln(output.bold('Metrics'));
+                    output.printList(entries.map(([k, v]) => `${k}: ${String(v)}`));
+                }
+            }
+            return { success: true, data };
+        }
+        catch {
+            output.writeln(`No replay data for session ${sessionId}`);
+            return { success: true, message: 'No replay data' };
+        }
+    },
+};
+const replayListCommand = {
+    name: 'list',
+    description: 'List available session replays',
+    options: [
+        { name: 'limit', short: 'n', type: 'number', description: 'Max entries', default: 20 },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        try {
+            const { ReplayReader } = await import('../observability/replay-reader.js');
+            const reader = new ReplayReader();
+            const rawLimit = ctx.flags['limit'];
+            // Cap limit to prevent DoS
+            const limit = typeof rawLimit === 'number' && Number.isFinite(rawLimit)
+                ? Math.max(1, Math.min(Math.floor(rawLimit), 500))
+                : 20;
+            const data = await reader.list(limit);
+            if (ctx.flags['json']) {
+                output.writeln(JSON.stringify(data, null, 2));
+                return { success: true, data };
+            }
+            if (data.length === 0) {
+                output.writeln('No replay sessions available');
+                return { success: true, data };
+            }
+            output.writeln();
+            output.writeln(output.bold(`Session Replays (${data.length})`));
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'id', header: 'ID', width: 26 },
+                    { key: 'started', header: 'Started', width: 20 },
+                    { key: 'ended', header: 'Ended', width: 20 },
+                    { key: 'tasks', header: 'Tasks', width: 8, align: 'right' }
+                ],
+                data: data.map(s => ({
+                    id: s.id,
+                    started: formatDate(s.startedAt),
+                    ended: s.endedAt ? formatDate(s.endedAt) : '-',
+                    tasks: s.taskCount != null ? String(s.taskCount) : '-'
+                }))
+            });
+            output.writeln();
+            output.printInfo('Show details with: monomind session replay show <sessionId>');
+            return { success: true, data };
+        }
+        catch {
+            output.writeln('No replay sessions available');
+            return { success: true, message: 'No sessions' };
+        }
+    },
+};
+const replayCommand = {
+    name: 'replay',
+    description: 'Session replay and inspection',
+    subcommands: [replayShowCommand, replayListCommand],
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('Session Replay'));
+        output.writeln();
+        output.writeln('Usage: monomind session replay <show|list> [options]');
+        output.printList([
+            `${output.highlight('show <sessionId>')} - Show replay for a session`,
+            `${output.highlight('list')}             - List available session replays`
+        ]);
+        return { success: true };
+    },
+};
 // Helper functions
 function formatSize(bytes) {
     if (bytes === 0)
@@ -486,7 +622,8 @@ export const sessionCommand = {
         saveCommand,
         restoreCommand,
         deleteCommand,
-        currentCommand
+        currentCommand,
+        replayCommand
     ],
     options: [],
     examples: [
@@ -494,7 +631,9 @@ export const sessionCommand = {
         { command: 'monomind session save -n "checkpoint-1"', description: 'Save current session' },
         { command: 'monomind session restore session-123', description: 'Restore a session' },
         { command: 'monomind session delete session-123', description: 'Delete a session' },
-        { command: 'monomind session current', description: 'Show current session' }
+        { command: 'monomind session current', description: 'Show current session' },
+        { command: 'monomind session replay list', description: 'List available session replays' },
+        { command: 'monomind session replay show session-123', description: 'Show replay for a session' }
     ],
     action: async (ctx) => {
         // Show help if no subcommand
@@ -509,7 +648,8 @@ export const sessionCommand = {
             `${output.highlight('save')}    - Save current session state`,
             `${output.highlight('restore')} - Restore a saved session`,
             `${output.highlight('delete')}  - Delete a saved session`,
-            `${output.highlight('current')} - Show current active session`
+            `${output.highlight('current')} - Show current active session`,
+            `${output.highlight('replay')}  - Session replay and inspection (show, list)`
         ]);
         output.writeln();
         output.writeln('Run "monomind session <subcommand> --help" for subcommand help');

package/packages/@monomind/cli/dist/src/commands/start.js

@@ -8,7 +8,6 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
 // Default configuration
-const DEFAULT_PORT = 3000;
 const DEFAULT_TOPOLOGY = 'hierarchical-mesh';
 const DEFAULT_MAX_AGENTS = 15;
 // Check if project is initialized
@@ -85,9 +84,7 @@ function loadConfig(cwd) {
 // Main start action
 const startAction = async (ctx) => {
     const daemon = ctx.flags.daemon;
-    const port = ctx.flags.port;
     const topology = ctx.flags.topology;
-    const skipMcp = ctx.flags['skip-mcp'];
     const cwd = ctx.cwd;
     // Check initialization
     if (!isInitialized(cwd)) {
@@ -364,33 +361,18 @@ export const startCommand = {
             type: 'boolean',
             default: false
         },
-        {
-            name: 'port',
-            short: 'p',
-            description: 'MCP server port',
-            type: 'number',
-            default: DEFAULT_PORT
-        },
         {
             name: 'topology',
             short: 't',
             description: 'Swarm topology (hierarchical-mesh, mesh, hierarchical, ring, star)',
             type: 'string',
             choices: ['hierarchical-mesh', 'mesh', 'hierarchical', 'ring', 'star']
-        },
-        {
-            name: 'skip-mcp',
-            description: 'Skip starting MCP server',
-            type: 'boolean',
-            default: false
         }
     ],
     examples: [
         { command: 'monomind start', description: 'Start with configuration defaults' },
         { command: 'monomind start --daemon', description: 'Start as background daemon' },
-        { command: 'monomind start --port 3001', description: 'Start MCP on custom port' },
         { command: 'monomind start --topology mesh', description: 'Start with mesh topology' },
-        { command: 'monomind start --skip-mcp', description: 'Start without MCP server' },
         { command: 'monomind start quick', description: 'Quick start with defaults' },
         { command: 'monomind start stop', description: 'Stop the running system' }
     ],

package/packages/@monomind/cli/dist/src/commands/swarm.js

@@ -7,50 +7,68 @@ import { select, confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
-// Get dynamic swarm status from memory/session files
+import { writeJsonFileAtomic } from '../utils/json-file.js';
+// Canonical paths — shared with MCP tools so CLI and MCP see the same state
+const SWARM_STATE_DIR = '.monomind/swarm';
+const SWARM_STATE_FILE = 'swarm-state.json';
+const AGENT_STORE_PATH = '.monomind/agents/store.json';
+// Get dynamic swarm status from MCP-canonical state files
 function getSwarmStatus(swarmId) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
     const sessionDir = path.join(process.cwd(), '.claude', 'sessions');
     const memoryPaths = [
-        path.join(process.cwd(), '.swarm', 'memory.db'),
+        path.join(process.cwd(), '.monomind', 'memory.db'),
         path.join(process.cwd(), '.claude', 'memory.db'),
     ];
-    // Check for active swarm state file
-    const swarmStateFile = path.join(swarmDir, 'state.json');
+    // Read swarm state from MCP-canonical path (.monomind/swarm/swarm-state.json)
+    const swarmStateFile = path.join(process.cwd(), SWARM_STATE_DIR, SWARM_STATE_FILE);
     let swarmState = null;
     if (fs.existsSync(swarmStateFile)) {
         try {
             const swarmStatSz = fs.statSync(swarmStateFile).size;
-            if (swarmStatSz <= 1_048_576) {
-                swarmState = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
+            if (swarmStatSz <= 10_485_760) {
+                const store = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
+                // MCP swarm-tools stores { swarms: { [id]: SwarmState } }
+                if (store?.swarms && typeof store.swarms === 'object') {
+                    const swarms = store.swarms;
+                    if (swarmId && swarms[swarmId]) {
+                        swarmState = swarms[swarmId];
+                    }
+                    else {
+                        // Find latest non-terminated swarm
+                        const running = Object.values(swarms)
+                            .filter((s) => s.status !== 'terminated')
+                            .sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')));
+                        if (running.length > 0)
+                            swarmState = running[0];
+                    }
+                }
+                else if (store?.id || store?.swarmId) {
+                    // Legacy CLI-written format { id, topology, ... }
+                    swarmState = store;
+                }
             }
         }
         catch {
             // Ignore parse errors
         }
     }
-    // Count active agents from process files
+    // Count agents from MCP-canonical agent store (.monomind/agents/store.json)
     let activeAgents = 0;
     let totalAgents = 0;
-    const agentsDir = path.join(swarmDir, 'agents');
-    if (fs.existsSync(agentsDir)) {
+    const agentStoreFile = path.join(process.cwd(), AGENT_STORE_PATH);
+    if (fs.existsSync(agentStoreFile)) {
         try {
-            const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.json'));
-            totalAgents = agentFiles.length;
-            for (const file of agentFiles) {
-                try {
-                    const agentFilePath = path.join(agentsDir, file);
-                    const agentSz = fs.statSync(agentFilePath).size;
-                    if (agentSz <= 524_288) {
-                        const agent = JSON.parse(fs.readFileSync(agentFilePath, 'utf-8'));
-                        if (agent.status === 'active' || agent.status === 'running') {
+            const agentSz = fs.statSync(agentStoreFile).size;
+            if (agentSz <= 52_428_800) {
+                const agentStore = JSON.parse(fs.readFileSync(agentStoreFile, 'utf-8'));
+                if (agentStore?.agents && typeof agentStore.agents === 'object') {
+                    for (const agent of Object.values(agentStore.agents)) {
+                        totalAgents++;
+                        if (agent.status === 'idle' || agent.status === 'busy') {
                             activeAgents++;
                         }
                     }
                 }
-                catch {
-                    // Ignore
-                }
             }
         }
         catch {
@@ -84,7 +102,7 @@ function getSwarmStatus(swarmId) {
     let completedTasks = 0;
     let inProgressTasks = 0;
     let pendingTasks = 0;
-    const tasksDir = path.join(swarmDir, 'tasks');
+    const tasksDir = path.join(process.cwd(), SWARM_STATE_DIR, 'tasks');
     if (fs.existsSync(tasksDir)) {
         try {
             const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
@@ -137,7 +155,7 @@ function getSwarmStatus(swarmId) {
         status = 'ready';
     }
     return {
-        id: swarmId || swarmState?.id || 'no-active-swarm',
+        id: swarmId || swarmState?.swarmId || swarmState?.id || 'no-active-swarm',
         topology: swarmState?.topology || 'none',
         status,
         objective: swarmState?.objective || 'No active objective',
@@ -291,24 +309,35 @@ const initCommand = {
             });
             output.writeln();
             output.printSuccess('Swarm initialized successfully');
-            // Save swarm state locally for status command to read
-            const swarmDir = path.join(process.cwd(), '.swarm');
+            // Save swarm state to MCP-canonical path so CLI and MCP share state
             try {
-                if (!fs.existsSync(swarmDir)) {
-                    fs.mkdirSync(swarmDir, { recursive: true });
+                const swarmDir2 = path.join(process.cwd(), SWARM_STATE_DIR);
+                if (!fs.existsSync(swarmDir2)) {
+                    fs.mkdirSync(swarmDir2, { recursive: true });
                 }
-                const stateFile = path.join(swarmDir, 'state.json');
-                const tmpStateFile1 = stateFile + '.tmp';
-                fs.writeFileSync(tmpStateFile1, JSON.stringify({
-                    id: result.swarmId,
+                // Read existing store to preserve other swarms
+                const stateFile = path.join(swarmDir2, SWARM_STATE_FILE);
+                let store = { swarms: {}, version: '3.0.0' };
+                if (fs.existsSync(stateFile)) {
+                    try {
+                        store = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+                    }
+                    catch { /* use default */ }
+                }
+                if (!store.swarms || typeof store.swarms !== 'object')
+                    store.swarms = {};
+                store.swarms[result.swarmId] = {
+                    swarmId: result.swarmId,
                     topology: result.topology,
                     maxAgents: result.config.maxAgents,
-                    strategy: ctx.flags.strategy || 'development',
-                    v1Mode,
-                    initializedAt: result.initializedAt,
-                    status: 'ready'
-                }, null, 2));
-                fs.renameSync(tmpStateFile1, stateFile);
+                    status: 'running',
+                    agents: [],
+                    tasks: [],
+                    config: { strategy: ctx.flags.strategy || 'development', v1Mode },
+                    createdAt: result.initializedAt || new Date().toISOString(),
+                    updatedAt: new Date().toISOString()
+                };
+                writeJsonFileAtomic(stateFile, store);
             }
             catch {
                 // Ignore errors writing state file
@@ -428,34 +457,46 @@ const startCommand = {
             spinner.succeed('Swarm initialized via MCP');
         }
         catch (err) {
-            spinner.fail('MCP swarm_init failed — swarm metadata saved locally only');
+            // swarm_init runs in-process via the local MCP tool registry — there is no
+            // separate MCP server to "start" here. A failure means the handler itself
+            // threw (bad input, filesystem/config issue, etc.), not that a server is down.
+            spinner.fail('swarm_init failed — swarm metadata saved locally only');
             output.writeln(output.dim(`  Error: ${err instanceof Error ? err.message : String(err)}`));
-            output.writeln(output.dim('  The MCP server may not be running. Start it with: claude mcp add monomind npx monomind@v1alpha mcp start'));
+            output.writeln(output.dim('  Run with -v/--verbose for more detail, or `monomind doctor` to check config/permission issues.'));
         }
-        // Persist swarm state to disk so `swarm status` can read it
-        const swarmDir = path.join(process.cwd(), '.swarm');
+        // Persist swarm state to MCP-canonical path so CLI and MCP share state
+        const swarmDir = path.join(process.cwd(), SWARM_STATE_DIR);
         if (!fs.existsSync(swarmDir))
             fs.mkdirSync(swarmDir, { recursive: true });
-        const executionState = {
+        // Read existing store to preserve other swarms
+        const stateFile2 = path.join(swarmDir, SWARM_STATE_FILE);
+        let startStore = { swarms: {}, version: '3.0.0' };
+        if (fs.existsSync(stateFile2)) {
+            try {
+                startStore = JSON.parse(fs.readFileSync(stateFile2, 'utf-8'));
+            }
+            catch { /* use default */ }
+        }
+        if (!startStore.swarms || typeof startStore.swarms !== 'object')
+            startStore.swarms = {};
+        startStore.swarms[resolvedSwarmId] = {
             swarmId: resolvedSwarmId,
-            objective,
-            strategy,
-            status: 'initialized',
-            agents: totalAgents,
-            agentPlan,
-            startedAt: new Date().toISOString(),
-            parallel: ctx.flags.parallel ?? true
+            topology: 'hierarchical',
+            maxAgents: totalAgents,
+            status: 'running',
+            agents: [],
+            tasks: [],
+            config: { strategy, objective, agentPlan, parallel: ctx.flags.parallel ?? true },
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
         };
-        const stateFile2 = path.join(swarmDir, 'state.json');
-        const tmpStateFile2 = stateFile2 + '.tmp';
-        fs.writeFileSync(tmpStateFile2, JSON.stringify(executionState, null, 2));
-        fs.renameSync(tmpStateFile2, stateFile2);
+        writeJsonFileAtomic(stateFile2, startStore);
         output.writeln();
         output.printSuccess(`Swarm ${resolvedSwarmId} initialized with ${totalAgents} agent slots`);
         output.writeln(output.dim('  Note: Agents are registered but actual task execution requires'));
         output.writeln(output.dim('  Claude Code Task tool or hive-mind spawn --claude to drive work.'));
         output.writeln(output.dim(`  Monitor: monomind swarm status ${resolvedSwarmId}`));
-        return { success: true, data: executionState };
+        return { success: true, data: { swarmId: resolvedSwarmId, objective, strategy, agents: totalAgents } };
     }
 };
 // Swarm status
@@ -585,18 +626,24 @@ const stopCommand = {
         }
         // Only update persisted swarm state if the MCP call succeeded (#1423)
         if (mcpStopped) {
-            const swarmStateFile = path.join(process.cwd(), '.swarm', 'state.json');
-            if (fs.existsSync(swarmStateFile)) {
+            const stopStateFile = path.join(process.cwd(), SWARM_STATE_DIR, SWARM_STATE_FILE);
+            if (fs.existsSync(stopStateFile)) {
                 try {
-                    const stopStatSz = fs.statSync(swarmStateFile).size;
-                    if (stopStatSz > 1_048_576)
+                    const stopStatSz = fs.statSync(stopStateFile).size;
+                    if (stopStatSz > 10_485_760)
                         throw new Error('swarm state file too large');
-                    const state = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
-                    state.status = 'stopped';
-                    state.stoppedAt = new Date().toISOString();
-                    const tmpSwarmStop = swarmStateFile + '.tmp';
-                    fs.writeFileSync(tmpSwarmStop, JSON.stringify(state, null, 2));
-                    fs.renameSync(tmpSwarmStop, swarmStateFile);
+                    const store = JSON.parse(fs.readFileSync(stopStateFile, 'utf-8'));
+                    // Update the specific swarm in the MCP store format
+                    if (store?.swarms?.[swarmId]) {
+                        store.swarms[swarmId].status = 'terminated';
+                        store.swarms[swarmId].updatedAt = new Date().toISOString();
+                    }
+                    else if (store?.id || store?.swarmId) {
+                        // Legacy format
+                        store.status = 'stopped';
+                        store.stoppedAt = new Date().toISOString();
+                    }
+                    writeJsonFileAtomic(stopStateFile, store);
                     output.writeln(output.dim('  Swarm state updated'));
                 }
                 catch {

package/packages/@monomind/cli/dist/src/consensus/audit-writer.js

@@ -7,7 +7,49 @@ import { appendFileSync, readFileSync, existsSync, mkdirSync, statSync } from 'f
 import { createHmac, timingSafeEqual } from 'crypto';
 import { dirname, join, resolve, relative } from 'path';
 import { parseJsonl } from '../utils/parse-jsonl.js';
-import { deriveSigningKey, signVote, verifyVote } from './vote-signer.js';
+// ─── HMAC tamper-detection helpers (private) ─────────────────────────────────
+// These sign each vote entry in the audit log so verifyIntegrity() can detect
+// after-the-fact edits to the JSONL file. They are log tamper-detection, not an
+// inter-agent trust mechanism — all signing happens inside this one process.
+/** Max depth for canonicalize() to prevent stack overflow on deeply nested objects. */
+const MAX_CANONICALIZE_DEPTH = 32;
+/** Cap string inputs to prevent OOM when hashing very long strings. */
+const MAX_INPUT_LEN = 1024;
+/** Derive a signing key from a swarmId and session secret using HMAC-SHA256. */
+function deriveSigningKey(swarmId, sessionSecret) {
+    return createHmac('sha256', sessionSecret.slice(0, MAX_INPUT_LEN)).update(swarmId.slice(0, MAX_INPUT_LEN)).digest();
+}
+function canonicalize(val, depth = 0) {
+    // Guard against deeply-nested objects that would overflow the call stack.
+    if (depth > MAX_CANONICALIZE_DEPTH)
+        return '"[MaxDepth]"';
+    if (val === null || typeof val !== 'object')
+        return JSON.stringify(val);
+    if (Array.isArray(val))
+        return '[' + val.map(item => canonicalize(item, depth + 1)).join(',') + ']';
+    const sorted = Object.keys(val).sort().map(k => JSON.stringify(k) + ':' + canonicalize(val[k], depth + 1));
+    return '{' + sorted.join(',') + '}';
+}
+/** Sign a vote entry, producing a hex-encoded HMAC-SHA256 signature. */
+function signVote(agentId, vote, decisionId, key) {
+    // Cap string fields to prevent OOM when hashing attacker-supplied inputs.
+    const safeAgentId = agentId.slice(0, MAX_INPUT_LEN);
+    const safeDecisionId = decisionId.slice(0, MAX_INPUT_LEN);
+    const payload = JSON.stringify({ agentId: safeAgentId, vote: canonicalize(vote), decisionId: safeDecisionId });
+    return createHmac('sha256', key).update(payload).digest('hex');
+}
+/** Verify a vote entry signature using constant-time comparison. */
+function verifyVote(agentId, vote, decisionId, signature, key) {
+    // Guard: odd-length or non-hex signature string causes Buffer.from to throw.
+    if (!/^[0-9a-fA-F]{64}$/.test(signature))
+        return false;
+    const expected = signVote(agentId, vote, decisionId, key);
+    const sigBuf = Buffer.from(signature, 'hex');
+    const expBuf = Buffer.from(expected, 'hex');
+    if (sigBuf.length !== expBuf.length)
+        return false;
+    return timingSafeEqual(sigBuf, expBuf);
+}
 export class AuditWriter {
     auditPath;
     votesPath;

package/packages/@monomind/cli/dist/src/consensus/tally.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Confidence-weighted vote tally for multi-agent voting.
+ *
+ * This is plain vote counting across subagents of one process — not a
+ * distributed consensus protocol. Each vote carries a confidence weight
+ * in [0,1]; quorum passes when weighted approval exceeds half the total weight.
+ */
+export declare function weightedTally(votes: Array<{
+    agentId: string;
+    vote: boolean;
+    confidence: number;
+}>): {
+    approved: number;
+    rejected: number;
+    weightedApproval: number;
+    weightedRejection: number;
+    quorum: boolean;
+};
+//# sourceMappingURL=tally.d.ts.map

package/packages/@monomind/cli/dist/src/consensus/tally.js

@@ -0,0 +1,34 @@
+/**
+ * Confidence-weighted vote tally for multi-agent voting.
+ *
+ * This is plain vote counting across subagents of one process — not a
+ * distributed consensus protocol. Each vote carries a confidence weight
+ * in [0,1]; quorum passes when weighted approval exceeds half the total weight.
+ */
+/** Cap votes array to prevent OOM. */
+const MAX_VOTES = 1000;
+export function weightedTally(votes) {
+    // Cap votes array to prevent OOM from an oversized input.
+    const safeVotes = votes.length > MAX_VOTES ? votes.slice(0, MAX_VOTES) : votes;
+    let weightedApproval = 0;
+    let weightedRejection = 0;
+    let totalWeight = 0;
+    for (const { vote, confidence } of safeVotes) {
+        const w = Math.max(0, Math.min(1, confidence)); // clamp to [0,1]
+        totalWeight += w;
+        if (vote) {
+            weightedApproval += w;
+        }
+        else {
+            weightedRejection += w;
+        }
+    }
+    return {
+        approved: safeVotes.filter(v => v.vote).length,
+        rejected: safeVotes.filter(v => !v.vote).length,
+        weightedApproval,
+        weightedRejection,
+        quorum: totalWeight > 0 && weightedApproval / totalWeight > 0.5,
+    };
+}
+//# sourceMappingURL=tally.js.map

package/packages/@monomind/cli/dist/src/index.d.ts

@@ -49,8 +49,9 @@ export declare class CLI {
     private loadConfig;
     /**
      * Initialize optional subsystems at startup (non-blocking, all failures are silent).
-     * Wires TierManager, ObservabilityBus + TraceCollector, and SwarmCheckpointer
-     * so that packages/@monomind/* actually contribute to the live runtime.
+     * Starts the @monomind/hooks WorkerManager, wires SwarmCheckpointer, and builds
+     * the unified agent registry so that packages/@monomind/* actually contribute
+     * to the live runtime.
      */
     private initSubsystems;
     /**