machine-bridge-mcp 1.2.1 → 1.2.5

package/src/local/relay-connection.mjs

@@ -6,6 +6,7 @@ const DEFAULT_HEARTBEAT_INTERVAL_MS = 25_000;
 const DEFAULT_HEARTBEAT_TIMEOUT_MS = 75_000;
 const DEFAULT_CONNECT_TIMEOUT_MS = 15_000;
 const DEFAULT_HANDSHAKE_TIMEOUT_MS = 10_000;
+const DEFAULT_READINESS_TIMEOUT_MS = 15_000;
 const DEFAULT_OUTAGE_WARN_AFTER_MS = 10_000;
 const DEFAULT_OUTAGE_WARN_REPEAT_MS = 60_000;
 const DEFAULT_OUTAGE_WARN_MAX_REPEAT_MS = 15 * 60_000;
@@ -43,6 +44,7 @@ export class RelayConnection {
     this.heartbeatTimeoutMs = boundedPositiveInteger(options.heartbeatTimeoutMs, DEFAULT_HEARTBEAT_TIMEOUT_MS);
     this.connectTimeoutMs = boundedPositiveInteger(options.connectTimeoutMs, DEFAULT_CONNECT_TIMEOUT_MS);
     this.handshakeTimeoutMs = boundedPositiveInteger(options.handshakeTimeoutMs, DEFAULT_HANDSHAKE_TIMEOUT_MS);
+    this.readinessTimeoutMs = boundedPositiveInteger(options.readinessTimeoutMs, DEFAULT_READINESS_TIMEOUT_MS);
     this.outageWarnAfterMs = boundedPositiveInteger(options.outageWarnAfterMs, DEFAULT_OUTAGE_WARN_AFTER_MS);
     this.outageWarnRepeatMs = boundedPositiveInteger(options.outageWarnRepeatMs, DEFAULT_OUTAGE_WARN_REPEAT_MS);
     this.outageWarnMaxRepeatMs = Math.max(
@@ -52,7 +54,9 @@ export class RelayConnection {
 
     this.closed = true;
     this.socket = null;
+    this.authenticated = false;
     this.ready = false;
+    this.readinessProbeDelivered = false;
     this.hasConnected = false;
     this.connectedAt = 0;
     this.lastInboundAt = 0;
@@ -61,6 +65,7 @@ export class RelayConnection {
     this.connectTimer = null;
     this.heartbeatTimer = null;
     this.handshakeTimer = null;
+    this.readinessTimer = null;
     this.outageWarnTimer = null;
     this.outageStartedAt = 0;
     this.outageAttempts = 0;
@@ -73,18 +78,27 @@ export class RelayConnection {
     this.connectedOnce = null;
     this.connectedOnceResolve = null;
     this.connectedOnceReject = null;
+    this.sessionGeneration = 0;
+    this.activeSessionId = 0;
   }
 
   status() {
     return {
+      authenticated: this.authenticated,
       ready: this.ready,
+      readiness_probe_delivered: this.readinessProbeDelivered,
       closed: this.closed,
       network_route: this.networkRoute,
       reconnect_attempt: this.reconnectAttempt,
       outage_active: this.outageStartedAt > 0,
+      session_generation: this.sessionGeneration,
     };
   }
 
+  currentSessionId() {
+    return this.authenticated ? this.activeSessionId : 0;
+  }
+
   start() {
     if (!this.closed && this.connectedOnce) return this.connectedOnce;
     this.closed = false;
@@ -98,10 +112,14 @@ export class RelayConnection {
 
   stop() {
     this.closed = true;
+    this.authenticated = false;
     this.ready = false;
+    this.readinessProbeDelivered = false;
+    this.activeSessionId = 0;
     this.clearTimer("heartbeatTimer", "clearInterval");
     this.clearTimer("connectTimer", "clearTimeout");
     this.clearTimer("handshakeTimer", "clearTimeout");
+    this.clearTimer("readinessTimer", "clearTimeout");
     this.clearTimer("reconnectTimer", "clearTimeout");
     this.clearTimer("outageWarnTimer", "clearTimeout");
     const socket = this.socket;
@@ -118,6 +136,16 @@ export class RelayConnection {
     return this.sendOnSocket(this.socket, value);
   }
 
+  sendForSession(value, expectedSessionId) {
+    const sessionId = Number(expectedSessionId) || 0;
+    if (!sessionId || sessionId !== this.activeSessionId) return { ok: false, reason: "session_ended" };
+    if (!this.authenticated || !this.isSocketOpen(this.socket)) return { ok: false, reason: "transport_unavailable" };
+    if (!this.ready && value?.type !== "relay_probe_result") return { ok: false, reason: "transport_unavailable" };
+    if (!this.sendOnSocket(this.socket, value)) return { ok: false, reason: "send_failed" };
+    if (value?.type === "relay_probe_result") this.readinessProbeDelivered = true;
+    return { ok: true, reason: "sent" };
+  }
+
   interrupt(category = "relay_transport_error") {
     if (this.closed || !this.socket) return false;
     this.pendingCloseCategory = String(category || "relay_transport_error");
@@ -127,7 +155,7 @@ export class RelayConnection {
 
   observeWelcome(message = {}) {
     const socket = this.socket;
-    if (this.closed || this.ready || !this.isSocketOpen(socket)) return false;
+    if (this.closed || this.authenticated || !this.isSocketOpen(socket)) return false;
     const mismatch = welcomeMismatch(message, this.expectedServer, this.expectedVersion);
     if (mismatch) {
       this.logger.debug?.("remote relay welcome rejected", { reason: mismatch });
@@ -140,24 +168,54 @@ export class RelayConnection {
 
   acknowledge(message = {}) {
     const socket = this.socket;
-    if (this.closed || this.ready || !this.isSocketOpen(socket)) return false;
+    if (this.closed || this.authenticated || !this.isSocketOpen(socket)) return false;
     const mismatch = acknowledgementMismatch(message, this.expectedServer, this.expectedVersion);
     if (mismatch) {
       this.logger.debug?.("remote relay acknowledgement rejected", { reason: mismatch });
       this.failPermanently("relay_protocol_mismatch");
       return false;
     }
-    this.ready = true;
+    this.authenticated = true;
+    this.readinessProbeDelivered = false;
+    this.sessionGeneration += 1;
+    this.activeSessionId = this.sessionGeneration;
     this.clearTimer("handshakeTimer", "clearTimeout");
     this.connectedAt = this.now();
     this.lastInboundAt = this.connectedAt;
-    this.reconnectAttempt = 0;
     this.startHeartbeat();
+    this.clearTimer("readinessTimer", "clearTimeout");
+    this.readinessTimer = this.scheduler.setTimeout(() => {
+      if (this.socket !== socket || this.closed || this.ready) return;
+      this.logger.debug?.("remote relay end-to-end readiness probe timed out", { timeout_ms: this.readinessTimeoutMs });
+      this.pendingCloseCategory = "relay_readiness_timeout";
+      terminateSocket(socket);
+    }, this.readinessTimeoutMs);
+    this.readinessTimer?.unref?.();
+    return true;
+  }
+
+  confirmReady(message = {}) {
+    const socket = this.socket;
+    if (this.closed || !this.authenticated || this.ready || !this.isSocketOpen(socket)) return false;
+    const mismatch = readinessMismatch(message, this.expectedServer, this.expectedVersion);
+    if (!mismatch && !this.readinessProbeDelivered) {
+      this.logger.debug?.("remote relay declared readiness before the end-to-end probe result was delivered");
+      this.failPermanently("relay_protocol_mismatch");
+      return false;
+    }
+    if (mismatch) {
+      this.logger.debug?.("remote relay readiness acknowledgement rejected", { reason: mismatch });
+      this.failPermanently("relay_protocol_mismatch");
+      return false;
+    }
+    this.ready = true;
+    this.clearTimer("readinessTimer", "clearTimeout");
+    this.reconnectAttempt = 0;
 
     if (!this.hasConnected) {
-      this.logger.info?.("remote relay connected");
+      this.logger.info?.("remote relay connected and end-to-end result delivery verified");
     } else if (this.outageStartedAt > 0) {
-      const outageMs = Math.max(0, this.connectedAt - this.outageStartedAt);
+      const outageMs = Math.max(0, this.now() - this.outageStartedAt);
       if (this.outageNoticeEmitted) {
         this.logger.info?.(`remote relay connection restored after ${formatDuration(outageMs)} (${formatAttempts(this.outageAttempts)})`);
         this.logger.debug?.("remote relay outage recovery details", {
@@ -185,13 +243,20 @@ export class RelayConnection {
   handleServerError(message = {}) {
     const errorCode = sanitizeProtocolErrorCode(message?.error);
     this.logger.debug?.("remote relay reported a protocol error", { error_code: errorCode });
-    if (errorCode === "daemon_hello_timeout" && !this.ready) {
+    if (errorCode === "daemon_hello_timeout" && !this.authenticated) {
       const socket = this.socket;
       if (this.closed || !socket) return true;
       this.pendingCloseCategory = "relay_handshake_timeout";
       terminateSocket(socket);
       return true;
     }
+    if (errorCode === "daemon_ready_timeout" && this.authenticated && !this.ready) {
+      const socket = this.socket;
+      if (this.closed || !socket) return true;
+      this.pendingCloseCategory = "relay_readiness_timeout";
+      terminateSocket(socket);
+      return true;
+    }
     this.failPermanently("relay_protocol_error");
     return true;
   }
@@ -253,8 +318,10 @@ export class RelayConnection {
     socket.on("message", (data) => {
       if (this.socket !== socket || this.closed) return;
       this.lastInboundAt = this.now();
+      // Bind results to the generation that received this message.
+      const relayContext = { sessionId: this.activeSessionId, authenticated: this.authenticated, ready: this.ready };
       try {
-        const outcome = this.onMessage(data);
+        const outcome = this.onMessage(data, relayContext);
         if (outcome && typeof outcome.catch === "function") {
           outcome.catch((error) => this.logger.error?.("daemon message handler failed", { error_class: classifyOperationalError(error) }));
         }
@@ -266,15 +333,20 @@ export class RelayConnection {
     socket.on("close", (code, reason) => {
       if (this.socket !== socket) return;
       const wasReady = this.ready;
+      const wasAuthenticated = this.authenticated;
       this.socket = null;
+      this.authenticated = false;
       this.ready = false;
+      this.readinessProbeDelivered = false;
+      this.activeSessionId = 0;
       this.clearTimer("connectTimer", "clearTimeout");
       this.clearTimer("heartbeatTimer", "clearInterval");
       this.clearTimer("handshakeTimer", "clearTimeout");
+      this.clearTimer("readinessTimer", "clearTimeout");
       const reasonText = sanitizeCloseReason(reason);
       const category = this.pendingCloseCategory || relayCloseCategory(code, reasonText);
       this.pendingCloseCategory = "";
-      const connectedForMs = wasReady && this.connectedAt > 0 ? Math.max(0, this.now() - this.connectedAt) : 0;
+      const connectedForMs = wasAuthenticated && this.connectedAt > 0 ? Math.max(0, this.now() - this.connectedAt) : 0;
       this.logger.debug?.("remote relay transport closed", {
         close_code: Number(code) || 0,
         close_reason: reasonText || "<none>",
@@ -298,7 +370,7 @@ export class RelayConnection {
         this.closed = true;
         this.clearTimer("reconnectTimer", "clearTimeout");
         this.clearTimer("outageWarnTimer", "clearTimeout");
-        this.logger.warn?.("daemon connection was replaced by a newer authenticated instance");
+        this.logger.warn?.("daemon connection was replaced by a newer verified instance");
         queueMicrotask(() => {
           try { this.onSuperseded(); } catch (error) {
             this.logger.error?.("daemon superseded callback failed", { error_class: classifyOperationalError(error) });
@@ -328,11 +400,15 @@ export class RelayConnection {
     if (this.closed) return;
     const socket = this.socket;
     this.closed = true;
+    this.authenticated = false;
     this.ready = false;
+    this.readinessProbeDelivered = false;
+    this.activeSessionId = 0;
     this.socket = null;
     this.clearTimer("connectTimer", "clearTimeout");
     this.clearTimer("heartbeatTimer", "clearInterval");
     this.clearTimer("handshakeTimer", "clearTimeout");
+    this.clearTimer("readinessTimer", "clearTimeout");
     this.clearTimer("reconnectTimer", "clearTimeout");
     this.clearTimer("outageWarnTimer", "clearTimeout");
     if (wasReady) {
@@ -392,7 +468,7 @@ export class RelayConnection {
     this.clearTimer("heartbeatTimer", "clearInterval");
     this.heartbeatTimer = this.scheduler.setInterval(() => {
       const socket = this.socket;
-      if (this.closed || !this.ready || !this.isSocketOpen(socket)) return;
+      if (this.closed || !this.authenticated || !this.isSocketOpen(socket)) return;
       const silentForMs = Math.max(0, this.now() - this.lastInboundAt);
       if (silentForMs >= this.heartbeatTimeoutMs) {
         this.logger.debug?.("remote relay heartbeat timed out", { silent_for_ms: silentForMs });
@@ -484,6 +560,7 @@ export function relayCloseCategory(code, reason = "") {
   const reasonText = String(reason || "");
   if (isSupersededClose(numeric, reasonText)) return "superseded";
   if (numeric === 1008 && reasonText === "daemon hello timeout") return "relay_handshake_timeout";
+  if (numeric === 1008 && reasonText === "daemon ready timeout") return "relay_readiness_timeout";
   if (numeric === 1008 && ["stale daemon candidate", "expired daemon candidate"].includes(reasonText)) return "relay_restarting_or_unavailable";
   if (numeric === 1008 && ["daemon hello required", "missing daemon attachment", "invalid daemon candidate timestamp"].includes(reasonText)) return "relay_protocol_error";
   if (numeric === 1000) return "normal_close";
@@ -520,6 +597,7 @@ function relayCloseUserCause(category) {
     relay_authentication_failed: "relay authentication failed",
     relay_connect_timeout: "relay connection attempt timed out",
     relay_handshake_timeout: "relay authentication acknowledgement timed out",
+    relay_readiness_timeout: "end-to-end relay readiness verification timed out",
     relay_heartbeat_timeout: "relay stopped responding",
     relay_transport_error: "relay transport error",
     relay_protocol_error: "relay protocol error",
@@ -551,8 +629,17 @@ export function acknowledgementMismatch(message, expectedServer = "", expectedVe
   return "";
 }
 
+export function readinessMismatch(message, expectedServer = "", expectedVersion = "") {
+  if (!message || typeof message !== "object" || Array.isArray(message)) return "invalid_readiness_acknowledgement";
+  if (message.type !== "ready_ack") return "unexpected_readiness_acknowledgement_type";
+  if (expectedServer && message.server !== expectedServer) return "server_identity_mismatch";
+  if (expectedVersion && message.version !== expectedVersion) return "server_version_mismatch";
+  if (typeof message.server !== "string" || !message.server || typeof message.version !== "string" || !message.version) return "incomplete_readiness_acknowledgement";
+  return "";
+}
+
 export function isSupersededClose(code, reason) {
-  return Number(code) === 1012 && String(reason || "") === "replaced by authenticated daemon";
+  return Number(code) === 1012 && String(reason || "") === "replaced by verified daemon";
 }
 
 export function reconnectDelay(attempt, random = Math.random) {

package/src/local/runtime.mjs

@@ -113,6 +113,8 @@ export class LocalRuntime {
     this.processTracker = new ProcessTracker();
     this.lifecycle = new LifecycleController("local runtime");
     this.observability = new RuntimeObservability();
+    this.activeRelayCalls = new Set();
+    this.suppressedRelayResults = new Map();
     this.callRegistry = new CallRegistry({
       maximum: MAX_CONCURRENT_TOOL_CALLS,
       onCancel: (record) => {
@@ -121,7 +123,7 @@ export class LocalRuntime {
         this.processTracker.terminateCall(record.id);
         this.logger.event?.("debug", "tool.call.cancel_requested", {
           call_id: shortCallId(record.id), tool: record.tool, origin: record.origin,
-        });
+        }, "Tool call cancellation requested");
       },
       onFinish: (record) => this.processTracker.releaseCall(record.id),
     });
@@ -289,7 +291,7 @@ export class LocalRuntime {
     return this.relay?.send(value) === true;
   }
 
-  async handleMessage(raw) {
+  async handleMessage(raw, relayContext = {}) {
     let message;
     try { message = JSON.parse(raw); } catch {
       this.handleRelayProtocolViolation("invalid_server_json");
@@ -300,11 +302,14 @@ export class LocalRuntime {
       return;
     }
     if (this.handleRelayControlMessage(message)) return;
-    if (message.type !== "tool_call") {
-      this.handleRelayProtocolViolation("unexpected_server_message_type");
+    if (message.type === "relay_probe") {
+      if (relayContext.ready === true) return this.handleRelayProtocolViolation("unexpected_relay_probe");
+      this.handleRelayProbe(message, relayContext);
       return;
     }
-    await this.handleRelayToolCall(message);
+    if (message.type !== "tool_call") return this.handleRelayProtocolViolation("unexpected_server_message_type");
+    if (relayContext.ready !== true) return this.handleRelayProtocolViolation("tool_call_before_ready");
+    await this.handleRelayToolCall(message, relayContext);
   }
 
   handleRelayControlMessage(message) {
@@ -316,13 +321,17 @@ export class LocalRuntime {
       this.relay?.acknowledge(message);
       return true;
     }
+    if (message.type === "ready_ack") {
+      this.relay?.confirmReady(message);
+      return true;
+    }
     if (message.type === "pong") return true;
     if (message.type === "error") {
       this.relay?.handleServerError(message);
       return true;
     }
     if (message.type === "cancel_call") {
-      if (typeof message.id === "string") this.cancelCall(message.id, "remote cancellation");
+      if (typeof message.id === "string") this.cancelRelayCall(message.id, "caller_cancelled");
       return true;
     }
     return false;
@@ -336,37 +345,78 @@ export class LocalRuntime {
     this.logger.error?.("remote relay protocol error; upgrade and redeploy both components, then restart the daemon");
   }
 
-  async handleRelayToolCall(message) {
+  handleRelayProbe(message, relayContext = {}) {
+    const id = typeof message?.id === "string" && /^probe_[A-Za-z0-9_-]{8,240}$/.test(message.id) ? message.id : "";
+    const relaySessionId = Number(relayContext.sessionId) || 0;
+    if (!id || !relaySessionId) return this.handleRelayProtocolViolation("invalid_relay_probe");
+    this.deliverRelayToolResult({ type: "relay_probe_result", id }, relaySessionId);
+  }
+
+  async handleRelayToolCall(message, relayContext = {}) {
     const envelope = normalizeRelayToolCall(message);
+    const relaySessionId = Number(relayContext.sessionId) || 0;
     if (!envelope.ok) {
-      this.logger.event?.("warn", "relay.tool_call.invalid", { has_call_id: Boolean(envelope.id) });
+      this.logger.warn?.("Received an invalid tool request from the relay; the request was rejected.");
+      this.logger.event?.("debug", "relay.tool_call.invalid", {
+        has_call_id: Boolean(envelope.id),
+      }, "Invalid relay tool request details");
       if (envelope.id) this.deliverRelayToolResult({
         type: "tool_result",
         id: envelope.id,
         ok: false,
         error: { code: "invalid_request", message: "invalid tool_call envelope", retryable: false },
-      });
+      }, relaySessionId);
+      return;
+    }
+    if (this.activeRelayCalls.has(envelope.id)) {
+      this.handleRelayProtocolViolation("duplicate_tool_call_id");
       return;
     }
-    let response;
+    this.activeRelayCalls.add(envelope.id);
     try {
-      const result = await this.executeTool(envelope.tool, envelope.arguments, {
-        callId: envelope.id,
-        origin: "relay",
-        timeoutMs: envelope.timeoutMs,
-        authorization: envelope.authorization,
-      });
-      response = { type: "tool_result", id: envelope.id, ok: true, result };
-    } catch (error) {
-      response = { type: "tool_result", id: envelope.id, ok: false, error: publicError(error) };
+      let response;
+      try {
+        const result = await this.executeTool(envelope.tool, envelope.arguments, {
+          callId: envelope.id,
+          origin: "relay",
+          timeoutMs: envelope.timeoutMs,
+          authorization: envelope.authorization,
+        });
+        response = { type: "tool_result", id: envelope.id, ok: true, result };
+      } catch (error) {
+        response = { type: "tool_result", id: envelope.id, ok: false, error: publicError(error) };
+      }
+      const suppressionReason = this.suppressedRelayResults.get(envelope.id) || "";
+      if (suppressionReason) {
+        this.logger.event?.("debug", "relay.tool_result.discarded", {
+          call_id: shortCallId(envelope.id), reason: suppressionReason,
+        }, "Discarded a tool result because the caller was no longer waiting");
+        return;
+      }
+      this.deliverRelayToolResult(response, relaySessionId);
+    } finally {
+      this.activeRelayCalls.delete(envelope.id);
+      this.suppressedRelayResults.delete(envelope.id);
     }
-    this.deliverRelayToolResult(response);
   }
 
-  deliverRelayToolResult(response) {
-    if (this.send(response)) return true;
-    this.logger.event?.("warn", "relay.tool_result.delivery_failed", { call_id: shortCallId(response?.id) });
-    this.relay?.interrupt?.("relay_transport_error");
+  deliverRelayToolResult(response, relaySessionId = 0) {
+    const sessionId = Number(relaySessionId) || 0;
+    const outcome = this.relay?.sendForSession
+      ? this.relay.sendForSession(response, sessionId)
+      : (this.send(response) ? { ok: true, reason: "sent" } : { ok: false, reason: "transport_unavailable" });
+    if (outcome?.ok) return true;
+    const reason = String(outcome?.reason || "transport_unavailable");
+    const missingSession = reason === "session_ended" && sessionId <= 0;
+    this.logger.event?.(missingSession ? "error" : "debug", "relay.tool_result.discarded", {
+      call_id: shortCallId(response?.id), reason, relay_session_id: sessionId,
+      active_session_id: Number(this.relay?.currentSessionId?.() || 0),
+    }, missingSession
+      ? "Discarded a tool result because the relay session id was missing from the inbound tool_call context"
+      : reason === "send_failed"
+        ? "Could not send a tool result because the relay transport failed"
+        : "Discarded a tool result because its relay session had ended");
+    if (reason === "send_failed") this.relay?.interrupt?.("relay_transport_error");
     return false;
   }
 
@@ -379,11 +429,19 @@ export class LocalRuntime {
     return this.callRegistry.cancel(callId, reason);
   }
 
+  cancelRelayCall(callId, suppressionReason = "caller_cancelled") {
+    const id = String(callId);
+    if (this.activeRelayCalls.has(id)) this.suppressedRelayResults.set(id, suppressionReason);
+    return this.cancelCall(id, "remote cancellation");
+  }
+
   handleRelayDisconnect() {
+    for (const callId of this.activeRelayCalls) this.suppressedRelayResults.set(callId, "relay_disconnected");
     const cancelled = this.callRegistry.cancelOrigin("relay", "remote relay disconnected");
     this.terminateActiveProcesses("SIGTERM", true);
     if (cancelled > 0) {
-      this.logger.event?.("debug", "relay.calls.cancelled_on_disconnect", { cancelled_calls: cancelled });
+      this.logger.event?.("debug", "relay.calls.cancelled_on_disconnect", { cancelled_calls: cancelled },
+        "Cancelled in-flight tool calls after the relay connection ended");
     }
   }
 
@@ -669,7 +727,7 @@ function createRelayConnection(runtime, { workerUrl, secret, expectedVersion, on
       policy: runtime.policy,
       protocol_versions: MCP_SUPPORTED_PROTOCOL_VERSIONS,
     }),
-    onMessage: (data) => handleRelayData(runtime, data),
+    onMessage: (data, relayContext) => handleRelayData(runtime, data, relayContext),
     onDisconnect: () => runtime.handleRelayDisconnect(),
     onSuperseded: () => {
       runtime.terminateActiveProcesses("SIGKILL");
@@ -684,13 +742,13 @@ function createRelayConnection(runtime, { workerUrl, secret, expectedVersion, on
   });
 }
 
-function handleRelayData(runtime, data) {
+function handleRelayData(runtime, data, relayContext = {}) {
   const raw = typeof data === "string" ? data : Buffer.from(data).toString("utf8");
   if (Buffer.byteLength(raw) > MAX_WS_MESSAGE_BYTES) {
     runtime.handleRelayProtocolViolation("server_message_too_large");
     return;
   }
-  return runtime.handleMessage(raw);
+  return runtime.handleMessage(raw, relayContext);
 }
 
 function normalizeRelayToolCall(message) {

package/src/local/tool-executor.mjs

@@ -67,7 +67,7 @@ function observabilityMiddleware(observability, logger, safeMessage, slowMs) {
       call_id: shortCallId(operation.context.callId),
       tool: operation.tool,
       origin: operation.context.origin,
-    });
+    }, "Tool call started");
     try {
       const result = await next(operation);
       const durationMs = performance.now() - started;
@@ -75,7 +75,7 @@ function observabilityMiddleware(observability, logger, safeMessage, slowMs) {
       observability.finish(operation.tool, { status: "completed", durationMs, slow });
       logger.event?.("debug", slow ? "tool.call.slow" : "tool.call.completed", {
         call_id: shortCallId(operation.context.callId), tool: operation.tool, origin: operation.context.origin, duration_ms: durationMs,
-      });
+      }, slow ? "Tool call completed slowly" : "Tool call completed");
       return result;
     } catch (error) {
       const normalized = normalizeBridgeError(error, { safeMessage: () => safeMessage(error, operation.args) });
@@ -86,7 +86,7 @@ function observabilityMiddleware(observability, logger, safeMessage, slowMs) {
       logger.event?.("debug", "tool.call.failed", {
         call_id: shortCallId(operation.context.callId), tool: operation.tool, origin: operation.context.origin,
         duration_ms: durationMs, error_code: code, retryable: normalized.retryable,
-      });
+      }, "Tool call failed");
       throw normalized;
     }
   };

package/src/worker/daemon-liveness.ts

@@ -0,0 +1,63 @@
+/**
+ * Worker-side authenticated daemon liveness.
+ *
+ * Local daemons heartbeat about every 25s and treat 75s of silence as half-open.
+ * The Worker must apply a symmetric bound: role=daemon + readyState=OPEN is not
+ * enough after Durable Object hibernation or a half-closed transport, because
+ * those sockets still look connected while tool_call never returns.
+ */
+export const DAEMON_LIVENESS_TIMEOUT_MS = 90_000;
+export const DAEMON_READY_TIMEOUT_MS = 15_000;
+
+export type DaemonRole = "candidate" | "probing" | "expired" | "daemon";
+
+export interface DaemonLivenessFields {
+  role?: DaemonRole | string;
+  connectedAt?: string;
+  lastSeenAt?: string;
+}
+
+export function daemonLastSeenMs(attachment: DaemonLivenessFields | undefined | null): number {
+  const raw = attachment?.lastSeenAt || attachment?.connectedAt || "";
+  return Date.parse(raw);
+}
+
+export function isLiveDaemonAttachment(
+  attachment: DaemonLivenessFields | undefined | null,
+  now = Date.now(),
+): boolean {
+  if (!attachment || attachment.role !== "daemon") return false;
+  const lastSeen = daemonLastSeenMs(attachment);
+  if (!Number.isFinite(lastSeen)) return false;
+  const age = now - lastSeen;
+  return age >= 0 && age <= DAEMON_LIVENESS_TIMEOUT_MS;
+}
+
+export function daemonLivenessDeadlineMs(attachment: DaemonLivenessFields | undefined | null): number {
+  const lastSeen = daemonLastSeenMs(attachment);
+  if (!Number.isFinite(lastSeen)) return Number.NaN;
+  return lastSeen + DAEMON_LIVENESS_TIMEOUT_MS;
+}
+
+export function daemonReadyDeadlineMs(attachment: DaemonLivenessFields | undefined | null): number {
+  if (!attachment || attachment.role !== "probing") return Number.NaN;
+  const connectedAt = Date.parse(attachment.connectedAt || "");
+  if (!Number.isFinite(connectedAt)) return Number.NaN;
+  return connectedAt + DAEMON_READY_TIMEOUT_MS;
+}
+
+export function withDaemonLastSeenAt<T extends DaemonLivenessFields>(
+  attachment: T,
+  lastSeenAt = new Date().toISOString(),
+): T & { lastSeenAt: string } {
+  return { ...attachment, lastSeenAt };
+}
+
+export const DAEMON_HELLO_TIMEOUT_MS = 10_000;
+
+export function isFreshDaemonCandidate(connectedAt: string, now = Date.now()): boolean {
+  const timestamp = Date.parse(connectedAt);
+  if (!Number.isFinite(timestamp)) return false;
+  const age = now - timestamp;
+  return age >= 0 && age <= DAEMON_HELLO_TIMEOUT_MS;
+}