@cabane/companion 0.6.87 → 0.6.89

package/dist/cli.js

@@ -2457,10 +2457,22 @@ var CabaneApi = class {
   // token whose turn has ended. The dispatcher mints it before this call and
   // reuses the same value on its active-run PATCH, so the token's turn id and the
   // pair's `active_turn_id` agree.
-  getTurnContext(conversationId, messageId2, turnId) {
-    const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "");
+  // CT1380: `resumed` says this dispatch is a REPLAY of an interrupted turn, so
+  // the server should hand back `turnSeqFloor` — the turn's committed seq
+  // high-water mark. Only the supervisor knows (it minted the id or recovered
+  // it), so it is passed down rather than inferred here. It gates the COST of
+  // the aggregate, never the tenancy scoping, which the route applies
+  // unconditionally.
+  getTurnContext(conversationId, messageId2, turnId, resumed) {
+    const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "") + (resumed ? "&resumed=1" : "");
     return this.request("GET", `/api/agent/turn-context?${q}`);
   }
+  // CT1380: the local half of a resumed turn's seq floor (see
+  // `Outbox.maxSeqForTurn`). 0 when no outbox is configured — a one-shot CLI or
+  // test has no durable queue, so nothing can be hiding in it.
+  outboxMaxSeqForTurn(turnId) {
+    return this.opts.outbox?.maxSeqForTurn(turnId) ?? 0;
+  }
   // CT714: read a turn's recorded turn-control intent. An EXTERNAL adapter
   // (Codex / opencode) records `reply_to` / `skip_turn` into `turn_intents`
   // server-side (the URL MCP surface) rather than the dispatcher's in-memory
@@ -2647,6 +2659,35 @@ var CabaneApi = class {
       signal
     );
   }
+  // CT1357: post ONE ordinary addressed message — not turn speech, no `turnId`
+  // — so `dispatch` is honoured and the target agent is woken. The turn-commit
+  // fork ignores `dispatch` (an act rides its own call now), which leaves this
+  // as the only way a companion can address a peer OUTSIDE a running turn.
+  //
+  // The prepare-failure handback is exactly that case and the reason this
+  // exists. It fires before the turn is ever admitted — the active-run PATCH
+  // that admits it comes after the prepare hook — so `turnAct` is not available:
+  // its route resolves the turn first and 404s when there is none. The failure
+  // notice's own commit is what admits the turn, and by then it has also settled
+  // it. An ordinary addressed post depends on no lease at all, which is what
+  // makes it the right shape here.
+  //
+  // Retried like any durable write, and therefore REQUIRING `idempotencyKey`:
+  // this is not outbox-queued (there is no `(turnId, seq)` for a non-turn row),
+  // so without a key a committed request whose response was lost — or a
+  // redelivered dispatch event — writes a second row and wakes the peer twice.
+  // The server dedupes on `(conversation_id, idempotency_key)`: the repeat
+  // returns the existing row and raises no second dispatch (CT239). Required,
+  // not optional, so a future caller cannot omit it and silently lose the
+  // guarantee.
+  postAddressedMessage(workspaceId, conversationId, body, signal) {
+    return this.request(
+      "POST",
+      `/api/workspaces/${workspaceId}/conversations/${conversationId}/messages`,
+      body,
+      signal ? { retry: true, signal } : { retry: true }
+    );
+  }
   // SJ477: report one tool-activity transition (start / done / error) for the
   // live activity cards. Transient — the server publishes an `agent_activity`
   // SSE and writes no row. Agent-PAT authed; the URL `:agentId` must match the
@@ -7938,6 +7979,39 @@ async function writeCodexInstructionsFile(contents) {
   };
 }
 
+// src/turn-seq-floor.ts
+var SeqFloorUnavailable = class extends Error {
+  constructor(detail) {
+    super(`seq_floor_unavailable: ${detail}`);
+    this.detail = detail;
+    this.name = "SeqFloorUnavailable";
+  }
+  detail;
+};
+function resolveSeqFloor(sources, ctx) {
+  const { serverFloor, outboxFloor } = sources;
+  if (serverFloor === void 0) {
+    throw new SeqFloorUnavailable("server sent no committed floor for a resumed turn");
+  }
+  const floor = Math.max(serverFloor, outboxFloor);
+  ctx.log.info(
+    { turnId: ctx.turnId, floor, outboxFloor, serverFloor },
+    "companion: resumed turn \u2014 seq counter seeded above its committed high-water mark"
+  );
+  return floor;
+}
+function readOutboxFloor(read, turnId, log) {
+  try {
+    return read(turnId);
+  } catch (err) {
+    log.error(
+      { turnId, err: err instanceof Error ? err.message : String(err) },
+      "companion: the on-disk outbox floor is unreadable; refusing to resume"
+    );
+    throw new SeqFloorUnavailable("outbox unreadable");
+  }
+}
+
 // src/prepared.ts
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, rmSync as rmSync5, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
 import { join as join11 } from "path";
@@ -8388,6 +8462,7 @@ var TurnExecution = class {
     this.opts = opts;
     this.supervisor = supervisor;
     this.payload = payload;
+    this.resumed = handleOpts.resumed === true;
     this.dispatchId = payload.messageId;
     this.workspaceId = opts.workspaceId;
     this.turnLog = opts.log.child({
@@ -8410,7 +8485,13 @@ var TurnExecution = class {
   outcome = initialOutcome();
   seqCounter = 0;
   // CT11: per-turn monotonic counter mirroring the in-process dispatcher's.
+  //
+  // CT1380: 0 for a NEW turn only — a resume is seeded in `fetchContext` first.
   nextSeq = () => ++this.seqCounter;
+  // CT1380: a REPLAY, told to us by the supervisor — not derivable here, since
+  // `turnId` is set on every dispatch. `resumedFromSeq` is what it seeded from.
+  resumed;
+  resumedFromSeq;
   turnContext;
   resolvedMcpServers;
   effectiveCwd;
@@ -8456,6 +8537,10 @@ var TurnExecution = class {
       await this.acquireLease();
       await this.selectAdapter();
     } catch (err) {
+      if (err instanceof SeqFloorUnavailable) {
+        this.supervisor.releaseAbort(this.turnId, this.abortController);
+        return this.concludeBeforeRun(err.message, err.message);
+      }
       if (err instanceof TurnConcluded) {
         this.supervisor.releaseAbort(this.turnId, this.abortController);
         return this.admitted ? this.concludeAdmittedRun(err.reason, err.errorReason) : this.concludeBeforeRun(err.reason, err.errorReason);
@@ -8534,12 +8619,14 @@ var TurnExecution = class {
   }
   async fetchContext() {
     const { payload, turnId, turnLog } = this;
+    const outboxFloor = this.resumed ? readOutboxFloor((id) => this.opts.api.outboxMaxSeqForTurn(id), turnId, turnLog) : 0;
     let turnContext;
     try {
       turnContext = await this.opts.api.getTurnContext(
         payload.conversationId,
         payload.messageId,
-        turnId
+        turnId,
+        this.resumed
       );
     } catch (err) {
       const status2 = err instanceof ApiError ? err.status : 0;
@@ -8556,6 +8643,11 @@ var TurnExecution = class {
       throw this.concluded(fetchReason, fetchReason);
     }
     this.turnContext = turnContext;
+    if (this.resumed) {
+      const sources = { serverFloor: turnContext.turnSeqFloor, outboxFloor };
+      this.resumedFromSeq = resolveSeqFloor(sources, { turnId, log: turnLog });
+      this.seqCounter = Math.max(this.seqCounter, this.resumedFromSeq);
+    }
   }
   gateTrigger() {
     const { payload, turnLog } = this;
@@ -8617,12 +8709,31 @@ var TurnExecution = class {
     }
     let hookEnv;
     const triggerIsPrepareFailure = this.turnContext.message.body.startsWith(PREPARE_FAILED_PREFIX);
-    const prepareFailureDispatch = this.turnContext.dispatchedByAgentId && !triggerIsPrepareFailure ? {
-      dispatch: this.turnContext.dispatchedByAgentId,
-      dispatchBody: `${PREPARE_FAILED_PREFIX}
+    const sendPrepareFailureHandback = async () => {
+      if (!this.turnContext.dispatchedByAgentId || triggerIsPrepareFailure) return;
+      try {
+        await this.opts.api.postAddressedMessage(workspaceId, payload.conversationId, {
+          body: `${PREPARE_FAILED_PREFIX}
 
-The dispatched turn could not start. Re-dispatch it after repairing the preparation failure shown in this conversation.`
-    } : {};
+The dispatched turn could not start. Re-dispatch it after repairing the preparation failure shown in this conversation.`,
+          dispatch: this.turnContext.dispatchedByAgentId,
+          // Keyed on the TRIGGER, not the turn: a redelivered dispatch event is
+          // the replay this has to survive, and it mints a fresh `turnId` while
+          // carrying the same `messageId`. One handback per failed pickup of a
+          // given trigger — which is also CT992's rule, that the first failure
+          // is the one carrying information. A genuine re-dispatch after a
+          // repair authors a NEW trigger message, so it keys differently and
+          // hands back again.
+          idempotencyKey: `prepare-failure-handback:${payload.messageId}`,
+          parentMessageId: payload.messageId
+        });
+      } catch (err) {
+        turnLog.warn(
+          { err: err instanceof Error ? err.message : String(err) },
+          "dispatcher: prepare-failure handback failed"
+        );
+      }
+    };
     if (prepareHook) {
       let cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
       if (cached2 && !checkoutState(cached2.cwd).ok) {
@@ -8661,8 +8772,7 @@ The dispatched turn could not start. Re-dispatch it after repairing the preparat
 ${reason}`,
                 kind: "final",
                 turnId,
-                parentMessageId: payload.messageId,
-                ...prepareFailureDispatch
+                parentMessageId: payload.messageId
               });
             } catch (postErr) {
               turnLog.warn(
@@ -8670,6 +8780,7 @@ ${reason}`,
                 "dispatcher: prepare-rejection post failed"
               );
             }
+            await sendPrepareFailureHandback();
             throw this.concluded(`prepare_failed: ${reason}`);
           }
         }
@@ -8737,8 +8848,7 @@ ${reason}`,
               kind: "final",
               turnId,
               // CT113: stamp the parent even on the prepare-failed close.
-              parentMessageId: payload.messageId,
-              ...prepareFailureDispatch
+              parentMessageId: payload.messageId
             });
           } catch (postErr) {
             turnLog.warn(
@@ -8746,6 +8856,7 @@ ${reason}`,
               "dispatcher: prepare-failure post failed"
             );
           }
+          await sendPrepareFailureHandback();
           const failReason = `prepare_failed: ${reason}`;
           throw this.concluded(failReason);
         }
@@ -8767,6 +8878,8 @@ ${reason}`,
     try {
       await this.opts.api.setActiveRun(workspaceId, payload.conversationId, payload.agentId, {
         activeRunStartedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        // CT1380: the durable record that this turn resumed, and from where.
+        ...this.resumedFromSeq !== void 0 ? { resumedFromSeq: this.resumedFromSeq } : {},
         // CT33: hand the server this turn's id so the new-run chokepoint's
         // `closeAbandonedTurns` sweep excludes it. The prepare hook may have
         // already emitted a "preparing" activity row for this turn above (it
@@ -9515,6 +9628,35 @@ var Outbox = class {
     );
     return entries;
   }
+  // CT1380: the highest `seq` this turn has queued but not yet delivered — the
+  // half of a resumed turn's seq floor the SERVER CANNOT SEE. A commit that
+  // failed transiently before the crash is sitting in this directory with its
+  // seq already spent, and the restart's drain is fire-and-forget
+  // (`drain.kick()`, never awaited), so `maxSeqForTurn` on the server can report
+  // below it and the resumed run would mint that number a second time.
+  //
+  // Reads the directory rather than `list()` because only the filename matters:
+  // `<turnId>__<seq>.json` carries both halves of the key, so a corrupt body
+  // can't hide a spent seq from the floor. Returns 0 for a turn with nothing
+  // queued, which is the overwhelmingly common case.
+  // THROWS rather than returning 0 when the directory exists but cannot be
+  // read. 0 is a claim ("this turn has nothing queued"), and an unreadable
+  // directory cannot support it — a queued entry holding seq N would be
+  // invisible and the resumed run would mint N again. A missing directory is
+  // different: it is positive evidence that nothing was ever queued here.
+  maxSeqForTurn(turnId) {
+    const dir2 = this.dir();
+    if (!existsSync12(dir2)) return 0;
+    const names = readdirSync3(dir2);
+    const prefix = `${encodeURIComponent(turnId)}__`;
+    let max = 0;
+    for (const name of names) {
+      if (!name.startsWith(prefix) || !name.endsWith(".json")) continue;
+      const seq = Number(name.slice(prefix.length, -".json".length));
+      if (Number.isInteger(seq) && seq > max) max = seq;
+    }
+    return max;
+  }
   // Remove a delivered (or terminally-discarded) entry. No-op if already gone.
   remove(turnId, seq) {
     try {
@@ -10431,7 +10573,10 @@ var CompanionSupervisor = class {
         "companion: resuming an interrupted turn under its original id"
       );
     }
-    const result = await agent.dispatcher.handle(payload, { turnId });
+    const result = await agent.dispatcher.handle(payload, {
+      turnId,
+      resumed: resumedTurnId !== null
+    });
     if (ev.id) markCompleted(workspaceId, ev.id);
     if (ev.id) wr.cursor.settle(ev.id);
     const durationS = (result.durationMs / 1e3).toFixed(1);

package/dist/runtime.js

@@ -1875,10 +1875,22 @@ var CabaneApi = class {
   // token whose turn has ended. The dispatcher mints it before this call and
   // reuses the same value on its active-run PATCH, so the token's turn id and the
   // pair's `active_turn_id` agree.
-  getTurnContext(conversationId, messageId2, turnId) {
-    const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "");
+  // CT1380: `resumed` says this dispatch is a REPLAY of an interrupted turn, so
+  // the server should hand back `turnSeqFloor` — the turn's committed seq
+  // high-water mark. Only the supervisor knows (it minted the id or recovered
+  // it), so it is passed down rather than inferred here. It gates the COST of
+  // the aggregate, never the tenancy scoping, which the route applies
+  // unconditionally.
+  getTurnContext(conversationId, messageId2, turnId, resumed) {
+    const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "") + (resumed ? "&resumed=1" : "");
     return this.request("GET", `/api/agent/turn-context?${q}`);
   }
+  // CT1380: the local half of a resumed turn's seq floor (see
+  // `Outbox.maxSeqForTurn`). 0 when no outbox is configured — a one-shot CLI or
+  // test has no durable queue, so nothing can be hiding in it.
+  outboxMaxSeqForTurn(turnId) {
+    return this.opts.outbox?.maxSeqForTurn(turnId) ?? 0;
+  }
   // CT714: read a turn's recorded turn-control intent. An EXTERNAL adapter
   // (Codex / opencode) records `reply_to` / `skip_turn` into `turn_intents`
   // server-side (the URL MCP surface) rather than the dispatcher's in-memory
@@ -2065,6 +2077,35 @@ var CabaneApi = class {
       signal
     );
   }
+  // CT1357: post ONE ordinary addressed message — not turn speech, no `turnId`
+  // — so `dispatch` is honoured and the target agent is woken. The turn-commit
+  // fork ignores `dispatch` (an act rides its own call now), which leaves this
+  // as the only way a companion can address a peer OUTSIDE a running turn.
+  //
+  // The prepare-failure handback is exactly that case and the reason this
+  // exists. It fires before the turn is ever admitted — the active-run PATCH
+  // that admits it comes after the prepare hook — so `turnAct` is not available:
+  // its route resolves the turn first and 404s when there is none. The failure
+  // notice's own commit is what admits the turn, and by then it has also settled
+  // it. An ordinary addressed post depends on no lease at all, which is what
+  // makes it the right shape here.
+  //
+  // Retried like any durable write, and therefore REQUIRING `idempotencyKey`:
+  // this is not outbox-queued (there is no `(turnId, seq)` for a non-turn row),
+  // so without a key a committed request whose response was lost — or a
+  // redelivered dispatch event — writes a second row and wakes the peer twice.
+  // The server dedupes on `(conversation_id, idempotency_key)`: the repeat
+  // returns the existing row and raises no second dispatch (CT239). Required,
+  // not optional, so a future caller cannot omit it and silently lose the
+  // guarantee.
+  postAddressedMessage(workspaceId, conversationId, body, signal) {
+    return this.request(
+      "POST",
+      `/api/workspaces/${workspaceId}/conversations/${conversationId}/messages`,
+      body,
+      signal ? { retry: true, signal } : { retry: true }
+    );
+  }
   // SJ477: report one tool-activity transition (start / done / error) for the
   // live activity cards. Transient — the server publishes an `agent_activity`
   // SSE and writes no row. Agent-PAT authed; the URL `:agentId` must match the
@@ -7435,6 +7476,39 @@ async function writeCodexInstructionsFile(contents) {
   };
 }
 
+// src/turn-seq-floor.ts
+var SeqFloorUnavailable = class extends Error {
+  constructor(detail) {
+    super(`seq_floor_unavailable: ${detail}`);
+    this.detail = detail;
+    this.name = "SeqFloorUnavailable";
+  }
+  detail;
+};
+function resolveSeqFloor(sources, ctx) {
+  const { serverFloor, outboxFloor } = sources;
+  if (serverFloor === void 0) {
+    throw new SeqFloorUnavailable("server sent no committed floor for a resumed turn");
+  }
+  const floor = Math.max(serverFloor, outboxFloor);
+  ctx.log.info(
+    { turnId: ctx.turnId, floor, outboxFloor, serverFloor },
+    "companion: resumed turn \u2014 seq counter seeded above its committed high-water mark"
+  );
+  return floor;
+}
+function readOutboxFloor(read, turnId, log) {
+  try {
+    return read(turnId);
+  } catch (err) {
+    log.error(
+      { turnId, err: err instanceof Error ? err.message : String(err) },
+      "companion: the on-disk outbox floor is unreadable; refusing to resume"
+    );
+    throw new SeqFloorUnavailable("outbox unreadable");
+  }
+}
+
 // src/prepared.ts
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync6, rmSync as rmSync5, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
 import { join as join11 } from "path";
@@ -7885,6 +7959,7 @@ var TurnExecution = class {
     this.opts = opts;
     this.supervisor = supervisor;
     this.payload = payload;
+    this.resumed = handleOpts.resumed === true;
     this.dispatchId = payload.messageId;
     this.workspaceId = opts.workspaceId;
     this.turnLog = opts.log.child({
@@ -7907,7 +7982,13 @@ var TurnExecution = class {
   outcome = initialOutcome();
   seqCounter = 0;
   // CT11: per-turn monotonic counter mirroring the in-process dispatcher's.
+  //
+  // CT1380: 0 for a NEW turn only — a resume is seeded in `fetchContext` first.
   nextSeq = () => ++this.seqCounter;
+  // CT1380: a REPLAY, told to us by the supervisor — not derivable here, since
+  // `turnId` is set on every dispatch. `resumedFromSeq` is what it seeded from.
+  resumed;
+  resumedFromSeq;
   turnContext;
   resolvedMcpServers;
   effectiveCwd;
@@ -7953,6 +8034,10 @@ var TurnExecution = class {
       await this.acquireLease();
       await this.selectAdapter();
     } catch (err) {
+      if (err instanceof SeqFloorUnavailable) {
+        this.supervisor.releaseAbort(this.turnId, this.abortController);
+        return this.concludeBeforeRun(err.message, err.message);
+      }
       if (err instanceof TurnConcluded) {
         this.supervisor.releaseAbort(this.turnId, this.abortController);
         return this.admitted ? this.concludeAdmittedRun(err.reason, err.errorReason) : this.concludeBeforeRun(err.reason, err.errorReason);
@@ -8031,12 +8116,14 @@ var TurnExecution = class {
   }
   async fetchContext() {
     const { payload, turnId, turnLog } = this;
+    const outboxFloor = this.resumed ? readOutboxFloor((id) => this.opts.api.outboxMaxSeqForTurn(id), turnId, turnLog) : 0;
     let turnContext;
     try {
       turnContext = await this.opts.api.getTurnContext(
         payload.conversationId,
         payload.messageId,
-        turnId
+        turnId,
+        this.resumed
       );
     } catch (err) {
       const status = err instanceof ApiError ? err.status : 0;
@@ -8053,6 +8140,11 @@ var TurnExecution = class {
       throw this.concluded(fetchReason, fetchReason);
     }
     this.turnContext = turnContext;
+    if (this.resumed) {
+      const sources = { serverFloor: turnContext.turnSeqFloor, outboxFloor };
+      this.resumedFromSeq = resolveSeqFloor(sources, { turnId, log: turnLog });
+      this.seqCounter = Math.max(this.seqCounter, this.resumedFromSeq);
+    }
   }
   gateTrigger() {
     const { payload, turnLog } = this;
@@ -8114,12 +8206,31 @@ var TurnExecution = class {
     }
     let hookEnv;
     const triggerIsPrepareFailure = this.turnContext.message.body.startsWith(PREPARE_FAILED_PREFIX);
-    const prepareFailureDispatch = this.turnContext.dispatchedByAgentId && !triggerIsPrepareFailure ? {
-      dispatch: this.turnContext.dispatchedByAgentId,
-      dispatchBody: `${PREPARE_FAILED_PREFIX}
+    const sendPrepareFailureHandback = async () => {
+      if (!this.turnContext.dispatchedByAgentId || triggerIsPrepareFailure) return;
+      try {
+        await this.opts.api.postAddressedMessage(workspaceId, payload.conversationId, {
+          body: `${PREPARE_FAILED_PREFIX}
 
-The dispatched turn could not start. Re-dispatch it after repairing the preparation failure shown in this conversation.`
-    } : {};
+The dispatched turn could not start. Re-dispatch it after repairing the preparation failure shown in this conversation.`,
+          dispatch: this.turnContext.dispatchedByAgentId,
+          // Keyed on the TRIGGER, not the turn: a redelivered dispatch event is
+          // the replay this has to survive, and it mints a fresh `turnId` while
+          // carrying the same `messageId`. One handback per failed pickup of a
+          // given trigger — which is also CT992's rule, that the first failure
+          // is the one carrying information. A genuine re-dispatch after a
+          // repair authors a NEW trigger message, so it keys differently and
+          // hands back again.
+          idempotencyKey: `prepare-failure-handback:${payload.messageId}`,
+          parentMessageId: payload.messageId
+        });
+      } catch (err) {
+        turnLog.warn(
+          { err: err instanceof Error ? err.message : String(err) },
+          "dispatcher: prepare-failure handback failed"
+        );
+      }
+    };
     if (prepareHook) {
       let cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
       if (cached2 && !checkoutState(cached2.cwd).ok) {
@@ -8158,8 +8269,7 @@ The dispatched turn could not start. Re-dispatch it after repairing the preparat
 ${reason}`,
                 kind: "final",
                 turnId,
-                parentMessageId: payload.messageId,
-                ...prepareFailureDispatch
+                parentMessageId: payload.messageId
               });
             } catch (postErr) {
               turnLog.warn(
@@ -8167,6 +8277,7 @@ ${reason}`,
                 "dispatcher: prepare-rejection post failed"
               );
             }
+            await sendPrepareFailureHandback();
             throw this.concluded(`prepare_failed: ${reason}`);
           }
         }
@@ -8234,8 +8345,7 @@ ${reason}`,
               kind: "final",
               turnId,
               // CT113: stamp the parent even on the prepare-failed close.
-              parentMessageId: payload.messageId,
-              ...prepareFailureDispatch
+              parentMessageId: payload.messageId
             });
           } catch (postErr) {
             turnLog.warn(
@@ -8243,6 +8353,7 @@ ${reason}`,
               "dispatcher: prepare-failure post failed"
             );
           }
+          await sendPrepareFailureHandback();
           const failReason = `prepare_failed: ${reason}`;
           throw this.concluded(failReason);
         }
@@ -8264,6 +8375,8 @@ ${reason}`,
     try {
       await this.opts.api.setActiveRun(workspaceId, payload.conversationId, payload.agentId, {
         activeRunStartedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        // CT1380: the durable record that this turn resumed, and from where.
+        ...this.resumedFromSeq !== void 0 ? { resumedFromSeq: this.resumedFromSeq } : {},
         // CT33: hand the server this turn's id so the new-run chokepoint's
         // `closeAbandonedTurns` sweep excludes it. The prepare hook may have
         // already emitted a "preparing" activity row for this turn above (it
@@ -9012,6 +9125,35 @@ var Outbox = class {
     );
     return entries;
   }
+  // CT1380: the highest `seq` this turn has queued but not yet delivered — the
+  // half of a resumed turn's seq floor the SERVER CANNOT SEE. A commit that
+  // failed transiently before the crash is sitting in this directory with its
+  // seq already spent, and the restart's drain is fire-and-forget
+  // (`drain.kick()`, never awaited), so `maxSeqForTurn` on the server can report
+  // below it and the resumed run would mint that number a second time.
+  //
+  // Reads the directory rather than `list()` because only the filename matters:
+  // `<turnId>__<seq>.json` carries both halves of the key, so a corrupt body
+  // can't hide a spent seq from the floor. Returns 0 for a turn with nothing
+  // queued, which is the overwhelmingly common case.
+  // THROWS rather than returning 0 when the directory exists but cannot be
+  // read. 0 is a claim ("this turn has nothing queued"), and an unreadable
+  // directory cannot support it — a queued entry holding seq N would be
+  // invisible and the resumed run would mint N again. A missing directory is
+  // different: it is positive evidence that nothing was ever queued here.
+  maxSeqForTurn(turnId) {
+    const dir2 = this.dir();
+    if (!existsSync12(dir2)) return 0;
+    const names = readdirSync3(dir2);
+    const prefix = `${encodeURIComponent(turnId)}__`;
+    let max = 0;
+    for (const name of names) {
+      if (!name.startsWith(prefix) || !name.endsWith(".json")) continue;
+      const seq = Number(name.slice(prefix.length, -".json".length));
+      if (Number.isInteger(seq) && seq > max) max = seq;
+    }
+    return max;
+  }
   // Remove a delivered (or terminally-discarded) entry. No-op if already gone.
   remove(turnId, seq) {
     try {
@@ -9928,7 +10070,10 @@ var CompanionSupervisor = class {
         "companion: resuming an interrupted turn under its original id"
       );
     }
-    const result = await agent.dispatcher.handle(payload, { turnId });
+    const result = await agent.dispatcher.handle(payload, {
+      turnId,
+      resumed: resumedTurnId !== null
+    });
     if (ev.id) markCompleted(workspaceId, ev.id);
     if (ev.id) wr.cursor.settle(ev.id);
     const durationS = (result.durationMs / 1e3).toFixed(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.87",
+  "version": "0.6.89",
   "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",