very-happy-cli 0.2.175 → 0.2.177

package/dist/{runClaudeDeps-CUDebE9e.cjs → runClaudeDeps-D2v_WDSL.cjs}

@@ -1,83 +1,83 @@
 'use strict';
 
-var logger = require('./logger-C7dRaCkE.cjs');
-var controlClient = require('./controlClient-CtsQMw--.cjs');
+var logger = require('./logger-LvwVeATU.cjs');
+var controlClient = require('./controlClient-SX8gSza2.cjs');
 var backgroundTaskActivity = require('./backgroundTaskActivity-CBvUdj39.cjs');
 var node_crypto = require('node:crypto');
 var messageBuffer = require('./messageBuffer-fJMH6uY8.cjs');
-var index = require('./index-D3kI0hDR.cjs');
+var index = require('./index-DFPT4HOO.cjs');
 var claudeAgentSdk = require('@anthropic-ai/claude-agent-sdk');
 var permissionMode = require('./permissionMode-CrV-XuMs.cjs');
-var systemPrompt = require('./systemPrompt-DaTKLEb-.cjs');
+var systemPrompt = require('./systemPrompt-DtibzbRU.cjs');
 var path$1 = require('node:path');
-var specialCommands = require('./specialCommands-DGUeZqdm.cjs');
+var specialCommands = require('./specialCommands-DbntVs0d.cjs');
 require('axios');
 require('node:events');
 require('socket.io-client');
-var attachmentLimits = require('./attachmentLimits-D6bT2jU1.cjs');
+var attachmentLimits = require('./attachmentLimits-DtFqqiwR.cjs');
 require('tweetnacl');
-var configuration = require('./configuration-UV4EE5ui.cjs');
-require('./index-BZdhwBKa.cjs');
-require('./registerCommonHandlers-B7QZxkCL.cjs');
+var configuration = require('./configuration-DZPy0T9Z.cjs');
+require('./index-De8L5lFK.cjs');
+require('./registerCommonHandlers-60VuTkdg.cjs');
 require('os');
 require('child_process');
 require('@paralleldrive/cuid2');
-require('./persistence-DweHi8xa.cjs');
+require('./persistence-DXbKOHxl.cjs');
 var contentLogMetadata = require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('chalk');
 var types = require('./types-CRS-srZK.cjs');
 var path = require('./path-B7zW-WwE.cjs');
 var fs = require('fs/promises');
-var time = require('./time-0szhiPo4.cjs');
+var time = require('./time-Dg5tVB8S.cjs');
 var node_fs = require('node:fs');
-var deterministicJson = require('./deterministicJson-je21npNx.cjs');
-var sessionScanner = require('./sessionScanner-BpegdnXK.cjs');
+var deterministicJson = require('./deterministicJson-ChGfQEF6.cjs');
+var sessionScanner = require('./sessionScanner-CQL_WSaC.cjs');
 var node_child_process = require('node:child_process');
-var streamRelay = require('./streamRelay-DqPFsCgx.cjs');
-var attachmentContent = require('./attachmentContent-4L9dO8E3.cjs');
+var streamRelay = require('./streamRelay-Cx01enfe.cjs');
+var attachmentContent = require('./attachmentContent-kJKXpkMX.cjs');
 var promises = require('node:fs/promises');
-var claudeSessionFork = require('./claudeSessionFork-DQk5-dzR.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-CcX84g-T.cjs');
-var doctor = require('./doctor-BXKcYVGU.cjs');
+var claudeSessionFork = require('./claudeSessionFork-CbDfm8Fz.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-pqChBKwO.cjs');
+var doctor = require('./doctor-BsN3JZJn.cjs');
 var node_http = require('node:http');
 var editPaths = require('./editPaths-Bqp4OFPw.cjs');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
-var titleGenerator = require('./titleGenerator-Dz5P7sE1.cjs');
+var titleGenerator = require('./titleGenerator-BMEaDTwU.cjs');
 var oneShotPrompts = require('./oneShotPrompts-CL0dip9C.cjs');
-var reportProgressTool = require('./reportProgressTool-DzMi4mvH.cjs');
+var reportProgressTool = require('./reportProgressTool-Du_zAK4h.cjs');
 require('node:util');
 require('./smallFastModel-D_uxGMo3.cjs');
 require('./trimIdent-4gvk9Wk6.cjs');
 require('node:os');
 require('./agentGuidance-BtBx2xxE.cjs');
-require('./rateLimitWindows-Bp4T21RI.cjs');
+require('./rateLimitWindows-DFnMU2Vt.cjs');
 require('zod');
-require('./package-VqWv7EI5.cjs');
+require('./package-Ch9WGDV_.cjs');
 require('util');
 require('crypto');
 require('path');
 require('cross-spawn');
 require('./authRelay-BdYkC1Po.cjs');
-require('./client-BHZVyQwi.cjs');
-require('./context-BmH2BKip.cjs');
-require('./sessionOps-9MChM9Op.cjs');
+require('./client-DyvBTYee.cjs');
+require('./context-BKbrZ55r.cjs');
+require('./sessionOps-Dmt7WUUs.cjs');
 require('./resources-JDPugcDq.cjs');
-require('./tools-C77-Ssan.cjs');
-require('./peerTools-BktGmlpd.cjs');
+require('./tools-DDKTB5aQ.cjs');
+require('./peerTools-DtGKWli5.cjs');
 require('./ids-B6ZC0HGt.cjs');
-require('./remoteSessionClient-CL3akj0K.cjs');
+require('./remoteSessionClient-B7NvjHD3.cjs');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 require('./limits-C-a7gr04.cjs');
-require('./downloadTarget-JC7FZl7W.cjs');
+require('./downloadTarget-Dj3WoVJa.cjs');
 require('./terminals-B_bfC9c2.cjs');
 require('./terminalTitleSuggest-DhvRFX3H.cjs');
 require('./tmuxSocket-D-Xt6Vn-.cjs');
-require('./bootstrap-DTJ6-vYT.cjs');
+require('./bootstrap-6OI698q9.cjs');
 require('./previewPath-B0rBdhy1.cjs');
-require('./sync-BK-IBkuB.cjs');
+require('./sync-C7sxoUYG.cjs');
 require('./transcriptCursor-DcXGLeSc.cjs');
-require('./startFileWatcher-BtBaahTn.cjs');
+require('./startFileWatcher-C292fhra.cjs');
 require('node:readline');
 require('./doctor-u46qYYKX.cjs');
 require('ps-list');
@@ -85,11 +85,11 @@ require('./doctorReadiness-BCZGcN0a.cjs');
 require('./detectCLI-DR9ZaN6B.cjs');
 require('fs');
 require('./cliUpdate-DsKXPFYp.cjs');
-require('./piRunnerArgs-BNzWTNRV.cjs');
-require('./sessionModeFile-DhuTNcJr.cjs');
+require('./piRunnerArgs-BVRZe2AR.cjs');
+require('./sessionModeFile-CsLtn_PL.cjs');
 require('url');
 require('node:module');
-require('./client-BhLhjj_x.cjs');
+require('./client-COmgDDy0.cjs');
 require('./precheckCompat-CWOi5c9L.cjs');
 
 const SCHEDULE_WAKEUP_GRACE_MS = 6e4;
@@ -1023,17 +1023,159 @@ function createClaudePrewarmLease(input) {
   return lease;
 }
 
-function withTimeout(promise, ms) {
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+function withTimeout(promise, ms, label) {
   promise.catch(() => {
   });
   let timer;
   const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(`timed out after ${ms}ms`)), ms);
+    timer = setTimeout(() => reject(new TimeoutError(`${label ? `${label} ` : ""}timed out after ${ms}ms`)), ms);
   });
   return Promise.race([promise, timeout]).finally(() => {
     if (timer) clearTimeout(timer);
   });
 }
+
+function readClaudeSessionState(message) {
+  const m = message;
+  if (!m || m.type !== "system" || m.subtype !== "session_state_changed") return null;
+  return m.state === "idle" || m.state === "running" || m.state === "requires_action" ? m.state : null;
+}
+function createClaudeTurnTracker() {
+  let pending = false;
+  let open = false;
+  let idleOwed = 0;
+  return {
+    get isOpen() {
+      return open;
+    },
+    get isPending() {
+      return pending;
+    },
+    /** A prompt was pushed into the Query. Not a turn yet: the CLI has to pick it up. */
+    pushed() {
+      pending = true;
+    },
+    /** The CLI reported `init` for a turn: it is running. Idempotent. */
+    announced() {
+      open = true;
+      pending = false;
+    },
+    /** A `result` frame: true when it ends the turn (the caller runs its turn-end), false when the turn already ended. */
+    onResult() {
+      if (!open && !pending) return false;
+      open = false;
+      pending = false;
+      idleOwed += 1;
+      return true;
+    },
+    onSessionState(state) {
+      if (state === "running") {
+        idleOwed = 0;
+        open = true;
+        pending = false;
+        return "ignore";
+      }
+      if (state !== "idle") return "ignore";
+      if (idleOwed > 0) {
+        idleOwed -= 1;
+        return "duplicate";
+      }
+      if (!open) return "ignore";
+      open = false;
+      return "end";
+    }
+  };
+}
+
+const CLAUDE_COMMAND_LIFECYCLE_STATES = ["queued", "started", "completed", "cancelled", "discarded", "refused"];
+function readClaudeCommandLifecycle(frame) {
+  const m = frame;
+  if (!m) return null;
+  const isLifecycle = m.type === "command_lifecycle" || m.type === "system" && m.subtype === "command_lifecycle";
+  if (!isLifecycle || typeof m.command_uuid !== "string" || m.command_uuid.length === 0) return null;
+  const state = CLAUDE_COMMAND_LIFECYCLE_STATES.find((candidate) => candidate === m.state);
+  return state ? { uuid: m.command_uuid, state } : null;
+}
+const uuidList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length > 0) : [];
+const INTERRUPT_CANCEL_QUEUED_CAPABILITY = "interrupt_cancel_queued_v1";
+const PENDING_MAX = 256;
+const REPORTED_MAX = 512;
+function createClaudeCommandTracker() {
+  const pending = /* @__PURE__ */ new Map();
+  const reported = /* @__PURE__ */ new Set();
+  const drop = (uuid) => {
+    pending.delete(uuid);
+    if (reported.has(uuid)) return null;
+    reported.add(uuid);
+    if (reported.size > REPORTED_MAX) reported.delete(reported.values().next().value);
+    return uuid;
+  };
+  return {
+    /** A uuid-stamped user message (prompt or steer) was handed to the Query. */
+    track(uuid) {
+      if (!pending.has(uuid) && pending.size >= PENDING_MAX) pending.delete(pending.keys().next().value);
+      pending.set(uuid, { started: false });
+    },
+    isTracked(uuid) {
+      return pending.has(uuid);
+    },
+    /** A lifecycle frame; returns the uuids now known to have never run. */
+    observe(lifecycle) {
+      const entry = pending.get(lifecycle.uuid);
+      if (!entry) return [];
+      switch (lifecycle.state) {
+        case "queued":
+          return [];
+        case "started":
+          entry.started = true;
+          return [];
+        case "completed":
+          pending.delete(lifecycle.uuid);
+          return [];
+        default: {
+          if (entry.started) {
+            pending.delete(lifecycle.uuid);
+            return [];
+          }
+          const dropped = drop(lifecycle.uuid);
+          return dropped ? [dropped] : [];
+        }
+      }
+    },
+    /**
+     * An interrupt's receipt: `cancelled` members we track never ran;
+     * `still_queued` members we track are returned for the per-uuid
+     * follow-up (`cancel_async_message`) a CLI without cancel_queued needs.
+     */
+    onInterruptReceipt(receipt) {
+      const dropped = [];
+      for (const uuid of uuidList(receipt?.cancelled)) {
+        if (!pending.has(uuid)) continue;
+        const result = drop(uuid);
+        if (result) dropped.push(result);
+      }
+      const stillQueued = uuidList(receipt?.still_queued).filter((uuid) => pending.has(uuid));
+      return { dropped, stillQueued };
+    },
+    /** The answer to `cancel_async_message`: true = withdrawn before it ran; false = already dequeued, its lifecycle frames follow. */
+    onCancelResponse(uuid, cancelled) {
+      if (!cancelled || !pending.has(uuid)) return [];
+      const dropped = drop(uuid);
+      return dropped ? [dropped] : [];
+    },
+    clear() {
+      pending.clear();
+    }
+  };
+}
+
+const SET_MODEL_TIMEOUT_MS = 3e4;
 const PROMPT_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function promptUuid(uuid) {
   return uuid && PROMPT_UUID_RE.test(uuid) ? { uuid } : {};
@@ -1078,6 +1220,14 @@ async function claudeRemote(opts) {
       }
     }
   };
+  const turn = createClaudeTurnTracker();
+  const commandTracker = createClaudeCommandTracker();
+  let cliCapabilities = /* @__PURE__ */ new Set();
+  const reportDroppedCommands = (uuids) => {
+    if (uuids.length === 0) return;
+    logger.logger.debug(`[claudeRemote] ${uuids.length} user message(s) were never read by Claude Code: ${uuids.join(", ")}`);
+    opts.onCommandsDropped?.(uuids);
+  };
   let callbackDepth = 0;
   const guardCallback = (callback) => (async (...args) => {
     callbackDepth++;
@@ -1335,7 +1485,19 @@ async function claudeRemote(opts) {
       setPermissionMode: (mode2) => response.setPermissionMode(mode2),
       setModel: (model) => response.setModel(modelTarget(model)),
       interrupt: async () => {
-        await response.interrupt();
+        const cancelQueued = cliCapabilities.has(INTERRUPT_CANCEL_QUEUED_CAPABILITY);
+        const receipt = await response.interrupt(cancelQueued ? { cancelQueued: true } : void 0);
+        const { dropped, stillQueued } = commandTracker.onInterruptReceipt(receipt);
+        if (!cancelQueued && stillQueued.length > 0) {
+          const cancelAsyncMessage = response.cancelAsyncMessage;
+          if (typeof cancelAsyncMessage === "function") {
+            for (const uuid of stillQueued) {
+              const cancelled = await cancelAsyncMessage.call(response, uuid).then((value) => value === true, () => false);
+              dropped.push(...commandTracker.onCancelResponse(uuid, cancelled));
+            }
+          }
+        }
+        reportDroppedCommands(dropped);
       },
       // `request` is the SDK's generic control-request sender (every typed
       // method wraps it); the public types omit `side_question`, the CLI
@@ -1345,19 +1507,90 @@ async function claudeRemote(opts) {
         const body = raw?.response;
         return body && typeof body === "object" ? body : { response: null };
       },
-      steer: (message, nextMode) => {
+      steer: (message, nextMode, localKey) => {
         mode = { ...nextMode, model: mode.model };
+        const uuid = promptUuid(localKey);
+        if (uuid.uuid) commandTracker.track(uuid.uuid);
         messages.push({
           type: "user",
           parent_tool_use_id: null,
           priority: "now",
           origin: { kind: "human" },
+          ...uuid,
           message: { role: "user", content: message }
         });
       }
     });
   }
   let lastAssistantError;
+  turn.pushed();
+  if (initialUserMessage.uuid) commandTracker.track(initialUserMessage.uuid);
+  let modelUnconfirmed = false;
+  let pullingNext = false;
+  const pullNextMessage = () => {
+    if (pullingNext) {
+      logger.logger.debug("[claudeRemote] Already waiting for the next message");
+      return;
+    }
+    pullingNext = true;
+    opts.nextMessage().then(async (next) => {
+      if (!next) {
+        messages.end();
+        return;
+      }
+      if (modelUnconfirmed || needsModelSwitch(mode.model, next.mode.model)) {
+        try {
+          await withTimeout(response.setModel(modelTarget(next.mode.model)), SET_MODEL_TIMEOUT_MS, "set_model");
+          modelUnconfirmed = false;
+          logger.logger.debug(`[claudeRemote] Model switched to ${modelTarget(next.mode.model) ?? "default"}`);
+        } catch (e) {
+          logger.logger.debug(`[claudeRemote] setModel failed: ${e instanceof Error ? e.message : String(e)}`);
+          opts.onCompletionEvent?.(modelSwitchFailureNotice(next.mode.model, e));
+          if (e instanceof TimeoutError) modelUnconfirmed = true;
+          next = { ...next, mode: { ...next.mode, model: mode.model } };
+        }
+      }
+      mode = next.mode;
+      updateThinking(true);
+      turn.pushed();
+      const uuid = promptUuid(next.uuid);
+      if (uuid.uuid) commandTracker.track(uuid.uuid);
+      timingMarks = { pushedAt: next.enqueuedAt ?? Date.now() };
+      messages.push({
+        type: "user",
+        parent_tool_use_id: null,
+        origin: { kind: "human" },
+        ...uuid,
+        message: { role: "user", content: next.message }
+      });
+    }).catch(() => {
+      messages.end();
+    }).finally(() => {
+      pullingNext = false;
+    });
+  };
+  const recycleIfPoisoned = (result) => {
+    const recycleReason = queryRecycleReason(result ?? { }, lastAssistantError);
+    lastAssistantError = void 0;
+    if (!recycleReason) return false;
+    logger.logger.warn(`[claudeRemote] Ending SDK query after ${recycleReason}; the next message starts a fresh Claude Code process`);
+    opts.onCompletionEvent?.(QUERY_RECYCLE_NOTICE[recycleReason]);
+    opts.onAuthFailure?.(recycleReason);
+    messages.end();
+    return true;
+  };
+  const endTurnWithoutResult = () => {
+    updateThinking(false);
+    logger.logger.debug(`[claudeRemote] Turn ${timingTurn} ended by session_state_changed idle without a result frame`);
+    timingTurn++;
+    timingMarks = {};
+    if (isCompactCommand) {
+      logger.logger.debug("[claudeRemote] /compact ended without a result; outcome unknown");
+      isCompactCommand = false;
+    }
+    opts.onReady(void 0);
+    if (!recycleIfPoisoned()) pullNextMessage();
+  };
   updateThinking(true);
   try {
     logger.logger.debug(`[claudeRemote] Starting to iterate over response`);
@@ -1389,9 +1622,22 @@ async function claudeRemote(opts) {
       }
       const outboundMessage = isCompactCommand && message.type === "assistant" ? { ...message, isCompactSummary: true } : message;
       opts.onMessage(outboundMessage);
+      const lifecycle = readClaudeCommandLifecycle(message);
+      if (lifecycle) reportDroppedCommands(commandTracker.observe(lifecycle));
+      const sessionState = readClaudeSessionState(message);
+      if (sessionState) {
+        const verdict = turn.onSessionState(sessionState);
+        if (verdict === "end") {
+          endTurnWithoutResult();
+        } else {
+          logger.logger.debug(`[claudeRemote] session_state_changed ${sessionState}: ${verdict}`);
+        }
+      }
       if (message.type === "system" && message.subtype === "init") {
         updateThinking(true);
+        turn.announced();
         const systemInit = message;
+        cliCapabilities = new Set(Array.isArray(systemInit.capabilities) ? systemInit.capabilities : []);
         if (opts.onSDKMetadata) {
           opts.onSDKMetadata({
             models,
@@ -1424,8 +1670,9 @@ async function claudeRemote(opts) {
         }
       }
       if (message.type === "result") {
+        const endsTurn = turn.onResult();
         updateThinking(false);
-        logger.logger.debug("[claudeRemote] Result received");
+        logger.logger.debug(endsTurn ? "[claudeRemote] Result received" : "[claudeRemote] Result received for a turn already ended by idle");
         logger.logger.debug(formatClaudeTimingLine({
           turn: timingTurn,
           firstTurnOfProcess: timingTurn === 1,
@@ -1447,44 +1694,9 @@ async function claudeRemote(opts) {
           }
           isCompactCommand = false;
         }
-        opts.onReady(message);
-        const recycleReason = queryRecycleReason(message, lastAssistantError);
-        lastAssistantError = void 0;
-        if (recycleReason) {
-          logger.logger.warn(`[claudeRemote] Ending SDK query after ${recycleReason}; the next message starts a fresh Claude Code process`);
-          opts.onCompletionEvent?.(QUERY_RECYCLE_NOTICE[recycleReason]);
-          opts.onAuthFailure?.(recycleReason);
-          messages.end();
-          continue;
-        }
-        opts.nextMessage().then(async (next) => {
-          if (!next) {
-            messages.end();
-            return;
-          }
-          if (needsModelSwitch(mode.model, next.mode.model)) {
-            try {
-              await response.setModel(modelTarget(next.mode.model));
-              logger.logger.debug(`[claudeRemote] Model switched to ${modelTarget(next.mode.model) ?? "default"}`);
-            } catch (e) {
-              logger.logger.debug(`[claudeRemote] setModel failed: ${e instanceof Error ? e.message : String(e)}`);
-              opts.onCompletionEvent?.(modelSwitchFailureNotice(next.mode.model, e));
-              next = { ...next, mode: { ...next.mode, model: mode.model } };
-            }
-          }
-          mode = next.mode;
-          updateThinking(true);
-          timingMarks = { pushedAt: next.enqueuedAt ?? Date.now() };
-          messages.push({
-            type: "user",
-            parent_tool_use_id: null,
-            origin: { kind: "human" },
-            ...promptUuid(next.uuid),
-            message: { role: "user", content: next.message }
-          });
-        }).catch(() => {
-          messages.end();
-        });
+        if (endsTurn) opts.onReady(message);
+        if (recycleIfPoisoned(message)) continue;
+        if (endsTurn) pullNextMessage();
       }
       if (message.type === "user") {
         const msg = message;
@@ -1522,6 +1734,7 @@ function getToolDescriptor(toolName) {
   return { edit: false, exitPlan: false, dangerous: false };
 }
 
+const LIVE_PERMISSION_MODE_TIMEOUT_MS = 15e3;
 function elicitationContent(input) {
   if (!input) return void 0;
   const content = {};
@@ -1618,10 +1831,16 @@ class PermissionHandler {
         return;
       }
       await new Promise((resolve) => setImmediate(resolve));
-      await this.setPermissionModeCallback(mode);
+      await withTimeout(this.setPermissionModeCallback(mode), LIVE_PERMISSION_MODE_TIMEOUT_MS, "set_permission_mode");
     } catch (error) {
       this.permissionMode = previousMode;
       if (this.deferredPermissionMode === mode) this.deferredPermissionMode = void 0;
+      if (error instanceof TimeoutError && this.setPermissionModeCallback) {
+        this.setPermissionModeCallback(previousMode).then(
+          () => logger.logger.debug(`[PermissionHandler] Re-asserted ${previousMode} after the switch to ${mode} timed out`),
+          (reassertError) => logger.logger.debug("[PermissionHandler] Re-asserting the previous permission mode failed", reassertError)
+        );
+      }
       throw error;
     }
   }
@@ -1632,7 +1851,7 @@ class PermissionHandler {
     setImmediate(() => {
       const task = this.modeChangeQueue.then(async () => {
         if (!this.setPermissionModeCallback || this.permissionMode !== mode) return;
-        await this.setPermissionModeCallback(mode);
+        await withTimeout(this.setPermissionModeCallback(mode), LIVE_PERMISSION_MODE_TIMEOUT_MS, "set_permission_mode");
       });
       this.modeChangeQueue = task.catch((error) => {
         logger.logger.debug("[PermissionHandler] Deferred SDK permission mode update failed", error);
@@ -2265,6 +2484,7 @@ class SDKToLogConverter {
       timestamp
     };
     let logMessage = null;
+    if (sdkMessage.type === "command_lifecycle") return null;
     switch (sdkMessage.type) {
       case "user": {
         const userMsg = sdkMessage;
@@ -2704,10 +2924,13 @@ function applyClaudeSdkMetadata(current, update) {
   };
 }
 
-function createTurnSteeringController() {
+const INTERRUPT_TIMEOUT_MS = 8e3;
+function createTurnSteeringController(opts = {}) {
+  const interruptTimeoutMs = opts.interruptTimeoutMs ?? INTERRUPT_TIMEOUT_MS;
   let interrupt = null;
   let steering = false;
   let interrupting = false;
+  const boundedInterrupt = (run) => withTimeout(run(), interruptTimeoutMs, "interrupt");
   return {
     setInterrupt(next) {
       interrupt = next;
@@ -2716,7 +2939,7 @@ function createTurnSteeringController() {
       if (!interrupt) return false;
       steering = true;
       try {
-        await interrupt();
+        await boundedInterrupt(interrupt);
         return true;
       } catch (error) {
         steering = false;
@@ -2734,7 +2957,7 @@ function createTurnSteeringController() {
       if (!interrupt) return false;
       interrupting = true;
       try {
-        await interrupt();
+        await boundedInterrupt(interrupt);
         return true;
       } catch (error) {
         interrupting = false;
@@ -3357,6 +3580,56 @@ async function persistRewindRecord(client, record, opts = {}) {
   }
 }
 
+const int = (value) => typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : null;
+function delayText(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = ms / 1e3;
+  return `${Number.isInteger(seconds) ? seconds : seconds.toFixed(1)}s`;
+}
+function describeClaudeApiRetry(frame) {
+  const status = int(frame.error_status);
+  const kind = typeof frame.error === "string" && frame.error && frame.error !== "unknown" ? frame.error.replace(/_/g, " ") : "";
+  const cause = status !== null ? `HTTP ${status}${kind ? ` ${kind}` : ""}` : "a connection error";
+  const attempt = int(frame.attempt);
+  const max = int(frame.max_retries);
+  const delay = int(frame.retry_delay_ms);
+  const details = [];
+  if (attempt !== null) details.push(`attempt ${attempt}${max !== null ? `/${max}` : ""}`);
+  if (delay !== null && delay >= 0) details.push(`next retry in ${delayText(delay)}`);
+  return `Claude is retrying after ${cause}${details.length ? ` (${details.join(", ")})` : ""}`;
+}
+const API_RETRY_NOTICE_MIN_INTERVAL_MS = 6e4;
+function createClaudeApiRetryGate(opts = {}) {
+  const minIntervalMs = opts.minIntervalMs ?? API_RETRY_NOTICE_MIN_INTERVAL_MS;
+  let lastAttempt = null;
+  let lastPersistedAt = null;
+  return {
+    /** True when this frame should be persisted. */
+    observe(frame, now) {
+      const attempt = int(frame.attempt);
+      const newRun = attempt !== null && (lastAttempt === null || attempt <= lastAttempt);
+      if (attempt !== null) lastAttempt = attempt;
+      if (newRun || lastPersistedAt === null || now - lastPersistedAt >= minIntervalMs) {
+        lastPersistedAt = now;
+        return true;
+      }
+      return false;
+    },
+    /** The turn ended: the next retry is a new run. */
+    reset() {
+      lastAttempt = null;
+      lastPersistedAt = null;
+    }
+  };
+}
+const INFORMATIONAL_MAX_CHARS = 500;
+function describeClaudeInformational(frame) {
+  if (frame.level !== "warning" || typeof frame.content !== "string") return null;
+  const text = frame.content.replace(/\s+/g, " ").trim();
+  if (!text) return null;
+  return text.length > INFORMATIONAL_MAX_CHARS ? `${text.slice(0, INFORMATIONAL_MAX_CHARS - 1)}\u2026` : text;
+}
+
 const ABORT_INTERRUPT_GRACE_MS = 4e3;
 const REWIND_LOG_WINDOW = 500;
 const REWIND_STARTUP_BUDGET_MS = 15e3;
@@ -3524,6 +3797,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
   const streamRelay$1 = new streamRelay.StreamRelay({
     send: (frame) => session.client.sendStreamFrame(frame)
   });
+  const apiRetryGate = createClaudeApiRetryGate();
   const messageQueue = new OutgoingMessageQueue(
     (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
   );
@@ -3545,6 +3819,21 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
     backgroundTasks.observe(message);
     session.setBackgroundTasks(backgroundTasks.list());
     session.scheduledWakeups.observe(message);
+    if (message.type === "system" && message.subtype === "api_retry") {
+      const notice = describeClaudeApiRetry(message);
+      messageBuffer$1.addMessage(notice, "status");
+      if (apiRetryGate.observe(message, Date.now())) {
+        session.client.sendSessionEvent({ type: "message", message: notice, kind: "claude-api-retry" });
+      }
+    } else if (message.type === "system" && message.subtype === "informational") {
+      const warning = describeClaudeInformational(message);
+      if (warning) {
+        messageBuffer$1.addMessage(warning, "status");
+        session.client.sendSessionEvent({ type: "message", message: warning, kind: "claude-warning" });
+      }
+    } else if (message.type === "result") {
+      apiRetryGate.reset();
+    }
     if (isRuntimeCheckpointReplay(message)) return;
     if (message.type === "user" && isClaudeInterruptSentinelContent(message.message.content)) {
       sdkToLogConverter.convert(message);
@@ -3798,7 +4087,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
               }
               if (!session.thinking || !modeGate.matches(input.mode)) return false;
               if (typeof message === "string") onPromptFinalized?.(message);
-              q.steer(message, input.mode);
+              q.steer(message, input.mode, input.localKey);
               return true;
             });
             permissionHandler.setPermissionModeUpdater(async (mode) => {
@@ -3828,6 +4117,14 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
             logger.logger.debug("[remote]: Session reset");
             session.clearSessionId();
           },
+          // B-631: a Stop swept these user messages (steers, or prompts
+          // queued behind a pre-empting steer's turn) before the model
+          // read them — the same tombstone a destroyed queue item gets
+          // (B-332), so the web shows them as not delivered, not answered.
+          onCommandsDropped: (uuids) => {
+            logger.logger.debug(`[remote]: ${uuids.length} user message(s) never read before the turn ended`);
+            session.client.sendQueueCancelReason(uuids, "aborted");
+          },
           onReady: (result) => {
             if (turnSteering.consumeReady()) {
               session.client.closeClaudeSessionTurn("cancelled");
@@ -3873,9 +4170,10 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
             session.client.closeClaudeSessionTurn("cancelled");
             continue;
           }
-          session.client.closeClaudeSessionTurn("failed");
-          session.client.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
-          session.onSessionError(e instanceof Error ? e.message : "Process exited unexpectedly");
+          const exit = sessionScanner.describeClaudeProcessExit(e);
+          const closed = session.client.closeClaudeSessionTurn("failed", { error: exit });
+          if (!closed) session.client.sendSessionEvent({ type: "message", message: exit, kind: "claude-process-exit" });
+          session.onSessionError(exit);
           continue;
         }
       } finally {
@@ -3965,7 +4263,7 @@ async function loop(opts) {
     logger.logger.debug(`[loop] Iteration with mode: ${mode}`);
     switch (mode) {
       case "local": {
-        const { claudeLocalLauncher } = await Promise.resolve().then(function () { return require('./claudeLocalLauncher-Dnv4CH8r.cjs'); });
+        const { claudeLocalLauncher } = await Promise.resolve().then(function () { return require('./claudeLocalLauncher-A4VuevIi.cjs'); });
         const result = await claudeLocalLauncher(session);
         switch (result.type) {
           case "switch":
@@ -4371,7 +4669,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const fork = deps.run ?? (async (input) => {
-    const { query } = await Promise.resolve().then(function () { return require('./index-D3kI0hDR.cjs'); });
+    const { query } = await Promise.resolve().then(function () { return require('./index-DFPT4HOO.cjs'); });
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {