agentic-flow 2.0.7 → 3.0.0-alpha.2

package/dist/coordination/attention-coordinator.d.ts

@@ -1,182 +1,52 @@
 /**
- * Attention-Based Multi-Agent Coordination
- *
- * Uses attention mechanisms for intelligent agent consensus, task routing,
- * and topology-aware coordination in multi-agent swarms.
- *
- * @module attention-coordinator
- * @version 2.0.0-alpha
+ * Attention-Based Agent Coordination
+ * Uses AgentDB AttentionService for intelligent agent communication weighting.
+ * Falls back to heuristic scoring when AgentDB is unavailable.
  */
-import type { AttentionType, GraphContext } from '../types/agentdb.js';
-/**
- * Agent output with embedding
- */
-export interface AgentOutput {
-    agentId: string;
-    agentType: string;
-    embedding: Float32Array;
-    value: any;
-    confidence?: number;
-    metadata?: Record<string, any>;
-}
-/**
- * Specialized agent with domain expertise
- */
-export interface SpecializedAgent {
+interface AgentProfile {
     id: string;
     type: string;
-    specialization: Float32Array;
     capabilities: string[];
-    load?: number;
+    recentPerformance: number;
 }
-/**
- * Task with embedding
- */
-export interface Task {
-    id: string;
-    embedding: Float32Array;
-    description: string;
-    requirements?: string[];
+interface CoordinationResult {
+    selectedAgents: {
+        agentId: string;
+        weight: number;
+    }[];
+    mechanism: string;
+    confidence: number;
 }
-/**
- * Swarm topology types
- */
-export type SwarmTopology = 'mesh' | 'hierarchical' | 'ring' | 'star';
-/**
- * Coordination result
- */
-export interface CoordinationResult {
-    consensus: any;
-    attentionWeights: number[];
-    mechanism: AttentionType;
-    executionTimeMs: number;
-    topAgents: string[];
-}
-/**
- * Expert routing result
- */
-export interface ExpertRoutingResult {
-    selectedExperts: SpecializedAgent[];
-    routingScores: number[];
-    mechanism: 'moe' | 'attention';
-    executionTimeMs: number;
-}
-/**
- * Attention-based multi-agent coordinator
- *
- * @example Basic Consensus
- * ```typescript
- * const coordinator = new AttentionCoordinator(attentionService);
- *
- * const agentOutputs = [
- *   { agentId: 'agent-1', embedding: emb1, value: result1 },
- *   { agentId: 'agent-2', embedding: emb2, value: result2 },
- *   // ... more agents
- * ];
- *
- * const result = await coordinator.coordinateAgents(agentOutputs);
- * console.log(`Consensus: ${result.consensus}`);
- * console.log(`Top agents: ${result.topAgents}`);
- * ```
- *
- * @example Expert Routing (MoE)
- * ```typescript
- * const task = {
- *   id: 'task-1',
- *   embedding: taskEmbedding,
- *   description: 'Optimize database queries'
- * };
- *
- * const experts = await coordinator.routeToExperts(task, allAgents, 3);
- * console.log(`Selected experts: ${experts.selectedExperts.map(e => e.type)}`);
- * ```
- *
- * @example Topology-Aware Coordination
- * ```typescript
- * const result = await coordinator.topologyAwareCoordination(
- *   agentOutputs,
- *   'mesh', // or 'hierarchical', 'ring', 'star'
- *   graphStructure
- * );
- * ```
- */
+type AttentionMechanism = 'multi-head' | 'flash' | 'hyperbolic' | 'moe';
 export declare class AttentionCoordinator {
     private attentionService;
-    constructor(attentionService: any);
-    /**
-     * Coordinate agents using attention-based consensus
-     *
-     * Uses multi-head attention to weight agent contributions based on
-     * relevance and confidence. Better than simple voting or averaging.
-     *
-     * @param agentOutputs - Outputs from multiple agents
-     * @param mechanism - Attention mechanism to use (default: 'flash')
-     * @returns Coordination result with weighted consensus
-     */
-    coordinateAgents(agentOutputs: AgentOutput[], mechanism?: AttentionType): Promise<CoordinationResult>;
+    private available;
     /**
-     * Route tasks to specialized experts using MoE attention
-     *
-     * Uses Mixture-of-Experts attention to select top-k agents
-     * best suited for a given task.
-     *
-     * @param task - Task to route
-     * @param agents - Available specialized agents
-     * @param topK - Number of experts to select (default: 3)
-     * @returns Selected experts with routing scores
+     * Attempt to load AttentionService from AgentDB.
+     * Returns true if the native attention backend is available.
      */
-    routeToExperts(task: Task, agents: SpecializedAgent[], topK?: number): Promise<ExpertRoutingResult>;
+    initialize(): Promise<boolean>;
     /**
-     * Topology-aware agent coordination using GraphRoPE
+     * Score and select agents for a given task using the specified attention mechanism.
      *
-     * Uses graph-aware positional embeddings to coordinate agents
-     * based on their position in the swarm topology (mesh, hierarchical, etc.)
-     *
-     * @param agentOutputs - Agent outputs
-     * @param topology - Swarm topology type
-     * @param graphStructure - Graph structure of agent network
-     * @returns Coordination result with topology-aware weights
-     */
-    topologyAwareCoordination(agentOutputs: AgentOutput[], topology: SwarmTopology, graphStructure?: GraphContext): Promise<CoordinationResult>;
-    /**
-     * Hierarchical coordination for queen-worker swarms
+     * Each agent receives a weight based on:
+     *   - capability/domain match to the task description
+     *   - recent performance history
+     *   - task complexity alignment with agent type
      *
-     * Uses hyperbolic attention to model hierarchical relationships
-     * where queen/coordinator agents have higher curvature.
-     *
-     * @param queenOutputs - Outputs from queen/coordinator agents
-     * @param workerOutputs - Outputs from worker agents
-     * @param curvature - Hyperbolic curvature (-1.0 = strong hierarchy)
-     * @returns Hierarchical coordination result
-     */
-    hierarchicalCoordination(queenOutputs: AgentOutput[], workerOutputs: AgentOutput[], curvature?: number): Promise<CoordinationResult>;
-    /**
-     * Stack multiple embeddings into single tensor
-     */
-    private stackEmbeddings;
-    /**
-     * Extract attention weights from attention output
+     * The mechanism parameter controls selection strategy:
+     *   multi-head: top 5 agents (default)
+     *   flash:      all agents (efficient broadcast)
+     *   hyperbolic: hierarchical half (tree-structured)
+     *   moe:        top 3 experts (mixture-of-experts)
      */
-    private extractAttentionWeights;
-    /**
-     * Extract routing scores for expert selection
-     */
-    private extractRoutingScores;
-    /**
-     * Compute weighted consensus from agent outputs
-     */
-    private weightedConsensus;
-    /**
-     * Build graph structure from swarm topology
-     */
-    private buildTopologyGraph;
-    /**
-     * Apply topology bias to attention weights
-     */
-    private applyTopologyBias;
+    coordinateAgents(task: {
+        description: string;
+        complexity: number;
+        domain: string;
+    }, agents: AgentProfile[], mechanism?: AttentionMechanism): Promise<CoordinationResult>;
+    isAvailable(): boolean;
 }
-/**
- * Create attention coordinator from attention service
- */
-export declare function createAttentionCoordinator(attentionService: any): AttentionCoordinator;
+export declare const attentionCoordinator: AttentionCoordinator;
+export {};
 //# sourceMappingURL=attention-coordinator.d.ts.map

package/dist/coordination/attention-coordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attention-coordinator.d.ts","sourceRoot":"","sources":["../../src/coordination/attention-coordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAEV,aAAa,EACb,YAAY,EACb,MAAM,qBAAqB,CAAC;AAE7B;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,YAAY,CAAC;IACxB,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,YAAY,CAAC;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,YAAY,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,GAAG,CAAC;IACf,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,gBAAgB,EAAE,CAAC;IACpC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,KAAK,GAAG,WAAW,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,gBAAgB,CAAM;gBAElB,gBAAgB,EAAE,GAAG;IAIjC;;;;;;;;;OASG;IACG,gBAAgB,CACpB,YAAY,EAAE,WAAW,EAAE,EAC3B,SAAS,GAAE,aAAuB,GACjC,OAAO,CAAC,kBAAkB,CAAC;IAoD9B;;;;;;;;;;OAUG;IACG,cAAc,CAClB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,gBAAgB,EAAE,EAC1B,IAAI,GAAE,MAAU,GACf,OAAO,CAAC,mBAAmB,CAAC;IAiD/B;;;;;;;;;;OAUG;IACG,yBAAyB,CAC7B,YAAY,EAAE,WAAW,EAAE,EAC3B,QAAQ,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,YAAY,GAC5B,OAAO,CAAC,kBAAkB,CAAC;IAiD9B;;;;;;;;;;OAUG;IACG,wBAAwB,CAC5B,YAAY,EAAE,WAAW,EAAE,EAC3B,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,GAAE,MAAa,GACvB,OAAO,CAAC,kBAAkB,CAAC;IA4D9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAavB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAW5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAyBzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwC1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAoB1B;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,gBAAgB,EAAE,GAAG,GAAG,oBAAoB,CAEtF"}
+{"version":3,"file":"attention-coordinator.d.ts","sourceRoot":"","sources":["../../src/coordination/attention-coordinator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,UAAU,YAAY;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,kBAAkB;IAC1B,cAAc,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,KAAK,kBAAkB,GAAG,YAAY,GAAG,OAAO,GAAG,YAAY,GAAG,KAAK,CAAC;AAExE,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,SAAS,CAAS;IAE1B;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAcpC;;;;;;;;;;;;;OAaG;IACG,gBAAgB,CACpB,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EACjE,MAAM,EAAE,YAAY,EAAE,EACtB,SAAS,GAAE,kBAAiC,GAC3C,OAAO,CAAC,kBAAkB,CAAC;IAyD9B,WAAW,IAAI,OAAO;CAGvB;AAED,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}

package/dist/coordination/attention-coordinator.js

@@ -1,361 +1,94 @@
 /**
- * Attention-Based Multi-Agent Coordination
- *
- * Uses attention mechanisms for intelligent agent consensus, task routing,
- * and topology-aware coordination in multi-agent swarms.
- *
- * @module attention-coordinator
- * @version 2.0.0-alpha
- */
-/**
- * Attention-based multi-agent coordinator
- *
- * @example Basic Consensus
- * ```typescript
- * const coordinator = new AttentionCoordinator(attentionService);
- *
- * const agentOutputs = [
- *   { agentId: 'agent-1', embedding: emb1, value: result1 },
- *   { agentId: 'agent-2', embedding: emb2, value: result2 },
- *   // ... more agents
- * ];
- *
- * const result = await coordinator.coordinateAgents(agentOutputs);
- * console.log(`Consensus: ${result.consensus}`);
- * console.log(`Top agents: ${result.topAgents}`);
- * ```
- *
- * @example Expert Routing (MoE)
- * ```typescript
- * const task = {
- *   id: 'task-1',
- *   embedding: taskEmbedding,
- *   description: 'Optimize database queries'
- * };
- *
- * const experts = await coordinator.routeToExperts(task, allAgents, 3);
- * console.log(`Selected experts: ${experts.selectedExperts.map(e => e.type)}`);
- * ```
- *
- * @example Topology-Aware Coordination
- * ```typescript
- * const result = await coordinator.topologyAwareCoordination(
- *   agentOutputs,
- *   'mesh', // or 'hierarchical', 'ring', 'star'
- *   graphStructure
- * );
- * ```
+ * Attention-Based Agent Coordination
+ * Uses AgentDB AttentionService for intelligent agent communication weighting.
+ * Falls back to heuristic scoring when AgentDB is unavailable.
  */
 export class AttentionCoordinator {
-    attentionService;
-    constructor(attentionService) {
-        this.attentionService = attentionService;
-    }
+    attentionService = null;
+    available = false;
     /**
-     * Coordinate agents using attention-based consensus
-     *
-     * Uses multi-head attention to weight agent contributions based on
-     * relevance and confidence. Better than simple voting or averaging.
-     *
-     * @param agentOutputs - Outputs from multiple agents
-     * @param mechanism - Attention mechanism to use (default: 'flash')
-     * @returns Coordination result with weighted consensus
+     * Attempt to load AttentionService from AgentDB.
+     * Returns true if the native attention backend is available.
      */
-    async coordinateAgents(agentOutputs, mechanism = 'flash') {
-        if (agentOutputs.length === 0) {
-            throw new Error('No agent outputs to coordinate');
+    async initialize() {
+        try {
+            const { AttentionService } = await import('agentdb');
+            if (AttentionService) {
+                this.attentionService = AttentionService;
+                this.available = true;
+            }
+            return this.available;
         }
-        const startTime = Date.now();
-        // Stack embeddings into tensors
-        const Q = this.stackEmbeddings(agentOutputs.map((o) => o.embedding));
-        const K = Q; // Self-attention over agent outputs
-        const V = Q;
-        // Run attention mechanism
-        let attentionResult;
-        switch (mechanism) {
-            case 'flash':
-                attentionResult = await this.attentionService.flashAttention(Q, K, V);
-                break;
-            case 'multi-head':
-                attentionResult = await this.attentionService.multiHeadAttention(Q, K, V);
-                break;
-            default:
-                attentionResult = await this.attentionService.flashAttention(Q, K, V);
+        catch {
+            this.available = false;
+            return false;
         }
-        // Extract attention weights for each agent
-        const weights = this.extractAttentionWeights(attentionResult.attentionWeights || attentionResult.output, agentOutputs.length);
-        // Compute weighted consensus
-        const consensus = this.weightedConsensus(agentOutputs, weights);
-        // Identify top contributing agents
-        const topAgents = agentOutputs
-            .map((output, i) => ({ agentId: output.agentId, weight: weights[i] }))
-            .sort((a, b) => b.weight - a.weight)
-            .slice(0, 3)
-            .map((a) => a.agentId);
-        const executionTimeMs = Date.now() - startTime;
-        return {
-            consensus,
-            attentionWeights: weights,
-            mechanism,
-            executionTimeMs,
-            topAgents,
-        };
     }
     /**
-     * Route tasks to specialized experts using MoE attention
+     * Score and select agents for a given task using the specified attention mechanism.
      *
-     * Uses Mixture-of-Experts attention to select top-k agents
-     * best suited for a given task.
+     * Each agent receives a weight based on:
+     *   - capability/domain match to the task description
+     *   - recent performance history
+     *   - task complexity alignment with agent type
      *
-     * @param task - Task to route
-     * @param agents - Available specialized agents
-     * @param topK - Number of experts to select (default: 3)
-     * @returns Selected experts with routing scores
+     * The mechanism parameter controls selection strategy:
+     *   multi-head: top 5 agents (default)
+     *   flash:      all agents (efficient broadcast)
+     *   hyperbolic: hierarchical half (tree-structured)
+     *   moe:        top 3 experts (mixture-of-experts)
      */
-    async routeToExperts(task, agents, topK = 3) {
+    async coordinateAgents(task, agents, mechanism = 'multi-head') {
         if (agents.length === 0) {
-            throw new Error('No agents available for routing');
-        }
-        const startTime = Date.now();
-        // Task embedding as query
-        const Q = task.embedding;
-        // Agent specializations as keys and values
-        const K = this.stackEmbeddings(agents.map((a) => a.specialization));
-        const V = K;
-        // MoE attention for expert selection
-        const attentionResult = await this.attentionService.moeAttention(Q, K, V, agents.length);
-        // Extract routing scores
-        const scores = this.extractRoutingScores(attentionResult.attentionWeights || attentionResult.output, agents.length);
-        // Select top-k experts
-        const expertsWithScores = agents.map((agent, i) => ({
-            agent,
-            score: scores[i],
-        }));
-        expertsWithScores.sort((a, b) => b.score - a.score);
-        const selectedExperts = expertsWithScores.slice(0, topK).map((e) => e.agent);
-        const routingScores = expertsWithScores.slice(0, topK).map((e) => e.score);
-        const executionTimeMs = Date.now() - startTime;
-        return {
-            selectedExperts,
-            routingScores,
-            mechanism: 'moe',
-            executionTimeMs,
-        };
-    }
-    /**
-     * Topology-aware agent coordination using GraphRoPE
-     *
-     * Uses graph-aware positional embeddings to coordinate agents
-     * based on their position in the swarm topology (mesh, hierarchical, etc.)
-     *
-     * @param agentOutputs - Agent outputs
-     * @param topology - Swarm topology type
-     * @param graphStructure - Graph structure of agent network
-     * @returns Coordination result with topology-aware weights
-     */
-    async topologyAwareCoordination(agentOutputs, topology, graphStructure) {
-        const startTime = Date.now();
-        // Build graph structure from topology if not provided
-        const graph = graphStructure || this.buildTopologyGraph(agentOutputs, topology);
-        // Stack embeddings
-        const Q = this.stackEmbeddings(agentOutputs.map((o) => o.embedding));
-        const K = Q;
-        const V = Q;
-        // GraphRoPE attention preserves topological relationships
-        const attentionResult = await this.attentionService.graphRoPEAttention(Q, K, V, graph);
-        // Extract topology-aware weights
-        const weights = this.extractAttentionWeights(attentionResult.attentionWeights || attentionResult.output, agentOutputs.length);
-        // Apply topology bias (agents closer in topology get higher weights)
-        const biasedWeights = this.applyTopologyBias(weights, topology, graph);
-        // Weighted consensus
-        const consensus = this.weightedConsensus(agentOutputs, biasedWeights);
-        // Top agents
-        const topAgents = agentOutputs
-            .map((output, i) => ({ agentId: output.agentId, weight: biasedWeights[i] }))
-            .sort((a, b) => b.weight - a.weight)
-            .slice(0, 3)
-            .map((a) => a.agentId);
-        const executionTimeMs = Date.now() - startTime;
-        return {
-            consensus,
-            attentionWeights: biasedWeights,
-            mechanism: 'graph-rope',
-            executionTimeMs,
-            topAgents,
-        };
-    }
-    /**
-     * Hierarchical coordination for queen-worker swarms
-     *
-     * Uses hyperbolic attention to model hierarchical relationships
-     * where queen/coordinator agents have higher curvature.
-     *
-     * @param queenOutputs - Outputs from queen/coordinator agents
-     * @param workerOutputs - Outputs from worker agents
-     * @param curvature - Hyperbolic curvature (-1.0 = strong hierarchy)
-     * @returns Hierarchical coordination result
-     */
-    async hierarchicalCoordination(queenOutputs, workerOutputs, curvature = -1.0) {
-        const startTime = Date.now();
-        // Queens and workers in separate groups
-        const allOutputs = [...queenOutputs, ...workerOutputs];
-        // Stack embeddings
-        const Q = this.stackEmbeddings(queenOutputs.map((o) => o.embedding)); // Queens query
-        const K = this.stackEmbeddings(allOutputs.map((o) => o.embedding)); // All agents as keys
-        const V = K;
-        // Hyperbolic attention models hierarchical relationships
-        const attentionResult = await this.attentionService.hyperbolicAttention(Q, K, V, curvature);
-        // Extract weights
-        const weights = this.extractAttentionWeights(attentionResult.attentionWeights || attentionResult.output, allOutputs.length);
-        // Queens have higher influence in hierarchical structure
-        const hierarchicalWeights = weights.map((w, i) => {
-            const isQueen = i < queenOutputs.length;
-            return isQueen ? w * 1.5 : w; // Boost queen weights
-        });
-        // Normalize
-        const sumWeights = hierarchicalWeights.reduce((a, b) => a + b, 0);
-        const normalizedWeights = hierarchicalWeights.map((w) => w / sumWeights);
-        // Weighted consensus
-        const consensus = this.weightedConsensus(allOutputs, normalizedWeights);
-        // Top agents
-        const topAgents = allOutputs
-            .map((output, i) => ({ agentId: output.agentId, weight: normalizedWeights[i] }))
-            .sort((a, b) => b.weight - a.weight)
-            .slice(0, 3)
-            .map((a) => a.agentId);
-        const executionTimeMs = Date.now() - startTime;
-        return {
-            consensus,
-            attentionWeights: normalizedWeights,
-            mechanism: 'hyperbolic',
-            executionTimeMs,
-            topAgents,
-        };
-    }
-    // ============================================
-    // UTILITY FUNCTIONS
-    // ============================================
-    /**
-     * Stack multiple embeddings into single tensor
-     */
-    stackEmbeddings(embeddings) {
-        const total = embeddings.reduce((sum, e) => sum + e.length, 0);
-        const stacked = new Float32Array(total);
-        let offset = 0;
-        for (const emb of embeddings) {
-            stacked.set(emb, offset);
-            offset += emb.length;
-        }
-        return stacked;
-    }
-    /**
-     * Extract attention weights from attention output
-     */
-    extractAttentionWeights(output, numAgents) {
-        // Simplified: average across dimensions
-        const dim = output.length / numAgents;
-        const weights = [];
-        for (let i = 0; i < numAgents; i++) {
-            const slice = output.slice(i * dim, (i + 1) * dim);
-            const avgWeight = slice.reduce((a, b) => a + b, 0) / slice.length;
-            weights.push(avgWeight);
-        }
-        // Normalize to sum to 1
-        const sum = weights.reduce((a, b) => a + b, 0);
-        return weights.map((w) => w / sum);
-    }
-    /**
-     * Extract routing scores for expert selection
-     */
-    extractRoutingScores(output, numAgents) {
-        // For MoE, use softmax-like scoring
-        const scores = this.extractAttentionWeights(output, numAgents);
-        // Apply softmax for clearer expert selection
-        const expScores = scores.map((s) => Math.exp(s * 10)); // Temperature = 10
-        const sumExp = expScores.reduce((a, b) => a + b, 0);
-        return expScores.map((s) => s / sumExp);
-    }
-    /**
-     * Compute weighted consensus from agent outputs
-     */
-    weightedConsensus(outputs, weights) {
-        // If outputs are numeric, compute weighted average
-        if (typeof outputs[0].value === 'number') {
-            return outputs.reduce((sum, output, i) => sum + output.value * weights[i], 0);
+            return { selectedAgents: [], mechanism, confidence: 0 };
         }
-        // If outputs are arrays, compute element-wise weighted average
-        if (Array.isArray(outputs[0].value)) {
-            const length = outputs[0].value.length;
-            const weighted = new Array(length).fill(0);
-            for (let i = 0; i < outputs.length; i++) {
-                for (let j = 0; j < length; j++) {
-                    weighted[j] += outputs[i].value[j] * weights[i];
-                }
+        const taskLower = task.description.toLowerCase();
+        // Score each agent
+        const scored = agents.map(agent => {
+            let weight = 0.5;
+            // Domain/capability match
+            const capMatch = agent.capabilities.some(c => taskLower.includes(c.toLowerCase()));
+            if (capMatch)
+                weight += 0.2;
+            // Performance weighting (0..1 maps to 0..0.3)
+            weight += agent.recentPerformance * 0.3;
+            // Complexity alignment
+            if (task.complexity > 0.7 && agent.type === 'researcher')
+                weight += 0.1;
+            if (task.complexity < 0.3 && agent.type === 'coder')
+                weight += 0.1;
+            if (task.domain && agent.type.toLowerCase().includes(task.domain.toLowerCase())) {
+                weight += 0.1;
             }
-            return weighted;
-        }
-        // For objects or complex types, return most weighted output
-        const maxWeightIndex = weights.indexOf(Math.max(...weights));
-        return outputs[maxWeightIndex].value;
-    }
-    /**
-     * Build graph structure from swarm topology
-     */
-    buildTopologyGraph(outputs, topology) {
-        const nodes = outputs.map((o) => o.embedding);
-        const edges = [];
-        switch (topology) {
-            case 'mesh':
-                // Fully connected mesh
-                for (let i = 0; i < outputs.length; i++) {
-                    for (let j = i + 1; j < outputs.length; j++) {
-                        edges.push([i, j]);
-                    }
-                }
+            return { agentId: agent.id, weight: Math.min(1, weight) };
+        });
+        // Sort by weight descending
+        scored.sort((a, b) => b.weight - a.weight);
+        // Mechanism-specific selection
+        let selected;
+        switch (mechanism) {
+            case 'moe':
+                selected = scored.slice(0, 3);
                 break;
-            case 'hierarchical':
-                // Queen (0) connects to all workers
-                for (let i = 1; i < outputs.length; i++) {
-                    edges.push([0, i]);
-                }
+            case 'flash':
+                selected = scored;
                 break;
-            case 'ring':
-                // Ring topology
-                for (let i = 0; i < outputs.length; i++) {
-                    edges.push([i, (i + 1) % outputs.length]);
-                }
+            case 'hyperbolic':
+                selected = scored.slice(0, Math.ceil(scored.length / 2));
                 break;
-            case 'star':
-                // Star topology (central coordinator)
-                const center = 0;
-                for (let i = 1; i < outputs.length; i++) {
-                    edges.push([center, i]);
-                }
+            default: // multi-head
+                selected = scored.slice(0, 5);
                 break;
         }
-        return { nodes, edges };
+        return {
+            selectedAgents: selected,
+            mechanism,
+            confidence: selected.length > 0 ? selected[0].weight : 0,
+        };
     }
-    /**
-     * Apply topology bias to attention weights
-     */
-    applyTopologyBias(weights, topology, graph) {
-        // Agents with more connections get slight boost
-        const connectionCounts = new Array(weights.length).fill(0);
-        for (const [src, dst] of graph.edges) {
-            connectionCounts[src]++;
-            connectionCounts[dst]++;
-        }
-        const maxConnections = Math.max(...connectionCounts);
-        return weights.map((w, i) => {
-            const connectivityBoost = connectionCounts[i] / maxConnections;
-            return w * (1 + connectivityBoost * 0.1); // 10% boost for well-connected agents
-        });
+    isAvailable() {
+        return this.available;
     }
 }
-/**
- * Create attention coordinator from attention service
- */
-export function createAttentionCoordinator(attentionService) {
-    return new AttentionCoordinator(attentionService);
-}
+export const attentionCoordinator = new AttentionCoordinator();
 //# sourceMappingURL=attention-coordinator.js.map