very-happy-cli 0.2.175 → 0.2.177

package/dist/{runClaudeDeps-D1M1dzlZ.mjs → runClaudeDeps-Dz2iydq4.mjs}

@@ -1,86 +1,86 @@
-import { l as logger } from './logger-D5EzMy30.mjs';
-import { o as notifyDaemonSessionEvent, q as notifyDaemonClaudeAuthFailed } from './controlClient-DqtC0pq1.mjs';
-export { j as reportSessionEditToDaemon } from './controlClient-DqtC0pq1.mjs';
-import { s as sameBackgroundTasks, c as createBackgroundTaskTracker } from './backgroundTaskActivity-8PdPxrvy.mjs';
+import { l as logger } from './logger-13cBr_ew.mjs';
+import { q as notifyDaemonSessionEvent, t as notifyDaemonClaudeAuthFailed } from './controlClient-C4xB5J6O.mjs';
+export { j as reportSessionEditToDaemon } from './controlClient-C4xB5J6O.mjs';
+import { s as sameBackgroundTasks, e as createBackgroundTaskTracker } from './backgroundTaskActivity-BVwJBl02.mjs';
 import { randomInt, randomUUID, createHash } from 'node:crypto';
 import { M as MessageBuffer } from './messageBuffer-BWlGgR3A.mjs';
-import { query } from './index-B6UGRQ7h.mjs';
+import { query } from './index-CEjJnq05.mjs';
 import { AbortError } from '@anthropic-ai/claude-agent-sdk';
 import { m as mapToClaudeMode, p as parseClaudePermissionMode, c as resolveRemoteClaudePermissionMode } from './permissionMode-CH4FoZfU.mjs';
-import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-e-qeag_h.mjs';
+import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-CdHOlyVW.mjs';
 import { join, resolve, dirname } from 'node:path';
-import { p as parseSpecialCommand, w as wrapperRateLimitReporter } from './specialCommands-DUUBqzvd.mjs';
+import { p as parseSpecialCommand, w as wrapperRateLimitReporter } from './specialCommands-DkdFJi4N.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
-import { A as AsyncLock } from './attachmentLimits-BLbji11b.mjs';
+import { A as AsyncLock } from './attachmentLimits-Di1Z93lN.mjs';
 import 'tweetnacl';
-import { c as configuration, e as ensurePrivateDirectory } from './configuration-BNGPXg07.mjs';
-import './index-boE-d8CM.mjs';
-import './registerCommonHandlers-CR5jpiSx.mjs';
+import { c as configuration, e as ensurePrivateDirectory } from './configuration-D55F0t16.mjs';
+import './index-DMy3OCBe.mjs';
+import './registerCommonHandlers-D8OMpBbQ.mjs';
 import 'os';
 import 'child_process';
 import '@paralleldrive/cuid2';
-import './persistence-CIIhP0Uw.mjs';
+import './persistence-C_tYtOqK.mjs';
 import { c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
 export { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import { g as getProjectPath } from './path-D2wdaNSk.mjs';
 import { access } from 'fs/promises';
-import { d as delay } from './time-CvrpeD3S.mjs';
+import { d as delay } from './time-yEL6wHUF.mjs';
 import { mkdirSync, writeFileSync, readFileSync, unlinkSync, renameSync, statSync, existsSync } from 'node:fs';
-import { h as hashObject } from './deterministicJson-DF4xv6MH.mjs';
-export { s as startHappyServer } from './deterministicJson-DF4xv6MH.mjs';
-import { F as Future } from './sessionScanner-CxXPAVyS.mjs';
-export { c as createSessionScanner } from './sessionScanner-CxXPAVyS.mjs';
+import { h as hashObject } from './deterministicJson-BkQETt8_.mjs';
+export { s as startHappyServer } from './deterministicJson-BkQETt8_.mjs';
+import { F as Future, d as describeClaudeProcessExit } from './sessionScanner-CNVaSNOn.mjs';
+export { c as createSessionScanner } from './sessionScanner-CNVaSNOn.mjs';
 import { execSync } from 'node:child_process';
-import { S as StreamRelay } from './streamRelay-C8zI7OnR.mjs';
-import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-PrNJg8gG.mjs';
+import { S as StreamRelay } from './streamRelay-_qCd873P.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-cPVF463_.mjs';
 import { writeFile, rename, unlink, readFile } from 'node:fs/promises';
-import { F as ForkSourceMissingError } from './claudeSessionFork-CxjOBoBh.mjs';
-export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-DLiu24CQ.mjs';
-export { g as getEnvironmentInfo } from './doctor-Ba92L7-b.mjs';
+import { F as ForkSourceMissingError } from './claudeSessionFork-BtROOjqf.mjs';
+export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-Drhf7-Vz.mjs';
+export { a as getEnvironmentInfo } from './doctor-B9c2C9dF.mjs';
 import { createServer } from 'node:http';
 export { E as EditReportThrottle, b as extractClaudeEditPaths } from './editPaths-BVfS_FFL.mjs';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
-import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-BZ5770wq.mjs';
-export { T as TitleGenerator } from './titleGenerator-BZ5770wq.mjs';
+import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-Dr-BtjzO.mjs';
+export { T as TitleGenerator } from './titleGenerator-Dr-BtjzO.mjs';
 import { B as BOARD_ANALYZER_PROMPT_PREFIX } from './oneShotPrompts-DT4p6RNd.mjs';
-import { i as isSelfReportFresh } from './reportProgressTool-BLLwMQrN.mjs';
-export { c as createSelfReportState } from './reportProgressTool-BLLwMQrN.mjs';
+import { i as isSelfReportFresh } from './reportProgressTool-B203EZCR.mjs';
+export { c as createSelfReportState } from './reportProgressTool-B203EZCR.mjs';
 import 'node:util';
 import './smallFastModel-BLNgMrwR.mjs';
 import './trimIdent-BAjmv_TG.mjs';
 import 'node:os';
 import './agentGuidance-BDYt2Qy2.mjs';
-import './rateLimitWindows-Bo6XVnie.mjs';
+import './rateLimitWindows-DYHDGuzQ.mjs';
 import 'zod';
-import './package-D0dxZ-W8.mjs';
+import './package-CjlsAaRe.mjs';
 import 'util';
 import 'crypto';
 import 'path';
 import 'cross-spawn';
 import './authRelay-DSAvg1uv.mjs';
-import './client-eQjOvC55.mjs';
-import './context-Ptdnlcv6.mjs';
-import './sessionOps-ByZJbkMq.mjs';
+import './client-BPMWutfs.mjs';
+import './context-CCRpVXFo.mjs';
+import './sessionOps-CdgbEJgf.mjs';
 import './resources-BdFBQi8r.mjs';
-import './tools-Cp0qJeBq.mjs';
-import './peerTools-B_eiNB3P.mjs';
+import './tools-BrM3bZW5.mjs';
+import './peerTools-CxmrKnfV.mjs';
 import './ids-DU6sLx4C.mjs';
-import './remoteSessionClient-CUjw1COc.mjs';
+import './remoteSessionClient-D01Hso2-.mjs';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import './limits-DIo7rEBR.mjs';
-import './downloadTarget-CUJg8iJV.mjs';
+import './downloadTarget-ByXzbDK4.mjs';
 import './terminals-Dlg0x3nY.mjs';
 import './terminalTitleSuggest-CeKsX_V6.mjs';
 import './tmuxSocket-B8Yx20sT.mjs';
-import './bootstrap-CWjpC5-J.mjs';
+import './bootstrap-C0s2bPFQ.mjs';
 import './previewPath-CXN4Vag0.mjs';
-import './sync-D5YqUVjS.mjs';
+import './sync-C3p7-KLn.mjs';
 import './transcriptCursor-B7T_gkQ0.mjs';
-import './startFileWatcher-CaYRObJu.mjs';
+import './startFileWatcher-UQyTSRAP.mjs';
 import 'node:readline';
 import './doctor-BPkYWSuq.mjs';
 import 'ps-list';
@@ -88,11 +88,11 @@ import './doctorReadiness-C208SMN9.mjs';
 import './detectCLI-CSGMlV51.mjs';
 import 'fs';
 import './cliUpdate-Y34VGe9Y.mjs';
-import './piRunnerArgs-cQafsadv.mjs';
-import './sessionModeFile-C-fr1M1h.mjs';
+import './piRunnerArgs-BpHc-JZl.mjs';
+import './sessionModeFile-CWVq8AT9.mjs';
 import 'url';
 import 'node:module';
-import './client-C4ddTzrD.mjs';
+import './client-DG5ndWLw.mjs';
 import './precheckCompat-DeEbilbr.mjs';
 
 const SCHEDULE_WAKEUP_GRACE_MS = 6e4;
@@ -1026,17 +1026,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 } : {};
@@ -1081,6 +1223,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.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++;
@@ -1338,7 +1488,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
@@ -1348,19 +1510,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.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.debug(`[claudeRemote] Model switched to ${modelTarget(next.mode.model) ?? "default"}`);
+        } catch (e) {
+          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.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.debug(`[claudeRemote] Turn ${timingTurn} ended by session_state_changed idle without a result frame`);
+    timingTurn++;
+    timingMarks = {};
+    if (isCompactCommand) {
+      logger.debug("[claudeRemote] /compact ended without a result; outcome unknown");
+      isCompactCommand = false;
+    }
+    opts.onReady(void 0);
+    if (!recycleIfPoisoned()) pullNextMessage();
+  };
   updateThinking(true);
   try {
     logger.debug(`[claudeRemote] Starting to iterate over response`);
@@ -1392,9 +1625,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.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,
@@ -1427,8 +1673,9 @@ async function claudeRemote(opts) {
         }
       }
       if (message.type === "result") {
+        const endsTurn = turn.onResult();
         updateThinking(false);
-        logger.debug("[claudeRemote] Result received");
+        logger.debug(endsTurn ? "[claudeRemote] Result received" : "[claudeRemote] Result received for a turn already ended by idle");
         logger.debug(formatClaudeTimingLine({
           turn: timingTurn,
           firstTurnOfProcess: timingTurn === 1,
@@ -1450,44 +1697,9 @@ async function claudeRemote(opts) {
           }
           isCompactCommand = false;
         }
-        opts.onReady(message);
-        const recycleReason = queryRecycleReason(message, lastAssistantError);
-        lastAssistantError = void 0;
-        if (recycleReason) {
-          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.debug(`[claudeRemote] Model switched to ${modelTarget(next.mode.model) ?? "default"}`);
-            } catch (e) {
-              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;
@@ -1525,6 +1737,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 = {};
@@ -1621,10 +1834,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.debug(`[PermissionHandler] Re-asserted ${previousMode} after the switch to ${mode} timed out`),
+          (reassertError) => logger.debug("[PermissionHandler] Re-asserting the previous permission mode failed", reassertError)
+        );
+      }
       throw error;
     }
   }
@@ -1635,7 +1854,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.debug("[PermissionHandler] Deferred SDK permission mode update failed", error);
@@ -2268,6 +2487,7 @@ class SDKToLogConverter {
       timestamp
     };
     let logMessage = null;
+    if (sdkMessage.type === "command_lifecycle") return null;
     switch (sdkMessage.type) {
       case "user": {
         const userMsg = sdkMessage;
@@ -2707,10 +2927,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;
@@ -2719,7 +2942,7 @@ function createTurnSteeringController() {
       if (!interrupt) return false;
       steering = true;
       try {
-        await interrupt();
+        await boundedInterrupt(interrupt);
         return true;
       } catch (error) {
         steering = false;
@@ -2737,7 +2960,7 @@ function createTurnSteeringController() {
       if (!interrupt) return false;
       interrupting = true;
       try {
-        await interrupt();
+        await boundedInterrupt(interrupt);
         return true;
       } catch (error) {
         interrupting = false;
@@ -3360,6 +3583,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;
@@ -3527,6 +3800,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
   const streamRelay = new StreamRelay({
     send: (frame) => session.client.sendStreamFrame(frame)
   });
+  const apiRetryGate = createClaudeApiRetryGate();
   const messageQueue = new OutgoingMessageQueue(
     (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
   );
@@ -3548,6 +3822,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.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.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);
@@ -3801,7 +4090,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) => {
@@ -3831,6 +4120,14 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
             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.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");
@@ -3876,9 +4173,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 = 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 {
@@ -3968,7 +4266,7 @@ async function loop(opts) {
     logger.debug(`[loop] Iteration with mode: ${mode}`);
     switch (mode) {
       case "local": {
-        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-D4vmjI3c.mjs');
+        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-7p6y88nj.mjs');
         const result = await claudeLocalLauncher(session);
         switch (result.type) {
           case "switch":
@@ -4374,7 +4672,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 import('./index-B6UGRQ7h.mjs');
+    const { query } = await import('./index-CEjJnq05.mjs');
     return runSideQuestion(query, input);
   });
   const run = async (input, live) => {