monomind 1.18.15 → 2.0.0

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

@@ -170,17 +170,6 @@ export const agentTools = [
             };
             store.agents[agentId] = agent;
             saveAgentStore(store);
-            // Task 46: AgentSandboxing — register sandbox for isolated agent execution
-            try {
-                const { WasmSandbox, DockerSandbox, register } = await import('@monomind/security');
-                const sandboxType = config.sandbox?.type ?? 'wasm';
-                const sandboxConfig = config.sandbox ?? {};
-                const sandbox = sandboxType === 'docker'
-                    ? DockerSandbox.create(agentId, sandboxConfig)
-                    : WasmSandbox.create(agentId, sandboxConfig);
-                register(agentId, sandbox);
-            }
-            catch { /* optional — @monomind/security may not be installed */ }
             // Include Agent Booster routing info if applicable
             const response = {
                 success: true,
@@ -225,12 +214,6 @@ export const agentTools = [
             if (Object.hasOwn(store.agents, agentId)) {
                 store.agents[agentId].status = 'terminated';
                 saveAgentStore(store);
-                // Task 46: AgentSandboxing — clean up sandbox on termination
-                try {
-                    const { cleanup } = await import('@monomind/security');
-                    cleanup(agentId);
-                }
-                catch { /* optional */ }
                 return {
                     success: true,
                     agentId,

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

@@ -1,10 +1,10 @@
 /**
- * Causal Inference Tool - pr_causal_infer
+ * Causal Graph Analysis 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
+ * Analyzes causal graph structure to assess identifiability.
+ * Identifies confounders, finds backdoor paths, and determines
+ * whether a causal effect can be identified from the graph.
+ * Does NOT estimate causal effect magnitude (that requires data).
  */
 import type { MCPTool } from './types.js';
 /**

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

@@ -1,10 +1,10 @@
 /**
- * Causal Inference Tool - pr_causal_infer
+ * Causal Graph Analysis 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
+ * Analyzes causal graph structure to assess identifiability.
+ * Identifies confounders, finds backdoor paths, and determines
+ * whether a causal effect can be identified from the graph.
+ * Does NOT estimate causal effect magnitude (that requires data).
  */
 import { CausalInputSchema, successResult, errorResult, } from './types.js';
 // Default logger
@@ -155,41 +155,37 @@ function validateIntervention(treatment, outcome, graph) {
     return descendants.has(outcome);
 }
 /**
- * Estimate causal effect using backdoor adjustment
- * This is a simplified estimation - real estimation requires data
+ * Assess identifiability of the causal effect based on graph structure.
+ * Does NOT estimate the causal effect magnitude -- that requires
+ * observational or experimental data which this tool does not have.
+ * Returns an identifiability score reflecting how cleanly the effect
+ * can be estimated if data were available (fewer confounders and
+ * unblocked backdoor paths = higher identifiability).
  */
-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)
+function assessIdentifiability(confounders, backdoorPaths) {
+    // Identifiability decreases with confounders and unblocked backdoor paths
     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 };
+    const identifiability = Math.max(0.1, 1 - confounderPenalty - pathPenalty);
+    return { identifiability };
 }
 /**
- * Get interpretation of causal analysis results
+ * Get interpretation of causal graph analysis results
  */
-function getInterpretation(interventionValid, confounders, backdoorPaths, confidence) {
+function getInterpretation(interventionValid, confounders, backdoorPaths, identifiability) {
     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';
+        return 'Clean causal identification - no confounding detected. Effect is identifiable with data.';
     }
-    if (confidence > 0.8) {
-        return 'Strong causal identification - confounders can be adjusted for';
+    if (identifiability > 0.8) {
+        return 'Strong identifiability - confounders can be adjusted for with observational data';
     }
-    if (confidence > 0.5) {
-        return `Moderate causal identification - ${confounders.length} confounder(s) require adjustment`;
+    if (identifiability > 0.5) {
+        return `Moderate identifiability - ${confounders.length} confounder(s) require adjustment`;
     }
-    return `Weak causal identification - multiple confounders (${confounders.length}) and backdoor paths (${backdoorPaths.length}) detected`;
+    return `Weak identifiability - multiple confounders (${confounders.length}) and backdoor paths (${backdoorPaths.length}) detected`;
 }
 /**
  * Handler for pr_causal_infer tool
@@ -219,10 +215,7 @@ async function handler(input, context) {
             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 identifiability;
         let confounders;
         let backdoorPaths;
         let interventionValid;
@@ -231,11 +224,10 @@ async function handler(input, context) {
             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;
+                identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
             }
             catch (wasmError) {
                 logger.warn('WASM bridge failed, falling back to JS implementation', {
@@ -246,9 +238,7 @@ async function handler(input, context) {
                 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;
+                identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
             }
         }
         else {
@@ -258,26 +248,22 @@ async function handler(input, context) {
             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;
+            identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
         }
         const output = {
-            effect,
-            confidence,
+            identifiability,
             backdoorPaths: backdoorPaths.map(p => p.join(' -> ')),
             details: {
                 confounders,
                 interventionValid,
-                interpretation: getInterpretation(interventionValid, confounders, backdoorPaths, confidence),
+                interpretation: getInterpretation(interventionValid, confounders, backdoorPaths, identifiability),
                 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),
+        logger.info('Causal graph analysis completed', {
+            identifiability: identifiability.toFixed(4),
             confounders: confounders.length,
             backdoorPaths: backdoorPaths.length,
             interventionValid,
@@ -299,7 +285,7 @@ async function handler(input, context) {
  */
 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.',
+    description: 'Analyze causal graph structure for identifiability. Identifies confounders, finds backdoor paths, and assesses whether a causal effect can be identified. Does not estimate effect magnitude (requires observational data).',
     category: 'causal',
     version: '0.1.3',
     tags: ['causal', 'do-calculus', 'confounders', 'backdoor-paths', 'ai-interpretability'],

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

@@ -6,6 +6,7 @@
  *
  * Uses CohomologyEngine from prime-radiant-advanced-wasm
  */
+import { cosineSimilarity } from '../../utils/cosine-similarity.js';
 import { CoherenceInputSchema, successResult, errorResult, } from './types.js';
 // Default logger for when context doesn't provide one
 const defaultLogger = {
@@ -68,25 +69,6 @@ function detectContradictions(vectors, threshold) {
     }
     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
  */

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

@@ -1,10 +1,9 @@
 /**
  * Consensus Verification Tool - pr_consensus_verify
  *
- * Verifies multi-agent consensus mathematically using coherence analysis.
+ * Verifies multi-agent consensus using cosine-similarity coherence analysis.
  * Identifies divergent agents and measures agreement ratios.
- *
- * Uses CohomologyEngine for multi-agent consensus validation
+ * Connectivity stability uses a degree-ratio heuristic (not spectral decomposition).
  */
 import type { MCPTool } from './types.js';
 /**

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

@@ -1,10 +1,9 @@
 /**
  * Consensus Verification Tool - pr_consensus_verify
  *
- * Verifies multi-agent consensus mathematically using coherence analysis.
+ * Verifies multi-agent consensus using cosine-similarity coherence analysis.
  * Identifies divergent agents and measures agreement ratios.
- *
- * Uses CohomologyEngine for multi-agent consensus validation
+ * Connectivity stability uses a degree-ratio heuristic (not spectral decomposition).
  */
 import { ConsensusInputSchema, successResult, errorResult, cosineSimilarity, } from './types.js';
 // Default logger
@@ -107,12 +106,17 @@ function computeVoteAgreement(agentStates) {
     return maxCount / votes.length;
 }
 /**
- * Compute spectral stability from similarity matrix
+ * Compute connectivity stability from similarity matrix.
+ * Uses the ratio of average to maximum degree as a connectivity proxy.
+ * A ratio near 1 means uniform connectivity; near 0 means a few nodes
+ * dominate connectivity while others are isolated.
+ * NOTE: This is NOT a true spectral gap (which requires eigendecomposition
+ * of the Laplacian). It is a lightweight degree-based heuristic.
  */
-function computeSpectralStability(similarityMatrix) {
+function computeConnectivityStability(similarityMatrix) {
     const n = similarityMatrix.length;
     if (n < 2)
-        return { stable: true, spectralGap: 1 };
+        return { stable: true, degreeRatio: 1 };
     // Convert similarity to adjacency (threshold at 0.5)
     const adjacency = [];
     for (let i = 0; i < n; i++) {
@@ -124,7 +128,7 @@ function computeSpectralStability(similarityMatrix) {
         }
         adjacency.push(row);
     }
-    // Compute degree matrix and Laplacian
+    // Compute degrees
     const degrees = [];
     for (let i = 0; i < n; i++) {
         let degree = 0;
@@ -134,26 +138,24 @@ function computeSpectralStability(similarityMatrix) {
         }
         degrees.push(degree);
     }
-    // Estimate spectral gap using power iteration on Laplacian
-    // Simplified: use average degree connectivity as proxy
     const avgDegree = degrees.reduce((a, b) => a + b, 0) / n;
     const maxDegree = Math.max(...degrees);
-    const spectralGap = maxDegree > 0 ? avgDegree / maxDegree : 0;
-    const stable = spectralGap > 0.3;
-    return { stable, spectralGap };
+    const degreeRatio = maxDegree > 0 ? avgDegree / maxDegree : 0;
+    const stable = degreeRatio > 0.3;
+    return { stable, degreeRatio };
 }
 /**
  * Get interpretation of consensus results
  */
-function getInterpretation(verified, coherenceScore, divergentAgents, spectralStability) {
+function getInterpretation(verified, coherenceScore, divergentAgents, connectivityStable) {
     if (verified && divergentAgents.length === 0) {
         return 'Strong consensus achieved - all agents are aligned';
     }
     if (verified && divergentAgents.length > 0) {
         return `Consensus achieved with ${divergentAgents.length} minority agent(s)`;
     }
-    if (!spectralStability) {
-        return 'Consensus not achieved - agent network shows instability patterns';
+    if (!connectivityStable) {
+        return 'Consensus not achieved - agent network shows poor connectivity (uneven degree distribution)';
     }
     if (coherenceScore < 0.5) {
         return 'Consensus not achieved - significant disagreement between agents';
@@ -218,7 +220,7 @@ async function handler(input, context) {
         }
         // Compute additional metrics
         const similarityMatrix = computeSimilarityMatrix(embeddings);
-        const { stable: spectralStability, spectralGap } = computeSpectralStability(similarityMatrix);
+        const { stable: connectivityStable, degreeRatio } = computeConnectivityStability(similarityMatrix);
         const voteAgreement = computeVoteAgreement(agentStates);
         // Coherence score is inverse of energy
         const coherenceScore = 1 - coherenceEnergy;
@@ -234,9 +236,9 @@ async function handler(input, context) {
             details: {
                 agreementRatio,
                 coherenceEnergy,
-                spectralStability,
-                spectralGap,
-                interpretation: getInterpretation(verified, coherenceScore, divergentAgents, spectralStability),
+                connectivityStable,
+                degreeRatio,
+                interpretation: getInterpretation(verified, coherenceScore, divergentAgents, connectivityStable),
                 agentCount: agentStates.length,
             },
         };
@@ -263,7 +265,7 @@ async function handler(input, context) {
  */
 export const consensusVerifyTool = {
     name: 'pr_consensus_verify',
-    description: 'Verify multi-agent consensus mathematically using coherence analysis. Identifies divergent agents and measures agreement ratios. Uses CohomologyEngine for consensus validation.',
+    description: 'Verify multi-agent consensus using cosine-similarity coherence analysis. Identifies divergent agents, measures agreement ratios, and checks connectivity stability via degree-ratio heuristic.',
     category: 'consensus',
     version: '0.1.3',
     tags: ['consensus', 'multi-agent', 'coherence', 'swarm', 'ai-interpretability'],

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

@@ -3,8 +3,9 @@
  *
  * Pre-storage coherence gate for memory entries.
  * Validates that new entries are coherent with existing context before storage.
- *
- * Uses CohomologyEngine Sheaf Laplacian for coherence validation
+ * Uses cosine similarity on vectors to compute coherence energy.
+ * When no pre-computed embeddings are supplied, falls back to a deterministic
+ * hash-based vector (structural proxy, not semantic similarity).
  */
 import type { MCPTool } from './types.js';
 /**

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

@@ -3,8 +3,9 @@
  *
  * Pre-storage coherence gate for memory entries.
  * Validates that new entries are coherent with existing context before storage.
- *
- * Uses CohomologyEngine Sheaf Laplacian for coherence validation
+ * Uses cosine similarity on vectors to compute coherence energy.
+ * When no pre-computed embeddings are supplied, falls back to a deterministic
+ * hash-based vector (structural proxy, not semantic similarity).
  */
 import { MemoryGateInputSchema, successResult, errorResult, cosineSimilarity, } from './types.js';
 // Default logger
@@ -18,31 +19,42 @@ const defaultLogger = {
 // Memory Gate Functions
 // ============================================================================
 /**
- * Generate embedding from value (simplified - in production use actual embedding model)
+ * Deterministic hash-based vector from value content.
+ * This is NOT a semantic embedding -- it produces a normalized vector
+ * derived from character codes via an LCG, so only identical (or
+ * near-identical) strings will be "similar". It serves as a
+ * structural-consistency proxy when no real embedding model is available.
+ *
+ * For real semantic similarity, use the generateEmbedding() from
+ * neural-tools.ts which tries ONNX first and falls back to a
+ * deterministic hash.
  */
-function generateEmbedding(value) {
-    // Convert value to string representation
+function hashVector(value) {
     const str = typeof value === 'string' ? value : JSON.stringify(value);
-    // Simple hash-based embedding (for demo purposes)
-    // In production, use actual embedding model
-    const embedding = new Array(64).fill(0);
+    // Seed from string content
+    let seed = 0;
     for (let i = 0; i < str.length; i++) {
-        const charCode = str.charCodeAt(i);
-        const idx = i % embedding.length;
-        embedding[idx] += charCode * (i + 1) * 0.001;
+        seed = ((seed * 1103515245 + 12345) & 0x7fffffff) ^ (str.charCodeAt(i) * (i + 1));
+    }
+    // Generate deterministic vector via LCG
+    const dims = 64;
+    const vec = new Array(dims);
+    for (let i = 0; i < dims; i++) {
+        seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+        vec[i] = (seed / 0x7fffffff) * 2 - 1;
     }
     // Normalize
     let norm = 0;
-    for (let i = 0; i < embedding.length; i++) {
-        norm += embedding[i] * embedding[i];
+    for (let i = 0; i < dims; i++) {
+        norm += vec[i] * vec[i];
     }
     norm = Math.sqrt(norm);
     if (norm > 0) {
-        for (let i = 0; i < embedding.length; i++) {
-            embedding[i] /= norm;
+        for (let i = 0; i < dims; i++) {
+            vec[i] /= norm;
         }
     }
-    return embedding;
+    return vec;
 }
 /**
  * Compute coherence energy using Sheaf Laplacian
@@ -123,8 +135,9 @@ async function handler(input, context) {
             warnThreshold,
             rejectThreshold,
         });
-        // Generate embedding for the new value
-        const newEmbedding = generateEmbedding(value);
+        // Generate hash-based vector for the new value (not a semantic embedding --
+        // only detects near-identical content, not semantic similarity)
+        const newEmbedding = hashVector(value);
         // If no existing context, always allow
         if (!existingVectors || existingVectors.length === 0) {
             const output = {
@@ -221,7 +234,7 @@ async function handler(input, context) {
  */
 export const memoryGateTool = {
     name: 'pr_memory_gate',
-    description: 'Pre-storage coherence gate for memory entries. Validates new entries against existing context using Sheaf Laplacian energy. Blocks contradictory entries to maintain memory coherence.',
+    description: 'Pre-storage coherence gate for memory entries. Validates new entries against existing context vectors using cosine-similarity energy. When no pre-computed embeddings are supplied, uses a deterministic hash-based vector (structural proxy, not semantic). Blocks contradictory entries to maintain memory coherence.',
     category: 'memory',
     version: '0.1.3',
     tags: ['memory', 'coherence', 'gate', 'validation', 'ai-interpretability'],

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

@@ -1,10 +1,10 @@
 /**
- * Quantum Topology Tool - pr_quantum_topology
+ * Computational Topology Tool - pr_quantum_topology
  *
- * Computes quantum topology features including Betti numbers and persistence diagrams.
+ * Computes topological features including Betti numbers (b0, b1) and
+ * persistence diagrams via Vietoris-Rips filtration.
  * Analyzes topological features of point clouds and simplicial complexes.
- *
- * Uses QuantumEngine from prime-radiant-advanced-wasm
+ * b2 (voids) is not computed -- requires boundary-operator linear algebra.
  */
 import type { MCPTool } from './types.js';
 /**

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

@@ -1,10 +1,10 @@
 /**
- * Quantum Topology Tool - pr_quantum_topology
+ * Computational Topology Tool - pr_quantum_topology
  *
- * Computes quantum topology features including Betti numbers and persistence diagrams.
+ * Computes topological features including Betti numbers (b0, b1) and
+ * persistence diagrams via Vietoris-Rips filtration.
  * Analyzes topological features of point clouds and simplicial complexes.
- *
- * Uses QuantumEngine from prime-radiant-advanced-wasm
+ * b2 (voids) is not computed -- requires boundary-operator linear algebra.
  */
 import { TopologyInputSchema, successResult, errorResult, } from './types.js';
 // Default logger
@@ -163,14 +163,9 @@ function computeBettiNumbers(vertices, simplices, maxDimension) {
         const b1 = Math.max(0, edges - n + b0);
         bettiNumbers.push(b1);
     }
-    // b2: Approximate from triangle/tetrahedron relationship
-    if (maxDimension >= 2) {
-        const triangles = simplexCounts[2] || 0;
-        const tetrahedra = simplexCounts[3] || 0;
-        // Simplified: b2 related to enclosed voids
-        const b2 = Math.max(0, tetrahedra > 0 ? 1 : 0);
-        bettiNumbers.push(b2);
-    }
+    // b2 requires computing the rank of the boundary matrices (dim-2 and dim-3),
+    // which needs full boundary-operator linear algebra not implemented here.
+    // We do NOT fabricate b2 -- only b0 and b1 are reported.
     return bettiNumbers;
 }
 /**
@@ -256,7 +251,6 @@ function interpretBettiNumbers(bettiNumbers) {
     return {
         b0: `${bettiNumbers[0] || 0} connected component(s)`,
         b1: `${bettiNumbers[1] || 0} loop(s)/cycle(s)`,
-        b2: `${bettiNumbers[2] || 0} void(s)/cavit${(bettiNumbers[2] || 0) === 1 ? 'y' : 'ies'}`,
     };
 }
 /**
@@ -274,7 +268,7 @@ async function handler(input, context) {
         }
         const { complex } = validationResult.data;
         const { vertices, maxDimension } = complex;
-        logger.debug('Processing quantum topology', {
+        logger.debug('Processing computational topology', {
             vertexCount: vertices.length,
             maxDimension,
         });
@@ -338,7 +332,7 @@ async function handler(input, context) {
             },
         };
         const duration = performance.now() - startTime;
-        logger.info('Quantum topology completed', {
+        logger.info('Topology computation completed', {
             bettiNumbers: bettiNumbers.join(', '),
             persistencePoints: persistenceDiagram.length,
             homologyClasses,
@@ -348,7 +342,7 @@ async function handler(input, context) {
     }
     catch (error) {
         const duration = performance.now() - startTime;
-        logger.error('Quantum topology failed', {
+        logger.error('Topology computation failed', {
             error: error instanceof Error ? error.message : String(error),
             durationMs: duration.toFixed(2),
         });
@@ -360,7 +354,7 @@ async function handler(input, context) {
  */
 export const quantumTopologyTool = {
     name: 'pr_quantum_topology',
-    description: 'Compute quantum topology features including Betti numbers and persistence diagrams. Analyzes topological features of point clouds. Uses QuantumEngine for persistent homology computation.',
+    description: 'Compute topological features via Vietoris-Rips filtration. Reports Betti numbers b0 (components) and b1 (loops) with persistence diagrams. b2 (voids) is not computed.',
     category: 'topology',
     version: '0.1.3',
     tags: ['topology', 'betti-numbers', 'persistence', 'homology', 'ai-interpretability'],

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

@@ -2,9 +2,8 @@
  * Spectral Analysis Tool - pr_spectral_analyze
  *
  * Analyzes stability of systems using spectral graph theory.
- * Computes eigenvalues, spectral gap, and stability metrics.
- *
- * Uses SpectralEngine from prime-radiant-advanced-wasm
+ * Computes eigenvalues via power iteration with Hotelling deflation,
+ * spectral gap, and stability metrics from the graph Laplacian.
  */
 import type { MCPTool } from './types.js';
 /**