monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/types.d.ts

@@ -183,13 +183,13 @@ export declare const AgentStateSchema: z.ZodObject<{
     vote: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    embedding: number[];
     agentId: string;
+    embedding: number[];
     metadata?: Record<string, unknown> | undefined;
     vote?: string | undefined;
 }, {
-    embedding: number[];
     agentId: string;
+    embedding: number[];
     metadata?: Record<string, unknown> | undefined;
     vote?: string | undefined;
 }>;
@@ -201,13 +201,13 @@ export declare const ConsensusInputSchema: z.ZodObject<{
         vote: z.ZodOptional<z.ZodString>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
-        embedding: number[];
         agentId: string;
+        embedding: number[];
         metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
     }, {
-        embedding: number[];
         agentId: string;
+        embedding: number[];
         metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
     }>, "many">;
@@ -215,15 +215,15 @@ export declare const ConsensusInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     threshold: number;
     agentStates: {
-        embedding: number[];
         agentId: string;
+        embedding: number[];
         metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
     }[];
 }, {
     agentStates: {
-        embedding: number[];
         agentId: string;
+        embedding: number[];
         metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
     }[];
@@ -247,11 +247,11 @@ export declare const SimplexSchema: z.ZodObject<{
     vertices: z.ZodArray<z.ZodNumber, "many">;
     dimension: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    vertices: number[];
     dimension: number;
-}, {
     vertices: number[];
+}, {
     dimension: number;
+    vertices: number[];
 }>;
 export type Simplex = z.infer<typeof SimplexSchema>;
 export declare const SimplicialComplexSchema: z.ZodObject<{
@@ -260,25 +260,25 @@ export declare const SimplicialComplexSchema: z.ZodObject<{
         vertices: z.ZodArray<z.ZodNumber, "many">;
         dimension: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        vertices: number[];
         dimension: number;
-    }, {
         vertices: number[];
+    }, {
         dimension: number;
+        vertices: number[];
     }>, "many">>;
     maxDimension: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     vertices: number[][];
     maxDimension: number;
     simplices?: {
-        vertices: number[];
         dimension: number;
+        vertices: number[];
     }[] | undefined;
 }, {
     vertices: number[][];
     simplices?: {
-        vertices: number[];
         dimension: number;
+        vertices: number[];
     }[] | undefined;
     maxDimension?: number | undefined;
 }>;
@@ -290,25 +290,25 @@ export declare const TopologyInputSchema: z.ZodObject<{
             vertices: z.ZodArray<z.ZodNumber, "many">;
             dimension: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            vertices: number[];
             dimension: number;
-        }, {
             vertices: number[];
+        }, {
             dimension: number;
+            vertices: number[];
         }>, "many">>;
         maxDimension: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         vertices: number[][];
         maxDimension: number;
         simplices?: {
-            vertices: number[];
             dimension: number;
+            vertices: number[];
         }[] | undefined;
     }, {
         vertices: number[][];
         simplices?: {
-            vertices: number[];
             dimension: number;
+            vertices: number[];
         }[] | undefined;
         maxDimension?: number | undefined;
     }>;
@@ -317,16 +317,16 @@ export declare const TopologyInputSchema: z.ZodObject<{
         vertices: number[][];
         maxDimension: number;
         simplices?: {
-            vertices: number[];
             dimension: number;
+            vertices: number[];
         }[] | undefined;
     };
 }, {
     complex: {
         vertices: number[][];
         simplices?: {
-            vertices: number[];
             dimension: number;
+            vertices: number[];
         }[] | undefined;
         maxDimension?: number | undefined;
     };
@@ -423,7 +423,8 @@ export declare function trackPerformance<T>(operationName: string, operation: ()
     metrics: PerformanceMetrics;
 }>;
 /**
- * Calculate cosine similarity between two vectors
+ * Cosine similarity — re-exported from shared utility.
+ * Callers that already import from this module continue to work unchanged.
  */
-export declare function cosineSimilarity(a: number[] | Float32Array, b: number[] | Float32Array): number;
+export { cosineSimilarity } from '../../utils/cosine-similarity.js';
 //# sourceMappingURL=types.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/types.js

@@ -137,23 +137,8 @@ export function trackPerformance(operationName, operation) {
     });
 }
 /**
- * Calculate cosine similarity between two vectors
+ * Cosine similarity — re-exported from shared utility.
+ * Callers that already import from this module continue to work unchanged.
  */
-export function cosineSimilarity(a, b) {
-    if (a.length !== b.length) {
-        throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
-    }
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-    if (denominator === 0)
-        return 0;
-    return dotProduct / denominator;
-}
+export { cosineSimilarity } from '../../utils/cosine-similarity.js';
 //# sourceMappingURL=types.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/embeddings-tools.js

@@ -6,6 +6,7 @@
  */
 import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
+import { cosineSimilarity } from '../utils/cosine-similarity.js';
 // Configuration paths
 const CONFIG_DIR = '.monomind';
 const EMBEDDINGS_CONFIG = 'embeddings.json';
@@ -125,13 +126,6 @@ function poincareDistance(a, b, curvature) {
     const delta = 2 * diffSq / (denom + 1e-15);
     return (1 / Math.sqrt(c)) * Math.acosh(1 + delta);
 }
-// Cosine similarity
-function cosineSimilarity(a, b) {
-    const dot = a.reduce((sum, _, i) => sum + a[i] * b[i], 0);
-    const normA = Math.sqrt(a.reduce((sum, x) => sum + x * x, 0));
-    const normB = Math.sqrt(b.reduce((sum, x) => sum + x * x, 0));
-    return dot / (normA * normB + 1e-15);
-}
 export const embeddingsTools = [
     {
         name: 'embeddings_init',

package/packages/@monomind/cli/dist/src/mcp-tools/graphify-tools.js

@@ -4,9 +4,9 @@
  * All graphify_* tools are deprecated. They proxy to monograph_* tools.
  * Will be removed in next major release.
  */
-import { monographTools } from './monograph-tools.js';
+import { allMonographTools } from './monograph-tools.js';
 function findMonographTool(name) {
-    const tool = monographTools.find(t => t.name === name);
+    const tool = allMonographTools.find(t => t.name === name);
     if (!tool)
         throw new Error(`[monograph] Tool ${name} not found`);
     return tool;

package/packages/@monomind/cli/dist/src/mcp-tools/guidance-tools.js

@@ -144,13 +144,13 @@ const CAPABILITY_CATALOG = {
         whenToUse: 'When working with GitHub repos, PRs, issues, releases, or CI/CD pipelines.',
     },
     'session-workflow': {
-        name: 'Session & Workflow',
-        description: 'Session state management, workflow execution, task lifecycle, and daemon scheduling.',
-        tools: ['session_start', 'session_end', 'session_restore', 'session_list', 'workflow_execute', 'workflow_create', 'task_create', 'task_assign', 'task_status'],
-        commands: ['session start', 'session end', 'session restore', 'workflow execute', 'workflow create', 'task create', 'daemon start', 'daemon stop'],
+        name: 'Session & Tasks',
+        description: 'Session state management and task lifecycle.',
+        tools: ['session_start', 'session_end', 'session_restore', 'session_list', 'task_create', 'task_assign', 'task_status'],
+        commands: ['session start', 'session end', 'session restore', 'task create'],
         agents: [],
         skills: [],
-        whenToUse: 'When managing long-running sessions, executing workflow templates, or scheduling tasks.',
+        whenToUse: 'When managing long-running sessions or scheduling tasks.',
     },
     'embeddings-vectors': {
         name: 'Embeddings & Vector Search',
@@ -170,15 +170,6 @@ const CAPABILITY_CATALOG = {
         skills: ['verification-quality'],
         whenToUse: 'When analyzing code quality, diffs, coverage gaps, or dependency graphs.',
     },
-    'sparc-methodology': {
-        name: 'SPARC Methodology',
-        description: 'Specification, Pseudocode, Architecture, Refinement, Completion — structured development.',
-        tools: [],
-        commands: [],
-        agents: ['specification', 'pseudocode', 'architecture', 'refinement'],
-        skills: ['sparc-methodology'],
-        whenToUse: 'When following structured SPARC development methodology for new features.',
-    },
     'config-system': {
         name: 'Configuration & System',
         description: 'Configuration management, provider setup, system diagnostics, shell completions.',
@@ -201,7 +192,7 @@ const TASK_ROUTES = [
     { pattern: /\b(release|deploy|publish|version|changelog)\b/i, areas: ['github-integration', 'session-workflow'], workflow: 'release' },
     { pattern: /\b(swarm|multi.agent|coordin|hive|consensus)\b/i, areas: ['swarm-orchestration', 'hive-mind'], workflow: 'swarm' },
     { pattern: /\b(learn|train|neural|pattern|sona|lora)\b/i, areas: ['intelligence-learning'], workflow: 'learning' },
-    { pattern: /\b(hook|pre.task|post.task|worker|daemon)\b/i, areas: ['hooks-automation', 'session-workflow'], workflow: 'automation' },
+    { pattern: /\b(hook|pre.task|post.task|worker)\b/i, areas: ['hooks-automation', 'session-workflow'], workflow: 'automation' },
     { pattern: /\b(config|setup|init|provider|doctor)\b/i, areas: ['config-system'], workflow: 'setup' },
 ];
 const WORKFLOW_TEMPLATES = {
@@ -266,7 +257,7 @@ const WORKFLOW_TEMPLATES = {
         topology: 'hierarchical',
     },
     setup: {
-        steps: ['Run doctor diagnostics', 'Configure providers', 'Initialize memory', 'Start daemon'],
+        steps: ['Run doctor diagnostics', 'Configure providers', 'Initialize memory'],
         agents: [],
         topology: 'hierarchical',
     },
@@ -570,7 +561,6 @@ const guidanceQuickRef = {
                 commands: [
                     { cmd: 'npx monomind@latest init --wizard', desc: 'Initialize project with interactive setup' },
                     { cmd: 'npx monomind@latest doctor --fix', desc: 'Run diagnostics and auto-fix issues' },
-                    { cmd: 'npx monomind@latest daemon start', desc: 'Start background workers' },
                     { cmd: 'npx monomind@latest status', desc: 'Check system status' },
                 ],
             },

package/packages/@monomind/cli/dist/src/mcp-tools/hive-mind-tools.d.ts

@@ -1,7 +1,14 @@
 /**
  * Hive-Mind MCP Tools for CLI
  *
- * Tool definitions for collective intelligence and swarm coordination.
+ * Tool definitions for multi-agent coordination and voting.
+ *
+ * Honest scope note: the "consensus strategies" here are vote-count thresholds
+ * applied to a single in-process tally — NOT distributed consensus protocols.
+ * There is no log replication, leader election, network partitioning, or
+ * adversarial fault model. 'bft' = require 2f+1 votes, 'raft' = require
+ * majority, 'quorum' = configurable preset (majority/supermajority/unanimous).
+ * The names are kept for CLI/API compatibility.
  */
 import { type MCPTool } from './types.js';
 export declare const hiveMindTools: MCPTool[];

package/packages/@monomind/cli/dist/src/mcp-tools/hive-mind-tools.js

@@ -1,12 +1,20 @@
 /**
  * Hive-Mind MCP Tools for CLI
  *
- * Tool definitions for collective intelligence and swarm coordination.
+ * Tool definitions for multi-agent coordination and voting.
+ *
+ * Honest scope note: the "consensus strategies" here are vote-count thresholds
+ * applied to a single in-process tally — NOT distributed consensus protocols.
+ * There is no log replication, leader election, network partitioning, or
+ * adversarial fault model. 'bft' = require 2f+1 votes, 'raft' = require
+ * majority, 'quorum' = configurable preset (majority/supermajority/unanimous).
+ * The names are kept for CLI/API compatibility.
  */
 import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
-import { weightedTally } from '../consensus/vote-signer.js';
+import { weightedTally } from '../consensus/tally.js';
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const HIVE_DIR = 'hive-mind';
@@ -125,6 +133,48 @@ function saveHiveState(state) {
     writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf-8');
     renameSync(tmp, dest);
 }
+const SESSION_SECRET_FILE = 'session-secret';
+/**
+ * Resolve the HMAC signing secret used for consensus vote/audit records.
+ *
+ * Previously this was read exclusively from MONOMIND_SESSION_SECRET, which
+ * nothing in `init`/`doctor`/docs ever sets — so by default every consensus
+ * decision silently produced zero audit records (writes were skipped, and
+ * hive-mind_audit_verify refused to run at all). To make the audit trail
+ * work out of the box, fall back to a per-project secret generated once and
+ * persisted alongside the hive state (0600-equivalent: kept out of state.json
+ * and never returned by any tool). MONOMIND_SESSION_SECRET still takes
+ * precedence for callers that want to manage/rotate the secret themselves.
+ */
+function getOrCreateSessionSecret() {
+    const envSecret = process.env.MONOMIND_SESSION_SECRET;
+    if (envSecret)
+        return envSecret;
+    const path = join(getHiveDir(), SESSION_SECRET_FILE);
+    try {
+        if (existsSync(path)) {
+            const existing = readFileSync(path, 'utf-8').trim();
+            if (existing)
+                return existing;
+        }
+    }
+    catch { /* fall through to regeneration */ }
+    try {
+        ensureHiveDir();
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const secret = randomBytes(32).toString('hex');
+        const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, secret, 'utf-8');
+        renameSync(tmp, path);
+        return secret;
+    }
+    catch {
+        // Filesystem unavailable — fall back to an ephemeral in-process secret.
+        // Audit records signed with this won't verify across process restarts,
+        // but propose/vote/resolve still function.
+        return randomBytes(32).toString('hex');
+    }
+}
 // Import agent store helpers for spawn functionality
 import { existsSync as agentStoreExists, readFileSync as readAgentStore, writeFileSync as writeAgentStore, mkdirSync as mkdirAgentStore } from 'node:fs';
 // Canonical agent store path matches agent-tools.ts: .monomind/agents/store.json
@@ -266,6 +316,11 @@ export const hiveMindTools = [
             const effectiveConsensus = PLANNED_CONSENSUS.includes(requestedConsensus)
                 ? 'byzantine'
                 : (SUPPORTED_CONSENSUS.includes(requestedConsensus) ? requestedConsensus : 'byzantine');
+            // Persist the chosen strategy on the hive state so hive-mind_consensus
+            // propose/vote default to it instead of silently using 'raft'.
+            // 'byzantine' is the CLI-facing name; the internal ConsensusStrategy type uses 'bft'.
+            state.consensusStrategy = (effectiveConsensus === 'byzantine' ? 'bft' : effectiveConsensus);
+            saveHiveState(state);
             return {
                 success: true,
                 hiveId,
@@ -481,7 +536,9 @@ export const hiveMindTools = [
         handler: async (input) => {
             const state = loadHiveState();
             const action = input.action;
-            const rawStrategy = input.strategy || 'raft';
+            // Default to the strategy chosen at hive-mind_init (state.consensusStrategy);
+            // fall back to 'raft' only when the hive hasn't been initialized with one.
+            const rawStrategy = input.strategy || state.consensusStrategy || 'raft';
             // Gossip and CRDT are planned but not yet implemented -- reject early
             // with an honest message instead of silently falling through.
             const UNIMPLEMENTED_STRATEGIES = ['gossip', 'crdt'];
@@ -716,42 +773,39 @@ export const hiveMindTools = [
                         });
                     }
                     catch { /* LanceDB not available — JSON store is primary */ }
-                    // Persist consensus audit record
-                    const sessionSecret = process.env.MONOMIND_SESSION_SECRET;
-                    if (!sessionSecret) {
-                        process.stderr.write('[hive-consensus] Audit write skipped: MONOMIND_SESSION_SECRET not set\n');
+                    // Persist consensus audit record — uses MONOMIND_SESSION_SECRET when
+                    // set, otherwise a per-project generated-and-persisted secret so the
+                    // audit trail is populated by default (see getOrCreateSessionSecret).
+                    const sessionSecret = getOrCreateSessionSecret();
+                    try {
+                        const { AuditWriter } = await import('../consensus/audit-writer.js');
+                        const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
+                        const writer = new AuditWriter(auditDir);
+                        const now = new Date().toISOString();
+                        const voteEntries = Object.entries(proposal.votes).map(([agentId, vote]) => ({
+                            agentId,
+                            agentSlug: agentId,
+                            vote,
+                            votedAt: now,
+                        }));
+                        writer.record({
+                            decisionId: proposal.proposalId,
+                            swarmId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
+                            protocol: (proposalStrategy === 'bft' ? 'byzantine' : proposalStrategy === 'raft' ? 'raft' : 'quorum'),
+                            topic: proposal.type,
+                            decision: resolution,
+                            votes: voteEntries,
+                            quorumRequired: required,
+                            quorumThreshold: required / Math.max(totalNodes, 1),
+                            round: (proposal.divergenceRoundsSeen ?? 0) + 1,
+                            startedAt: proposal.proposedAt,
+                            completedAt: now,
+                            sessionSecret,
+                        });
                     }
-                    else {
-                        try {
-                            const { AuditWriter } = await import('../consensus/audit-writer.js');
-                            const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
-                            const writer = new AuditWriter(auditDir);
-                            const now = new Date().toISOString();
-                            const voteEntries = Object.entries(proposal.votes).map(([agentId, vote]) => ({
-                                agentId,
-                                agentSlug: agentId,
-                                vote,
-                                votedAt: now,
-                            }));
-                            writer.record({
-                                decisionId: proposal.proposalId,
-                                swarmId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
-                                protocol: (proposalStrategy === 'bft' ? 'byzantine' : proposalStrategy === 'raft' ? 'raft' : 'quorum'),
-                                topic: proposal.type,
-                                decision: resolution,
-                                votes: voteEntries,
-                                quorumRequired: required,
-                                quorumThreshold: required / Math.max(totalNodes, 1),
-                                round: (proposal.divergenceRoundsSeen ?? 0) + 1,
-                                startedAt: proposal.proposedAt,
-                                completedAt: now,
-                                sessionSecret,
-                            });
-                        }
-                        catch (e) {
-                            if (process.env.MONOMIND_LOG_LEVEL === 'debug') {
-                                process.stderr.write(`[hive-consensus] Audit write failed: ${e.message}\n`);
-                            }
+                    catch (e) {
+                        if (process.env.MONOMIND_LOG_LEVEL === 'debug') {
+                            process.stderr.write(`[hive-consensus] Audit write failed: ${e.message}\n`);
                         }
                     }
                 }
@@ -1047,5 +1101,87 @@ export const hiveMindTools = [
             return { action, error: 'Unknown action' };
         },
     },
+    {
+        name: 'hive-mind_audit_list',
+        description: 'List tamper-evident consensus audit records (HMAC-signed JSONL trail)',
+        category: 'hive-mind',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                swarmId: { type: 'string', description: 'Filter by swarm ID (optional)' },
+                limit: { type: 'number', description: 'Max records to return (default: 50, max: 500)' },
+            },
+        },
+        handler: async (input) => {
+            try {
+                const { AuditWriter } = await import('../consensus/audit-writer.js');
+                const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
+                const writer = new AuditWriter(auditDir);
+                const limit = Math.min(Math.max(1, input.limit || 50), 500);
+                const swarmId = input.swarmId;
+                const records = writer.listDecisions(swarmId, limit);
+                return {
+                    success: true,
+                    count: records.length,
+                    records: records.map(r => ({
+                        decisionId: r.decisionId,
+                        swarmId: r.swarmId,
+                        protocol: r.protocol,
+                        topic: r.topic,
+                        decision: r.decision,
+                        voteCount: r.votes.length,
+                        quorumAchieved: r.quorumAchieved,
+                        round: r.round,
+                        durationMs: r.durationMs,
+                        completedAt: r.completedAt,
+                        signed: !!r.recordSignature,
+                    })),
+                };
+            }
+            catch (e) {
+                return { success: false, error: `Audit trail unavailable: ${e.message}` };
+            }
+        },
+    },
+    {
+        name: 'hive-mind_audit_verify',
+        description: 'Verify tamper-evidence of a consensus decision (checks HMAC signatures on all votes and the record itself)',
+        category: 'hive-mind',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                decisionId: { type: 'string', description: 'Decision/proposal ID to verify' },
+            },
+            required: ['decisionId'],
+        },
+        handler: async (input) => {
+            // Uses MONOMIND_SESSION_SECRET when set, otherwise the same
+            // per-project generated-and-persisted secret used to sign records
+            // in hive-mind_consensus (see getOrCreateSessionSecret).
+            const sessionSecret = getOrCreateSessionSecret();
+            const decisionId = input.decisionId;
+            if (typeof decisionId !== 'string' || decisionId.length === 0 || decisionId.length > 256) {
+                return { success: false, error: 'Invalid decisionId' };
+            }
+            try {
+                const { AuditWriter } = await import('../consensus/audit-writer.js');
+                const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
+                const writer = new AuditWriter(auditDir);
+                const result = writer.verifyDecision(decisionId, sessionSecret);
+                return {
+                    success: true,
+                    decisionId,
+                    valid: result.valid,
+                    invalidVotes: result.invalidVotes,
+                    message: result.valid
+                        ? 'All vote signatures and record signature verified — no tampering detected.'
+                        : `Verification failed: ${result.invalidVotes.length} invalid vote(s) or record signature mismatch.`,
+                };
+            }
+            catch (e) {
+                return { success: false, error: `Audit verification failed: ${e.message}` };
+            }
+        },
+    },
 ];
 //# sourceMappingURL=hive-mind-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/hooks-advanced.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hooks Advanced MCP Tools — wires genuinely unique @monomind/hooks/mcp tools
+ * into the CLI's live MCP tool registry.
+ *
+ * Background: @monomind/hooks/src/mcp/index.ts defined a full parallel MCP tool
+ * surface (hooksMCPTools) that was exported from the package's public barrel but
+ * had zero consumers anywhere — the CLI's actual MCP server (mcp-client.ts) built
+ * its own independent implementations in hooks-routing.ts / hooks-intelligence.ts.
+ * Several of those hooks-package tools were pure stub duplicates (hardcoded fake
+ * data) of the CLI's real, wired versions and were deleted outright. The tools
+ * re-exported below are genuinely unique — they wrap real subsystems
+ * (AFLOW/DAGLearner/LATS search, EvoAgentX GEPA prompt evolution, RLVR verifiable
+ * rewards, trace observability, human-in-the-loop interrupt checkpoints) that have
+ * no CLI equivalent — so instead of deleting them, they are wired in here.
+ */
+import { type MCPTool } from './types.js';
+export declare const hooksAdvancedTools: MCPTool[];
+//# sourceMappingURL=hooks-advanced.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/hooks-advanced.js

@@ -0,0 +1,25 @@
+/**
+ * Hooks Advanced MCP Tools — wires genuinely unique @monomind/hooks/mcp tools
+ * into the CLI's live MCP tool registry.
+ *
+ * Background: @monomind/hooks/src/mcp/index.ts defined a full parallel MCP tool
+ * surface (hooksMCPTools) that was exported from the package's public barrel but
+ * had zero consumers anywhere — the CLI's actual MCP server (mcp-client.ts) built
+ * its own independent implementations in hooks-routing.ts / hooks-intelligence.ts.
+ * Several of those hooks-package tools were pure stub duplicates (hardcoded fake
+ * data) of the CLI's real, wired versions and were deleted outright. The tools
+ * re-exported below are genuinely unique — they wrap real subsystems
+ * (AFLOW/DAGLearner/LATS search, EvoAgentX GEPA prompt evolution, RLVR verifiable
+ * rewards, trace observability, human-in-the-loop interrupt checkpoints) that have
+ * no CLI equivalent — so instead of deleting them, they are wired in here.
+ */
+import { routeAdvancedTool, statuslineTool, evoAgentXTool, rlvrOutcomeTool, traceMCPTools, checkpointMCPTools, } from '@monomind/hooks';
+export const hooksAdvancedTools = [
+    routeAdvancedTool,
+    statuslineTool,
+    evoAgentXTool,
+    rlvrOutcomeTool,
+    ...traceMCPTools,
+    ...checkpointMCPTools,
+];
+//# sourceMappingURL=hooks-advanced.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/hooks-intelligence.d.ts

@@ -1,9 +1,10 @@
 /**
- * Hooks Intelligence & Worker MCP Tools
+ * Hooks Intelligence MCP Tools
  * MCP tool implementations for intelligence reset, trajectories, patterns,
- * intelligence stats/learn/attention, worker dispatch/status/detect/cancel,
- * and model routing.
+ * intelligence stats/learn/attention, and model routing.
  * Extracted from hooks-tools.ts.
+ * The simulated worker dispatch/status/detect/cancel tools were deleted with
+ * the worker daemon -- real workers live in @monomind/hooks (`hooks worker run`).
  */
 import { type MCPTool } from './types.js';
 export declare const hooksIntelligenceReset: MCPTool;
@@ -15,12 +16,7 @@ export declare const hooksPatternSearch: MCPTool;
 export declare const hooksIntelligenceStats: MCPTool;
 export declare const hooksIntelligenceLearn: MCPTool;
 export declare const hooksIntelligenceAttention: MCPTool;
-export declare const hooksWorkerList: MCPTool;
-export declare const hooksWorkerDispatch: MCPTool;
-export declare const hooksWorkerStatus: MCPTool;
-export declare const hooksWorkerDetect: MCPTool;
 export declare const hooksModelRoute: MCPTool;
 export declare const hooksModelOutcome: MCPTool;
 export declare const hooksModelStats: MCPTool;
-export declare const hooksWorkerCancel: MCPTool;
 //# sourceMappingURL=hooks-intelligence.d.ts.map