@autohq/cli 0.1.337 → 0.1.338

package/dist/agent-bridge.js

@@ -23434,7 +23434,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.337",
+  version: "0.1.338",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -67372,6 +67372,98 @@ function tomlString(value2) {
   return `"${value2.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 
+// src/commands/agent-bridge/harness/codex/turn-retry.ts
+var MAX_CODEX_TURN_RETRY_ATTEMPTS = 3;
+var MAX_CODEX_TURN_RETRY_TOTAL_DELAY_MS = 3e4;
+var CODEX_TURN_RETRY_BACKOFF_BASE_MS = 500;
+var CODEX_TURN_RETRY_MIN_DELAY_MS = 250;
+var CODEX_TURN_RETRY_MAX_DELAY_MS = 1e4;
+var CODEX_TURN_RETRY_JITTER_RATIO = 0.2;
+function classifyRetryableCodexTurnFailure(message) {
+  if (!message) {
+    return null;
+  }
+  const explicitRetryAfterMs = parseExplicitRetryAfterMs(message);
+  const retryAfterMs = explicitRetryAfterMs ?? parseTryAgainDelayMs(message);
+  if (!isRateLimitMessage(message) && explicitRetryAfterMs === null) {
+    return null;
+  }
+  return {
+    cause: "rate_limit",
+    message,
+    retryAfterMs
+  };
+}
+function codexTurnRetryDelayMs(input) {
+  if (input.attempt > MAX_CODEX_TURN_RETRY_ATTEMPTS) {
+    return null;
+  }
+  const remainingDelayBudgetMs = MAX_CODEX_TURN_RETRY_TOTAL_DELAY_MS - input.cumulativeDelayMs;
+  if (remainingDelayBudgetMs <= 0) {
+    return null;
+  }
+  const delayMs = input.failure.retryAfterMs !== null ? boundedRetryAfterMs(input.failure.retryAfterMs) : jitteredBackoffMs(input.attempt);
+  return delayMs <= remainingDelayBudgetMs ? delayMs : null;
+}
+function isRateLimitMessage(message) {
+  return /\b(?:too many requests|tokens per min|tpm)\b/i.test(message) || /\b(?:http\s*)?(?:status(?:\s*code)?|code)\s*[:=]?\s*429\b/i.test(
+    message
+  ) || /\b429\b[^\n.]{0,80}\btoo many requests\b/i.test(message) || /\brate[-\s]?limit(?:ed| reached)?\b/i.test(message);
+}
+function parseExplicitRetryAfterMs(message) {
+  return parseDelayMs(
+    message.match(
+      /\bretry[-\s]?after\b\s*[:=]?\s*(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m)?\b/i
+    )
+  );
+}
+function parseTryAgainDelayMs(message) {
+  return parseDelayMs(
+    message.match(
+      /\b(?:try again|retry)\s+(?:in|after)\s+(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m)?\b/i
+    )
+  );
+}
+function parseDelayMs(match) {
+  if (!match) {
+    return null;
+  }
+  const value2 = Number.parseFloat(match[1] ?? "");
+  if (!Number.isFinite(value2) || value2 < 0) {
+    return null;
+  }
+  switch ((match[2] ?? "s").toLowerCase()) {
+    case "millisecond":
+    case "milliseconds":
+    case "msec":
+    case "msecs":
+    case "ms":
+      return Math.round(value2);
+    case "minute":
+    case "minutes":
+    case "min":
+    case "mins":
+    case "m":
+      return Math.round(value2 * 6e4);
+    default:
+      return Math.round(value2 * 1e3);
+  }
+}
+function boundedRetryAfterMs(delayMs) {
+  return Math.min(
+    Math.max(delayMs, CODEX_TURN_RETRY_MIN_DELAY_MS),
+    CODEX_TURN_RETRY_MAX_DELAY_MS
+  );
+}
+function jitteredBackoffMs(attempt) {
+  const baseDelayMs = Math.min(
+    CODEX_TURN_RETRY_BACKOFF_BASE_MS * 2 ** (attempt - 1),
+    CODEX_TURN_RETRY_MAX_DELAY_MS
+  );
+  const jitter = 1 - CODEX_TURN_RETRY_JITTER_RATIO + Math.random() * CODEX_TURN_RETRY_JITTER_RATIO * 2;
+  return boundedRetryAfterMs(Math.round(baseDelayMs * jitter));
+}
+
 // src/commands/agent-bridge/harness/codex/session.ts
 var CODEX_REQUEST_TIMEOUT_MS = 3e4;
 var CODEX_ITEM_SETTLE_TIMEOUT_MS = 1e4;
@@ -67380,6 +67472,7 @@ var CODEX_TOOL_ITEM_TYPES = /* @__PURE__ */ new Set([
   "fileChange",
   "mcpToolCall"
 ]);
+var CODEX_RETRYABLE_ERROR_PAIRING_WINDOW_MS = 1e3;
 function startCodexAgentBridgeSession(input) {
   return new CodexAgentBridgeSessionImpl(input);
 }
@@ -67404,6 +67497,8 @@ var CodexAgentBridgeSessionImpl = class {
   // Messages held in "deferred" mode while a turn is in flight; flushed as a
   // fresh turn once the active turn completes.
   deferredMessages = [];
+  turnRetry = null;
+  pendingRetryableError = null;
   constructor(input) {
     this.input = input;
   }
@@ -67414,6 +67509,13 @@ var CodexAgentBridgeSessionImpl = class {
     await this.ensureStarted();
     const threadId = this.requireThreadId();
     const mode = options?.mode ?? "interrupt";
+    if (this.turnRetry !== null) {
+      this.deferredMessages.push(message);
+      this.input.writeOutput?.(
+        "agent_bridge_codex_message_deferred reason=turn_retry"
+      );
+      return;
+    }
     if (this.activeTurnId === null) {
       await this.startTurn(threadId, message);
       return;
@@ -67449,6 +67551,8 @@ var CodexAgentBridgeSessionImpl = class {
       });
     }
     this.activeTurnId = null;
+    this.turnRetry = null;
+    this.clearPendingRetryableError();
     this.pendingToolItemIds.clear();
     this.resolveSettlement();
     this.rejectAllPending(new Error("Codex session is closed"));
@@ -67551,6 +67655,12 @@ var CodexAgentBridgeSessionImpl = class {
       input: [userTextInput(message)]
     });
   }
+  async startContinuationTurn(threadId) {
+    await this.request("turn/start", {
+      threadId,
+      input: []
+    });
+  }
   // Inject a message into the active turn. Prefers `turn/steer` (codex folds the
   // input into the running turn and owns transcript consistency); falls back to a
   // hard `turn/interrupt` + fresh `turn/start` when the turn cannot be steered.
@@ -67671,10 +67781,7 @@ var CodexAgentBridgeSessionImpl = class {
         this.settleResponse(message.id, message.result, message.error);
         return;
       case "notification":
-        this.trackNotification(message.notification);
-        this.enqueueCallback(
-          () => this.input.onNotification(message.notification)
-        );
+        this.handleNotification(message.notification);
         return;
       case "serverRequest":
         this.enqueueCallback(() => this.input.onServerRequest(message.request));
@@ -67715,6 +67822,156 @@ var CodexAgentBridgeSessionImpl = class {
       }
     });
   }
+  handleNotification(notification) {
+    if (notification.type === "turnCompleted") {
+      this.handleTurnCompletedNotification(notification);
+      return;
+    }
+    if (notification.type === "error") {
+      this.handleErrorNotification(notification);
+      return;
+    }
+    this.trackNotification(notification);
+    this.enqueueCallback(() => this.input.onNotification(notification));
+  }
+  handleErrorNotification(notification) {
+    const retryableFailure = !notification.willRetry && classifyRetryableCodexTurnFailure(notification.message);
+    if (retryableFailure && (this.activeTurnId !== null || this.turnRetry !== null)) {
+      this.holdRetryableError(notification, {
+        releaseOnTimeout: this.turnRetry === null
+      });
+      return;
+    }
+    this.trackNotification(notification);
+    this.enqueueCallback(() => this.input.onNotification(notification));
+  }
+  handleTurnCompletedNotification(notification) {
+    if (notification.status !== "failed") {
+      this.turnRetry = null;
+      this.clearPendingRetryableError();
+      this.trackNotification(notification);
+      this.enqueueCallback(() => this.input.onNotification(notification));
+      return;
+    }
+    const failure = classifyRetryableCodexTurnFailure(
+      notification.errorMessage
+    );
+    if (!failure) {
+      this.turnRetry = null;
+      this.clearPendingRetryableError();
+      this.trackNotification(notification);
+      this.enqueueCallback(() => this.input.onNotification(notification));
+      return;
+    }
+    this.clearPendingRetryableError();
+    const currentRetry = this.turnRetry ?? {
+      originalFailure: notification,
+      attempts: 0,
+      cumulativeDelayMs: 0
+    };
+    const nextAttempt = currentRetry.attempts + 1;
+    const delayMs = codexTurnRetryDelayMs({
+      attempt: nextAttempt,
+      cumulativeDelayMs: currentRetry.cumulativeDelayMs,
+      failure
+    });
+    if (delayMs === null) {
+      this.turnRetry = null;
+      this.settleCompletedTurn({
+        flushDeferred: true,
+        turnId: notification.turnId
+      });
+      this.input.writeOutput?.(
+        `agent_bridge_codex_turn_retry_exhausted attempts=${currentRetry.attempts} total_delay_ms=${currentRetry.cumulativeDelayMs} cause=${failure.cause} original_error=${singleLine(currentRetry.originalFailure.errorMessage ?? "unknown error")}`
+      );
+      this.enqueueCallback(
+        () => this.input.onNotification(currentRetry.originalFailure)
+      );
+      return;
+    }
+    this.turnRetry = {
+      originalFailure: currentRetry.originalFailure,
+      attempts: nextAttempt,
+      cumulativeDelayMs: currentRetry.cumulativeDelayMs + delayMs
+    };
+    this.settleCompletedTurn({
+      flushDeferred: false,
+      turnId: notification.turnId
+    });
+    this.scheduleFailedTurnRetry({
+      attempt: nextAttempt,
+      delayMs,
+      failure,
+      originalFailure: currentRetry.originalFailure
+    });
+  }
+  holdRetryableError(notification, input) {
+    this.clearPendingRetryableError();
+    this.input.writeOutput?.(
+      `agent_bridge_codex_retryable_error_held message=${singleLine(notification.message)}`
+    );
+    const timer = setTimeout(() => {
+      if (this.pendingRetryableError?.notification !== notification) {
+        return;
+      }
+      this.pendingRetryableError = null;
+      if (!input.releaseOnTimeout) {
+        return;
+      }
+      this.enqueueCallback(() => this.input.onNotification(notification));
+    }, CODEX_RETRYABLE_ERROR_PAIRING_WINDOW_MS);
+    timer.unref?.();
+    this.pendingRetryableError = { notification, timer };
+  }
+  clearPendingRetryableError() {
+    if (!this.pendingRetryableError) {
+      return;
+    }
+    clearTimeout(this.pendingRetryableError.timer);
+    this.pendingRetryableError = null;
+  }
+  scheduleFailedTurnRetry(input) {
+    this.input.writeOutput?.(
+      `agent_bridge_codex_turn_retry_scheduled attempt=${input.attempt} max_attempts=${MAX_CODEX_TURN_RETRY_ATTEMPTS} delay_ms=${input.delayMs} cause=${input.failure.cause} error=${singleLine(input.failure.message)}`
+    );
+    const timer = setTimeout(() => {
+      void this.retryFailedTurn(input).catch((error51) => {
+        this.enqueueCallback(() => this.input.onError(error51));
+      });
+    }, input.delayMs);
+    timer.unref?.();
+  }
+  async retryFailedTurn(input) {
+    if (this.closed) {
+      return;
+    }
+    const threadId = this.threadId;
+    if (threadId === null) {
+      this.turnRetry = null;
+      this.clearPendingRetryableError();
+      this.flushDeferredMessages();
+      this.enqueueCallback(
+        () => this.input.onNotification(input.originalFailure)
+      );
+      return;
+    }
+    try {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_turn_retry_starting attempt=${input.attempt} thread_id=${threadId}`
+      );
+      await this.startContinuationTurn(threadId);
+    } catch (error51) {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_turn_retry_failed attempt=${input.attempt} error=${errorMessage2(error51)}`
+      );
+      this.turnRetry = null;
+      this.clearPendingRetryableError();
+      this.flushDeferredMessages();
+      this.enqueueCallback(
+        () => this.input.onNotification(input.originalFailure)
+      );
+    }
+  }
   // Track turn/item lifecycle so steer/interrupt target the live turn and gate on
   // tool-item settlement.
   trackNotification(notification) {
@@ -67723,12 +67980,10 @@ var CodexAgentBridgeSessionImpl = class {
         this.activeTurnId = notification.turnId;
         return;
       case "turnCompleted":
-        if (notification.turnId === this.activeTurnId) {
-          this.activeTurnId = null;
-        }
-        this.pendingToolItemIds.clear();
-        this.resolveSettlement();
-        this.flushDeferredMessages();
+        this.settleCompletedTurn({
+          flushDeferred: true,
+          turnId: notification.turnId
+        });
         return;
       case "itemStarted":
         if (CODEX_TOOL_ITEM_TYPES.has(notification.item.type)) {
@@ -67745,6 +68000,16 @@ var CodexAgentBridgeSessionImpl = class {
         return;
     }
   }
+  settleCompletedTurn(input) {
+    if (input.turnId === this.activeTurnId) {
+      this.activeTurnId = null;
+    }
+    this.pendingToolItemIds.clear();
+    this.resolveSettlement();
+    if (input.flushDeferred) {
+      this.flushDeferredMessages();
+    }
+  }
   onProcessExit(code) {
     this.rejectAllPending(
       new Error(`Codex app-server exited (code ${code ?? "unknown"})`)
@@ -67841,6 +68106,9 @@ function threadIdFromResult(result) {
 function errorMessage2(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
+function singleLine(message) {
+  return message.replace(/\s+/g, " ").trim();
+}
 
 // src/commands/agent-bridge/harness/codex/index.ts
 function createCodexCommandHandler(input) {

package/dist/index.js

@@ -30455,7 +30455,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.337",
+      version: "0.1.338",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -45020,6 +45020,98 @@ function tomlString(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 
+// src/commands/agent-bridge/harness/codex/turn-retry.ts
+var MAX_CODEX_TURN_RETRY_ATTEMPTS = 3;
+var MAX_CODEX_TURN_RETRY_TOTAL_DELAY_MS = 3e4;
+var CODEX_TURN_RETRY_BACKOFF_BASE_MS = 500;
+var CODEX_TURN_RETRY_MIN_DELAY_MS = 250;
+var CODEX_TURN_RETRY_MAX_DELAY_MS = 1e4;
+var CODEX_TURN_RETRY_JITTER_RATIO = 0.2;
+function classifyRetryableCodexTurnFailure(message) {
+  if (!message) {
+    return null;
+  }
+  const explicitRetryAfterMs = parseExplicitRetryAfterMs(message);
+  const retryAfterMs = explicitRetryAfterMs ?? parseTryAgainDelayMs(message);
+  if (!isRateLimitMessage(message) && explicitRetryAfterMs === null) {
+    return null;
+  }
+  return {
+    cause: "rate_limit",
+    message,
+    retryAfterMs
+  };
+}
+function codexTurnRetryDelayMs(input) {
+  if (input.attempt > MAX_CODEX_TURN_RETRY_ATTEMPTS) {
+    return null;
+  }
+  const remainingDelayBudgetMs = MAX_CODEX_TURN_RETRY_TOTAL_DELAY_MS - input.cumulativeDelayMs;
+  if (remainingDelayBudgetMs <= 0) {
+    return null;
+  }
+  const delayMs = input.failure.retryAfterMs !== null ? boundedRetryAfterMs(input.failure.retryAfterMs) : jitteredBackoffMs(input.attempt);
+  return delayMs <= remainingDelayBudgetMs ? delayMs : null;
+}
+function isRateLimitMessage(message) {
+  return /\b(?:too many requests|tokens per min|tpm)\b/i.test(message) || /\b(?:http\s*)?(?:status(?:\s*code)?|code)\s*[:=]?\s*429\b/i.test(
+    message
+  ) || /\b429\b[^\n.]{0,80}\btoo many requests\b/i.test(message) || /\brate[-\s]?limit(?:ed| reached)?\b/i.test(message);
+}
+function parseExplicitRetryAfterMs(message) {
+  return parseDelayMs(
+    message.match(
+      /\bretry[-\s]?after\b\s*[:=]?\s*(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m)?\b/i
+    )
+  );
+}
+function parseTryAgainDelayMs(message) {
+  return parseDelayMs(
+    message.match(
+      /\b(?:try again|retry)\s+(?:in|after)\s+(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m)?\b/i
+    )
+  );
+}
+function parseDelayMs(match) {
+  if (!match) {
+    return null;
+  }
+  const value = Number.parseFloat(match[1] ?? "");
+  if (!Number.isFinite(value) || value < 0) {
+    return null;
+  }
+  switch ((match[2] ?? "s").toLowerCase()) {
+    case "millisecond":
+    case "milliseconds":
+    case "msec":
+    case "msecs":
+    case "ms":
+      return Math.round(value);
+    case "minute":
+    case "minutes":
+    case "min":
+    case "mins":
+    case "m":
+      return Math.round(value * 6e4);
+    default:
+      return Math.round(value * 1e3);
+  }
+}
+function boundedRetryAfterMs(delayMs) {
+  return Math.min(
+    Math.max(delayMs, CODEX_TURN_RETRY_MIN_DELAY_MS),
+    CODEX_TURN_RETRY_MAX_DELAY_MS
+  );
+}
+function jitteredBackoffMs(attempt) {
+  const baseDelayMs = Math.min(
+    CODEX_TURN_RETRY_BACKOFF_BASE_MS * 2 ** (attempt - 1),
+    CODEX_TURN_RETRY_MAX_DELAY_MS
+  );
+  const jitter = 1 - CODEX_TURN_RETRY_JITTER_RATIO + Math.random() * CODEX_TURN_RETRY_JITTER_RATIO * 2;
+  return boundedRetryAfterMs(Math.round(baseDelayMs * jitter));
+}
+
 // src/commands/agent-bridge/harness/codex/session.ts
 var CODEX_REQUEST_TIMEOUT_MS = 3e4;
 var CODEX_ITEM_SETTLE_TIMEOUT_MS = 1e4;
@@ -45028,6 +45120,7 @@ var CODEX_TOOL_ITEM_TYPES = /* @__PURE__ */ new Set([
   "fileChange",
   "mcpToolCall"
 ]);
+var CODEX_RETRYABLE_ERROR_PAIRING_WINDOW_MS = 1e3;
 function startCodexAgentBridgeSession(input) {
   return new CodexAgentBridgeSessionImpl(input);
 }
@@ -45052,6 +45145,8 @@ var CodexAgentBridgeSessionImpl = class {
   // Messages held in "deferred" mode while a turn is in flight; flushed as a
   // fresh turn once the active turn completes.
   deferredMessages = [];
+  turnRetry = null;
+  pendingRetryableError = null;
   constructor(input) {
     this.input = input;
   }
@@ -45062,6 +45157,13 @@ var CodexAgentBridgeSessionImpl = class {
     await this.ensureStarted();
     const threadId = this.requireThreadId();
     const mode = options?.mode ?? "interrupt";
+    if (this.turnRetry !== null) {
+      this.deferredMessages.push(message);
+      this.input.writeOutput?.(
+        "agent_bridge_codex_message_deferred reason=turn_retry"
+      );
+      return;
+    }
     if (this.activeTurnId === null) {
       await this.startTurn(threadId, message);
       return;
@@ -45097,6 +45199,8 @@ var CodexAgentBridgeSessionImpl = class {
       });
     }
     this.activeTurnId = null;
+    this.turnRetry = null;
+    this.clearPendingRetryableError();
     this.pendingToolItemIds.clear();
     this.resolveSettlement();
     this.rejectAllPending(new Error("Codex session is closed"));
@@ -45199,6 +45303,12 @@ var CodexAgentBridgeSessionImpl = class {
       input: [userTextInput(message)]
     });
   }
+  async startContinuationTurn(threadId) {
+    await this.request("turn/start", {
+      threadId,
+      input: []
+    });
+  }
   // Inject a message into the active turn. Prefers `turn/steer` (codex folds the
   // input into the running turn and owns transcript consistency); falls back to a
   // hard `turn/interrupt` + fresh `turn/start` when the turn cannot be steered.
@@ -45319,10 +45429,7 @@ var CodexAgentBridgeSessionImpl = class {
         this.settleResponse(message.id, message.result, message.error);
         return;
       case "notification":
-        this.trackNotification(message.notification);
-        this.enqueueCallback(
-          () => this.input.onNotification(message.notification)
-        );
+        this.handleNotification(message.notification);
         return;
       case "serverRequest":
         this.enqueueCallback(() => this.input.onServerRequest(message.request));
@@ -45363,6 +45470,156 @@ var CodexAgentBridgeSessionImpl = class {
       }
     });
   }
+  handleNotification(notification) {
+    if (notification.type === "turnCompleted") {
+      this.handleTurnCompletedNotification(notification);
+      return;
+    }
+    if (notification.type === "error") {
+      this.handleErrorNotification(notification);
+      return;
+    }
+    this.trackNotification(notification);
+    this.enqueueCallback(() => this.input.onNotification(notification));
+  }
+  handleErrorNotification(notification) {
+    const retryableFailure = !notification.willRetry && classifyRetryableCodexTurnFailure(notification.message);
+    if (retryableFailure && (this.activeTurnId !== null || this.turnRetry !== null)) {
+      this.holdRetryableError(notification, {
+        releaseOnTimeout: this.turnRetry === null
+      });
+      return;
+    }
+    this.trackNotification(notification);
+    this.enqueueCallback(() => this.input.onNotification(notification));
+  }
+  handleTurnCompletedNotification(notification) {
+    if (notification.status !== "failed") {
+      this.turnRetry = null;
+      this.clearPendingRetryableError();
+      this.trackNotification(notification);
+      this.enqueueCallback(() => this.input.onNotification(notification));
+      return;
+    }
+    const failure = classifyRetryableCodexTurnFailure(
+      notification.errorMessage
+    );
+    if (!failure) {
+      this.turnRetry = null;
+      this.clearPendingRetryableError();
+      this.trackNotification(notification);
+      this.enqueueCallback(() => this.input.onNotification(notification));
+      return;
+    }
+    this.clearPendingRetryableError();
+    const currentRetry = this.turnRetry ?? {
+      originalFailure: notification,
+      attempts: 0,
+      cumulativeDelayMs: 0
+    };
+    const nextAttempt = currentRetry.attempts + 1;
+    const delayMs = codexTurnRetryDelayMs({
+      attempt: nextAttempt,
+      cumulativeDelayMs: currentRetry.cumulativeDelayMs,
+      failure
+    });
+    if (delayMs === null) {
+      this.turnRetry = null;
+      this.settleCompletedTurn({
+        flushDeferred: true,
+        turnId: notification.turnId
+      });
+      this.input.writeOutput?.(
+        `agent_bridge_codex_turn_retry_exhausted attempts=${currentRetry.attempts} total_delay_ms=${currentRetry.cumulativeDelayMs} cause=${failure.cause} original_error=${singleLine(currentRetry.originalFailure.errorMessage ?? "unknown error")}`
+      );
+      this.enqueueCallback(
+        () => this.input.onNotification(currentRetry.originalFailure)
+      );
+      return;
+    }
+    this.turnRetry = {
+      originalFailure: currentRetry.originalFailure,
+      attempts: nextAttempt,
+      cumulativeDelayMs: currentRetry.cumulativeDelayMs + delayMs
+    };
+    this.settleCompletedTurn({
+      flushDeferred: false,
+      turnId: notification.turnId
+    });
+    this.scheduleFailedTurnRetry({
+      attempt: nextAttempt,
+      delayMs,
+      failure,
+      originalFailure: currentRetry.originalFailure
+    });
+  }
+  holdRetryableError(notification, input) {
+    this.clearPendingRetryableError();
+    this.input.writeOutput?.(
+      `agent_bridge_codex_retryable_error_held message=${singleLine(notification.message)}`
+    );
+    const timer = setTimeout(() => {
+      if (this.pendingRetryableError?.notification !== notification) {
+        return;
+      }
+      this.pendingRetryableError = null;
+      if (!input.releaseOnTimeout) {
+        return;
+      }
+      this.enqueueCallback(() => this.input.onNotification(notification));
+    }, CODEX_RETRYABLE_ERROR_PAIRING_WINDOW_MS);
+    timer.unref?.();
+    this.pendingRetryableError = { notification, timer };
+  }
+  clearPendingRetryableError() {
+    if (!this.pendingRetryableError) {
+      return;
+    }
+    clearTimeout(this.pendingRetryableError.timer);
+    this.pendingRetryableError = null;
+  }
+  scheduleFailedTurnRetry(input) {
+    this.input.writeOutput?.(
+      `agent_bridge_codex_turn_retry_scheduled attempt=${input.attempt} max_attempts=${MAX_CODEX_TURN_RETRY_ATTEMPTS} delay_ms=${input.delayMs} cause=${input.failure.cause} error=${singleLine(input.failure.message)}`
+    );
+    const timer = setTimeout(() => {
+      void this.retryFailedTurn(input).catch((error51) => {
+        this.enqueueCallback(() => this.input.onError(error51));
+      });
+    }, input.delayMs);
+    timer.unref?.();
+  }
+  async retryFailedTurn(input) {
+    if (this.closed) {
+      return;
+    }
+    const threadId = this.threadId;
+    if (threadId === null) {
+      this.turnRetry = null;
+      this.clearPendingRetryableError();
+      this.flushDeferredMessages();
+      this.enqueueCallback(
+        () => this.input.onNotification(input.originalFailure)
+      );
+      return;
+    }
+    try {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_turn_retry_starting attempt=${input.attempt} thread_id=${threadId}`
+      );
+      await this.startContinuationTurn(threadId);
+    } catch (error51) {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_turn_retry_failed attempt=${input.attempt} error=${errorMessage2(error51)}`
+      );
+      this.turnRetry = null;
+      this.clearPendingRetryableError();
+      this.flushDeferredMessages();
+      this.enqueueCallback(
+        () => this.input.onNotification(input.originalFailure)
+      );
+    }
+  }
   // Track turn/item lifecycle so steer/interrupt target the live turn and gate on
   // tool-item settlement.
   trackNotification(notification) {
@@ -45371,12 +45628,10 @@ var CodexAgentBridgeSessionImpl = class {
         this.activeTurnId = notification.turnId;
         return;
       case "turnCompleted":
-        if (notification.turnId === this.activeTurnId) {
-          this.activeTurnId = null;
-        }
-        this.pendingToolItemIds.clear();
-        this.resolveSettlement();
-        this.flushDeferredMessages();
+        this.settleCompletedTurn({
+          flushDeferred: true,
+          turnId: notification.turnId
+        });
         return;
       case "itemStarted":
         if (CODEX_TOOL_ITEM_TYPES.has(notification.item.type)) {
@@ -45393,6 +45648,16 @@ var CodexAgentBridgeSessionImpl = class {
         return;
     }
   }
+  settleCompletedTurn(input) {
+    if (input.turnId === this.activeTurnId) {
+      this.activeTurnId = null;
+    }
+    this.pendingToolItemIds.clear();
+    this.resolveSettlement();
+    if (input.flushDeferred) {
+      this.flushDeferredMessages();
+    }
+  }
   onProcessExit(code) {
     this.rejectAllPending(
       new Error(`Codex app-server exited (code ${code ?? "unknown"})`)
@@ -45489,6 +45754,9 @@ function threadIdFromResult(result) {
 function errorMessage2(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
+function singleLine(message) {
+  return message.replace(/\s+/g, " ").trim();
+}
 
 // src/commands/agent-bridge/harness/codex/index.ts
 function createCodexCommandHandler(input) {
@@ -49557,7 +49825,7 @@ function formatSearchText(result, writeLine, style) {
       writeLine(
         `${style.dim(String(match.sequence))} ${match.kind} ${style.label(
           `[${snippet.query}]`
-        )}: ${singleLine(snippet.text)}`
+        )}: ${singleLine2(snippet.text)}`
       );
     }
   }
@@ -49719,16 +49987,16 @@ function entryPreview(event, full) {
         return "";
     }
   });
-  const joined = singleLine(texts.join(" "));
+  const joined = singleLine2(texts.join(" "));
   return full ? joined : clip(joined);
 }
 function preview(value) {
-  return clip(singleLine(stringify5(value)));
+  return clip(singleLine2(stringify5(value)));
 }
 function stringify5(value) {
   return typeof value === "string" ? value : JSON.stringify(value);
 }
-function singleLine(text) {
+function singleLine2(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function clip(text) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autohq/cli",
-  "version": "0.1.337",
+  "version": "0.1.338",
   "license": "SEE LICENSE IN README.md",
   "publishConfig": {
     "access": "public"