monomind 1.18.13 → 1.19.0

package/packages/@monomind/cli/dist/src/commands/workflow.js

@@ -181,106 +181,6 @@ const runCommand = {
         }
     }
 };
-// Validate subcommand
-const validateCommand = {
-    name: 'validate',
-    description: 'Validate a workflow definition',
-    options: [
-        {
-            name: 'file',
-            short: 'f',
-            description: 'Workflow definition file',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'strict',
-            short: 's',
-            description: 'Strict validation mode',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind workflow validate -f ./workflow.yaml', description: 'Validate workflow file' },
-        { command: 'monomind workflow validate -f ./workflow.json --strict', description: 'Strict validation' }
-    ],
-    action: async (ctx) => {
-        const rawFile = ctx.flags.file || ctx.args[0];
-        const strict = ctx.flags.strict;
-        if (!rawFile) {
-            output.printError('Workflow file is required. Use --file or -f');
-            return { success: false, exitCode: 1 };
-        }
-        // Path traversal guard: file must stay within working directory
-        const pathMod = await import('path');
-        const effectiveCwd = ctx.cwd || process.cwd();
-        const absFile = pathMod.isAbsolute(rawFile) ? rawFile : pathMod.resolve(effectiveCwd, rawFile);
-        const resolvedFile = pathMod.resolve(absFile);
-        const resolvedCwd = pathMod.resolve(effectiveCwd);
-        if (!resolvedFile.startsWith(resolvedCwd + pathMod.sep) && resolvedFile !== resolvedCwd) {
-            output.printError('Workflow file path must be within the working directory.');
-            return { success: false, exitCode: 1 };
-        }
-        const file = resolvedFile;
-        output.printInfo(`Validating: ${file}`);
-        try {
-            const result = await callMCPTool('workflow_validate', {
-                file,
-                strict,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: result.valid, data: result };
-            }
-            output.writeln();
-            if (result.valid) {
-                output.printSuccess('Workflow is valid');
-            }
-            else {
-                output.printError('Workflow validation failed');
-            }
-            if (result.errors.length > 0) {
-                output.writeln();
-                output.writeln(output.bold(output.error('Errors')));
-                output.printTable({
-                    columns: [
-                        { key: 'line', header: 'Line', width: 8, align: 'right' },
-                        { key: 'severity', header: 'Severity', width: 10 },
-                        { key: 'message', header: 'Message', width: 50 }
-                    ],
-                    data: result.errors
-                });
-            }
-            if (result.warnings.length > 0) {
-                output.writeln();
-                output.writeln(output.bold(output.warning('Warnings')));
-                result.warnings.forEach(w => {
-                    output.writeln(output.warning(`  Line ${w.line}: ${w.message}`));
-                });
-            }
-            if (result.valid) {
-                output.writeln();
-                output.writeln(output.bold('Workflow Stats'));
-                output.printList([
-                    `Stages: ${result.stats.stages}`,
-                    `Agents Required: ${result.stats.agents}`,
-                    `Est. Duration: ${result.stats.estimatedDuration}`
-                ]);
-            }
-            return { success: result.valid, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Validation error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 // List subcommand
 const listCommand = {
     name: 'list',
@@ -437,7 +337,7 @@ const stopCommand = {
             }
         }
         try {
-            const result = await callMCPTool('workflow_stop', {
+            const result = await callMCPTool('workflow_cancel', {
                 workflowId,
                 graceful: !force,
             });
@@ -588,11 +488,10 @@ const templateCommand = {
 export const workflowCommand = {
     name: 'workflow',
     description: 'Workflow execution and management',
-    subcommands: [runCommand, validateCommand, listCommand, statusCommand, stopCommand, templateCommand],
+    subcommands: [runCommand, listCommand, statusCommand, stopCommand, templateCommand],
     options: [],
     examples: [
         { command: 'monomind workflow run -t development --task "Build feature"', description: 'Run workflow' },
-        { command: 'monomind workflow validate -f ./workflow.yaml', description: 'Validate workflow' },
         { command: 'monomind workflow list', description: 'List workflows' }
     ],
     action: async () => {
@@ -604,7 +503,6 @@ export const workflowCommand = {
         output.writeln('Subcommands:');
         output.printList([
             `${output.highlight('run')}       - Execute a workflow`,
-            `${output.highlight('validate')}  - Validate workflow definition`,
             `${output.highlight('list')}      - List workflows`,
             `${output.highlight('status')}    - Show workflow status`,
             `${output.highlight('stop')}      - Stop running workflow`,

package/packages/@monomind/cli/dist/src/index.js

@@ -423,6 +423,13 @@ export class CLI {
             await initDefaultWorkers();
         }
         catch { /* optional */ }
+        // Start the @monomind/hooks WorkerManager (performance/health/swarm/git/learning/
+        // adr/ddd/security/patterns/cache/progress) — previously implemented but never invoked
+        try {
+            const { workerManager } = await import('@monomind/hooks');
+            await workerManager.start();
+        }
+        catch { /* optional */ }
         // GAP-007: SwarmCheckpointer — write checkpoint files so crashed swarms can resume
         try {
             const { SwarmCheckpointer } = await import('@monoes/memory');

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -1414,11 +1414,6 @@ memory:
     confidenceDecayRate: 0.005
     accessBoostAmount: 0.03
     consolidationThreshold: 10
-  memoryGraph:
-    enabled: ${options.runtime.enableMemoryGraph ?? true}
-    pageRankDamping: 0.85
-    maxNodes: 5000
-    similarityThreshold: 0.8
   agentScopes:
     enabled: ${options.runtime.enableAgentScopes ?? true}
     defaultScope: project
@@ -1639,8 +1634,7 @@ Monomind is a domain-driven design architecture for multi-agent AI coordination
 | Memory Backend | ${options.runtime.memoryBackend} |
 | HNSW Indexing | ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'} |
 | Neural Learning | ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'} |
-| LearningBridge | ${options.runtime.enableLearningBridge ? 'Enabled (ReasoningBank)' : 'Disabled'} |
-| Knowledge Graph | ${options.runtime.enableMemoryGraph ? 'Enabled (PageRank + Communities)' : 'Disabled'} |
+| Learning | ${options.runtime.enableLearningBridge ? 'Enabled' : 'Disabled'} |
 | Agent Scopes | ${options.runtime.enableAgentScopes ? 'Enabled (project/local/user)' : 'Disabled'} |
 
 ---
@@ -1743,8 +1737,6 @@ npx monomind@latest swarm monitor
 | \`security\` | 6 | Security scanning |
 | \`performance\` | 5 | Profiling & benchmarks |
 | \`providers\` | 5 | AI provider config |
-
-| \`deployment\` | 5 | Deploy management |
 | \`embeddings\` | 4 | Vector embeddings |
 | \`claims\` | 4 | Authorization |
 | \`migrate\` | 5 | V2→V1 migration |
@@ -1841,13 +1833,10 @@ and command outcomes are recorded and scored so routing quality is measured.
 
 | Component | Status | Description |
 |-----------|--------|-------------|
-| **LearningBridge** | ${options.runtime.enableLearningBridge ? '✅ Enabled' : '⏸ Disabled'} | Connects insights to the ReasoningBank pattern store |
-| **MemoryGraph** | ${options.runtime.enableMemoryGraph ? '✅ Enabled' : '⏸ Disabled'} | PageRank knowledge graph + community detection |
+| **Learning** | ${options.runtime.enableLearningBridge ? '✅ Enabled' : '⏸ Disabled'} | Connects insights to the pattern store |
 | **AgentMemoryScope** | ${options.runtime.enableAgentScopes ? '✅ Enabled' : '⏸ Disabled'} | 3-scope agent memory (project/local/user) |
 
-**LearningBridge** - Insights trigger learning trajectories. Confidence evolves: +0.03 on access, -0.005/hour decay. Consolidation runs the JUDGE/DISTILL/CONSOLIDATE pipeline.
-
-**MemoryGraph** - Builds a knowledge graph from entry references. PageRank identifies influential insights. Communities group related knowledge. Graph-aware ranking blends vector + structural scores.
+**Learning** — Insights trigger learning trajectories. Confidence evolves: +0.03 on access, -0.005/hour decay.
 
 **AgentMemoryScope** - Maps Claude Code 3-scope directories:
 - \`project\`: \`<gitRoot>/.claude/agent-memory/<agent>/\`

package/packages/@monomind/cli/dist/src/init/helpers-generator.js

@@ -933,31 +933,11 @@ async function loadMemoryPackage() {
 }
 
 async function doImport() {
-  const memPkg = await loadMemoryPackage();
-
-  if (!memPkg || !memPkg.AutoMemoryBridge) {
-    dim('Memory package not available — auto memory import skipped (non-critical)');
-    return;
-  }
-
-  // Full implementation deferred to copied version
-  dim('Auto memory import available — run init --upgrade for full support');
+  dim('Auto memory import skipped — AutoMemoryBridge removed');
 }
 
 async function doSync() {
-  if (!existsSync(STORE_PATH)) {
-    dim('No entries to sync');
-    return;
-  }
-
-  const memPkg = await loadMemoryPackage();
-
-  if (!memPkg || !memPkg.AutoMemoryBridge) {
-    dim('Memory package not available — sync skipped (non-critical)');
-    return;
-  }
-
-  dim('Auto memory sync available — run init --upgrade for full support');
+  dim('Auto memory sync skipped — AutoMemoryBridge removed');
 }
 
 function doStatus() {

package/packages/@monomind/cli/dist/src/init/settings-generator.js

@@ -100,7 +100,6 @@ export function generateSettings(options) {
             backend: options.runtime.memoryBackend,
             enableHNSW: options.runtime.enableHNSW,
             learningBridge: { enabled: options.runtime.enableLearningBridge ?? true },
-            memoryGraph: { enabled: options.runtime.enableMemoryGraph ?? true },
             agentScopes: { enabled: options.runtime.enableAgentScopes ?? true },
         },
         neural: {

package/packages/@monomind/cli/dist/src/init/types.d.ts

@@ -197,10 +197,8 @@ export interface RuntimeConfig {
     enableHNSW: boolean;
     /** Enable neural learning */
     enableNeural: boolean;
-    /** Enable LearningBridge (ADR-049) - connects insights to the ReasoningBank pattern store */
+    /** Enable learning system - connects insights to the pattern store */
     enableLearningBridge?: boolean;
-    /** Enable MemoryGraph (ADR-049) - PageRank knowledge graph */
-    enableMemoryGraph?: boolean;
     /** Enable AgentMemoryScope (ADR-049) - 3-scope agent memory */
     enableAgentScopes?: boolean;
     /** CLAUDE.md template variant */

package/packages/@monomind/cli/dist/src/init/types.js

@@ -123,7 +123,6 @@ export const DEFAULT_INIT_OPTIONS = {
         enableHNSW: true,
         enableNeural: true,
         enableLearningBridge: true,
-        enableMemoryGraph: true,
         enableAgentScopes: true,
     },
     embeddings: {
@@ -187,7 +186,6 @@ export const MINIMAL_INIT_OPTIONS = {
         enableHNSW: false,
         enableNeural: false,
         enableLearningBridge: false,
-        enableMemoryGraph: false,
         enableAgentScopes: false,
     },
     embeddings: {

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

@@ -29,7 +29,6 @@ import { neuralTools } from './mcp-tools/neural-tools.js';
 import { performanceTools } from './mcp-tools/performance-tools.js';
 import { githubTools } from './mcp-tools/github-tools.js';
 import { daaTools } from './mcp-tools/daa-tools.js';
-import { coordinationTools } from './mcp-tools/coordination-tools.js';
 import { browserTools } from './mcp-tools/browser-tools.js';
 import { guidanceTools } from './mcp-tools/guidance-tools.js';
 import { autopilotTools } from './mcp-tools/autopilot-tools.js';
@@ -38,8 +37,6 @@ import { graphifyTools } from './mcp-tools/graphify-tools.js';
 import { monographTools } from './mcp-tools/monograph-tools.js';
 // Coverage-aware routing tools
 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 and Coherence core tools
 import { qualityTools } from './mcp-tools/quality-tools.js';
 import { coherenceTools } from './mcp-tools/coherence-tools.js';
@@ -82,7 +79,6 @@ registerTools([
     ...performanceTools,
     ...githubTools,
     ...daaTools,
-    ...coordinationTools,
     ...browserTools,
     // Guidance & discovery tools
     ...guidanceTools,
@@ -94,8 +90,6 @@ registerTools([
     ...graphifyTools,
     // Coverage-aware routing tools
     ...coverageRouterTools,
-    // A2A Agent Card protocol (source: https://a2a-protocol.org)
-    ...a2aTools,
     // Quality tools
     ...qualityTools,
     // Coherence tools

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

@@ -464,6 +464,22 @@ export class MCPServerManager extends EventEmitter {
                     }
                     const toolName = params.name;
                     const toolParams = (rawArgs || {});
+                    // validateInput boundary: sanitize the incoming tool name
+                    try {
+                        const secMod = await import('@monomind/security').catch(() => null);
+                        const validateInput = secMod?.validateInput;
+                        if (validateInput) {
+                            const check = validateInput(toolName, { type: 'string', maxLength: 200 });
+                            if (!check.valid) {
+                                return {
+                                    jsonrpc: '2.0',
+                                    id: message.id,
+                                    error: { code: -32602, message: `Invalid tool name: ${check.error}` },
+                                };
+                            }
+                        }
+                    }
+                    catch { /* security module optional */ }
                     if (!hasTool(toolName)) {
                         return {
                             jsonrpc: '2.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/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'],