clawdentity 0.0.24 → 0.0.26

package/dist/index.js

@@ -14361,6 +14361,9 @@ var INVITES_REDEEM_PATH = "/v1/invites/redeem";
 var ME_API_KEYS_PATH = "/v1/me/api-keys";
 var REGISTRY_METADATA_PATH = "/v1/metadata";
 var RELAY_CONNECT_PATH = "/v1/relay/connect";
+var RELAY_DELIVERY_RECEIPTS_PATH = "/v1/relay/delivery-receipts";
+var RELAY_CONVERSATION_ID_HEADER = "x-claw-conversation-id";
+var RELAY_DELIVERY_RECEIPT_URL_HEADER = "x-claw-delivery-receipt-url";
 var RELAY_RECIPIENT_AGENT_DID_HEADER = "x-claw-recipient-agent-did";
 
 // ../../packages/protocol/src/http-signing.ts
@@ -14376,6 +14379,24 @@ function canonicalizeRequest(input) {
   ].join("\n");
 }
 
+// ../../packages/sdk/src/datetime.ts
+function toDate(value) {
+  const parsed = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new TypeError(`Invalid datetime value: ${String(value)}`);
+  }
+  return parsed;
+}
+function nowUtcMs() {
+  return Date.now();
+}
+function toIso(value) {
+  return toDate(value).toISOString();
+}
+function nowIso() {
+  return toIso(nowUtcMs());
+}
+
 // ../../node_modules/.pnpm/hono@4.11.9/node_modules/hono/dist/request/constants.js
 var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
 
@@ -15573,7 +15594,7 @@ async function refreshAgentAuthWithClawProof(input) {
   const refreshBody = JSON.stringify({
     refreshToken: input.refreshToken
   });
-  const nowMs = input.nowMs?.() ?? Date.now();
+  const nowMs = input.nowMs?.() ?? nowUtcMs();
   const timestamp = String(Math.floor(nowMs / 1e3));
   const nonce = encodeBase64url(crypto.getRandomValues(new Uint8Array(16)));
   const signed = await signHttpRequest({
@@ -15780,11 +15801,6 @@ function parseRegistryConfig(env, options = {}) {
 var DEFAULT_CRL_REFRESH_INTERVAL_MS = 5 * 60 * 1e3;
 var DEFAULT_CRL_MAX_AGE_MS = 15 * 60 * 1e3;
 
-// ../../packages/sdk/src/datetime.ts
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-
 // ../../node_modules/.pnpm/jose@6.1.3/node_modules/jose/dist/webapi/lib/buffer_utils.js
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -17840,7 +17856,7 @@ var parseAgentIdFromDid = (agentName, did) => {
   }
 };
 var formatExpiresAt = (expires) => {
-  return new Date(expires * 1e3).toISOString();
+  return toIso(expires * 1e3);
 };
 var resolveFramework = (framework) => {
   if (framework === void 0) {
@@ -17991,7 +18007,7 @@ var writeSecureFile2 = async (path, content) => {
   await chmod2(path, FILE_MODE2);
 };
 var writeSecureFileAtomically = async (path, content) => {
-  const tempPath = `${path}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const tempPath = `${path}.tmp-${nowUtcMs()}-${Math.random().toString(16).slice(2)}`;
   await writeFile2(tempPath, content, "utf-8");
   await chmod2(tempPath, FILE_MODE2);
   try {
@@ -18936,7 +18952,9 @@ var DEFAULT_OPENCLAW_DELIVER_MAX_ATTEMPTS = 4;
 var DEFAULT_OPENCLAW_DELIVER_RETRY_INITIAL_DELAY_MS = 300;
 var DEFAULT_OPENCLAW_DELIVER_RETRY_MAX_DELAY_MS = 2e3;
 var DEFAULT_OPENCLAW_DELIVER_RETRY_BACKOFF_FACTOR = 2;
+var DEFAULT_CONNECT_TIMEOUT_MS = 15e3;
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 3e4;
+var DEFAULT_HEARTBEAT_ACK_TIMEOUT_MS = 6e4;
 var DEFAULT_RECONNECT_MIN_DELAY_MS = 1e3;
 var DEFAULT_RECONNECT_MAX_DELAY_MS = 3e4;
 var DEFAULT_RECONNECT_BACKOFF_FACTOR = 2;
@@ -18953,6 +18971,15 @@ var DEFAULT_CONNECTOR_INBOUND_REPLAY_BATCH_SIZE = 25;
 var DEFAULT_CONNECTOR_INBOUND_RETRY_INITIAL_DELAY_MS = 1e3;
 var DEFAULT_CONNECTOR_INBOUND_RETRY_MAX_DELAY_MS = 6e4;
 var DEFAULT_CONNECTOR_INBOUND_RETRY_BACKOFF_FACTOR = 2;
+var DEFAULT_CONNECTOR_INBOUND_EVENTS_MAX_BYTES = 10 * 1024 * 1024;
+var DEFAULT_CONNECTOR_INBOUND_EVENTS_MAX_FILES = 5;
+var DEFAULT_CONNECTOR_INBOUND_DEAD_LETTER_NON_RETRYABLE_MAX_ATTEMPTS = 5;
+var DEFAULT_CONNECTOR_OPENCLAW_PROBE_INTERVAL_MS = 1e4;
+var DEFAULT_CONNECTOR_OPENCLAW_PROBE_TIMEOUT_MS = 3e3;
+var DEFAULT_CONNECTOR_RUNTIME_REPLAY_DELIVER_MAX_ATTEMPTS = 3;
+var DEFAULT_CONNECTOR_RUNTIME_REPLAY_DELIVER_RETRY_INITIAL_DELAY_MS = 2e3;
+var DEFAULT_CONNECTOR_RUNTIME_REPLAY_DELIVER_RETRY_MAX_DELAY_MS = 8e3;
+var DEFAULT_CONNECTOR_RUNTIME_REPLAY_DELIVER_RETRY_BACKOFF_FACTOR = 2;
 var AGENT_ACCESS_HEADER = "x-claw-agent-access";
 var WS_READY_STATE_OPEN = 1;
 
@@ -19114,6 +19141,7 @@ function serializeFrame(frame) {
 }
 
 // ../../packages/connector/src/client.ts
+var WS_READY_STATE_CONNECTING = 0;
 function isAbortError(error48) {
   return error48 instanceof Error && error48.name === "AbortError";
 }
@@ -19178,6 +19206,33 @@ function readCloseEvent(event) {
     wasClean: typeof event.wasClean === "boolean" ? event.wasClean : false
   };
 }
+function readUnexpectedResponseStatus(event) {
+  if (!isObject3(event)) {
+    return void 0;
+  }
+  if (typeof event.status === "number") {
+    return event.status;
+  }
+  if (typeof event.statusCode === "number") {
+    return event.statusCode;
+  }
+  const response = event.response;
+  if (isObject3(response)) {
+    if (typeof response.status === "number") {
+      return response.status;
+    }
+    if (typeof response.statusCode === "number") {
+      return response.statusCode;
+    }
+  }
+  return void 0;
+}
+function readErrorEventReason(event) {
+  if (!isObject3(event) || !("error" in event)) {
+    return "WebSocket error";
+  }
+  return sanitizeErrorReason(event.error);
+}
 function normalizeConnectionHeaders(headers) {
   if (headers === void 0) {
     return {};
@@ -19199,7 +19254,9 @@ var ConnectorClient = class {
   connectionHeadersProvider;
   openclawHookUrl;
   openclawHookToken;
+  connectTimeoutMs;
   heartbeatIntervalMs;
+  heartbeatAckTimeoutMs;
   reconnectMinDelayMs;
   reconnectMaxDelayMs;
   reconnectBackoffFactor;
@@ -19214,14 +19271,36 @@ var ConnectorClient = class {
   fetchImpl;
   logger;
   hooks;
+  outboundQueuePersistence;
   inboundDeliverHandler;
   now;
   random;
   ulidFactory;
   socket;
   reconnectTimeout;
+  connectTimeout;
   heartbeatInterval;
+  heartbeatAckTimeout;
+  pendingHeartbeatAcks = /* @__PURE__ */ new Map();
   reconnectAttempt = 0;
+  reconnectCount = 0;
+  connectAttempts = 0;
+  connectedSinceMs;
+  accumulatedConnectedMs = 0;
+  lastConnectedAtIso;
+  heartbeatRttSampleCount = 0;
+  heartbeatRttTotalMs = 0;
+  heartbeatRttMaxMs = 0;
+  heartbeatRttLastMs;
+  inboundAckLatencySampleCount = 0;
+  inboundAckLatencyTotalMs = 0;
+  inboundAckLatencyMaxMs = 0;
+  inboundAckLatencyLastMs;
+  maxObservedOutboundQueueDepth = 0;
+  outboundQueueLoaded = false;
+  outboundQueueLoadPromise;
+  outboundQueueSaveChain = Promise.resolve();
+  authUpgradeImmediateRetryUsed = false;
   started = false;
   outboundQueue = [];
   constructor(options) {
@@ -19231,7 +19310,17 @@ var ConnectorClient = class {
     );
     this.connectionHeadersProvider = options.connectionHeadersProvider;
     this.openclawHookToken = options.openclawHookToken;
+    this.connectTimeoutMs = Math.max(
+      0,
+      Math.floor(options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS)
+    );
     this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    this.heartbeatAckTimeoutMs = Math.max(
+      0,
+      Math.floor(
+        options.heartbeatAckTimeoutMs ?? DEFAULT_HEARTBEAT_ACK_TIMEOUT_MS
+      )
+    );
     this.reconnectMinDelayMs = options.reconnectMinDelayMs ?? DEFAULT_RECONNECT_MIN_DELAY_MS;
     this.reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
     this.reconnectBackoffFactor = options.reconnectBackoffFactor ?? DEFAULT_RECONNECT_BACKOFF_FACTOR;
@@ -19269,6 +19358,7 @@ var ConnectorClient = class {
     this.fetchImpl = options.fetchImpl ?? fetch;
     this.logger = options.logger ?? createLogger({ service: "connector", module: "client" });
     this.hooks = options.hooks ?? {};
+    this.outboundQueuePersistence = options.outboundQueuePersistence;
     this.inboundDeliverHandler = options.inboundDeliverHandler;
     this.now = options.now ?? Date.now;
     this.random = options.random ?? Math.random;
@@ -19283,16 +19373,19 @@ var ConnectorClient = class {
       return;
     }
     this.started = true;
+    if (this.outboundQueuePersistence !== void 0) {
+      void this.ensureOutboundQueueLoaded();
+    }
     void this.connectSocket();
   }
   disconnect() {
     this.started = false;
     this.clearReconnectTimeout();
-    this.clearHeartbeatInterval();
+    this.clearSocketState();
     if (this.socket !== void 0) {
       const socket = this.socket;
       this.socket = void 0;
-      socket.close(1e3, "client disconnect");
+      this.closeSocketQuietly(socket, 1e3, "client disconnect");
     }
   }
   isConnected() {
@@ -19301,6 +19394,42 @@ var ConnectorClient = class {
   getQueuedOutboundCount() {
     return this.outboundQueue.length;
   }
+  getMetricsSnapshot() {
+    const nowMs = this.now();
+    const uptimeMs = this.accumulatedConnectedMs + (this.connectedSinceMs === void 0 ? 0 : nowMs - this.connectedSinceMs);
+    return {
+      connection: {
+        connectAttempts: this.connectAttempts,
+        connected: this.isConnected(),
+        reconnectCount: this.reconnectCount,
+        uptimeMs: Math.max(0, uptimeMs),
+        lastConnectedAt: this.lastConnectedAtIso
+      },
+      heartbeat: {
+        pendingAckCount: this.pendingHeartbeatAcks.size,
+        sampleCount: this.heartbeatRttSampleCount,
+        lastRttMs: this.heartbeatRttLastMs,
+        maxRttMs: this.heartbeatRttSampleCount > 0 ? this.heartbeatRttMaxMs : void 0,
+        avgRttMs: this.heartbeatRttSampleCount > 0 ? Math.floor(
+          this.heartbeatRttTotalMs / this.heartbeatRttSampleCount
+        ) : void 0
+      },
+      inboundDelivery: {
+        sampleCount: this.inboundAckLatencySampleCount,
+        lastAckLatencyMs: this.inboundAckLatencyLastMs,
+        maxAckLatencyMs: this.inboundAckLatencySampleCount > 0 ? this.inboundAckLatencyMaxMs : void 0,
+        avgAckLatencyMs: this.inboundAckLatencySampleCount > 0 ? Math.floor(
+          this.inboundAckLatencyTotalMs / this.inboundAckLatencySampleCount
+        ) : void 0
+      },
+      outboundQueue: {
+        currentDepth: this.outboundQueue.length,
+        maxDepth: this.maxObservedOutboundQueueDepth,
+        loadedFromPersistence: this.outboundQueueLoaded,
+        persistenceEnabled: this.outboundQueuePersistence !== void 0
+      }
+    };
+  }
   enqueueOutbound(input) {
     const frame = enqueueFrameSchema.parse({
       v: CONNECTOR_FRAME_VERSION,
@@ -19313,11 +19442,17 @@ var ConnectorClient = class {
       replyTo: input.replyTo
     });
     this.outboundQueue.push(frame);
+    this.recordOutboundQueueDepth();
+    this.persistOutboundQueue();
     this.flushOutboundQueue();
     return frame;
   }
   async connectSocket() {
     this.clearReconnectTimeout();
+    this.connectAttempts += 1;
+    if (this.outboundQueuePersistence !== void 0) {
+      await this.ensureOutboundQueueLoaded();
+    }
     let connectionHeaders = this.connectionHeaders;
     if (this.connectionHeadersProvider) {
       try {
@@ -19344,8 +19479,18 @@ var ConnectorClient = class {
       this.scheduleReconnect();
       return;
     }
-    this.socket.addEventListener("open", () => {
+    const socket = this.socket;
+    this.startConnectTimeout(socket);
+    socket.addEventListener("open", () => {
+      if (this.socket !== socket) {
+        return;
+      }
+      this.clearConnectTimeout();
+      this.clearHeartbeatTracking();
       this.reconnectAttempt = 0;
+      this.authUpgradeImmediateRetryUsed = false;
+      this.connectedSinceMs = this.now();
+      this.lastConnectedAtIso = this.makeTimestamp();
       this.logger.info("connector.websocket.connected", {
         url: this.connectorUrl
       });
@@ -19353,12 +19498,16 @@ var ConnectorClient = class {
       this.flushOutboundQueue();
       this.hooks.onConnected?.();
     });
-    this.socket.addEventListener("message", (event) => {
+    socket.addEventListener("message", (event) => {
+      if (this.socket !== socket) {
+        return;
+      }
       void this.handleIncomingMessage(readMessageEventData(event));
     });
-    this.socket.addEventListener("close", (event) => {
-      this.clearHeartbeatInterval();
-      this.socket = void 0;
+    socket.addEventListener("close", (event) => {
+      if (!this.detachSocket(socket)) {
+        return;
+      }
       const closeEvent = readCloseEvent(event);
       this.logger.warn("connector.websocket.closed", {
         closeCode: closeEvent.code,
@@ -19374,22 +19523,61 @@ var ConnectorClient = class {
         this.scheduleReconnect();
       }
     });
-    this.socket.addEventListener("error", () => {
+    socket.addEventListener("error", (event) => {
+      if (this.socket !== socket) {
+        return;
+      }
+      const readyState = socket.readyState;
+      const shouldForceReconnect = readyState !== WS_READY_STATE_OPEN && readyState !== WS_READY_STATE_CONNECTING;
+      if (!shouldForceReconnect) {
+        this.logger.warn("connector.websocket.error", {
+          url: this.connectorUrl,
+          reason: readErrorEventReason(event),
+          readyState
+        });
+        return;
+      }
+      if (!this.detachSocket(socket)) {
+        return;
+      }
+      const reason = readErrorEventReason(event);
       this.logger.warn("connector.websocket.error", {
-        url: this.connectorUrl
+        url: this.connectorUrl,
+        reason
       });
+      this.closeSocketQuietly(socket, 1011, "websocket error");
+      this.hooks.onDisconnected?.({
+        code: 1006,
+        reason,
+        wasClean: false
+      });
+      if (this.started) {
+        this.scheduleReconnect();
+      }
+    });
+    socket.addEventListener("unexpected-response", (event) => {
+      void this.handleUnexpectedResponse(socket, event);
     });
   }
-  scheduleReconnect() {
+  scheduleReconnect(options) {
     if (!this.started) {
       return;
     }
-    const exponentialDelay = this.reconnectMinDelayMs * this.reconnectBackoffFactor ** this.reconnectAttempt;
-    const boundedDelay = Math.min(exponentialDelay, this.reconnectMaxDelayMs);
-    const jitterRange = boundedDelay * this.reconnectJitterRatio;
-    const jitterOffset = jitterRange === 0 ? 0 : (this.random() * 2 - 1) * jitterRange;
-    const delayMs = Math.max(0, Math.floor(boundedDelay + jitterOffset));
-    this.reconnectAttempt += 1;
+    this.clearReconnectTimeout();
+    let delayMs;
+    if (options?.delayMs !== void 0) {
+      delayMs = Math.max(0, Math.floor(options.delayMs));
+    } else {
+      const exponentialDelay = this.reconnectMinDelayMs * this.reconnectBackoffFactor ** this.reconnectAttempt;
+      const boundedDelay = Math.min(exponentialDelay, this.reconnectMaxDelayMs);
+      const jitterRange = boundedDelay * this.reconnectJitterRatio;
+      const jitterOffset = jitterRange === 0 ? 0 : (this.random() * 2 - 1) * jitterRange;
+      delayMs = Math.max(0, Math.floor(boundedDelay + jitterOffset));
+    }
+    if (options?.incrementAttempt ?? true) {
+      this.reconnectAttempt += 1;
+    }
+    this.reconnectCount += 1;
     this.reconnectTimeout = setTimeout(() => {
       void this.connectSocket();
     }, delayMs);
@@ -19400,8 +19588,124 @@ var ConnectorClient = class {
       this.reconnectTimeout = void 0;
     }
   }
+  startConnectTimeout(socket) {
+    this.clearConnectTimeout();
+    if (this.connectTimeoutMs <= 0) {
+      return;
+    }
+    this.connectTimeout = setTimeout(() => {
+      if (!this.detachSocket(socket)) {
+        return;
+      }
+      this.logger.warn("connector.websocket.connect_timeout", {
+        timeoutMs: this.connectTimeoutMs,
+        url: this.connectorUrl
+      });
+      this.closeSocketQuietly(socket, 1e3, "connect timeout");
+      this.hooks.onDisconnected?.({
+        code: 1006,
+        reason: "WebSocket connect timed out",
+        wasClean: false
+      });
+      if (this.started) {
+        this.scheduleReconnect();
+      }
+    }, this.connectTimeoutMs);
+  }
+  clearConnectTimeout() {
+    if (this.connectTimeout !== void 0) {
+      clearTimeout(this.connectTimeout);
+      this.connectTimeout = void 0;
+    }
+  }
+  clearSocketState() {
+    this.clearConnectTimeout();
+    this.clearHeartbeatTracking();
+  }
+  clearHeartbeatTracking() {
+    if (this.heartbeatInterval !== void 0) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = void 0;
+    }
+    if (this.heartbeatAckTimeout !== void 0) {
+      clearTimeout(this.heartbeatAckTimeout);
+      this.heartbeatAckTimeout = void 0;
+    }
+    this.pendingHeartbeatAcks.clear();
+  }
+  detachSocket(socket) {
+    if (this.socket !== socket) {
+      return false;
+    }
+    this.socket = void 0;
+    if (this.connectedSinceMs !== void 0) {
+      this.accumulatedConnectedMs += Math.max(
+        0,
+        this.now() - this.connectedSinceMs
+      );
+      this.connectedSinceMs = void 0;
+    }
+    this.clearSocketState();
+    return true;
+  }
+  closeSocketQuietly(socket, code, reason) {
+    try {
+      socket.close(code, reason);
+    } catch (error48) {
+      this.logger.warn("connector.websocket.close_failed", {
+        reason: sanitizeErrorReason(error48)
+      });
+    }
+  }
+  async handleUnexpectedResponse(socket, event) {
+    if (!this.detachSocket(socket)) {
+      return;
+    }
+    const statusCode = readUnexpectedResponseStatus(event);
+    const isAuthRejected = statusCode === 401;
+    const immediateRetry = isAuthRejected && !this.authUpgradeImmediateRetryUsed;
+    if (isAuthRejected) {
+      this.authUpgradeImmediateRetryUsed = true;
+      await this.invokeAuthUpgradeRejectedHook({
+        status: 401,
+        immediateRetry
+      });
+    }
+    const reason = statusCode === void 0 ? "WebSocket upgrade rejected" : `WebSocket upgrade rejected with status ${statusCode}`;
+    this.logger.warn("connector.websocket.unexpected_response", {
+      statusCode,
+      immediateRetry,
+      url: this.connectorUrl
+    });
+    this.closeSocketQuietly(socket, 1e3, reason);
+    this.hooks.onDisconnected?.({
+      code: 1006,
+      reason,
+      wasClean: false
+    });
+    if (this.started) {
+      this.scheduleReconnect(
+        immediateRetry ? { delayMs: 0, incrementAttempt: false } : void 0
+      );
+    }
+  }
+  async invokeAuthUpgradeRejectedHook(input) {
+    if (this.hooks.onAuthUpgradeRejected === void 0) {
+      return;
+    }
+    try {
+      await this.hooks.onAuthUpgradeRejected(input);
+    } catch (error48) {
+      this.logger.warn(
+        "connector.websocket.auth_upgrade_rejected_hook_failed",
+        {
+          reason: sanitizeErrorReason(error48)
+        }
+      );
+    }
+  }
   startHeartbeatInterval() {
-    this.clearHeartbeatInterval();
+    this.clearHeartbeatTracking();
     if (this.heartbeatIntervalMs <= 0) {
       return;
     }
@@ -19412,13 +19716,82 @@ var ConnectorClient = class {
         id: this.makeFrameId(),
         ts: this.makeTimestamp()
       };
-      this.sendFrame(frame);
+      if (this.sendFrame(frame)) {
+        this.trackHeartbeatAck(frame.id);
+      }
     }, this.heartbeatIntervalMs);
   }
-  clearHeartbeatInterval() {
-    if (this.heartbeatInterval !== void 0) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = void 0;
+  trackHeartbeatAck(ackId) {
+    if (this.heartbeatAckTimeoutMs <= 0) {
+      return;
+    }
+    this.pendingHeartbeatAcks.set(ackId, this.now());
+    this.scheduleHeartbeatAckTimeoutCheck();
+  }
+  handleHeartbeatAckFrame(frame) {
+    const sentAtMs = this.pendingHeartbeatAcks.get(frame.ackId);
+    if (sentAtMs === void 0) {
+      return;
+    }
+    this.pendingHeartbeatAcks.delete(frame.ackId);
+    const rttMs = Math.max(0, this.now() - sentAtMs);
+    this.heartbeatRttSampleCount += 1;
+    this.heartbeatRttTotalMs += rttMs;
+    this.heartbeatRttMaxMs = Math.max(this.heartbeatRttMaxMs, rttMs);
+    this.heartbeatRttLastMs = rttMs;
+    this.scheduleHeartbeatAckTimeoutCheck();
+  }
+  scheduleHeartbeatAckTimeoutCheck() {
+    if (this.heartbeatAckTimeout !== void 0) {
+      clearTimeout(this.heartbeatAckTimeout);
+      this.heartbeatAckTimeout = void 0;
+    }
+    if (this.pendingHeartbeatAcks.size === 0 || this.heartbeatAckTimeoutMs <= 0) {
+      return;
+    }
+    let oldestSentAt = Number.POSITIVE_INFINITY;
+    for (const sentAt of this.pendingHeartbeatAcks.values()) {
+      oldestSentAt = Math.min(oldestSentAt, sentAt);
+    }
+    const elapsedMs = this.now() - oldestSentAt;
+    const delayMs = Math.max(0, this.heartbeatAckTimeoutMs - elapsedMs);
+    this.heartbeatAckTimeout = setTimeout(() => {
+      this.heartbeatAckTimeout = void 0;
+      this.handleHeartbeatAckTimeout();
+    }, delayMs);
+  }
+  handleHeartbeatAckTimeout() {
+    const pendingCount = this.pendingHeartbeatAcks.size;
+    if (pendingCount === 0) {
+      return;
+    }
+    let oldestSentAt = Number.POSITIVE_INFINITY;
+    for (const sentAt of this.pendingHeartbeatAcks.values()) {
+      oldestSentAt = Math.min(oldestSentAt, sentAt);
+    }
+    const nowMs = this.now();
+    const oldestPendingAgeMs = nowMs - oldestSentAt;
+    if (oldestPendingAgeMs < this.heartbeatAckTimeoutMs) {
+      this.scheduleHeartbeatAckTimeoutCheck();
+      return;
+    }
+    const socket = this.socket;
+    if (socket === void 0 || !this.detachSocket(socket)) {
+      return;
+    }
+    this.logger.warn("connector.websocket.heartbeat_ack_timeout", {
+      pendingCount,
+      oldestPendingAgeMs,
+      timeoutMs: this.heartbeatAckTimeoutMs
+    });
+    this.closeSocketQuietly(socket, 1e3, "heartbeat ack timeout");
+    this.hooks.onDisconnected?.({
+      code: 1006,
+      reason: "Heartbeat acknowledgement timed out",
+      wasClean: false
+    });
+    if (this.started) {
+      this.scheduleReconnect();
     }
   }
   flushOutboundQueue() {
@@ -19432,7 +19805,74 @@ var ConnectorClient = class {
         return;
       }
       this.outboundQueue.shift();
+      this.persistOutboundQueue();
+    }
+  }
+  recordOutboundQueueDepth() {
+    this.maxObservedOutboundQueueDepth = Math.max(
+      this.maxObservedOutboundQueueDepth,
+      this.outboundQueue.length
+    );
+  }
+  persistOutboundQueue() {
+    if (this.outboundQueuePersistence === void 0) {
+      return;
+    }
+    this.outboundQueueSaveChain = this.outboundQueueSaveChain.then(async () => {
+      await this.ensureOutboundQueueLoaded();
+      await this.outboundQueuePersistence?.save([...this.outboundQueue]);
+    }).catch((error48) => {
+      this.logger.warn("connector.outbound.persistence_save_failed", {
+        reason: sanitizeErrorReason(error48)
+      });
+    });
+  }
+  async ensureOutboundQueueLoaded() {
+    if (this.outboundQueueLoaded) {
+      return;
+    }
+    if (this.outboundQueuePersistence === void 0) {
+      this.outboundQueueLoaded = true;
+      return;
     }
+    if (this.outboundQueueLoadPromise !== void 0) {
+      await this.outboundQueueLoadPromise;
+      return;
+    }
+    this.outboundQueueLoadPromise = (async () => {
+      try {
+        const loadedFrames = await this.outboundQueuePersistence?.load();
+        if (!loadedFrames || loadedFrames.length === 0) {
+          return;
+        }
+        const existingIds = new Set(this.outboundQueue.map((item) => item.id));
+        const validLoadedFrames = [];
+        for (const candidate of loadedFrames) {
+          const parsed = enqueueFrameSchema.safeParse(candidate);
+          if (!parsed.success) {
+            continue;
+          }
+          if (existingIds.has(parsed.data.id)) {
+            continue;
+          }
+          validLoadedFrames.push(parsed.data);
+          existingIds.add(parsed.data.id);
+        }
+        if (validLoadedFrames.length === 0) {
+          return;
+        }
+        this.outboundQueue.unshift(...validLoadedFrames);
+        this.recordOutboundQueueDepth();
+      } catch (error48) {
+        this.logger.warn("connector.outbound.persistence_load_failed", {
+          reason: sanitizeErrorReason(error48)
+        });
+      } finally {
+        this.outboundQueueLoaded = true;
+      }
+    })();
+    await this.outboundQueueLoadPromise;
+    this.flushOutboundQueue();
   }
   sendFrame(frame) {
     const socket = this.socket;
@@ -19466,6 +19906,10 @@ var ConnectorClient = class {
       this.handleHeartbeatFrame(frame);
       return;
     }
+    if (frame.type === "heartbeat_ack") {
+      this.handleHeartbeatAckFrame(frame);
+      return;
+    }
     if (frame.type === "deliver") {
       await this.handleDeliverFrame(frame);
       return;
@@ -19482,6 +19926,7 @@ var ConnectorClient = class {
     this.sendFrame(ackFrame);
   }
   async handleDeliverFrame(frame) {
+    const startedAtMs = this.now();
     if (this.inboundDeliverHandler !== void 0) {
       try {
         const result = await this.inboundDeliverHandler(frame);
@@ -19505,6 +19950,7 @@ var ConnectorClient = class {
             )
           );
         }
+        this.recordInboundDeliveryAckLatency(this.now() - startedAtMs);
       } catch (error48) {
         const ackFrame = {
           v: CONNECTOR_FRAME_VERSION,
@@ -19517,6 +19963,7 @@ var ConnectorClient = class {
         };
         this.sendFrame(ackFrame);
         this.hooks.onDeliverFailed?.(frame, error48);
+        this.recordInboundDeliveryAckLatency(this.now() - startedAtMs);
       }
       return;
     }
@@ -19532,6 +19979,7 @@ var ConnectorClient = class {
       };
       this.sendFrame(ackFrame);
       this.hooks.onDeliverSucceeded?.(frame);
+      this.recordInboundDeliveryAckLatency(this.now() - startedAtMs);
     } catch (error48) {
       const ackFrame = {
         v: CONNECTOR_FRAME_VERSION,
@@ -19544,8 +19992,19 @@ var ConnectorClient = class {
       };
       this.sendFrame(ackFrame);
       this.hooks.onDeliverFailed?.(frame, error48);
+      this.recordInboundDeliveryAckLatency(this.now() - startedAtMs);
     }
   }
+  recordInboundDeliveryAckLatency(durationMs) {
+    const latencyMs = Math.max(0, Math.floor(durationMs));
+    this.inboundAckLatencySampleCount += 1;
+    this.inboundAckLatencyTotalMs += latencyMs;
+    this.inboundAckLatencyMaxMs = Math.max(
+      this.inboundAckLatencyMaxMs,
+      latencyMs
+    );
+    this.inboundAckLatencyLastMs = latencyMs;
+  }
   async deliverToLocalOpenclaw(frame) {
     const controller = new AbortController();
     const timeout = setTimeout(() => {
@@ -19553,6 +20012,9 @@ var ConnectorClient = class {
     }, this.openclawDeliverTimeoutMs);
     const headers = {
       "content-type": "application/json",
+      "x-clawdentity-agent-did": frame.fromAgentDid,
+      "x-clawdentity-to-agent-did": frame.toAgentDid,
+      "x-clawdentity-verified": "true",
       "x-request-id": frame.id
     };
     if (this.openclawHookToken !== void 0) {
@@ -19568,7 +20030,7 @@ var ConnectorClient = class {
       if (!response.ok) {
         throw new LocalOpenclawDeliveryError({
           message: `Local OpenClaw hook rejected payload with status ${response.status}`,
-          retryable: response.status >= 500 || response.status === 404 || response.status === 429
+          retryable: response.status === 401 || response.status === 403 || response.status >= 500 || response.status === 404 || response.status === 429
         });
       }
     } catch (error48) {
@@ -19631,7 +20093,7 @@ var ConnectorClient = class {
     return this.ulidFactory(this.now());
   }
   makeTimestamp() {
-    return new Date(this.now()).toISOString();
+    return toIso(this.now());
   }
 };
 
@@ -19641,36 +20103,44 @@ import {
   mkdir as mkdir3,
   readFile as readFile3,
   rename as rename2,
+  stat as stat2,
+  unlink as unlink2,
   writeFile as writeFile3
 } from "fs/promises";
 import { dirname as dirname2, join as join4 } from "path";
 var INBOUND_INBOX_DIR_NAME = "inbound-inbox";
 var INBOUND_INBOX_INDEX_FILE_NAME = "index.json";
+var INBOUND_INBOX_INDEX_LOCK_FILE_NAME = "index.lock";
 var INBOUND_INBOX_EVENTS_FILE_NAME = "events.jsonl";
-var INBOUND_INBOX_SCHEMA_VERSION = 1;
-function nowIso2() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
+var INBOUND_INBOX_SCHEMA_VERSION = 2;
+var DEFAULT_INDEX_LOCK_TIMEOUT_MS = 5e3;
+var DEFAULT_INDEX_LOCK_STALE_MS = 3e4;
+var DEFAULT_INDEX_LOCK_RETRY_MS = 50;
 function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
+function parseOptionalNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
 function parsePendingItem(value) {
   if (!isRecord5(value)) {
     return void 0;
   }
-  const id = typeof value.id === "string" ? value.id.trim() : "";
-  const requestId = typeof value.requestId === "string" ? value.requestId.trim() : "";
-  const fromAgentDid = typeof value.fromAgentDid === "string" ? value.fromAgentDid.trim() : "";
-  const toAgentDid = typeof value.toAgentDid === "string" ? value.toAgentDid.trim() : "";
-  const receivedAt = typeof value.receivedAt === "string" ? value.receivedAt.trim() : "";
-  const nextAttemptAt = typeof value.nextAttemptAt === "string" ? value.nextAttemptAt.trim() : "";
+  const id = parseOptionalNonEmptyString(value.id) ?? "";
+  const requestId = parseOptionalNonEmptyString(value.requestId) ?? "";
+  const fromAgentDid = parseOptionalNonEmptyString(value.fromAgentDid) ?? "";
+  const toAgentDid = parseOptionalNonEmptyString(value.toAgentDid) ?? "";
+  const receivedAt = parseOptionalNonEmptyString(value.receivedAt) ?? "";
+  const nextAttemptAt = parseOptionalNonEmptyString(value.nextAttemptAt) ?? "";
   const attemptCount = typeof value.attemptCount === "number" && Number.isInteger(value.attemptCount) ? value.attemptCount : NaN;
   const payloadBytes = typeof value.payloadBytes === "number" && Number.isInteger(value.payloadBytes) ? value.payloadBytes : NaN;
   if (id.length === 0 || requestId.length === 0 || fromAgentDid.length === 0 || toAgentDid.length === 0 || receivedAt.length === 0 || nextAttemptAt.length === 0 || !Number.isFinite(attemptCount) || attemptCount < 0 || !Number.isFinite(payloadBytes) || payloadBytes < 0) {
     return void 0;
   }
-  const lastError = typeof value.lastError === "string" ? value.lastError : void 0;
-  const lastAttemptAt = typeof value.lastAttemptAt === "string" ? value.lastAttemptAt : void 0;
   return {
     id,
     requestId,
@@ -19681,41 +20151,89 @@ function parsePendingItem(value) {
     receivedAt,
     nextAttemptAt,
     attemptCount,
-    lastError,
-    lastAttemptAt
+    lastError: parseOptionalNonEmptyString(value.lastError),
+    lastAttemptAt: parseOptionalNonEmptyString(value.lastAttemptAt),
+    conversationId: parseOptionalNonEmptyString(value.conversationId),
+    replyTo: parseOptionalNonEmptyString(value.replyTo)
+  };
+}
+function parseDeadLetterItem(value) {
+  const pending = parsePendingItem(value);
+  if (!pending) {
+    return void 0;
+  }
+  if (!isRecord5(value)) {
+    return void 0;
+  }
+  const deadLetteredAt = parseOptionalNonEmptyString(value.deadLetteredAt) ?? "";
+  const deadLetterReason = parseOptionalNonEmptyString(value.deadLetterReason) ?? "";
+  if (deadLetteredAt.length === 0 || deadLetterReason.length === 0) {
+    return void 0;
+  }
+  return {
+    ...pending,
+    deadLetteredAt,
+    deadLetterReason
   };
 }
 function toDefaultIndexFile() {
   return {
     version: INBOUND_INBOX_SCHEMA_VERSION,
     pendingBytes: 0,
+    deadLetterBytes: 0,
     pendingByRequestId: {},
-    updatedAt: nowIso2()
+    deadLetterByRequestId: {},
+    updatedAt: nowIso()
   };
 }
 function normalizeIndexFile(raw) {
   if (!isRecord5(raw)) {
     throw new Error("Inbound inbox index root must be an object");
   }
+  if (raw.version !== INBOUND_INBOX_SCHEMA_VERSION) {
+    throw new Error(
+      `Inbound inbox index schema version ${String(raw.version)} is unsupported`
+    );
+  }
   const pendingByRequestIdRaw = raw.pendingByRequestId;
+  const deadLetterByRequestIdRaw = raw.deadLetterByRequestId;
   if (!isRecord5(pendingByRequestIdRaw)) {
     throw new Error("Inbound inbox index pendingByRequestId must be an object");
   }
+  if (!isRecord5(deadLetterByRequestIdRaw)) {
+    throw new Error(
+      "Inbound inbox index deadLetterByRequestId must be an object"
+    );
+  }
   const pendingByRequestId = {};
   let pendingBytes = 0;
   for (const [requestId, candidate] of Object.entries(pendingByRequestIdRaw)) {
     const entry = parsePendingItem(candidate);
-    if (entry === void 0 || entry.requestId !== requestId) {
+    if (!entry || entry.requestId !== requestId) {
       continue;
     }
     pendingByRequestId[requestId] = entry;
     pendingBytes += entry.payloadBytes;
   }
+  const deadLetterByRequestId = {};
+  let deadLetterBytes = 0;
+  for (const [requestId, candidate] of Object.entries(
+    deadLetterByRequestIdRaw
+  )) {
+    const entry = parseDeadLetterItem(candidate);
+    if (!entry || entry.requestId !== requestId) {
+      continue;
+    }
+    deadLetterByRequestId[requestId] = entry;
+    deadLetterBytes += entry.payloadBytes;
+  }
   return {
-    version: typeof raw.version === "number" && Number.isFinite(raw.version) ? raw.version : INBOUND_INBOX_SCHEMA_VERSION,
-    pendingBytes,
+    version: INBOUND_INBOX_SCHEMA_VERSION,
     pendingByRequestId,
-    updatedAt: typeof raw.updatedAt === "string" && raw.updatedAt.trim().length > 0 ? raw.updatedAt : nowIso2()
+    deadLetterByRequestId,
+    pendingBytes,
+    deadLetterBytes,
+    updatedAt: parseOptionalNonEmptyString(raw.updatedAt) ?? nowIso()
   };
 }
 function toComparableTimeMs(value) {
@@ -19727,11 +20245,14 @@ function toComparableTimeMs(value) {
 }
 var ConnectorInboundInbox = class {
   agentName;
+  eventsMaxBytes;
+  eventsMaxFiles;
   eventsPath;
+  inboxDir;
   indexPath;
+  indexLockPath;
   maxPendingBytes;
   maxPendingMessages;
-  inboxDir;
   writeChain = Promise.resolve();
   constructor(options) {
     this.agentName = options.agentName;
@@ -19742,15 +20263,20 @@ var ConnectorInboundInbox = class {
       INBOUND_INBOX_DIR_NAME
     );
     this.indexPath = join4(this.inboxDir, INBOUND_INBOX_INDEX_FILE_NAME);
+    this.indexLockPath = join4(
+      this.inboxDir,
+      INBOUND_INBOX_INDEX_LOCK_FILE_NAME
+    );
     this.eventsPath = join4(this.inboxDir, INBOUND_INBOX_EVENTS_FILE_NAME);
     this.maxPendingBytes = options.maxPendingBytes;
     this.maxPendingMessages = options.maxPendingMessages;
+    this.eventsMaxBytes = Math.max(0, options.eventsMaxBytes);
+    this.eventsMaxFiles = Math.max(0, options.eventsMaxFiles);
   }
   async enqueue(frame) {
     return await this.withWriteLock(async () => {
       const index = await this.loadIndex();
-      const existing = index.pendingByRequestId[frame.id];
-      if (existing !== void 0) {
+      if (index.pendingByRequestId[frame.id] !== void 0 || index.deadLetterByRequestId[frame.id] !== void 0) {
         await this.appendEvent({
           type: "inbound_duplicate",
           requestId: frame.id
@@ -19789,13 +20315,15 @@ var ConnectorInboundInbox = class {
         toAgentDid: frame.toAgentDid,
         payload: frame.payload,
         payloadBytes,
-        receivedAt: nowIso2(),
-        nextAttemptAt: nowIso2(),
-        attemptCount: 0
+        receivedAt: nowIso(),
+        nextAttemptAt: nowIso(),
+        attemptCount: 0,
+        conversationId: parseOptionalNonEmptyString(frame.conversationId),
+        replyTo: parseOptionalNonEmptyString(frame.replyTo)
       };
       index.pendingByRequestId[pendingItem.requestId] = pendingItem;
       index.pendingBytes += pendingItem.payloadBytes;
-      index.updatedAt = nowIso2();
+      index.updatedAt = nowIso();
       await this.saveIndex(index);
       await this.appendEvent({
         type: "inbound_persisted",
@@ -19803,7 +20331,9 @@ var ConnectorInboundInbox = class {
         details: {
           payloadBytes,
           fromAgentDid: pendingItem.fromAgentDid,
-          toAgentDid: pendingItem.toAgentDid
+          toAgentDid: pendingItem.toAgentDid,
+          conversationId: pendingItem.conversationId,
+          replyTo: pendingItem.replyTo
         }
       });
       return {
@@ -19834,7 +20364,7 @@ var ConnectorInboundInbox = class {
       }
       delete index.pendingByRequestId[requestId];
       index.pendingBytes = Math.max(0, index.pendingBytes - entry.payloadBytes);
-      index.updatedAt = nowIso2();
+      index.updatedAt = nowIso();
       await this.saveIndex(index);
       await this.appendEvent({
         type: "replay_succeeded",
@@ -19843,17 +20373,44 @@ var ConnectorInboundInbox = class {
     });
   }
   async markReplayFailure(input) {
-    await this.withWriteLock(async () => {
+    return await this.withWriteLock(async () => {
       const index = await this.loadIndex();
       const entry = index.pendingByRequestId[input.requestId];
       if (entry === void 0) {
-        return;
+        return { movedToDeadLetter: false };
       }
       entry.attemptCount += 1;
       entry.lastError = input.errorMessage;
-      entry.lastAttemptAt = nowIso2();
+      entry.lastAttemptAt = nowIso();
+      const shouldMoveToDeadLetter = !input.retryable && entry.attemptCount >= Math.max(1, input.maxNonRetryableAttempts);
+      if (shouldMoveToDeadLetter) {
+        const deadLetterEntry = {
+          ...entry,
+          deadLetteredAt: nowIso(),
+          deadLetterReason: input.errorMessage
+        };
+        delete index.pendingByRequestId[input.requestId];
+        index.pendingBytes = Math.max(
+          0,
+          index.pendingBytes - entry.payloadBytes
+        );
+        index.deadLetterByRequestId[input.requestId] = deadLetterEntry;
+        index.deadLetterBytes += deadLetterEntry.payloadBytes;
+        index.updatedAt = nowIso();
+        await this.saveIndex(index);
+        await this.appendEvent({
+          type: "dead_letter_moved",
+          requestId: input.requestId,
+          details: {
+            attemptCount: deadLetterEntry.attemptCount,
+            retryable: input.retryable,
+            errorMessage: input.errorMessage
+          }
+        });
+        return { movedToDeadLetter: true };
+      }
       entry.nextAttemptAt = input.nextAttemptAt;
-      index.updatedAt = nowIso2();
+      index.updatedAt = nowIso();
       await this.saveIndex(index);
       await this.appendEvent({
         type: "replay_failed",
@@ -19861,62 +20418,184 @@ var ConnectorInboundInbox = class {
         details: {
           attemptCount: entry.attemptCount,
           nextAttemptAt: input.nextAttemptAt,
+          retryable: input.retryable,
           errorMessage: input.errorMessage
         }
       });
+      return { movedToDeadLetter: false };
     });
   }
-  async pruneDelivered() {
-    await this.withWriteLock(async () => {
-      const index = await this.loadIndex();
-      const beforeCount = Object.keys(index.pendingByRequestId).length;
-      if (beforeCount === 0) {
-        return;
+  async listDeadLetter(input) {
+    const index = await this.loadIndex();
+    const entries = Object.values(index.deadLetterByRequestId).sort(
+      (left, right) => {
+        const leftDeadAt = toComparableTimeMs(left.deadLetteredAt);
+        const rightDeadAt = toComparableTimeMs(right.deadLetteredAt);
+        if (leftDeadAt !== rightDeadAt) {
+          return leftDeadAt - rightDeadAt;
+        }
+        return toComparableTimeMs(left.receivedAt) - toComparableTimeMs(right.receivedAt);
       }
-      const after = {};
-      let pendingBytes = 0;
-      for (const [requestId, entry] of Object.entries(
-        index.pendingByRequestId
-      )) {
-        if (entry.attemptCount < 0) {
+    );
+    const limit = Math.max(1, input?.limit ?? (entries.length || 1));
+    return entries.slice(0, limit);
+  }
+  async replayDeadLetter(input) {
+    return await this.withWriteLock(async () => {
+      const index = await this.loadIndex();
+      const requestIds = input?.requestIds !== void 0 ? Array.from(
+        new Set(
+          input.requestIds.map((item) => item.trim()).filter((item) => item.length > 0)
+        )
+      ) : Object.keys(index.deadLetterByRequestId);
+      let replayedCount = 0;
+      for (const requestId of requestIds) {
+        if (requestId.length === 0) {
           continue;
         }
-        after[requestId] = entry;
-        pendingBytes += entry.payloadBytes;
-      }
-      index.pendingByRequestId = after;
-      index.pendingBytes = pendingBytes;
-      index.updatedAt = nowIso2();
-      await this.saveIndex(index);
-      await this.appendEvent({
-        type: "inbox_pruned",
-        details: {
-          beforeCount,
-          afterCount: Object.keys(after).length
+        const dead = index.deadLetterByRequestId[requestId];
+        if (!dead) {
+          continue;
         }
-      });
-    });
+        delete index.deadLetterByRequestId[requestId];
+        index.deadLetterBytes = Math.max(
+          0,
+          index.deadLetterBytes - dead.payloadBytes
+        );
+        index.pendingByRequestId[requestId] = {
+          ...dead,
+          nextAttemptAt: nowIso(),
+          lastError: dead.deadLetterReason
+        };
+        index.pendingBytes += dead.payloadBytes;
+        replayedCount += 1;
+        await this.appendEvent({
+          type: "dead_letter_replayed",
+          requestId,
+          details: {
+            deadLetteredAt: dead.deadLetteredAt,
+            deadLetterReason: dead.deadLetterReason
+          }
+        });
+      }
+      if (replayedCount > 0) {
+        index.updatedAt = nowIso();
+        await this.saveIndex(index);
+      }
+      return { replayedCount };
+    });
+  }
+  async purgeDeadLetter(input) {
+    return await this.withWriteLock(async () => {
+      const index = await this.loadIndex();
+      const requestIds = input?.requestIds !== void 0 ? Array.from(
+        new Set(
+          input.requestIds.map((item) => item.trim()).filter((item) => item.length > 0)
+        )
+      ) : Object.keys(index.deadLetterByRequestId);
+      let purgedCount = 0;
+      for (const requestId of requestIds) {
+        if (requestId.length === 0) {
+          continue;
+        }
+        const dead = index.deadLetterByRequestId[requestId];
+        if (!dead) {
+          continue;
+        }
+        delete index.deadLetterByRequestId[requestId];
+        index.deadLetterBytes = Math.max(
+          0,
+          index.deadLetterBytes - dead.payloadBytes
+        );
+        purgedCount += 1;
+        await this.appendEvent({
+          type: "dead_letter_purged",
+          requestId,
+          details: {
+            deadLetteredAt: dead.deadLetteredAt,
+            deadLetterReason: dead.deadLetterReason
+          }
+        });
+      }
+      if (purgedCount > 0) {
+        index.updatedAt = nowIso();
+        await this.saveIndex(index);
+      }
+      return { purgedCount };
+    });
+  }
+  async pruneDelivered() {
+    await this.withWriteLock(async () => {
+      const index = await this.loadIndex();
+      const beforePendingCount = Object.keys(index.pendingByRequestId).length;
+      const beforeDeadLetterCount = Object.keys(
+        index.deadLetterByRequestId
+      ).length;
+      if (beforePendingCount === 0 && beforeDeadLetterCount === 0) {
+        return;
+      }
+      const nextPending = {};
+      let pendingBytes = 0;
+      for (const [requestId, entry] of Object.entries(
+        index.pendingByRequestId
+      )) {
+        if (entry.attemptCount < 0) {
+          continue;
+        }
+        nextPending[requestId] = entry;
+        pendingBytes += entry.payloadBytes;
+      }
+      const nextDead = {};
+      let deadLetterBytes = 0;
+      for (const [requestId, entry] of Object.entries(
+        index.deadLetterByRequestId
+      )) {
+        if (entry.attemptCount < 0) {
+          continue;
+        }
+        nextDead[requestId] = entry;
+        deadLetterBytes += entry.payloadBytes;
+      }
+      index.pendingByRequestId = nextPending;
+      index.pendingBytes = pendingBytes;
+      index.deadLetterByRequestId = nextDead;
+      index.deadLetterBytes = deadLetterBytes;
+      index.updatedAt = nowIso();
+      await this.saveIndex(index);
+      await this.appendEvent({
+        type: "inbox_pruned",
+        details: {
+          beforePendingCount,
+          afterPendingCount: Object.keys(nextPending).length,
+          beforeDeadLetterCount,
+          afterDeadLetterCount: Object.keys(nextDead).length
+        }
+      });
+    });
   }
   async getSnapshot() {
     const index = await this.loadIndex();
-    const entries = Object.values(index.pendingByRequestId);
-    if (entries.length === 0) {
-      return {
-        pendingCount: 0,
-        pendingBytes: index.pendingBytes
-      };
-    }
-    entries.sort((left, right) => {
-      return toComparableTimeMs(left.receivedAt) - toComparableTimeMs(right.receivedAt);
-    });
-    const nextAttemptAt = entries.map((entry) => entry.nextAttemptAt).sort(
+    const pendingEntries = Object.values(index.pendingByRequestId).sort(
+      (left, right) => toComparableTimeMs(left.receivedAt) - toComparableTimeMs(right.receivedAt)
+    );
+    const deadEntries = Object.values(index.deadLetterByRequestId).sort(
+      (left, right) => toComparableTimeMs(left.deadLetteredAt) - toComparableTimeMs(right.deadLetteredAt)
+    );
+    const nextAttemptAt = pendingEntries.map((entry) => entry.nextAttemptAt).sort(
       (left, right) => toComparableTimeMs(left) - toComparableTimeMs(right)
     )[0];
     return {
-      pendingCount: entries.length,
-      pendingBytes: index.pendingBytes,
-      oldestPendingAt: entries[0]?.receivedAt,
-      nextAttemptAt
+      pending: {
+        pendingCount: pendingEntries.length,
+        pendingBytes: index.pendingBytes,
+        oldestPendingAt: pendingEntries[0]?.receivedAt,
+        nextAttemptAt
+      },
+      deadLetter: {
+        deadLetterCount: deadEntries.length,
+        deadLetterBytes: index.deadLetterBytes,
+        oldestDeadLetterAt: deadEntries[0]?.deadLetteredAt
+      }
     };
   }
   async withWriteLock(fn) {
@@ -19926,12 +20605,67 @@ var ConnectorInboundInbox = class {
       release = resolve2;
     });
     await previous;
+    const releaseFileLock = await this.acquireIndexFileLock();
     try {
       return await fn();
     } finally {
+      await releaseFileLock();
       release?.();
     }
   }
+  async acquireIndexFileLock() {
+    const startedAt = nowUtcMs();
+    await mkdir3(this.inboxDir, { recursive: true });
+    while (true) {
+      try {
+        await writeFile3(
+          this.indexLockPath,
+          `${JSON.stringify({ pid: process.pid, createdAt: nowIso() })}
+`,
+          {
+            encoding: "utf8",
+            flag: "wx"
+          }
+        );
+        let released = false;
+        return async () => {
+          if (released) {
+            return;
+          }
+          released = true;
+          try {
+            await unlink2(this.indexLockPath);
+          } catch {
+          }
+        };
+      } catch (error48) {
+        const code = error48 && typeof error48 === "object" && "code" in error48 ? error48.code : void 0;
+        if (code !== "EEXIST") {
+          throw error48;
+        }
+        const lockStats = await this.readLockStats();
+        if (lockStats !== void 0 && nowUtcMs() - lockStats.mtimeMs > DEFAULT_INDEX_LOCK_STALE_MS) {
+          try {
+            await unlink2(this.indexLockPath);
+          } catch {
+          }
+          continue;
+        }
+        if (nowUtcMs() - startedAt >= DEFAULT_INDEX_LOCK_TIMEOUT_MS) {
+          throw new Error("Timed out waiting for inbound inbox index lock");
+        }
+        await this.sleep(DEFAULT_INDEX_LOCK_RETRY_MS);
+      }
+    }
+  }
+  async readLockStats() {
+    try {
+      const lockStat = await stat2(this.indexLockPath);
+      return { mtimeMs: lockStat.mtimeMs };
+    } catch {
+      return void 0;
+    }
+  }
   async loadIndex() {
     await mkdir3(this.inboxDir, { recursive: true });
     let raw;
@@ -19954,9 +20688,9 @@ var ConnectorInboundInbox = class {
     const payload = {
       ...index,
       version: INBOUND_INBOX_SCHEMA_VERSION,
-      updatedAt: nowIso2()
+      updatedAt: nowIso()
     };
-    const tmpPath = `${this.indexPath}.tmp-${Date.now()}`;
+    const tmpPath = `${this.indexPath}.tmp-${nowUtcMs()}`;
     await writeFile3(tmpPath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
     await rename2(tmpPath, this.indexPath);
@@ -19965,10 +20699,53 @@ var ConnectorInboundInbox = class {
     await mkdir3(dirname2(this.eventsPath), { recursive: true });
     await appendFile(
       this.eventsPath,
-      `${JSON.stringify({ ...event, at: nowIso2() })}
+      `${JSON.stringify({ ...event, at: nowIso() })}
 `,
       "utf8"
     );
+    await this.rotateEventsIfNeeded();
+  }
+  async rotateEventsIfNeeded() {
+    if (this.eventsMaxBytes <= 0 || this.eventsMaxFiles <= 0) {
+      return;
+    }
+    let currentSize;
+    try {
+      const current = await stat2(this.eventsPath);
+      currentSize = current.size;
+    } catch {
+      return;
+    }
+    if (currentSize <= this.eventsMaxBytes) {
+      return;
+    }
+    for (let index = this.eventsMaxFiles; index >= 1; index -= 1) {
+      const fromPath = index === 1 ? this.eventsPath : `${this.eventsPath}.${index - 1}`;
+      const toPath = `${this.eventsPath}.${index}`;
+      const fromExists = await this.pathExists(fromPath);
+      if (!fromExists) {
+        continue;
+      }
+      const toExists = await this.pathExists(toPath);
+      if (toExists) {
+        await unlink2(toPath);
+      }
+      await rename2(fromPath, toPath);
+    }
+    await writeFile3(this.eventsPath, "", "utf8");
+  }
+  async pathExists(pathValue) {
+    try {
+      await stat2(pathValue);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async sleep(durationMs) {
+    await new Promise((resolve2) => {
+      setTimeout(resolve2, durationMs);
+    });
   }
 };
 function createConnectorInboundInbox(options) {
@@ -19981,10 +20758,13 @@ import { mkdir as mkdir4, readFile as readFile4, rename as rename3, writeFile as
 import {
   createServer
 } from "http";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname3, isAbsolute, join as join5 } from "path";
 import { WebSocket as NodeWebSocket } from "ws";
 var REGISTRY_AUTH_FILENAME = "registry-auth.json";
+var OPENCLAW_RELAY_RUNTIME_FILE_NAME = "openclaw-relay.json";
 var AGENTS_DIR_NAME2 = "agents";
+var OUTBOUND_QUEUE_DIR_NAME = "outbound-queue";
+var OUTBOUND_QUEUE_FILENAME = "queue.json";
 var REFRESH_SINGLE_FLIGHT_PREFIX = "connector-runtime";
 var NONCE_SIZE = 16;
 var MAX_OUTBOUND_BODY_BYTES = 1024 * 1024;
@@ -20001,6 +20781,23 @@ function parseRequiredString(value, field) {
   }
   return value.trim();
 }
+function parseOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function parseOptionalProxyOrigin(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return new URL(value.trim()).origin;
+  } catch {
+    return void 0;
+  }
+}
 function normalizeOutboundBaseUrl(baseUrlInput) {
   const raw = baseUrlInput?.trim() || DEFAULT_CONNECTOR_BASE_URL;
   let parsed;
@@ -20062,6 +20859,15 @@ function toOpenclawHookUrl2(baseUrl, hookPath) {
   const normalizedHookPath = hookPath.startsWith("/") ? hookPath.slice(1) : hookPath;
   return new URL(normalizedHookPath, normalizedBase).toString();
 }
+function toHttpOriginFromWebSocketUrl(value) {
+  const normalized = new URL(value.toString());
+  if (normalized.protocol === "wss:") {
+    normalized.protocol = "https:";
+  } else if (normalized.protocol === "ws:") {
+    normalized.protocol = "http:";
+  }
+  return normalized.origin;
+}
 function parsePositiveIntEnv(key, fallback, minimum = 1) {
   const raw = process.env[key]?.trim();
   if (!raw) {
@@ -20080,10 +20886,12 @@ function sanitizeErrorReason2(error48) {
   return error48.message.trim().slice(0, 240) || "Unknown error";
 }
 var LocalOpenclawDeliveryError2 = class extends Error {
+  code;
   retryable;
   constructor(input) {
     super(input.message);
     this.name = "LocalOpenclawDeliveryError";
+    this.code = input.code;
     this.retryable = input.retryable;
   }
 };
@@ -20091,7 +20899,22 @@ function loadInboundReplayPolicy() {
   const retryBackoffFactor = Number.parseFloat(
     process.env.CONNECTOR_INBOUND_RETRY_BACKOFF_FACTOR ?? ""
   );
+  const runtimeReplayRetryBackoffFactor = Number.parseFloat(
+    process.env.CONNECTOR_RUNTIME_REPLAY_RETRY_BACKOFF_FACTOR ?? ""
+  );
   return {
+    deadLetterNonRetryableMaxAttempts: parsePositiveIntEnv(
+      "CONNECTOR_INBOUND_DEAD_LETTER_NON_RETRYABLE_MAX_ATTEMPTS",
+      DEFAULT_CONNECTOR_INBOUND_DEAD_LETTER_NON_RETRYABLE_MAX_ATTEMPTS
+    ),
+    eventsMaxBytes: parsePositiveIntEnv(
+      "CONNECTOR_INBOUND_EVENTS_MAX_BYTES",
+      DEFAULT_CONNECTOR_INBOUND_EVENTS_MAX_BYTES
+    ),
+    eventsMaxFiles: parsePositiveIntEnv(
+      "CONNECTOR_INBOUND_EVENTS_MAX_FILES",
+      DEFAULT_CONNECTOR_INBOUND_EVENTS_MAX_FILES
+    ),
     inboxMaxMessages: parsePositiveIntEnv(
       "CONNECTOR_INBOUND_INBOX_MAX_MESSAGES",
       DEFAULT_CONNECTOR_INBOUND_INBOX_MAX_MESSAGES
@@ -20116,7 +20939,32 @@ function loadInboundReplayPolicy() {
       "CONNECTOR_INBOUND_RETRY_MAX_DELAY_MS",
       DEFAULT_CONNECTOR_INBOUND_RETRY_MAX_DELAY_MS
     ),
-    retryBackoffFactor: Number.isFinite(retryBackoffFactor) && retryBackoffFactor >= 1 ? retryBackoffFactor : DEFAULT_CONNECTOR_INBOUND_RETRY_BACKOFF_FACTOR
+    retryBackoffFactor: Number.isFinite(retryBackoffFactor) && retryBackoffFactor >= 1 ? retryBackoffFactor : DEFAULT_CONNECTOR_INBOUND_RETRY_BACKOFF_FACTOR,
+    runtimeReplayMaxAttempts: parsePositiveIntEnv(
+      "CONNECTOR_RUNTIME_REPLAY_MAX_ATTEMPTS",
+      DEFAULT_CONNECTOR_RUNTIME_REPLAY_DELIVER_MAX_ATTEMPTS
+    ),
+    runtimeReplayRetryInitialDelayMs: parsePositiveIntEnv(
+      "CONNECTOR_RUNTIME_REPLAY_RETRY_INITIAL_DELAY_MS",
+      DEFAULT_CONNECTOR_RUNTIME_REPLAY_DELIVER_RETRY_INITIAL_DELAY_MS
+    ),
+    runtimeReplayRetryMaxDelayMs: parsePositiveIntEnv(
+      "CONNECTOR_RUNTIME_REPLAY_RETRY_MAX_DELAY_MS",
+      DEFAULT_CONNECTOR_RUNTIME_REPLAY_DELIVER_RETRY_MAX_DELAY_MS
+    ),
+    runtimeReplayRetryBackoffFactor: Number.isFinite(runtimeReplayRetryBackoffFactor) && runtimeReplayRetryBackoffFactor >= 1 ? runtimeReplayRetryBackoffFactor : DEFAULT_CONNECTOR_RUNTIME_REPLAY_DELIVER_RETRY_BACKOFF_FACTOR
+  };
+}
+function loadOpenclawProbePolicy() {
+  return {
+    intervalMs: parsePositiveIntEnv(
+      "CONNECTOR_OPENCLAW_PROBE_INTERVAL_MS",
+      DEFAULT_CONNECTOR_OPENCLAW_PROBE_INTERVAL_MS
+    ),
+    timeoutMs: parsePositiveIntEnv(
+      "CONNECTOR_OPENCLAW_PROBE_TIMEOUT_MS",
+      DEFAULT_CONNECTOR_OPENCLAW_PROBE_TIMEOUT_MS
+    )
   };
 }
 function computeReplayDelayMs(input) {
@@ -20129,13 +20977,90 @@ function computeReplayDelayMs(input) {
   );
   return Math.max(1, delay);
 }
+function computeRuntimeReplayRetryDelayMs(input) {
+  const exponent = Math.max(0, input.attemptCount - 1);
+  const delay = Math.min(
+    input.policy.runtimeReplayRetryMaxDelayMs,
+    Math.floor(
+      input.policy.runtimeReplayRetryInitialDelayMs * input.policy.runtimeReplayRetryBackoffFactor ** exponent
+    )
+  );
+  return Math.max(1, delay);
+}
+async function waitWithAbort(input) {
+  if (input.signal.aborted) {
+    throw new LocalOpenclawDeliveryError2({
+      code: "RUNTIME_STOPPING",
+      message: "Connector runtime is stopping",
+      retryable: false
+    });
+  }
+  await new Promise((resolve2, reject) => {
+    const timeoutHandle = setTimeout(() => {
+      input.signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, input.delayMs);
+    const onAbort = () => {
+      clearTimeout(timeoutHandle);
+      input.signal.removeEventListener("abort", onAbort);
+      reject(
+        new LocalOpenclawDeliveryError2({
+          code: "RUNTIME_STOPPING",
+          message: "Connector runtime is stopping",
+          retryable: false
+        })
+      );
+    };
+    input.signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function readOpenclawHookTokenFromRelayRuntimeConfig(input) {
+  const runtimeConfigPath = join5(
+    input.configDir,
+    OPENCLAW_RELAY_RUNTIME_FILE_NAME
+  );
+  let raw;
+  try {
+    raw = await readFile4(runtimeConfigPath, "utf8");
+  } catch (error48) {
+    if (error48 && typeof error48 === "object" && "code" in error48 && error48.code === "ENOENT") {
+      return void 0;
+    }
+    input.logger.warn("connector.runtime.openclaw_relay_config_read_failed", {
+      runtimeConfigPath,
+      reason: sanitizeErrorReason2(error48)
+    });
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    input.logger.warn("connector.runtime.openclaw_relay_config_invalid_json", {
+      runtimeConfigPath
+    });
+    return void 0;
+  }
+  if (!isRecord6(parsed)) {
+    return void 0;
+  }
+  const tokenValue = parsed.openclawHookToken;
+  if (typeof tokenValue !== "string") {
+    return void 0;
+  }
+  const trimmed = tokenValue.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
 async function deliverToOpenclawHook(input) {
-  const controller = new AbortController();
-  const timeoutHandle = setTimeout(() => {
-    controller.abort();
-  }, DEFAULT_OPENCLAW_DELIVER_TIMEOUT_MS);
+  const timeoutSignal = AbortSignal.timeout(
+    DEFAULT_OPENCLAW_DELIVER_TIMEOUT_MS
+  );
+  const signal = AbortSignal.any([input.shutdownSignal, timeoutSignal]);
   const headers = {
     "content-type": "application/json",
+    "x-clawdentity-agent-did": input.fromAgentDid,
+    "x-clawdentity-to-agent-did": input.toAgentDid,
+    "x-clawdentity-verified": "true",
     "x-request-id": input.requestId
   };
   if (input.openclawHookToken !== void 0) {
@@ -20146,16 +21071,24 @@ async function deliverToOpenclawHook(input) {
       method: "POST",
       headers,
       body: JSON.stringify(input.payload),
-      signal: controller.signal
+      signal
     });
     if (!response.ok) {
       throw new LocalOpenclawDeliveryError2({
         message: `Local OpenClaw hook rejected payload with status ${response.status}`,
-        retryable: response.status >= 500 || response.status === 404 || response.status === 429
+        retryable: response.status === 401 || response.status === 403 || response.status >= 500 || response.status === 404 || response.status === 429,
+        code: response.status === 401 || response.status === 403 ? "HOOK_AUTH_REJECTED" : void 0
       });
     }
   } catch (error48) {
     if (error48 instanceof Error && error48.name === "AbortError") {
+      if (input.shutdownSignal.aborted) {
+        throw new LocalOpenclawDeliveryError2({
+          code: "RUNTIME_STOPPING",
+          message: "Connector runtime is stopping",
+          retryable: false
+        });
+      }
       throw new LocalOpenclawDeliveryError2({
         message: "Local OpenClaw hook request timed out",
         retryable: true
@@ -20168,8 +21101,6 @@ async function deliverToOpenclawHook(input) {
       message: sanitizeErrorReason2(error48),
       retryable: true
     });
-  } finally {
-    clearTimeout(timeoutHandle);
   }
 }
 function toInitialAuthBundle(credentials) {
@@ -20207,11 +21138,26 @@ function parseOutboundRelayRequest(payload) {
       expose: true
     });
   }
+  const replyTo = parseOptionalString(payload.replyTo);
+  if (replyTo !== void 0) {
+    try {
+      new URL(replyTo);
+    } catch {
+      throw new AppError({
+        code: "CONNECTOR_OUTBOUND_INVALID_REQUEST",
+        message: "Outbound relay replyTo must be a valid URL",
+        status: 400,
+        expose: true
+      });
+    }
+  }
   return {
     peer: parseRequiredString(payload.peer, "peer"),
     peerDid: parseRequiredString(payload.peerDid, "peerDid"),
     peerProxyUrl: parseRequiredString(payload.peerProxyUrl, "peerProxyUrl"),
-    payload: payload.payload
+    payload: payload.payload,
+    conversationId: parseOptionalString(payload.conversationId),
+    replyTo
   };
 }
 function createWebSocketFactory() {
@@ -20251,6 +21197,14 @@ function createWebSocketFactory() {
           });
           return;
         }
+        if (type === "unexpected-response") {
+          socket.on("unexpected-response", (_request, response) => {
+            listener({
+              status: response.statusCode
+            });
+          });
+          return;
+        }
         socket.on("error", (error48) => listener({ error: error48 }));
       }
     };
@@ -20263,7 +21217,7 @@ async function writeRegistryAuthAtomic(input) {
     input.agentName,
     REGISTRY_AUTH_FILENAME
   );
-  const tmpPath = `${targetPath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const tmpPath = `${targetPath}.tmp-${nowUtcMs()}-${Math.random().toString(16).slice(2)}`;
   await mkdir4(dirname3(targetPath), { recursive: true });
   await writeFile4(tmpPath, `${JSON.stringify(input.auth, null, 2)}
 `, "utf8");
@@ -20326,6 +21280,68 @@ async function readRegistryAuthFromDisk(input) {
   }
   return auth;
 }
+function resolveOutboundQueuePath(input) {
+  return join5(
+    input.configDir,
+    AGENTS_DIR_NAME2,
+    input.agentName,
+    OUTBOUND_QUEUE_DIR_NAME,
+    OUTBOUND_QUEUE_FILENAME
+  );
+}
+function createOutboundQueuePersistence(input) {
+  const queuePath = resolveOutboundQueuePath({
+    configDir: input.configDir,
+    agentName: input.agentName
+  });
+  const load = async () => {
+    let raw;
+    try {
+      raw = await readFile4(queuePath, "utf8");
+    } catch (error48) {
+      if (error48 && typeof error48 === "object" && "code" in error48 && error48.code === "ENOENT") {
+        return [];
+      }
+      input.logger.warn("connector.outbound.persistence_read_failed", {
+        queuePath,
+        reason: sanitizeErrorReason2(error48)
+      });
+      return [];
+    }
+    if (raw.trim().length === 0) {
+      return [];
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error48) {
+      input.logger.warn("connector.outbound.persistence_invalid_json", {
+        queuePath,
+        reason: sanitizeErrorReason2(error48)
+      });
+      return [];
+    }
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    const frames = [];
+    for (const candidate of parsed) {
+      const parsedFrame = enqueueFrameSchema.safeParse(candidate);
+      if (parsedFrame.success) {
+        frames.push(parsedFrame.data);
+      }
+    }
+    return frames;
+  };
+  const save = async (frames) => {
+    await mkdir4(dirname3(queuePath), { recursive: true });
+    const tmpPath = `${queuePath}.tmp-${nowUtcMs()}-${Math.random().toString(16).slice(2)}`;
+    await writeFile4(tmpPath, `${JSON.stringify(frames, null, 2)}
+`, "utf8");
+    await rename3(tmpPath, queuePath);
+  };
+  return { load, save };
+}
 async function readRequestJson(req) {
   const chunks = [];
   let totalBytes = 0;
@@ -20357,6 +21373,19 @@ async function readRequestJson(req) {
     });
   }
 }
+function parseRequestIds(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      value.map((item) => typeof item === "string" ? item.trim() : "").filter((item) => item.length > 0)
+    )
+  );
+}
 function writeJson(res, status, payload) {
   res.statusCode = status;
   res.setHeader("content-type", "application/json; charset=utf-8");
@@ -20367,7 +21396,7 @@ function isRetryableRelayAuthError(error48) {
   return error48 instanceof AppError && error48.code === "OPENCLAW_RELAY_AGENT_AUTH_REJECTED" && error48.status === 401;
 }
 async function buildUpgradeHeaders(input) {
-  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const timestamp = Math.floor(nowUtcMs() / 1e3).toString();
   const nonce = encodeBase64url(randomBytes2(NONCE_SIZE));
   const signed = await signHttpRequest({
     method: "GET",
@@ -20382,6 +21411,93 @@ async function buildUpgradeHeaders(input) {
     ...signed.headers
   };
 }
+async function loadTrustedReceiptTargets(input) {
+  const trustedReceiptTargets = {
+    origins: /* @__PURE__ */ new Set(),
+    byAgentDid: /* @__PURE__ */ new Map()
+  };
+  const relayRuntimeConfigPath = join5(
+    input.configDir,
+    OPENCLAW_RELAY_RUNTIME_FILE_NAME
+  );
+  let relayRuntimeRaw;
+  try {
+    relayRuntimeRaw = await readFile4(relayRuntimeConfigPath, "utf8");
+  } catch (error48) {
+    if (error48 && typeof error48 === "object" && "code" in error48 && error48.code === "ENOENT") {
+      return trustedReceiptTargets;
+    }
+    input.logger.warn("connector.delivery_receipt.runtime_config_read_failed", {
+      relayRuntimeConfigPath,
+      reason: sanitizeErrorReason2(error48)
+    });
+    return trustedReceiptTargets;
+  }
+  let relayRuntimeParsed;
+  try {
+    relayRuntimeParsed = JSON.parse(relayRuntimeRaw);
+  } catch (error48) {
+    input.logger.warn(
+      "connector.delivery_receipt.runtime_config_invalid_json",
+      {
+        relayRuntimeConfigPath,
+        reason: sanitizeErrorReason2(error48)
+      }
+    );
+    return trustedReceiptTargets;
+  }
+  if (!isRecord6(relayRuntimeParsed)) {
+    return trustedReceiptTargets;
+  }
+  const relayTransformPeersPathRaw = typeof relayRuntimeParsed.relayTransformPeersPath === "string" && relayRuntimeParsed.relayTransformPeersPath.trim().length > 0 ? relayRuntimeParsed.relayTransformPeersPath.trim() : void 0;
+  if (!relayTransformPeersPathRaw) {
+    return trustedReceiptTargets;
+  }
+  const relayTransformPeersPath = isAbsolute(relayTransformPeersPathRaw) ? relayTransformPeersPathRaw : join5(input.configDir, relayTransformPeersPathRaw);
+  let relayTransformPeersRaw;
+  try {
+    relayTransformPeersRaw = await readFile4(relayTransformPeersPath, "utf8");
+  } catch (error48) {
+    input.logger.warn("connector.delivery_receipt.peers_snapshot_read_failed", {
+      relayTransformPeersPath,
+      reason: sanitizeErrorReason2(error48)
+    });
+    return trustedReceiptTargets;
+  }
+  let relayTransformPeersParsed;
+  try {
+    relayTransformPeersParsed = JSON.parse(relayTransformPeersRaw);
+  } catch (error48) {
+    input.logger.warn(
+      "connector.delivery_receipt.peers_snapshot_invalid_json",
+      {
+        relayTransformPeersPath,
+        reason: sanitizeErrorReason2(error48)
+      }
+    );
+    return trustedReceiptTargets;
+  }
+  if (!isRecord6(relayTransformPeersParsed)) {
+    return trustedReceiptTargets;
+  }
+  const peersValue = relayTransformPeersParsed.peers;
+  if (!isRecord6(peersValue)) {
+    return trustedReceiptTargets;
+  }
+  for (const peerValue of Object.values(peersValue)) {
+    if (!isRecord6(peerValue)) {
+      continue;
+    }
+    const agentDid = typeof peerValue.did === "string" && peerValue.did.trim().length > 0 ? peerValue.did.trim() : void 0;
+    const origin = parseOptionalProxyOrigin(peerValue.proxyUrl);
+    if (!agentDid || !origin) {
+      continue;
+    }
+    trustedReceiptTargets.origins.add(origin);
+    trustedReceiptTargets.byAgentDid.set(agentDid, origin);
+  }
+  return trustedReceiptTargets;
+}
 async function startConnectorRuntime(input) {
   const logger11 = input.logger ?? createLogger({ service: "connector", module: "runtime" });
   const fetchImpl = input.fetchImpl ?? fetch;
@@ -20408,9 +21524,12 @@ async function startConnectorRuntime(input) {
   };
   const refreshCurrentAuthIfNeeded = async () => {
     await syncAuthFromDisk();
-    if (!shouldRefreshAccessToken(currentAuth, Date.now())) {
+    if (!shouldRefreshAccessToken(currentAuth, nowUtcMs())) {
       return;
     }
+    await refreshCurrentAuth();
+  };
+  const refreshCurrentAuth = async () => {
     currentAuth = await refreshAgentAuthWithClawProof({
       registryUrl: input.registryUrl,
       ait: input.credentials.ait,
@@ -20427,23 +21546,47 @@ async function startConnectorRuntime(input) {
   await refreshCurrentAuthIfNeeded();
   const wsUrl = normalizeWebSocketUrl(input.proxyWebsocketUrl);
   const wsParsed = new URL(wsUrl);
+  const defaultReceiptCallbackUrl = new URL(
+    RELAY_DELIVERY_RECEIPTS_PATH.slice(1),
+    `${toHttpOriginFromWebSocketUrl(wsParsed)}/`
+  ).toString();
+  const defaultReceiptCallbackOrigin = new URL(defaultReceiptCallbackUrl).origin;
   const openclawBaseUrl = resolveOpenclawBaseUrl(input.openclawBaseUrl);
+  const openclawProbeUrl = openclawBaseUrl;
   const openclawHookPath = resolveOpenclawHookPath(input.openclawHookPath);
-  const openclawHookToken = resolveOpenclawHookToken(input.openclawHookToken);
+  const explicitOpenclawHookToken = resolveOpenclawHookToken(
+    input.openclawHookToken
+  );
+  const hasExplicitOpenclawHookToken = explicitOpenclawHookToken !== void 0;
+  let currentOpenclawHookToken = explicitOpenclawHookToken;
   const openclawHookUrl = toOpenclawHookUrl2(openclawBaseUrl, openclawHookPath);
   const inboundReplayPolicy = loadInboundReplayPolicy();
+  const openclawProbePolicy = loadOpenclawProbePolicy();
+  const trustedReceiptTargets = await loadTrustedReceiptTargets({
+    configDir: input.configDir,
+    logger: logger11
+  });
+  trustedReceiptTargets.origins.add(defaultReceiptCallbackOrigin);
   const inboundInbox = createConnectorInboundInbox({
     configDir: input.configDir,
     agentName: input.agentName,
+    eventsMaxBytes: inboundReplayPolicy.eventsMaxBytes,
+    eventsMaxFiles: inboundReplayPolicy.eventsMaxFiles,
     maxPendingMessages: inboundReplayPolicy.inboxMaxMessages,
     maxPendingBytes: inboundReplayPolicy.inboxMaxBytes
   });
   const inboundReplayStatus = {
     replayerActive: false
   };
+  const openclawGatewayProbeStatus = {
+    reachable: true
+  };
+  let openclawProbeInFlight = false;
   let runtimeStopping = false;
   let replayInFlight = false;
   let replayIntervalHandle;
+  let openclawProbeIntervalHandle;
+  const runtimeShutdownController = new AbortController();
   const resolveUpgradeHeaders = async () => {
     await refreshCurrentAuthIfNeeded();
     return buildUpgradeHeaders({
@@ -20453,6 +21596,116 @@ async function startConnectorRuntime(input) {
       secretKey
     });
   };
+  const syncOpenclawHookToken = async (reason) => {
+    if (hasExplicitOpenclawHookToken) {
+      return;
+    }
+    const diskToken = await readOpenclawHookTokenFromRelayRuntimeConfig({
+      configDir: input.configDir,
+      logger: logger11
+    });
+    const nextToken = diskToken;
+    if (nextToken === currentOpenclawHookToken) {
+      return;
+    }
+    currentOpenclawHookToken = nextToken;
+    logger11.info("connector.runtime.openclaw_hook_token_synced", {
+      reason,
+      source: diskToken !== void 0 ? "openclaw-relay.json" : "unset",
+      hasToken: currentOpenclawHookToken !== void 0
+    });
+  };
+  const probeOpenclawGateway = async () => {
+    if (runtimeStopping || openclawProbeInFlight) {
+      return;
+    }
+    openclawProbeInFlight = true;
+    const checkedAt = nowIso();
+    try {
+      const timeoutSignal = AbortSignal.timeout(openclawProbePolicy.timeoutMs);
+      const signal = AbortSignal.any([
+        runtimeShutdownController.signal,
+        timeoutSignal
+      ]);
+      await fetchImpl(openclawProbeUrl, {
+        method: "GET",
+        signal
+      });
+      openclawGatewayProbeStatus.reachable = true;
+      openclawGatewayProbeStatus.lastCheckedAt = checkedAt;
+      openclawGatewayProbeStatus.lastSuccessAt = checkedAt;
+      openclawGatewayProbeStatus.lastFailureReason = void 0;
+    } catch (error48) {
+      if (runtimeShutdownController.signal.aborted) {
+        return;
+      }
+      openclawGatewayProbeStatus.reachable = false;
+      openclawGatewayProbeStatus.lastCheckedAt = checkedAt;
+      openclawGatewayProbeStatus.lastFailureReason = sanitizeErrorReason2(error48);
+    } finally {
+      openclawProbeInFlight = false;
+    }
+  };
+  const deliverToOpenclawHookWithRetry = async (inputReplay) => {
+    let attempt = 1;
+    while (true) {
+      try {
+        await deliverToOpenclawHook({
+          fetchImpl,
+          fromAgentDid: inputReplay.fromAgentDid,
+          openclawHookUrl,
+          openclawHookToken: currentOpenclawHookToken,
+          payload: inputReplay.payload,
+          requestId: inputReplay.requestId,
+          shutdownSignal: runtimeShutdownController.signal,
+          toAgentDid: inputReplay.toAgentDid
+        });
+        return;
+      } catch (error48) {
+        if (error48 instanceof LocalOpenclawDeliveryError2 && error48.code === "RUNTIME_STOPPING") {
+          throw error48;
+        }
+        const retryable = error48 instanceof LocalOpenclawDeliveryError2 ? error48.retryable : true;
+        const authRejected = error48 instanceof LocalOpenclawDeliveryError2 && error48.code === "HOOK_AUTH_REJECTED";
+        if (authRejected) {
+          const previousToken = currentOpenclawHookToken;
+          await syncOpenclawHookToken("auth_rejected");
+          const tokenChanged = currentOpenclawHookToken !== previousToken;
+          const attemptsRemaining2 = attempt < inboundReplayPolicy.runtimeReplayMaxAttempts;
+          if (tokenChanged && !runtimeStopping && attemptsRemaining2) {
+            logger11.warn(
+              "connector.inbound.replay_hook_auth_rejected_retrying",
+              {
+                requestId: inputReplay.requestId,
+                attempt
+              }
+            );
+            attempt += 1;
+            continue;
+          }
+        }
+        const attemptsRemaining = attempt < inboundReplayPolicy.runtimeReplayMaxAttempts;
+        if (!retryable || !attemptsRemaining || runtimeStopping) {
+          throw error48;
+        }
+        const retryDelayMs = computeRuntimeReplayRetryDelayMs({
+          attemptCount: attempt,
+          policy: inboundReplayPolicy
+        });
+        logger11.warn("connector.inbound.replay_retry_scheduled", {
+          requestId: inputReplay.requestId,
+          attempt,
+          retryDelayMs,
+          reason: sanitizeErrorReason2(error48)
+        });
+        await waitWithAbort({
+          delayMs: retryDelayMs,
+          signal: runtimeShutdownController.signal
+        });
+        attempt += 1;
+      }
+    }
+  };
   const replayPendingInboundMessages = async () => {
     if (runtimeStopping || replayInFlight) {
       return;
@@ -20461,64 +21714,141 @@ async function startConnectorRuntime(input) {
     inboundReplayStatus.replayerActive = true;
     try {
       const dueItems = await inboundInbox.listDuePending({
-        nowMs: Date.now(),
+        nowMs: nowUtcMs(),
         limit: inboundReplayPolicy.batchSize
       });
+      if (dueItems.length === 0) {
+        return;
+      }
+      await syncOpenclawHookToken("batch");
+      if (!openclawGatewayProbeStatus.reachable) {
+        logger11.info("connector.inbound.replay_skipped_gateway_unreachable", {
+          pendingCount: dueItems.length,
+          openclawBaseUrl: openclawProbeUrl,
+          lastFailureReason: openclawGatewayProbeStatus.lastFailureReason
+        });
+        return;
+      }
+      const laneByKey = /* @__PURE__ */ new Map();
       for (const pending of dueItems) {
-        inboundReplayStatus.lastAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
-        try {
-          await deliverToOpenclawHook({
-            fetchImpl,
-            openclawHookUrl,
-            openclawHookToken,
-            requestId: pending.requestId,
-            payload: pending.payload
-          });
-          await inboundInbox.markDelivered(pending.requestId);
-          inboundReplayStatus.lastReplayAt = (/* @__PURE__ */ new Date()).toISOString();
-          inboundReplayStatus.lastReplayError = void 0;
-          inboundReplayStatus.lastAttemptStatus = "ok";
-          logger11.info("connector.inbound.replay_succeeded", {
-            requestId: pending.requestId,
-            attemptCount: pending.attemptCount + 1
-          });
-        } catch (error48) {
-          const reason = sanitizeErrorReason2(error48);
-          const retryable = error48 instanceof LocalOpenclawDeliveryError2 ? error48.retryable : true;
-          const nextAttemptAt = new Date(
-            Date.now() + computeReplayDelayMs({
-              attemptCount: pending.attemptCount + 1,
-              policy: inboundReplayPolicy
-            }) * (retryable ? 1 : 10)
-          ).toISOString();
-          await inboundInbox.markReplayFailure({
-            requestId: pending.requestId,
-            errorMessage: reason,
-            nextAttemptAt
-          });
-          inboundReplayStatus.lastReplayError = reason;
-          inboundReplayStatus.lastAttemptStatus = "failed";
-          logger11.warn("connector.inbound.replay_failed", {
-            requestId: pending.requestId,
-            attemptCount: pending.attemptCount + 1,
-            retryable,
-            nextAttemptAt,
-            reason
-          });
+        const laneKey = pending.conversationId !== void 0 ? `conversation:${pending.conversationId}` : "legacy-best-effort";
+        const lane = laneByKey.get(laneKey);
+        if (lane) {
+          lane.push(pending);
+        } else {
+          laneByKey.set(laneKey, [pending]);
         }
       }
+      await Promise.all(
+        Array.from(laneByKey.values()).map(async (laneItems) => {
+          for (const pending of laneItems) {
+            inboundReplayStatus.lastAttemptAt = nowIso();
+            try {
+              await deliverToOpenclawHookWithRetry({
+                fromAgentDid: pending.fromAgentDid,
+                requestId: pending.requestId,
+                payload: pending.payload,
+                toAgentDid: pending.toAgentDid
+              });
+              await inboundInbox.markDelivered(pending.requestId);
+              inboundReplayStatus.lastReplayAt = nowIso();
+              inboundReplayStatus.lastReplayError = void 0;
+              inboundReplayStatus.lastAttemptStatus = "ok";
+              logger11.info("connector.inbound.replay_succeeded", {
+                requestId: pending.requestId,
+                attemptCount: pending.attemptCount + 1,
+                conversationId: pending.conversationId
+              });
+              if (pending.replyTo) {
+                try {
+                  await postDeliveryReceipt({
+                    requestId: pending.requestId,
+                    senderAgentDid: pending.fromAgentDid,
+                    recipientAgentDid: pending.toAgentDid,
+                    replyTo: pending.replyTo,
+                    status: "processed_by_openclaw"
+                  });
+                } catch (error48) {
+                  logger11.warn("connector.inbound.delivery_receipt_failed", {
+                    requestId: pending.requestId,
+                    reason: sanitizeErrorReason2(error48),
+                    status: "processed_by_openclaw"
+                  });
+                }
+              }
+            } catch (error48) {
+              if (error48 instanceof LocalOpenclawDeliveryError2 && error48.code === "RUNTIME_STOPPING") {
+                logger11.info("connector.inbound.replay_stopped", {
+                  requestId: pending.requestId
+                });
+                return;
+              }
+              const reason = sanitizeErrorReason2(error48);
+              const retryable = error48 instanceof LocalOpenclawDeliveryError2 ? error48.retryable : true;
+              const nextAttemptAt = toIso(
+                nowUtcMs() + computeReplayDelayMs({
+                  attemptCount: pending.attemptCount + 1,
+                  policy: inboundReplayPolicy
+                }) * (retryable ? 1 : 10)
+              );
+              const markResult = await inboundInbox.markReplayFailure({
+                requestId: pending.requestId,
+                errorMessage: reason,
+                nextAttemptAt,
+                retryable,
+                maxNonRetryableAttempts: inboundReplayPolicy.deadLetterNonRetryableMaxAttempts
+              });
+              inboundReplayStatus.lastReplayError = reason;
+              inboundReplayStatus.lastAttemptStatus = "failed";
+              logger11.warn("connector.inbound.replay_failed", {
+                requestId: pending.requestId,
+                attemptCount: pending.attemptCount + 1,
+                retryable,
+                nextAttemptAt,
+                movedToDeadLetter: markResult.movedToDeadLetter,
+                reason
+              });
+              if (markResult.movedToDeadLetter && pending.replyTo) {
+                try {
+                  await postDeliveryReceipt({
+                    requestId: pending.requestId,
+                    senderAgentDid: pending.fromAgentDid,
+                    recipientAgentDid: pending.toAgentDid,
+                    replyTo: pending.replyTo,
+                    status: "dead_lettered",
+                    reason
+                  });
+                } catch (receiptError) {
+                  logger11.warn("connector.inbound.delivery_receipt_failed", {
+                    requestId: pending.requestId,
+                    reason: sanitizeErrorReason2(receiptError),
+                    status: "dead_lettered"
+                  });
+                }
+              }
+            }
+          }
+        })
+      );
     } finally {
       replayInFlight = false;
       inboundReplayStatus.replayerActive = false;
     }
   };
   const readInboundReplayView = async () => {
-    const pending = await inboundInbox.getSnapshot();
+    const snapshot = await inboundInbox.getSnapshot();
     return {
-      pending,
+      snapshot,
       replayerActive: inboundReplayStatus.replayerActive || replayInFlight,
       lastReplayAt: inboundReplayStatus.lastReplayAt,
       lastReplayError: inboundReplayStatus.lastReplayError,
+      openclawGateway: {
+        url: openclawProbeUrl,
+        reachable: openclawGatewayProbeStatus.reachable,
+        lastCheckedAt: openclawGatewayProbeStatus.lastCheckedAt,
+        lastSuccessAt: openclawGatewayProbeStatus.lastSuccessAt,
+        lastFailureReason: openclawGatewayProbeStatus.lastFailureReason
+      },
       openclawHook: {
         url: openclawHookUrl,
         lastAttemptAt: inboundReplayStatus.lastAttemptAt,
@@ -20526,14 +21856,39 @@ async function startConnectorRuntime(input) {
       }
     };
   };
+  const outboundQueuePersistence = createOutboundQueuePersistence({
+    configDir: input.configDir,
+    agentName: input.agentName,
+    logger: logger11
+  });
   const connectorClient = new ConnectorClient({
     connectorUrl: wsParsed.toString(),
     connectionHeadersProvider: resolveUpgradeHeaders,
     openclawBaseUrl,
     openclawHookPath,
-    openclawHookToken,
+    openclawHookToken: currentOpenclawHookToken,
     fetchImpl,
     logger: logger11,
+    hooks: {
+      onAuthUpgradeRejected: async ({ status, immediateRetry }) => {
+        logger11.warn("connector.websocket.auth_upgrade_rejected", {
+          status,
+          immediateRetry
+        });
+        await syncAuthFromDisk();
+        try {
+          await refreshCurrentAuth();
+        } catch (error48) {
+          logger11.warn(
+            "connector.runtime.registry_auth_refresh_on_ws_upgrade_reject_failed",
+            {
+              reason: sanitizeErrorReason2(error48)
+            }
+          );
+        }
+      }
+    },
+    outboundQueuePersistence,
     inboundDeliverHandler: async (frame) => {
       const persisted = await inboundInbox.enqueue(frame);
       if (!persisted.accepted) {
@@ -20560,30 +21915,136 @@ async function startConnectorRuntime(input) {
   const outboundBaseUrl = normalizeOutboundBaseUrl(input.outboundBaseUrl);
   const outboundPath = normalizeOutboundPath(input.outboundPath);
   const statusPath = DEFAULT_CONNECTOR_STATUS_PATH;
+  const deadLetterPath = "/v1/inbound/dead-letter";
+  const deadLetterReplayPath = "/v1/inbound/dead-letter/replay";
+  const deadLetterPurgePath = "/v1/inbound/dead-letter/purge";
   const outboundUrl = new URL(outboundPath, outboundBaseUrl).toString();
   const relayToPeer = async (request) => {
     await syncAuthFromDisk();
-    const peerUrl = new URL(request.peerProxyUrl);
-    const body = JSON.stringify(request.payload ?? {});
-    const refreshKey = `${REFRESH_SINGLE_FLIGHT_PREFIX}:${input.configDir}:${input.agentName}`;
-    const performRelay = async (auth) => {
-      const unixSeconds = Math.floor(Date.now() / 1e3).toString();
+    const peerUrl = new URL(request.peerProxyUrl);
+    trustedReceiptTargets.origins.add(peerUrl.origin);
+    trustedReceiptTargets.byAgentDid.set(request.peerDid, peerUrl.origin);
+    const body = JSON.stringify(request.payload ?? {});
+    const refreshKey = `${REFRESH_SINGLE_FLIGHT_PREFIX}:${input.configDir}:${input.agentName}`;
+    const performRelay = async (auth) => {
+      const replyTo = request.replyTo ?? defaultReceiptCallbackUrl;
+      const unixSeconds = Math.floor(nowUtcMs() / 1e3).toString();
+      const nonce = encodeBase64url(randomBytes2(NONCE_SIZE));
+      const signed = await signHttpRequest({
+        method: "POST",
+        pathWithQuery: toPathWithQuery2(peerUrl),
+        timestamp: unixSeconds,
+        nonce,
+        body: new TextEncoder().encode(body),
+        secretKey
+      });
+      const response = await fetchImpl(peerUrl.toString(), {
+        method: "POST",
+        headers: {
+          Authorization: `Claw ${input.credentials.ait}`,
+          "Content-Type": "application/json",
+          [AGENT_ACCESS_HEADER]: auth.accessToken,
+          [RELAY_RECIPIENT_AGENT_DID_HEADER]: request.peerDid,
+          ...request.conversationId ? { [RELAY_CONVERSATION_ID_HEADER]: request.conversationId } : {},
+          [RELAY_DELIVERY_RECEIPT_URL_HEADER]: replyTo,
+          ...signed.headers
+        },
+        body
+      });
+      if (!response.ok) {
+        if (response.status === 401) {
+          throw new AppError({
+            code: "OPENCLAW_RELAY_AGENT_AUTH_REJECTED",
+            message: "Peer relay rejected agent auth credentials",
+            status: 401,
+            expose: true
+          });
+        }
+        throw new AppError({
+          code: "CONNECTOR_OUTBOUND_DELIVERY_FAILED",
+          message: "Peer relay request failed",
+          status: 502
+        });
+      }
+    };
+    await executeWithAgentAuthRefreshRetry({
+      key: refreshKey,
+      shouldRetry: isRetryableRelayAuthError,
+      getAuth: async () => {
+        await syncAuthFromDisk();
+        return currentAuth;
+      },
+      persistAuth: async (nextAuth) => {
+        currentAuth = nextAuth;
+        await writeRegistryAuthAtomic({
+          configDir: input.configDir,
+          agentName: input.agentName,
+          auth: nextAuth
+        });
+      },
+      refreshAuth: async (auth) => refreshAgentAuthWithClawProof({
+        registryUrl: input.registryUrl,
+        ait: input.credentials.ait,
+        secretKey,
+        refreshToken: auth.refreshToken,
+        fetchImpl
+      }),
+      perform: performRelay
+    });
+  };
+  const postDeliveryReceipt = async (inputReceipt) => {
+    await syncAuthFromDisk();
+    const receiptUrl = new URL(inputReceipt.replyTo);
+    if (receiptUrl.pathname !== RELAY_DELIVERY_RECEIPTS_PATH) {
+      throw new AppError({
+        code: "CONNECTOR_DELIVERY_RECEIPT_INVALID_TARGET",
+        message: "Delivery receipt callback target is invalid",
+        status: 400
+      });
+    }
+    const expectedSenderOrigin = trustedReceiptTargets.byAgentDid.get(
+      inputReceipt.senderAgentDid
+    );
+    if (expectedSenderOrigin !== void 0 && receiptUrl.origin !== expectedSenderOrigin) {
+      throw new AppError({
+        code: "CONNECTOR_DELIVERY_RECEIPT_UNTRUSTED_TARGET",
+        message: "Delivery receipt callback target is untrusted",
+        status: 400
+      });
+    }
+    if (expectedSenderOrigin === void 0 && !trustedReceiptTargets.origins.has(receiptUrl.origin)) {
+      throw new AppError({
+        code: "CONNECTOR_DELIVERY_RECEIPT_UNTRUSTED_TARGET",
+        message: "Delivery receipt callback target is untrusted",
+        status: 400
+      });
+    }
+    const body = JSON.stringify({
+      requestId: inputReceipt.requestId,
+      senderAgentDid: inputReceipt.senderAgentDid,
+      recipientAgentDid: inputReceipt.recipientAgentDid,
+      status: inputReceipt.status,
+      reason: inputReceipt.reason,
+      processedAt: nowIso()
+    });
+    const refreshKey = `${REFRESH_SINGLE_FLIGHT_PREFIX}:${input.configDir}:${input.agentName}:delivery-receipt`;
+    const performReceipt = async (auth) => {
+      const unixSeconds = Math.floor(nowUtcMs() / 1e3).toString();
       const nonce = encodeBase64url(randomBytes2(NONCE_SIZE));
       const signed = await signHttpRequest({
         method: "POST",
-        pathWithQuery: toPathWithQuery2(peerUrl),
+        pathWithQuery: toPathWithQuery2(receiptUrl),
         timestamp: unixSeconds,
         nonce,
         body: new TextEncoder().encode(body),
         secretKey
       });
-      const response = await fetchImpl(peerUrl.toString(), {
+      const response = await fetchImpl(receiptUrl.toString(), {
         method: "POST",
         headers: {
           Authorization: `Claw ${input.credentials.ait}`,
           "Content-Type": "application/json",
           [AGENT_ACCESS_HEADER]: auth.accessToken,
-          [RELAY_RECIPIENT_AGENT_DID_HEADER]: request.peerDid,
           ...signed.headers
         },
         body
@@ -20592,14 +22053,14 @@ async function startConnectorRuntime(input) {
         if (response.status === 401) {
           throw new AppError({
             code: "OPENCLAW_RELAY_AGENT_AUTH_REJECTED",
-            message: "Peer relay rejected agent auth credentials",
+            message: "Delivery receipt callback rejected agent auth credentials",
             status: 401,
             expose: true
           });
         }
         throw new AppError({
-          code: "CONNECTOR_OUTBOUND_DELIVERY_FAILED",
-          message: "Peer relay request failed",
+          code: "CONNECTOR_DELIVERY_RECEIPT_FAILED",
+          message: "Delivery receipt callback request failed",
           status: 502
         });
       }
@@ -20626,7 +22087,7 @@ async function startConnectorRuntime(input) {
         refreshToken: auth.refreshToken,
         fetchImpl
       }),
-      perform: performRelay
+      perform: performReceipt
     });
   };
   const server = createServer(async (req, res) => {
@@ -20653,25 +22114,89 @@ async function startConnectorRuntime(input) {
           },
           outboundUrl,
           websocketUrl: wsUrl,
-          websocketConnected: connectorClient.isConnected()
+          websocket: {
+            connected: connectorClient.isConnected()
+          }
         });
         return;
       }
+      const clientMetrics = connectorClient.getMetricsSnapshot();
       writeJson(res, 200, {
         status: "ok",
         outboundUrl,
         websocketUrl: wsUrl,
-        websocketConnected: connectorClient.isConnected(),
-        inboundInbox: {
-          pendingCount: inboundReplayView.pending.pendingCount,
-          pendingBytes: inboundReplayView.pending.pendingBytes,
-          oldestPendingAt: inboundReplayView.pending.oldestPendingAt,
-          nextAttemptAt: inboundReplayView.pending.nextAttemptAt,
-          replayerActive: inboundReplayView.replayerActive,
-          lastReplayAt: inboundReplayView.lastReplayAt,
-          lastReplayError: inboundReplayView.lastReplayError
+        websocket: {
+          ...clientMetrics.connection
         },
-        openclawHook: inboundReplayView.openclawHook
+        inbound: {
+          pending: inboundReplayView.snapshot.pending,
+          deadLetter: inboundReplayView.snapshot.deadLetter,
+          replay: {
+            replayerActive: inboundReplayView.replayerActive,
+            lastReplayAt: inboundReplayView.lastReplayAt,
+            lastReplayError: inboundReplayView.lastReplayError
+          },
+          openclawGateway: inboundReplayView.openclawGateway,
+          openclawHook: inboundReplayView.openclawHook
+        },
+        outbound: {
+          queue: {
+            pendingCount: connectorClient.getQueuedOutboundCount()
+          }
+        },
+        metrics: {
+          heartbeat: clientMetrics.heartbeat,
+          inboundDelivery: clientMetrics.inboundDelivery,
+          outboundQueue: clientMetrics.outboundQueue
+        }
+      });
+      return;
+    }
+    if (requestPath === deadLetterPath) {
+      if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("allow", "GET");
+        writeJson(res, 405, { error: "Method Not Allowed" });
+        return;
+      }
+      const deadLetterItems = await inboundInbox.listDeadLetter();
+      writeJson(res, 200, {
+        status: "ok",
+        count: deadLetterItems.length,
+        items: deadLetterItems
+      });
+      return;
+    }
+    if (requestPath === deadLetterReplayPath) {
+      if (req.method !== "POST") {
+        res.statusCode = 405;
+        res.setHeader("allow", "POST");
+        writeJson(res, 405, { error: "Method Not Allowed" });
+        return;
+      }
+      const body = await readRequestJson(req);
+      const requestIds = isRecord6(body) ? parseRequestIds(body.requestIds) : void 0;
+      const replayResult = await inboundInbox.replayDeadLetter({ requestIds });
+      void replayPendingInboundMessages();
+      writeJson(res, 200, {
+        status: "ok",
+        replayedCount: replayResult.replayedCount
+      });
+      return;
+    }
+    if (requestPath === deadLetterPurgePath) {
+      if (req.method !== "POST") {
+        res.statusCode = 405;
+        res.setHeader("allow", "POST");
+        writeJson(res, 405, { error: "Method Not Allowed" });
+        return;
+      }
+      const body = await readRequestJson(req);
+      const requestIds = isRecord6(body) ? parseRequestIds(body.requestIds) : void 0;
+      const purgeResult = await inboundInbox.purgeDeadLetter({ requestIds });
+      writeJson(res, 200, {
+        status: "ok",
+        purgedCount: purgeResult.purgedCount
       });
       return;
     }
@@ -20722,10 +22247,15 @@ async function startConnectorRuntime(input) {
   });
   const stop = async () => {
     runtimeStopping = true;
+    runtimeShutdownController.abort();
     if (replayIntervalHandle !== void 0) {
       clearInterval(replayIntervalHandle);
       replayIntervalHandle = void 0;
     }
+    if (openclawProbeIntervalHandle !== void 0) {
+      clearInterval(openclawProbeIntervalHandle);
+      openclawProbeIntervalHandle = void 0;
+    }
     connectorClient.disconnect();
     await new Promise((resolve2, reject) => {
       server.close((error48) => {
@@ -20749,12 +22279,17 @@ async function startConnectorRuntime(input) {
       }
     );
   });
+  await syncOpenclawHookToken("batch");
+  await probeOpenclawGateway();
   connectorClient.connect();
   await inboundInbox.pruneDelivered();
   void replayPendingInboundMessages();
   replayIntervalHandle = setInterval(() => {
     void replayPendingInboundMessages();
   }, inboundReplayPolicy.replayIntervalMs);
+  openclawProbeIntervalHandle = setInterval(() => {
+    void probeOpenclawGateway();
+  }, openclawProbePolicy.intervalMs);
   logger11.info("connector.runtime.started", {
     outboundUrl,
     websocketUrl: wsUrl,
@@ -20777,7 +22312,7 @@ var IDENTITY_FILE_NAME2 = "identity.json";
 var AIT_FILE_NAME2 = "ait.jwt";
 var SECRET_KEY_FILE_NAME = "secret.key";
 var REGISTRY_AUTH_FILE_NAME2 = "registry-auth.json";
-var OPENCLAW_RELAY_RUNTIME_FILE_NAME = "openclaw-relay.json";
+var OPENCLAW_RELAY_RUNTIME_FILE_NAME2 = "openclaw-relay.json";
 var OPENCLAW_CONNECTORS_FILE_NAME = "openclaw-connectors.json";
 var SERVICE_LOG_DIR_NAME = "logs";
 var DEFAULT_CONNECTOR_BASE_URL2 = "http://127.0.0.1:19400";
@@ -20989,7 +22524,7 @@ async function readRequiredTrimmedFile(filePath, label, readFileImpl) {
   return trimmed;
 }
 async function readRelayRuntimeConfig(configDir, readFileImpl) {
-  const filePath = join6(configDir, OPENCLAW_RELAY_RUNTIME_FILE_NAME);
+  const filePath = join6(configDir, OPENCLAW_RELAY_RUNTIME_FILE_NAME2);
   let raw;
   try {
     raw = await readFileImpl(filePath, "utf8");
@@ -21995,7 +23530,7 @@ var LEGACY_OPENCLAW_CONFIG_FILE_NAMES = [
   "moltbot.json"
 ];
 var OPENCLAW_AGENT_FILE_NAME = "openclaw-agent-name";
-var OPENCLAW_RELAY_RUNTIME_FILE_NAME2 = "openclaw-relay.json";
+var OPENCLAW_RELAY_RUNTIME_FILE_NAME3 = "openclaw-relay.json";
 var OPENCLAW_CONNECTORS_FILE_NAME2 = "openclaw-connectors.json";
 var SKILL_DIR_NAME = "clawdentity-openclaw-relay";
 var RELAY_MODULE_FILE_NAME = "relay-to-peer.mjs";
@@ -22235,7 +23770,7 @@ function resolveOpenclawAgentNamePath(homeDir) {
   return join7(getConfigDir({ homeDir }), OPENCLAW_AGENT_FILE_NAME);
 }
 function resolveRelayRuntimeConfigPath(homeDir) {
-  return join7(getConfigDir({ homeDir }), OPENCLAW_RELAY_RUNTIME_FILE_NAME2);
+  return join7(getConfigDir({ homeDir }), OPENCLAW_RELAY_RUNTIME_FILE_NAME3);
 }
 function resolveConnectorAssignmentsPath(homeDir) {
   return join7(getConfigDir({ homeDir }), OPENCLAW_CONNECTORS_FILE_NAME2);
@@ -22608,27 +24143,35 @@ function resolveConnectorStatusUrl(connectorBaseUrl) {
   ).toString();
 }
 function parseConnectorStatusPayload(payload) {
-  if (!isRecord9(payload) || typeof payload.websocketConnected !== "boolean") {
+  if (!isRecord9(payload) || !isRecord9(payload.websocket) || typeof payload.websocket.connected !== "boolean") {
     throw createCliError6(
       "CLI_OPENCLAW_SETUP_CONNECTOR_STATUS_INVALID",
       "Connector status response is invalid"
     );
   }
+  const inboundRoot = isRecord9(payload.inbound) ? payload.inbound : void 0;
+  const pending = inboundRoot && isRecord9(inboundRoot.pending) ? inboundRoot.pending : void 0;
+  const deadLetter = inboundRoot && isRecord9(inboundRoot.deadLetter) ? inboundRoot.deadLetter : void 0;
+  const replay = inboundRoot && isRecord9(inboundRoot.replay) ? inboundRoot.replay : void 0;
+  const hook = inboundRoot && isRecord9(inboundRoot.openclawHook) ? inboundRoot.openclawHook : void 0;
   return {
-    websocketConnected: payload.websocketConnected,
-    inboundInbox: isRecord9(payload.inboundInbox) ? {
-      pendingCount: typeof payload.inboundInbox.pendingCount === "number" ? payload.inboundInbox.pendingCount : void 0,
-      pendingBytes: typeof payload.inboundInbox.pendingBytes === "number" ? payload.inboundInbox.pendingBytes : void 0,
-      oldestPendingAt: typeof payload.inboundInbox.oldestPendingAt === "string" ? payload.inboundInbox.oldestPendingAt : void 0,
-      nextAttemptAt: typeof payload.inboundInbox.nextAttemptAt === "string" ? payload.inboundInbox.nextAttemptAt : void 0,
-      lastReplayAt: typeof payload.inboundInbox.lastReplayAt === "string" ? payload.inboundInbox.lastReplayAt : void 0,
-      lastReplayError: typeof payload.inboundInbox.lastReplayError === "string" ? payload.inboundInbox.lastReplayError : void 0,
-      replayerActive: typeof payload.inboundInbox.replayerActive === "boolean" ? payload.inboundInbox.replayerActive : void 0
+    websocketConnected: payload.websocket.connected,
+    inboundInbox: pending || deadLetter || replay ? {
+      pendingCount: pending && typeof pending.pendingCount === "number" ? pending.pendingCount : void 0,
+      pendingBytes: pending && typeof pending.pendingBytes === "number" ? pending.pendingBytes : void 0,
+      oldestPendingAt: pending && typeof pending.oldestPendingAt === "string" ? pending.oldestPendingAt : void 0,
+      nextAttemptAt: pending && typeof pending.nextAttemptAt === "string" ? pending.nextAttemptAt : void 0,
+      lastReplayAt: replay && typeof replay.lastReplayAt === "string" ? replay.lastReplayAt : void 0,
+      lastReplayError: replay && typeof replay.lastReplayError === "string" ? replay.lastReplayError : void 0,
+      replayerActive: replay && typeof replay.replayerActive === "boolean" ? replay.replayerActive : void 0,
+      deadLetterCount: deadLetter && typeof deadLetter.deadLetterCount === "number" ? deadLetter.deadLetterCount : void 0,
+      deadLetterBytes: deadLetter && typeof deadLetter.deadLetterBytes === "number" ? deadLetter.deadLetterBytes : void 0,
+      oldestDeadLetterAt: deadLetter && typeof deadLetter.oldestDeadLetterAt === "string" ? deadLetter.oldestDeadLetterAt : void 0
     } : void 0,
-    openclawHook: isRecord9(payload.openclawHook) ? {
-      url: typeof payload.openclawHook.url === "string" ? payload.openclawHook.url : void 0,
-      lastAttemptAt: typeof payload.openclawHook.lastAttemptAt === "string" ? payload.openclawHook.lastAttemptAt : void 0,
-      lastAttemptStatus: payload.openclawHook.lastAttemptStatus === "ok" || payload.openclawHook.lastAttemptStatus === "failed" ? payload.openclawHook.lastAttemptStatus : void 0
+    openclawHook: hook ? {
+      url: typeof hook.url === "string" ? hook.url : void 0,
+      lastAttemptAt: typeof hook.lastAttemptAt === "string" ? hook.lastAttemptAt : void 0,
+      lastAttemptStatus: hook.lastAttemptStatus === "ok" || hook.lastAttemptStatus === "failed" ? hook.lastAttemptStatus : void 0
     } : void 0
   };
 }
@@ -22679,12 +24222,12 @@ async function fetchConnectorHealthStatus(input) {
   }
 }
 async function waitForConnectorConnected(input) {
-  const deadline = Date.now() + input.waitTimeoutSeconds * 1e3;
+  const deadline = nowUtcMs() + input.waitTimeoutSeconds * 1e3;
   let latest = await fetchConnectorHealthStatus({
     connectorBaseUrl: input.connectorBaseUrl,
     fetchImpl: input.fetchImpl
   });
-  while (!latest.connected && Date.now() < deadline) {
+  while (!latest.connected && nowUtcMs() < deadline) {
     await new Promise((resolve2) => {
       setTimeout(resolve2, 1e3);
     });
@@ -22718,7 +24261,7 @@ async function monitorConnectorStabilityWindow(input) {
       fetchImpl: input.fetchImpl
     });
   }
-  const deadline = Date.now() + input.durationSeconds * 1e3;
+  const deadline = nowUtcMs() + input.durationSeconds * 1e3;
   let latest = await fetchConnectorHealthStatus({
     connectorBaseUrl: input.connectorBaseUrl,
     fetchImpl: input.fetchImpl
@@ -22726,7 +24269,7 @@ async function monitorConnectorStabilityWindow(input) {
   if (!latest.connected) {
     return latest;
   }
-  while (Date.now() < deadline) {
+  while (nowUtcMs() < deadline) {
     await sleepMilliseconds(input.pollIntervalMs);
     latest = await fetchConnectorHealthStatus({
       connectorBaseUrl: input.connectorBaseUrl,
@@ -23230,10 +24773,80 @@ function printRelayTestResult(result) {
     writeStdoutLine(`Fix: ${result.remediationHint}`);
   }
 }
+function printRelayWebsocketTestResult(result) {
+  writeStdoutLine(`Relay websocket test status: ${result.status}`);
+  writeStdoutLine(`Peer alias: ${result.peerAlias}`);
+  if (typeof result.connectorBaseUrl === "string") {
+    writeStdoutLine(`Connector base URL: ${result.connectorBaseUrl}`);
+  }
+  if (typeof result.connectorStatusUrl === "string") {
+    writeStdoutLine(`Connector status URL: ${result.connectorStatusUrl}`);
+  }
+  writeStdoutLine(`Message: ${result.message}`);
+  if (result.remediationHint) {
+    writeStdoutLine(`Fix: ${result.remediationHint}`);
+  }
+}
 function toSendToPeerEndpoint(openclawBaseUrl) {
   const normalizedBase = openclawBaseUrl.endsWith("/") ? openclawBaseUrl : `${openclawBaseUrl}/`;
   return new URL(OPENCLAW_SEND_TO_PEER_HOOK_PATH, normalizedBase).toString();
 }
+async function resolveSelectedAgentName(input) {
+  const selectedAgentPath = resolveOpenclawAgentNamePath(input.homeDir);
+  let selectedAgentRaw;
+  try {
+    selectedAgentRaw = await readFile6(selectedAgentPath, "utf8");
+  } catch (error48) {
+    if (getErrorCode2(error48) === "ENOENT") {
+      throw createCliError6(
+        "CLI_OPENCLAW_SELECTED_AGENT_MISSING",
+        "Selected agent marker is missing",
+        { selectedAgentPath }
+      );
+    }
+    throw createCliError6(
+      "CLI_OPENCLAW_SELECTED_AGENT_INVALID",
+      "Selected agent marker is invalid",
+      { selectedAgentPath }
+    );
+  }
+  try {
+    return {
+      agentName: assertValidAgentName(selectedAgentRaw.trim()),
+      selectedAgentPath
+    };
+  } catch {
+    throw createCliError6(
+      "CLI_OPENCLAW_SELECTED_AGENT_INVALID",
+      "Selected agent marker is invalid",
+      { selectedAgentPath }
+    );
+  }
+}
+async function resolveConnectorAssignment(input) {
+  const connectorAssignmentsPath = resolveConnectorAssignmentsPath(
+    input.homeDir
+  );
+  const connectorAssignments = await loadConnectorAssignments(
+    connectorAssignmentsPath
+  );
+  const assignment = connectorAssignments.agents[input.agentName];
+  if (assignment === void 0) {
+    throw createCliError6(
+      "CLI_OPENCLAW_CONNECTOR_ASSIGNMENT_MISSING",
+      "Connector assignment is missing for selected agent",
+      {
+        connectorAssignmentsPath,
+        agentName: input.agentName
+      }
+    );
+  }
+  return {
+    connectorAssignmentsPath,
+    connectorBaseUrl: assignment.connectorBaseUrl,
+    connectorStatusUrl: resolveConnectorStatusUrl(assignment.connectorBaseUrl)
+  };
+}
 async function runOpenclawDoctor(options = {}) {
   const homeDir = resolveHomeDir2(options.homeDir);
   const openclawDir = resolveOpenclawDir(options.openclawDir, homeDir);
@@ -24245,6 +25858,111 @@ async function runOpenclawRelayTest(options) {
     preflight
   };
 }
+async function runOpenclawRelayWebsocketTest(options) {
+  const homeDir = resolveHomeDir2(options.homeDir);
+  const openclawDir = resolveOpenclawDir(options.openclawDir, homeDir);
+  const checkedAt = nowIso();
+  let peerAlias;
+  try {
+    peerAlias = await resolveRelayProbePeerAlias({
+      homeDir,
+      peerAliasOption: options.peer
+    });
+  } catch (error48) {
+    const appError = error48 instanceof AppError ? error48 : void 0;
+    return {
+      status: "failure",
+      checkedAt,
+      peerAlias: "unresolved",
+      message: appError?.message ?? "Unable to resolve relay peer alias",
+      remediationHint: OPENCLAW_PAIRING_COMMAND_HINT,
+      details: appError?.details
+    };
+  }
+  const preflight = await runOpenclawDoctor({
+    homeDir,
+    openclawDir,
+    peerAlias,
+    resolveConfigImpl: options.resolveConfigImpl,
+    includeConnectorRuntimeCheck: false
+  });
+  if (preflight.status === "unhealthy") {
+    const firstFailure = preflight.checks.find(
+      (check2) => check2.status === "fail"
+    );
+    return {
+      status: "failure",
+      checkedAt,
+      peerAlias,
+      message: firstFailure === void 0 ? "Preflight checks failed" : `Preflight failed: ${firstFailure.label}`,
+      remediationHint: firstFailure?.remediationHint,
+      preflight
+    };
+  }
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    return {
+      status: "failure",
+      checkedAt,
+      peerAlias,
+      message: "fetch implementation is unavailable",
+      remediationHint: "Run relay websocket test in a Node runtime with fetch support",
+      preflight
+    };
+  }
+  let connectorBaseUrl;
+  let connectorStatusUrl;
+  try {
+    const selectedAgent = await resolveSelectedAgentName({ homeDir });
+    const connectorAssignment = await resolveConnectorAssignment({
+      homeDir,
+      agentName: selectedAgent.agentName
+    });
+    connectorBaseUrl = connectorAssignment.connectorBaseUrl;
+    connectorStatusUrl = connectorAssignment.connectorStatusUrl;
+  } catch (error48) {
+    const appError = error48 instanceof AppError ? error48 : void 0;
+    return {
+      status: "failure",
+      checkedAt,
+      peerAlias,
+      connectorBaseUrl,
+      connectorStatusUrl,
+      message: appError?.message ?? "Unable to resolve connector assignment for websocket test",
+      remediationHint: OPENCLAW_SETUP_COMMAND_HINT,
+      details: appError?.details,
+      preflight
+    };
+  }
+  const connectorStatus = await fetchConnectorHealthStatus({
+    connectorBaseUrl,
+    fetchImpl
+  });
+  if (!connectorStatus.connected) {
+    return {
+      status: "failure",
+      checkedAt,
+      peerAlias,
+      connectorBaseUrl,
+      connectorStatusUrl: connectorStatus.statusUrl,
+      message: "Connector websocket is not connected",
+      remediationHint: OPENCLAW_SETUP_COMMAND_HINT,
+      details: connectorStatus.reason === void 0 ? void 0 : {
+        reason: connectorStatus.reason
+      },
+      preflight
+    };
+  }
+  return {
+    status: "success",
+    checkedAt,
+    peerAlias,
+    connectorBaseUrl,
+    connectorStatusUrl: connectorStatus.statusUrl,
+    message: "Connector websocket is connected for paired relay",
+    preflight
+  };
+}
 async function setupOpenclawRelay(agentName, options) {
   const normalizedAgentName = assertValidAgentName(agentName);
   const homeDir = resolveHomeDir2(options.homeDir);
@@ -24629,6 +26347,38 @@ var createOpenclawCommand = () => {
       }
     )
   );
+  relayCommand.command("ws-test").description(
+    "Validate connector websocket connectivity for a paired relay peer"
+  ).option("--peer <alias>", "Peer alias in local peers map").option(
+    "--openclaw-dir <path>",
+    "OpenClaw state directory (default ~/.openclaw)"
+  ).option("--json", "Print machine-readable JSON output").action(
+    withErrorHandling(
+      "openclaw relay ws-test",
+      async (options) => {
+        const result = await runOpenclawRelayWebsocketTest(options);
+        if (options.json) {
+          writeStdoutLine(JSON.stringify(result, null, 2));
+        } else {
+          printRelayWebsocketTestResult(result);
+          if (result.preflight !== void 0 && result.preflight.status === "unhealthy") {
+            writeStdoutLine("Preflight details:");
+            for (const check2 of result.preflight.checks) {
+              if (check2.status === "fail") {
+                writeStdoutLine(formatDoctorCheckLine(check2));
+                if (check2.remediationHint) {
+                  writeStdoutLine(`Fix: ${check2.remediationHint}`);
+                }
+              }
+            }
+          }
+        }
+        if (result.status === "failure") {
+          process.exitCode = 1;
+        }
+      }
+    )
+  );
   return openclawCommand;
 };
 
@@ -24639,7 +26389,7 @@ import {
   mkdir as mkdir7,
   readdir as readdir2,
   readFile as readFile7,
-  unlink as unlink2,
+  unlink as unlink3,
   writeFile as writeFile7
 } from "fs/promises";
 import { dirname as dirname6, join as join8, resolve } from "path";
@@ -24653,7 +26403,7 @@ var AIT_FILE_NAME4 = "ait.jwt";
 var SECRET_KEY_FILE_NAME3 = "secret.key";
 var PAIRING_QR_DIR_NAME = "pairing";
 var PEERS_FILE_NAME2 = "peers.json";
-var OPENCLAW_RELAY_RUNTIME_FILE_NAME3 = "openclaw-relay.json";
+var OPENCLAW_RELAY_RUNTIME_FILE_NAME4 = "openclaw-relay.json";
 var PAIR_START_PATH = "/pair/start";
 var PAIR_CONFIRM_PATH = "/pair/confirm";
 var PAIR_STATUS_PATH = "/pair/status";
@@ -24669,6 +26419,7 @@ var MAX_PROFILE_NAME_LENGTH = 64;
 var isRecord10 = (value) => {
   return typeof value === "object" && value !== null;
 };
+var nowUnixSeconds = () => Math.floor(nowUtcMs() / 1e3);
 function createCliError7(code, message2) {
   return new AppError({
     code,
@@ -24720,10 +26471,24 @@ function parsePeerProfile(payload) {
       "Pair profile must be an object"
     );
   }
-  return {
+  const profile = {
     agentName: parseProfileName(payload.agentName, "agentName"),
     humanName: parseProfileName(payload.humanName, "humanName")
   };
+  const proxyOrigin = parseNonEmptyString10(payload.proxyOrigin);
+  if (proxyOrigin.length > 0) {
+    let parsedProxyOrigin;
+    try {
+      parsedProxyOrigin = new URL(parseProxyUrl2(proxyOrigin)).origin;
+    } catch {
+      throw createCliError7(
+        "CLI_PAIR_PROFILE_INVALID",
+        "proxyOrigin is invalid for pairing"
+      );
+    }
+    profile.proxyOrigin = parsedProxyOrigin;
+  }
+  return profile;
 }
 function parsePairingTicket(value) {
   let ticket = parseNonEmptyString10(value);
@@ -24992,7 +26757,7 @@ async function savePeersConfig2(input) {
   await input.chmodImpl(peersPath, FILE_MODE4);
 }
 function resolveRelayRuntimeConfigPath2(getConfigDirImpl) {
-  return join8(getConfigDirImpl(), OPENCLAW_RELAY_RUNTIME_FILE_NAME3);
+  return join8(getConfigDirImpl(), OPENCLAW_RELAY_RUNTIME_FILE_NAME4);
 }
 async function loadRelayTransformPeersPath(input) {
   const relayRuntimeConfigPath = resolveRelayRuntimeConfigPath2(
@@ -25107,10 +26872,59 @@ function resolveLocalPairProfile(input) {
       "Human name is missing. Run `clawdentity invite redeem <clw_inv_...> --display-name <name>` or `clawdentity config set humanName <name>`."
     );
   }
-  return {
+  const profile = {
     agentName: parseProfileName(input.agentName, "agentName"),
     humanName: parseProfileName(humanName, "humanName")
   };
+  const proxyUrl = parseNonEmptyString10(input.proxyUrl);
+  if (proxyUrl.length > 0) {
+    profile.proxyOrigin = new URL(parseProxyUrl2(proxyUrl)).origin;
+  }
+  return profile;
+}
+function normalizeProxyOrigin(candidate) {
+  return new URL(parseProxyUrl2(candidate)).origin;
+}
+function resolvePeerProxyUrl(input) {
+  const configuredPeerOrigin = parseNonEmptyString10(input.peerProxyOrigin);
+  const profilePeerOrigin = parseNonEmptyString10(input.peerProfile.proxyOrigin);
+  const fallbackPeerOrigin = parsePairingTicketIssuerOrigin(input.ticket);
+  const peerOrigin = configuredPeerOrigin.length > 0 ? configuredPeerOrigin : profilePeerOrigin.length > 0 ? profilePeerOrigin : fallbackPeerOrigin;
+  return new URL(
+    "/hooks/agent",
+    `${normalizeProxyOrigin(peerOrigin)}/`
+  ).toString();
+}
+function toIssuerProxyUrl(ticket) {
+  return parseProxyUrl2(parsePairingTicketIssuerOrigin(ticket));
+}
+function toIssuerProxyRequestUrl(ticket, path) {
+  return toProxyRequestUrl(toIssuerProxyUrl(ticket), path);
+}
+function toPeerProxyOriginFromStatus(input) {
+  if (input.callerAgentDid === input.initiatorAgentDid) {
+    return input.responderProfile?.proxyOrigin;
+  }
+  if (input.callerAgentDid === input.responderAgentDid) {
+    return input.initiatorProfile.proxyOrigin;
+  }
+  return void 0;
+}
+function toPeerProxyOriginFromConfirm(input) {
+  const initiatorOrigin = parseNonEmptyString10(
+    input.initiatorProfile.proxyOrigin
+  );
+  if (initiatorOrigin.length > 0) {
+    return initiatorOrigin;
+  }
+  return parsePairingTicketIssuerOrigin(input.ticket);
+}
+function toResponderProfile(input) {
+  return resolveLocalPairProfile({
+    config: input.config,
+    agentName: input.agentName,
+    proxyUrl: input.localProxyUrl
+  });
 }
 function parseProxyUrl2(candidate) {
   try {
@@ -25507,7 +27321,7 @@ function decodeTicketFromPng(imageBytes) {
 async function persistPairingQr(input) {
   const mkdirImpl = input.dependencies.mkdirImpl ?? mkdir7;
   const readdirImpl = input.dependencies.readdirImpl ?? readdir2;
-  const unlinkImpl = input.dependencies.unlinkImpl ?? unlink2;
+  const unlinkImpl = input.dependencies.unlinkImpl ?? unlink3;
   const writeFileImpl = input.dependencies.writeFileImpl ?? writeFile7;
   const getConfigDirImpl = input.dependencies.getConfigDirImpl ?? getConfigDir;
   const qrEncodeImpl = input.dependencies.qrEncodeImpl ?? encodeTicketQrPng;
@@ -25585,8 +27399,11 @@ async function persistPairedPeer(input) {
   const mkdirImpl = input.dependencies.mkdirImpl ?? mkdir7;
   const writeFileImpl = input.dependencies.writeFileImpl ?? writeFile7;
   const chmodImpl = input.dependencies.chmodImpl ?? chmod4;
-  const issuerOrigin = parsePairingTicketIssuerOrigin(input.ticket);
-  const peerProxyUrl = new URL("/hooks/agent", `${issuerOrigin}/`).toString();
+  const peerProxyUrl = resolvePeerProxyUrl({
+    ticket: input.ticket,
+    peerProfile: input.peerProfile,
+    peerProxyOrigin: input.peerProxyOrigin
+  });
   const peersConfig = await loadPeersConfig2({
     getConfigDirImpl,
     readFileImpl
@@ -25621,7 +27438,7 @@ async function persistPairedPeer(input) {
 async function startPairing(agentName, options, dependencies = {}) {
   const fetchImpl = dependencies.fetchImpl ?? fetch;
   const resolveConfigImpl = dependencies.resolveConfigImpl ?? resolveConfig;
-  const nowSecondsImpl = dependencies.nowSecondsImpl ?? (() => Math.floor(Date.now() / 1e3));
+  const nowSecondsImpl = dependencies.nowSecondsImpl ?? nowUnixSeconds;
   const nonceFactoryImpl = dependencies.nonceFactoryImpl ?? (() => randomBytes4(NONCE_SIZE2).toString("base64url"));
   const ttlSeconds = parseTtlSeconds(options.ttlSeconds);
   const config2 = await resolveConfigImpl();
@@ -25632,7 +27449,8 @@ async function startPairing(agentName, options, dependencies = {}) {
   const normalizedAgentName = assertValidAgentName(agentName);
   const initiatorProfile = resolveLocalPairProfile({
     config: config2,
-    agentName: normalizedAgentName
+    agentName: normalizedAgentName,
+    proxyUrl
   });
   const { ait, secretKey } = await readAgentProofMaterial(
     normalizedAgentName,
@@ -25693,21 +27511,22 @@ async function startPairing(agentName, options, dependencies = {}) {
 async function confirmPairing(agentName, options, dependencies = {}) {
   const fetchImpl = dependencies.fetchImpl ?? fetch;
   const resolveConfigImpl = dependencies.resolveConfigImpl ?? resolveConfig;
-  const nowSecondsImpl = dependencies.nowSecondsImpl ?? (() => Math.floor(Date.now() / 1e3));
+  const nowSecondsImpl = dependencies.nowSecondsImpl ?? nowUnixSeconds;
   const nonceFactoryImpl = dependencies.nonceFactoryImpl ?? (() => randomBytes4(NONCE_SIZE2).toString("base64url"));
   const readFileImpl = dependencies.readFileImpl ?? readFile7;
   const qrDecodeImpl = dependencies.qrDecodeImpl ?? decodeTicketFromPng;
   const config2 = await resolveConfigImpl();
   const normalizedAgentName = assertValidAgentName(agentName);
-  const responderProfile = resolveLocalPairProfile({
+  const localProxyUrl = await resolveProxyUrl({
     config: config2,
-    agentName: normalizedAgentName
+    fetchImpl
   });
-  const ticketSource = resolveConfirmTicketSource(options);
-  const proxyUrl = await resolveProxyUrl({
+  const responderProfile = toResponderProfile({
     config: config2,
-    fetchImpl
+    agentName: normalizedAgentName,
+    localProxyUrl
   });
+  const ticketSource = resolveConfirmTicketSource(options);
   let ticket = ticketSource.ticket;
   if (ticketSource.source === "qr-file") {
     if (!ticketSource.qrFilePath) {
@@ -25732,16 +27551,12 @@ async function confirmPairing(agentName, options, dependencies = {}) {
     ticket = parsePairingTicket(qrDecodeImpl(new Uint8Array(imageBytes)));
   }
   ticket = parsePairingTicket(ticket);
-  assertTicketIssuerMatchesProxy({
-    ticket,
-    proxyUrl,
-    context: "confirm"
-  });
+  const proxyUrl = toIssuerProxyUrl(ticket);
   const { ait, secretKey } = await readAgentProofMaterial(
     normalizedAgentName,
     dependencies
   );
-  const requestUrl = toProxyRequestUrl(proxyUrl, PAIR_CONFIRM_PATH);
+  const requestUrl = toIssuerProxyRequestUrl(ticket, PAIR_CONFIRM_PATH);
   const requestBody = JSON.stringify({
     ticket,
     responderProfile
@@ -25778,14 +27593,19 @@ async function confirmPairing(agentName, options, dependencies = {}) {
     );
   }
   const parsed = parsePairConfirmResponse(responseBody);
+  const peerProxyOrigin = toPeerProxyOriginFromConfirm({
+    ticket,
+    initiatorProfile: parsed.initiatorProfile
+  });
   const peerAlias = await persistPairedPeer({
     ticket,
     peerDid: parsed.initiatorAgentDid,
     peerProfile: parsed.initiatorProfile,
+    peerProxyOrigin,
     dependencies
   });
   if (ticketSource.source === "qr-file" && ticketSource.qrFilePath) {
-    const unlinkImpl = dependencies.unlinkImpl ?? unlink2;
+    const unlinkImpl = dependencies.unlinkImpl ?? unlink3;
     await unlinkImpl(ticketSource.qrFilePath).catch((error48) => {
       const nodeError = error48;
       if (nodeError.code === "ENOENT") {
@@ -25806,7 +27626,7 @@ async function confirmPairing(agentName, options, dependencies = {}) {
 async function getPairingStatusOnce(agentName, options, dependencies = {}) {
   const fetchImpl = dependencies.fetchImpl ?? fetch;
   const resolveConfigImpl = dependencies.resolveConfigImpl ?? resolveConfig;
-  const nowSecondsImpl = dependencies.nowSecondsImpl ?? (() => Math.floor(Date.now() / 1e3));
+  const nowSecondsImpl = dependencies.nowSecondsImpl ?? nowUnixSeconds;
   const nonceFactoryImpl = dependencies.nonceFactoryImpl ?? (() => randomBytes4(NONCE_SIZE2).toString("base64url"));
   const config2 = await resolveConfigImpl();
   const proxyUrl = await resolveProxyUrl({
@@ -25885,6 +27705,13 @@ async function getPairingStatusOnce(agentName, options, dependencies = {}) {
       ticket,
       peerDid,
       peerProfile,
+      peerProxyOrigin: toPeerProxyOriginFromStatus({
+        callerAgentDid,
+        initiatorAgentDid: parsed.initiatorAgentDid,
+        responderAgentDid,
+        initiatorProfile: parsed.initiatorProfile,
+        responderProfile: parsed.responderProfile
+      }),
       dependencies
     });
   }
@@ -25895,7 +27722,7 @@ async function getPairingStatusOnce(agentName, options, dependencies = {}) {
   };
 }
 async function waitForPairingStatus(input) {
-  const nowSecondsImpl = input.dependencies.nowSecondsImpl ?? (() => Math.floor(Date.now() / 1e3));
+  const nowSecondsImpl = input.dependencies.nowSecondsImpl ?? nowUnixSeconds;
   const sleepImpl = input.dependencies.sleepImpl ?? (async (ms) => {
     await new Promise((resolve2) => {
       setTimeout(resolve2, ms);
@@ -26640,7 +28467,7 @@ var fetchRegistryKeys = async (registryUrl) => {
   return parseSigningKeys(await parseResponseJson(response));
 };
 var loadRegistryKeys = async (registryUrl) => {
-  const now = Date.now();
+  const now = nowUtcMs();
   const rawCache = await readCacheFile(REGISTRY_KEYS_CACHE_FILE);
   const cache2 = typeof rawCache === "string" ? parseRegistryKeysCache(rawCache) : void 0;
   const isFresh = isFreshCache({
@@ -26699,7 +28526,7 @@ var fetchCrlClaims = async (input) => {
   }
 };
 var loadCrlClaims = async (input) => {
-  const now = Date.now();
+  const now = nowUtcMs();
   const rawCache = await readCacheFile(CRL_CLAIMS_CACHE_FILE);
   const cache2 = typeof rawCache === "string" ? parseCrlCache(rawCache) : void 0;
   const isFresh = isFreshCache({