monomind 1.18.13 → 1.19.0

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

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

@@ -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 { SpectralInputSchema, successResult, errorResult, } from './types.js';
 // Default logger
@@ -15,14 +14,32 @@ const defaultLogger = {
     error: (msg, meta) => console.error(`[pr_spectral_analyze] ${msg}`, meta),
 };
 /**
- * Power iteration method for finding dominant eigenvalue
+ * Simple deterministic hash to seed initial vectors reproducibly from matrix content
+ */
+function matrixHash(matrix) {
+    let hash = 0;
+    for (let i = 0; i < matrix.length; i++) {
+        for (let j = 0; j < matrix[i].length; j++) {
+            // Combine with a simple LCG-style mixing
+            hash = ((hash * 1103515245 + 12345) & 0x7fffffff) ^ (matrix[i][j] * 1000003 | 0);
+        }
+    }
+    return hash;
+}
+/**
+ * Power iteration method for finding dominant eigenvalue.
+ * Returns both the eigenvalue and the converged eigenvector.
  */
-function powerIteration(matrix, maxIterations = 100, tolerance = 1e-10) {
+function powerIteration(matrix, maxIterations = 100, tolerance = 1e-10, seed) {
     const n = matrix.length;
     if (n === 0)
-        return 0;
-    // Initialize random vector
-    let v = new Array(n).fill(0).map(() => Math.random());
+        return { eigenvalue: 0, eigenvector: [] };
+    // Initialize with deterministic vector seeded from matrix content
+    let s = seed ?? matrixHash(matrix);
+    let v = new Array(n).fill(0).map(() => {
+        s = (s * 1103515245 + 12345) & 0x7fffffff;
+        return (s / 0x7fffffff) * 2 - 1;
+    });
     let eigenvalue = 0;
     for (let iter = 0; iter < maxIterations; iter++) {
         // Multiply matrix by vector
@@ -44,7 +61,7 @@ function powerIteration(matrix, maxIterations = 100, tolerance = 1e-10) {
         // Check convergence
         const newEigenvalue = maxComponent;
         if (Math.abs(newEigenvalue - eigenvalue) < tolerance) {
-            return newEigenvalue;
+            return { eigenvalue: newEigenvalue, eigenvector: v };
         }
         eigenvalue = newEigenvalue;
         // Normalize
@@ -52,38 +69,40 @@ function powerIteration(matrix, maxIterations = 100, tolerance = 1e-10) {
             v[i] = w[i] / maxComponent;
         }
     }
-    return eigenvalue;
+    return { eigenvalue, eigenvector: v };
 }
 /**
- * Compute approximate eigenvalues using QR iteration (simplified)
- * For production, consider using a proper numerical library
+ * Compute eigenvalues via repeated power-iteration with Hotelling deflation.
+ * Returns only eigenvalues actually computed (up to min(n, maxCount)).
+ * For production, consider using a proper numerical library.
  */
-function computeEigenvalues(matrix) {
+function computeEigenvalues(matrix, maxCount = 10) {
     const n = matrix.length;
     if (n === 0)
         return [];
     if (n === 1)
         return [matrix[0][0]];
-    // For small matrices, use characteristic polynomial roots (simplified)
-    // For larger matrices, use power iteration for top k eigenvalues
     const eigenvalues = [];
-    // Get dominant eigenvalue
-    const lambda1 = powerIteration(matrix);
-    eigenvalues.push(lambda1);
-    // For spectral analysis, we mainly need the top eigenvalues and spectral gap
-    // Use deflation to get second eigenvalue
-    if (n > 1) {
-        // Simplified: estimate second eigenvalue from trace
-        let trace = 0;
+    // Work on a copy so deflation doesn't mutate the original
+    let current = matrix.map(row => [...row]);
+    const count = Math.min(n, maxCount);
+    for (let k = 0; k < count; k++) {
+        const { eigenvalue, eigenvector } = powerIteration(current, 200, 1e-10, matrixHash(current) + k);
+        // If power iteration didn't converge to anything meaningful, stop
+        if (Math.abs(eigenvalue) < 1e-12)
+            break;
+        eigenvalues.push(eigenvalue);
+        // Hotelling deflation: subtract lambda * v * v^T from the matrix
+        // to remove the dominant eigenvalue and find the next one
+        let vNorm = 0;
+        for (let i = 0; i < n; i++)
+            vNorm += eigenvector[i] * eigenvector[i];
+        if (vNorm < 1e-12)
+            break;
         for (let i = 0; i < n; i++) {
-            trace += matrix[i][i];
-        }
-        // Second eigenvalue approximation
-        const lambda2Approx = (trace - lambda1) / (n - 1);
-        eigenvalues.push(lambda2Approx);
-        // Add remaining approximate eigenvalues
-        for (let i = 2; i < Math.min(n, 10); i++) {
-            eigenvalues.push(lambda2Approx * (1 - i * 0.1)); // Decreasing approximation
+            for (let j = 0; j < n; j++) {
+                current[i][j] -= eigenvalue * (eigenvector[i] * eigenvector[j]) / vNorm;
+            }
         }
     }
     return eigenvalues.sort((a, b) => Math.abs(b) - Math.abs(a));
@@ -264,7 +283,7 @@ async function handler(input, context) {
  */
 export const spectralAnalyzeTool = {
     name: 'pr_spectral_analyze',
-    description: 'Analyze stability using spectral graph theory. Computes eigenvalues, spectral gap, and stability metrics. Uses SpectralEngine for mathematical validation of system stability.',
+    description: 'Analyze stability using spectral graph theory. Computes eigenvalues via power iteration with Hotelling deflation, spectral gap, and stability metrics from the graph Laplacian.',
     category: 'spectral',
     version: '0.1.3',
     tags: ['spectral', 'eigenvalues', 'stability', 'graph-theory', 'ai-interpretability'],

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

@@ -162,15 +162,12 @@ export declare const CausalInputSchema: z.ZodObject<{
 }>;
 export type CausalInput = z.infer<typeof CausalInputSchema>;
 export interface CausalResult {
-    effect: number;
     confounders: string[];
     interventionValid: boolean;
     backdoorPaths: string[][];
-    confidence: number;
 }
 export interface CausalOutput {
-    effect: number;
-    confidence: number;
+    identifiability: number;
     backdoorPaths: string[];
     details: {
         confounders: string[];
@@ -240,8 +237,8 @@ export interface ConsensusOutput {
     details: {
         agreementRatio: number;
         coherenceEnergy: number;
-        spectralStability: boolean;
-        spectralGap: number;
+        connectivityStable: boolean;
+        degreeRatio: number;
         interpretation: string;
         agentCount: number;
     };
@@ -352,7 +349,6 @@ export interface TopologyOutput {
         interpretation: {
             b0: string;
             b1: string;
-            b2: string;
         };
         vertexCount: number;
         maxDimension: number;
@@ -375,19 +371,19 @@ export declare const MemoryGateInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     key: string;
     value?: unknown;
+    existingVectors?: number[][] | undefined;
     thresholds?: {
         warn: number;
         reject: number;
     } | undefined;
-    existingVectors?: number[][] | undefined;
 }, {
     key: string;
     value?: unknown;
+    existingVectors?: number[][] | undefined;
     thresholds?: {
         warn?: number | undefined;
         reject?: number | undefined;
     } | undefined;
-    existingVectors?: number[][] | undefined;
 }>;
 export type MemoryGateInput = z.infer<typeof MemoryGateInputSchema>;
 export interface MemoryGateOutput {

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

@@ -85,9 +85,9 @@ const CAPABILITY_CATALOG = {
     },
     'intelligence-learning': {
         name: 'Intelligence & Learning',
-        description: 'Neural pattern training (SONA), RL loops, Flash Attention, EWC++ consolidation.',
+        description: 'Pattern storage and cosine-similarity search (SONA/ReasoningBank) backed by real embeddings.',
         tools: ['neural_train', 'neural_predict', 'neural_status', 'neural_patterns', 'neural_optimize'],
-        commands: ['neural train', 'neural predict', 'neural status', 'neural patterns', 'neural optimize'],
+        commands: [],
         agents: ['sona-learning-optimizer', 'safla-neural'],
         skills: ['reasoningbank-intelligence', 'memory-reasoningbank'],
         whenToUse: 'When optimizing agent routing, training patterns from outcomes, or adaptive learning.',

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

@@ -256,17 +256,28 @@ export const hiveMindTools = [
                 updatedAt: now,
             };
             saveHiveState(state);
+            // Validate consensus strategy: gossip and crdt are planned but not implemented
+            const SUPPORTED_CONSENSUS = ['byzantine', 'bft', 'raft', 'quorum'];
+            const PLANNED_CONSENSUS = ['gossip', 'crdt'];
+            const requestedConsensus = input.consensus || 'byzantine';
+            const consensusWarning = PLANNED_CONSENSUS.includes(requestedConsensus)
+                ? `Strategy "${requestedConsensus}" is planned but not yet implemented; defaulting to "byzantine".`
+                : undefined;
+            const effectiveConsensus = PLANNED_CONSENSUS.includes(requestedConsensus)
+                ? 'byzantine'
+                : (SUPPORTED_CONSENSUS.includes(requestedConsensus) ? requestedConsensus : 'byzantine');
             return {
                 success: true,
                 hiveId,
                 topology: state.topology,
-                consensus: input.consensus || 'byzantine',
+                consensus: effectiveConsensus,
                 queenId,
                 neuralLearning: 'unavailable',
                 status: 'initialized',
+                ...(consensusWarning ? { warning: consensusWarning } : {}),
                 config: {
                     topology: state.topology,
-                    consensus: input.consensus || 'byzantine',
+                    consensus: effectiveConsensus,
                     maxAgents: input.maxAgents || 15,
                     persist: input.persist !== false,
                     memoryBackend: input.memoryBackend || 'hybrid',
@@ -470,7 +481,18 @@ export const hiveMindTools = [
         handler: async (input) => {
             const state = loadHiveState();
             const action = input.action;
-            const strategy = input.strategy || 'raft';
+            const rawStrategy = input.strategy || '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'];
+            if (UNIMPLEMENTED_STRATEGIES.includes(rawStrategy)) {
+                return {
+                    action,
+                    error: `Strategy "${rawStrategy}" is planned but not yet implemented. Available strategies: bft, raft, quorum.`,
+                    availableStrategies: ['bft', 'raft', 'quorum'],
+                };
+            }
+            const strategy = rawStrategy;
             const totalNodes = state.workers.length;
             if (action === 'propose') {
                 const proposalId = `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;

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

@@ -20,8 +20,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