overmind-mcp 3.4.1 → 3.4.3

package/dist/tools/a2a_hub.js

@@ -1,44 +1,125 @@
 /**
  * ═══════════════════════════════════════════════════════════════════════════
- * A2A Hub — Outil MCP unifié pour la communication Agent-to-Agent
+ * A2A Hub — Outil MCP pour la communication Agent-to-Agent
  * ═══════════════════════════════════════════════════════════════════════════
  *
- * Cet outil donne aux agents une vue complète du système multi-agents:
+ * Architecture distribuee — chaque worker est un serveur HTTP independant:
  *
- *   - LISTER tous les agents persistants (Hermes profiles + live registry)
- *   - VOIR ce que chaque agent fait en temps réel (status, busy/idle, dernière activité)
- *   - DELEGUER une tâche à un autre agent (async avec callback)
- *   - PIPELINE chainé (A→B→C avec passing de contexte)
- *   - FANOUT parallèle (1→N + merge des résultats)
- *   - QUERY multi-agents (poser une question à plusieurs agents simultanément)
- *   - BROADCAST (message global à tous les agents online)
+ *   discord-master (:discord) → routes !trade → TV Analyst :3002
+ *                             → routes !sniper → Sniperbot :3001
  *
- * L'agent qui appelle cet outil découvre AUTOMATIQUEMENT:
- *   - Quels agents existent sur le système (profiles Hermes)
- *   - Leur status (online/busy/idle/offline)
- *   - Leur runner (hermes, claude, kilo, etc.)
- *   - Leur modèle LLM
- *   - Leur dernière activité
- *   - Le compteur A2A (combien de messages envoyés/reçus)
+ *   a2a_hub parle DIRECTEMENT aux workers HTTP:
+ *     POST :300X/send  → message synchrone
+ *     GET  :300X/health → status live
  *
- * Aucune configuration manuelle — l'outil scanne ~/.overmind/hermes/profiles/
- * et croise avec le registry live du bridge.
+ * Decouverte automatique:
+ *   1. Scan ports 3001-3020 (workers connus)
+ *   2. Scan ~/.overmind/hermes/profiles/ (agents Hermes)
+ *   3. Cross-reference: profile ↔ worker port
+ *   4. Lit ~/.overmind/bridge/workers.json si present
  */
 import { z } from 'zod';
 import { execSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-// ─── Discovery: scan profiles + live status ────────────────────────────────
+// ─── HTTP Helper (curl synchrone) ──────────────────────────────────────────
+function httpGet(url, timeoutMs = 5000) {
+    try {
+        const result = execSync(`curl -s -m ${Math.floor(timeoutMs / 1000)} "${url}" 2>/dev/null`, {
+            encoding: 'utf8',
+            timeout: timeoutMs + 1000,
+        });
+        return JSON.parse(result);
+    }
+    catch {
+        return null;
+    }
+}
+function httpPost(url, body, timeoutMs = 300000) {
+    const payload = JSON.stringify(body);
+    try {
+        const escapedPayload = payload.replace(/'/g, "'\\''");
+        const result = execSync(`curl -s -m ${Math.floor(timeoutMs / 1000)} -X POST "${url}" -H "Content-Type: application/json" -d '${escapedPayload}' 2>/dev/null`, { encoding: 'utf8', timeout: timeoutMs + 1000, maxBuffer: 50 * 1024 * 1024 });
+        return JSON.parse(result);
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Worker Discovery ──────────────────────────────────────────────────────
+function discoverWorkers() {
+    const workers = [];
+    const workersJsonPath = path.join(os.homedir(), '.overmind', 'bridge', 'workers.json');
+    // 1. Try reading workers registry
+    let knownPorts = [];
+    if (fs.existsSync(workersJsonPath)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(workersJsonPath, 'utf8'));
+            if (Array.isArray(data.workers)) {
+                knownPorts = data.workers.map((w) => ({
+                    port: w.port,
+                    agentName: w.agentName || 'unknown',
+                }));
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    // 2. Fallback: scan ports 3001-3020
+    if (knownPorts.length === 0) {
+        knownPorts = [];
+        for (let port = 3001; port <= 3020; port++) {
+            knownPorts.push({ port, agentName: '' });
+        }
+    }
+    // 3. Probe each port
+    for (const { port, agentName } of knownPorts) {
+        const url = `http://localhost:${port}`;
+        const health = httpGet(`${url}/health`, 3000);
+        if (health) {
+            // Worker is online — extract agent name from health
+            const detectedAgent = agentName ||
+                health.agent ||
+                health.agentName ||
+                health.service ||
+                'unknown';
+            workers.push({
+                port,
+                url,
+                online: true,
+                agentName: detectedAgent,
+                health,
+            });
+        }
+        else {
+            // Check if port is listening at all
+            workers.push({
+                port,
+                url,
+                online: false,
+                agentName: agentName || '',
+            });
+        }
+    }
+    return workers;
+}
+// ─── Agent Discovery ───────────────────────────────────────────────────────
 function discoverAgents() {
     const home = os.homedir();
-    const profilesDir = process.platform === 'win32'
-        ? path.join(home, '.overmind', 'hermes', 'profiles')
-        : path.join(home, '.overmind', 'hermes', 'profiles');
-    const bridgeUrl = process.env.OVERMIND_BRIDGE_URL || 'http://localhost:3100/rpc';
+    const profilesDir = path.join(home, '.overmind', 'hermes', 'profiles');
     const selfAgent = process.env.OVERMIND_AGENT_NAME || null;
     const agents = [];
-    // 1. Scan Hermes profiles
+    const workers = discoverWorkers();
+    // Build worker lookup: agentName → worker
+    const workerByAgent = new Map();
+    for (const w of workers) {
+        if (w.online && w.agentName && w.agentName !== 'unknown') {
+            workerByAgent.set(w.agentName, w);
+        }
+    }
+    // Scan Hermes profiles
     if (fs.existsSync(profilesDir)) {
         const entries = fs.readdirSync(profilesDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -51,12 +132,12 @@ function discoverAgents() {
             let provider = 'unknown';
             if (fs.existsSync(configPath)) {
                 const config = fs.readFileSync(configPath, 'utf8');
-                const modelMatch = config.match(/model:\s*(.+)/);
-                const providerMatch = config.match(/provider:\s*(.+)/);
+                const modelMatch = config.match(/^\s*model:\s*(?!provider)(.+)/m);
+                const providerMatch = config.match(/^\s*provider:\s*(.+)/m);
                 if (modelMatch)
-                    model = modelMatch[1].trim();
+                    model = modelMatch[1].trim().replace(/['"]/g, '');
                 if (providerMatch)
-                    provider = providerMatch[1].trim();
+                    provider = providerMatch[1].trim().replace(/['"]/g, '');
             }
             // Read profile.yaml for description
             const profileYamlPath = path.join(profilePath, 'profile.yaml');
@@ -92,119 +173,96 @@ function discoverAgents() {
             }
             // Check memory
             const hasMemory = fs.existsSync(path.join(profilePath, 'memories', 'MEMORY.md'));
-            // Last activity (state.db mtime)
+            // Last activity
             let lastActivity = null;
             const stateDb = path.join(profilePath, 'state.db');
             if (fs.existsSync(stateDb)) {
                 try {
-                    const stat = fs.statSync(stateDb);
-                    lastActivity = stat.mtime.toISOString();
+                    lastActivity = fs.statSync(stateDb).mtime.toISOString();
                 }
                 catch {
                     // ignore
                 }
             }
+            // Cross-reference with workers
+            const worker = workerByAgent.get(entry.name);
             agents.push({
                 name: entry.name,
-                runner: 'hermes',
                 model,
-                status: 'unknown', // Will be enriched from bridge if available
                 provider,
-                lastActivity,
+                status: worker ? 'online' : 'offline',
+                workerPort: worker?.port ?? null,
+                workerUrl: worker?.url ?? null,
                 description,
                 skillsCount,
                 hasMemory,
-                a2aCapabilities: ['delegate', 'pipeline', 'fanout', 'query', 'broadcast', 'a2a'],
+                lastActivity,
             });
         }
     }
-    // 2. Try to get live status from bridge
-    let bridgeOnline = false;
-    try {
-        const healthUrl = bridgeUrl.replace('/rpc', '/health');
-        const result = execSync(`curl -s -m 3 "${healthUrl}" 2>/dev/null || echo '{}'`, {
-            encoding: 'utf8',
-            timeout: 5000,
-        });
-        const health = JSON.parse(result);
-        bridgeOnline = health.status === 'online' || health.status === 'degraded';
-        // Enrich agents with live status from registry
-        if (health.agents && Array.isArray(health.agents)) {
-            for (const liveAgent of health.agents) {
-                const found = agents.find((a) => a.name === liveAgent.name);
-                if (found) {
-                    found.status = liveAgent.status;
-                }
-            }
-        }
-    }
-    catch {
-        // Bridge not reachable — agents keep 'unknown' status
-    }
-    // Default 'offline' for agents we couldn't reach
-    for (const a of agents) {
-        if (a.status === 'unknown')
-            a.status = 'offline';
-    }
     return {
         totalAgents: agents.length,
-        onlineAgents: agents.filter((a) => a.status === 'online').length,
-        busyAgents: agents.filter((a) => a.status === 'busy').length,
+        onlineWorkers: workers.filter((w) => w.online).length,
         agents,
+        workers,
         selfAgent,
-        bridgeUrl,
-        bridgeOnline,
     };
 }
-// ─── RPC Helper ────────────────────────────────────────────────────────────
-function rpcCall(method, params) {
-    const bridgeUrl = process.env.OVERMIND_BRIDGE_URL || 'http://localhost:3100/rpc';
-    const payload = JSON.stringify({
-        jsonrpc: '2.0',
-        id: Date.now(),
-        method,
-        params,
-    });
-    try {
-        const result = execSync(`curl -s -m 300 -X POST "${bridgeUrl}" -H "Content-Type: application/json" -d '${payload.replace(/'/g, "'\\''")}' 2>/dev/null`, { encoding: 'utf8', timeout: 310000, maxBuffer: 50 * 1024 * 1024 });
-        const response = JSON.parse(result);
-        if (response.error) {
-            return {
-                error: response.error.message,
-                code: response.error.code,
-            };
-        }
-        return response.result;
+// ─── Send message to a worker ──────────────────────────────────────────────
+function sendToWorker(port, message, opts = {}) {
+    const url = `http://localhost:${port}/send`;
+    const body = {
+        message,
+        userId: `a2a_${process.env.OVERMIND_AGENT_NAME || 'system'}`,
+        username: process.env.OVERMIND_AGENT_NAME || 'A2A Hub',
+        channelId: 'a2a',
+    };
+    if (opts.model)
+        body.model = opts.model;
+    const response = httpPost(url, body, opts.timeoutMs ?? 300000);
+    if (response === null) {
+        return { success: false, text: `Worker :${port} injoignable`, raw: null };
     }
-    catch (err) {
-        return { error: err.message };
+    if (response.error) {
+        return {
+            success: false,
+            text: `Erreur :${port}: ${response.error}`,
+            raw: response,
+        };
     }
+    // Workers may return { result, content, response, output }
+    const text = response.result ||
+        response.response ||
+        response.output ||
+        (Array.isArray(response.content)
+            ? response.content.map((c) => c.text || '').join('\n')
+            : '') ||
+        JSON.stringify(response);
+    return { success: true, text, raw: response };
 }
 // ─── Schema ────────────────────────────────────────────────────────────────
 export const a2aHubSchema = z.object({
     action: z
         .enum(['discover', 'status', 'send', 'delegate', 'pipeline', 'fanout', 'query', 'broadcast'])
-        .describe("Action à effectuer: discover=liste tous les agents, status=état d'un agent, send=message synchrone, delegate=async+callback, pipeline=chaîne A→B→C, fanout=1→N parallèle+merge, query=question multi-agents, broadcast=message global"),
-    // ─── Target (for send/delegate/status) ──────────────────────────────────
-    target: z.string().optional().describe("Nom de l'agent cible (ex: 'sniperbot_analyst')"),
-    // ─── Message ─────────────────────────────────────────────────────────────
+        .describe("Action: discover=liste tous les agents+workers, status=état d'un worker, send=message synchrone, delegate=async, pipeline=chaîne A→B→C, fanout=1→N+merge, query=multi-agents, broadcast=global"),
+    target: z
+        .string()
+        .optional()
+        .describe("Nom de l'agent cible (ex: 'sniperbot_analyst') OU port du worker (ex: '3001')"),
     message: z.string().optional().describe('Le message/prompt à envoyer aux agents'),
-    // ─── Targets (for fanout/query/broadcast/pipeline) ──────────────────────
     targets: z
         .array(z.string())
         .optional()
-        .describe('Liste des agents cibles (pour fanout/query). Si absent pour broadcast → tous les agents online'),
-    // ─── Pipeline steps ──────────────────────────────────────────────────────
+        .describe('Liste des agents cibles (noms ou ports) pour fanout/query/broadcast'),
     steps: z
         .array(z.object({
-        agentName: z.string(),
+        agentName: z
+            .string()
+            .describe("Nom de l'agent ou port (ex: 'sniperbot_analyst' ou '3001')"),
         promptPrefix: z.string().optional(),
     }))
         .optional()
         .describe('Étapes de la pipeline (pour action=pipeline)'),
-    // ─── Options ─────────────────────────────────────────────────────────────
-    runner: z.string().optional().default('hermes').describe('Runner à utiliser (default: hermes)'),
-    model: z.string().optional().describe('Modèle LLM à utiliser (override)'),
     mergeStrategy: z
         .enum(['concat', 'best', 'vote', 'first_success'])
         .optional()
@@ -214,232 +272,225 @@ export const a2aHubSchema = z.object({
         .boolean()
         .optional()
         .default(false)
-        .describe("Pour broadcast: si true, retourne dès qu'un agent répond"),
+        .describe('Pour broadcast: si true, premier qui répond gagne'),
     async: z
         .boolean()
         .optional()
         .default(true)
-        .describe('Pour delegate: si true (default), retourne immédiatement avec un taskId'),
-    callbackUrl: z
-        .string()
-        .optional()
-        .describe("Pour delegate: URL appelée quand l'agent termine (POST result)"),
+        .describe('Pour delegate: si true (default), retourne immédiatement'),
     accumulateContext: z
         .boolean()
         .optional()
         .default(false)
-        .describe('Pour pipeline: si true, chaque step reçoit tous les outputs précédents'),
+        .describe('Pour pipeline: chaque step reçoit tous les outputs précédents'),
     timeoutMs: z
         .number()
         .int()
-        .min(1000)
-        .max(3600000)
+        .min(5000)
+        .max(600000)
         .optional()
-        .describe('Timeout en ms (défaut selon action)'),
+        .describe('Timeout par agent en ms (default: 300000 = 5min)'),
+    model: z.string().optional().describe('Modèle LLM override'),
 });
+// ─── Resolve agent name to worker port ─────────────────────────────────────
+function resolveTarget(target, discovery) {
+    // If target is a port number
+    const portMatch = target.match(/^(\d{4,5})$/);
+    if (portMatch) {
+        const port = parseInt(portMatch[1], 10);
+        const worker = discovery.workers.find((w) => w.port === port);
+        return { port, agentName: worker?.agentName || target };
+    }
+    // If target is an agent name, find its worker
+    const agent = discovery.agents.find((a) => a.name === target);
+    if (agent?.workerPort) {
+        return { port: agent.workerPort, agentName: target };
+    }
+    // Try online workers
+    const worker = discovery.workers.find((w) => w.online && w.agentName === target);
+    if (worker) {
+        return { port: worker.port, agentName: target };
+    }
+    return { port: null, agentName: target };
+}
 // ─── Execute ───────────────────────────────────────────────────────────────
 export async function a2aHub(args) {
     const selfAgent = process.env.OVERMIND_AGENT_NAME || 'unknown';
-    const { action } = args;
+    const timeout = args.timeoutMs ?? 300000;
     try {
-        switch (action) {
+        switch (args.action) {
             // ═══════════════════════════════════════════════════════════════════════
-            // DISCOVER — Liste TOUS les agents + leur status temps réel
+            // DISCOVER
             // ═══════════════════════════════════════════════════════════════════════
             case 'discover': {
-                const discovery = discoverAgents();
+                const d = discoverAgents();
                 const lines = [
                     `🌐 **A2A Hub — Découverte du système multi-agents**`,
                     ``,
-                    `**Self:** ${discovery.selfAgent || '(inconnu)'}`,
-                    `**Bridge:** ${discovery.bridgeUrl} (${discovery.bridgeOnline ? '✅ online' : '❌ offline'})`,
-                    `**Total agents:** ${discovery.totalAgents} | **Online:** ${discovery.onlineAgents} | **Busy:** ${discovery.busyAgents}`,
+                    `**Self:** ${d.selfAgent || '(inconnu)'}`,
+                    `**Workers online:** ${d.onlineWorkers}`,
+                    `**Total agents:** ${d.totalAgents}`,
+                    ``,
+                    `### Workers HTTP`,
                     ``,
                 ];
-                if (discovery.agents.length === 0) {
+                const onlineWorkers = d.workers.filter((w) => w.online);
+                if (onlineWorkers.length === 0) {
+                    lines.push('Aucun worker HTTP en ligne.');
+                }
+                else {
+                    lines.push('| Port | Agent | Status | URL |');
+                    lines.push('|------|-------|--------|-----|');
+                    for (const w of onlineWorkers) {
+                        lines.push(`| :${w.port} | ${w.agentName} | 🟢 online | ${w.url} |`);
+                    }
+                }
+                lines.push('');
+                lines.push('### Agents Hermes');
+                lines.push('');
+                if (d.agents.length === 0) {
                     lines.push('Aucun agent trouvé dans ~/.overmind/hermes/profiles/');
                 }
                 else {
-                    lines.push('| Agent | Status | Model | Provider | Skills | Description |');
-                    lines.push('|-------|--------|-------|----------|--------|-------------|');
-                    for (const a of discovery.agents) {
-                        const statusIcon = a.status === 'online'
-                            ? '🟢'
-                            : a.status === 'busy'
-                                ? '🟡'
-                                : a.status === 'idle'
-                                    ? '⚪'
-                                    : '🔴';
-                        lines.push(`| ${a.name === selfAgent ? '**' + a.name + ' (self)**' : a.name} | ${statusIcon} ${a.status} | ${a.model} | ${a.provider} | ${a.skillsCount} | ${a.description.slice(0, 40)} |`);
+                    lines.push('| Agent | Status | Worker | Model | Provider | Skills | Description |');
+                    lines.push('|-------|--------|--------|-------|----------|--------|-------------|');
+                    for (const a of d.agents) {
+                        const statusIcon = a.status === 'online' ? '🟢' : '🔴';
+                        const workerInfo = a.workerPort ? `:${a.workerPort}` : '—';
+                        const nameDisplay = a.name === selfAgent ? `**${a.name} (self)**` : a.name;
+                        lines.push(`| ${nameDisplay} | ${statusIcon} ${a.status} | ${workerInfo} | ${a.model} | ${a.provider} | ${a.skillsCount} | ${a.description.slice(0, 40)} |`);
                     }
-                    lines.push('');
-                    lines.push('**Capacités A2A disponibles:**');
-                    lines.push('  • `send` — Message synchrone A→B');
-                    lines.push('  • `delegate` — Tâche async + callback');
-                    lines.push('  • `pipeline` — Chaîne A→B→C');
-                    lines.push('  • `fanout` — 1→N parallèle + merge');
-                    lines.push('  • `query` — Question multi-agents');
-                    lines.push('  • `broadcast` — Message global');
                 }
-                return {
-                    content: [{ type: 'text', text: lines.join('\n') }],
-                };
+                lines.push('');
+                lines.push('**Actions disponibles:** send, delegate, pipeline, fanout, query, broadcast');
+                lines.push('**Exemple:** a2a_hub(action: "send", target: "sniperbot_analyst", message: "Analyse BTC")');
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
             }
             // ═══════════════════════════════════════════════════════════════════════
-            // STATUS — État détaillé d'un agent
+            // STATUS
             // ═══════════════════════════════════════════════════════════════════════
             case 'status': {
                 if (!args.target) {
                     return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: '❌ Paramètre `target` requis pour action=status',
-                            },
-                        ],
+                        content: [{ type: 'text', text: '❌ `target` requis (nom ou port)' }],
                         isError: true,
                     };
                 }
-                const result = rpcCall('agent.status', {
-                    agentName: args.target,
-                    runner: args.runner,
-                    action: 'status',
-                });
-                const r = result;
-                if (r.error) {
+                const d = discoverAgents();
+                const { port, agentName } = resolveTarget(args.target, d);
+                if (!port) {
                     return {
                         content: [
-                            {
-                                type: 'text',
-                                text: `❌ Erreur status ${args.target}: ${r.error}`,
-                            },
+                            { type: 'text', text: `❌ Worker pour "${args.target}" introuvable` },
                         ],
                         isError: true,
                     };
                 }
-                const local = (r.local || r.result?.local);
-                const lines = [`📊 **Status: ${args.target}**`, ``];
-                if (local) {
-                    lines.push(`**État local:** ${local.status || 'unknown'}`);
-                    lines.push(`**Runner:** ${local.runner || 'unknown'}`);
-                    lines.push(`**Total runs:** ${local.totalRuns || 0}`);
-                    lines.push(`**Erreurs:** ${local.totalErrors || 0}`);
-                    lines.push(`**A2A reçus:** ${local.a2aReceived || 0}`);
-                    lines.push(`**A2A envoyés:** ${local.a2aSent || 0}`);
-                    if (local.currentSessionId) {
-                        lines.push(`**Session:** ${local.currentSessionId}`);
-                    }
-                    if (local.lastActivityAt) {
-                        lines.push(`**Dernière activité:** ${new Date(local.lastActivityAt).toISOString()}`);
-                    }
+                const health = httpGet(`http://localhost:${port}/health`);
+                if (!health) {
+                    return {
+                        content: [{ type: 'text', text: `❌ Worker :${port} injoignable` }],
+                        isError: true,
+                    };
                 }
-                return {
-                    content: [{ type: 'text', text: lines.join('\n') }],
-                };
+                const lines = [`📊 **Status: ${agentName} (:${port})**`, ``];
+                for (const [key, value] of Object.entries(health)) {
+                    lines.push(`**${key}:** ${typeof value === 'object' ? JSON.stringify(value).slice(0, 100) : value}`);
+                }
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
             }
             // ═══════════════════════════════════════════════════════════════════════
-            // SEND — Message synchrone A→B (via agent.a2a)
+            // SEND
             // ═══════════════════════════════════════════════════════════════════════
             case 'send': {
                 if (!args.target || !args.message) {
+                    return {
+                        content: [{ type: 'text', text: '❌ `target` et `message` requis' }],
+                        isError: true,
+                    };
+                }
+                const d = discoverAgents();
+                const { port, agentName } = resolveTarget(args.target, d);
+                if (!port) {
                     return {
                         content: [
                             {
                                 type: 'text',
-                                text: '❌ Paramètres `target` et `message` requis pour action=send',
+                                text: `❌ Worker pour "${args.target}" introuvable. Utilisez action=discover pour lister les agents.`,
                             },
                         ],
                         isError: true,
                     };
                 }
-                const result = rpcCall('agent.a2a', {
-                    fromAgent: selfAgent,
-                    toAgent: args.target,
-                    runner: args.runner,
-                    prompt: args.message,
-                    ...(args.model ? { model: args.model } : {}),
+                const enrichedMessage = `[A2A — Message from ${selfAgent}]\n${args.message}`;
+                const result = sendToWorker(port, enrichedMessage, {
+                    model: args.model,
+                    timeoutMs: timeout,
                 });
-                const r = result;
-                if (r.error) {
+                if (!result.success) {
                     return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `❌ Erreur send → ${args.target}: ${r.error}`,
-                            },
-                        ],
+                        content: [{ type: 'text', text: `❌ ${result.text}` }],
                         isError: true,
                     };
                 }
-                const content = (r.content || []);
-                const responseText = content.map((c) => c.text).join('\n');
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `📤 **Message envoyé à ${args.target}**\n\n${responseText}`,
+                            text: `📤 **Message envoyé à ${agentName} (:${port})**\n\n${result.text}`,
                         },
                     ],
                 };
             }
             // ═══════════════════════════════════════════════════════════════════════
-            // DELEGATE — Async fire-and-forget + callback
+            // DELEGATE (async — fire and forget)
             // ═══════════════════════════════════════════════════════════════════════
             case 'delegate': {
                 if (!args.target || !args.message) {
                     return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: '❌ Paramètres `target` et `message` requis pour action=delegate',
-                            },
-                        ],
+                        content: [{ type: 'text', text: '❌ `target` et `message` requis' }],
                         isError: true,
                     };
                 }
-                const result = rpcCall('agent.delegate', {
-                    fromAgent: selfAgent,
-                    toAgent: args.target,
-                    runner: args.runner,
-                    prompt: args.message,
-                    async: args.async,
-                    ...(args.model ? { model: args.model } : {}),
-                    ...(args.callbackUrl ? { callbackUrl: args.callbackUrl } : {}),
-                });
-                const r = result;
-                if (r.error) {
+                const d = discoverAgents();
+                const { port, agentName } = resolveTarget(args.target, d);
+                if (!port) {
                     return {
                         content: [
-                            {
-                                type: 'text',
-                                text: `❌ Erreur delegate → ${args.target}: ${r.error}`,
-                            },
+                            { type: 'text', text: `❌ Worker pour "${args.target}" introuvable` },
                         ],
                         isError: true,
                     };
                 }
-                if (args.async) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `🤝 **Tâche déléguée à ${args.target}**\n\n**TaskId:** ${r.taskId}\n**Status:** ${r.status}\n${r.message || ''}`,
-                            },
-                        ],
-                    };
+                // Fire and forget — don't wait for response
+                const enrichedMessage = `[A2A — Delegate from ${selfAgent}]\n${args.message}`;
+                const url = `http://localhost:${port}/send`;
+                const body = {
+                    message: enrichedMessage,
+                    userId: `a2a_${selfAgent}`,
+                    username: selfAgent,
+                    channelId: 'a2a_delegate',
+                    ...(args.model ? { model: args.model } : {}),
+                };
+                // Spawn curl in background (fire-and-forget)
+                try {
+                    const payload = JSON.stringify(body).replace(/'/g, "'\\''");
+                    execSync(`nohup curl -s -m ${Math.floor(timeout / 1000)} -X POST "${url}" -H "Content-Type: application/json" -d '${payload}' > /dev/null 2>&1 &`, { timeout: 2000 });
+                }
+                catch {
+                    // ignore — fire and forget
                 }
-                const content = (r.content || []);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `✅ **${args.target} a terminé**\n\n${content.map((c) => c.text).join('\n')}`,
+                            text: `🤝 **Tâche déléguée à ${agentName} (:${port})**\n\nLe worker traite la requête en arrière-plan. Le résultat sera disponible dans sa session.`,
                         },
                     ],
                 };
             }
             // ═══════════════════════════════════════════════════════════════════════
-            // PIPELINE — Chaîne séquentielle A→B→C
+            // PIPELINE
             // ═══════════════════════════════════════════════════════════════════════
             case 'pipeline': {
                 if (!args.message || !args.steps || args.steps.length === 0) {
@@ -447,201 +498,227 @@ export async function a2aHub(args) {
                         content: [
                             {
                                 type: 'text',
-                                text: "❌ Paramètres `message` (prompt initial) et `steps` (chaîne d'agents) requis pour action=pipeline",
+                                text: '❌ `message` (prompt initial) et `steps` requis pour pipeline',
                             },
                         ],
                         isError: true,
                     };
                 }
-                const result = rpcCall('agent.pipeline', {
-                    initiator: selfAgent,
-                    runner: args.runner,
-                    prompt: args.message,
-                    steps: args.steps,
-                    accumulateContext: args.accumulateContext,
-                    ...(args.timeoutMs ? { totalTimeoutMs: args.timeoutMs } : {}),
-                });
-                const r = result;
-                if (r.error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `❌ Erreur pipeline: ${r.error}`,
-                            },
-                        ],
-                        isError: true,
-                    };
+                const d = discoverAgents();
+                const outputs = [];
+                let currentPrompt = args.message;
+                for (let i = 0; i < args.steps.length; i++) {
+                    const step = args.steps[i];
+                    const { port, agentName } = resolveTarget(step.agentName, d);
+                    if (!port) {
+                        outputs.push({ agent: step.agentName, output: 'Worker introuvable', success: false });
+                        break;
+                    }
+                    const stepPrompt = (step.promptPrefix ? step.promptPrefix + '\n\n' : '') +
+                        `[Pipeline Step ${i + 1}/${args.steps.length}]\n${currentPrompt}`;
+                    const result = sendToWorker(port, stepPrompt, { timeoutMs: timeout });
+                    outputs.push({
+                        agent: `${agentName} (:${port})`,
+                        output: result.text,
+                        success: result.success,
+                    });
+                    if (!result.success)
+                        break;
+                    currentPrompt = args.accumulateContext
+                        ? outputs.map((o) => `[${o.agent}]: ${o.output}`).join('\n\n---\n\n')
+                        : result.text;
                 }
-                const outputs = (r.outputs || []);
                 const lines = [
-                    `🔗 **Pipeline terminé** (${r.executedSteps}/${r.totalSteps} steps)`,
+                    `🔗 **Pipeline terminé** (${outputs.length}/${args.steps.length} steps)`,
                     ``,
                 ];
                 for (const o of outputs) {
-                    lines.push(`**${o.success ? '✅' : '❌'} ${o.agentName}:**`);
-                    lines.push(o.output.slice(0, 500) + (o.output.length > 500 ? '...' : ''));
+                    lines.push(`**${o.success ? '✅' : '❌'} ${o.agent}:**`);
+                    lines.push(o.output.slice(0, 800) + (o.output.length > 800 ? '...' : ''));
                     lines.push('');
                 }
-                lines.push(`**Output final:**`);
-                lines.push((r.finalOutput || '').slice(0, 1000));
-                return {
-                    content: [{ type: 'text', text: lines.join('\n') }],
-                };
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
             }
             // ═══════════════════════════════════════════════════════════════════════
-            // FANOUT — 1→N parallèle + merge
+            // FANOUT
             // ═══════════════════════════════════════════════════════════════════════
             case 'fanout': {
                 if (!args.message || !args.targets || args.targets.length === 0) {
                     return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: '❌ Paramètres `message` et `targets` requis pour action=fanout',
-                            },
-                        ],
+                        content: [{ type: 'text', text: '❌ `message` et `targets` requis' }],
                         isError: true,
                     };
                 }
-                const result = rpcCall('agent.fanout', {
-                    fromAgent: selfAgent,
-                    runner: args.runner,
-                    prompt: args.message,
-                    targets: args.targets,
-                    mergeStrategy: args.mergeStrategy,
-                    ...(args.model ? { model: args.model } : {}),
-                    ...(args.timeoutMs ? { agentTimeoutMs: args.timeoutMs } : {}),
-                });
-                const r = result;
-                if (r.error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `❌ Erreur fanout: ${r.error}`,
-                            },
-                        ],
-                        isError: true,
-                    };
+                const d = discoverAgents();
+                const enrichedMessage = `[A2A — Fanout from ${selfAgent}]\n${args.message}`;
+                // Run all in parallel
+                const results = args.targets
+                    .map((target) => {
+                    const { port } = resolveTarget(target, d);
+                    if (!port) {
+                        return { agent: target, success: false, text: 'Worker introuvable' };
+                    }
+                    return sendToWorker(port, enrichedMessage, { model: args.model, timeoutMs: timeout });
+                })
+                    .map((r, i) => ({
+                    agent: args.targets[i],
+                    success: r.success,
+                    text: r.text,
+                }));
+                // Merge
+                let merged;
+                let winner;
+                switch (args.mergeStrategy) {
+                    case 'first_success': {
+                        const first = results.find((r) => r.success);
+                        merged = first ? first.text : 'Tous ont échoué';
+                        winner = first?.agent;
+                        break;
+                    }
+                    case 'best': {
+                        const sorted = results
+                            .filter((r) => r.success)
+                            .sort((a, b) => b.text.length - a.text.length);
+                        merged = sorted.length > 0 ? sorted[0].text : 'Tous ont échoué';
+                        winner = sorted[0]?.agent;
+                        break;
+                    }
+                    case 'concat':
+                    default: {
+                        merged = results
+                            .map((r) => `### ${r.agent}${r.success ? '' : ' (ÉCHEC)'}\n${r.text}`)
+                            .join('\n\n---\n\n');
+                        break;
+                    }
                 }
+                const successCount = results.filter((r) => r.success).length;
                 const lines = [
-                    `🌐 **Fanout terminé** (${r.successCount}/${r.totalResults} succès, merge=${r.mergeStrategy})`,
-                    ...(r.winner ? [`**Gagnant:** ${r.winner}`] : []),
+                    `🌐 **Fanout** (${successCount}/${results.length} succès, merge=${args.mergeStrategy})`,
+                    ...(winner ? [`**Gagnant:** ${winner}`] : []),
                     ``,
-                    `**Résultat fusionné:**`,
-                    (r.merged || '').slice(0, 2000),
+                    merged.slice(0, 3000),
                 ];
-                return {
-                    content: [{ type: 'text', text: lines.join('\n') }],
-                };
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
             }
             // ═══════════════════════════════════════════════════════════════════════
-            // QUERY — Question multi-agents rapide
+            // QUERY
             // ═══════════════════════════════════════════════════════════════════════
             case 'query': {
                 if (!args.message || !args.targets || args.targets.length === 0) {
                     return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: '❌ Paramètres `message` et `targets` requis pour action=query',
-                            },
-                        ],
+                        content: [{ type: 'text', text: '❌ `message` et `targets` requis' }],
                         isError: true,
                     };
                 }
-                const result = rpcCall('agent.query', {
-                    fromAgent: selfAgent,
-                    runner: args.runner,
-                    prompt: args.message,
-                    targets: args.targets,
-                    ...(args.model ? { model: args.model } : {}),
-                    ...(args.timeoutMs ? { agentTimeoutMs: args.timeoutMs } : {}),
-                });
-                const r = result;
-                if (r.error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `❌ Erreur query: ${r.error}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                const results = (r.results || []);
+                const d = discoverAgents();
+                const enrichedMessage = `[A2A — Query from ${selfAgent}]\n${args.message}`;
+                const queryTimeout = Math.min(timeout, 60000);
+                const results = args.targets
+                    .map((target) => {
+                    const { port } = resolveTarget(target, d);
+                    if (!port) {
+                        return { agent: target, success: false, text: 'Worker introuvable' };
+                    }
+                    return sendToWorker(port, enrichedMessage, {
+                        model: args.model,
+                        timeoutMs: queryTimeout,
+                    });
+                })
+                    .map((r, i) => ({
+                    agent: args.targets[i],
+                    success: r.success,
+                    text: r.text,
+                }));
                 const lines = [
-                    `❓ **Query multi-agents** (${r.successCount}/${r.totalQueried} réponses)`,
+                    `❓ **Query multi-agents** (${results.filter((r) => r.success).length}/${results.length} réponses)`,
                     ``,
                 ];
-                for (const res of results) {
-                    lines.push(`**${res.success ? '✅' : '❌'} ${res.agentName}:**`);
-                    lines.push(res.text.slice(0, 500) + (res.text.length > 500 ? '...' : ''));
+                for (const r of results) {
+                    lines.push(`**${r.success ? '✅' : '❌'} ${r.agent}:**`);
+                    lines.push(r.text.slice(0, 500) + (r.text.length > 500 ? '...' : ''));
                     lines.push('');
                 }
-                return {
-                    content: [{ type: 'text', text: lines.join('\n') }],
-                };
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
             }
             // ═══════════════════════════════════════════════════════════════════════
-            // BROADCAST — Message global à tous les agents online
+            // BROADCAST
             // ═══════════════════════════════════════════════════════════════════════
             case 'broadcast': {
                 if (!args.message) {
                     return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: '❌ Paramètre `message` requis pour action=broadcast',
-                            },
-                        ],
+                        content: [{ type: 'text', text: '❌ `message` requis' }],
                         isError: true,
                     };
                 }
-                const result = rpcCall('agent.broadcast', {
-                    fromAgent: selfAgent,
-                    runner: args.runner,
-                    prompt: args.message,
-                    race: args.race,
-                    ...(args.targets ? { targets: args.targets } : {}),
-                    ...(args.model ? { model: args.model } : {}),
-                    ...(args.timeoutMs ? { agentTimeoutMs: args.timeoutMs } : {}),
-                });
-                const r = result;
-                if (r.error) {
+                const d = discoverAgents();
+                // Determine targets
+                let targetWorkers;
+                if (args.targets && args.targets.length > 0) {
+                    // Resolve each target to a worker
+                    targetWorkers = args.targets
+                        .map((t) => {
+                        const { port } = resolveTarget(t, d);
+                        return d.workers.find((w) => w.port === port);
+                    })
+                        .filter((w) => w !== undefined);
+                }
+                else {
+                    // All online workers
+                    targetWorkers = d.workers.filter((w) => w.online);
+                }
+                if (targetWorkers.length === 0) {
                     return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `❌ Erreur broadcast: ${r.error}`,
-                            },
-                        ],
+                        content: [{ type: 'text', text: '❌ Aucun worker online pour broadcast' }],
                         isError: true,
                     };
                 }
-                const results = (r.results || []);
-                const lines = [
-                    `📡 **Broadcast ${r.race ? '(race mode)' : ''}** — ${r.successCount}/${r.total} succès`,
-                    ``,
-                ];
-                for (const res of results) {
-                    const text = res.content?.map((c) => c.text).join('\n') || res.error || '';
-                    lines.push(`**${res.success ? '✅' : '❌'} ${res.agentName}:**`);
-                    lines.push(text.slice(0, 300) + (text.length > 300 ? '...' : ''));
+                const enrichedMessage = `[A2A — Broadcast from ${selfAgent}]\n${args.message}`;
+                if (args.race) {
+                    // First to respond wins
+                    for (const w of targetWorkers) {
+                        const result = sendToWorker(w.port, enrichedMessage, {
+                            model: args.model,
+                            timeoutMs: timeout,
+                        });
+                        if (result.success) {
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: `📡 **Broadcast race — ${w.agentName} (:${w.port}) a gagné!**\n\n${result.text}`,
+                                    },
+                                ],
+                            };
+                        }
+                    }
+                    return {
+                        content: [{ type: 'text', text: '❌ Tous les workers ont échoué' }],
+                        isError: true,
+                    };
+                }
+                // Send to all in parallel
+                const results = targetWorkers.map((w) => {
+                    const r = sendToWorker(w.port, enrichedMessage, {
+                        model: args.model,
+                        timeoutMs: timeout,
+                    });
+                    return { agent: `${w.agentName} (:${w.port})`, success: r.success, text: r.text };
+                });
+                const successCount = results.filter((r) => r.success).length;
+                const lines = [`📡 **Broadcast** — ${successCount}/${results.length} succès`, ``];
+                for (const r of results) {
+                    lines.push(`**${r.success ? '✅' : '❌'} ${r.agent}:**`);
+                    lines.push(r.text.slice(0, 300) + (r.text.length > 300 ? '...' : ''));
                     lines.push('');
                 }
-                return {
-                    content: [{ type: 'text', text: lines.join('\n') }],
-                };
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
             }
             default:
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `❌ Action inconnue: ${action}. Actions: discover, status, send, delegate, pipeline, fanout, query, broadcast`,
+                            text: `❌ Action inconnue: ${args.action}`,
                         },
                     ],
                     isError: true,