agentic-qe 3.2.3 → 3.3.0

package/v3/dist/integrations/coherence/engines/spectral-adapter.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Agentic QE v3 - Spectral Engine Adapter
+ *
+ * Wraps the Prime Radiant SpectralEngine for spectral graph analysis.
+ * Used for predicting swarm collapse through Fiedler value analysis.
+ *
+ * Fiedler Value (Spectral Gap):
+ * The second-smallest eigenvalue of the Laplacian matrix.
+ * Low values indicate:
+ * - Weak connectivity
+ * - Potential for network fragmentation
+ * - False consensus risk
+ *
+ * @module integrations/coherence/engines/spectral-adapter
+ */
+import type { SwarmState, CollapseRisk, IWasmLoader, CoherenceLogger } from '../types';
+/**
+ * Interface for the spectral adapter
+ */
+export interface ISpectralAdapter {
+    /** Initialize the adapter */
+    initialize(): Promise<void>;
+    /** Check if initialized */
+    isInitialized(): boolean;
+    /** Add a node (agent) to the graph */
+    addNode(nodeId: string): void;
+    /** Add an edge (relationship) between nodes */
+    addEdge(source: string, target: string, weight: number): void;
+    /** Remove a node */
+    removeNode(nodeId: string): void;
+    /** Compute the Fiedler value */
+    computeFiedlerValue(): number;
+    /** Predict collapse risk */
+    predictCollapseRisk(): number;
+    /** Get weak vertices (at-risk nodes) */
+    getWeakVertices(count: number): string[];
+    /** Analyze swarm state for collapse risk */
+    analyzeSwarmState(state: SwarmState): CollapseRisk;
+    /** Clear the graph */
+    clear(): void;
+    /** Dispose of resources */
+    dispose(): void;
+}
+/**
+ * Adapter for the Prime Radiant SpectralEngine
+ *
+ * Provides spectral graph analysis for predicting swarm collapse
+ * and identifying weak points in the agent network.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new SpectralAdapter(wasmLoader, logger);
+ * await adapter.initialize();
+ *
+ * adapter.addNode('agent-1');
+ * adapter.addNode('agent-2');
+ * adapter.addEdge('agent-1', 'agent-2', 1.0);
+ *
+ * const fiedlerValue = adapter.computeFiedlerValue();
+ * const collapseRisk = adapter.predictCollapseRisk();
+ * const weakAgents = adapter.getWeakVertices(3);
+ * ```
+ */
+export declare class SpectralAdapter implements ISpectralAdapter {
+    private readonly wasmLoader;
+    private readonly logger;
+    private engine;
+    private initialized;
+    private readonly nodes;
+    private readonly edges;
+    /**
+     * Create a new SpectralAdapter
+     *
+     * @param wasmLoader - WASM module loader
+     * @param logger - Optional logger for diagnostics
+     */
+    constructor(wasmLoader: IWasmLoader, logger?: CoherenceLogger);
+    /**
+     * Initialize the adapter by loading the WASM module
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if the adapter is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Ensure the adapter is initialized before use
+     */
+    private ensureInitialized;
+    /**
+     * Add a node (agent) to the spectral graph
+     *
+     * @param nodeId - Unique identifier for the node
+     */
+    addNode(nodeId: string): void;
+    /**
+     * Add an edge between two nodes
+     *
+     * @param source - Source node ID
+     * @param target - Target node ID
+     * @param weight - Edge weight (relationship strength)
+     */
+    addEdge(source: string, target: string, weight: number): void;
+    /**
+     * Remove a node from the graph
+     *
+     * @param nodeId - ID of the node to remove
+     */
+    removeNode(nodeId: string): void;
+    /**
+     * Compute the Fiedler value (algebraic connectivity)
+     *
+     * The Fiedler value is the second-smallest eigenvalue of the Laplacian.
+     * - Higher values indicate better connectivity
+     * - Low values suggest the network could easily split
+     * - Zero indicates disconnected components
+     *
+     * @returns The Fiedler value (>= 0)
+     */
+    computeFiedlerValue(): number;
+    /**
+     * Predict the risk of swarm collapse
+     *
+     * Based on spectral analysis of the agent connectivity graph.
+     *
+     * @returns Collapse risk (0-1, higher = more risk)
+     */
+    predictCollapseRisk(): number;
+    /**
+     * Get the nodes most at risk of causing collapse
+     *
+     * These are nodes whose removal would most significantly
+     * impact network connectivity.
+     *
+     * @param count - Number of weak vertices to return
+     * @returns Array of node IDs sorted by vulnerability
+     */
+    getWeakVertices(count: number): string[];
+    /**
+     * Analyze a swarm state for collapse risk
+     *
+     * Builds a spectral graph from the swarm state and analyzes it.
+     *
+     * @param state - Current swarm state
+     * @returns Collapse risk analysis
+     */
+    analyzeSwarmState(state: SwarmState): CollapseRisk;
+    /**
+     * Build edges between agents based on belief similarity
+     */
+    private buildEdgesFromAgents;
+    /**
+     * Compute similarity between two agents based on their states
+     */
+    private computeAgentSimilarity;
+    /**
+     * Compute overlap between belief sets using embedding similarity
+     */
+    private computeBeliefOverlap;
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Generate recommendations based on collapse analysis
+     */
+    private generateRecommendations;
+    /**
+     * Clear all nodes and edges from the graph
+     */
+    clear(): void;
+    /**
+     * Dispose of adapter resources
+     */
+    dispose(): void;
+    /**
+     * Get the number of nodes in the graph
+     */
+    getNodeCount(): number;
+    /**
+     * Get the number of edges in the graph
+     */
+    getEdgeCount(): number;
+}
+/**
+ * Create and initialize a SpectralAdapter
+ *
+ * @param wasmLoader - WASM module loader
+ * @param logger - Optional logger
+ * @returns Initialized adapter
+ */
+export declare function createSpectralAdapter(wasmLoader: IWasmLoader, logger?: CoherenceLogger): Promise<SpectralAdapter>;
+//# sourceMappingURL=spectral-adapter.d.ts.map

package/v3/dist/integrations/coherence/engines/spectral-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spectral-adapter.d.ts","sourceRoot":"","sources":["../../../../src/integrations/coherence/engines/spectral-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,UAAU,EAEV,YAAY,EAGZ,WAAW,EACX,eAAe,EAChB,MAAM,UAAU,CAAC;AA8GlB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6BAA6B;IAC7B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,2BAA2B;IAC3B,aAAa,IAAI,OAAO,CAAC;IACzB,sCAAsC;IACtC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,+CAA+C;IAC/C,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9D,oBAAoB;IACpB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,gCAAgC;IAChC,mBAAmB,IAAI,MAAM,CAAC;IAC9B,4BAA4B;IAC5B,mBAAmB,IAAI,MAAM,CAAC;IAC9B,wCAAwC;IACxC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzC,4CAA4C;IAC5C,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAAC;IACnD,sBAAsB;IACtB,KAAK,IAAI,IAAI,CAAC;IACd,2BAA2B;IAC3B,OAAO,IAAI,IAAI,CAAC;CACjB;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAgB,YAAW,gBAAgB;IAapD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAbzB,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiE;IAEvF;;;;;OAKG;gBAEgB,UAAU,EAAE,WAAW,EACvB,MAAM,GAAE,eAA0C;IAGrE;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBjC;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAc7B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAiB7D;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAiBhC;;;;;;;;;OASG;IACH,mBAAmB,IAAI,MAAM;IAc7B;;;;;;OAMG;IACH,mBAAmB,IAAI,MAAM;IAc7B;;;;;;;;OAQG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAkBxC;;;;;;;OAOG;IACH,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY;IA0ClD;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAW5B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAqB9B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgD/B;;OAEG;IACH,KAAK,IAAI,IAAI;IAUb;;OAEG;IACH,OAAO,IAAI,IAAI;IAYf;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,YAAY,IAAI,MAAM;CAGvB;AAMD;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,WAAW,EACvB,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,eAAe,CAAC,CAI1B"}

package/v3/dist/integrations/coherence/engines/spectral-adapter.js

@@ -0,0 +1,476 @@
+/**
+ * Agentic QE v3 - Spectral Engine Adapter
+ *
+ * Wraps the Prime Radiant SpectralEngine for spectral graph analysis.
+ * Used for predicting swarm collapse through Fiedler value analysis.
+ *
+ * Fiedler Value (Spectral Gap):
+ * The second-smallest eigenvalue of the Laplacian matrix.
+ * Low values indicate:
+ * - Weak connectivity
+ * - Potential for network fragmentation
+ * - False consensus risk
+ *
+ * @module integrations/coherence/engines/spectral-adapter
+ */
+import { WasmNotLoadedError, DEFAULT_COHERENCE_LOGGER } from '../types';
+// ============================================================================
+// WASM Engine Wrapper
+// ============================================================================
+/**
+ * Creates an ISpectralEngine wrapper around the raw WASM engine
+ *
+ * IMPORTANT: WASM expects numeric node IDs (usize), so we maintain
+ * a bidirectional mapping between string IDs and numeric indices.
+ */
+function createSpectralEngineWrapper(rawEngine) {
+    const nodes = new Set();
+    const edges = [];
+    // Bidirectional mapping: string ID <-> numeric index
+    // WASM expects usize (unsigned integer) for node IDs
+    const stringToIndex = new Map();
+    const indexToString = new Map();
+    let nextIndex = 0;
+    // Get or create numeric index for a string ID
+    const getOrCreateIndex = (id) => {
+        let idx = stringToIndex.get(id);
+        if (idx === undefined) {
+            idx = nextIndex++;
+            stringToIndex.set(id, idx);
+            indexToString.set(idx, id);
+        }
+        return idx;
+    };
+    // Get string ID from numeric index
+    const getStringId = (idx) => {
+        return indexToString.get(idx) ?? `unknown-${idx}`;
+    };
+    // Build graph representation for WASM calls using numeric IDs
+    // WASM may expect nodes as objects with id/label or as simple numeric array depending on engine
+    const buildGraph = () => ({
+        nodes: Array.from(nodes).map(id => ({
+            id: getOrCreateIndex(id), // Numeric index
+            label: id, // Original string ID as label
+        })),
+        edges: edges.map(e => ({
+            source: getOrCreateIndex(e.source), // Convert to numeric
+            target: getOrCreateIndex(e.target), // Convert to numeric
+            weight: e.weight,
+        })),
+    });
+    return {
+        add_node(id) {
+            nodes.add(id);
+            getOrCreateIndex(id); // Pre-register the ID
+        },
+        add_edge(source, target, weight) {
+            edges.push({ source, target, weight });
+            // Pre-register edge endpoint IDs
+            getOrCreateIndex(source);
+            getOrCreateIndex(target);
+        },
+        remove_node(id) {
+            nodes.delete(id);
+            // Note: We don't remove from index mappings to maintain consistency
+            for (let i = edges.length - 1; i >= 0; i--) {
+                if (edges[i].source === id || edges[i].target === id) {
+                    edges.splice(i, 1);
+                }
+            }
+        },
+        compute_fiedler_value() {
+            const graph = buildGraph();
+            return rawEngine.algebraicConnectivity(graph);
+        },
+        predict_collapse_risk() {
+            const graph = buildGraph();
+            const fiedler = rawEngine.algebraicConnectivity(graph);
+            // Lower Fiedler value = higher collapse risk
+            return Math.max(0, Math.min(1, 1 - fiedler));
+        },
+        get_weak_vertices(count) {
+            const graph = buildGraph();
+            const minCut = rawEngine.predictMinCut(graph);
+            if (!minCut?.vertices)
+                return Array.from(nodes).slice(0, count);
+            // Convert numeric indices back to string IDs
+            return minCut.vertices.slice(0, count).map(idx => getStringId(idx));
+        },
+        clear() {
+            nodes.clear();
+            edges.length = 0;
+            stringToIndex.clear();
+            indexToString.clear();
+            nextIndex = 0;
+        },
+    };
+}
+// ============================================================================
+// Spectral Adapter Implementation
+// ============================================================================
+/**
+ * Adapter for the Prime Radiant SpectralEngine
+ *
+ * Provides spectral graph analysis for predicting swarm collapse
+ * and identifying weak points in the agent network.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new SpectralAdapter(wasmLoader, logger);
+ * await adapter.initialize();
+ *
+ * adapter.addNode('agent-1');
+ * adapter.addNode('agent-2');
+ * adapter.addEdge('agent-1', 'agent-2', 1.0);
+ *
+ * const fiedlerValue = adapter.computeFiedlerValue();
+ * const collapseRisk = adapter.predictCollapseRisk();
+ * const weakAgents = adapter.getWeakVertices(3);
+ * ```
+ */
+export class SpectralAdapter {
+    wasmLoader;
+    logger;
+    engine = null;
+    initialized = false;
+    nodes = new Set();
+    edges = [];
+    /**
+     * Create a new SpectralAdapter
+     *
+     * @param wasmLoader - WASM module loader
+     * @param logger - Optional logger for diagnostics
+     */
+    constructor(wasmLoader, logger = DEFAULT_COHERENCE_LOGGER) {
+        this.wasmLoader = wasmLoader;
+        this.logger = logger;
+    }
+    /**
+     * Initialize the adapter by loading the WASM module
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        this.logger.debug('Initializing SpectralAdapter');
+        const isAvailable = await this.wasmLoader.isAvailable();
+        if (!isAvailable) {
+            throw new WasmNotLoadedError('WASM module is not available. Cannot initialize SpectralAdapter.');
+        }
+        const module = await this.wasmLoader.load();
+        // Create wrapper around raw WASM engine
+        const rawEngine = new module.SpectralEngine();
+        this.engine = createSpectralEngineWrapper(rawEngine);
+        this.initialized = true;
+        this.logger.info('SpectralAdapter initialized successfully');
+    }
+    /**
+     * Check if the adapter is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Ensure the adapter is initialized before use
+     */
+    ensureInitialized() {
+        if (!this.initialized || !this.engine) {
+            throw new WasmNotLoadedError('SpectralAdapter not initialized. Call initialize() first.');
+        }
+    }
+    /**
+     * Add a node (agent) to the spectral graph
+     *
+     * @param nodeId - Unique identifier for the node
+     */
+    addNode(nodeId) {
+        this.ensureInitialized();
+        if (this.nodes.has(nodeId)) {
+            this.logger.debug('Node already exists', { nodeId });
+            return;
+        }
+        this.nodes.add(nodeId);
+        this.engine.add_node(nodeId);
+        this.logger.debug('Added node to spectral graph', { nodeId });
+    }
+    /**
+     * Add an edge between two nodes
+     *
+     * @param source - Source node ID
+     * @param target - Target node ID
+     * @param weight - Edge weight (relationship strength)
+     */
+    addEdge(source, target, weight) {
+        this.ensureInitialized();
+        // Ensure both nodes exist
+        if (!this.nodes.has(source)) {
+            this.addNode(source);
+        }
+        if (!this.nodes.has(target)) {
+            this.addNode(target);
+        }
+        this.edges.push({ source, target, weight });
+        this.engine.add_edge(source, target, weight);
+        this.logger.debug('Added edge to spectral graph', { source, target, weight });
+    }
+    /**
+     * Remove a node from the graph
+     *
+     * @param nodeId - ID of the node to remove
+     */
+    removeNode(nodeId) {
+        this.ensureInitialized();
+        this.nodes.delete(nodeId);
+        this.engine.remove_node(nodeId);
+        // Remove edges connected to this node
+        for (let i = this.edges.length - 1; i >= 0; i--) {
+            const edge = this.edges[i];
+            if (edge.source === nodeId || edge.target === nodeId) {
+                this.edges.splice(i, 1);
+            }
+        }
+        this.logger.debug('Removed node from spectral graph', { nodeId });
+    }
+    /**
+     * Compute the Fiedler value (algebraic connectivity)
+     *
+     * The Fiedler value is the second-smallest eigenvalue of the Laplacian.
+     * - Higher values indicate better connectivity
+     * - Low values suggest the network could easily split
+     * - Zero indicates disconnected components
+     *
+     * @returns The Fiedler value (>= 0)
+     */
+    computeFiedlerValue() {
+        this.ensureInitialized();
+        if (this.nodes.size < 2) {
+            return 0; // Need at least 2 nodes for meaningful analysis
+        }
+        const fiedlerValue = this.engine.compute_fiedler_value();
+        this.logger.debug('Computed Fiedler value', { fiedlerValue });
+        return fiedlerValue;
+    }
+    /**
+     * Predict the risk of swarm collapse
+     *
+     * Based on spectral analysis of the agent connectivity graph.
+     *
+     * @returns Collapse risk (0-1, higher = more risk)
+     */
+    predictCollapseRisk() {
+        this.ensureInitialized();
+        if (this.nodes.size < 2) {
+            return 0; // Can't collapse with fewer than 2 nodes
+        }
+        const risk = this.engine.predict_collapse_risk();
+        this.logger.debug('Predicted collapse risk', { risk });
+        return risk;
+    }
+    /**
+     * Get the nodes most at risk of causing collapse
+     *
+     * These are nodes whose removal would most significantly
+     * impact network connectivity.
+     *
+     * @param count - Number of weak vertices to return
+     * @returns Array of node IDs sorted by vulnerability
+     */
+    getWeakVertices(count) {
+        this.ensureInitialized();
+        if (this.nodes.size === 0) {
+            return [];
+        }
+        const safeCount = Math.min(count, this.nodes.size);
+        const weakVertices = this.engine.get_weak_vertices(safeCount);
+        this.logger.debug('Retrieved weak vertices', {
+            requested: count,
+            returned: weakVertices.length,
+        });
+        return weakVertices;
+    }
+    /**
+     * Analyze a swarm state for collapse risk
+     *
+     * Builds a spectral graph from the swarm state and analyzes it.
+     *
+     * @param state - Current swarm state
+     * @returns Collapse risk analysis
+     */
+    analyzeSwarmState(state) {
+        const startTime = Date.now();
+        // Clear existing graph and build from state
+        this.clear();
+        // Add agents as nodes
+        for (const agent of state.agents) {
+            this.addNode(agent.agentId);
+        }
+        // Add edges based on agent relationships
+        // Agents with similar beliefs are connected
+        this.buildEdgesFromAgents(state.agents);
+        // Analyze the graph
+        const risk = this.predictCollapseRisk();
+        const fiedlerValue = this.computeFiedlerValue();
+        const weakVertices = this.getWeakVertices(5);
+        const durationMs = Date.now() - startTime;
+        const result = {
+            risk,
+            fiedlerValue,
+            collapseImminent: risk > 0.7,
+            weakVertices,
+            recommendations: this.generateRecommendations(risk, fiedlerValue, weakVertices),
+            durationMs,
+            usedFallback: false,
+        };
+        this.logger.info('Analyzed swarm state', {
+            agentCount: state.agents.length,
+            risk,
+            fiedlerValue,
+            durationMs,
+        });
+        return result;
+    }
+    /**
+     * Build edges between agents based on belief similarity
+     */
+    buildEdgesFromAgents(agents) {
+        for (let i = 0; i < agents.length; i++) {
+            for (let j = i + 1; j < agents.length; j++) {
+                const similarity = this.computeAgentSimilarity(agents[i], agents[j]);
+                if (similarity > 0.3) {
+                    this.addEdge(agents[i].agentId, agents[j].agentId, similarity);
+                }
+            }
+        }
+    }
+    /**
+     * Compute similarity between two agents based on their states
+     */
+    computeAgentSimilarity(agent1, agent2) {
+        // Factor in:
+        // 1. Health similarity
+        const healthSim = 1 - Math.abs(agent1.health - agent2.health);
+        // 2. Success rate similarity
+        const successSim = 1 - Math.abs(agent1.successRate - agent2.successRate);
+        // 3. Same agent type bonus
+        const typeBonus = agent1.agentType === agent2.agentType ? 0.2 : 0;
+        // 4. Belief overlap (if both have beliefs)
+        let beliefSim = 0;
+        if (agent1.beliefs.length > 0 && agent2.beliefs.length > 0) {
+            beliefSim = this.computeBeliefOverlap(agent1.beliefs, agent2.beliefs);
+        }
+        // Weighted combination
+        return (healthSim * 0.3 + successSim * 0.3 + typeBonus + beliefSim * 0.2);
+    }
+    /**
+     * Compute overlap between belief sets using embedding similarity
+     */
+    computeBeliefOverlap(beliefs1, beliefs2) {
+        if (beliefs1.length === 0 || beliefs2.length === 0) {
+            return 0;
+        }
+        let totalSimilarity = 0;
+        let comparisons = 0;
+        for (const b1 of beliefs1) {
+            for (const b2 of beliefs2) {
+                totalSimilarity += this.cosineSimilarity(b1.embedding, b2.embedding);
+                comparisons++;
+            }
+        }
+        return comparisons > 0 ? totalSimilarity / comparisons : 0;
+    }
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length || a.length === 0) {
+            return 0;
+        }
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    /**
+     * Generate recommendations based on collapse analysis
+     */
+    generateRecommendations(risk, fiedlerValue, weakVertices) {
+        const recommendations = [];
+        if (risk > 0.7) {
+            recommendations.push('CRITICAL: Immediate action required to prevent swarm collapse.');
+            recommendations.push('Consider spawning additional coordination agents to strengthen connectivity.');
+        }
+        else if (risk > 0.5) {
+            recommendations.push('WARNING: Elevated collapse risk detected. Monitor closely.');
+        }
+        if (fiedlerValue < 0.1) {
+            recommendations.push('Network connectivity is weak. Consider adding redundant communication channels.');
+        }
+        if (fiedlerValue < 0.05) {
+            recommendations.push('ALERT: Near-zero Fiedler value indicates potential false consensus.');
+            recommendations.push('Recommend spawning an independent reviewer to verify decisions.');
+        }
+        if (weakVertices.length > 0) {
+            recommendations.push(`At-risk agents: ${weakVertices.join(', ')}. Consider reassigning critical tasks.`);
+        }
+        if (recommendations.length === 0) {
+            recommendations.push('Swarm health is good. No immediate action required.');
+        }
+        return recommendations;
+    }
+    /**
+     * Clear all nodes and edges from the graph
+     */
+    clear() {
+        this.ensureInitialized();
+        this.nodes.clear();
+        this.edges.length = 0;
+        this.engine.clear();
+        this.logger.debug('Cleared spectral graph');
+    }
+    /**
+     * Dispose of adapter resources
+     */
+    dispose() {
+        if (this.engine) {
+            this.engine.clear();
+            this.engine = null;
+        }
+        this.nodes.clear();
+        this.edges.length = 0;
+        this.initialized = false;
+        this.logger.info('SpectralAdapter disposed');
+    }
+    /**
+     * Get the number of nodes in the graph
+     */
+    getNodeCount() {
+        return this.nodes.size;
+    }
+    /**
+     * Get the number of edges in the graph
+     */
+    getEdgeCount() {
+        return this.edges.length;
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+/**
+ * Create and initialize a SpectralAdapter
+ *
+ * @param wasmLoader - WASM module loader
+ * @param logger - Optional logger
+ * @returns Initialized adapter
+ */
+export async function createSpectralAdapter(wasmLoader, logger) {
+    const adapter = new SpectralAdapter(wasmLoader, logger);
+    await adapter.initialize();
+    return adapter;
+}
+//# sourceMappingURL=spectral-adapter.js.map