agentic-qe 3.2.2 → 3.3.0

package/v3/dist/mcp/tools/coherence/audit.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Agentic QE v3 - Coherence Audit Memory MCP Tool
+ * ADR-052: Phase 4 Action A4.1
+ *
+ * qe/coherence/audit - Audit QE memory for contradictions
+ *
+ * Uses the MemoryCoherenceAuditor to scan QE patterns for coherence issues,
+ * detecting contradictions and generating remediation recommendations.
+ */
+import { MCPToolBase, MCPToolConfig, MCPToolContext } from '../base.js';
+import { ToolResult } from '../../types.js';
+/**
+ * Parameters for memory audit
+ */
+export interface CoherenceAuditParams {
+    /** Namespace to audit (default: 'qe-patterns') */
+    namespace?: string;
+    /** Maximum patterns to scan (default: 1000) */
+    maxPatterns?: number;
+    /** Energy threshold for flagging issues (default: 0.4) */
+    energyThreshold?: number;
+    /** Include detailed pattern information in results */
+    includeDetails?: boolean;
+    /** Index signature for Record<string, unknown> compatibility */
+    [key: string]: unknown;
+}
+/**
+ * Result of memory audit
+ */
+export interface CoherenceAuditResult {
+    /** Total number of patterns in the database */
+    totalPatterns: number;
+    /** Number of patterns scanned in this audit */
+    scannedPatterns: number;
+    /** Number of contradictions found */
+    contradictionCount: number;
+    /** Overall coherence energy (lower = more coherent) */
+    globalEnergy: number;
+    /** High-energy domains requiring attention */
+    hotspots: Array<{
+        domain: string;
+        patternIds: string[];
+        energy: number;
+        description: string;
+    }>;
+    /** Actionable recommendations */
+    recommendations: Array<{
+        type: 'merge' | 'remove' | 'review' | 'split';
+        patternIds: string[];
+        reason: string;
+        priority: 'low' | 'medium' | 'high';
+    }>;
+    /** Audit duration in milliseconds */
+    durationMs: number;
+    /** Audit timestamp */
+    timestamp: string;
+    /** Memory health score (0-100, higher = healthier) */
+    healthScore: number;
+}
+/**
+ * Coherence Audit Memory Tool
+ *
+ * Scans QE patterns for coherence issues using Prime Radiant:
+ * - Detects contradictory patterns
+ * - Identifies duplicate/overlapping patterns
+ * - Flags outdated patterns with low usage
+ * - Generates remediation recommendations
+ *
+ * @example
+ * ```typescript
+ * const result = await tool.invoke({
+ *   namespace: 'qe-patterns',
+ *   maxPatterns: 500,
+ *   energyThreshold: 0.5,
+ * });
+ *
+ * console.log(`Health Score: ${result.data.healthScore}/100`);
+ * console.log('Hotspots:', result.data.hotspots);
+ * console.log('Recommendations:', result.data.recommendations);
+ * ```
+ */
+export declare class CoherenceAuditTool extends MCPToolBase<CoherenceAuditParams, CoherenceAuditResult> {
+    readonly config: MCPToolConfig;
+    private coherenceService;
+    private auditor;
+    /**
+     * Get or create the CoherenceService instance
+     */
+    private getService;
+    /**
+     * Reset instance cache (called when fleet is disposed)
+     */
+    resetInstanceCache(): void;
+    /**
+     * Execute the memory audit
+     */
+    execute(params: CoherenceAuditParams, context: MCPToolContext): Promise<ToolResult<CoherenceAuditResult>>;
+    /**
+     * Calculate memory health score (0-100)
+     */
+    private calculateHealthScore;
+}
+/**
+ * Create a CoherenceAuditTool instance
+ */
+export declare function createCoherenceAuditTool(): CoherenceAuditTool;
+//# sourceMappingURL=audit.d.ts.map

package/v3/dist/mcp/tools/coherence/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tools/coherence/audit.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,WAAW,EACX,aAAa,EACb,cAAc,EAGf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAsB5C;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sDAAsD;IACtD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,gEAAgE;IAChE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,aAAa,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,eAAe,EAAE,MAAM,CAAC;IACxB,qCAAqC;IACrC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uDAAuD;IACvD,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,QAAQ,EAAE,KAAK,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;IACH,iCAAiC;IACjC,eAAe,EAAE,KAAK,CAAC;QACrB,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;QAC9C,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;KACrC,CAAC,CAAC;IACH,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;CACrB;AAyCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,kBAAmB,SAAQ,WAAW,CACjD,oBAAoB,EACpB,oBAAoB,CACrB;IACC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAS5B;IAEF,OAAO,CAAC,gBAAgB,CAAiC;IACzD,OAAO,CAAC,OAAO,CAAuC;IAEtD;;OAEG;YACW,UAAU;IAOxB;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAQ1B;;OAEG;IACG,OAAO,CACX,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC;IA+H5C;;OAEG;IACH,OAAO,CAAC,oBAAoB;CAoB7B;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAE7D"}

package/v3/dist/mcp/tools/coherence/audit.js

@@ -0,0 +1,236 @@
+/**
+ * Agentic QE v3 - Coherence Audit Memory MCP Tool
+ * ADR-052: Phase 4 Action A4.1
+ *
+ * qe/coherence/audit - Audit QE memory for contradictions
+ *
+ * Uses the MemoryCoherenceAuditor to scan QE patterns for coherence issues,
+ * detecting contradictions and generating remediation recommendations.
+ */
+import { MCPToolBase, getSharedMemoryBackend, } from '../base.js';
+import { createCoherenceService, wasmLoader, } from '../../../integrations/coherence/index.js';
+import { createMemoryAuditor, } from '../../../learning/index.js';
+import { createPatternStore, } from '../../../learning/index.js';
+// ============================================================================
+// Schema
+// ============================================================================
+const COHERENCE_AUDIT_SCHEMA = {
+    type: 'object',
+    properties: {
+        namespace: {
+            type: 'string',
+            description: 'Namespace to audit (default: qe-patterns)',
+            default: 'qe-patterns',
+        },
+        maxPatterns: {
+            type: 'number',
+            description: 'Maximum patterns to scan (default: 1000)',
+            default: 1000,
+            minimum: 1,
+            maximum: 10000,
+        },
+        energyThreshold: {
+            type: 'number',
+            description: 'Energy threshold for flagging issues (default: 0.4)',
+            default: 0.4,
+            minimum: 0,
+            maximum: 1,
+        },
+        includeDetails: {
+            type: 'boolean',
+            description: 'Include detailed pattern information in results',
+            default: false,
+        },
+    },
+    required: [],
+};
+// ============================================================================
+// Tool Implementation
+// ============================================================================
+/**
+ * Coherence Audit Memory Tool
+ *
+ * Scans QE patterns for coherence issues using Prime Radiant:
+ * - Detects contradictory patterns
+ * - Identifies duplicate/overlapping patterns
+ * - Flags outdated patterns with low usage
+ * - Generates remediation recommendations
+ *
+ * @example
+ * ```typescript
+ * const result = await tool.invoke({
+ *   namespace: 'qe-patterns',
+ *   maxPatterns: 500,
+ *   energyThreshold: 0.5,
+ * });
+ *
+ * console.log(`Health Score: ${result.data.healthScore}/100`);
+ * console.log('Hotspots:', result.data.hotspots);
+ * console.log('Recommendations:', result.data.recommendations);
+ * ```
+ */
+export class CoherenceAuditTool extends MCPToolBase {
+    config = {
+        name: 'qe/coherence/audit',
+        description: 'Audit QE memory for contradictions and coherence issues. ' +
+            'Scans patterns, detects hotspots, and generates remediation recommendations.',
+        domain: 'learning-optimization',
+        schema: COHERENCE_AUDIT_SCHEMA,
+        streaming: false,
+        timeout: 60000,
+    };
+    coherenceService = null;
+    auditor = null;
+    /**
+     * Get or create the CoherenceService instance
+     */
+    async getService() {
+        if (!this.coherenceService) {
+            this.coherenceService = await createCoherenceService(wasmLoader);
+        }
+        return this.coherenceService;
+    }
+    /**
+     * Reset instance cache (called when fleet is disposed)
+     */
+    resetInstanceCache() {
+        if (this.coherenceService) {
+            this.coherenceService.dispose();
+            this.coherenceService = null;
+        }
+        this.auditor = null;
+    }
+    /**
+     * Execute the memory audit
+     */
+    async execute(params, context) {
+        const { namespace = 'qe-patterns', maxPatterns = 1000, energyThreshold = 0.4, } = params;
+        try {
+            // Get coherence service
+            const service = await this.getService();
+            // Create auditor if not exists
+            if (!this.auditor) {
+                this.auditor = createMemoryAuditor(service, undefined, {
+                    energyThreshold,
+                    hotspotThreshold: energyThreshold + 0.2,
+                    maxRecommendations: 10,
+                });
+            }
+            // Get memory backend and fetch patterns
+            const memory = await getSharedMemoryBackend();
+            const patternStore = createPatternStore(memory, {
+                namespace,
+                embeddingDimension: 128,
+            });
+            await patternStore.initialize();
+            // Search for all patterns (empty query returns all)
+            const searchResult = await patternStore.search('', {
+                limit: maxPatterns,
+                useVectorSearch: false,
+            });
+            const patterns = searchResult.success
+                ? searchResult.value.map((r) => r.pattern)
+                : [];
+            // Run audit if we have patterns
+            let auditResult;
+            if (patterns.length > 0) {
+                auditResult = await this.auditor.auditPatterns(patterns);
+            }
+            else {
+                // No patterns - return empty audit
+                auditResult = {
+                    totalPatterns: 0,
+                    scannedPatterns: 0,
+                    contradictionCount: 0,
+                    globalEnergy: 0,
+                    hotspots: [],
+                    recommendations: [],
+                    duration: 0,
+                    timestamp: new Date(),
+                };
+            }
+            // Calculate health score (0-100)
+            const healthScore = this.calculateHealthScore(auditResult);
+            this.markAsRealData();
+            return {
+                success: true,
+                data: {
+                    totalPatterns: auditResult.totalPatterns,
+                    scannedPatterns: auditResult.scannedPatterns,
+                    contradictionCount: auditResult.contradictionCount,
+                    globalEnergy: auditResult.globalEnergy,
+                    hotspots: auditResult.hotspots.map((h) => ({
+                        domain: h.domain,
+                        patternIds: h.patternIds,
+                        energy: h.energy,
+                        description: h.description,
+                    })),
+                    recommendations: auditResult.recommendations.map((r) => ({
+                        type: r.type,
+                        patternIds: r.patternIds,
+                        reason: r.reason,
+                        priority: r.priority,
+                    })),
+                    durationMs: auditResult.duration,
+                    timestamp: auditResult.timestamp.toISOString(),
+                    healthScore,
+                },
+            };
+        }
+        catch (error) {
+            // Check if WASM is unavailable - provide graceful fallback
+            if (error instanceof Error &&
+                error.message.includes('WASM')) {
+                this.markAsDemoData(context, 'WASM module unavailable');
+                return {
+                    success: true,
+                    data: {
+                        totalPatterns: 0,
+                        scannedPatterns: 0,
+                        contradictionCount: 0,
+                        globalEnergy: 0,
+                        hotspots: [],
+                        recommendations: [
+                            {
+                                type: 'review',
+                                patternIds: [],
+                                reason: 'WASM module unavailable - install prime-radiant-advanced-wasm for full audit',
+                                priority: 'medium',
+                            },
+                        ],
+                        durationMs: 0,
+                        timestamp: new Date().toISOString(),
+                        healthScore: 100,
+                    },
+                };
+            }
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Calculate memory health score (0-100)
+     */
+    calculateHealthScore(result) {
+        let score = 100;
+        // Deduct for contradictions
+        score -= Math.min(30, result.contradictionCount * 5);
+        // Deduct for high energy
+        score -= Math.min(30, result.globalEnergy * 50);
+        // Deduct for hotspots
+        score -= Math.min(20, result.hotspots.length * 5);
+        // Deduct for critical recommendations
+        const criticalCount = result.recommendations.filter((r) => r.priority === 'high').length;
+        score -= Math.min(20, criticalCount * 5);
+        return Math.max(0, Math.round(score));
+    }
+}
+/**
+ * Create a CoherenceAuditTool instance
+ */
+export function createCoherenceAuditTool() {
+    return new CoherenceAuditTool();
+}
+//# sourceMappingURL=audit.js.map

package/v3/dist/mcp/tools/coherence/audit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.js","sourceRoot":"","sources":["../../../../src/mcp/tools/coherence/audit.ts"],"names":[],"mappings":"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"}

package/v3/dist/mcp/tools/coherence/check.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Agentic QE v3 - Coherence Check MCP Tool
+ * ADR-052: Phase 4 Action A4.1
+ *
+ * qe/coherence/check - Check coherence of beliefs/facts using Prime Radiant
+ *
+ * Uses the CoherenceService to verify mathematical coherence of a set of nodes,
+ * detecting contradictions and computing the overall coherence energy.
+ */
+import { MCPToolBase, MCPToolConfig, MCPToolContext } from '../base.js';
+import { ToolResult } from '../../types.js';
+import { type ComputeLane } from '../../../integrations/coherence/index.js';
+/**
+ * Parameters for coherence check
+ */
+export interface CoherenceCheckParams {
+    /** Nodes to check for coherence - each node has id, embedding, and optional weight/metadata */
+    nodes: Array<{
+        /** Unique identifier for the node */
+        id: string;
+        /** Embedding vector (array of numbers) */
+        embedding: number[];
+        /** Optional weight (0-1, defaults to 1.0) */
+        weight?: number;
+        /** Optional metadata */
+        metadata?: Record<string, unknown>;
+    }>;
+    /** Optional custom energy threshold for contradiction detection (default: 0.4) */
+    energyThreshold?: number;
+    /** Index signature for Record<string, unknown> compatibility */
+    [key: string]: unknown;
+}
+/**
+ * Result of coherence check
+ */
+export interface CoherenceCheckResult {
+    /** Whether the nodes are coherent */
+    isCoherent: boolean;
+    /** Computed coherence energy (lower = more coherent) */
+    energy: number;
+    /** Compute lane based on energy threshold */
+    lane: ComputeLane;
+    /** Detected contradictions */
+    contradictions: Array<{
+        /** IDs of the contradicting nodes */
+        nodeIds: [string, string];
+        /** Severity of the contradiction */
+        severity: string;
+        /** Human-readable description */
+        description: string;
+    }>;
+    /** Recommendations for resolving incoherence */
+    recommendations: string[];
+    /** Number of nodes analyzed */
+    nodeCount: number;
+    /** Execution time in milliseconds */
+    executionTimeMs: number;
+    /** Whether fallback logic was used */
+    usedFallback: boolean;
+}
+/**
+ * Coherence Check Tool
+ *
+ * Uses Prime Radiant's sheaf cohomology engine to verify mathematical
+ * coherence of a set of nodes/beliefs.
+ *
+ * @example
+ * ```typescript
+ * const result = await tool.invoke({
+ *   nodes: [
+ *     { id: 'belief-1', embedding: [0.1, 0.2, ...], weight: 0.9 },
+ *     { id: 'belief-2', embedding: [0.3, 0.1, ...], weight: 0.8 },
+ *   ],
+ *   energyThreshold: 0.4,
+ * });
+ *
+ * if (!result.data.isCoherent) {
+ *   console.log('Contradictions found:', result.data.contradictions);
+ * }
+ * ```
+ */
+export declare class CoherenceCheckTool extends MCPToolBase<CoherenceCheckParams, CoherenceCheckResult> {
+    readonly config: MCPToolConfig;
+    private coherenceService;
+    /**
+     * Get or create the CoherenceService instance
+     */
+    private getService;
+    /**
+     * Reset instance cache (called when fleet is disposed)
+     */
+    resetInstanceCache(): void;
+    /**
+     * Execute the coherence check
+     */
+    execute(params: CoherenceCheckParams, context: MCPToolContext): Promise<ToolResult<CoherenceCheckResult>>;
+    /**
+     * Generate additional recommendations based on coherence results
+     */
+    private generateAdditionalRecommendations;
+}
+/**
+ * Create a CoherenceCheckTool instance
+ */
+export declare function createCoherenceCheckTool(): CoherenceCheckTool;
+//# sourceMappingURL=check.d.ts.map

package/v3/dist/mcp/tools/coherence/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tools/coherence/check.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,WAAW,EACX,aAAa,EACb,cAAc,EAEf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAML,KAAK,WAAW,EACjB,MAAM,0CAA0C,CAAC;AAMlD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,+FAA+F;IAC/F,KAAK,EAAE,KAAK,CAAC;QACX,qCAAqC;QACrC,EAAE,EAAE,MAAM,CAAC;QACX,0CAA0C;QAC1C,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,6CAA6C;QAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,wBAAwB;QACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACpC,CAAC,CAAC;IACH,kFAAkF;IAClF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,qCAAqC;IACrC,UAAU,EAAE,OAAO,CAAC;IACpB,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,IAAI,EAAE,WAAW,CAAC;IAClB,8BAA8B;IAC9B,cAAc,EAAE,KAAK,CAAC;QACpB,qCAAqC;QACrC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC1B,oCAAoC;QACpC,QAAQ,EAAE,MAAM,CAAC;QACjB,iCAAiC;QACjC,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;IACH,gDAAgD;IAChD,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,sCAAsC;IACtC,YAAY,EAAE,OAAO,CAAC;CACvB;AA6BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,kBAAmB,SAAQ,WAAW,CACjD,oBAAoB,EACpB,oBAAoB,CACrB;IACC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAS5B;IAEF,OAAO,CAAC,gBAAgB,CAAiC;IAEzD;;OAEG;YACW,UAAU;IAOxB;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAO1B;;OAEG;IACG,OAAO,CACX,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC;IAuG5C;;OAEG;IACH,OAAO,CAAC,iCAAiC;CAiC1C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAE7D"}

package/v3/dist/mcp/tools/coherence/check.js

@@ -0,0 +1,205 @@
+/**
+ * Agentic QE v3 - Coherence Check MCP Tool
+ * ADR-052: Phase 4 Action A4.1
+ *
+ * qe/coherence/check - Check coherence of beliefs/facts using Prime Radiant
+ *
+ * Uses the CoherenceService to verify mathematical coherence of a set of nodes,
+ * detecting contradictions and computing the overall coherence energy.
+ */
+import { MCPToolBase, } from '../base.js';
+import { createCoherenceService, wasmLoader, } from '../../../integrations/coherence/index.js';
+// ============================================================================
+// Schema
+// ============================================================================
+const COHERENCE_CHECK_SCHEMA = {
+    type: 'object',
+    properties: {
+        nodes: {
+            type: 'array',
+            description: 'Array of nodes to check for coherence. Each node must have an id and embedding vector.',
+        },
+        energyThreshold: {
+            type: 'number',
+            description: 'Custom energy threshold for contradiction detection (default: 0.4)',
+            minimum: 0,
+            maximum: 1,
+        },
+    },
+    required: ['nodes'],
+};
+// ============================================================================
+// Tool Implementation
+// ============================================================================
+/**
+ * Coherence Check Tool
+ *
+ * Uses Prime Radiant's sheaf cohomology engine to verify mathematical
+ * coherence of a set of nodes/beliefs.
+ *
+ * @example
+ * ```typescript
+ * const result = await tool.invoke({
+ *   nodes: [
+ *     { id: 'belief-1', embedding: [0.1, 0.2, ...], weight: 0.9 },
+ *     { id: 'belief-2', embedding: [0.3, 0.1, ...], weight: 0.8 },
+ *   ],
+ *   energyThreshold: 0.4,
+ * });
+ *
+ * if (!result.data.isCoherent) {
+ *   console.log('Contradictions found:', result.data.contradictions);
+ * }
+ * ```
+ */
+export class CoherenceCheckTool extends MCPToolBase {
+    config = {
+        name: 'qe/coherence/check',
+        description: 'Check mathematical coherence of beliefs/facts using Prime Radiant sheaf cohomology. ' +
+            'Detects contradictions and computes coherence energy for multi-agent coordination.',
+        domain: 'learning-optimization',
+        schema: COHERENCE_CHECK_SCHEMA,
+        streaming: false,
+        timeout: 30000,
+    };
+    coherenceService = null;
+    /**
+     * Get or create the CoherenceService instance
+     */
+    async getService() {
+        if (!this.coherenceService) {
+            this.coherenceService = await createCoherenceService(wasmLoader);
+        }
+        return this.coherenceService;
+    }
+    /**
+     * Reset instance cache (called when fleet is disposed)
+     */
+    resetInstanceCache() {
+        if (this.coherenceService) {
+            this.coherenceService.dispose();
+            this.coherenceService = null;
+        }
+    }
+    /**
+     * Execute the coherence check
+     */
+    async execute(params, context) {
+        const startTime = Date.now();
+        const { nodes, energyThreshold = 0.4 } = params;
+        // Validate nodes
+        if (!nodes || nodes.length === 0) {
+            return {
+                success: false,
+                error: 'At least one node is required for coherence check',
+            };
+        }
+        // Validate embeddings
+        for (const node of nodes) {
+            if (!node.embedding || !Array.isArray(node.embedding)) {
+                return {
+                    success: false,
+                    error: `Node ${node.id} has invalid embedding - must be an array of numbers`,
+                };
+            }
+        }
+        try {
+            // Get service (initializes WASM if needed)
+            const service = await this.getService();
+            // Convert to CoherenceNode format
+            const coherenceNodes = nodes.map((node) => ({
+                id: node.id,
+                embedding: node.embedding,
+                weight: node.weight ?? 1.0,
+                metadata: node.metadata,
+            }));
+            // Perform coherence check
+            const result = await service.checkCoherence(coherenceNodes);
+            // Generate recommendations based on results
+            const recommendations = [
+                ...result.recommendations,
+                ...this.generateAdditionalRecommendations(result, energyThreshold),
+            ];
+            // Format contradictions for output (convert Severity enum to string)
+            const contradictions = result.contradictions.map((c) => ({
+                nodeIds: c.nodeIds,
+                severity: String(c.severity),
+                description: c.description ||
+                    `Contradiction between nodes ${c.nodeIds[0]} and ${c.nodeIds[1]}`,
+            }));
+            const executionTimeMs = Date.now() - startTime;
+            this.markAsRealData();
+            return {
+                success: true,
+                data: {
+                    isCoherent: result.isCoherent,
+                    energy: result.energy,
+                    lane: result.lane,
+                    contradictions,
+                    recommendations,
+                    nodeCount: nodes.length,
+                    executionTimeMs,
+                    usedFallback: result.usedFallback,
+                },
+            };
+        }
+        catch (error) {
+            // Check if WASM is unavailable - provide graceful fallback
+            if (error instanceof Error &&
+                error.message.includes('WASM')) {
+                this.markAsDemoData(context, 'WASM module unavailable');
+                return {
+                    success: true,
+                    data: {
+                        isCoherent: true,
+                        energy: 0.1,
+                        lane: 'reflex',
+                        contradictions: [],
+                        recommendations: [
+                            'WASM module unavailable - coherence check running in fallback mode',
+                            'Install prime-radiant-advanced-wasm for full coherence verification',
+                        ],
+                        nodeCount: nodes.length,
+                        executionTimeMs: Date.now() - startTime,
+                        usedFallback: true,
+                    },
+                };
+            }
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Generate additional recommendations based on coherence results
+     */
+    generateAdditionalRecommendations(result, threshold) {
+        const recommendations = [];
+        if (result.energy > threshold) {
+            recommendations.push(`High coherence energy (${result.energy.toFixed(3)}) detected - review contradicting beliefs`);
+        }
+        switch (result.lane) {
+            case 'reflex':
+                recommendations.push('Low energy - safe for immediate execution');
+                break;
+            case 'retrieval':
+                recommendations.push('Moderate energy - consider fetching additional context');
+                break;
+            case 'heavy':
+                recommendations.push('High energy - deep analysis recommended');
+                break;
+            case 'human':
+                recommendations.push('Critical energy - escalate to Queen coordinator');
+                break;
+        }
+        return recommendations;
+    }
+}
+/**
+ * Create a CoherenceCheckTool instance
+ */
+export function createCoherenceCheckTool() {
+    return new CoherenceCheckTool();
+}
+//# sourceMappingURL=check.js.map