monomind 2.7.4 → 2.7.5

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

@@ -1,15 +0,0 @@
-/**
- * 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

@@ -1,188 +0,0 @@
-/**
- * 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 { cosineSimilarity } from '../../utils/cosine-similarity.js';
-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;
-}
-/**
- * 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

@@ -1,14 +0,0 @@
-/**
- * Consensus Verification Tool - pr_consensus_verify
- *
- * Verifies multi-agent consensus using cosine-similarity coherence analysis.
- * Identifies divergent agents and measures agreement ratios.
- * Connectivity stability uses a degree-ratio heuristic (not spectral decomposition).
- */
-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

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

@@ -1,305 +0,0 @@
-/**
- * Consensus Verification Tool - pr_consensus_verify
- *
- * Verifies multi-agent consensus using cosine-similarity coherence analysis.
- * Identifies divergent agents and measures agreement ratios.
- * Connectivity stability uses a degree-ratio heuristic (not spectral decomposition).
- */
-import { ConsensusInputSchema, successResult, errorResult, cosineSimilarity, } from './types.js';
-// Default logger
-const defaultLogger = {
-    debug: (msg, meta) => console.debug(`[pr_consensus_verify] ${msg}`, meta),
-    info: (msg, meta) => console.info(`[pr_consensus_verify] ${msg}`, meta),
-    warn: (msg, meta) => console.warn(`[pr_consensus_verify] ${msg}`, meta),
-    error: (msg, meta) => console.error(`[pr_consensus_verify] ${msg}`, meta),
-};
-// ============================================================================
-// Consensus Analysis Functions
-// ============================================================================
-/**
- * Compute pairwise similarity matrix
- */
-function computeSimilarityMatrix(embeddings) {
-    const n = embeddings.length;
-    const matrix = [];
-    for (let i = 0; i < n; i++) {
-        const row = [];
-        const embi = embeddings[i];
-        for (let j = 0; j < n; j++) {
-            const embj = embeddings[j];
-            row.push(cosineSimilarity(embi, embj));
-        }
-        matrix.push(row);
-    }
-    return matrix;
-}
-/**
- * Compute coherence energy using Sheaf Laplacian approach
- */
-function computeCoherenceEnergy(embeddings) {
-    if (embeddings.length < 2)
-        return 0;
-    const n = embeddings.length;
-    let totalDisagreement = 0;
-    let edgeCount = 0;
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            const embi = embeddings[i];
-            const embj = embeddings[j];
-            const similarity = cosineSimilarity(embi, embj);
-            const disagreement = 1 - Math.max(0, similarity);
-            totalDisagreement += disagreement;
-            edgeCount++;
-        }
-    }
-    return edgeCount > 0 ? totalDisagreement / edgeCount : 0;
-}
-/**
- * Identify divergent agents whose embeddings differ significantly from the group
- */
-function identifyDivergentAgents(agentStates, threshold) {
-    if (agentStates.length < 2)
-        return [];
-    const embeddings = agentStates.map(s => s.embedding);
-    const n = embeddings.length;
-    const divergentAgents = [];
-    // Compute centroid
-    const firstEmb = embeddings[0];
-    if (!firstEmb)
-        return [];
-    const dim = firstEmb.length;
-    const centroid = new Array(dim).fill(0);
-    for (const emb of embeddings) {
-        for (let d = 0; d < dim; d++) {
-            const val = emb[d];
-            if (val !== undefined) {
-                centroid[d] = (centroid[d] ?? 0) + val / n;
-            }
-        }
-    }
-    // Find agents far from centroid
-    for (let i = 0; i < n; i++) {
-        const embi = embeddings[i];
-        const agentState = agentStates[i];
-        const similarity = cosineSimilarity(embi, centroid);
-        if (similarity < threshold) {
-            divergentAgents.push(agentState.agentId);
-        }
-    }
-    return divergentAgents;
-}
-/**
- * Compute vote-based agreement ratio
- */
-function computeVoteAgreement(agentStates) {
-    const votes = agentStates.filter(s => s.vote !== undefined).map(s => s.vote);
-    if (votes.length < 2)
-        return 1;
-    // Count vote frequencies
-    const voteCounts = new Map();
-    for (const vote of votes) {
-        voteCounts.set(vote, (voteCounts.get(vote) || 0) + 1);
-    }
-    // Agreement is based on majority
-    const values = Array.from(voteCounts.values());
-    const maxCount = values.length > 0 ? Math.max(...values) : 0;
-    return maxCount / votes.length;
-}
-/**
- * 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 computeConnectivityStability(similarityMatrix) {
-    const n = similarityMatrix.length;
-    if (n < 2)
-        return { stable: true, degreeRatio: 1 };
-    // Convert similarity to adjacency (threshold at 0.5)
-    const adjacency = [];
-    for (let i = 0; i < n; i++) {
-        const row = [];
-        const simRow = similarityMatrix[i];
-        for (let j = 0; j < n; j++) {
-            const simVal = simRow[j] ?? 0;
-            row.push(simVal > 0.5 ? simVal : 0);
-        }
-        adjacency.push(row);
-    }
-    // Compute degrees
-    const degrees = [];
-    for (let i = 0; i < n; i++) {
-        let degree = 0;
-        const adjRow = adjacency[i];
-        for (let j = 0; j < n; j++) {
-            degree += adjRow[j] ?? 0;
-        }
-        degrees.push(degree);
-    }
-    const avgDegree = degrees.reduce((a, b) => a + b, 0) / n;
-    const maxDegree = Math.max(...degrees);
-    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, 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 (!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';
-    }
-    return `Consensus not achieved - ${divergentAgents.length} divergent agent(s) detected`;
-}
-/**
- * Handler for pr_consensus_verify tool
- */
-async function handler(input, context) {
-    const logger = context?.logger ?? defaultLogger;
-    const startTime = performance.now();
-    try {
-        // Validate input
-        const validationResult = ConsensusInputSchema.safeParse(input);
-        if (!validationResult.success) {
-            logger.error('Input validation failed', { error: validationResult.error.message });
-            return errorResult(`Invalid input: ${validationResult.error.message}`);
-        }
-        const { agentStates, threshold } = validationResult.data;
-        logger.debug('Processing consensus verification', {
-            agentCount: agentStates.length,
-            threshold,
-        });
-        if (agentStates.length === 0) {
-            return errorResult('No agent states provided');
-        }
-        // Validate embedding dimensions are consistent
-        const firstDim = agentStates[0].embedding.length;
-        for (let i = 1; i < agentStates.length; i++) {
-            if (agentStates[i].embedding.length !== firstDim) {
-                return errorResult(`Embedding dimension mismatch: agent ${agentStates[i].agentId} has ` +
-                    `${agentStates[i].embedding.length} dimensions, expected ${firstDim}`);
-            }
-        }
-        const embeddings = agentStates.map(s => s.embedding);
-        let coherenceEnergy;
-        let divergentAgents;
-        // Try to use WASM bridge if available
-        if (context?.bridge?.initialized) {
-            try {
-                logger.debug('Using WASM bridge for coherence check');
-                const float32Embeddings = embeddings.map(e => new Float32Array(e));
-                const result = await context.bridge.checkCoherence(float32Embeddings);
-                coherenceEnergy = result.energy;
-                // WASM doesn't return divergent agents, compute separately
-                divergentAgents = identifyDivergentAgents(agentStates, threshold);
-            }
-            catch (wasmError) {
-                logger.warn('WASM bridge failed, falling back to JS implementation', {
-                    error: wasmError instanceof Error ? wasmError.message : String(wasmError),
-                });
-                coherenceEnergy = computeCoherenceEnergy(embeddings);
-                divergentAgents = identifyDivergentAgents(agentStates, threshold);
-            }
-        }
-        else {
-            // Pure JavaScript fallback
-            logger.debug('Using JavaScript fallback for consensus verification');
-            coherenceEnergy = computeCoherenceEnergy(embeddings);
-            divergentAgents = identifyDivergentAgents(agentStates, threshold);
-        }
-        // Compute additional metrics
-        const similarityMatrix = computeSimilarityMatrix(embeddings);
-        const { stable: connectivityStable, degreeRatio } = computeConnectivityStability(similarityMatrix);
-        const voteAgreement = computeVoteAgreement(agentStates);
-        // Coherence score is inverse of energy
-        const coherenceScore = 1 - coherenceEnergy;
-        // Agreement ratio combines embedding coherence and vote agreement
-        const agreementRatio = (coherenceScore + voteAgreement) / 2;
-        // Consensus is verified if agreement exceeds threshold and no major divergence
-        const verified = agreementRatio >= threshold &&
-            divergentAgents.length <= Math.floor(agentStates.length * 0.2); // Allow 20% minority
-        const output = {
-            verified,
-            coherenceScore,
-            divergentAgents,
-            details: {
-                agreementRatio,
-                coherenceEnergy,
-                connectivityStable,
-                degreeRatio,
-                interpretation: getInterpretation(verified, coherenceScore, divergentAgents, connectivityStable),
-                agentCount: agentStates.length,
-            },
-        };
-        const duration = performance.now() - startTime;
-        logger.info('Consensus verification completed', {
-            verified,
-            coherenceScore: coherenceScore.toFixed(4),
-            divergentAgents: divergentAgents.length,
-            durationMs: duration.toFixed(2),
-        });
-        return successResult(output);
-    }
-    catch (error) {
-        const duration = performance.now() - startTime;
-        logger.error('Consensus verification failed', {
-            error: error instanceof Error ? error.message : String(error),
-            durationMs: duration.toFixed(2),
-        });
-        return errorResult(error instanceof Error ? error : new Error(String(error)));
-    }
-}
-/**
- * pr_consensus_verify MCP Tool Definition
- */
-export const consensusVerifyTool = {
-    name: 'pr_consensus_verify',
-    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'],
-    cacheable: false, // Agent states change frequently
-    inputSchema: {
-        type: 'object',
-        properties: {
-            agentStates: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        agentId: { type: 'string', description: 'Unique agent identifier' },
-                        embedding: {
-                            type: 'array',
-                            items: { type: 'number' },
-                            description: 'Agent state embedding vector',
-                        },
-                        vote: { type: 'string', description: 'Agent vote or decision' },
-                        metadata: { type: 'object', description: 'Additional agent metadata' },
-                    },
-                    required: ['agentId', 'embedding'],
-                },
-                description: 'Array of agent states to verify consensus',
-            },
-            threshold: {
-                type: 'number',
-                default: 0.8,
-                description: 'Required agreement threshold (0-1)',
-            },
-        },
-        required: ['agentStates'],
-    },
-    handler,
-};
-export default consensusVerifyTool;
-//# sourceMappingURL=consensus-verify.js.map

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

@@ -1,16 +0,0 @@
-/**
- * Memory Gate Tool - pr_memory_gate
- *
- * Pre-storage coherence gate for memory entries.
- * Validates that new entries are coherent with existing context before storage.
- * 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';
-/**
- * pr_memory_gate MCP Tool Definition
- */
-export declare const memoryGateTool: MCPTool;
-export default memoryGateTool;
-//# sourceMappingURL=memory-gate.d.ts.map