eacn3 0.5.0 → 0.6.0

package/dist/server.js

@@ -11,9 +11,27 @@ import { z } from "zod";
 import { EACN3_DEFAULT_NETWORK_ENDPOINT } from "./src/models.js";
 import * as state from "./src/state.js";
 import * as net from "./src/network-client.js";
-import * as ws from "./src/event-transport.js";
+import * as transport from "./src/event-transport.js";
 import * as a2a from "./src/a2a-server.js";
 import * as rc from "./src/reverse-control.js";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+// ---------------------------------------------------------------------------
+// Activity log — file-based traceability
+// ---------------------------------------------------------------------------
+const __log_dir = join(dirname(fileURLToPath(import.meta.url)), "..", "logs");
+let __activity_log = null;
+function _writeActivityLog(line) {
+    try {
+        if (!__activity_log) {
+            mkdirSync(__log_dir, { recursive: true });
+            __activity_log = join(__log_dir, "activity.log");
+        }
+        appendFileSync(__activity_log, line + "\n");
+    }
+    catch { }
+}
 // ---------------------------------------------------------------------------
 // Helper: MCP text result
 // ---------------------------------------------------------------------------
@@ -33,15 +51,19 @@ function ok(data) {
 function err(message) {
     return { content: [{ type: "text", text: JSON.stringify({ error: message }) }] };
 }
-/** Log MCP tool calls to stderr for traceability. */
+/** Log MCP tool calls to stderr AND activity.log for traceability. */
 function logToolCall(toolName, params) {
     const ts = new Date().toISOString();
-    console.error(`[MCP] ${ts} CALL ${toolName} params=${JSON.stringify(params)}`);
+    const line = `[MCP] ${ts} CALL ${toolName} params=${JSON.stringify(params)}`;
+    console.error(line);
+    _writeActivityLog(line);
 }
 function logToolResult(toolName, success, detail) {
     const ts = new Date().toISOString();
     const tag = success ? "OK" : "ERR";
-    console.error(`[MCP] ${ts} ${tag}  ${toolName}${detail ? ` ${detail}` : ""}`);
+    const line = `[MCP] ${ts} ${tag}  ${toolName}${detail ? ` ${detail}` : ""}`;
+    console.error(line);
+    _writeActivityLog(line);
 }
 /**
  * Resolve agent ID: use provided value, or auto-inject from state.
@@ -58,18 +80,117 @@ function resolveAgentId(provided) {
         throw new Error("No agents registered. Call eacn3_register_agent first.");
     throw new Error(`Multiple agents registered (${agents.map(a => a.agent_id).join(", ")}). Specify agent_id explicitly.`);
 }
+/**
+ * Detect whether an API error indicates the server/agent registration is stale
+ * on the backend (e.g. "server not found", "agent not found", 404 on discovery).
+ */
+function isStaleRegistrationError(e) {
+    const msg = (e instanceof Error ? e.message : String(e)).toLowerCase();
+    return (msg.includes("404") ||
+        msg.includes("not found") ||
+        msg.includes("not registered") ||
+        msg.includes("unknown server") ||
+        msg.includes("unknown agent"));
+}
+/**
+ * Wrap a tool's async handler to auto-reconnect on stale registration errors.
+ * If the first attempt fails because the backend forgot our server/agent,
+ * trigger autoReconnect() and retry once.
+ */
+async function withAutoReconnect(fn) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        if (isStaleRegistrationError(e) && !reconnecting) {
+            console.error(`[EACN3] stale registration detected, auto-reconnecting before retry...`);
+            await autoReconnect();
+            // Retry once after reconnect
+            return await fn();
+        }
+        throw e;
+    }
+}
 // ---------------------------------------------------------------------------
-// Heartbeat background interval
+// Heartbeat background interval with auto-reconnect
 // ---------------------------------------------------------------------------
 let heartbeatInterval = null;
+let heartbeatConsecutiveFailures = 0;
+let reconnecting = false;
+const HEARTBEAT_FAIL_THRESHOLD = 2; // trigger reconnect after 2 consecutive heartbeat failures
+/**
+ * Attempt to re-register server and agents with the network.
+ * Called when heartbeat failures indicate the backend has forgotten us.
+ */
+async function autoReconnect() {
+    if (reconnecting)
+        return;
+    reconnecting = true;
+    console.error("[EACN3] auto-reconnect: heartbeat failures exceeded threshold, re-registering...");
+    const s = state.getState();
+    try {
+        // Try heartbeat once more — maybe transient
+        try {
+            await net.heartbeat();
+            heartbeatConsecutiveFailures = 0;
+            console.error("[EACN3] auto-reconnect: heartbeat recovered, no re-registration needed");
+            return;
+        }
+        catch { /* still failing */ }
+        // Re-register server
+        const res = await net.registerServer("0.5.1", "plugin://local", "plugin-user");
+        const newSid = res.server_id;
+        s.server_card = {
+            server_id: newSid,
+            version: "0.5.1",
+            endpoint: "plugin://local",
+            owner: "plugin-user",
+            status: "online",
+        };
+        state.saveServerData();
+        // Re-register all owned agents with the new server_id
+        for (const agent of state.listAgents()) {
+            agent.server_id = newSid;
+            try {
+                await net.registerAgent(agent);
+                console.error(`[EACN3] auto-reconnect: re-registered agent ${agent.agent_id}`);
+            }
+            catch (e) {
+                console.error(`[EACN3] auto-reconnect: failed to re-register agent ${agent.agent_id}: ${e.message}`);
+            }
+        }
+        state.save();
+        heartbeatConsecutiveFailures = 0;
+        console.error("[EACN3] auto-reconnect: completed successfully");
+    }
+    catch (e) {
+        console.error(`[EACN3] auto-reconnect: failed: ${e.message}`);
+    }
+    finally {
+        reconnecting = false;
+    }
+}
 function startHeartbeat() {
     if (heartbeatInterval)
         return;
+    heartbeatConsecutiveFailures = 0;
+    // Wire up the connection-degraded callback from network-client
+    net.setConnectionDegradedCallback(() => {
+        console.error("[EACN3] connection degraded (multiple request failures), scheduling reconnect");
+        autoReconnect();
+    });
     heartbeatInterval = setInterval(async () => {
         try {
             await net.heartbeat();
+            heartbeatConsecutiveFailures = 0;
+        }
+        catch (e) {
+            heartbeatConsecutiveFailures++;
+            console.error(`[EACN3] heartbeat failed (${heartbeatConsecutiveFailures}/${HEARTBEAT_FAIL_THRESHOLD}): ${e.message}`);
+            if (heartbeatConsecutiveFailures >= HEARTBEAT_FAIL_THRESHOLD) {
+                autoReconnect();
+            }
         }
-        catch { /* silent */ }
     }, 60_000);
 }
 function stopHeartbeat() {
@@ -77,11 +198,14 @@ function stopHeartbeat() {
         clearInterval(heartbeatInterval);
         heartbeatInterval = null;
     }
+    heartbeatConsecutiveFailures = 0;
 }
 // ---------------------------------------------------------------------------
 // MCP Server
 // ---------------------------------------------------------------------------
-const server = new McpServer({ name: "eacn3", version: "0.5.0" });
+const server = new McpServer({ name: "eacn3", version: "0.5.1" }, {
+    capabilities: { logging: {} },
+});
 // ═══════════════════════════════════════════════════════════════════════════
 // Health / Cluster (2)
 // ═══════════════════════════════════════════════════════════════════════════
@@ -89,12 +213,15 @@ const server = new McpServer({ name: "eacn3", version: "0.5.0" });
 server.tool("eacn3_health", "Check if a network node is alive and responding. No prerequisites — works before eacn3_connect. Returns {status: 'ok'} on success. Use this to verify an endpoint before connecting.", {
     endpoint: z.string().optional().describe("Node URL to probe. Defaults to configured network endpoint."),
 }, async (params) => {
+    logToolCall("eacn3_health", params);
     const target = params.endpoint ?? state.getState().network_endpoint;
     try {
         const health = await net.checkHealth(target);
+        logToolResult("eacn3_health", true);
         return ok({ endpoint: target, ...health });
     }
     catch (e) {
+        logToolResult("eacn3_health", false, e.message);
         return err(`Health check failed for ${target}: ${e.message}`);
     }
 });
@@ -115,7 +242,7 @@ server.tool("eacn3_cluster_status", "Retrieve the full cluster topology includin
 // Server Management (4)
 // ═══════════════════════════════════════════════════════════════════════════
 // #1 eacn3_connect
-server.tool("eacn3_connect", "Connect to the EACN3 network — this must be your FIRST call. Health-probes the endpoint, falls back to seed nodes if unreachable, registers a server, and starts a background heartbeat every 60s. Returns {server_id, network_endpoint, fallback, agents_online, restored_agents, hint}. Side effects: starts event polling for any previously registered agents. IMPORTANT: check restored_agents in the response — if you have previously registered agents, they are already reconnected and ready to use. You do NOT need to re-register them. Only call eacn3_register_agent if you need a NEW agent.", {
+server.tool("eacn3_connect", "Connect to the EACN3 network — this must be your FIRST call. Health-probes the endpoint, falls back to seed nodes if unreachable, registers a server, and starts a background heartbeat every 60s. Returns {server_id, network_endpoint, fallback, available_agents, hint}. IMPORTANT: agents are NOT auto-restored. Check available_agents — if you have a previous agent, call eacn3_claim_agent(agent_id) to resume it. Otherwise call eacn3_register_agent() to create a new one. Only one agent per session.", {
     network_endpoint: z.string().optional().describe(`Network URL. Defaults to ${EACN3_DEFAULT_NETWORK_ENDPOINT}`),
     seed_nodes: z.array(z.string()).optional().describe("Additional seed node URLs for fallback"),
 }, async (params) => {
@@ -143,11 +270,11 @@ server.tool("eacn3_connect", "Connect to the EACN3 network — this must be your
         }
         catch {
             // Server no longer known to network — re-register
-            const res = await net.registerServer("0.5.0", "plugin://local", "plugin-user");
+            const res = await net.registerServer("0.5.1", "plugin://local", "plugin-user");
             sid = res.server_id;
             s.server_card = {
                 server_id: sid,
-                version: "0.5.0",
+                version: "0.5.1",
                 endpoint: "plugin://local",
                 owner: "plugin-user",
                 status: "online",
@@ -163,48 +290,30 @@ server.tool("eacn3_connect", "Connect to the EACN3 network — this must be your
         }
     }
     else {
-        const res = await net.registerServer("0.5.0", "plugin://local", "plugin-user");
+        const res = await net.registerServer("0.5.1", "plugin://local", "plugin-user");
         sid = res.server_id;
         s.server_card = {
             server_id: sid,
-            version: "0.5.0",
+            version: "0.5.1",
             endpoint: "plugin://local",
             owner: "plugin-user",
             status: "online",
         };
     }
-    state.save();
+    state.saveServerData();
     // Start background heartbeat
     startHeartbeat();
-    // Reconnect WS for all existing agents; re-register if network lost them
-    for (const agent of Object.values(s.agents)) {
-        try {
-            await net.getAgentInfo(agent.agent_id);
-        }
-        catch {
-            // Agent not found on network (e.g. server restarted with in-memory DB)
-            try {
-                await net.registerAgent(agent);
-            }
-            catch { /* best-effort */ }
-        }
-        ws.connect(agent.agent_id);
-    }
-    const restoredAgents = Object.values(s.agents).map((a) => ({
-        agent_id: a.agent_id,
-        name: a.name,
-        domains: a.domains,
-        tier: a.tier,
-    }));
+    // List agents available on disk (from previous sessions) — do NOT auto-restore.
+    // Each session must explicitly claim an agent via eacn3_claim_agent.
+    const availableAgents = state.listAvailableAgents();
     return ok({
         connected: true,
         server_id: sid,
         network_endpoint: endpoint,
         fallback,
-        agents_online: restoredAgents.length,
-        restored_agents: restoredAgents,
-        hint: restoredAgents.length > 0
-            ? "You have previously registered agents restored and reconnected. You can use them directly without re-registering. Call eacn3_list_my_agents() for full details."
+        available_agents: availableAgents,
+        hint: availableAgents.length > 0
+            ? "Previous agents found on disk. Call eacn3_claim_agent(agent_id) to resume one, or eacn3_register_agent() to create a new one."
             : "No previous agents found. Register a new agent with eacn3_register_agent().",
         toolkit: {
             workflow: {
@@ -212,9 +321,8 @@ server.tool("eacn3_connect", "Connect to the EACN3 network — this must be your
                 eacn3_get_events: "Drain all pending events at once (bulk alternative to next).",
             },
             team: {
-                eacn3_team_setup: "Form a team of agents around a shared git repo. Creates handshake tasks between all pairs.",
-                eacn3_team_status: "Check team formation progress — which handshakes are done, which peer branches are known.",
-                eacn3_team_set_branch: "Record your git branch name for a team after creating it.",
+                eacn3_team_setup: "Form a team of agents around a shared git repo via ACK message exchange.",
+                eacn3_team_status: "Check team formation progress — which ACKs are exchanged, which peer branches are known.",
             },
             task: {
                 eacn3_create_task: "Publish a task (supports team_id to auto-inject team preamble).",
@@ -227,16 +335,16 @@ server.tool("eacn3_connect", "Connect to the EACN3 network — this must be your
     });
 });
 // #2 eacn3_disconnect
-server.tool("eacn3_disconnect", "Disconnect from the EACN3 network and stop event polling. Requires: eacn3_connect first. Side effects: active tasks will timeout and hurt reputation. Server identity and agent registrations are preserved — on next eacn3_connect they will be automatically reconnected. Returns {disconnected: true}. Only call at end of session.", {}, async () => {
+server.tool("eacn3_disconnect", "Disconnect from the EACN3 network. Requires: eacn3_connect first. Side effects: active tasks will timeout and hurt reputation. Server identity is preserved — on next eacn3_connect you can claim your agent back via eacn3_claim_agent. Returns {disconnected: true}. Only call at end of session.", {}, async () => {
     stopHeartbeat();
-    ws.disconnectAll();
+    transport.disconnectAll();
     // Do NOT call unregisterServer — it cascade-deletes all agents on the network side.
     // We only go offline; identity is preserved for reconnection.
     const s = state.getState();
-    if (s.server_card) {
+    // Don't write server.json — other sessions may still be using this server.
+    // Just clean up this session's in-memory state.
+    if (s.server_card)
         s.server_card.status = "offline";
-    }
-    state.save();
     return ok({ disconnected: true });
 });
 // #3 eacn3_heartbeat
@@ -266,8 +374,45 @@ server.tool("eacn3_server_info", "Get current server connection state, including
     });
 });
 // ═══════════════════════════════════════════════════════════════════════════
-// Agent Management (7)
+// Agent Management (8)
 // ═══════════════════════════════════════════════════════════════════════════
+// #4b eacn3_claim_agent
+server.tool("eacn3_claim_agent", "Claim a previously registered agent from disk into this session. Use this to resume an agent listed in available_agents from eacn3_connect. The agent is re-registered on the network and event transport is started. Only one agent per session.", {
+    agent_id: z.string().describe("ID of the agent to claim (from available_agents)"),
+}, async (params) => {
+    logToolCall("eacn3_claim_agent", params);
+    if (state.listAgents().length > 0) {
+        return err("This session already has an agent. Only one agent per session.");
+    }
+    const agent = state.claimAgent(params.agent_id);
+    if (!agent) {
+        return err(`Agent ${params.agent_id} not found on disk. Use eacn3_register_agent to create a new one.`);
+    }
+    // Re-register on network with current session's server_id
+    const s = state.getState();
+    const oldServerId = agent.server_id;
+    if (s.server_card)
+        agent.server_id = s.server_card.server_id;
+    try {
+        await net.registerAgent(agent);
+    }
+    catch {
+        agent.server_id = oldServerId; // Revert on failure to stay consistent with network
+    }
+    // Start event transport
+    transport.connect(agent.agent_id);
+    // Initialize reverse control
+    rc.configure(agent.agent_id);
+    state.save();
+    logToolResult("eacn3_claim_agent", true, agent.agent_id);
+    return ok({
+        claimed: true,
+        agent_id: agent.agent_id,
+        name: agent.name,
+        domains: agent.domains,
+        tier: agent.tier,
+    });
+});
 // #5 eacn3_register_agent
 // Inlines: adapter (AgentCard assembly) + registry (validate + persist + DHT)
 server.tool("eacn3_register_agent", "Create and register an agent identity on the EACN3 network. Requires: eacn3_connect first. Assembles an AgentCard, registers it with the network, persists it locally, and starts polling for push events (task_broadcast, subtask_completed, etc.). Returns {agent_id, seeds, domains}. Domains control which task broadcasts you receive — be specific (e.g. 'python-coding' not 'coding').", {
@@ -334,8 +479,8 @@ server.tool("eacn3_register_agent", "Create and register an agent identity on th
     const res = await net.registerAgent(card);
     // Persist locally
     state.addAgent(card);
-    // Start polling for push events
-    ws.connect(agentId);
+    // Register agent for on-demand event fetching
+    transport.connect(agentId);
     // Configure reverse control for this agent
     if (params.reverse_control?.enabled !== false) {
         const rcPolicies = {};
@@ -367,9 +512,8 @@ server.tool("eacn3_register_agent", "Create and register an agent identity on th
                 eacn3_get_events: "Drain all pending events at once (bulk alternative to next).",
             },
             team: {
-                eacn3_team_setup: "Form a team of agents around a shared git repo. Creates handshake tasks between all pairs.",
-                eacn3_team_status: "Check team formation progress — which handshakes are done, which peer branches are known.",
-                eacn3_team_set_branch: "Record your git branch name for a team after creating it.",
+                eacn3_team_setup: "Form a team of agents around a shared git repo via ACK message exchange.",
+                eacn3_team_status: "Check team formation progress — which ACKs are exchanged, which peer branches are known.",
             },
             task: {
                 eacn3_create_task: "Publish a task (supports team_id to auto-inject team preamble).",
@@ -425,11 +569,11 @@ server.tool("eacn3_update_agent", "Update a registered agent's mutable fields: n
     return ok({ updated: true, agent_id, ...res });
 });
 // #8 eacn3_unregister_agent
-server.tool("eacn3_unregister_agent", "Remove an agent from the network and stop its event polling. Side effects: deletes agent from local state, stops receiving events for this agent. Active tasks assigned to this agent will timeout and hurt reputation. Returns {unregistered: true, agent_id}.", {
+server.tool("eacn3_unregister_agent", "Remove an agent from the network. Side effects: deletes agent from local state. Active tasks assigned to this agent will timeout and hurt reputation. Returns {unregistered: true, agent_id}.", {
     agent_id: z.string(),
 }, async (params) => {
     const res = await net.unregisterAgent(params.agent_id);
-    ws.disconnect(params.agent_id);
+    transport.disconnect(params.agent_id);
     rc.unconfigure(params.agent_id);
     state.removeAgent(params.agent_id);
     // Stop A2A server if no agents remain
@@ -439,7 +583,7 @@ server.tool("eacn3_unregister_agent", "Remove an agent from the network and stop
     return ok({ unregistered: true, agent_id: params.agent_id, ...res });
 });
 // #9 eacn3_list_my_agents
-server.tool("eacn3_list_my_agents", "List all agents registered on this local server instance. Returns {count, agents[]} where each agent includes agent_id, name, domains, tier, and polling_active (event polling status). No network call — reads local state only. Use to check which agents are active and receiving events.", {}, async () => {
+server.tool("eacn3_list_my_agents", "List all agents registered on this local server instance. Returns {count, agents[]} where each agent includes agent_id, name, domains, tier, and registered status. No network call — reads local state only. Use to check which agents are active.", {}, async () => {
     const agents = state.listAgents();
     return ok({
         count: agents.length,
@@ -447,8 +591,8 @@ server.tool("eacn3_list_my_agents", "List all agents registered on this local se
             agent_id: a.agent_id,
             name: a.name,
             domains: a.domains,
-            connected: ws.isConnected(a.agent_id),
-            transport: ws.getTransportStatus(a.agent_id),
+            connected: transport.isConnected(a.agent_id),
+            transport: transport.getTransportStatus(a.agent_id),
         })),
     });
 });
@@ -579,7 +723,7 @@ server.tool("eacn3_create_task", "Publish a new task to the EACN3 network for ot
         ].filter(Boolean).join("\n");
         finalDescription = `${preamble}\n${params.description}`;
     }
-    const task = await net.createTask({
+    const task = await withAutoReconnect(() => net.createTask({
         task_id: taskId,
         initiator_id: initiatorId,
         content: {
@@ -594,7 +738,7 @@ server.tool("eacn3_create_task", "Publish a new task to the EACN3 network for ot
         human_contact: params.human_contact,
         level: params.level ?? "general",
         invited_agent_ids: params.invited_agent_ids,
-    });
+    }));
     // Track locally
     state.updateTask({
         task_id: taskId,
@@ -605,6 +749,11 @@ server.tool("eacn3_create_task", "Publish a new task to the EACN3 network for ot
         description_summary: params.description.slice(0, 100),
         created_at: new Date().toISOString(),
     });
+    // If team task: reply to pending reverse handshakes with branch + task details
+    if (activeTeam) {
+        const taskSummary = { task_id: taskId, description: params.description.slice(0, 500) };
+        await replyPendingHandshakes(initiatorId, activeTeam, taskSummary);
+    }
     return ok({
         task_id: taskId,
         status: task.status,
@@ -629,25 +778,6 @@ server.tool("eacn3_select_result", "Pick the winning result for a task, triggeri
 }, async (params) => {
     const initiatorId = resolveAgentId(params.initiator_id);
     const res = await net.selectResult(params.task_id, initiatorId, params.agent_id);
-    // If this was a team handshake task, extract peer branch and update local team state
-    const teams = state.getTeamsForAgent(initiatorId);
-    for (const team of teams) {
-        const handshakeTarget = Object.entries(team.handshake_out).find(([, taskId]) => taskId === params.task_id);
-        if (handshakeTarget) {
-            // Fetch the result to get the branch name
-            try {
-                const taskData = await net.getTask(params.task_id);
-                const results = taskData?.results ?? [];
-                const winnerResult = results.find((r) => r.agent_id === params.agent_id);
-                const branch = winnerResult?.content?.branch;
-                if (branch) {
-                    state.updateTeamPeerBranch(team.team_id, handshakeTarget[0], branch);
-                }
-            }
-            catch { /* best effort */ }
-            break;
-        }
-    }
     return ok(res);
 });
 // #19 eacn3_close_task
@@ -763,7 +893,7 @@ server.tool("eacn3_submit_bid", "Bid on an open task by specifying your confiden
     const agentId = resolveAgentId(params.agent_id);
     // Tier/level filtering and invite bypass are handled server-side in matcher.check_bid().
     // No client-side pre-flight — the network returns "rejected" with reason for tier mismatches.
-    const res = await net.submitBid(params.task_id, agentId, params.confidence, params.price);
+    const res = await withAutoReconnect(() => net.submitBid(params.task_id, agentId, params.confidence, params.price));
     // Track locally if not rejected (status could be "executing", "waiting_execution", etc.)
     if (res.status && res.status !== "rejected") {
         state.updateTask({
@@ -786,7 +916,7 @@ server.tool("eacn3_submit_result", "Submit your completed work for a task you ar
     agent_id: z.string().optional().describe("Executor agent ID (auto-injected if omitted)"),
 }, async (params) => {
     const agentId = resolveAgentId(params.agent_id);
-    const res = await net.submitResult(params.task_id, agentId, params.content);
+    const res = await withAutoReconnect(() => net.submitResult(params.task_id, agentId, params.content));
     // Auto-report reputation event (what logger used to do)
     try {
         await net.reportEvent(agentId, "task_completed");
@@ -802,7 +932,7 @@ server.tool("eacn3_reject_task", "Abandon a task you accepted, freeing your exec
     agent_id: z.string().optional().describe("Executor agent ID (auto-injected if omitted)"),
 }, async (params) => {
     const agentId = resolveAgentId(params.agent_id);
-    const res = await net.rejectTask(params.task_id, agentId, params.reason);
+    const res = await withAutoReconnect(() => net.rejectTask(params.task_id, agentId, params.reason));
     // Auto-report reputation event
     try {
         await net.reportEvent(agentId, "task_rejected");
@@ -821,7 +951,7 @@ server.tool("eacn3_create_subtask", "Delegate part of your work by creating a ch
     initiator_id: z.string().optional().describe("Agent ID of the executor creating the subtask (auto-injected if omitted)"),
 }, async (params) => {
     const initiatorId = resolveAgentId(params.initiator_id);
-    const task = await net.createSubtask(params.parent_task_id, initiatorId, { description: params.description }, params.domains, params.budget, params.deadline, params.level);
+    const task = await withAutoReconnect(() => net.createSubtask(params.parent_task_id, initiatorId, { description: params.description }, params.domains, params.budget, params.deadline, params.level));
     return ok({
         subtask_id: task.id,
         parent_task_id: params.parent_task_id,
@@ -878,6 +1008,7 @@ server.tool("eacn3_send_message", "Send a direct agent-to-agent message. Deliver
                     from: senderId,
                     content: params.content,
                 }),
+                signal: AbortSignal.timeout(10_000),
             });
             if (res.ok) {
                 return ok({ sent: true, to: targetId, from: senderId, method: "a2a_direct" });
@@ -971,19 +1102,21 @@ server.tool("eacn3_list_sessions", "List all agents you have active message sess
 });
 // ═══════════════════════════════════════════════════════════════════════════
 // #34 eacn3_get_events
-server.tool("eacn3_get_events", "Drain the in-memory event buffer for a specific agent, returning its pending events and clearing them. Returns {count, events[], reverse_control} where event types include: task_broadcast, bid_request_confirmation, bid_result, discussion_update, subtask_completed, task_collected, task_timeout, adjudication_task, direct_message. With reverse_control enabled, high-priority events may already have been handled via LLM sampling — check reverse_control.status for details. Call periodically in your main loop.", {
+server.tool("eacn3_get_events", "Fetch pending events from the network for a specific agent, plus any locally buffered synthetic events. Returns {count, events[], reverse_control} where event types include: task_broadcast, bid_request_confirmation, bid_result, discussion_update, subtask_completed, task_collected, task_timeout, adjudication_task, direct_message. With reverse_control enabled, high-priority events may already have been handled via LLM sampling — check reverse_control.status for details.", {
     agent_id: z.string().optional().describe("Agent ID to drain events for (auto-injected if omitted)"),
 }, async (params) => {
     const agentId = resolveAgentId(params.agent_id);
-    const events = state.drainEvents(agentId);
+    const networkEvents = await transport.fetchEvents(agentId, 0);
+    const localEvents = state.drainEvents(agentId);
+    const events = [...networkEvents, ...localEvents].filter((e) => !e._handled);
     return ok({
         count: events.length,
         events,
         reverse_control: rc.getStatus(),
     });
 });
-// #39 eacn3_await_events — long-polling reverse control
-server.tool("eacn3_await_events", "Block until a network event arrives or timeout expires, then return with the event AND a suggested action. This is the reverse-control mechanism when MCP sampling is unavailable (e.g. OpenClaw). Instead of polling eacn3_get_events in a loop, call this — it waits for the network to push something, then tells you exactly what to do. Returns {event, suggested_action, suggested_tool, suggested_params, urgency} per event, or {timeout: true}. Prefer this over eacn3_get_events for reactive agent loops.", {
+// #39 eacn3_await_events — on-demand long-polling
+server.tool("eacn3_await_events", "Fetch events from the network with a configurable wait time. First checks locally buffered synthetic events, then does a single long-poll to the network. Returns {event, suggested_action, suggested_tool, suggested_params, urgency} per event, or {timeout: true}. Prefer this over eacn3_get_events for reactive agent loops.", {
     agent_id: z.string().optional().describe("Agent ID to await events for (auto-injected if omitted)"),
     timeout_seconds: z.number().optional().describe("Max seconds to wait (1-120). Default 30."),
     event_types: z.array(z.string()).optional().describe("Only return for these event types. Default: all."),
@@ -991,27 +1124,29 @@ server.tool("eacn3_await_events", "Block until a network event arrives or timeou
     const agentId = resolveAgentId(params.agent_id);
     const timeoutSec = Math.min(Math.max(params.timeout_seconds ?? 30, 1), 120);
     const filterTypes = params.event_types;
-    // Check immediate buffered events
-    const immediate = drainMatchingEvents(agentId, filterTypes);
+    // Check locally buffered synthetic events first
+    const immediate = drainMatchingEvents(agentId, filterTypes).filter((e) => !e._handled);
     if (immediate.length > 0) {
         return ok(buildAwaitResponse(immediate));
     }
-    // Long-poll
-    const result = await new Promise((resolve) => {
-        const deadline = setTimeout(() => { cleanup(); resolve([]); }, timeoutSec * 1000);
-        const poll = setInterval(() => {
-            const events = drainMatchingEvents(agentId, filterTypes);
-            if (events.length > 0) {
-                cleanup();
-                resolve(events);
-            }
-        }, 500);
-        function cleanup() { clearTimeout(deadline); clearInterval(poll); }
-    });
-    if (result.length === 0) {
+    // Single long-poll to network with the agent's requested timeout
+    const networkEvents = await transport.fetchEvents(agentId, timeoutSec);
+    const localAfter = drainMatchingEvents(agentId, filterTypes);
+    const all = [...networkEvents, ...localAfter].filter((e) => !e._handled);
+    // Filter by event types if specified
+    const filtered = filterTypes && filterTypes.length > 0
+        ? all.filter((e) => filterTypes.includes(e.type))
+        : all;
+    // Put back non-matching events
+    if (filterTypes && filterTypes.length > 0) {
+        const remaining = all.filter((e) => !filterTypes.includes(e.type));
+        if (remaining.length > 0)
+            state.pushEvents(agentId, remaining);
+    }
+    if (filtered.length === 0) {
         return ok({ timeout: true, waited_seconds: timeoutSec, hint: "No events arrived. Call again to keep waiting, or proceed with other work." });
     }
-    return ok(buildAwaitResponse(result));
+    return ok(buildAwaitResponse(filtered));
 });
 // #41 eacn3_next — single-event non-blocking poll
 const URGENCY_ORDER = {
@@ -1030,22 +1165,6 @@ function buildNextAction(event) {
     const payload = event.payload;
     switch (event.type) {
         case "task_broadcast": {
-            // Detect team handshake tasks
-            const desc = String(payload?.description ?? "");
-            if (desc.startsWith("Team handshake:") || payload?.budget === 0) {
-                // Check if this looks like a handshake (0-budget, team-coordination domain)
-                const domains = payload.domains ?? [];
-                if (domains.includes("team-coordination")) {
-                    return {
-                        action: "handshake",
-                        description: `Team handshake from another agent on task ${event.task_id}. ` +
-                            `Bid with price=0 confidence=1, then submit_result with your branch name: ` +
-                            `{branch: "agent/your-id", _handshake_ack: true, team_id: "..."}.`,
-                        tool: "eacn3_submit_bid",
-                        params: { task_id: event.task_id, confidence: 1, price: 0 },
-                    };
-                }
-            }
             return {
                 action: "bid",
                 description: `New task [${(payload.domains ?? []).join(", ")}] budget=${payload.budget ?? "?"}. Evaluate and bid.`,
@@ -1125,7 +1244,10 @@ server.tool("eacn3_next", "Non-blocking single-step work dispatcher: returns the
     agent_id: z.string().optional().describe("Agent ID (auto-injected if omitted)"),
 }, async (params) => {
     const agentId = resolveAgentId(params.agent_id);
-    const events = state.drainEvents(agentId);
+    // Fetch from network (non-blocking) + drain local synthetic events
+    const networkEvents = await transport.fetchEvents(agentId, 0);
+    const localEvents = state.drainEvents(agentId);
+    const events = [...networkEvents, ...localEvents].filter((e) => !e._handled);
     if (events.length === 0) {
         // Build context-aware prompts based on agent's current task state
         const tasks = Object.values(state.getState().local_tasks).filter((t) => t.agent_id === agentId);
@@ -1186,128 +1308,95 @@ server.tool("eacn3_next", "Non-blocking single-step work dispatcher: returns the
         ...next,
     });
 });
-// #42 eacn3_team_setup — human-facing team coordination toolkit
-server.tool("eacn3_team_setup", "Human-facing toolkit: form a team of agents around a shared git repo. " +
-    "Creates 0-budget handshake tasks between every pair of agents (both directions). " +
-    "Each agent creates its own operation branch and learns peers' branches through handshake responses. " +
-    "Set peers_running_next=true if other agents already have next loops — this agent will notify them via messages first.", {
+// #42 eacn3_team_setup — task-based team handshake (fully automatic)
+server.tool("eacn3_team_setup", "Form a team of agents around a shared git repo. " +
+    "Creates handshake tasks (0-budget, 30-min deadline) to exchange branch info with each peer. " +
+    "Peers auto-bid and auto-reply; handshake is purely for branch exchange. " +
+    "After team is ready, use eacn3_create_task with team_id to publish work for the team.", {
     agent_ids: z.array(z.string()).min(2).describe("Agent IDs to form a team"),
     git_repo: z.string().describe("Git repo URL for recording operations"),
-    peers_running_next: z.boolean().optional().describe("If true, notify peers via messages before handshakes"),
+    my_branch: z.string().describe("This agent's operation branch name"),
 }, async (params) => {
-    const localAgents = state.listAgents();
-    const localIds = new Set(localAgents.map((a) => a.agent_id));
-    // Find which of the requested agents are local
-    const myAgents = params.agent_ids.filter((id) => localIds.has(id));
-    if (myAgents.length === 0) {
-        return err("None of the specified agent_ids are registered on this server");
+    // Only the calling agent creates outgoing handshakes — peers join via autoHandshakeRespond
+    const myId = resolveAgentId(undefined);
+    if (!state.getAgent(myId)) {
+        return err(`Agent ${myId} is not registered on this server`);
+    }
+    if (!params.agent_ids.includes(myId)) {
+        return err(`Your agent ID ${myId} must be included in agent_ids`);
     }
     const teamId = `team-${Date.now().toString(36)}`;
-    const results = [];
-    for (const myId of myAgents) {
-        const peers = params.agent_ids.filter((id) => id !== myId);
-        // Save team info
-        const teamInfo = {
-            team_id: teamId,
-            git_repo: params.git_repo,
-            agent_ids: params.agent_ids,
-            my_agent_id: myId,
-            peer_branches: {},
-            handshake_out: {},
-            handshake_in: {},
-            status: "forming",
-        };
-        // If peers are running next loops, notify them first
-        if (params.peers_running_next) {
-            for (const peerId of peers) {
-                try {
-                    const msg = JSON.stringify({
-                        _team_notify: true,
-                        team_id: teamId,
-                        git_repo: params.git_repo,
-                        team_members: params.agent_ids,
-                        message: `Team setup initiated. You will receive handshake tasks shortly. Create your branch in ${params.git_repo} and respond with your branch name.`,
-                    });
-                    await net.relayMessage({
-                        to: { network_id: "", server_id: "", agent_id: peerId },
-                        from: { network_id: "", server_id: state.getServerId() ?? "", agent_id: myId },
-                        content: msg,
-                    });
-                }
-                catch { /* best-effort notification */ }
-            }
+    const peers = params.agent_ids.filter((id) => id !== myId);
+    const teamInfo = {
+        team_id: teamId,
+        git_repo: params.git_repo,
+        agent_ids: params.agent_ids,
+        my_agent_id: myId,
+        my_branch: params.my_branch,
+        peer_branches: {},
+        ack_out: {},
+        ack_in: {},
+        is_initiator: true,
+        status: "forming",
+    };
+    const tasksCreated = [];
+    const failed = [];
+    for (const peerId of peers) {
+        try {
+            const taskId = `t-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+            const handshakeDeadline = new Date(Date.now() + 30 * 60 * 1000).toISOString();
+            const task = await net.createTask({
+                task_id: taskId,
+                initiator_id: myId,
+                content: { description: `Team handshake: ${myId} → ${peerId} [team=${teamId}] [repo=${params.git_repo}] [members=${params.agent_ids.join(",")}]` },
+                domains: ["team-coordination"],
+                budget: 0,
+                deadline: handshakeDeadline,
+                max_concurrent_bidders: 1,
+                max_depth: 0,
+                invited_agent_ids: [peerId],
+            });
+            teamInfo.ack_out[peerId] = task.id;
+            tasksCreated.push(task.id);
+            state.updateTask({
+                task_id: task.id,
+                agent_id: myId,
+                role: "initiator",
+                status: task.status,
+                domains: ["team-coordination"],
+                description_summary: `Handshake → ${peerId}`,
+                created_at: new Date().toISOString(),
+            });
         }
-        // Create 0-budget handshake task for each peer
-        const handshakesCreated = [];
-        for (const peerId of peers) {
-            try {
-                const taskId = `t-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
-                const content = {
-                    _handshake: true,
-                    team_id: teamId,
-                    git_repo: params.git_repo,
-                    from_agent: myId,
-                    team_members: params.agent_ids,
-                };
-                const task = await net.createTask({
-                    task_id: taskId,
-                    initiator_id: myId,
-                    content: { description: `Team handshake: ${myId} → ${peerId}` },
-                    domains: ["team-coordination"],
-                    budget: 0,
-                    max_concurrent_bidders: 1,
-                    max_depth: 0,
-                    invited_agent_ids: [peerId],
-                });
-                // Update task content with handshake marker via discussions
-                try {
-                    await net.updateDiscussions(task.id, myId, JSON.stringify(content));
-                }
-                catch { /* content is in description as fallback */ }
-                teamInfo.handshake_out[peerId] = task.id;
-                handshakesCreated.push(task.id);
-                state.updateTask({
-                    task_id: task.id,
-                    agent_id: myId,
-                    role: "initiator",
-                    status: task.status,
-                    domains: ["team-coordination"],
-                    description_summary: `Handshake → ${peerId}`,
-                    created_at: new Date().toISOString(),
-                });
-            }
-            catch (e) {
-                handshakesCreated.push(`FAILED(${peerId}): ${e.message ?? e}`);
-            }
+        catch (e) {
+            failed.push(`${peerId}: ${e.message ?? e}`);
         }
-        state.addTeam(teamInfo);
-        results.push({ agent_id: myId, handshakes_created: handshakesCreated });
     }
+    state.addTeam(teamInfo);
     return ok({
         team_id: teamId,
         git_repo: params.git_repo,
         agent_ids: params.agent_ids,
-        local_agents: myAgents,
-        results,
+        my_agent_id: myId,
+        my_branch: params.my_branch,
+        tasks_created: tasksCreated,
+        failed,
         next_steps: [
-            "Each agent should now create their operation branch in the git repo.",
-            "When receiving handshake tasks (task_broadcast with _handshake marker), " +
-                "bid with price=0 and confidence=1, then submit_result with {branch: 'your-branch-name', _handshake_ack: true, team_id: '...'}.",
-            "When your handshake tasks get results, select_result to complete the handshake.",
-            "Team is ready when all peer branches are known.",
+            "Handshake tasks are auto-processed — peers auto-bid and reply, results are auto-selected.",
+            "Call eacn3_team_status to check progress. Use eacn3_team_retry_ack if a peer is unresponsive.",
         ],
     });
 });
 // #43 eacn3_team_status — check team formation progress
-server.tool("eacn3_team_status", "Check the current status of a team: which handshakes are complete, which peer branches are known, and whether the team is ready.", {
+server.tool("eacn3_team_status", "Check team formation progress: which handshake tasks are complete, which peer branches are known, and whether the team is ready. If peers are unresponsive, use eacn3_team_retry_ack.", {
     team_id: z.string().describe("Team ID from eacn3_team_setup"),
 }, async (params) => {
     const team = state.getTeam(params.team_id);
     if (!team)
         return err(`Team ${params.team_id} not found`);
     const peers = team.agent_ids.filter((id) => id !== team.my_agent_id);
-    const handshakes_complete = peers.filter((id) => id in team.peer_branches);
-    const handshakes_pending = peers.filter((id) => !(id in team.peer_branches));
+    const connected = peers.filter((id) => id in team.peer_branches);
+    const pending = peers.filter((id) => !(id in team.peer_branches));
     return ok({
         team_id: team.team_id,
         git_repo: team.git_repo,
@@ -1315,21 +1404,45 @@ server.tool("eacn3_team_status", "Check the current status of a team: which hand
         my_agent_id: team.my_agent_id,
         my_branch: team.my_branch ?? null,
         peer_branches: team.peer_branches,
-        handshakes_complete: handshakes_complete,
-        handshakes_pending: handshakes_pending,
+        ack_out: team.ack_out,
+        ack_in: team.ack_in,
+        connected,
+        pending,
         ready: team.status === "ready",
     });
 });
-// #44 eacn3_team_set_branch — record this agent's operation branch
-server.tool("eacn3_team_set_branch", "Record this agent's git branch name for a team. Call after creating your branch in the git repo.", {
+// #45 eacn3_team_retry_ack — re-create handshake task for unresponsive peer
+server.tool("eacn3_team_retry_ack", "Re-create a handshake task for a specific peer who hasn't responded. Use when eacn3_team_status shows a peer in 'pending'.", {
     team_id: z.string().describe("Team ID"),
-    branch: z.string().describe("Branch name (e.g. 'agent/my-agent-id')"),
+    peer_id: z.string().describe("Agent ID of the unresponsive peer"),
 }, async (params) => {
     const team = state.getTeam(params.team_id);
     if (!team)
         return err(`Team ${params.team_id} not found`);
-    state.setTeamBranch(params.team_id, params.branch);
-    return ok({ team_id: params.team_id, branch: params.branch, message: "Branch recorded" });
+    if (!team.agent_ids.includes(params.peer_id)) {
+        return err(`${params.peer_id} is not a member of team ${params.team_id}`);
+    }
+    try {
+        const taskId = `t-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+        const handshakeDeadline = new Date(Date.now() + 30 * 60 * 1000).toISOString();
+        const task = await net.createTask({
+            task_id: taskId,
+            initiator_id: team.my_agent_id,
+            content: { description: `Team handshake: ${team.my_agent_id} → ${params.peer_id} [team=${team.team_id}] [repo=${team.git_repo}] [members=${team.agent_ids.join(",")}]` },
+            domains: ["team-coordination"],
+            budget: 0,
+            deadline: handshakeDeadline,
+            max_concurrent_bidders: 1,
+            max_depth: 0,
+            invited_agent_ids: [params.peer_id],
+        });
+        team.ack_out[params.peer_id] = task.id;
+        state.addTeam(team); // persist updated ack_out
+        return ok({ team_id: team.team_id, peer_id: params.peer_id, task_id: task.id, message: "Handshake task re-created" });
+    }
+    catch (e) {
+        return err(`Failed to create handshake task for ${params.peer_id}: ${e.message ?? e}`);
+    }
 });
 // #40 eacn3_reverse_control_status
 server.tool("eacn3_reverse_control_status", "Get the current status of the MCP reverse control engine. Shows whether sampling is available, which agents are configured, pending directive count, and rate limiting info. Use for debugging reverse control behavior.", {}, async () => {
@@ -1386,7 +1499,11 @@ function buildAwaitResponse(events) {
 // WS Event Callbacks — auto-actions when events arrive
 // ---------------------------------------------------------------------------
 function registerEventCallbacks() {
-    ws.setEventCallback((agentId, event) => {
+    transport.setEventCallback((agentId, event) => {
+        // Skip if agent not claimed in this session — events are on-demand only,
+        // but guard against edge cases.
+        if (!state.getAgent(agentId))
+            return;
         const taskId = event.task_id;
         // --- Reverse Control: try to handle event proactively ---
         // This runs async; if it handles the event, it may take action
@@ -1427,12 +1544,39 @@ function registerEventCallbacks() {
                 // Bid exceeded budget — mark in local state for initiator to handle
                 // The event stays in the buffer for /eacn3-bounty to surface
                 break;
-            case "task_broadcast":
-                // New task available — auto-evaluate bid if agent has matching domains
-                autoBidEvaluate(agentId, event).catch(() => { });
+            case "task_broadcast": {
+                const bPayload = event.payload;
+                const bDomains = bPayload?.domains ?? [];
+                const bDesc = String(bPayload?.description ?? "");
+                if (bDomains.includes("team-coordination") && bDesc.startsWith("Team handshake:")) {
+                    event._handled = true;
+                    autoHandshakeRespond(agentId, event).catch((e) => { console.error(`[handshake] autoHandshakeRespond failed for ${agentId}:`, e); });
+                }
+                else {
+                    autoBidEvaluate(agentId, event).catch(() => { });
+                }
+                break;
+            }
+            case "bid_result": {
+                const brPayload = event.payload;
+                if (brPayload?.accepted) {
+                    const match = state.findTeamByHandshakeTask(event.task_id);
+                    if (match && match.direction === "in") {
+                        event._handled = true;
+                        autoHandshakeSubmit(agentId, event).catch((e) => { console.error(`[handshake] autoHandshakeSubmit failed for ${agentId}:`, e); });
+                    }
+                }
+                break;
+            }
+            case "result_submitted": {
+                const match = state.findTeamByHandshakeTask(event.task_id);
+                if (match && match.direction === "out") {
+                    event._handled = true;
+                    autoHandshakeSelect(agentId, event).catch((e) => { console.error(`[handshake] autoHandshakeSelect failed for ${agentId}:`, e); });
+                }
                 break;
+            }
             case "direct_message": {
-                // Another agent sent a direct message — store in session
                 const payload = event.payload;
                 const from = payload?.from;
                 const content = payload?.content;
@@ -1451,6 +1595,198 @@ function registerEventCallbacks() {
     });
 }
 // ---------------------------------------------------------------------------
+// Team handshake auto-handling
+// ---------------------------------------------------------------------------
+/**
+ * Auto-respond to an incoming handshake task_broadcast:
+ * 1. Parse team info from description
+ * 2. Create local team record if needed, auto-set branch to agent/{id}
+ * 3. Auto-bid on the incoming task
+ * 4. Create outgoing handshake tasks to all peers we haven't ACKed yet
+ */
+async function autoHandshakeRespond(agentId, event) {
+    const payload = event.payload;
+    const desc = String(payload?.description ?? "");
+    const teamMatch = desc.match(/\[team=([^\]]+)\]/);
+    const repoMatch = desc.match(/\[repo=([^\]]+)\]/);
+    const membersMatch = desc.match(/\[members=([^\]]+)\]/);
+    const fromMatch = desc.match(/^Team handshake:\s*(\S+)/);
+    if (!teamMatch)
+        return;
+    const teamId = teamMatch[1];
+    const gitRepo = repoMatch?.[1] ?? "";
+    const members = membersMatch?.[1]?.split(",") ?? [];
+    const fromAgent = fromMatch?.[1] ?? "";
+    // Ensure local team record exists
+    let team = state.getTeamsForAgent(agentId).find((t) => t.team_id === teamId);
+    if (!team) {
+        const teamInfo = {
+            team_id: teamId,
+            git_repo: gitRepo,
+            agent_ids: members,
+            my_agent_id: agentId,
+            my_branch: `agent/${agentId}`,
+            peer_branches: {},
+            ack_out: {},
+            ack_in: {},
+            status: "forming",
+        };
+        state.addTeam(teamInfo);
+        team = state.getTeamsForAgent(agentId).find((t) => t.team_id === teamId);
+    }
+    // Auto-set branch if not yet set
+    if (!team.my_branch) {
+        state.setTeamBranch(teamId, `agent/${agentId}`);
+        team.my_branch = `agent/${agentId}`;
+    }
+    // Record incoming handshake task
+    state.recordAckIn(teamId, agentId, fromAgent, event.task_id);
+    // If this agent is the team initiator (called eacn3_team_setup), DON'T auto-respond.
+    // The initiator replies later via replyPendingHandshakes (called by create_task)
+    // so it can include task details in the response.
+    if (team.is_initiator)
+        return;
+    // Auto-bid on the incoming task
+    try {
+        await net.submitBid(event.task_id, agentId, 0, 1);
+    }
+    catch (e) {
+        console.error(`[handshake] auto-bid failed for ${agentId} on task ${event.task_id}:`, e);
+        return; // Can't proceed without a bid
+    }
+    // Create outgoing tasks to peers we haven't ACKed yet
+    await createOutgoingHandshakes(team, agentId);
+}
+/**
+ * Auto-submit result after handshake bid is accepted (bid_result event).
+ * Refuses to submit if branch is not set.
+ */
+async function autoHandshakeSubmit(agentId, event) {
+    const taskId = event.task_id;
+    const match = state.findTeamByHandshakeTask(taskId);
+    if (!match || match.direction !== "in")
+        return;
+    try {
+        await net.submitResult(taskId, agentId, {
+            _handshake_ack: true,
+            team_id: match.team.team_id,
+            branch: match.team.my_branch ?? `agent/${agentId}`,
+        });
+    }
+    catch (e) {
+        console.error(`[handshake] auto-submit failed for ${agentId} on task ${taskId}:`, e);
+    }
+}
+/**
+ * Create outgoing handshake tasks to all peers we haven't ACKed yet.
+ */
+async function createOutgoingHandshakes(team, agentId) {
+    const peers = team.agent_ids.filter((id) => id !== agentId);
+    for (const peerId of peers) {
+        if (team.ack_out[peerId])
+            continue;
+        try {
+            const taskId = `t-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+            const handshakeDeadline = new Date(Date.now() + 30 * 60 * 1000).toISOString();
+            const task = await net.createTask({
+                task_id: taskId,
+                initiator_id: agentId,
+                content: { description: `Team handshake: ${agentId} → ${peerId} [team=${team.team_id}] [repo=${team.git_repo}] [members=${team.agent_ids.join(",")}]` },
+                domains: ["team-coordination"],
+                budget: 0,
+                deadline: handshakeDeadline,
+                max_concurrent_bidders: 1,
+                max_depth: 0,
+                invited_agent_ids: [peerId],
+            });
+            team.ack_out[peerId] = task.id;
+            state.addTeam(team);
+        }
+        catch (e) {
+            console.error(`[handshake] createOutgoingHandshake ${agentId} → ${peerId} failed:`, e);
+        }
+    }
+}
+/**
+ * Auto-select result for handshake tasks when a result is submitted.
+ * Only acts on tasks in our ack_out (i.e., tasks we created as initiator).
+ */
+async function autoHandshakeSelect(agentId, event) {
+    const taskId = event.task_id;
+    const match = state.findTeamByHandshakeTask(taskId);
+    if (!match || match.direction !== "out")
+        return; // Not our outgoing handshake
+    const payload = event.payload;
+    const resultAgentId = payload?.agent_id;
+    if (!resultAgentId)
+        return;
+    // Auto-select the result
+    try {
+        await net.selectResult(taskId, agentId, resultAgentId);
+    }
+    catch (e) {
+        console.error(`[handshake] auto-select failed for ${agentId} on task ${taskId}:`, e);
+    }
+    // Extract branch from the result
+    try {
+        const taskData = await net.getTask(taskId);
+        const results = taskData?.results ?? [];
+        const result = results.find((r) => r.agent_id === resultAgentId);
+        const branch = result?.content?.branch;
+        if (branch) {
+            state.updateTeamPeerBranch(match.team.team_id, match.peerId, branch);
+        }
+        // If the reply carries a team task, buffer it as a synthetic event for the agent
+        const teamTask = result?.content?.team_task;
+        if (teamTask && teamTask.task_id) {
+            state.pushEvents(agentId, [{
+                    msg_id: crypto.randomUUID().replace(/-/g, ""),
+                    type: "direct_message",
+                    task_id: teamTask.task_id,
+                    payload: {
+                        from: match.peerId,
+                        content: JSON.stringify({ _team_task: true, ...teamTask }),
+                    },
+                    received_at: Date.now(),
+                }]);
+        }
+    }
+    catch (e) {
+        console.error(`[handshake] branch extraction failed for task ${taskId}:`, e);
+    }
+}
+/**
+ * Reply to pending reverse handshakes when creating a team task.
+ * Uses ack_in (recorded by autoHandshakeRespond) to find task IDs
+ * that the initiator hasn't responded to yet. Bids and submits result
+ * with branch + task details.
+ */
+async function replyPendingHandshakes(agentId, team, taskSummary) {
+    for (const [peerId, taskId] of Object.entries(team.ack_in)) {
+        // Bid on the reverse handshake task
+        try {
+            await net.submitBid(taskId, agentId, 0, 1);
+        }
+        catch (e) {
+            console.error(`[handshake] replyPendingHandshakes bid failed for ${agentId} → ${peerId} (task ${taskId}):`, e);
+            continue;
+        }
+        // Submit result with branch + task details
+        // On a 0-budget invited task, bid is typically auto-accepted
+        try {
+            await net.submitResult(taskId, agentId, {
+                _handshake_ack: true,
+                team_id: team.team_id,
+                branch: team.my_branch ?? `agent/${agentId}`,
+                team_task: taskSummary,
+            });
+        }
+        catch (e) {
+            console.error(`[handshake] replyPendingHandshakes submit failed for ${agentId} → ${peerId} (task ${taskId}):`, e);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
 // Auto-bid evaluation — communication layer auto-filter per agent.md:172-193
 // ---------------------------------------------------------------------------
 async function autoBidEvaluate(agentId, event) {
@@ -1481,6 +1817,29 @@ async function autoBidEvaluate(agentId, event) {
         }]);
 }
 // ---------------------------------------------------------------------------
+// Global crash handlers — log to file so post-mortem is possible
+// ---------------------------------------------------------------------------
+const __crash_dir = join(dirname(fileURLToPath(import.meta.url)), "..", "logs");
+function writeCrashLog(label, err) {
+    try {
+        mkdirSync(__crash_dir, { recursive: true });
+        const ts = new Date().toISOString();
+        const msg = err instanceof Error ? `${err.message}\n${err.stack}` : String(err);
+        const line = `[${ts}] ${label}: ${msg}\n`;
+        appendFileSync(join(__crash_dir, "crash.log"), line);
+        console.error(`[EACN3] ${label}:`, msg);
+    }
+    catch { /* last resort — nothing we can do */ }
+}
+process.on("uncaughtException", (err) => {
+    writeCrashLog("uncaughtException", err);
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    writeCrashLog("unhandledRejection", reason);
+    process.exit(1);
+});
+// ---------------------------------------------------------------------------
 // Start
 // ---------------------------------------------------------------------------
 async function main() {