very-happy-cli 0.2.173 → 0.2.175

package/dist/{codexAppServerClient-BgNcgkVT.cjs → codexAppServerClient-D-9z-lWP.cjs}

@@ -3,11 +3,11 @@
 var node_child_process = require('node:child_process');
 var spawn = require('cross-spawn');
 var node_readline = require('node:readline');
-var logger = require('./logger-DYejzaY9.cjs');
+var logger = require('./logger-C7dRaCkE.cjs');
 var contentLogMetadata = require('./contentLogMetadata-ZSFk_NjQ.cjs');
 var manager = require('./manager-HrEj442o.cjs');
-var _package = require('./package-DwxuhtoO.cjs');
-var rateLimitWindows = require('./rateLimitWindows-Blhk1RyR.cjs');
+var _package = require('./package-VqWv7EI5.cjs');
+var rateLimitWindows = require('./rateLimitWindows-Bp4T21RI.cjs');
 
 function isAppServerAvailable() {
   try {
@@ -91,7 +91,6 @@ class CodexAppServerClient {
   _turnId = null;
   threadDefaults = null;
   // Turn completion tracking for the currently active sendTurnAndWait call.
-  // A completion event only resolves once we have seen task_started for this turn.
   pendingTurnCompletion = null;
   // Tracks in-flight interruptTurn() RPCs so sendTurnAndWait can wait for them
   // before starting a new turn (prevents stale turn/interrupt from aborting the next turn).
@@ -101,7 +100,29 @@ class CodexAppServerClient {
   idleRelease = null;
   notificationProtocol = "unknown";
   completedTurnIds = /* @__PURE__ */ new Set();
+  /** B-625: turns whose failure has already been forwarded, so a second failed frame is not. */
+  failedTurnIds = /* @__PURE__ */ new Set();
+  // B-625: the app-server speaks for every thread it hosts — the session's own and the
+  // children `spawn_agent` opens — so a lifecycle frame (turn/started, turn/completed,
+  // thread/status/changed, error, thread/closed) is the session's only when its `threadId`
+  // is ours; a frame naming no thread belongs to the thread it was asked on (Orca's rule,
+  // src/main/codex/codex-structured-turn-open-wait.ts). Before this, a child's
+  // `turn/completed` ended the parent's turn in the UI and a child's `turn/started`
+  // retargeted `turn/interrupt` at the child.
+  /** The own thread's last turn-ending `error` (willRetry=false), for a turn end that arrives without a verdict. */
+  lastTurnError = null;
+  /** Own thread reported idle/systemError while a turn was pending: Codex's `turn/completed`
+   *  follows within a millisecond; this ends the turn if it does not (see armThreadStopGrace). */
+  threadStopGrace = null;
+  /** Last few hundred chars of the app-server's stderr: Codex's own last words when it dies. */
+  stderrRing = "";
   rawFileChangesByItemId = /* @__PURE__ */ new Map();
+  // B-622: inactivity watchdog for the pending turn — re-armed by every
+  // notification, never a cap on how long a turn may run (see sendTurnAndWait).
+  turnWatchdog = null;
+  // Approval / elicitation requests we are still answering: a human may take
+  // longer than the watchdog to decide, and that is not Codex going silent.
+  inflightServerRequests = 0;
   // Handlers set by the consumer (runCodex.ts)
   eventHandler = null;
   approvalHandler = null;
@@ -163,8 +184,21 @@ class CodexAppServerClient {
     const status = params?.turn?.status ?? params?.status ?? null;
     return typeof status === "string" && status.length > 0 ? status : null;
   }
+  extractThreadId(params) {
+    const threadId = params?.threadId ?? params?.thread_id ?? params?.thread?.id ?? null;
+    return typeof threadId === "string" && threadId.length > 0 ? threadId : null;
+  }
+  /** B-625: whether a lifecycle frame is about the session's own thread (see the field comment). */
+  isOwnThreadFrame(params) {
+    const threadId = this.extractThreadId(params);
+    return threadId === null || this._threadId === null || threadId === this._threadId;
+  }
+  /** Codex's last stderr lines, one line, for a message a person reads. */
+  stderrTail() {
+    return this.stderrRing.replace(/\x1b\[[0-9;]*m/g, "").replace(/\s+/g, " ").trim();
+  }
   shouldHandleRawNotification(method) {
-    const isRawNotification = method === "thread/started" || method === "turn/started" || method === "turn/completed" || method === "thread/status/changed" || method === "thread/tokenUsage/updated" || method.startsWith("item/");
+    const isRawNotification = method === "thread/started" || method === "turn/started" || method === "turn/completed" || method === "thread/status/changed" || method === "thread/closed" || method === "thread/tokenUsage/updated" || method.startsWith("item/");
     if (!isRawNotification) {
       return false;
     }
@@ -178,14 +212,20 @@ class CodexAppServerClient {
   }
   emitRawTurnCompletion(turnId, status, error, source) {
     const aborted = status === "cancelled" || status === "canceled" || status === "aborted" || status === "interrupted";
+    const failed = status === "failed" || error !== void 0 && error !== null;
+    this.clearThreadStopGrace();
     this.tryResolvePendingTurn(aborted, turnId, source);
     this._turnId = null;
     this.maybeRefreshRateLimits();
+    if (this.lastTurnError && (!turnId || !this.lastTurnError.turnId || this.lastTurnError.turnId === turnId)) {
+      this.lastTurnError = null;
+    }
     if (turnId && this.completedTurnIds.has(turnId)) {
-      return;
+      if (!failed || this.failedTurnIds.has(turnId)) return;
     }
     if (turnId) {
       this.completedTurnIds.add(turnId);
+      if (failed) this.failedTurnIds.add(turnId);
     }
     if (aborted) {
       this.eventHandler?.({
@@ -208,6 +248,10 @@ class CodexAppServerClient {
       return false;
     }
     if (method === "turn/started") {
+      if (!this.isOwnThreadFrame(params)) {
+        logger.logger.debug(`[CodexAppServer] Child thread ${this.extractThreadId(params)} started a turn`);
+        return true;
+      }
       const turnId = this.extractTurnId(params);
       if (turnId) {
         this._turnId = turnId;
@@ -220,6 +264,10 @@ class CodexAppServerClient {
       return true;
     }
     if (method === "turn/completed") {
+      if (!this.isOwnThreadFrame(params)) {
+        logger.logger.debug(`[CodexAppServer] Child thread ${this.extractThreadId(params)} ended a turn`);
+        return true;
+      }
       this.emitRawTurnCompletion(
         this.extractTurnId(params),
         this.extractTurnStatus(params),
@@ -229,9 +277,23 @@ class CodexAppServerClient {
       return true;
     }
     if (method === "thread/status/changed") {
+      if (!this.isOwnThreadFrame(params)) return true;
       const statusType = params?.status?.type;
-      if (statusType === "idle" && this.pendingTurnCompletion) {
-        this.emitRawTurnCompletion(this._turnId, "completed", null, method);
+      if ((statusType === "idle" || statusType === "systemError") && this.pendingTurnCompletion?.opened) {
+        this.armThreadStopGrace(statusType);
+      } else if (statusType === "active") {
+        this.clearThreadStopGrace();
+      }
+      return true;
+    }
+    if (method === "thread/closed") {
+      if (this.isOwnThreadFrame(params) && this.pendingTurnCompletion) {
+        this.emitRawTurnCompletion(
+          this.pendingTurnCompletion.turnId ?? this._turnId,
+          "aborted",
+          { message: "Codex closed the thread before the turn ended." },
+          method
+        );
       }
       return true;
     }
@@ -318,14 +380,6 @@ class CodexAppServerClient {
           phase: item.phase
         });
       }
-      if (item.phase === "final_answer" && this.pendingTurnCompletion) {
-        this.emitRawTurnCompletion(
-          this.extractTurnId(params),
-          "completed",
-          null,
-          `${method}:final_answer`
-        );
-      }
       return true;
     }
     return method.startsWith("item/");
@@ -385,17 +439,35 @@ class CodexAppServerClient {
         return;
       }
       this.connected = false;
+      const tail = this.stderrTail();
+      const exited = `Codex process exited (code=${code ?? "null"}${signal ? `, signal=${signal}` : ""})`;
       for (const [id, req] of this.pending) {
         if (req.epoch !== epoch) continue;
-        req.reject(new Error(`Codex process exited (code=${code}) while waiting for ${req.method}`));
+        const error = new Error(`${exited} while waiting for ${req.method}`);
+        error.codexStderrTail = tail;
+        req.reject(error);
         this.pending.delete(id);
       }
+      if (this.pendingTurnCompletion) {
+        const turnId = this.pendingTurnCompletion.turnId ?? this._turnId;
+        this.eventHandler?.({
+          type: "turn_aborted",
+          reason: "process-exit",
+          ...turnId ? { turn_id: turnId } : {},
+          error: { message: `${exited}${tail ? `: ${tail}` : ""}` }
+        });
+      }
       this.resolvePendingTurn(true);
     });
+    this.stderrRing = "";
     proc.stderr?.on("data", (chunk) => {
       if (this.process !== proc || this.processEpoch !== epoch) return;
       const text = chunk.toString().trim();
-      if (text) logger.logger.debug("[CodexAppServer:stderr]", contentLogMetadata.contentLogMetadata(text));
+      if (text) {
+        logger.logger.debug("[CodexAppServer:stderr]", contentLogMetadata.contentLogMetadata(text));
+        this.stderrRing = `${this.stderrRing}
+${text}`.slice(-400);
+      }
     });
     this.readline = node_readline.createInterface({ input: proc.stdout });
     this.readline.on("line", (line) => {
@@ -446,6 +518,9 @@ class CodexAppServerClient {
     this._turnId = null;
     this.notificationProtocol = "unknown";
     this.completedTurnIds.clear();
+    this.failedTurnIds.clear();
+    this.lastTurnError = null;
+    this.clearThreadStopGrace();
     if (!opts?.preserveThreadState) {
       this._threadId = null;
       this.threadDefaults = null;
@@ -663,15 +738,50 @@ class CodexAppServerClient {
   }
   resolvePendingTurn(aborted) {
     if (!this.pendingTurnCompletion) return;
+    this.clearTurnWatchdog();
+    this.clearThreadStopGrace();
     this.pendingTurnCompletion.resolve(aborted);
     this.pendingTurnCompletion = null;
   }
   markPendingTurnStarted(turnId) {
     if (!this.pendingTurnCompletion) return;
+    this.pendingTurnCompletion.opened = true;
     if (turnId) {
       this.pendingTurnCompletion.turnId = turnId;
     }
   }
+  /** Default wait for Codex's `turn/completed` after its thread reported idle/systemError. */
+  static THREAD_STOP_GRACE_MS = 1500;
+  /**
+   * B-625: the own thread stopped (idle / systemError) while a turn was pending and
+   * had opened. Codex's `turn/completed` follows at once in every probed release
+   * (0.154.0: 1 ms); this is the net under a release that does not send it, so the
+   * session never waits on the silence watchdog for a turn Codex has already left.
+   */
+  armThreadStopGrace(statusType) {
+    this.clearThreadStopGrace();
+    const graceMs = this.pendingTurnCompletion?.threadStopGraceMs ?? CodexAppServerClient.THREAD_STOP_GRACE_MS;
+    this.threadStopGrace = setTimeout(() => {
+      this.threadStopGrace = null;
+      const pending = this.pendingTurnCompletion;
+      if (!pending) return;
+      const turnId = pending.turnId ?? this._turnId;
+      const lastError = this.lastTurnError && (!turnId || !this.lastTurnError.turnId || this.lastTurnError.turnId === turnId) ? this.lastTurnError.error : null;
+      logger.logger.warn(`[CodexAppServer] Thread went ${statusType} and no turn/completed followed for turn ${turnId ?? "?"}; ending the turn`);
+      const failed = statusType === "systemError" || lastError !== null;
+      this.emitRawTurnCompletion(
+        turnId,
+        failed ? "failed" : "completed",
+        lastError ?? (failed ? { message: "Codex reported a system error and ended the turn without a verdict." } : null),
+        `thread/status/changed:${statusType}`
+      );
+    }, graceMs);
+  }
+  clearThreadStopGrace() {
+    if (!this.threadStopGrace) return;
+    clearTimeout(this.threadStopGrace);
+    this.threadStopGrace = null;
+  }
   tryResolvePendingTurn(aborted, turnId, source) {
     const pending = this.pendingTurnCompletion;
     if (!pending) return;
@@ -773,6 +883,8 @@ class CodexAppServerClient {
   }
   /** Default timeout for waiting on turn completion (ms). 10 minutes. */
   static TURN_TIMEOUT_MS = 10 * 60 * 1e3;
+  /** How much of the app-server's stderr is kept for its exit message. */
+  static STDERR_TAIL_CHARS = 400;
   /**
    * Send a user turn and wait for it to complete (task_complete or turn_aborted).
    * Returns { aborted: true } if the turn was aborted (user cancel, permission reject, etc.).
@@ -784,30 +896,58 @@ class CodexAppServerClient {
     }
     await this.ensureConnected();
     const timeoutMs = opts?.turnTimeoutMs ?? CodexAppServerClient.TURN_TIMEOUT_MS;
-    let timer = null;
     const completion = new Promise((resolve) => {
       this.pendingTurnCompletion = {
         resolve,
-        turnId: null
+        turnId: null,
+        opened: false,
+        threadStopGraceMs: opts?.threadStopGraceMs ?? CodexAppServerClient.THREAD_STOP_GRACE_MS
       };
-      timer = setTimeout(() => {
-        if (this.pendingTurnCompletion) {
-          logger.logger.warn(`[CodexAppServer] Turn timed out after ${timeoutMs}ms \u2014 treating as abort`);
-          this.resolvePendingTurn(true);
-        }
-      }, timeoutMs);
+      this.lastTurnError = null;
+      this.armTurnWatchdog(timeoutMs);
     });
     try {
       await this.sendTurn(prompt, opts);
     } catch (err) {
-      if (timer) clearTimeout(timer);
+      this.clearTurnWatchdog();
       this.pendingTurnCompletion = null;
       throw err;
     }
     const aborted = await completion;
-    if (timer) clearTimeout(timer);
+    this.clearTurnWatchdog();
     return { aborted };
   }
+  armTurnWatchdog(timeoutMs) {
+    this.clearTurnWatchdog();
+    const timer = setTimeout(() => {
+      this.turnWatchdog = null;
+      if (!this.pendingTurnCompletion) return;
+      if (this.inflightServerRequests > 0) {
+        this.armTurnWatchdog(timeoutMs);
+        return;
+      }
+      logger.logger.warn(`[CodexAppServer] No notification from Codex for ${timeoutMs}ms \u2014 giving the turn up as aborted`);
+      const turnId = this.pendingTurnCompletion.turnId ?? this._turnId;
+      this.eventHandler?.({
+        type: "turn_aborted",
+        reason: "timeout",
+        ...turnId ? { turn_id: turnId } : {},
+        error: { message: `Codex sent nothing for ${Math.max(1, Math.round(timeoutMs / 6e4))} minutes; this turn was given up. Send the message again, or restart the session if it keeps happening.` }
+      });
+      this.resolvePendingTurn(true);
+    }, timeoutMs);
+    this.turnWatchdog = { timer, timeoutMs };
+  }
+  /** Any sign of life from the app-server while a turn is pending restarts the clock. */
+  touchTurnWatchdog() {
+    if (!this.turnWatchdog || !this.pendingTurnCompletion) return;
+    this.armTurnWatchdog(this.turnWatchdog.timeoutMs);
+  }
+  clearTurnWatchdog() {
+    if (!this.turnWatchdog) return;
+    clearTimeout(this.turnWatchdog.timer);
+    this.turnWatchdog = null;
+  }
   async interruptTurn() {
     if (!this._threadId) return;
     if (!this._turnId) {
@@ -843,6 +983,8 @@ class CodexAppServerClient {
     this._turnId = null;
     this.threadDefaults = null;
     this.completedTurnIds.clear();
+    this.failedTurnIds.clear();
+    this.lastTurnError = null;
     this.rawFileChangesByItemId.clear();
   }
   // ─── JSON-RPC transport ─────────────────────────────────────
@@ -1015,6 +1157,15 @@ class CodexAppServerClient {
     };
   }
   async handleServerRequest(id, method, params) {
+    this.inflightServerRequests += 1;
+    try {
+      await this.handleServerRequestInner(id, method, params);
+    } finally {
+      this.inflightServerRequests -= 1;
+      this.touchTurnWatchdog();
+    }
+  }
+  async handleServerRequestInner(id, method, params) {
     if (method === "mcpServer/elicitation/request") {
       const toolName = this.parseToolNameFromElicitationMessage(params?.message) ?? params?.serverName ?? "McpTool";
       const decision = await this.handleApproval({
@@ -1068,6 +1219,7 @@ class CodexAppServerClient {
     return "denied";
   }
   handleNotification(method, params) {
+    this.touchTurnWatchdog();
     if (method === "codex/event" || method.startsWith("codex/event/")) {
       this.notificationProtocol = "legacy";
       const msg = params?.msg;
@@ -1101,6 +1253,7 @@ class CodexAppServerClient {
     }
     if (method === "thread/started" || method === "turn/started" || method === "turn/completed" || method === "thread/status/changed") {
       logger.logger.debug(`[CodexAppServer] Lifecycle notification: ${method}`);
+      if (!this.isOwnThreadFrame(params)) return;
       if (method === "turn/started") {
         const turnId = this.extractTurnId(params);
         if (turnId) {
@@ -1127,6 +1280,30 @@ class CodexAppServerClient {
       logger.logger.debug(`[CodexAppServer] mcpServer startup status:`, params);
       return;
     }
+    if (method === "error") {
+      if (!this.isOwnThreadFrame(params)) return;
+      const error = params?.error ?? {};
+      const turnId = typeof params?.turnId === "string" && params.turnId.length > 0 ? params.turnId : null;
+      if (params?.willRetry === true) {
+        const message = typeof error.message === "string" ? error.message : "";
+        const info = error.codexErrorInfo;
+        const httpStatus = info && typeof info === "object" ? info.responseStreamDisconnected?.httpStatusCode ?? info.httpStatusCode ?? null : null;
+        this.eventHandler?.({
+          type: "turn_retry",
+          message,
+          ...typeof httpStatus === "number" ? { http_status: httpStatus } : {},
+          ...turnId ? { turn_id: turnId } : {},
+          ...typeof error.additionalDetails === "string" ? { details: error.additionalDetails } : {}
+        });
+        return;
+      }
+      this.lastTurnError = { turnId, error };
+      const pending = this.pendingTurnCompletion;
+      if (pending && !pending.opened && (turnId === null || pending.turnId === null || pending.turnId === turnId)) {
+        this.emitRawTurnCompletion(turnId ?? pending.turnId, "failed", error, "error:unopened-turn");
+      }
+      return;
+    }
     logger.logger.debug(`[CodexAppServer] Notification: ${method}`);
   }
 }

package/dist/{codexCommand-B-xQ7uoD.cjs → codexCommand-AgVJYnFU.cjs}

@@ -1,61 +1,61 @@
 'use strict';
 
-var auth = require('./auth-3UXAs__6.cjs');
-var index = require('./index-C9hI8a10.cjs');
+var auth = require('./auth-BGmM3Vlm.cjs');
+var index = require('./index-BZdhwBKa.cjs');
 var forkBackfill = require('./forkBackfill-8eLDeS73.cjs');
 var node_crypto = require('node:crypto');
 var cuid2 = require('@paralleldrive/cuid2');
 var agentAttachments = require('./agentAttachments-Dbw8iMCZ.cjs');
-var attachmentContent = require('./attachmentContent-CmR86NxQ.cjs');
+var attachmentContent = require('./attachmentContent-4L9dO8E3.cjs');
 var ink = require('ink');
-var sessionLock = require('./sessionLock-DdoHaNAf.cjs');
+var sessionLock = require('./sessionLock-BWBcBZKh.cjs');
 var React = require('react');
-var api = require('./api-BBoamFqd.cjs');
-var codexAppServerClient = require('./codexAppServerClient-BgNcgkVT.cjs');
-var specialCommands = require('./specialCommands-BK2gc9vz.cjs');
-var logger = require('./logger-DYejzaY9.cjs');
-var BasePermissionHandler = require('./BasePermissionHandler-kD4FK-7K.cjs');
-var BaseReasoningProcessor = require('./BaseReasoningProcessor-CeMRo-8g.cjs');
+var api = require('./api-KZmVqSKO.cjs');
+var codexAppServerClient = require('./codexAppServerClient-D-9z-lWP.cjs');
+var specialCommands = require('./specialCommands-DGUeZqdm.cjs');
+var logger = require('./logger-C7dRaCkE.cjs');
+var BasePermissionHandler = require('./BasePermissionHandler-BbLYwd13.cjs');
+var BaseReasoningProcessor = require('./BaseReasoningProcessor-_S1PbSvH.cjs');
 var node_child_process = require('node:child_process');
-var persistence = require('./persistence-Bi1BTtHq.cjs');
-var machineMetadata = require('./machineMetadata-C7Slozib.cjs');
-var configuration = require('./configuration-C_-2io9T.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-DoR8z8b6.cjs');
+var persistence = require('./persistence-DweHi8xa.cjs');
+var machineMetadata = require('./machineMetadata-DYYuK_0c.cjs');
+var configuration = require('./configuration-UV4EE5ui.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-CcX84g-T.cjs');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
 var path = require('node:path');
-var createSessionMetadata = require('./createSessionMetadata-BeY_Ct51.cjs');
-var deterministicJson = require('./deterministicJson-3OOoCWI0.cjs');
+var createSessionMetadata = require('./createSessionMetadata-2IuH5nlA.cjs');
+var deterministicJson = require('./deterministicJson-je21npNx.cjs');
 var messageBuffer = require('./messageBuffer-fJMH6uY8.cjs');
-var controlClient = require('./controlClient-DCH7YKU2.cjs');
-var defaultPermissionMode = require('./defaultPermissionMode-CP-RNe7S.cjs');
+var controlClient = require('./controlClient-CtsQMw--.cjs');
+var defaultPermissionMode = require('./defaultPermissionMode-Bn4HcU8S.cjs');
 var authRelay = require('./authRelay-BdYkC1Po.cjs');
-var setupOfflineReconnection = require('./setupOfflineReconnection-BcHl9VGI.cjs');
+var setupOfflineReconnection = require('./setupOfflineReconnection-CS_8Da8R.cjs');
 var trimIdent = require('./trimIdent-4gvk9Wk6.cjs');
 var constants = require('./constants-VJ0N6WuG.cjs');
 var editPaths = require('./editPaths-Bqp4OFPw.cjs');
-var ensureDaemonRunning = require('./ensureDaemonRunning-D3F9Wn4o.cjs');
+var ensureDaemonRunning = require('./ensureDaemonRunning-bIp6-vgi.cjs');
 require('tweetnacl');
 require('axios');
-require('./time-BDZ6VD5o.cjs');
-require('./browser-Cbyo0qny.cjs');
+require('./time-0szhiPo4.cjs');
+require('./browser-DmgVoopB.cjs');
 require('open');
 require('zod');
 require('node:fs/promises');
-require('./attachmentLimits-BEYEEBm8.cjs');
+require('./attachmentLimits-D6bT2jU1.cjs');
 require('node:fs');
-require('./lidState-hKB4aKcf.cjs');
+require('./lidState-BmJp2pLt.cjs');
 require('os');
 require('child_process');
 require('node:events');
 require('socket.io-client');
 require('./limits-C-a7gr04.cjs');
-require('./registerCommonHandlers-Ct5XkkNU.cjs');
+require('./registerCommonHandlers-B7QZxkCL.cjs');
 require('util');
 require('fs/promises');
 require('crypto');
 require('path');
 require('cross-spawn');
-require('./sync-BN5jPiq4.cjs');
+require('./sync-BK-IBkuB.cjs');
 require('./backgroundTaskActivity-CBvUdj39.cjs');
 require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('chalk');
@@ -63,36 +63,36 @@ require('node:readline');
 require('./manager-HrEj442o.cjs');
 require('@anthropic-ai/sandbox-runtime');
 require('node:os');
-require('./package-DwxuhtoO.cjs');
-require('./rateLimitWindows-Blhk1RyR.cjs');
+require('./package-VqWv7EI5.cjs');
+require('./rateLimitWindows-Bp4T21RI.cjs');
 require('node:util');
 require('./detectCLI-DR9ZaN6B.cjs');
 require('fs');
-require('./localHappyAgentAuth-B_ItamJZ.cjs');
+require('./localHappyAgentAuth-9SP7hdiw.cjs');
 require('./types-CRS-srZK.cjs');
 require('url');
-require('./client-CuadUoga.cjs');
-require('./context--xjJuO00.cjs');
-require('./sessionOps-BUzvciA5.cjs');
+require('./client-BHZVyQwi.cjs');
+require('./context-BmH2BKip.cjs');
+require('./sessionOps-9MChM9Op.cjs');
 require('./resources-JDPugcDq.cjs');
-require('./tools-C5HNddiJ.cjs');
-require('./reportProgressTool-BVTrYVsY.cjs');
-require('./client-W3gPBBN2.cjs');
+require('./tools-C77-Ssan.cjs');
+require('./reportProgressTool-DzMi4mvH.cjs');
+require('./client-BhLhjj_x.cjs');
 require('./precheckCompat-CWOi5c9L.cjs');
 require('./agentGuidance-BtBx2xxE.cjs');
-require('./peerTools-DiBZOaPT.cjs');
+require('./peerTools-BktGmlpd.cjs');
 require('./ids-B6ZC0HGt.cjs');
-require('./remoteSessionClient-B7YBUGMI.cjs');
+require('./remoteSessionClient-CL3akj0K.cjs');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('node:http');
 require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-require('./downloadTarget-nKU9KvK-.cjs');
+require('./downloadTarget-JC7FZl7W.cjs');
 require('./terminals-B_bfC9c2.cjs');
 require('./terminalTitleSuggest-DhvRFX3H.cjs');
 require('./tmuxSocket-D-Xt6Vn-.cjs');
-require('./bootstrap-BsXIVhrG.cjs');
+require('./bootstrap-DTJ6-vYT.cjs');
 require('./previewPath-B0rBdhy1.cjs');
-require('./spawnHappyCLI-A9QYQdFL.cjs');
+require('./spawnHappyCLI-DByQcqEN.cjs');
 require('./doctorReadiness-BCZGcN0a.cjs');
 
 function getStartedSubagents(state) {
@@ -1030,18 +1030,41 @@ function unsupportedEffortReason(catalog, model, effort) {
   return `Reasoning effort "${effort}" is not supported by ${model ?? "the default model"}. Choose a supported level.`;
 }
 
+const UNEXPECTED_STATUS = /^unexpected status (\d{3}) ([^:]*?):\s*([\s\S]*?)(?:,\s*url:\s*(\S+))?$/;
 function readableCodexErrorText(text) {
   const trimmed = text.trim();
-  if (!trimmed.startsWith("{")) return trimmed;
+  const status = UNEXPECTED_STATUS.exec(trimmed);
+  if (status) {
+    const [, code, reason, rawBody, url] = status;
+    const head = `HTTP ${code} ${reason.trim()} from the model API`;
+    const detail = readableHttpBody(rawBody, `${code} ${reason}`);
+    return `${head}${detail ? `: ${detail}` : ""}${url ? ` (${url})` : ""}`;
+  }
+  return unwrapJsonMessage(trimmed) ?? trimmed;
+}
+function unwrapJsonMessage(text) {
+  if (!text.startsWith("{")) return null;
   try {
-    const body = JSON.parse(trimmed);
+    const body = JSON.parse(text);
     const inner = typeof body.error === "object" && body.error ? body.error.message : void 0;
     const message = typeof inner === "string" && inner.trim() ? inner : typeof body.error === "string" && body.error.trim() ? body.error : typeof body.message === "string" && body.message.trim() ? body.message : null;
-    return message ? message.trim() : trimmed;
+    return message ? message.trim() : null;
   } catch {
-    return trimmed;
+    return null;
   }
 }
+function readableHttpBody(raw, statusLine) {
+  let body = unwrapJsonMessage(raw.trim()) ?? raw.trim();
+  if (/<[a-z!/][^>]*>/i.test(body)) {
+    const title = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(body);
+    body = title ? title[1] : body.replace(/<[^>]+>/g, " ");
+  }
+  body = body.replace(/\s+/g, " ").trim();
+  if (!body) return null;
+  const normalize = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+  if (normalize(body) === normalize(statusLine)) return null;
+  return body.length > 240 ? `${body.slice(0, 240)}\u2026` : body;
+}
 function describeCodexFailure(msg) {
   const hasFailure = msg?.status === "failed" || msg?.error !== void 0 && msg?.error !== null;
   if (!hasFailure) return null;
@@ -1052,6 +1075,16 @@ function describeCodexFailure(msg) {
   }
   return "Unknown error";
 }
+function describeCodexRetry(msg) {
+  const message = typeof msg?.message === "string" ? msg.message.trim() : "";
+  const status = typeof msg?.http_status === "number" ? msg.http_status : null;
+  const cause = status ? `HTTP ${status} from the model API` : "a model API error";
+  return message ? `Codex is retrying after ${cause} (${message})` : `Codex is retrying after ${cause}`;
+}
+function codexStderrTailOf(error) {
+  const tail = error?.codexStderrTail;
+  return typeof tail === "string" && tail.trim() ? tail.trim() : null;
+}
 const TRANSPORT_LOSS = /^Codex process (exited|disconnected)\b|stdin not writable| timed out after \d+ms/;
 function describeThrownTurnError(error) {
   const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
@@ -1743,6 +1776,10 @@ async function runCodex(opts) {
       } else {
         messageBuffer$1.addMessage("Turn aborted", "status");
       }
+    } else if (msg.type === "turn_retry") {
+      const notice = describeCodexRetry(msg);
+      messageBuffer$1.addMessage(notice, "status");
+      session.sendSessionEvent({ type: "message", message: notice });
     }
     if (msg.type === "task_started") {
       if (!thinking) {
@@ -1957,6 +1994,10 @@ async function runCodex(opts) {
       if (!message) {
         break;
       }
+      if (!thinking) {
+        thinking = true;
+        session.keepAlive(thinking, "remote");
+      }
       idleRelease.cancel();
       turnActive = true;
       if (isCodexClearText(message.message)) {
@@ -2049,8 +2090,9 @@ async function runCodex(opts) {
           messageBuffer$1.addMessage(`Task failed: ${reason}`, "status");
           session.sendSessionEvent({ type: "message", message: `Codex error: ${reason}` });
         } else {
+          const tail = codexStderrTailOf(error);
           messageBuffer$1.addMessage("Process exited unexpectedly", "status");
-          session.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+          session.sendSessionEvent({ type: "message", message: tail ? `Process exited unexpectedly: ${tail}` : "Process exited unexpectedly" });
         }
       } finally {
         permissionHandler.reset();