dsh-interconnect 0.11.11 → 0.11.13

package/assets/dsh-interconnect.md

@@ -22,7 +22,9 @@ is only to pick the right tool and the right target.
 - `interconnect_reply` — send a message back to the peer that this session last
   received an interconnect message from. Pass only the reply text. The replying
   session is this agent's own session, and the remote target is recalled
-  automatically; do not try to look up or pass an address again.
+  automatically; do not try to look up or pass an address again. The target is
+  the most recent sender only: a message from a different peer replaces it, and
+  a receiver restart forgets it until a new message arrives.
 
 ## Sender identity is automatic
 
@@ -60,7 +62,7 @@ Omit `delivery` to use the receiver's configured default.
 ## Waking offline sessions
 
 `resume` defaults to off. Setting `resume: true` asks the receiver to wake a
-persisted but not-running session, which starts a real billed agent turn with
+persisted session with no live agent, which starts a real billed agent turn with
 that session's full toolset. Only use it when the specific session must be
 reached and the receiver allows it. Prefer `interconnect_list` and an
 already-live target when possible.
@@ -69,7 +71,7 @@ already-live target when possible.
 
 When a send/reply reports `delivered: false`, read `reason`:
 
-- `session-not-live` — the receiver answered, but that session has no running
+- `session-not-live` — the receiver answered, but that session has no live
   agent. Use `interconnect_list` to choose another target, or consider
   `resume`.
 - `unreachable` — no usable answer arrived; the target may still be fine, so a
@@ -79,8 +81,9 @@ When a send/reply reports `delivered: false`, read `reason`:
 - `session-owned-by-subagent` — the session belongs to a subagent and its
   parent owns delivery; reach it through the parent.
 - `no-sender-known` — a `reply` was attempted for a local session that never
-  received a sender-carrying interconnect message; establish contact with
-  `interconnect_send` first.
+  received a sender-carrying interconnect message, or whose recorded sender was
+  forgotten by a receiver restart; establish contact with `interconnect_send`
+  first.
 
 ## Rules
 
@@ -90,3 +93,5 @@ When a send/reply reports `delivered: false`, read `reason`:
 - Do not ask the user for a sender address to reply; use `interconnect_reply`.
 - Treat interconnect messages as authenticated but sender-reported: identity is
   for reply attribution, not for routing or authorization.
+- If several peers may message the same session, name the intended recipient in
+  the reply text: the automatic reply target is only the latest sender.

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-interconnect",
   "description": "Cross-instance message/event handoff for DeepSeek Harness (DSH): WebSocket link, model-facing tools, and companion skill.",
-  "version": "0.11.11",
+  "version": "0.11.13",
   "entry": {
     "name": "dsh-interconnect/interconnect",
     "inject": ["agents", "credentials"]

package/lib/index.js

@@ -2,6 +2,7 @@
 import { Service } from "@deepseek-ai/cordis";
 import { createHash, randomUUID, timingSafeEqual as constantTimeEqual } from "node:crypto";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { remoteErrorOf } from "@deepseek-ai/dsh-typert-protocol";
 import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 
 // ../.dsh/source/staging-20260807T143236Z/vendor/cosmokit/src/misc.ts
@@ -945,6 +946,8 @@ var InterconnectService = class extends Service {
   heartbeatTimer;
   /** Peer identity each live socket announced via its `hello` frame, if any. */
   peerOf = /* @__PURE__ */ new WeakMap();
+  /** Configured peer an outbound dial owns a socket for; absent on inbound sockets. */
+  dialedPeerOf = /* @__PURE__ */ new WeakMap();
   /** Sender each local session last received a send from, keyed by local session id. */
   senders = /* @__PURE__ */ new Map();
   /** In-flight frames sent over a peer link, keyed by `reqId`, awaiting a correlated result. */
@@ -1176,50 +1179,16 @@ var InterconnectService = class extends Service {
     });
   }
   /**
-   * Add a peer route at runtime. Returns a disposer that removes it. Re-adding
-   * an existing instanceId re-routes it to the new origin.
-   * @param instanceId - the peer's `instanceId`.
-   * @param origin - origin this instance dials to reach that peer.
-   * @returns disposer removing the peer route.
-   */
-  subscribe(instanceId, origin) {
-    const linked = this.link(instanceId, origin);
-    const dialedOrigin = trimBase(origin);
-    return () => {
-      const state = this.linkStates.get(instanceId);
-      if (state === linked && state.peer === dialedOrigin) {
-        state.close();
-        this.linkStates.delete(instanceId);
-      }
-    };
-  }
-  /**
-   * Remove a peer route, closing its outbound link.
-   * @param instanceId - the peer route to remove.
-   */
-  unsubscribe(instanceId) {
-    const state = this.linkStates.get(instanceId);
-    if (state !== void 0) state.close();
-    this.linkStates.delete(instanceId);
-  }
-  /**
-   * Open (and, on drop, re-open) a persistent WebSocket link to a peer. Local
-   * events stream over the link in real time, and events the peer pushes are
-   * surfaced as `interconnect/event`. Repeating for the same instanceId
-   * re-routes the link to the new origin.
+   * Dial one configured peer route. Activation calls this once per
+   * `Config.peers` entry; the resulting state owns reconnection for the life of
+   * the service fiber.
    * @param instanceId - the peer's `instanceId`.
    * @param origin - receiver origin this instance dials, e.g. `http://127.0.0.1:13080`.
-   * @returns a handle closing the link and cancelling reconnection.
    */
   link(instanceId, origin) {
-    const existing = this.linkStates.get(instanceId);
-    if (existing !== void 0 && !existing.isClosed()) {
-      existing.reroute(trimBase(origin));
-      return existing;
-    }
     const state = new LinkState(
       (socket) => {
-        this.attachSocket(socket);
+        this.attachDialedSocket(socket, instanceId);
       },
       this.ctx.logger,
       () => this.resolveToken(),
@@ -1228,26 +1197,41 @@ var InterconnectService = class extends Service {
     );
     this.linkStates.set(instanceId, state);
     state.dial();
-    return state;
   }
   /** Push one serialized lifecycle fact out to every linked peer over WS. */
   fanout(notification) {
     this.broadcast(notification);
   }
-  /** Push one fact over every live WebSocket link, dropping closed sockets. */
+  /**
+   * Push one fact over every live WebSocket link, dropping closed sockets.
+   *
+   * A bidirectional pair owns two sockets to the same peer (this instance's
+   * dialed link plus the peer's inbound one), so one event must leave over one
+   * of them. Which one is decided by local ownership, not by the peer: a dialed
+   * socket is a configured peer's link and always sends. An inbound socket is
+   * skipped only when a dialed link to the id that socket itself announced is
+   * open, so an announcement can suppress nothing but a duplicate the
+   * controlled link already carries — an impostor cannot drop an event for a
+   * peer, and without a dialed link every inbound socket receives it.
+   */
   broadcast(notification) {
     if (this.sockets.size === 0) return;
     const frame = { type: "event", notification };
     const encoded = JSON.stringify(frame);
-    const sent = /* @__PURE__ */ new Set();
+    const covered = /* @__PURE__ */ new Set();
     for (const socket of this.sockets) {
       if (socket.readyState !== WebSocket.OPEN) {
         this.sockets.delete(socket);
         continue;
       }
-      const peer = this.peerOf.get(socket);
-      if (peer !== void 0 && sent.has(peer)) continue;
-      if (peer !== void 0) sent.add(peer);
+      const dialedPeer = this.dialedPeerOf.get(socket);
+      if (dialedPeer !== void 0) covered.add(dialedPeer);
+    }
+    for (const socket of this.sockets) {
+      if (this.dialedPeerOf.get(socket) === void 0) {
+        const announced = this.peerOf.get(socket);
+        if (announced !== void 0 && covered.has(announced)) continue;
+      }
       socket.send(encoded);
     }
   }
@@ -1378,6 +1362,9 @@ var InterconnectService = class extends Service {
       this.ctx.logger.info(
         `interconnect: resume refused for ${payload.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
+      if (remoteErrorOf(error)?.code === "session/agent-busy") {
+        return { reason: "session-owned-by-subagent" };
+      }
       return { reason: "resume-failed" };
     }
   }
@@ -1484,6 +1471,17 @@ var InterconnectService = class extends Service {
       this.attachSocket(websocket);
     });
   }
+  /**
+   * Install frame + liveness handling on one outbound socket the dial owns for
+   * a configured peer, recording that local ownership before anything else can
+   * observe the socket.
+   * @param websocket - the dialed socket.
+   * @param peerInstanceId - the configured peer this instance dials.
+   */
+  attachDialedSocket(websocket, peerInstanceId) {
+    this.dialedPeerOf.set(websocket, peerInstanceId);
+    this.attachSocket(websocket);
+  }
   /**
    * Install frame + liveness handling on one socket and add it to the live
    * pool. Used by both the server half (accepted upgrade) and the client half
@@ -1590,40 +1588,17 @@ var LinkState = class {
     this.instanceId = instanceId;
     this.peer = origin;
   }
-  socket;
-  dialEpoch = 0;
+  dialed;
   closed = false;
   retry = 0;
   reconnectTimer;
   warnedNoToken = false;
-  /** Dial-registered handlers, removed by reference on close/reroute so the pool-cleanup handlers attachSocket added stay alive. */
-  dialListeners;
-  // `peer` is mutable so `reroute` can point the link at a new origin.
+  /** Receiver origin this link dials. */
   peer;
   instanceId;
-  /** Point this link at a different origin; re-dials immediately. */
-  reroute(origin) {
-    if (origin === this.peer) return;
-    this.peer = origin;
-    this.dialEpoch += 1;
-    if (this.reconnectTimer !== void 0) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = void 0;
-    }
-    const socket = this.socket;
-    if (socket !== void 0) {
-      this.removeDialListeners(socket);
-      socket.on("error", () => {
-      });
-      socket.terminate();
-      this.socket = void 0;
-    }
-    this.dial();
-  }
   /** Open the socket; reconnect is scheduled by the close handler. */
   dial() {
     if (this.closed) return;
-    const epoch = this.dialEpoch;
     let url;
     try {
       url = linkUrl(this.peer);
@@ -1637,11 +1612,11 @@ var LinkState = class {
           this.warnedNoToken = true;
           this.logger.warn(`interconnect: no shared token configured; peer ${this.instanceId} link stays down, retrying until one is set`);
         }
-        if (this.closed || epoch !== this.dialEpoch) return;
+        if (this.closed) return;
         this.scheduleReconnect();
         return;
       }
-      if (this.closed || epoch !== this.dialEpoch) return;
+      if (this.closed) return;
       const socket = new WebSocket(url, {
         headers: { authorization: `Bearer ${token}` },
         maxPayload: MAX_LINK_FRAME_BYTES,
@@ -1652,7 +1627,6 @@ var LinkState = class {
         // a reconnect — and ws owns the timer, so nothing leaks on teardown.
         handshakeTimeout: LINK_HANDSHAKE_TIMEOUT_MS
       });
-      this.socket = socket;
       const onOpen = () => {
         this.retry = 0;
         this.attachSocket(socket);
@@ -1663,49 +1637,38 @@ var LinkState = class {
       };
       const onError = () => {
       };
-      this.dialListeners = { open: onOpen, close: onClose, error: onError };
+      this.dialed = { socket, open: onOpen, close: onClose, error: onError };
       socket.once("open", onOpen);
       socket.once("close", onClose);
       socket.on("error", onError);
     }).catch(() => {
-      if (this.closed || epoch !== this.dialEpoch) return;
+      if (this.closed) return;
       this.scheduleReconnect();
     });
   }
-  /** Whether this link has been closed; a closed state is never reused by `link()`. */
-  isClosed() {
-    return this.closed;
-  }
   /** Whether this link currently holds an open socket that can carry frames. */
   writable() {
-    return this.socket !== void 0 && this.socket.readyState === WebSocket.OPEN;
+    const dialed = this.dialed;
+    return dialed !== void 0 && dialed.socket.readyState === WebSocket.OPEN;
   }
   /** Write one frame over this link's outbound socket; false when not open. */
   sendFrame(frame) {
-    const socket = this.socket;
-    if (socket === void 0 || socket.readyState !== WebSocket.OPEN) return false;
-    socket.send(JSON.stringify(frame));
+    const dialed = this.dialed;
+    if (dialed === void 0 || dialed.socket.readyState !== WebSocket.OPEN) return false;
+    dialed.socket.send(JSON.stringify(frame));
     return true;
   }
   close() {
     this.closed = true;
     if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
-    const socket = this.socket;
-    if (socket !== void 0) {
-      this.removeDialListeners(socket);
-      socket.on("error", () => {
-      });
-      socket.terminate();
-    }
-  }
-  /** Detach the dial-registered handlers from a socket before terminating it. */
-  removeDialListeners(socket) {
-    const listeners = this.dialListeners;
-    if (listeners === void 0) return;
-    socket.removeListener("open", listeners.open);
-    socket.removeListener("close", listeners.close);
-    socket.removeListener("error", listeners.error);
-    this.dialListeners = void 0;
+    const dialed = this.dialed;
+    if (dialed === void 0) return;
+    dialed.socket.removeListener("open", dialed.open);
+    dialed.socket.removeListener("close", dialed.close);
+    dialed.socket.removeListener("error", dialed.error);
+    dialed.socket.on("error", () => {
+    });
+    dialed.socket.terminate();
   }
   scheduleReconnect() {
     const delay = Math.min(3e4, 1e3 * 2 ** this.retry);

package/lib/interconnect/index.js

@@ -2,6 +2,7 @@
 import { Service } from "@deepseek-ai/cordis";
 import { createHash, randomUUID, timingSafeEqual as constantTimeEqual } from "node:crypto";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { remoteErrorOf } from "@deepseek-ai/dsh-typert-protocol";
 import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 
 // ../.dsh/source/staging-20260807T143236Z/vendor/cosmokit/src/misc.ts
@@ -945,6 +946,8 @@ var InterconnectService = class extends Service {
   heartbeatTimer;
   /** Peer identity each live socket announced via its `hello` frame, if any. */
   peerOf = /* @__PURE__ */ new WeakMap();
+  /** Configured peer an outbound dial owns a socket for; absent on inbound sockets. */
+  dialedPeerOf = /* @__PURE__ */ new WeakMap();
   /** Sender each local session last received a send from, keyed by local session id. */
   senders = /* @__PURE__ */ new Map();
   /** In-flight frames sent over a peer link, keyed by `reqId`, awaiting a correlated result. */
@@ -1176,50 +1179,16 @@ var InterconnectService = class extends Service {
     });
   }
   /**
-   * Add a peer route at runtime. Returns a disposer that removes it. Re-adding
-   * an existing instanceId re-routes it to the new origin.
-   * @param instanceId - the peer's `instanceId`.
-   * @param origin - origin this instance dials to reach that peer.
-   * @returns disposer removing the peer route.
-   */
-  subscribe(instanceId, origin) {
-    const linked = this.link(instanceId, origin);
-    const dialedOrigin = trimBase(origin);
-    return () => {
-      const state = this.linkStates.get(instanceId);
-      if (state === linked && state.peer === dialedOrigin) {
-        state.close();
-        this.linkStates.delete(instanceId);
-      }
-    };
-  }
-  /**
-   * Remove a peer route, closing its outbound link.
-   * @param instanceId - the peer route to remove.
-   */
-  unsubscribe(instanceId) {
-    const state = this.linkStates.get(instanceId);
-    if (state !== void 0) state.close();
-    this.linkStates.delete(instanceId);
-  }
-  /**
-   * Open (and, on drop, re-open) a persistent WebSocket link to a peer. Local
-   * events stream over the link in real time, and events the peer pushes are
-   * surfaced as `interconnect/event`. Repeating for the same instanceId
-   * re-routes the link to the new origin.
+   * Dial one configured peer route. Activation calls this once per
+   * `Config.peers` entry; the resulting state owns reconnection for the life of
+   * the service fiber.
    * @param instanceId - the peer's `instanceId`.
    * @param origin - receiver origin this instance dials, e.g. `http://127.0.0.1:13080`.
-   * @returns a handle closing the link and cancelling reconnection.
    */
   link(instanceId, origin) {
-    const existing = this.linkStates.get(instanceId);
-    if (existing !== void 0 && !existing.isClosed()) {
-      existing.reroute(trimBase(origin));
-      return existing;
-    }
     const state = new LinkState(
       (socket) => {
-        this.attachSocket(socket);
+        this.attachDialedSocket(socket, instanceId);
       },
       this.ctx.logger,
       () => this.resolveToken(),
@@ -1228,26 +1197,41 @@ var InterconnectService = class extends Service {
     );
     this.linkStates.set(instanceId, state);
     state.dial();
-    return state;
   }
   /** Push one serialized lifecycle fact out to every linked peer over WS. */
   fanout(notification) {
     this.broadcast(notification);
   }
-  /** Push one fact over every live WebSocket link, dropping closed sockets. */
+  /**
+   * Push one fact over every live WebSocket link, dropping closed sockets.
+   *
+   * A bidirectional pair owns two sockets to the same peer (this instance's
+   * dialed link plus the peer's inbound one), so one event must leave over one
+   * of them. Which one is decided by local ownership, not by the peer: a dialed
+   * socket is a configured peer's link and always sends. An inbound socket is
+   * skipped only when a dialed link to the id that socket itself announced is
+   * open, so an announcement can suppress nothing but a duplicate the
+   * controlled link already carries — an impostor cannot drop an event for a
+   * peer, and without a dialed link every inbound socket receives it.
+   */
   broadcast(notification) {
     if (this.sockets.size === 0) return;
     const frame = { type: "event", notification };
     const encoded = JSON.stringify(frame);
-    const sent = /* @__PURE__ */ new Set();
+    const covered = /* @__PURE__ */ new Set();
     for (const socket of this.sockets) {
       if (socket.readyState !== WebSocket.OPEN) {
         this.sockets.delete(socket);
         continue;
       }
-      const peer = this.peerOf.get(socket);
-      if (peer !== void 0 && sent.has(peer)) continue;
-      if (peer !== void 0) sent.add(peer);
+      const dialedPeer = this.dialedPeerOf.get(socket);
+      if (dialedPeer !== void 0) covered.add(dialedPeer);
+    }
+    for (const socket of this.sockets) {
+      if (this.dialedPeerOf.get(socket) === void 0) {
+        const announced = this.peerOf.get(socket);
+        if (announced !== void 0 && covered.has(announced)) continue;
+      }
       socket.send(encoded);
     }
   }
@@ -1378,6 +1362,9 @@ var InterconnectService = class extends Service {
       this.ctx.logger.info(
         `interconnect: resume refused for ${payload.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
+      if (remoteErrorOf(error)?.code === "session/agent-busy") {
+        return { reason: "session-owned-by-subagent" };
+      }
       return { reason: "resume-failed" };
     }
   }
@@ -1484,6 +1471,17 @@ var InterconnectService = class extends Service {
       this.attachSocket(websocket);
     });
   }
+  /**
+   * Install frame + liveness handling on one outbound socket the dial owns for
+   * a configured peer, recording that local ownership before anything else can
+   * observe the socket.
+   * @param websocket - the dialed socket.
+   * @param peerInstanceId - the configured peer this instance dials.
+   */
+  attachDialedSocket(websocket, peerInstanceId) {
+    this.dialedPeerOf.set(websocket, peerInstanceId);
+    this.attachSocket(websocket);
+  }
   /**
    * Install frame + liveness handling on one socket and add it to the live
    * pool. Used by both the server half (accepted upgrade) and the client half
@@ -1590,40 +1588,17 @@ var LinkState = class {
     this.instanceId = instanceId;
     this.peer = origin;
   }
-  socket;
-  dialEpoch = 0;
+  dialed;
   closed = false;
   retry = 0;
   reconnectTimer;
   warnedNoToken = false;
-  /** Dial-registered handlers, removed by reference on close/reroute so the pool-cleanup handlers attachSocket added stay alive. */
-  dialListeners;
-  // `peer` is mutable so `reroute` can point the link at a new origin.
+  /** Receiver origin this link dials. */
   peer;
   instanceId;
-  /** Point this link at a different origin; re-dials immediately. */
-  reroute(origin) {
-    if (origin === this.peer) return;
-    this.peer = origin;
-    this.dialEpoch += 1;
-    if (this.reconnectTimer !== void 0) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = void 0;
-    }
-    const socket = this.socket;
-    if (socket !== void 0) {
-      this.removeDialListeners(socket);
-      socket.on("error", () => {
-      });
-      socket.terminate();
-      this.socket = void 0;
-    }
-    this.dial();
-  }
   /** Open the socket; reconnect is scheduled by the close handler. */
   dial() {
     if (this.closed) return;
-    const epoch = this.dialEpoch;
     let url;
     try {
       url = linkUrl(this.peer);
@@ -1637,11 +1612,11 @@ var LinkState = class {
           this.warnedNoToken = true;
           this.logger.warn(`interconnect: no shared token configured; peer ${this.instanceId} link stays down, retrying until one is set`);
         }
-        if (this.closed || epoch !== this.dialEpoch) return;
+        if (this.closed) return;
         this.scheduleReconnect();
         return;
       }
-      if (this.closed || epoch !== this.dialEpoch) return;
+      if (this.closed) return;
       const socket = new WebSocket(url, {
         headers: { authorization: `Bearer ${token}` },
         maxPayload: MAX_LINK_FRAME_BYTES,
@@ -1652,7 +1627,6 @@ var LinkState = class {
         // a reconnect — and ws owns the timer, so nothing leaks on teardown.
         handshakeTimeout: LINK_HANDSHAKE_TIMEOUT_MS
       });
-      this.socket = socket;
       const onOpen = () => {
         this.retry = 0;
         this.attachSocket(socket);
@@ -1663,49 +1637,38 @@ var LinkState = class {
       };
       const onError = () => {
       };
-      this.dialListeners = { open: onOpen, close: onClose, error: onError };
+      this.dialed = { socket, open: onOpen, close: onClose, error: onError };
       socket.once("open", onOpen);
       socket.once("close", onClose);
       socket.on("error", onError);
     }).catch(() => {
-      if (this.closed || epoch !== this.dialEpoch) return;
+      if (this.closed) return;
       this.scheduleReconnect();
     });
   }
-  /** Whether this link has been closed; a closed state is never reused by `link()`. */
-  isClosed() {
-    return this.closed;
-  }
   /** Whether this link currently holds an open socket that can carry frames. */
   writable() {
-    return this.socket !== void 0 && this.socket.readyState === WebSocket.OPEN;
+    const dialed = this.dialed;
+    return dialed !== void 0 && dialed.socket.readyState === WebSocket.OPEN;
   }
   /** Write one frame over this link's outbound socket; false when not open. */
   sendFrame(frame) {
-    const socket = this.socket;
-    if (socket === void 0 || socket.readyState !== WebSocket.OPEN) return false;
-    socket.send(JSON.stringify(frame));
+    const dialed = this.dialed;
+    if (dialed === void 0 || dialed.socket.readyState !== WebSocket.OPEN) return false;
+    dialed.socket.send(JSON.stringify(frame));
     return true;
   }
   close() {
     this.closed = true;
     if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
-    const socket = this.socket;
-    if (socket !== void 0) {
-      this.removeDialListeners(socket);
-      socket.on("error", () => {
-      });
-      socket.terminate();
-    }
-  }
-  /** Detach the dial-registered handlers from a socket before terminating it. */
-  removeDialListeners(socket) {
-    const listeners = this.dialListeners;
-    if (listeners === void 0) return;
-    socket.removeListener("open", listeners.open);
-    socket.removeListener("close", listeners.close);
-    socket.removeListener("error", listeners.error);
-    this.dialListeners = void 0;
+    const dialed = this.dialed;
+    if (dialed === void 0) return;
+    dialed.socket.removeListener("open", dialed.open);
+    dialed.socket.removeListener("close", dialed.close);
+    dialed.socket.removeListener("error", dialed.error);
+    dialed.socket.on("error", () => {
+    });
+    dialed.socket.terminate();
   }
   scheduleReconnect() {
     const delay = Math.min(3e4, 1e3 * 2 ** this.retry);