monomind 1.15.3 → 1.15.5

package/.claude/scheduled_tasks.lock

@@ -1 +1 @@
-{"sessionId":"ed60b548-7aa2-4e96-bcec-4eaf8aa33732","pid":74650,"procStart":"Mon Jun  1 16:07:08 2026","acquiredAt":1780344677932}
+{"sessionId":"db24c21a-e929-4aba-911b-4cdb7fc5c3d5","pid":2346,"procStart":"Wed Jun 24 16:31:36 2026","acquiredAt":1782380072591}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.15.3",
+  "version": "1.15.5",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

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

@@ -43,6 +43,9 @@ import { monographTools } from './mcp-tools/monograph-tools.js';
 import { coverageRouterTools } from './monovector/coverage-tools.js';
 // A2A Agent Card protocol (source: https://a2a-protocol.org)
 import { a2aTools } from './mcp-tools/a2a-tools.js';
+// Quality (agentic-qe) and Coherence (prime-radiant) core tools
+import { qualityTools } from './mcp-tools/quality-tools.js';
+import { coherenceTools } from './mcp-tools/coherence-tools.js';
 /**
  * MCP Tool Registry
  * Maps tool names to their handler functions
@@ -100,6 +103,10 @@ registerTools([
     ...coverageRouterTools,
     // A2A Agent Card protocol (source: https://a2a-protocol.org)
     ...a2aTools,
+    // Quality tools (migrated from agentic-qe plugin)
+    ...qualityTools,
+    // Coherence tools (migrated from prime-radiant plugin)
+    ...coherenceTools,
 ]);
 /**
  * MCP Client Error

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

@@ -0,0 +1,15 @@
+/**
+ * Causal Inference Tool - pr_causal_infer
+ *
+ * Performs causal inference using do-calculus.
+ * Estimates causal effects, identifies confounders, and finds backdoor paths.
+ *
+ * Uses CausalEngine from prime-radiant-advanced-wasm
+ */
+import type { MCPTool } from './types.js';
+/**
+ * pr_causal_infer MCP Tool Definition
+ */
+export declare const causalInferTool: MCPTool;
+export default causalInferTool;
+//# sourceMappingURL=causal-infer.d.ts.map

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

@@ -0,0 +1,347 @@
+/**
+ * Causal Inference Tool - pr_causal_infer
+ *
+ * Performs causal inference using do-calculus.
+ * Estimates causal effects, identifies confounders, and finds backdoor paths.
+ *
+ * Uses CausalEngine from prime-radiant-advanced-wasm
+ */
+import { CausalInputSchema, successResult, errorResult, } from './types.js';
+// Default logger
+const defaultLogger = {
+    debug: (msg, meta) => console.debug(`[pr_causal_infer] ${msg}`, meta),
+    info: (msg, meta) => console.info(`[pr_causal_infer] ${msg}`, meta),
+    warn: (msg, meta) => console.warn(`[pr_causal_infer] ${msg}`, meta),
+    error: (msg, meta) => console.error(`[pr_causal_infer] ${msg}`, meta),
+};
+function buildGraphStructure(graph) {
+    const nodes = new Map();
+    // Initialize nodes
+    for (const nodeId of graph.nodes) {
+        nodes.set(nodeId, {
+            id: nodeId,
+            parents: new Set(),
+            children: new Set(),
+        });
+    }
+    // Add edges
+    for (const [from, to] of graph.edges) {
+        const fromNode = nodes.get(from);
+        const toNode = nodes.get(to);
+        if (fromNode && toNode) {
+            fromNode.children.add(to);
+            toNode.parents.add(from);
+        }
+    }
+    return nodes;
+}
+/**
+ * Find all ancestors of a node (including the node itself)
+ */
+function findAncestors(nodeId, graph) {
+    const ancestors = new Set();
+    const queue = [nodeId];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (ancestors.has(current))
+            continue;
+        ancestors.add(current);
+        const node = graph.get(current);
+        if (node) {
+            for (const parent of node.parents) {
+                queue.push(parent);
+            }
+        }
+    }
+    return ancestors;
+}
+/**
+ * Find all descendants of a node (including the node itself)
+ */
+function findDescendants(nodeId, graph) {
+    const descendants = new Set();
+    const queue = [nodeId];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (descendants.has(current))
+            continue;
+        descendants.add(current);
+        const node = graph.get(current);
+        if (node) {
+            for (const child of node.children) {
+                queue.push(child);
+            }
+        }
+    }
+    return descendants;
+}
+/**
+ * Identify confounders (common causes of treatment and outcome)
+ */
+function identifyConfounders(treatment, outcome, graph) {
+    const treatmentAncestors = findAncestors(treatment, graph);
+    const outcomeAncestors = findAncestors(outcome, graph);
+    // Confounders are ancestors of both treatment and outcome
+    // that are not the treatment itself
+    const confounders = [];
+    for (const ancestor of treatmentAncestors) {
+        if (ancestor !== treatment && ancestor !== outcome && outcomeAncestors.has(ancestor)) {
+            confounders.push(ancestor);
+        }
+    }
+    return confounders;
+}
+/**
+ * Find backdoor paths from treatment to outcome
+ * A backdoor path is a path that goes into the treatment node
+ */
+function findBackdoorPaths(treatment, outcome, graph, maxPaths = 10) {
+    const backdoorPaths = [];
+    const treatmentNode = graph.get(treatment);
+    if (!treatmentNode)
+        return [];
+    // Start from each parent of treatment (backdoor)
+    for (const parent of treatmentNode.parents) {
+        const paths = findAllPaths(parent, outcome, graph, new Set([treatment]), maxPaths - backdoorPaths.length);
+        for (const path of paths) {
+            backdoorPaths.push([treatment, ...path]);
+            if (backdoorPaths.length >= maxPaths)
+                break;
+        }
+        if (backdoorPaths.length >= maxPaths)
+            break;
+    }
+    return backdoorPaths;
+}
+/**
+ * Find all paths from source to target (BFS with path tracking)
+ */
+function findAllPaths(source, target, graph, exclude, maxPaths) {
+    const paths = [];
+    const queue = [{ node: source, path: [source] }];
+    while (queue.length > 0 && paths.length < maxPaths) {
+        const { node, path } = queue.shift();
+        if (node === target) {
+            paths.push(path);
+            continue;
+        }
+        const currentNode = graph.get(node);
+        if (!currentNode)
+            continue;
+        // Consider both parents and children for undirected path finding
+        const neighbors = new Set([...currentNode.parents, ...currentNode.children]);
+        for (const neighbor of neighbors) {
+            if (!path.includes(neighbor) && !exclude.has(neighbor)) {
+                queue.push({
+                    node: neighbor,
+                    path: [...path, neighbor],
+                });
+            }
+        }
+    }
+    return paths;
+}
+/**
+ * Check if intervention is valid (treatment must exist and have outgoing edges)
+ */
+function validateIntervention(treatment, outcome, graph) {
+    const treatmentNode = graph.get(treatment);
+    const outcomeNode = graph.get(outcome);
+    if (!treatmentNode || !outcomeNode) {
+        return false;
+    }
+    // Check if there's any path from treatment to outcome
+    const descendants = findDescendants(treatment, graph);
+    return descendants.has(outcome);
+}
+/**
+ * Estimate causal effect using backdoor adjustment
+ * This is a simplified estimation - real estimation requires data
+ */
+function estimateCausalEffect(treatment, outcome, confounders, backdoorPaths, graph) {
+    // Effect estimation heuristic based on graph structure
+    // In practice, this requires observational data
+    // Base effect: based on direct path existence
+    const treatmentNode = graph.get(treatment);
+    let baseEffect = treatmentNode?.children.has(outcome) ? 0.5 : 0.3;
+    // Adjust for confounders (more confounders = less identifiable effect)
+    const confounderPenalty = Math.min(confounders.length * 0.1, 0.3);
+    // Adjust for backdoor paths (more unblocked paths = less reliable)
+    const pathPenalty = Math.min(backdoorPaths.length * 0.05, 0.2);
+    const effect = Math.max(0, baseEffect - confounderPenalty - pathPenalty);
+    // Confidence decreases with confounders and backdoor paths
+    const confidence = Math.max(0.1, 1 - confounderPenalty - pathPenalty);
+    return { effect, confidence };
+}
+/**
+ * Get interpretation of causal analysis results
+ */
+function getInterpretation(interventionValid, confounders, backdoorPaths, confidence) {
+    if (!interventionValid) {
+        return 'Intervention is not valid - no causal path exists from treatment to outcome';
+    }
+    if (confounders.length === 0 && backdoorPaths.length === 0) {
+        return 'Clean causal identification - no confounding detected';
+    }
+    if (confidence > 0.8) {
+        return 'Strong causal identification - confounders can be adjusted for';
+    }
+    if (confidence > 0.5) {
+        return `Moderate causal identification - ${confounders.length} confounder(s) require adjustment`;
+    }
+    return `Weak causal identification - multiple confounders (${confounders.length}) and backdoor paths (${backdoorPaths.length}) detected`;
+}
+/**
+ * Handler for pr_causal_infer tool
+ */
+async function handler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        // Validate input
+        const validationResult = CausalInputSchema.safeParse(input);
+        if (!validationResult.success) {
+            logger.error('Input validation failed', { error: validationResult.error.message });
+            return errorResult(`Invalid input: ${validationResult.error.message}`);
+        }
+        const { graph, intervention, outcome } = validationResult.data;
+        logger.debug('Processing causal inference', {
+            nodes: graph.nodes.length,
+            edges: graph.edges.length,
+            intervention,
+            outcome,
+        });
+        // Validate nodes exist
+        if (!graph.nodes.includes(intervention)) {
+            return errorResult(`Intervention variable "${intervention}" not found in graph nodes`);
+        }
+        if (!graph.nodes.includes(outcome)) {
+            return errorResult(`Outcome variable "${outcome}" not found in graph nodes`);
+        }
+        const maxBackdoorPaths = context?.config?.causal?.maxBackdoorPaths ?? 10;
+        // Note: confidenceThreshold can be used for filtering in future enhancements
+        void (context?.config?.causal?.confidenceThreshold ?? 0.8);
+        let effect;
+        let confidence;
+        let confounders;
+        let backdoorPaths;
+        let interventionValid;
+        // Try to use WASM bridge if available
+        if (context?.bridge?.initialized) {
+            try {
+                logger.debug('Using WASM bridge for causal inference');
+                const result = await context.bridge.inferCausal(graph, intervention, outcome);
+                effect = result.effect;
+                confidence = result.confidence;
+                confounders = result.confounders;
+                backdoorPaths = result.backdoorPaths;
+                interventionValid = result.interventionValid;
+            }
+            catch (wasmError) {
+                logger.warn('WASM bridge failed, falling back to JS implementation', {
+                    error: wasmError instanceof Error ? wasmError.message : String(wasmError),
+                });
+                // Use JavaScript implementation
+                const graphStructure = buildGraphStructure(graph);
+                interventionValid = validateIntervention(intervention, outcome, graphStructure);
+                confounders = identifyConfounders(intervention, outcome, graphStructure);
+                backdoorPaths = findBackdoorPaths(intervention, outcome, graphStructure, maxBackdoorPaths);
+                const estimation = estimateCausalEffect(intervention, outcome, confounders, backdoorPaths, graphStructure);
+                effect = estimation.effect;
+                confidence = estimation.confidence;
+            }
+        }
+        else {
+            // Pure JavaScript fallback
+            logger.debug('Using JavaScript fallback for causal inference');
+            const graphStructure = buildGraphStructure(graph);
+            interventionValid = validateIntervention(intervention, outcome, graphStructure);
+            confounders = identifyConfounders(intervention, outcome, graphStructure);
+            backdoorPaths = findBackdoorPaths(intervention, outcome, graphStructure, maxBackdoorPaths);
+            const estimation = estimateCausalEffect(intervention, outcome, confounders, backdoorPaths, graphStructure);
+            effect = estimation.effect;
+            confidence = estimation.confidence;
+        }
+        const output = {
+            effect,
+            confidence,
+            backdoorPaths: backdoorPaths.map(p => p.join(' -> ')),
+            details: {
+                confounders,
+                interventionValid,
+                interpretation: getInterpretation(interventionValid, confounders, backdoorPaths, confidence),
+                nodeCount: graph.nodes.length,
+                edgeCount: graph.edges.length,
+            },
+        };
+        const duration = performance.now() - startTime;
+        logger.info('Causal inference completed', {
+            effect: effect.toFixed(4),
+            confidence: confidence.toFixed(4),
+            confounders: confounders.length,
+            backdoorPaths: backdoorPaths.length,
+            interventionValid,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult(output);
+    }
+    catch (error) {
+        const duration = performance.now() - startTime;
+        logger.error('Causal inference failed', {
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: duration.toFixed(2),
+        });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+/**
+ * pr_causal_infer MCP Tool Definition
+ */
+export const causalInferTool = {
+    name: 'pr_causal_infer',
+    description: 'Perform causal inference using do-calculus. Estimates causal effects, identifies confounders, and finds backdoor paths. Uses CausalEngine for mathematical causal analysis.',
+    category: 'causal',
+    version: '0.1.3',
+    tags: ['causal', 'do-calculus', 'confounders', 'backdoor-paths', 'ai-interpretability'],
+    cacheable: true,
+    cacheTTL: 60000,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            graph: {
+                type: 'object',
+                properties: {
+                    nodes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'List of variable names',
+                    },
+                    edges: {
+                        type: 'array',
+                        items: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            minItems: 2,
+                            maxItems: 2,
+                        },
+                        description: 'Directed edges as [from, to] pairs',
+                    },
+                },
+                required: ['nodes', 'edges'],
+                description: 'Causal graph with nodes and directed edges',
+            },
+            intervention: {
+                type: 'string',
+                description: 'Treatment/intervention variable',
+            },
+            outcome: {
+                type: 'string',
+                description: 'Outcome variable to measure effect on',
+            },
+        },
+        required: ['graph', 'intervention', 'outcome'],
+    },
+    handler,
+};
+export default causalInferTool;
+//# sourceMappingURL=causal-infer.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * Coherence Check Tool - pr_coherence_check
+ *
+ * Checks coherence of vectors using Sheaf Laplacian energy.
+ * Energy 0 = fully coherent, Energy 1 = contradictory
+ *
+ * Uses CohomologyEngine from prime-radiant-advanced-wasm
+ */
+import type { MCPTool } from './types.js';
+/**
+ * pr_coherence_check MCP Tool Definition
+ */
+export declare const coherenceCheckTool: MCPTool;
+export default coherenceCheckTool;
+//# sourceMappingURL=coherence-check.d.ts.map

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

@@ -0,0 +1,206 @@
+/**
+ * Coherence Check Tool - pr_coherence_check
+ *
+ * Checks coherence of vectors using Sheaf Laplacian energy.
+ * Energy 0 = fully coherent, Energy 1 = contradictory
+ *
+ * Uses CohomologyEngine from prime-radiant-advanced-wasm
+ */
+import { CoherenceInputSchema, successResult, errorResult, } from './types.js';
+// Default logger for when context doesn't provide one
+const defaultLogger = {
+    debug: (msg, meta) => console.debug(`[pr_coherence_check] ${msg}`, meta),
+    info: (msg, meta) => console.info(`[pr_coherence_check] ${msg}`, meta),
+    warn: (msg, meta) => console.warn(`[pr_coherence_check] ${msg}`, meta),
+    error: (msg, meta) => console.error(`[pr_coherence_check] ${msg}`, meta),
+};
+/**
+ * Compute Sheaf Laplacian energy for coherence detection
+ *
+ * The Sheaf Laplacian measures how well local data sections can be
+ * glued together into a global section. High energy indicates contradictions.
+ *
+ * For vectors v1, v2, ..., vn:
+ * 1. Construct a sheaf over the complete graph
+ * 2. Compute the Laplacian matrix L = D - A (where A captures similarities)
+ * 3. Energy = sum of disagreements across edges
+ */
+function computeSheafLaplacianEnergy(vectors) {
+    if (vectors.length < 2)
+        return 0;
+    const n = vectors.length;
+    let totalEnergy = 0;
+    let edgeCount = 0;
+    // Compute pairwise disagreement (1 - cosine_similarity)
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            const vi = vectors[i];
+            const vj = vectors[j];
+            const similarity = cosineSimilarity(vi, vj);
+            const disagreement = 1 - Math.max(0, similarity); // Clamp negative similarities
+            totalEnergy += disagreement;
+            edgeCount++;
+        }
+    }
+    // Normalize by number of edges
+    return edgeCount > 0 ? totalEnergy / edgeCount : 0;
+}
+/**
+ * Detect contradictions in the vector set
+ */
+function detectContradictions(vectors, threshold) {
+    const violations = [];
+    const n = vectors.length;
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            const vi = vectors[i];
+            const vj = vectors[j];
+            const similarity = cosineSimilarity(vi, vj);
+            // Negative similarity indicates potential contradiction
+            if (similarity < -0.3) {
+                violations.push(`Contradiction between vectors ${i} and ${j} (similarity: ${similarity.toFixed(3)})`);
+            }
+            // Low similarity with high threshold indicates inconsistency
+            else if (similarity < threshold && similarity > 0) {
+                violations.push(`Weak coherence between vectors ${i} and ${j} (similarity: ${similarity.toFixed(3)})`);
+            }
+        }
+    }
+    return violations;
+}
+/**
+ * Calculate cosine similarity
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i];
+        const bi = b[i];
+        dotProduct += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    return denominator > 0 ? dotProduct / denominator : 0;
+}
+/**
+ * Get interpretation of energy level
+ */
+function getInterpretation(energy) {
+    if (energy < 0.1)
+        return 'Fully coherent - vectors are highly consistent';
+    if (energy < 0.3)
+        return 'Minor inconsistencies - generally coherent with small variations';
+    if (energy < 0.5)
+        return 'Moderate inconsistencies - some conflicting information detected';
+    if (energy < 0.7)
+        return 'Significant contradictions - vectors contain conflicting content';
+    return 'Major contradictions detected - high disagreement between vectors';
+}
+/**
+ * Handler for pr_coherence_check tool
+ */
+async function handler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        // Validate input
+        const validationResult = CoherenceInputSchema.safeParse(input);
+        if (!validationResult.success) {
+            logger.error('Input validation failed', { error: validationResult.error.message });
+            return errorResult(`Invalid input: ${validationResult.error.message}`);
+        }
+        const { vectors, threshold } = validationResult.data;
+        logger.debug('Processing coherence check', { vectorCount: vectors.length, threshold });
+        // Convert to Float32Arrays
+        const float32Vectors = vectors.map(v => new Float32Array(v));
+        let energy;
+        let violations;
+        // Try to use WASM bridge if available
+        if (context?.bridge?.initialized) {
+            try {
+                logger.debug('Using WASM bridge for coherence check');
+                const result = await context.bridge.checkCoherence(float32Vectors);
+                energy = result.energy;
+                violations = result.violations;
+            }
+            catch (wasmError) {
+                logger.warn('WASM bridge failed, falling back to JS implementation', {
+                    error: wasmError instanceof Error ? wasmError.message : String(wasmError),
+                });
+                energy = computeSheafLaplacianEnergy(float32Vectors);
+                violations = detectContradictions(float32Vectors, threshold);
+            }
+        }
+        else {
+            // Pure JavaScript fallback implementation
+            logger.debug('Using JavaScript fallback for coherence check');
+            energy = computeSheafLaplacianEnergy(float32Vectors);
+            violations = detectContradictions(float32Vectors, threshold);
+        }
+        const isCoherent = energy < threshold;
+        const confidence = 1 - energy;
+        const output = {
+            energy,
+            isCoherent,
+            details: {
+                violations,
+                confidence,
+                interpretation: getInterpretation(energy),
+                vectorCount: vectors.length,
+                threshold,
+            },
+        };
+        const duration = performance.now() - startTime;
+        logger.info('Coherence check completed', {
+            energy: energy.toFixed(4),
+            isCoherent,
+            violations: violations.length,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult(output);
+    }
+    catch (error) {
+        const duration = performance.now() - startTime;
+        logger.error('Coherence check failed', {
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: duration.toFixed(2),
+        });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+/**
+ * pr_coherence_check MCP Tool Definition
+ */
+export const coherenceCheckTool = {
+    name: 'pr_coherence_check',
+    description: 'Check coherence of vectors using Sheaf Laplacian energy. Energy 0 = fully coherent, 1 = contradictory. Uses CohomologyEngine for mathematical validation of vector consistency.',
+    category: 'coherence',
+    version: '0.1.3',
+    tags: ['coherence', 'sheaf-laplacian', 'contradiction-detection', 'ai-interpretability'],
+    cacheable: true,
+    cacheTTL: 60000, // 1 minute cache
+    inputSchema: {
+        type: 'object',
+        properties: {
+            vectors: {
+                type: 'array',
+                items: { type: 'array', items: { type: 'number' } },
+                description: 'Array of embedding vectors to check for coherence',
+            },
+            threshold: {
+                type: 'number',
+                default: 0.3,
+                description: 'Energy threshold for coherence (0-1). Lower = stricter coherence requirement.',
+            },
+        },
+        required: ['vectors'],
+    },
+    handler,
+};
+export default coherenceCheckTool;
+//# sourceMappingURL=coherence-check.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * Consensus Verification Tool - pr_consensus_verify
+ *
+ * Verifies multi-agent consensus mathematically using coherence analysis.
+ * Identifies divergent agents and measures agreement ratios.
+ *
+ * Uses CohomologyEngine for multi-agent consensus validation
+ */
+import type { MCPTool } from './types.js';
+/**
+ * pr_consensus_verify MCP Tool Definition
+ */
+export declare const consensusVerifyTool: MCPTool;
+export default consensusVerifyTool;
+//# sourceMappingURL=consensus-verify.d.ts.map