monomind 1.18.15 → 2.0.0

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

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

@@ -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 { existsSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
@@ -234,6 +235,35 @@ export const hooksTrajectoryEnd = {
             }
             // Remove from active trajectories
             activeTrajectories.delete(trajectoryId);
+            // Bridge to the local intelligence ReasoningBank/SONA confidence-learning
+            // loop (src/memory/intelligence.ts). Previously this handler only wrote
+            // to the legacy JSON memory store (namespace 'trajectories') and the
+            // SONA routing optimizer's .swarm/sona-patterns.json — neither of which
+            // the ReasoningBank read from live, so trajectories recorded through
+            // this MCP tool (the path Claude Code actually calls) never fed the
+            // pattern store that `findSimilarPatterns`/`suggestAgentsFromIntelligence`
+            // read from. Recording a summary 'result' step here generates an
+            // embedding, stores a searchable pattern, and — because type 'result'
+            // triggers intelligence.ts's endTrajectory+distillLearning — applies
+            // the success/failure verdict to any semantically similar patterns.
+            try {
+                const intel = await import('../memory/intelligence.js');
+                await intel.initializeIntelligence();
+                const summary = `Task: ${trajectory.task} | Agent: ${trajectory.agent} | Steps: ${trajectory.steps.length} | Success: ${success}${feedback ? ` | Feedback: ${feedback}` : ''}`;
+                await intel.recordStep({
+                    type: 'result',
+                    content: summary,
+                    metadata: {
+                        verdict: success ? 'success' : 'failure',
+                        trajectoryId,
+                        agent: trajectory.agent,
+                    },
+                });
+            }
+            catch {
+                // Non-fatal: intelligence bridge unavailable, trajectory is still
+                // persisted via the legacy store above.
+            }
         }
         // SONA Learning - process trajectory outcome for routing optimization
         let sonaResult = {
@@ -745,448 +775,6 @@ export const hooksIntelligenceAttention = {
         };
     },
 };
-/**
- * Worker trigger patterns for auto-detection
- */
-const WORKER_TRIGGER_PATTERNS = {
-    ultralearn: [
-        /learn\s+about/i,
-        /understand\s+(how|what|why)/i,
-        /deep\s+dive\s+into/i,
-        /explain\s+in\s+detail/i,
-        /comprehensive\s+guide/i,
-        /master\s+this/i,
-    ],
-    optimize: [
-        /optimize/i,
-        /improve\s+performance/i,
-        /make\s+(it\s+)?faster/i,
-        /speed\s+up/i,
-        /reduce\s+(memory|time)/i,
-        /performance\s+issue/i,
-    ],
-    consolidate: [
-        /consolidate/i,
-        /merge\s+memories/i,
-        /clean\s+up\s+memory/i,
-        /deduplicate/i,
-        /memory\s+maintenance/i,
-    ],
-    predict: [
-        /what\s+will\s+happen/i,
-        /predict/i,
-        /forecast/i,
-        /anticipate/i,
-        /preload/i,
-        /prepare\s+for/i,
-    ],
-    audit: [
-        /security\s+audit/i,
-        /vulnerability/i,
-        /security\s+check/i,
-        /pentest/i,
-        /security\s+scan/i,
-        /cve/i,
-        /owasp/i,
-    ],
-    map: [
-        /map\s+(the\s+)?codebase/i,
-        /architecture\s+overview/i,
-        /project\s+structure/i,
-        /dependency\s+graph/i,
-        /code\s+map/i,
-        /explore\s+codebase/i,
-    ],
-    preload: [
-        /preload/i,
-        /cache\s+ahead/i,
-        /prefetch/i,
-        /warm\s+(up\s+)?cache/i,
-    ],
-    deepdive: [
-        /deep\s+dive/i,
-        /analyze\s+thoroughly/i,
-        /in-depth\s+analysis/i,
-        /comprehensive\s+review/i,
-        /detailed\s+examination/i,
-    ],
-    document: [
-        /document\s+(this|the)/i,
-        /generate\s+docs/i,
-        /add\s+documentation/i,
-        /write\s+readme/i,
-        /api\s+docs/i,
-        /jsdoc/i,
-    ],
-    refactor: [
-        /refactor/i,
-        /clean\s+up\s+code/i,
-        /improve\s+code\s+quality/i,
-        /restructure/i,
-        /simplify/i,
-        /make\s+more\s+readable/i,
-    ],
-    benchmark: [
-        /benchmark/i,
-        /performance\s+test/i,
-        /measure\s+speed/i,
-        /stress\s+test/i,
-        /load\s+test/i,
-    ],
-    testgaps: [
-        /test\s+coverage/i,
-        /missing\s+tests/i,
-        /untested\s+code/i,
-        /coverage\s+report/i,
-        /test\s+gaps/i,
-        /add\s+tests/i,
-    ],
-};
-/**
- * Worker configurations
- */
-const WORKER_CONFIGS = {
-    ultralearn: {
-        description: 'Deep knowledge acquisition and learning',
-        priority: 'normal',
-        estimatedDuration: '60s',
-        capabilities: ['research', 'analysis', 'synthesis'],
-    },
-    optimize: {
-        description: 'Performance optimization and tuning',
-        priority: 'high',
-        estimatedDuration: '30s',
-        capabilities: ['profiling', 'optimization', 'benchmarking'],
-    },
-    consolidate: {
-        description: 'Memory consolidation and cleanup',
-        priority: 'low',
-        estimatedDuration: '20s',
-        capabilities: ['memory-management', 'deduplication'],
-    },
-    predict: {
-        description: 'Predictive preloading and anticipation',
-        priority: 'normal',
-        estimatedDuration: '15s',
-        capabilities: ['prediction', 'caching', 'preloading'],
-    },
-    audit: {
-        description: 'Security analysis and vulnerability scanning',
-        priority: 'critical',
-        estimatedDuration: '45s',
-        capabilities: ['security', 'vulnerability-scanning', 'audit'],
-    },
-    map: {
-        description: 'Codebase mapping and architecture analysis',
-        priority: 'normal',
-        estimatedDuration: '30s',
-        capabilities: ['analysis', 'mapping', 'visualization'],
-    },
-    preload: {
-        description: 'Resource preloading and cache warming',
-        priority: 'low',
-        estimatedDuration: '10s',
-        capabilities: ['caching', 'preloading'],
-    },
-    deepdive: {
-        description: 'Deep code analysis and examination',
-        priority: 'normal',
-        estimatedDuration: '60s',
-        capabilities: ['analysis', 'review', 'understanding'],
-    },
-    document: {
-        description: 'Auto-documentation generation',
-        priority: 'normal',
-        estimatedDuration: '45s',
-        capabilities: ['documentation', 'writing', 'generation'],
-    },
-    refactor: {
-        description: 'Code refactoring suggestions',
-        priority: 'normal',
-        estimatedDuration: '30s',
-        capabilities: ['refactoring', 'code-quality', 'improvement'],
-    },
-    benchmark: {
-        description: 'Performance benchmarking',
-        priority: 'normal',
-        estimatedDuration: '60s',
-        capabilities: ['benchmarking', 'testing', 'measurement'],
-    },
-    testgaps: {
-        description: 'Test coverage analysis',
-        priority: 'normal',
-        estimatedDuration: '30s',
-        capabilities: ['testing', 'coverage', 'analysis'],
-    },
-};
-// In-memory worker tracking
-const activeWorkers = new Map();
-let workerIdCounter = 0;
-/**
- * Detect triggers from prompt text
- */
-function detectWorkerTriggers(text) {
-    const detectedTriggers = [];
-    let totalMatches = 0;
-    for (const [trigger, patterns] of Object.entries(WORKER_TRIGGER_PATTERNS)) {
-        for (const pattern of patterns) {
-            if (pattern.test(text)) {
-                if (!detectedTriggers.includes(trigger)) {
-                    detectedTriggers.push(trigger);
-                }
-                totalMatches++;
-            }
-        }
-    }
-    const confidence = detectedTriggers.length > 0
-        ? Math.min(1, totalMatches / (detectedTriggers.length * 2))
-        : 0;
-    return {
-        detected: detectedTriggers.length > 0,
-        triggers: detectedTriggers,
-        confidence,
-        context: text.slice(0, 100),
-    };
-}
-// Worker list tool
-export const hooksWorkerList = {
-    name: 'hooks_worker-list',
-    description: 'List all 12 background workers with status and capabilities',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            status: { type: 'string', description: 'Filter by status (all, running, completed, pending)' },
-            includeActive: { type: 'boolean', description: 'Include active worker instances' },
-        },
-    },
-    handler: async (params) => {
-        const statusFilter = params.status || 'all';
-        const includeActive = params.includeActive !== false;
-        const workers = Object.entries(WORKER_CONFIGS).map(([trigger, config]) => ({
-            trigger,
-            ...config,
-            patterns: WORKER_TRIGGER_PATTERNS[trigger].length,
-        }));
-        const activeList = includeActive
-            ? Array.from(activeWorkers.values()).filter(w => statusFilter === 'all' || w.status === statusFilter)
-            : [];
-        return {
-            workers,
-            total: 12,
-            active: {
-                instances: activeList,
-                count: activeList.length,
-                byStatus: {
-                    pending: activeList.filter(w => w.status === 'pending').length,
-                    running: activeList.filter(w => w.status === 'running').length,
-                    completed: activeList.filter(w => w.status === 'completed').length,
-                    failed: activeList.filter(w => w.status === 'failed').length,
-                },
-            },
-            performanceTargets: {
-                triggerDetection: '<5ms',
-                workerSpawn: '<50ms',
-                maxConcurrent: 10,
-            },
-        };
-    },
-};
-// Worker dispatch tool
-export const hooksWorkerDispatch = {
-    name: 'hooks_worker-dispatch',
-    description: 'Dispatch a background worker for analysis/optimization tasks',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            trigger: {
-                type: 'string',
-                description: 'Worker trigger type',
-                enum: ['ultralearn', 'optimize', 'consolidate', 'predict', 'audit', 'map', 'preload', 'deepdive', 'document', 'refactor', 'benchmark', 'testgaps'],
-            },
-            context: { type: 'string', description: 'Context for the worker (file path, topic, etc.)' },
-            priority: { type: 'string', description: 'Priority (low, normal, high, critical)' },
-            background: { type: 'boolean', description: 'Run in background (non-blocking)' },
-        },
-        required: ['trigger'],
-    },
-    handler: async (params) => {
-        const trigger = params.trigger;
-        const context = params.context || 'default';
-        const priority = params.priority || WORKER_CONFIGS[trigger]?.priority || 'normal';
-        const background = params.background !== false;
-        if (!WORKER_CONFIGS[trigger]) {
-            return {
-                success: false,
-                error: `Unknown worker trigger: ${trigger}`,
-                availableTriggers: Object.keys(WORKER_CONFIGS),
-            };
-        }
-        const workerId = `worker_${trigger}_${++workerIdCounter}_${Date.now().toString(36)}`;
-        const config = WORKER_CONFIGS[trigger];
-        const worker = {
-            id: workerId,
-            trigger,
-            context,
-            status: 'running',
-            progress: 0,
-            phase: 'initializing',
-            startedAt: new Date(),
-        };
-        activeWorkers.set(workerId, worker);
-        // Update worker progress in background
-        if (background) {
-            setTimeout(() => {
-                const w = activeWorkers.get(workerId);
-                if (w) {
-                    w.progress = 50;
-                    w.phase = 'processing';
-                }
-            }, 500);
-            setTimeout(() => {
-                const w = activeWorkers.get(workerId);
-                if (w) {
-                    w.progress = 100;
-                    w.phase = 'completed';
-                    w.status = 'completed';
-                    w.completedAt = new Date();
-                }
-            }, 1500);
-        }
-        else {
-            worker.progress = 100;
-            worker.phase = 'completed';
-            worker.status = 'completed';
-            worker.completedAt = new Date();
-        }
-        return {
-            success: true,
-            workerId,
-            trigger,
-            context,
-            priority,
-            config: {
-                description: config.description,
-                estimatedDuration: config.estimatedDuration,
-                capabilities: config.capabilities,
-            },
-            status: background ? 'dispatched' : 'completed',
-            background,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Worker status tool
-export const hooksWorkerStatus = {
-    name: 'hooks_worker-status',
-    description: 'Get status of a specific worker or all active workers',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            workerId: { type: 'string', description: 'Specific worker ID to check' },
-            includeCompleted: { type: 'boolean', description: 'Include completed workers' },
-        },
-    },
-    handler: async (params) => {
-        const workerId = params.workerId;
-        const includeCompleted = params.includeCompleted !== false;
-        if (workerId) {
-            const worker = activeWorkers.get(workerId);
-            if (!worker) {
-                return {
-                    success: false,
-                    error: `Worker not found: ${workerId}`,
-                };
-            }
-            return {
-                success: true,
-                worker: {
-                    ...worker,
-                    duration: worker.completedAt
-                        ? worker.completedAt.getTime() - worker.startedAt.getTime()
-                        : Date.now() - worker.startedAt.getTime(),
-                },
-            };
-        }
-        const workers = Array.from(activeWorkers.values())
-            .filter(w => includeCompleted || w.status !== 'completed')
-            .map(w => ({
-            ...w,
-            duration: w.completedAt
-                ? w.completedAt.getTime() - w.startedAt.getTime()
-                : Date.now() - w.startedAt.getTime(),
-        }));
-        return {
-            success: true,
-            workers,
-            summary: {
-                total: workers.length,
-                running: workers.filter(w => w.status === 'running').length,
-                completed: workers.filter(w => w.status === 'completed').length,
-                failed: workers.filter(w => w.status === 'failed').length,
-            },
-        };
-    },
-};
-// Worker detect tool - detect triggers from prompt
-export const hooksWorkerDetect = {
-    name: 'hooks_worker-detect',
-    description: 'Detect worker triggers from user prompt (for UserPromptSubmit hook)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            prompt: { type: 'string', description: 'User prompt to analyze' },
-            autoDispatch: { type: 'boolean', description: 'Automatically dispatch detected workers' },
-            minConfidence: { type: 'number', description: 'Minimum confidence threshold (0-1)' },
-        },
-        required: ['prompt'],
-    },
-    handler: async (params) => {
-        const prompt = params.prompt;
-        const autoDispatch = params.autoDispatch;
-        const minConfidence = params.minConfidence || 0.5;
-        const detection = detectWorkerTriggers(prompt);
-        const result = {
-            prompt: prompt.slice(0, 200) + (prompt.length > 200 ? '...' : ''),
-            detection,
-            triggersFound: detection.triggers.length,
-        };
-        if (detection.detected && detection.confidence >= minConfidence) {
-            result.triggerDetails = detection.triggers.map(trigger => ({
-                trigger,
-                ...WORKER_CONFIGS[trigger],
-            }));
-            if (autoDispatch) {
-                const dispatched = [];
-                for (const trigger of detection.triggers) {
-                    const workerId = `worker_${trigger}_${++workerIdCounter}_${Date.now().toString(36)}`;
-                    activeWorkers.set(workerId, {
-                        id: workerId,
-                        trigger,
-                        context: prompt.slice(0, 100),
-                        status: 'running',
-                        progress: 0,
-                        phase: 'initializing',
-                        startedAt: new Date(),
-                    });
-                    dispatched.push(workerId);
-                    // Mark worker completion after processing
-                    setTimeout(() => {
-                        const w = activeWorkers.get(workerId);
-                        if (w) {
-                            w.progress = 100;
-                            w.phase = 'completed';
-                            w.status = 'completed';
-                            w.completedAt = new Date();
-                        }
-                    }, 1500);
-                }
-                result.autoDispatched = true;
-                result.workerIds = dispatched;
-            }
-        }
-        return result;
-    },
-};
 // Model route tool - intelligent model selection
 export const hooksModelRoute = {
     name: 'hooks_model-route',
@@ -1291,41 +879,4 @@ function analyzeComplexityFallback(task) {
     const lengthScore = Math.min(1, task.length / 200);
     return Math.min(1, Math.max(0, 0.3 + highCount * 0.2 - lowCount * 0.15 + lengthScore * 0.2));
 }
-// Worker cancel tool
-export const hooksWorkerCancel = {
-    name: 'hooks_worker-cancel',
-    description: 'Cancel a running worker',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            workerId: { type: 'string', description: 'Worker ID to cancel' },
-        },
-        required: ['workerId'],
-    },
-    handler: async (params) => {
-        const workerId = params.workerId;
-        const worker = activeWorkers.get(workerId);
-        if (!worker) {
-            return {
-                success: false,
-                error: `Worker not found: ${workerId}`,
-            };
-        }
-        if (worker.status === 'completed' || worker.status === 'failed') {
-            return {
-                success: false,
-                error: `Worker already ${worker.status}`,
-            };
-        }
-        worker.status = 'failed';
-        worker.phase = 'cancelled';
-        worker.completedAt = new Date();
-        return {
-            success: true,
-            workerId,
-            cancelled: true,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
 //# sourceMappingURL=hooks-intelligence.js.map

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

@@ -10,6 +10,7 @@ export declare const hooksPostEdit: MCPTool;
 export declare const hooksPreCommand: MCPTool;
 export declare const hooksPostCommand: MCPTool;
 export declare const hooksRoute: MCPTool;
+export declare const hooksRouteSemantic: MCPTool;
 export declare const hooksMetrics: MCPTool;
 export declare const hooksList: MCPTool;
 export declare const hooksPreTask: MCPTool;
@@ -20,8 +21,5 @@ export declare const hooksBuildAgents: MCPTool;
 export declare const hooksTransfer: MCPTool;
 export declare const hooksSessionStart: MCPTool;
 export declare const hooksSessionEnd: MCPTool;
-export declare const hooksSessionRestore: MCPTool;
-export declare const hooksNotify: MCPTool;
-export declare const hooksInit: MCPTool;
 export declare const hooksIntelligence: MCPTool;
 //# sourceMappingURL=hooks-routing.d.ts.map