@parall/daemon 1.43.0 → 1.44.0

package/bundle/manifest.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.43.0",
-  "built_at": "2026-07-13T04:04:48.217Z",
+  "version": "1.44.0",
+  "built_at": "2026-07-14T07:01:33.876Z",
   "min_node_version": "20.0.0",
   "files": {
     "bb-browser-daemon.js": {
@@ -16,29 +16,29 @@
       "size": 18
     },
     "parall-browser-pod.js": {
-      "sha256": "464b249ca4be9ed4ebc520220f11b94fe78c4ceedda8cbfd3dee7c7e02ae4c38",
-      "size": 1699655
+      "sha256": "81dbdef2606b3295d94101d672f514f6fab6d7c105716b4fe9f917bb9b404b1a",
+      "size": 1699775
     },
     "parall-channel-exec.js": {
       "sha256": "32c438151df40ccda7491c57bfa0cd9d6c4d762755353c6c751d5793af57b971",
       "size": 7097
     },
     "parall-claude-agent.js": {
-      "sha256": "084f01f1e64aa582dde65ee1eaf3d85a99b7960451a55b1157cb2ad61816d7bd",
-      "size": 1639412
+      "sha256": "f7dadfab076bcb55a7aea0d79fdd59b93200dad8c8ef674ac1879e53720fd946",
+      "size": 1644021
     },
     "parall-codex-agent.js": {
-      "sha256": "4fa941ad4643333e97feb88dd728ec0badebc5cba21206dbe22d08a40cd76cf6",
-      "size": 1676742
+      "sha256": "4f77525ca21caa389106feb7aef1f630613ec91dedbf366ed52fc3c70b391607",
+      "size": 1681351
     },
     "parall-daemon.js": {
-      "sha256": "82f1047c975cb47e31063863a752163a756b857c962d63a7df9acbcdfe0c450d",
-      "size": 1726872
+      "sha256": "b880b10ae5b932968178ff1f216ad13859afdd02cca332fdd900279dc3ba87ea",
+      "size": 1727004
     },
     "parall-openclaw-agent.js": {
       "sha256": "505433b4bf3a4b8dbb7b96978d8693d6c48079f4513282ff1ee59a6d13b3eddf",
       "size": 9801
     }
   },
-  "signature": "YRCOk2+FiAfFASvIWGt7sDPkt+iZE1yfUfVnu793pKZhbSmjKedFXwq6WdUM+lpM6WqL09/JPSf9d3gmDNc9AA=="
+  "signature": "WChU4cNRetS9GZz1kISiZkkXjvwR5fSi4QeMiIyZx9r1FBio4CuLqLI7aUFoSEyTzTDSAH9mJS7jdV/csZvfBQ=="
 }

package/bundle/parall-browser-pod.js

@@ -36443,7 +36443,6 @@ var ParallClient = class _ParallClient {
   async steerDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_STEER(orgId), req);
   }
-  /** End a turn: no_action sweep of the lane's members + lane release + re-drive check. */
   async completeDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE(orgId), req);
   }
@@ -36451,6 +36450,10 @@ var ParallClient = class _ParallClient {
    * End a turn for a lane-less runtime: resolve the turn's folded WorkItems
    * by source — broad-cover to the turn's reply Effect when one exists,
    * no_action sweep otherwise. Idempotent.
+   *
+   * @deprecated Legacy ok-only alias — use {@link completeDispatch} with the
+   * `sources` form, which also carries `turn_outcome`. The endpoint retires
+   * at S3b (dispatch-convergence-design.md §3).
    */
   async completeDispatchSources(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE_SOURCES(orgId), req);

package/bundle/parall-claude-agent.js

@@ -27944,7 +27944,6 @@ var ParallClient = class _ParallClient {
   async steerDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_STEER(orgId), req);
   }
-  /** End a turn: no_action sweep of the lane's members + lane release + re-drive check. */
   async completeDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE(orgId), req);
   }
@@ -27952,6 +27951,10 @@ var ParallClient = class _ParallClient {
    * End a turn for a lane-less runtime: resolve the turn's folded WorkItems
    * by source — broad-cover to the turn's reply Effect when one exists,
    * no_action sweep otherwise. Idempotent.
+   *
+   * @deprecated Legacy ok-only alias — use {@link completeDispatch} with the
+   * `sources` form, which also carries `turn_outcome`. The endpoint retires
+   * at S3b (dispatch-convergence-design.md §3).
    */
   async completeDispatchSources(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE_SOURCES(orgId), req);
@@ -29157,7 +29160,11 @@ var LaneLedger = class {
         throw err;
       }
       if (!res.claimed || !res.lane) {
-        this.opts.log?.info(`lane for ${targetUri} held by a healthy incumbent \u2014 leaving events pending for re-drive`);
+        if (res.reason === "empty") {
+          this.opts.log?.warn(`claim for ${targetUri} came back empty \u2014 nothing foldable; leaving to the reconciler`);
+        } else {
+          this.opts.log?.info(`lane for ${targetUri} held by a healthy incumbent \u2014 leaving events pending for re-drive`);
+        }
         return null;
       }
       const leaseUntilMs = Date.parse(res.lease_until ?? "");
@@ -29234,6 +29241,18 @@ var LaneLedger = class {
    * re-drives any same-target pending work. A STALE_LANE answer means a
    * takeover already owns the resource — local state is dropped either way.
    */
+  /**
+   * Record that the turn on this lane surfaced a runtime error. The flow
+   * settles an errored lane immediately (dispatchLaneGroup returns 'failed'
+   * after a forced complete), so the bit normally lives for one turn only —
+   * it is the transport between the gateway's per-session error signal and
+   * this lane's complete request.
+   */
+  markTurnError(laneKey) {
+    const lane = this.lanes.get(laneKey);
+    if (lane)
+      lane.turnError = true;
+  }
   async completeIfIdle(laneKey, hasMoreLocal) {
     const lane = this.lanes.get(laneKey);
     if (!lane || hasMoreLocal)
@@ -29244,7 +29263,10 @@ var LaneLedger = class {
       const res = await this.opts.client.completeDispatch(this.opts.orgId, {
         lane: lane.lane,
         target_uri: lane.targetUri,
-        thread_root_id: lane.threadRootId
+        thread_root_id: lane.threadRootId,
+        // An error turn releases its members for retry instead of sweeping
+        // them as handled (ignored by older servers).
+        turn_outcome: lane.turnError ? "error" : "ok"
       });
       if (res.swept_no_action > 0 || res.redriven) {
         this.opts.log?.info(`lane complete for ${lane.targetUri}: swept ${res.swept_no_action} no_action, redriven=${res.redriven}`);
@@ -29257,6 +29279,17 @@ var LaneLedger = class {
       this.opts.log?.warn(`lane complete failed for ${lane.targetUri}: ${String(err)}`);
     }
   }
+  /**
+   * Renew one lane by its key — the external runtime-activity hook for
+   * adapters whose tool traffic bypasses the RuntimeEvent stream (openclaw
+   * hooks). Scoped to the session's own lane: renewing every lane would let
+   * one busy fork keep an unrelated stalled fork's lane leased forever.
+   */
+  renewByKey(laneKey) {
+    const lane = this.lanes.get(laneKey);
+    if (lane)
+      this.maybeRenew(lane);
+  }
   /**
    * Long-turn keepalive: renew the lane's lease on runtime activity, throttled
    * so a chatty turn doesn't spam the server. Without this, a legitimately
@@ -29398,17 +29431,34 @@ async function dispatchLaneGroup(host, opts) {
     }
     return "foreign";
   }
+  host.noteSessionLane(opts.sessionKey, lane.laneKey);
   let dispatched = false;
   try {
     dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
   } catch (err) {
+    host.noteSessionLane(opts.sessionKey, null);
     await ledger.release(lane.laneKey).catch(() => {
     });
     throw err;
+  } finally {
+    if (dispatched)
+      host.noteSessionLane(opts.sessionKey, null);
   }
   if (!dispatched) {
     return "shutdown";
   }
+  if (host.consumeTurnError(opts.sessionKey)) {
+    ledger.markTurnError(lane.laneKey);
+    for (const msgId of lane.folded.keys()) {
+      host.dispatchedMessages.delete(msgId);
+    }
+    try {
+      host.opts.dispatchAdapter.abortDispatch?.(opts.sessionKey);
+    } catch {
+    }
+    await ledger.completeIfIdle(lane.laneKey, false);
+    return "failed";
+  }
   const pendingInjections = host.opts.dispatchAdapter.hasPendingInjections?.(opts.sessionKey) ?? false;
   await ledger.completeIfIdle(lane.laneKey, pendingInjections || opts.hasMoreLocal());
   return "dispatched";
@@ -30791,6 +30841,44 @@ var ParallAgentGateway = class {
     this.dispatchedMessages.add(id);
     return true;
   }
+  /**
+   * Lane currently being dispatched per session — lets external activity
+   * signals renew exactly the caller's lane (renewing all lanes would keep
+   * an unrelated stalled fork's lane leased forever).
+   */
+  sessionActiveLanes = /* @__PURE__ */ new Map();
+  noteSessionLane(sessionKey, laneKey) {
+    if (laneKey == null)
+      this.sessionActiveLanes.delete(sessionKey);
+    else
+      this.sessionActiveLanes.set(sessionKey, laneKey);
+  }
+  /**
+   * External runtime-activity signal for adapters whose tool activity does
+   * not flow through the RuntimeEvent stream (openclaw hooks call this from
+   * the tool-call lifecycle): renews the session's OWN active ledger lane so
+   * a long tool call cannot outlive the lease and get dethroned mid-turn.
+   * No-op without an active ledger lane for the session.
+   */
+  touchRuntimeActivity(sessionKey) {
+    if (this.ledgerDisabled)
+      return;
+    const laneKey = this.sessionActiveLanes.get(sessionKey);
+    if (laneKey)
+      this.laneLedger?.renewByKey(laneKey);
+  }
+  /** Sessions whose in-flight turn surfaced a runtime error event. */
+  turnErrorSessions = /* @__PURE__ */ new Set();
+  /**
+   * Consume (read-and-clear) the error marker for sessionKey's last turn.
+   * Feeds complete's turn_outcome so an error turn's lane members are
+   * released for retry instead of no_action-swept (design §3). Consuming
+   * (rather than peeking) keeps one-shot fork session keys from accumulating
+   * in the set forever.
+   */
+  consumeTurnError(sessionKey) {
+    return this.turnErrorSessions.delete(sessionKey);
+  }
   async emitDispatchReceived(event) {
     const sourceType = event.ackSourceType ?? (event.type === "task" ? "task_activity" : "message");
     const sourceId = event.ackSourceId ?? event.messageId;
@@ -31140,6 +31228,7 @@ var ParallAgentGateway = class {
       this.pendingRestartNotification = null;
     }
     resetDispatchMetrics(sessionKey);
+    this.turnErrorSessions.delete(sessionKey);
     return runWithSessionKey(sessionKey, async () => {
       let dispatchSpan = null;
       setSessionChatId(sessionKey, event.targetId);
@@ -31247,6 +31336,9 @@ var ParallAgentGateway = class {
           } else if (runtimeEvent.type === "tool_result" && pendingSendCallIds.delete(runtimeEvent.callId)) {
             recordMessageSend(sessionKey, !runtimeEvent.error);
           }
+          if (runtimeEvent.type === "error") {
+            this.turnErrorSessions.add(sessionKey);
+          }
           await this.createRuntimeStep(binding.agentSessionId, event, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2);
         }
         if (!binding) {
@@ -31394,13 +31486,23 @@ var ParallAgentGateway = class {
               body: buildForkScopePrefix(last) + buildEventBody(last),
               earlier,
               captureText: batchText,
-              hasMoreLocal: () => fork.queue.length > 0
+              // Per-LANE residue check (parity with the main-buffer path):
+              // the fork queue can hold several lanes (channel + thread of
+              // the same chat). A whole-queue check would defer THIS lane's
+              // complete behind another lane's items and never revisit it —
+              // its members would sit received until lease expiry.
+              hasMoreLocal: () => fork.queue.some((it) => this.dispatchGroupKey(it.event) === this.dispatchGroupKey(last))
             });
             if (outcome === "foreign") {
               for (const item of items)
                 item.resolve(false);
               break;
             }
+            if (outcome === "failed") {
+              for (const item of items)
+                item.resolve(false);
+              continue;
+            }
             dispatched = outcome === "dispatched";
           } else {
             dispatched = await this.runDispatch(last, fork.fork.sessionKey, buildForkScopePrefix(last) + buildEventBody(last), earlier, batchText);
@@ -31434,6 +31536,7 @@ var ParallAgentGateway = class {
         remaining.resolve(false);
       }
     } finally {
+      this.turnErrorSessions.delete(fork.fork.sessionKey);
       if (fork.deadlineTimer) {
         clearTimeout(fork.deadlineTimer);
         fork.deadlineTimer = null;
@@ -31546,6 +31649,10 @@ var ParallAgentGateway = class {
             this.dispatchState.pendingForkResults.unshift(...pendingFork);
             continue;
           }
+          if (outcome === "failed") {
+            this.dispatchState.pendingForkResults.unshift(...pendingFork);
+            continue;
+          }
           continue;
         }
         try {
@@ -31649,7 +31756,7 @@ var ParallAgentGateway = class {
         }
         this.dispatchState.mainBuffer.push(event);
         if (this.usesLaneLedger(event)) {
-          if (this.mainCurrentGroupKey === this.dispatchGroupKey(event) && await this.laneLedger?.steerLive(event) && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))) {
+          if (this.mainCurrentGroupKey === this.dispatchGroupKey(event) && this.opts.dispatchAdapter.enqueueDuringDispatch != null && await this.laneLedger?.steerLive(event) && await this.opts.dispatchAdapter.enqueueDuringDispatch(this.opts.runtimeKey, buildEventBody(event))) {
             this.opts.log?.info(`steer folded+injected for ${event.messageId} (will drain for bookkeeping)`);
           }
         } else if (this.dispatchState.mainCurrentTargetId === event.targetId && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))) {
@@ -31676,12 +31783,14 @@ var ParallAgentGateway = class {
           this.dispatchState.mainBuffer.push(event);
           return false;
         }
-        try {
-          await this.emitDispatchReceived(event);
-        } catch (err) {
-          this.opts.log?.warn?.(`mark-received failed for fork dispatch, leaving unacked for retry: ${String(err)}`);
-          this.dispatchState.mainBuffer.push(event);
-          return false;
+        if (!this.usesLaneLedger(event)) {
+          try {
+            await this.emitDispatchReceived(event);
+          } catch (err) {
+            this.opts.log?.warn?.(`mark-received failed for fork dispatch, leaving unacked for retry: ${String(err)}`);
+            this.dispatchState.mainBuffer.push(event);
+            return false;
+          }
         }
         const fork = await this.opts.dispatchAdapter.forkSession({
           sessionKey: this.opts.runtimeKey,

package/bundle/parall-codex-agent.js

@@ -27944,7 +27944,6 @@ var ParallClient = class _ParallClient {
   async steerDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_STEER(orgId), req);
   }
-  /** End a turn: no_action sweep of the lane's members + lane release + re-drive check. */
   async completeDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE(orgId), req);
   }
@@ -27952,6 +27951,10 @@ var ParallClient = class _ParallClient {
    * End a turn for a lane-less runtime: resolve the turn's folded WorkItems
    * by source — broad-cover to the turn's reply Effect when one exists,
    * no_action sweep otherwise. Idempotent.
+   *
+   * @deprecated Legacy ok-only alias — use {@link completeDispatch} with the
+   * `sources` form, which also carries `turn_outcome`. The endpoint retires
+   * at S3b (dispatch-convergence-design.md §3).
    */
   async completeDispatchSources(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE_SOURCES(orgId), req);
@@ -29157,7 +29160,11 @@ var LaneLedger = class {
         throw err;
       }
       if (!res.claimed || !res.lane) {
-        this.opts.log?.info(`lane for ${targetUri} held by a healthy incumbent \u2014 leaving events pending for re-drive`);
+        if (res.reason === "empty") {
+          this.opts.log?.warn(`claim for ${targetUri} came back empty \u2014 nothing foldable; leaving to the reconciler`);
+        } else {
+          this.opts.log?.info(`lane for ${targetUri} held by a healthy incumbent \u2014 leaving events pending for re-drive`);
+        }
         return null;
       }
       const leaseUntilMs = Date.parse(res.lease_until ?? "");
@@ -29234,6 +29241,18 @@ var LaneLedger = class {
    * re-drives any same-target pending work. A STALE_LANE answer means a
    * takeover already owns the resource — local state is dropped either way.
    */
+  /**
+   * Record that the turn on this lane surfaced a runtime error. The flow
+   * settles an errored lane immediately (dispatchLaneGroup returns 'failed'
+   * after a forced complete), so the bit normally lives for one turn only —
+   * it is the transport between the gateway's per-session error signal and
+   * this lane's complete request.
+   */
+  markTurnError(laneKey) {
+    const lane = this.lanes.get(laneKey);
+    if (lane)
+      lane.turnError = true;
+  }
   async completeIfIdle(laneKey, hasMoreLocal) {
     const lane = this.lanes.get(laneKey);
     if (!lane || hasMoreLocal)
@@ -29244,7 +29263,10 @@ var LaneLedger = class {
       const res = await this.opts.client.completeDispatch(this.opts.orgId, {
         lane: lane.lane,
         target_uri: lane.targetUri,
-        thread_root_id: lane.threadRootId
+        thread_root_id: lane.threadRootId,
+        // An error turn releases its members for retry instead of sweeping
+        // them as handled (ignored by older servers).
+        turn_outcome: lane.turnError ? "error" : "ok"
       });
       if (res.swept_no_action > 0 || res.redriven) {
         this.opts.log?.info(`lane complete for ${lane.targetUri}: swept ${res.swept_no_action} no_action, redriven=${res.redriven}`);
@@ -29257,6 +29279,17 @@ var LaneLedger = class {
       this.opts.log?.warn(`lane complete failed for ${lane.targetUri}: ${String(err)}`);
     }
   }
+  /**
+   * Renew one lane by its key — the external runtime-activity hook for
+   * adapters whose tool traffic bypasses the RuntimeEvent stream (openclaw
+   * hooks). Scoped to the session's own lane: renewing every lane would let
+   * one busy fork keep an unrelated stalled fork's lane leased forever.
+   */
+  renewByKey(laneKey) {
+    const lane = this.lanes.get(laneKey);
+    if (lane)
+      this.maybeRenew(lane);
+  }
   /**
    * Long-turn keepalive: renew the lane's lease on runtime activity, throttled
    * so a chatty turn doesn't spam the server. Without this, a legitimately
@@ -29398,17 +29431,34 @@ async function dispatchLaneGroup(host, opts) {
     }
     return "foreign";
   }
+  host.noteSessionLane(opts.sessionKey, lane.laneKey);
   let dispatched = false;
   try {
     dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
   } catch (err) {
+    host.noteSessionLane(opts.sessionKey, null);
     await ledger.release(lane.laneKey).catch(() => {
     });
     throw err;
+  } finally {
+    if (dispatched)
+      host.noteSessionLane(opts.sessionKey, null);
   }
   if (!dispatched) {
     return "shutdown";
   }
+  if (host.consumeTurnError(opts.sessionKey)) {
+    ledger.markTurnError(lane.laneKey);
+    for (const msgId of lane.folded.keys()) {
+      host.dispatchedMessages.delete(msgId);
+    }
+    try {
+      host.opts.dispatchAdapter.abortDispatch?.(opts.sessionKey);
+    } catch {
+    }
+    await ledger.completeIfIdle(lane.laneKey, false);
+    return "failed";
+  }
   const pendingInjections = host.opts.dispatchAdapter.hasPendingInjections?.(opts.sessionKey) ?? false;
   await ledger.completeIfIdle(lane.laneKey, pendingInjections || opts.hasMoreLocal());
   return "dispatched";
@@ -30791,6 +30841,44 @@ var ParallAgentGateway = class {
     this.dispatchedMessages.add(id);
     return true;
   }
+  /**
+   * Lane currently being dispatched per session — lets external activity
+   * signals renew exactly the caller's lane (renewing all lanes would keep
+   * an unrelated stalled fork's lane leased forever).
+   */
+  sessionActiveLanes = /* @__PURE__ */ new Map();
+  noteSessionLane(sessionKey, laneKey) {
+    if (laneKey == null)
+      this.sessionActiveLanes.delete(sessionKey);
+    else
+      this.sessionActiveLanes.set(sessionKey, laneKey);
+  }
+  /**
+   * External runtime-activity signal for adapters whose tool activity does
+   * not flow through the RuntimeEvent stream (openclaw hooks call this from
+   * the tool-call lifecycle): renews the session's OWN active ledger lane so
+   * a long tool call cannot outlive the lease and get dethroned mid-turn.
+   * No-op without an active ledger lane for the session.
+   */
+  touchRuntimeActivity(sessionKey) {
+    if (this.ledgerDisabled)
+      return;
+    const laneKey = this.sessionActiveLanes.get(sessionKey);
+    if (laneKey)
+      this.laneLedger?.renewByKey(laneKey);
+  }
+  /** Sessions whose in-flight turn surfaced a runtime error event. */
+  turnErrorSessions = /* @__PURE__ */ new Set();
+  /**
+   * Consume (read-and-clear) the error marker for sessionKey's last turn.
+   * Feeds complete's turn_outcome so an error turn's lane members are
+   * released for retry instead of no_action-swept (design §3). Consuming
+   * (rather than peeking) keeps one-shot fork session keys from accumulating
+   * in the set forever.
+   */
+  consumeTurnError(sessionKey) {
+    return this.turnErrorSessions.delete(sessionKey);
+  }
   async emitDispatchReceived(event) {
     const sourceType = event.ackSourceType ?? (event.type === "task" ? "task_activity" : "message");
     const sourceId = event.ackSourceId ?? event.messageId;
@@ -31140,6 +31228,7 @@ var ParallAgentGateway = class {
       this.pendingRestartNotification = null;
     }
     resetDispatchMetrics(sessionKey);
+    this.turnErrorSessions.delete(sessionKey);
     return runWithSessionKey(sessionKey, async () => {
       let dispatchSpan = null;
       setSessionChatId(sessionKey, event.targetId);
@@ -31247,6 +31336,9 @@ var ParallAgentGateway = class {
           } else if (runtimeEvent.type === "tool_result" && pendingSendCallIds.delete(runtimeEvent.callId)) {
             recordMessageSend(sessionKey, !runtimeEvent.error);
           }
+          if (runtimeEvent.type === "error") {
+            this.turnErrorSessions.add(sessionKey);
+          }
           await this.createRuntimeStep(binding.agentSessionId, event, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2);
         }
         if (!binding) {
@@ -31394,13 +31486,23 @@ var ParallAgentGateway = class {
               body: buildForkScopePrefix(last) + buildEventBody(last),
               earlier,
               captureText: batchText,
-              hasMoreLocal: () => fork.queue.length > 0
+              // Per-LANE residue check (parity with the main-buffer path):
+              // the fork queue can hold several lanes (channel + thread of
+              // the same chat). A whole-queue check would defer THIS lane's
+              // complete behind another lane's items and never revisit it —
+              // its members would sit received until lease expiry.
+              hasMoreLocal: () => fork.queue.some((it) => this.dispatchGroupKey(it.event) === this.dispatchGroupKey(last))
             });
             if (outcome === "foreign") {
               for (const item of items)
                 item.resolve(false);
               break;
             }
+            if (outcome === "failed") {
+              for (const item of items)
+                item.resolve(false);
+              continue;
+            }
             dispatched = outcome === "dispatched";
           } else {
             dispatched = await this.runDispatch(last, fork.fork.sessionKey, buildForkScopePrefix(last) + buildEventBody(last), earlier, batchText);
@@ -31434,6 +31536,7 @@ var ParallAgentGateway = class {
         remaining.resolve(false);
       }
     } finally {
+      this.turnErrorSessions.delete(fork.fork.sessionKey);
       if (fork.deadlineTimer) {
         clearTimeout(fork.deadlineTimer);
         fork.deadlineTimer = null;
@@ -31546,6 +31649,10 @@ var ParallAgentGateway = class {
             this.dispatchState.pendingForkResults.unshift(...pendingFork);
             continue;
           }
+          if (outcome === "failed") {
+            this.dispatchState.pendingForkResults.unshift(...pendingFork);
+            continue;
+          }
           continue;
         }
         try {
@@ -31649,7 +31756,7 @@ var ParallAgentGateway = class {
         }
         this.dispatchState.mainBuffer.push(event);
         if (this.usesLaneLedger(event)) {
-          if (this.mainCurrentGroupKey === this.dispatchGroupKey(event) && await this.laneLedger?.steerLive(event) && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))) {
+          if (this.mainCurrentGroupKey === this.dispatchGroupKey(event) && this.opts.dispatchAdapter.enqueueDuringDispatch != null && await this.laneLedger?.steerLive(event) && await this.opts.dispatchAdapter.enqueueDuringDispatch(this.opts.runtimeKey, buildEventBody(event))) {
             this.opts.log?.info(`steer folded+injected for ${event.messageId} (will drain for bookkeeping)`);
           }
         } else if (this.dispatchState.mainCurrentTargetId === event.targetId && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))) {
@@ -31676,12 +31783,14 @@ var ParallAgentGateway = class {
           this.dispatchState.mainBuffer.push(event);
           return false;
         }
-        try {
-          await this.emitDispatchReceived(event);
-        } catch (err) {
-          this.opts.log?.warn?.(`mark-received failed for fork dispatch, leaving unacked for retry: ${String(err)}`);
-          this.dispatchState.mainBuffer.push(event);
-          return false;
+        if (!this.usesLaneLedger(event)) {
+          try {
+            await this.emitDispatchReceived(event);
+          } catch (err) {
+            this.opts.log?.warn?.(`mark-received failed for fork dispatch, leaving unacked for retry: ${String(err)}`);
+            this.dispatchState.mainBuffer.push(event);
+            return false;
+          }
         }
         const fork = await this.opts.dispatchAdapter.forkSession({
           sessionKey: this.opts.runtimeKey,

package/bundle/parall-daemon.js

@@ -1625,7 +1625,6 @@ var init_client = __esm({
       async steerDispatch(orgId, req) {
         return this.request("POST", ENDPOINTS.DISPATCH_STEER(orgId), req);
       }
-      /** End a turn: no_action sweep of the lane's members + lane release + re-drive check. */
       async completeDispatch(orgId, req) {
         return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE(orgId), req);
       }
@@ -1633,6 +1632,10 @@ var init_client = __esm({
        * End a turn for a lane-less runtime: resolve the turn's folded WorkItems
        * by source — broad-cover to the turn's reply Effect when one exists,
        * no_action sweep otherwise. Idempotent.
+       *
+       * @deprecated Legacy ok-only alias — use {@link completeDispatch} with the
+       * `sources` form, which also carries `turn_outcome`. The endpoint retires
+       * at S3b (dispatch-convergence-design.md §3).
        */
       async completeDispatchSources(orgId, req) {
         return this.request("POST", ENDPOINTS.DISPATCH_COMPLETE_SOURCES(orgId), req);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/daemon",
-  "version": "1.43.0",
+  "version": "1.44.0",
   "description": "Parall local agent runtime — daemon supervisor + bridge runtimes, bundled as standalone JS files",
   "license": "MIT",
   "repository": {
@@ -32,11 +32,11 @@
   "dependencies": {
     "@aws-sdk/client-s3": "3.984.0",
     "@pinixai/bb-browser-pro": "0.15.0",
-    "@parall/agent-core": "1.43.0",
-    "@parall/sdk": "1.43.0",
-    "@parall/claude-agent": "1.43.0",
-    "@parall/codex-agent": "1.43.0",
-    "@parall/openclaw-agent": "1.43.0"
+    "@parall/agent-core": "1.44.0",
+    "@parall/claude-agent": "1.44.0",
+    "@parall/sdk": "1.44.0",
+    "@parall/codex-agent": "1.44.0",
+    "@parall/openclaw-agent": "1.44.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",