monomind 1.18.15 → 2.0.0

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

@@ -79,8 +79,13 @@ async function getSystemStatus() {
         catch {
             // MCP not running
         }
-        // Get memory status
-        const memoryStatus = await callMCPTool('memory_stats', {});
+        // Memory status — no MCP tool available; use defaults
+        const memoryStatus = {
+            entries: 0,
+            size: 0,
+            backend: 'lancedb',
+            performance: { avgSearchTime: 0, cacheHitRate: 0 },
+        };
         // Get task status
         const taskStatus = await callMCPTool('task_summary', {});
         return {
@@ -495,8 +500,17 @@ const memoryCommand = {
     name: 'memory',
     description: 'Show detailed memory status',
     action: async (ctx) => {
+        // memory_detailed-stats MCP tool is not registered; use memory bridge directly
         try {
-            const result = await callMCPTool('memory_detailed-stats', {});
+            const { bridgeListEntries } = await import('../memory/memory-bridge.js');
+            const listed = await bridgeListEntries({ limit: 10000 });
+            const entries = listed?.success ? listed.entries : [];
+            const totalBytes = entries.reduce((s, e) => s + (e.content || '').length, 0);
+            const result = {
+                backend: 'LanceDB',
+                entries: entries.length,
+                size: totalBytes,
+            };
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
@@ -513,37 +527,12 @@ const memoryCommand = {
                     { property: 'Backend', value: result.backend },
                     { property: 'Total Entries', value: result.entries.toLocaleString() },
                     { property: 'Storage Size', value: formatBytes(result.size) },
-                    { property: 'HNSW Index', value: result.performance.hnswEnabled ? 'Enabled' : 'Disabled' }
-                ]
-            });
-            output.writeln();
-            output.writeln(output.bold('Performance'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 20 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Avg Search Time', value: `${result.performance.avgSearchTime.toFixed(2)}ms` },
-                    { metric: 'Avg Write Time', value: `${result.performance.avgWriteTime.toFixed(2)}ms` },
-                    { metric: 'Cache Hit Rate', value: `${(result.performance.cacheHitRate * 100).toFixed(1)}%` }
                 ]
             });
-            output.writeln();
-            output.writeln(output.bold('v1 Performance Gains'));
-            output.printList([
-                `Search Speed: ${output.success(result.v1Gains.searchImprovement)}`,
-                `Memory Usage: ${output.success(result.v1Gains.memoryReduction)}`
-            ]);
             return { success: true, data: result };
         }
         catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to get memory status: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
+            output.printError(`Failed to get memory status: ${error instanceof Error ? error.message : String(error)}`);
             return { success: false, exitCode: 1 };
         }
     }

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
@@ -575,7 +616,7 @@ const stopCommand = {
         // Attempt MCP cleanup first — only persist 'stopped' state if it succeeds
         let mcpStopped = false;
         try {
-            await callMCPTool('swarm_stop', { swarmId, force });
+            await callMCPTool('swarm_shutdown', { swarmId, force });
             output.writeln(output.dim('  MCP swarm stopped'));
             mcpStopped = true;
         }
@@ -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/commands/task.js

@@ -601,56 +601,11 @@ const assignCommand = {
         }
     }
 };
-// Retry subcommand
-const retryCommand = {
-    name: 'retry',
-    aliases: ['rerun'],
-    description: 'Retry a failed task',
-    options: [
-        {
-            name: 'reset-state',
-            description: 'Reset task state completely',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    action: async (ctx) => {
-        const taskId = (ctx.args[0] || '').slice(0, MAX_TASK_ID_LEN);
-        const resetState = ctx.flags['reset-state'];
-        if (!taskId) {
-            output.printError('Task ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('task_retry', {
-                taskId,
-                resetState
-            });
-            output.writeln();
-            output.printSuccess(`Task ${taskId} retried`);
-            output.printInfo(`New task ID: ${result.newTaskId}`);
-            output.printInfo(`Status: ${formatStatus(result.status)}`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to retry task: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 // Main task command
 export const taskCommand = {
     name: 'task',
     description: 'Task management commands',
-    subcommands: [createCommand, listCommand, statusCommand, cancelCommand, assignCommand, retryCommand],
+    subcommands: [createCommand, listCommand, statusCommand, cancelCommand, assignCommand],
     options: [],
     examples: [
         { command: 'monomind task create -t implementation -d "Add user auth"', description: 'Create a task' },
@@ -659,7 +614,6 @@ export const taskCommand = {
         { command: 'monomind task status task-123', description: 'Get task details' },
         { command: 'monomind task cancel task-123', description: 'Cancel a task' },
         { command: 'monomind task assign task-123 --agent coder-1', description: 'Assign task to agent' },
-        { command: 'monomind task retry task-123', description: 'Retry a failed task' }
     ],
     action: async (ctx) => {
         // Show help if no subcommand
@@ -674,8 +628,7 @@ export const taskCommand = {
             `${output.highlight('list')}    - List tasks`,
             `${output.highlight('status')}  - Get task details`,
             `${output.highlight('cancel')}  - Cancel a running task`,
-            `${output.highlight('assign')}  - Assign task to agent(s)`,
-            `${output.highlight('retry')}   - Retry a failed task`
+            `${output.highlight('assign')}  - Assign task to agent(s)`
         ]);
         output.writeln();
         output.writeln('Run "monomind task <subcommand> --help" for subcommand help');

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;
     /**

package/packages/@monomind/cli/dist/src/index.js

@@ -413,14 +413,16 @@ export class CLI {
     }
     /**
      * 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.
      */
     async initSubsystems() {
-        // GAP-004/005/006: Register background workers (EntityExtractor, EpisodeBinner, TraceCollector)
+        // Start the @monomind/hooks WorkerManager (performance/health/swarm/git/learning/
+        // adr/ddd/security/patterns/cache/progress) — previously implemented but never invoked
         try {
-            const { initDefaultWorkers } = await import('@monomind/hooks');
-            await initDefaultWorkers();
+            const { workerManager } = await import('@monomind/hooks');
+            await workerManager.start();
         }
         catch { /* optional */ }
         // GAP-007: SwarmCheckpointer — write checkpoint files so crashed swarms can resume
@@ -455,10 +457,12 @@ export class CLI {
         // runs it synchronously within its own check pass instead, so it's always
         // visible and itemized when you actually look for it.
         // NOTE: Semantic routing (@monomind/routing) is constructed on-demand by
-        // its consumers — `monomind route` and `monomind agent --task` (see
-        // commands/route.ts and commands/agent.ts). It is intentionally NOT
-        // eagerly initialized here: building all route centroids and probing for
-        // the `claude` CLI on every CLI startup would regress the <500ms startup
+        // its consumers — `monomind route semantic` (commands/route.ts) and the
+        // `hooks_route_semantic` MCP tool (mcp-tools/hooks-routing.ts), both via
+        // routing/route-layer-factory.ts. `monomind agent` has no --task flag —
+        // that routing point does not exist yet. It is intentionally NOT eagerly
+        // initialized here: building all route centroids and probing for the
+        // `claude` CLI on every CLI startup would regress the <500ms startup
         // budget for zero benefit (nothing reads a process-global route layer).
     }
     /**

package/packages/@monomind/cli/dist/src/init/claudemd-generator.js

@@ -194,10 +194,7 @@ function agentTypes() {
 \`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`
 
 ### GitHub & Repository
-\`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`
-
-### SPARC Methodology
-\`sparc-coord\`, \`sparc-coder\`, \`specification\`, \`pseudocode\`, \`architecture\``;
+\`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\``;
 }
 function hooksSystem() {
     return `## Hooks System (27 Hooks + 12 Workers)
@@ -213,21 +210,23 @@ function hooksSystem() {
 | \`intelligence\` | Pattern-learning intelligence system |
 | \`worker\` | Background worker management |
 
-### 12 Background Workers
+### Background Workers (@monomind/hooks, run in-process)
 
 | Worker | Priority | Description |
 |--------|----------|-------------|
-| \`optimize\` | high | Performance optimization |
-| \`audit\` | critical | Security analysis |
-| \`testgaps\` | normal | Test coverage analysis |
 | \`map\` | normal | Codebase mapping |
-| \`deepdive\` | normal | Deep code analysis |
-| \`document\` | normal | Auto-documentation |
+| \`audit\` | high | Security audit |
+| \`optimize\` | normal | Performance snapshot |
+| \`consolidate\` | low | Memory consolidation |
+| \`ddd\` | low | DDD progress tracking |
+| \`security\` | high | Secret/vulnerability scan |
+
+Metrics-producing workers refresh at session start when output is >6h old.
 
 \`\`\`bash
 npx monomind@latest hooks pre-task --description "[task]"
 npx monomind@latest hooks post-task --task-id "[id]" --success true
-npx monomind@latest hooks worker dispatch --trigger audit
+npx monomind@latest hooks worker run audit
 \`\`\``;
 }
 function learningProtocol() {
@@ -428,9 +427,6 @@ function setupAndBoundary() {
 # Add MCP server — includes monograph, swarm, memory, hooks, all 200+ tools
 claude mcp add monomind -- npx -y monomind@latest mcp start
 
-# Start background workers
-npx monomind@latest daemon start
-
 # Verify everything works
 npx monomind@latest doctor --fix
 \`\`\`