@cabane/companion 0.6.112 → 0.6.113

package/dist/cli.js

@@ -10654,6 +10654,41 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
   }
 }
 
+// src/dispatch-claims.ts
+var DispatchClaims = class {
+  inFlight = /* @__PURE__ */ new Map();
+  releases = /* @__PURE__ */ new Map();
+  // Claim a dispatch id for this process. Synchronous by design: two copies can
+  // arrive in the same tick, and a claim taken after an `await` would let both
+  // through.
+  claim(dispatchId) {
+    const running = this.inFlight.get(dispatchId);
+    if (running) return { first: false, done: running };
+    let release;
+    this.inFlight.set(
+      dispatchId,
+      new Promise((resolve2) => {
+        release = resolve2;
+      })
+    );
+    this.releases.set(dispatchId, release);
+    return { first: true };
+  }
+  // Hand the claim back once the run has finished — whatever its outcome.
+  // Releasing an id that isn't claimed is a no-op.
+  release(dispatchId) {
+    const resolve2 = this.releases.get(dispatchId);
+    if (!resolve2) return;
+    this.releases.delete(dispatchId);
+    this.inFlight.delete(dispatchId);
+    resolve2();
+  }
+  // The live set's size — the concurrent-turn count.
+  get size() {
+    return this.inFlight.size;
+  }
+};
+
 // src/outbox.ts
 import {
   existsSync as existsSync12,
@@ -11000,6 +11035,13 @@ var DRAIN_BASE_MS = 1e3;
 var DRAIN_MAX_MS = 3e4;
 var DRAIN_IDLE_MS = 15e3;
 var DEFAULT_UNRUNNABLE_RETRY_DELAYS_MS = [0, 1e3, 3e3];
+function dispatchPayload(wire) {
+  if (wire.type !== "device:dispatch_requested") return null;
+  return {
+    type: "device:dispatch_requested",
+    ...wire.payload
+  };
+}
 var CompanionSupervisor = class {
   workspaces = /* @__PURE__ */ new Map();
   config;
@@ -11058,6 +11100,9 @@ var CompanionSupervisor = class {
   // turn's classified outcome here (per runtime); the heartbeat echoes it so the
   // server's per-connector quota state survives a restart/race.
   connectorHealth = new ConnectorHealthStore();
+  // ACC10: which dispatches this process is running, so the copy of a frame that
+  // arrives on the other stream doesn't run the turn a second time.
+  claims = new DispatchClaims();
   constructor(opts) {
     this.config = opts.config;
     this.log = opts.log;
@@ -11101,7 +11146,9 @@ var CompanionSupervisor = class {
         if (ev.event === "assignments_changed") {
           if (this.refreshing && this.inFlightRefresh) await this.inFlightRefresh;
           await this.refreshAssignments();
+          return;
         }
+        if (ev.event === "message") await this.handleDeviceMessage(ev);
       },
       onAuthFailure: () => {
         this.log.error(
@@ -11612,17 +11659,75 @@ var CompanionSupervisor = class {
   async handleWorkspaceMessage(wr, ev) {
     if (ev.event !== "message") return;
     this.hub.recordEvent(wr.workspaceId);
-    let wire;
+    const wire = this.parseFrame(ev);
+    if (!wire) return;
+    if (ev.id) wr.cursor.observe(ev.id);
+    await this.deliverFrame(wr, ev.id, wire);
+  }
+  // ACC10: the device stream's frames — dispatch and cancel, addressed to this
+  // device and authenticated as it. Same frames and the same routing as above;
+  // what differs is that this stream keeps no cursor (it replays what is still
+  // offered on every connect instead of resuming from a `Last-Event-ID`), so
+  // nothing here observes or settles one.
+  async handleDeviceMessage(ev) {
+    const wire = this.parseFrame(ev);
+    if (!wire) return;
+    let wr = this.workspaces.get(wire.workspaceId);
+    if (!wr) {
+      if (this.refreshing && this.inFlightRefresh) await this.inFlightRefresh;
+      await this.refreshAssignments();
+      wr = this.workspaces.get(wire.workspaceId);
+      if (!wr) {
+        const payload = dispatchPayload(wire);
+        if (payload && payload.deviceId === this.deviceId) {
+          await this.reportUnrunnableDispatch(wire.workspaceId, payload);
+        } else {
+          this.log.debug(
+            { workspaceId: wire.workspaceId, type: wire.type },
+            "companion: device frame for a workspace this device does not run; ignoring"
+          );
+        }
+        return;
+      }
+    }
+    this.hub.recordEvent(wr.workspaceId);
+    await this.deliverFrame(wr, "", wire);
+  }
+  parseFrame(ev) {
     try {
-      wire = JSON.parse(ev.data);
+      return JSON.parse(ev.data);
     } catch (err) {
       this.log.debug(
         { err: err instanceof Error ? err.message : String(err) },
         "malformed SSE payload"
       );
+      return null;
+    }
+  }
+  // ACC10: the dedupe gate, and the only place that exists because there are two
+  // streams. Both carry the same frame with the same dispatch id; the first copy
+  // to arrive runs the turn, and the second waits for it and then settles its own
+  // stream's cursor. Settling a duplicate earlier than that would advance the
+  // low-water mark past an in-flight turn, which is exactly the CT282 bug.
+  //
+  // A cancel needs no gate: `dispatcher.cancel` on an already-aborted run is a
+  // no-op that reports `false`, so a second copy is inert.
+  async deliverFrame(wr, cursorId, wire) {
+    const claim = wire.type === "device:dispatch_requested" && wire.id ? this.claims.claim(wire.id) : null;
+    if (claim && !claim.first) {
+      await claim.done;
+      if (cursorId) wr.cursor.settle(cursorId);
       return;
     }
-    if (ev.id) wr.cursor.observe(ev.id);
+    try {
+      await this.routeFrame(wr, cursorId, wire);
+    } finally {
+      if (claim) this.claims.release(wire.id);
+    }
+  }
+  // Everything below here is the routing as it was: it takes a frame and knows
+  // nothing about which stream carried it.
+  async routeFrame(wr, cursorId, wire) {
     if (wire.type === "device:cancel_requested") {
       const payload2 = {
         type: "device:cancel_requested",
@@ -11642,17 +11747,14 @@ var CompanionSupervisor = class {
           );
         }
       }
-      if (ev.id) wr.cursor.settle(ev.id);
+      if (cursorId) wr.cursor.settle(cursorId);
       return;
     }
-    if (wire.type !== "device:dispatch_requested") {
-      if (ev.id) wr.cursor.settle(ev.id);
+    const payload = dispatchPayload(wire);
+    if (!payload) {
+      if (cursorId) wr.cursor.settle(cursorId);
       return;
     }
-    const payload = {
-      type: "device:dispatch_requested",
-      ...wire.payload
-    };
     if (this.deviceId && payload.deviceId && payload.deviceId !== this.deviceId) {
       this.log.debug(
         {
@@ -11663,7 +11765,7 @@ var CompanionSupervisor = class {
         },
         "companion: dispatch addressed to another device; ignoring"
       );
-      if (ev.id) wr.cursor.settle(ev.id);
+      if (cursorId) wr.cursor.settle(cursorId);
       return;
     }
     let agent = wr.agents.get(payload.agentId);
@@ -11671,16 +11773,16 @@ var CompanionSupervisor = class {
       agent = await this.recoverRacedAgent(wr, payload);
       if (!agent) {
         if (this.deviceId && payload.deviceId === this.deviceId) {
-          const reported = await this.reportUnrunnableDispatch(wr, payload);
+          const reported = await this.reportUnrunnableDispatch(wr.workspaceId, payload);
           if (!reported) return;
         }
-        if (ev.id) wr.cursor.settle(ev.id);
+        if (cursorId) wr.cursor.settle(cursorId);
         return;
       }
     }
     const chainKey = `${payload.conversationId}|${payload.agentId}`;
     const prev = wr.chains.get(chainKey) ?? Promise.resolve();
-    const tail = prev.then(() => this.runDispatch(wr, ev, payload, agent)).catch((err) => {
+    const tail = prev.then(() => this.runDispatch(wr, { dispatchId: wire.id, cursorId }, payload, agent)).catch((err) => {
       this.log.warn(
         {
           workspaceId: wr.workspaceId,
@@ -11707,7 +11809,7 @@ var CompanionSupervisor = class {
   // dropped socket) and one more attempt a second later usually lands. Bounded
   // hard — this runs inline on the event loop, and an unbounded wait here would
   // wedge the workspace's whole stream.
-  async reportUnrunnableDispatch(wr, payload) {
+  async reportUnrunnableDispatch(workspaceId, payload) {
     if (!this.deviceApi) return false;
     let lastErr;
     for (const wait of this.unrunnableRetryDelaysMs) {
@@ -11715,7 +11817,7 @@ var CompanionSupervisor = class {
       if (wait > 0) await new Promise((r) => setTimeout(r, wait));
       try {
         const { cleared } = await this.deviceApi.reportDispatchDrop({
-          workspaceId: wr.workspaceId,
+          workspaceId,
           conversationId: payload.conversationId,
           agentId: payload.agentId,
           messageId: payload.messageId,
@@ -11723,7 +11825,7 @@ var CompanionSupervisor = class {
         });
         this.log.debug(
           {
-            workspaceId: wr.workspaceId,
+            workspaceId,
             conversationId: payload.conversationId,
             agentId: payload.agentId,
             cleared
@@ -11737,7 +11839,7 @@ var CompanionSupervisor = class {
     }
     this.log.error(
       {
-        workspaceId: wr.workspaceId,
+        workspaceId,
         conversationId: payload.conversationId,
         agentId: payload.agentId,
         err: lastErr instanceof Error ? lastErr.message : String(lastErr)
@@ -11792,7 +11894,10 @@ var CompanionSupervisor = class {
         };
         const tail = this.runDispatch(
           wr,
-          { id: "", event: "recovery", data: "" },
+          // No frame delivered this one — it came off `/runs` — so there is
+          // neither a dispatch id to dedupe on nor a cursor to settle. The
+          // `recoveredTurns` set above is this path's own guard.
+          { dispatchId: "", cursorId: "" },
           payload,
           agent,
           run.turnId
@@ -11816,56 +11921,59 @@ var CompanionSupervisor = class {
   // One turn: the SJ516 F7 / CT26 skip-vs-resume dedupe, the dispatch, then
   // cursor + console summary. Mirrors the old per-workspace `handleEvent`, now
   // scoped to one agent.
-  async runDispatch(wr, ev, payload, agent, recoveredTurnId) {
+  async runDispatch(wr, ids, payload, agent, recoveredTurnId) {
     const workspaceId = wr.workspaceId;
-    if (ev.id && hasDispatched(workspaceId, ev.id)) {
-      if (hasCompleted(workspaceId, ev.id)) {
+    const settleCursor = () => {
+      if (ids.cursorId) wr.cursor.settle(ids.cursorId);
+    };
+    if (ids.dispatchId && hasDispatched(workspaceId, ids.dispatchId)) {
+      if (hasCompleted(workspaceId, ids.dispatchId)) {
         this.log.debug(
-          { workspaceId, eventId: ev.id },
+          { workspaceId, eventId: ids.dispatchId },
           "companion: skipping already-completed event (resume after restart)"
         );
-        wr.cursor.settle(ev.id);
+        settleCursor();
         return;
       }
       if (noResume()) {
         this.log.debug(
-          { workspaceId, eventId: ev.id },
+          { workspaceId, eventId: ids.dispatchId },
           "companion: skipping interrupted turn (CABANE_COMPANION_NO_RESUME=1) \u2014 resume disabled for this boot"
         );
-        markCompleted(workspaceId, ev.id);
-        wr.cursor.settle(ev.id);
+        markCompleted(workspaceId, ids.dispatchId);
+        settleCursor();
         return;
       }
-      const attempt = bumpResumeAttempt(workspaceId, ev.id);
+      const attempt = bumpResumeAttempt(workspaceId, ids.dispatchId);
       if (attempt > MAX_RESUME_ATTEMPTS) {
         this.log.error(
-          { workspaceId, eventId: ev.id, attempt, cap: MAX_RESUME_ATTEMPTS },
+          { workspaceId, eventId: ids.dispatchId, attempt, cap: MAX_RESUME_ATTEMPTS },
           "An interrupted turn couldn't finish after several attempts. Reply in Cabane to try again."
         );
-        markCompleted(workspaceId, ev.id);
-        wr.cursor.settle(ev.id);
+        markCompleted(workspaceId, ids.dispatchId);
+        settleCursor();
         return;
       }
       this.log.debug(
-        { workspaceId, eventId: ev.id, attempt, cap: MAX_RESUME_ATTEMPTS },
+        { workspaceId, eventId: ids.dispatchId, attempt, cap: MAX_RESUME_ATTEMPTS },
         "companion: re-dispatching interrupted turn (resume after restart)"
       );
     }
-    const resumedTurnId = recoveredTurnId ?? (ev.id ? turnIdForEvent(workspaceId, ev.id) : null);
+    const resumedTurnId = recoveredTurnId ?? (ids.dispatchId ? turnIdForEvent(workspaceId, ids.dispatchId) : null);
     const turnId = resumedTurnId ?? randomUUID4();
-    if (ev.id) {
-      const liveTurnIds = rememberTurnId(workspaceId, ev.id, turnId);
+    if (ids.dispatchId) {
+      const liveTurnIds = rememberTurnId(workspaceId, ids.dispatchId, turnId);
       if (liveTurnIds > TURN_ID_OVERFLOW_WARN) {
         this.log.debug(
           { workspaceId, liveTurnIds, threshold: TURN_ID_OVERFLOW_WARN },
           "companion: in-flight turn-id map is implausibly large \u2014 completion pruning is likely broken. Keeping every mapping; dropping one would silently lose a resumable turn."
         );
       }
-      markDispatched(workspaceId, ev.id);
+      markDispatched(workspaceId, ids.dispatchId);
     }
     if (resumedTurnId) {
       this.log.debug(
-        { workspaceId, eventId: ev.id, turnId },
+        { workspaceId, eventId: ids.dispatchId, turnId },
         "companion: resuming an interrupted turn under its original id"
       );
     }
@@ -11880,8 +11988,8 @@ var CompanionSupervisor = class {
       turnId,
       resumed: resumedTurnId !== null
     });
-    if (ev.id) markCompleted(workspaceId, ev.id);
-    if (ev.id) wr.cursor.settle(ev.id);
+    if (ids.dispatchId) markCompleted(workspaceId, ids.dispatchId);
+    settleCursor();
     const durationS = (result.durationMs / 1e3).toFixed(1);
     const bindings = {
       ...turnBindings,

package/dist/runtime.js

@@ -10077,6 +10077,41 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
   }
 }
 
+// src/dispatch-claims.ts
+var DispatchClaims = class {
+  inFlight = /* @__PURE__ */ new Map();
+  releases = /* @__PURE__ */ new Map();
+  // Claim a dispatch id for this process. Synchronous by design: two copies can
+  // arrive in the same tick, and a claim taken after an `await` would let both
+  // through.
+  claim(dispatchId) {
+    const running = this.inFlight.get(dispatchId);
+    if (running) return { first: false, done: running };
+    let release;
+    this.inFlight.set(
+      dispatchId,
+      new Promise((resolve2) => {
+        release = resolve2;
+      })
+    );
+    this.releases.set(dispatchId, release);
+    return { first: true };
+  }
+  // Hand the claim back once the run has finished — whatever its outcome.
+  // Releasing an id that isn't claimed is a no-op.
+  release(dispatchId) {
+    const resolve2 = this.releases.get(dispatchId);
+    if (!resolve2) return;
+    this.releases.delete(dispatchId);
+    this.inFlight.delete(dispatchId);
+    resolve2();
+  }
+  // The live set's size — the concurrent-turn count.
+  get size() {
+    return this.inFlight.size;
+  }
+};
+
 // src/outbox.ts
 import {
   existsSync as existsSync12,
@@ -10423,6 +10458,13 @@ var DRAIN_BASE_MS = 1e3;
 var DRAIN_MAX_MS = 3e4;
 var DRAIN_IDLE_MS = 15e3;
 var DEFAULT_UNRUNNABLE_RETRY_DELAYS_MS = [0, 1e3, 3e3];
+function dispatchPayload(wire) {
+  if (wire.type !== "device:dispatch_requested") return null;
+  return {
+    type: "device:dispatch_requested",
+    ...wire.payload
+  };
+}
 var CompanionSupervisor = class {
   workspaces = /* @__PURE__ */ new Map();
   config;
@@ -10481,6 +10523,9 @@ var CompanionSupervisor = class {
   // turn's classified outcome here (per runtime); the heartbeat echoes it so the
   // server's per-connector quota state survives a restart/race.
   connectorHealth = new ConnectorHealthStore();
+  // ACC10: which dispatches this process is running, so the copy of a frame that
+  // arrives on the other stream doesn't run the turn a second time.
+  claims = new DispatchClaims();
   constructor(opts) {
     this.config = opts.config;
     this.log = opts.log;
@@ -10524,7 +10569,9 @@ var CompanionSupervisor = class {
         if (ev.event === "assignments_changed") {
           if (this.refreshing && this.inFlightRefresh) await this.inFlightRefresh;
           await this.refreshAssignments();
+          return;
         }
+        if (ev.event === "message") await this.handleDeviceMessage(ev);
       },
       onAuthFailure: () => {
         this.log.error(
@@ -11035,17 +11082,75 @@ var CompanionSupervisor = class {
   async handleWorkspaceMessage(wr, ev) {
     if (ev.event !== "message") return;
     this.hub.recordEvent(wr.workspaceId);
-    let wire;
+    const wire = this.parseFrame(ev);
+    if (!wire) return;
+    if (ev.id) wr.cursor.observe(ev.id);
+    await this.deliverFrame(wr, ev.id, wire);
+  }
+  // ACC10: the device stream's frames — dispatch and cancel, addressed to this
+  // device and authenticated as it. Same frames and the same routing as above;
+  // what differs is that this stream keeps no cursor (it replays what is still
+  // offered on every connect instead of resuming from a `Last-Event-ID`), so
+  // nothing here observes or settles one.
+  async handleDeviceMessage(ev) {
+    const wire = this.parseFrame(ev);
+    if (!wire) return;
+    let wr = this.workspaces.get(wire.workspaceId);
+    if (!wr) {
+      if (this.refreshing && this.inFlightRefresh) await this.inFlightRefresh;
+      await this.refreshAssignments();
+      wr = this.workspaces.get(wire.workspaceId);
+      if (!wr) {
+        const payload = dispatchPayload(wire);
+        if (payload && payload.deviceId === this.deviceId) {
+          await this.reportUnrunnableDispatch(wire.workspaceId, payload);
+        } else {
+          this.log.debug(
+            { workspaceId: wire.workspaceId, type: wire.type },
+            "companion: device frame for a workspace this device does not run; ignoring"
+          );
+        }
+        return;
+      }
+    }
+    this.hub.recordEvent(wr.workspaceId);
+    await this.deliverFrame(wr, "", wire);
+  }
+  parseFrame(ev) {
     try {
-      wire = JSON.parse(ev.data);
+      return JSON.parse(ev.data);
     } catch (err) {
       this.log.debug(
         { err: err instanceof Error ? err.message : String(err) },
         "malformed SSE payload"
       );
+      return null;
+    }
+  }
+  // ACC10: the dedupe gate, and the only place that exists because there are two
+  // streams. Both carry the same frame with the same dispatch id; the first copy
+  // to arrive runs the turn, and the second waits for it and then settles its own
+  // stream's cursor. Settling a duplicate earlier than that would advance the
+  // low-water mark past an in-flight turn, which is exactly the CT282 bug.
+  //
+  // A cancel needs no gate: `dispatcher.cancel` on an already-aborted run is a
+  // no-op that reports `false`, so a second copy is inert.
+  async deliverFrame(wr, cursorId, wire) {
+    const claim = wire.type === "device:dispatch_requested" && wire.id ? this.claims.claim(wire.id) : null;
+    if (claim && !claim.first) {
+      await claim.done;
+      if (cursorId) wr.cursor.settle(cursorId);
       return;
     }
-    if (ev.id) wr.cursor.observe(ev.id);
+    try {
+      await this.routeFrame(wr, cursorId, wire);
+    } finally {
+      if (claim) this.claims.release(wire.id);
+    }
+  }
+  // Everything below here is the routing as it was: it takes a frame and knows
+  // nothing about which stream carried it.
+  async routeFrame(wr, cursorId, wire) {
     if (wire.type === "device:cancel_requested") {
       const payload2 = {
         type: "device:cancel_requested",
@@ -11065,17 +11170,14 @@ var CompanionSupervisor = class {
           );
         }
       }
-      if (ev.id) wr.cursor.settle(ev.id);
+      if (cursorId) wr.cursor.settle(cursorId);
       return;
     }
-    if (wire.type !== "device:dispatch_requested") {
-      if (ev.id) wr.cursor.settle(ev.id);
+    const payload = dispatchPayload(wire);
+    if (!payload) {
+      if (cursorId) wr.cursor.settle(cursorId);
       return;
     }
-    const payload = {
-      type: "device:dispatch_requested",
-      ...wire.payload
-    };
     if (this.deviceId && payload.deviceId && payload.deviceId !== this.deviceId) {
       this.log.debug(
         {
@@ -11086,7 +11188,7 @@ var CompanionSupervisor = class {
         },
         "companion: dispatch addressed to another device; ignoring"
       );
-      if (ev.id) wr.cursor.settle(ev.id);
+      if (cursorId) wr.cursor.settle(cursorId);
       return;
     }
     let agent = wr.agents.get(payload.agentId);
@@ -11094,16 +11196,16 @@ var CompanionSupervisor = class {
       agent = await this.recoverRacedAgent(wr, payload);
       if (!agent) {
         if (this.deviceId && payload.deviceId === this.deviceId) {
-          const reported = await this.reportUnrunnableDispatch(wr, payload);
+          const reported = await this.reportUnrunnableDispatch(wr.workspaceId, payload);
           if (!reported) return;
         }
-        if (ev.id) wr.cursor.settle(ev.id);
+        if (cursorId) wr.cursor.settle(cursorId);
         return;
       }
     }
     const chainKey = `${payload.conversationId}|${payload.agentId}`;
     const prev = wr.chains.get(chainKey) ?? Promise.resolve();
-    const tail = prev.then(() => this.runDispatch(wr, ev, payload, agent)).catch((err) => {
+    const tail = prev.then(() => this.runDispatch(wr, { dispatchId: wire.id, cursorId }, payload, agent)).catch((err) => {
       this.log.warn(
         {
           workspaceId: wr.workspaceId,
@@ -11130,7 +11232,7 @@ var CompanionSupervisor = class {
   // dropped socket) and one more attempt a second later usually lands. Bounded
   // hard — this runs inline on the event loop, and an unbounded wait here would
   // wedge the workspace's whole stream.
-  async reportUnrunnableDispatch(wr, payload) {
+  async reportUnrunnableDispatch(workspaceId, payload) {
     if (!this.deviceApi) return false;
     let lastErr;
     for (const wait of this.unrunnableRetryDelaysMs) {
@@ -11138,7 +11240,7 @@ var CompanionSupervisor = class {
       if (wait > 0) await new Promise((r) => setTimeout(r, wait));
       try {
         const { cleared } = await this.deviceApi.reportDispatchDrop({
-          workspaceId: wr.workspaceId,
+          workspaceId,
           conversationId: payload.conversationId,
           agentId: payload.agentId,
           messageId: payload.messageId,
@@ -11146,7 +11248,7 @@ var CompanionSupervisor = class {
         });
         this.log.debug(
           {
-            workspaceId: wr.workspaceId,
+            workspaceId,
             conversationId: payload.conversationId,
             agentId: payload.agentId,
             cleared
@@ -11160,7 +11262,7 @@ var CompanionSupervisor = class {
     }
     this.log.error(
       {
-        workspaceId: wr.workspaceId,
+        workspaceId,
         conversationId: payload.conversationId,
         agentId: payload.agentId,
         err: lastErr instanceof Error ? lastErr.message : String(lastErr)
@@ -11215,7 +11317,10 @@ var CompanionSupervisor = class {
         };
         const tail = this.runDispatch(
           wr,
-          { id: "", event: "recovery", data: "" },
+          // No frame delivered this one — it came off `/runs` — so there is
+          // neither a dispatch id to dedupe on nor a cursor to settle. The
+          // `recoveredTurns` set above is this path's own guard.
+          { dispatchId: "", cursorId: "" },
           payload,
           agent,
           run.turnId
@@ -11239,56 +11344,59 @@ var CompanionSupervisor = class {
   // One turn: the SJ516 F7 / CT26 skip-vs-resume dedupe, the dispatch, then
   // cursor + console summary. Mirrors the old per-workspace `handleEvent`, now
   // scoped to one agent.
-  async runDispatch(wr, ev, payload, agent, recoveredTurnId) {
+  async runDispatch(wr, ids, payload, agent, recoveredTurnId) {
     const workspaceId = wr.workspaceId;
-    if (ev.id && hasDispatched(workspaceId, ev.id)) {
-      if (hasCompleted(workspaceId, ev.id)) {
+    const settleCursor = () => {
+      if (ids.cursorId) wr.cursor.settle(ids.cursorId);
+    };
+    if (ids.dispatchId && hasDispatched(workspaceId, ids.dispatchId)) {
+      if (hasCompleted(workspaceId, ids.dispatchId)) {
         this.log.debug(
-          { workspaceId, eventId: ev.id },
+          { workspaceId, eventId: ids.dispatchId },
           "companion: skipping already-completed event (resume after restart)"
         );
-        wr.cursor.settle(ev.id);
+        settleCursor();
         return;
       }
       if (noResume()) {
         this.log.debug(
-          { workspaceId, eventId: ev.id },
+          { workspaceId, eventId: ids.dispatchId },
           "companion: skipping interrupted turn (CABANE_COMPANION_NO_RESUME=1) \u2014 resume disabled for this boot"
         );
-        markCompleted(workspaceId, ev.id);
-        wr.cursor.settle(ev.id);
+        markCompleted(workspaceId, ids.dispatchId);
+        settleCursor();
         return;
       }
-      const attempt = bumpResumeAttempt(workspaceId, ev.id);
+      const attempt = bumpResumeAttempt(workspaceId, ids.dispatchId);
       if (attempt > MAX_RESUME_ATTEMPTS) {
         this.log.error(
-          { workspaceId, eventId: ev.id, attempt, cap: MAX_RESUME_ATTEMPTS },
+          { workspaceId, eventId: ids.dispatchId, attempt, cap: MAX_RESUME_ATTEMPTS },
           "An interrupted turn couldn't finish after several attempts. Reply in Cabane to try again."
         );
-        markCompleted(workspaceId, ev.id);
-        wr.cursor.settle(ev.id);
+        markCompleted(workspaceId, ids.dispatchId);
+        settleCursor();
         return;
       }
       this.log.debug(
-        { workspaceId, eventId: ev.id, attempt, cap: MAX_RESUME_ATTEMPTS },
+        { workspaceId, eventId: ids.dispatchId, attempt, cap: MAX_RESUME_ATTEMPTS },
         "companion: re-dispatching interrupted turn (resume after restart)"
       );
     }
-    const resumedTurnId = recoveredTurnId ?? (ev.id ? turnIdForEvent(workspaceId, ev.id) : null);
+    const resumedTurnId = recoveredTurnId ?? (ids.dispatchId ? turnIdForEvent(workspaceId, ids.dispatchId) : null);
     const turnId = resumedTurnId ?? randomUUID4();
-    if (ev.id) {
-      const liveTurnIds = rememberTurnId(workspaceId, ev.id, turnId);
+    if (ids.dispatchId) {
+      const liveTurnIds = rememberTurnId(workspaceId, ids.dispatchId, turnId);
       if (liveTurnIds > TURN_ID_OVERFLOW_WARN) {
         this.log.debug(
           { workspaceId, liveTurnIds, threshold: TURN_ID_OVERFLOW_WARN },
           "companion: in-flight turn-id map is implausibly large \u2014 completion pruning is likely broken. Keeping every mapping; dropping one would silently lose a resumable turn."
         );
       }
-      markDispatched(workspaceId, ev.id);
+      markDispatched(workspaceId, ids.dispatchId);
     }
     if (resumedTurnId) {
       this.log.debug(
-        { workspaceId, eventId: ev.id, turnId },
+        { workspaceId, eventId: ids.dispatchId, turnId },
         "companion: resuming an interrupted turn under its original id"
       );
     }
@@ -11303,8 +11411,8 @@ var CompanionSupervisor = class {
       turnId,
       resumed: resumedTurnId !== null
     });
-    if (ev.id) markCompleted(workspaceId, ev.id);
-    if (ev.id) wr.cursor.settle(ev.id);
+    if (ids.dispatchId) markCompleted(workspaceId, ids.dispatchId);
+    settleCursor();
     const durationS = (result.durationMs / 1e3).toFixed(1);
     const bindings = {
       ...turnBindings,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.112",
+  "version": "0.6.113",
   "type": "module",
   "description": "The Cabane Companion (headless): connect a coding agent on your machine to your Cabane workspace as a responder — drive work against your own codebase, files, and MCP servers without putting any of it in Cabane.",
   "license": "UNLICENSED",