@cabane/companion 0.6.194 → 0.6.196

package/dist/cli.js

@@ -7214,6 +7214,20 @@ async function reapTurnScopes(turnId) {
     return classifyStopError(message2) === "absent" ? { failures: [] } : { failures: [message2.slice(0, 200)] };
   }
 }
+async function turnScopeOomKilled(turnId) {
+  if (process.platform !== "linux") return false;
+  const safe2 = turnId.replace(/[^A-Za-z0-9_.-]/g, "-");
+  try {
+    const { stdout } = await execFileAsync(
+      "systemctl",
+      ["--user", "show", "--property=Result", "--value", `*-turn-${safe2}-*.scope`],
+      { timeout: OOM_READ_TIMEOUT_MS }
+    );
+    return String(stdout).split("\n").some((line) => line.trim() === "oom-kill");
+  } catch {
+    return false;
+  }
+}
 function scopeCapabilityUsable(env, timeoutMs = CAPABILITY_PROBE_TIMEOUT_MS) {
   if (process.platform !== "linux") return false;
   try {
@@ -7462,7 +7476,7 @@ function createTurnContainment(turnId, deps = {}) {
     }
   };
 }
-var execFileAsync, asContained, CONTAINMENT_STOP_GRACE_SEC, FALLBACK_GRACE_MS, CAPABILITY_PROBE_TIMEOUT_MS, sleep2, MANAGER_ENV_KEYS, managerEnvKey;
+var execFileAsync, asContained, CONTAINMENT_STOP_GRACE_SEC, FALLBACK_GRACE_MS, CAPABILITY_PROBE_TIMEOUT_MS, OOM_READ_TIMEOUT_MS, sleep2, MANAGER_ENV_KEYS, managerEnvKey;
 var init_turn_containment = __esm({
   "src/turn-containment.ts"() {
     "use strict";
@@ -7471,6 +7485,7 @@ var init_turn_containment = __esm({
     CONTAINMENT_STOP_GRACE_SEC = 5;
     FALLBACK_GRACE_MS = CONTAINMENT_STOP_GRACE_SEC * 1e3;
     CAPABILITY_PROBE_TIMEOUT_MS = 4e3;
+    OOM_READ_TIMEOUT_MS = 1500;
     sleep2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
     MANAGER_ENV_KEYS = ["DBUS_SESSION_BUS_ADDRESS", "XDG_RUNTIME_DIR", "PATH"];
     managerEnvKey = (env) => MANAGER_ENV_KEYS.map((k) => `${k}=${env[k] ?? ""}`).join("\0");
@@ -7850,6 +7865,7 @@ async function settleUnstarted(opts, payload, turnId, errorReason, log2) {
 async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   const startedAt = Date.now();
   const { turnId } = handleOpts;
+  const oomKilled = (id) => (launch.oomKilled ?? turnScopeOomKilled)(id).catch(() => false);
   const log2 = opts.log.child({
     workspaceId: opts.workspaceId,
     conversationId: payload.conversationId,
@@ -7860,7 +7876,15 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   duties.registerAbort(turnId, controller);
   const stopRunner = new AbortController();
   let ready = false;
+  let child;
+  let stopAnnounced = false;
+  const announceStop = () => {
+    if (stopAnnounced || !child?.stdin.writable) return;
+    stopAnnounced = true;
+    child.stdin.write(encodeLauncherMessage({ cabaneLauncher: "stop" }));
+  };
   const forwardStop = () => {
+    announceStop();
     if (ready) stopRunner.abort();
   };
   controller.signal.addEventListener("abort", forwardStop, { once: true });
@@ -7883,7 +7907,6 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   let thrown;
   let code;
   let handle;
-  let child;
   const groups = [];
   const remote = [];
   const lockOwner = (id) => `${turnId}#${id}`;
@@ -7931,6 +7954,7 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
       stdin: runnerStdin(input)
     });
     child = running;
+    if (controller.signal.aborted) announceStop();
     log2.debug(
       { turnId, runnerPid: running.pid, provider: launch.provider.name },
       "runner: started"
@@ -7996,6 +8020,18 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
         case "remote_session":
           remote.push({ serverUrl: event.serverUrl, sessionId: event.sessionId });
           return;
+        case "terminated":
+          void oomKilled(turnId).then((oom) => {
+            if (running.stdin.writable) {
+              running.stdin.write(
+                encodeLauncherMessage({
+                  cabaneLauncher: "cause",
+                  cause: oom ? "out_of_memory" : null
+                })
+              );
+            }
+          });
+          return;
       }
     });
     const stderrDone = lines(running.stderr, (line) => relayRunnerLog(line, opts.log));
@@ -8013,7 +8049,7 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   if (result) return result;
   const durationMs = Date.now() - startedAt;
   const stopped = controller.signal.aborted && thrown === void 0;
-  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : `runner_exited: ${code}`;
+  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : await oomKilled(turnId) ? "out_of_memory" : `runner_exited: ${code}`;
   await child?.reap(groups);
   const reaped = await (launch.reapTurn ?? reapTurnScopes)(turnId).catch((err) => ({
     failures: [err instanceof Error ? err.message : String(err)]
@@ -9296,7 +9332,7 @@ function fingerprintSessionState(state) {
   }
   return createHash2("sha256").update(opaqueId).digest("hex").slice(0, 16);
 }
-var PREPARING_TOOL_NAME, HARNESS_UNAVAILABLE_NOTICE, NO_TURN_TOKEN_REASON, UNEXPECTED_ROLE_REASON, DEFAULT_PREPARING_ROW_DELAY_MS, DEFAULT_AGENT_IDLE_TIMEOUT_MS, DEFAULT_AGENT_TOTAL_TIMEOUT_MS, DEFAULT_LEASE_RENEWAL_MS, TurnConcluded, TurnExecution;
+var PREPARING_TOOL_NAME, HARNESS_UNAVAILABLE_NOTICE, NO_TURN_TOKEN_REASON, UNEXPECTED_ROLE_REASON, DEFAULT_PREPARING_ROW_DELAY_MS, DEFAULT_AGENT_IDLE_TIMEOUT_MS, DEFAULT_AGENT_TOTAL_TIMEOUT_MS, DEFAULT_LEASE_RENEWAL_MS, TurnConcluded, RUNNER_SIGTERM, RUNNER_TERMINATED, TurnExecution;
 var init_turn_execution = __esm({
   "src/turn-execution.ts"() {
     "use strict";
@@ -9342,6 +9378,8 @@ var init_turn_execution = __esm({
       reason;
       errorReason;
     };
+    RUNNER_SIGTERM = "runner_sigterm";
+    RUNNER_TERMINATED = "runner_terminated";
     TurnExecution = class {
       constructor(opts, supervisor, payload, handleOpts = {}) {
         this.opts = opts;
@@ -9451,6 +9489,16 @@ var init_turn_execution = __esm({
       concluded(reason, errorReason) {
         return new TurnConcluded(reason, errorReason);
       }
+      // A SIGTERM the launcher never announced as a Stop.
+      terminatedFromOutside() {
+        const { signal } = this.abortController;
+        return signal.aborted && signal.reason === RUNNER_SIGTERM && !(this.opts.inRunner?.stopRequested?.() ?? false);
+      }
+      // An abort before the run: a Stop is silent, a termination nobody asked for
+      // is reported.
+      concludedOnAbort() {
+        return this.terminatedFromOutside() ? this.concluded(RUNNER_TERMINATED, RUNNER_TERMINATED) : this.concluded("cancelled");
+      }
       // The arc. Phases in order; every pre-loop exit throws `TurnConcluded` and
       // funnels through ONE conclusion (hand back the controller — idempotent and
       // identity-checked at the supervisor — then clear the active-run flag);
@@ -9571,7 +9619,7 @@ var init_turn_execution = __esm({
         } catch (err) {
           if (this.abortController.signal.aborted) {
             turnLog.debug("dispatcher: stopped while loading the turn context");
-            throw this.concluded("cancelled");
+            throw this.concludedOnAbort();
           }
           const status2 = err instanceof ApiError ? err.status : 0;
           if (status2 === 404) {
@@ -9633,7 +9681,7 @@ var init_turn_execution = __esm({
           this.executionSourceId = adopted.executionSourceId;
           return "adopted";
         } catch (err) {
-          if (this.abortController.signal.aborted) throw this.concluded("cancelled");
+          if (this.abortController.signal.aborted) throw this.concludedOnAbort();
           if (apiErrorCode(err) === "execution_source_unavailable") return "refused";
           turnLog.warn(apiErrorLogFields(err), "dispatcher: failed to adopt the turn context");
           const reason = `execution_source_unavailable: ${describeError(err)}`;
@@ -10270,7 +10318,7 @@ var init_turn_execution = __esm({
           }
           if (abortController.signal.aborted) {
             o.okResult = false;
-            o.resultReason = o.leaseLost ? "lease_lost" : o.timeoutReason ?? "cancelled";
+            o.resultReason = o.leaseLost ? "lease_lost" : o.timeoutReason ?? (this.terminatedFromOutside() ? RUNNER_TERMINATED : "cancelled");
           }
           const emptyResultReason = !this.skipState.skipped && classifyEmptyResult({
             ok: o.okResult,
@@ -10309,7 +10357,16 @@ var init_turn_execution = __esm({
             o.resultReason = "lease_lost";
             o.okResult = false;
           }
-          const userCancelled = abortController.signal.aborted && o.timeoutReason === null && !o.leaseLost;
+          let terminated = this.terminatedFromOutside() && o.timeoutReason === null && !o.leaseLost;
+          const cause = terminated ? await this.opts.inRunner?.terminationCause?.() : null;
+          terminated &&= this.terminatedFromOutside();
+          if (terminated) {
+            o.resultReason = cause ?? RUNNER_TERMINATED;
+            o.okResult = false;
+          } else if (o.resultReason === RUNNER_TERMINATED) {
+            o.resultReason = "cancelled";
+          }
+          const userCancelled = abortController.signal.aborted && o.timeoutReason === null && !o.leaseLost && !terminated;
           if (o.timeoutReason !== null) {
             o.resultReason = o.timeoutReason;
             o.okResult = false;
@@ -10807,6 +10864,9 @@ function openLauncherChannel(stdin, emit, onLauncherGone) {
   let next = 0;
   let resolveFirst;
   let gotFirst = false;
+  let stopRequested = false;
+  let gone = false;
+  const causeWaiters = /* @__PURE__ */ new Set();
   const first = new Promise((resolve2) => resolveFirst = resolve2);
   const lines2 = createInterface3({ input: stdin, crlfDelay: Infinity });
   lines2.on("line", (line) => {
@@ -10817,13 +10877,35 @@ function openLauncherChannel(stdin, emit, onLauncherGone) {
     }
     const message2 = decodeLauncherMessage(line);
     if (message2?.cabaneLauncher === "granted") waiting.get(message2.id)?.();
+    if (message2?.cabaneLauncher === "stop") stopRequested = true;
+    if (message2?.cabaneLauncher === "cause") {
+      for (const resolve2 of causeWaiters) resolve2(message2.cause);
+    }
   });
   lines2.once("close", () => {
+    gone = true;
+    for (const resolve2 of causeWaiters) resolve2(null);
     if (!gotFirst) resolveFirst("");
     onLauncherGone();
   });
   return {
     first,
+    get stopRequested() {
+      return stopRequested;
+    },
+    terminationCause(timeoutMs = CAUSE_TIMEOUT_MS) {
+      if (gone) return Promise.resolve(null);
+      return new Promise((resolve2) => {
+        const done = (cause) => {
+          clearTimeout(timer);
+          causeWaiters.delete(done);
+          resolve2(cause);
+        };
+        const timer = setTimeout(() => done(null), timeoutMs);
+        causeWaiters.add(done);
+        emit({ cabaneRunner: "terminated" });
+      });
+    },
     acquire(key, signal) {
       const id = String(++next);
       return new Promise((resolve2, reject) => {
@@ -10850,10 +10932,12 @@ function openLauncherChannel(stdin, emit, onLauncherGone) {
     }
   };
 }
+var CAUSE_TIMEOUT_MS;
 var init_launcher_channel = __esm({
   "src/runner/launcher-channel.ts"() {
     "use strict";
     init_protocol();
+    CAUSE_TIMEOUT_MS = 2e3;
   }
 });
 
@@ -10950,6 +11034,8 @@ function runnerTurnOptions(input, log2, emit, extras = {}) {
         (sessionId) => emit({ cabaneRunner: "remote_session", serverUrl, sessionId })
       ),
       ...extras.onProcessGroup ? { onProcessGroup: extras.onProcessGroup } : {},
+      ...extras.stopRequested ? { stopRequested: extras.stopRequested } : {},
+      ...extras.terminationCause ? { terminationCause: extras.terminationCause } : {},
       codexExecutable: (path, containment) => {
         const prefix = containment.scopePrefix(process.env);
         return prefix ? shims.write([...prefix, path]) : path;
@@ -11007,16 +11093,16 @@ async function runTurn(env, deps) {
   const controllers = /* @__PURE__ */ new Set();
   const shims = createShimDir();
   let terminated = false;
-  const onTerm = () => {
-    terminated = true;
-    for (const controller of controllers) controller.abort();
-  };
-  deps.signals.on("SIGTERM", onTerm);
   const groups = [];
   const channel = openLauncherChannel(deps.stdin, emit, () => {
     if (deps.onLauncherGone) deps.onLauncherGone(groups);
     else void stopWithLauncher(groups);
   });
+  const onTerm = () => {
+    terminated = true;
+    for (const controller of controllers) controller.abort(RUNNER_SIGTERM);
+  };
+  deps.signals.on("SIGTERM", onTerm);
   emit({ cabaneRunner: "ready" });
   try {
     const input = parseRunnerInput(env, await channel.first);
@@ -11026,7 +11112,7 @@ async function runTurn(env, deps) {
     const supervisor = {
       registerAbort: (_turnId, controller) => {
         controllers.add(controller);
-        if (terminated) controller.abort();
+        if (terminated) controller.abort(RUNNER_SIGTERM);
       },
       releaseAbort: (_turnId, controller) => {
         controllers.delete(controller);
@@ -11045,6 +11131,8 @@ async function runTurn(env, deps) {
       ...deps.queryFn ? { queryFn: deps.queryFn } : {},
       shims,
       acquireLock: (key, signal) => channel.acquire(key, signal),
+      stopRequested: () => channel.stopRequested,
+      terminationCause: () => channel.terminationCause(),
       onProcessGroup: (pgid) => {
         groups.push(pgid);
         emit({ cabaneRunner: "process_group", pgid });
@@ -11073,6 +11161,7 @@ var init_run_turn = __esm({
     init_outbox();
     init_exec_shim();
     init_launcher_channel();
+    init_turn_execution();
     init_opencode_lock();
     init_secrets();
     init_transcript_writer();
@@ -11287,7 +11376,6 @@ import { join as join7 } from "path";
 // src/device-state.ts
 var DEVICE_STATES = ["waiting", "online", "offline", "deactivated"];
 var DEFAULT_DEVICE_OFFLINE_THRESHOLD_MS = 9e4;
-var DEFAULT_DEVICE_RECONNECT_GRACE_MS = 9e4;
 var HARNESS_STATES = [
   "checking",
   "connected",
@@ -14993,8 +15081,6 @@ var CompanionSupervisor = class {
         const key = `${run.conversationId}|${run.agentId}`;
         if (wr.chains.has(key)) continue;
         this.recoveredTurns.add(run.turnId);
-        if (bumpResumeAttempt(run.workspaceId, `restart:${run.turnId}`) > MAX_RESUME_ATTEMPTS)
-          continue;
         const payload = {
           type: "device:dispatch_requested",
           deviceId: this.deviceId,
@@ -15002,6 +15088,11 @@ var CompanionSupervisor = class {
           conversationId: run.conversationId,
           messageId: run.messageId
         };
+        const attempt = bumpResumeAttempt(run.workspaceId, `restart:${run.turnId}`);
+        if (attempt > MAX_RESUME_ATTEMPTS) {
+          await this.abandonResume(wr.workspaceId, agent, payload, run.turnId, attempt);
+          continue;
+        }
         const tail = this.runDispatch(
           wr,
           // Off `/runs`, not a frame, so no dispatch id to dedupe on;
@@ -15027,6 +15118,44 @@ var CompanionSupervisor = class {
       this.recovering = false;
     }
   }
+  // An interrupted turn this device has tried to resume too often: it stops
+  // trying, and the server is told the turn failed, so the conversation says it
+  // couldn't resume instead of going quiet. The settle the launcher sends for a
+  // turn it couldn't run: it ends the span under this id if one is still
+  // running, disposes of the offer if none ever started, and is a no-op on a
+  // turn that already ended. A settle that doesn't land leaves the turn to the
+  // server's sweep, as before.
+  async abandonResume(workspaceId, agent, payload, turnId, attempt, eventId) {
+    this.log.error(
+      {
+        workspaceId,
+        conversationId: payload.conversationId,
+        agentId: payload.agentId,
+        turnId,
+        ...eventId ? { eventId } : {},
+        attempt,
+        cap: MAX_RESUME_ATTEMPTS
+      },
+      "An interrupted turn couldn't finish after several attempts. Reply in Cabane to try again."
+    );
+    try {
+      await agent.api.setActiveRun(workspaceId, payload.conversationId, payload.agentId, {
+        activeRunStartedAt: null,
+        turnId,
+        outcome: "failed",
+        errorReason: "resume_exhausted",
+        readThrough: payload.messageId,
+        // The delivery being given up on, so a newer one of the same message
+        // is not failed in its name (the server checks under its lock).
+        ...payload.episode !== void 0 ? { dispatchMessageId: payload.messageId, dispatchEpisode: payload.episode } : {}
+      });
+    } catch (err) {
+      this.log.warn(
+        { ...apiErrorLogFields(err), turnId },
+        "Couldn't tell Cabane the interrupted turn won't resume. Check the conversation."
+      );
+    }
+  }
   // One turn: the skip-vs-resume dedupe, the dispatch, then the console summary.
   async runDispatch(wr, dispatchId, payload, agent, recoveredTurnId) {
     await this.initialHarnessReady;
@@ -15050,9 +15179,13 @@ var CompanionSupervisor = class {
       }
       const attempt = bumpResumeAttempt(workspaceId, dispatchId);
       if (attempt > MAX_RESUME_ATTEMPTS) {
-        this.log.error(
-          { workspaceId, eventId: dispatchId, attempt, cap: MAX_RESUME_ATTEMPTS },
-          "An interrupted turn couldn't finish after several attempts. Reply in Cabane to try again."
+        await this.abandonResume(
+          workspaceId,
+          agent,
+          payload,
+          turnIdForEvent(workspaceId, dispatchId) ?? randomUUID5(),
+          attempt,
+          dispatchId
         );
         markCompleted(workspaceId, dispatchId);
         return;
@@ -16246,7 +16379,7 @@ function defaultSpawnDetached(args) {
 // src/terminal-copy.ts
 init_cabane_command();
 var UNPAIRED = "This device isn't paired yet. Get a setup line from a workspace's Settings \u2192 Devices and paste it here.";
-var lease = DEFAULT_DEVICE_OFFLINE_THRESHOLD_MS + DEFAULT_DEVICE_RECONNECT_GRACE_MS;
+var lease = DEFAULT_DEVICE_OFFLINE_THRESHOLD_MS;
 function age(at, now) {
   const seconds = Math.max(0, Math.floor((now - Date.parse(at)) / 1e3));
   return seconds < 60 ? `${seconds}s` : seconds < 3600 ? `${Math.floor(seconds / 60)}m` : `${Math.floor(seconds / 3600)}h`;

package/dist/runtime.js

@@ -7340,6 +7340,7 @@ import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var CONTAINMENT_STOP_GRACE_SEC = 5;
 var FALLBACK_GRACE_MS = CONTAINMENT_STOP_GRACE_SEC * 1e3;
+var OOM_READ_TIMEOUT_MS = 1500;
 function turnScopeUnit(turnId, attempt) {
   const safe = turnId.replace(/[^A-Za-z0-9_.-]/g, "-");
   return `cabane-turn-${safe}-${attempt}`;
@@ -7357,6 +7358,20 @@ async function reapTurnScopes(turnId) {
     return classifyStopError(message) === "absent" ? { failures: [] } : { failures: [message.slice(0, 200)] };
   }
 }
+async function turnScopeOomKilled(turnId) {
+  if (process.platform !== "linux") return false;
+  const safe = turnId.replace(/[^A-Za-z0-9_.-]/g, "-");
+  try {
+    const { stdout } = await execFileAsync(
+      "systemctl",
+      ["--user", "show", "--property=Result", "--value", `*-turn-${safe}-*.scope`],
+      { timeout: OOM_READ_TIMEOUT_MS }
+    );
+    return String(stdout).split("\n").some((line) => line.trim() === "oom-kill");
+  } catch {
+    return false;
+  }
+}
 function classifyStopError(message) {
   if (/failed to connect to bus|failed to get d-?bus connection|connection refused|refusing to operate|spawn systemctl|systemctl.*ENOENT|ENOENT.*systemctl/i.test(
     message
@@ -7697,6 +7712,7 @@ async function settleUnstarted(opts, payload, turnId, errorReason, log) {
 async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   const startedAt = Date.now();
   const { turnId } = handleOpts;
+  const oomKilled = (id) => (launch.oomKilled ?? turnScopeOomKilled)(id).catch(() => false);
   const log = opts.log.child({
     workspaceId: opts.workspaceId,
     conversationId: payload.conversationId,
@@ -7707,7 +7723,15 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   duties.registerAbort(turnId, controller);
   const stopRunner = new AbortController();
   let ready = false;
+  let child;
+  let stopAnnounced = false;
+  const announceStop = () => {
+    if (stopAnnounced || !child?.stdin.writable) return;
+    stopAnnounced = true;
+    child.stdin.write(encodeLauncherMessage({ cabaneLauncher: "stop" }));
+  };
   const forwardStop = () => {
+    announceStop();
     if (ready) stopRunner.abort();
   };
   controller.signal.addEventListener("abort", forwardStop, { once: true });
@@ -7730,7 +7754,6 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   let thrown;
   let code;
   let handle;
-  let child;
   const groups = [];
   const remote = [];
   const lockOwner = (id) => `${turnId}#${id}`;
@@ -7778,6 +7801,7 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
       stdin: runnerStdin(input)
     });
     child = running;
+    if (controller.signal.aborted) announceStop();
     log.debug(
       { turnId, runnerPid: running.pid, provider: launch.provider.name },
       "runner: started"
@@ -7843,6 +7867,18 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
         case "remote_session":
           remote.push({ serverUrl: event.serverUrl, sessionId: event.sessionId });
           return;
+        case "terminated":
+          void oomKilled(turnId).then((oom) => {
+            if (running.stdin.writable) {
+              running.stdin.write(
+                encodeLauncherMessage({
+                  cabaneLauncher: "cause",
+                  cause: oom ? "out_of_memory" : null
+                })
+              );
+            }
+          });
+          return;
       }
     });
     const stderrDone = lines(running.stderr, (line) => relayRunnerLog(line, opts.log));
@@ -7860,7 +7896,7 @@ async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
   if (result) return result;
   const durationMs = Date.now() - startedAt;
   const stopped = controller.signal.aborted && thrown === void 0;
-  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : `runner_exited: ${code}`;
+  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : await oomKilled(turnId) ? "out_of_memory" : `runner_exited: ${code}`;
   await child?.reap(groups);
   const reaped = await (launch.reapTurn ?? reapTurnScopes)(turnId).catch((err) => ({
     failures: [err instanceof Error ? err.message : String(err)]
@@ -10655,8 +10691,6 @@ var CompanionSupervisor = class {
         const key = `${run.conversationId}|${run.agentId}`;
         if (wr.chains.has(key)) continue;
         this.recoveredTurns.add(run.turnId);
-        if (bumpResumeAttempt(run.workspaceId, `restart:${run.turnId}`) > MAX_RESUME_ATTEMPTS)
-          continue;
         const payload = {
           type: "device:dispatch_requested",
           deviceId: this.deviceId,
@@ -10664,6 +10698,11 @@ var CompanionSupervisor = class {
           conversationId: run.conversationId,
           messageId: run.messageId
         };
+        const attempt = bumpResumeAttempt(run.workspaceId, `restart:${run.turnId}`);
+        if (attempt > MAX_RESUME_ATTEMPTS) {
+          await this.abandonResume(wr.workspaceId, agent, payload, run.turnId, attempt);
+          continue;
+        }
         const tail = this.runDispatch(
           wr,
           // Off `/runs`, not a frame, so no dispatch id to dedupe on;
@@ -10689,6 +10728,44 @@ var CompanionSupervisor = class {
       this.recovering = false;
     }
   }
+  // An interrupted turn this device has tried to resume too often: it stops
+  // trying, and the server is told the turn failed, so the conversation says it
+  // couldn't resume instead of going quiet. The settle the launcher sends for a
+  // turn it couldn't run: it ends the span under this id if one is still
+  // running, disposes of the offer if none ever started, and is a no-op on a
+  // turn that already ended. A settle that doesn't land leaves the turn to the
+  // server's sweep, as before.
+  async abandonResume(workspaceId, agent, payload, turnId, attempt, eventId) {
+    this.log.error(
+      {
+        workspaceId,
+        conversationId: payload.conversationId,
+        agentId: payload.agentId,
+        turnId,
+        ...eventId ? { eventId } : {},
+        attempt,
+        cap: MAX_RESUME_ATTEMPTS
+      },
+      "An interrupted turn couldn't finish after several attempts. Reply in Cabane to try again."
+    );
+    try {
+      await agent.api.setActiveRun(workspaceId, payload.conversationId, payload.agentId, {
+        activeRunStartedAt: null,
+        turnId,
+        outcome: "failed",
+        errorReason: "resume_exhausted",
+        readThrough: payload.messageId,
+        // The delivery being given up on, so a newer one of the same message
+        // is not failed in its name (the server checks under its lock).
+        ...payload.episode !== void 0 ? { dispatchMessageId: payload.messageId, dispatchEpisode: payload.episode } : {}
+      });
+    } catch (err) {
+      this.log.warn(
+        { ...apiErrorLogFields(err), turnId },
+        "Couldn't tell Cabane the interrupted turn won't resume. Check the conversation."
+      );
+    }
+  }
   // One turn: the skip-vs-resume dedupe, the dispatch, then the console summary.
   async runDispatch(wr, dispatchId, payload, agent, recoveredTurnId) {
     await this.initialHarnessReady;
@@ -10712,9 +10789,13 @@ var CompanionSupervisor = class {
       }
       const attempt = bumpResumeAttempt(workspaceId, dispatchId);
       if (attempt > MAX_RESUME_ATTEMPTS) {
-        this.log.error(
-          { workspaceId, eventId: dispatchId, attempt, cap: MAX_RESUME_ATTEMPTS },
-          "An interrupted turn couldn't finish after several attempts. Reply in Cabane to try again."
+        await this.abandonResume(
+          workspaceId,
+          agent,
+          payload,
+          turnIdForEvent(workspaceId, dispatchId) ?? randomUUID5(),
+          attempt,
+          dispatchId
         );
         markCompleted(workspaceId, dispatchId);
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.194",
+  "version": "0.6.196",
   "type": "module",
   "description": "The Cabane Companion (headless): connect an 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",