@agentclientprotocol/codex-acp 1.1.14 → 1.3.0

package/dist/index.js

@@ -3453,7 +3453,7 @@ var require_main = __commonJS({
     exports.createMessageConnection = createMessageConnection2;
     var ril_1 = __importDefault(require_ril());
     ril_1.default.install();
-    var path6 = __importStar(__require("path"));
+    var path7 = __importStar(__require("path"));
     var os2 = __importStar(__require("os"));
     var fs7 = __importStar(__require("fs"));
     var crypto_1 = __require("crypto");
@@ -3605,7 +3605,7 @@ var require_main = __commonJS({
         throw new Error(`Unable to generate a random pipe name with ${randomLength} characters.`);
       }
       const randomSuffix = (0, crypto_1.randomBytes)(Math.floor(randomLength / 2)).toString("hex");
-      return path6.join(tmpDir, `lsp-${randomSuffix}.sock`);
+      return path7.join(tmpDir, `lsp-${randomSuffix}.sock`);
     }
     function createClientPipeTransport(pipeName, encoding = "utf-8") {
       let connectResolve;
@@ -4509,10 +4509,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path6) {
-  if (!path6)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path6.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4921,11 +4921,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path6, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path6);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -5072,16 +5072,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path6 = []) => {
+  const processError = (error52, path7 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -5108,17 +5108,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path6 = []) => {
+  const processError = (error52, path7 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5150,8 +5150,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path6) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17843,13 +17843,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path6 = ref.slice(1).split("/").filter(Boolean);
-  if (path6.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path6[0] === defsKey) {
-    const key = path6[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -22777,8 +22777,20 @@ function createTerminalOutputMeta(mode, terminalId, data) {
   }
 }
 
+// src/ContextCompactionMeta.ts
+var CONTEXT_COMPACTION_META_KEY = "contextCompaction";
+var CONTEXT_COMPACTION_META_VERSION = 1;
+function createContextCompactionMeta(metadata = {}) {
+  return {
+    [CONTEXT_COMPACTION_META_KEY]: {
+      version: CONTEXT_COMPACTION_META_VERSION,
+      ...metadata
+    }
+  };
+}
+
 // src/CodexToolCallMapper.ts
-var CONTEXT_COMPACTION_META = { contextCompaction: true };
+var CONTEXT_COMPACTION_META = createContextCompactionMeta();
 function toAcpStatus(status) {
   switch (status) {
     case "inProgress":
@@ -22925,8 +22937,8 @@ function createContextCompactionStartUpdate(item) {
   return {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
-    kind: "other",
-    title: "Context compacting",
+    kind: "think",
+    title: "Compact conversation",
     status: "in_progress",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -22935,7 +22947,7 @@ function createContextCompactionCompleteUpdate(item) {
   return {
     sessionUpdate: "tool_call_update",
     toolCallId: item.id,
-    title: "Context compacted",
+    title: "Compact conversation",
     status: "completed",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -22944,8 +22956,8 @@ function createCompletedContextCompactionUpdate(item) {
   return {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
-    kind: "other",
-    title: "Context compacted",
+    kind: "think",
+    title: "Compact conversation",
     status: "completed",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -23235,13 +23247,13 @@ function createTerminalCommandEvent(event, terminalId, cwd) {
     }
   };
 }
-function createSearchTitle(query, path6) {
-  if (query && path6) {
-    return `Search for '${query}' in ${path6}`;
+function createSearchTitle(query, path7) {
+  if (query && path7) {
+    return `Search for '${query}' in ${path7}`;
   } else if (query) {
     return `Search for '${query}'`;
-  } else if (path6) {
-    return `Search in '${path6}'`;
+  } else if (path7) {
+    return `Search in '${path7}'`;
   }
   return "Search";
 }
@@ -23467,12 +23479,12 @@ function revertPatch(unifiedDiff) {
   if (!patch) return null;
   return reversePatch(patch);
 }
-function createUpdateDiffContent(path6, oldText, newText) {
+function createUpdateDiffContent(path7, oldText, newText) {
   return {
     type: "diff",
     oldText,
     newText,
-    path: path6,
+    path: path7,
     _meta: {
       kind: "update"
     }
@@ -23597,10 +23609,104 @@ function sameThreadGoalSnapshot(left, right) {
 }
 
 // src/CodexEventHandler.ts
+import { randomUUID } from "node:crypto";
+
+// src/AirExtension.ts
+var JETBRAINS_META_KEY = "jetbrains";
+var AIR_META_KEY = "air";
+var AIR_EXTENSION_VERSION_KEY = "version";
+var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
+var AIR_SESSION_FAILURE_KEY = "sessionFailure";
+var AIR_EXTENSION_VERSION = 1;
+
+// src/CodexEventHandler.ts
+var MAX_SESSION_FAILURE_TITLE_LENGTH = 240;
+var SESSION_FAILURE_POLICY = {
+  transport_lost: {
+    category: "connection",
+    actions: ["retry", "new_session"]
+  },
+  auth_required: {
+    category: "access",
+    actions: ["login"]
+  },
+  rate_limited: {
+    category: "limit",
+    actions: ["retry"]
+  },
+  quota_exhausted: {
+    category: "limit",
+    actions: []
+  },
+  overloaded: {
+    category: "service",
+    actions: ["retry"]
+  },
+  context_exhausted: {
+    category: "limit",
+    actions: ["new_session"]
+  },
+  budget_exhausted: {
+    category: "limit",
+    actions: ["new_session"]
+  },
+  policy_denied: {
+    category: "request",
+    actions: []
+  },
+  bad_request: {
+    category: "request",
+    actions: []
+  },
+  provider_error: {
+    category: "service",
+    actions: ["retry"]
+  },
+  internal_error: {
+    category: "service",
+    actions: ["retry", "new_session"]
+  }
+};
+var SYNTHETIC_FAILURE_TITLE = {
+  transport_lost: "Connection to Codex was lost.",
+  internal_error: "Codex encountered an internal error."
+};
+function nextSessionFailureRevision(previous, id) {
+  return previous?.id === id ? previous.revision + 1 : 1;
+}
+var STRING_CODEX_ERROR_CATEGORIES = {
+  contextWindowExceeded: "context_exhausted",
+  sessionBudgetExceeded: "budget_exhausted",
+  usageLimitExceeded: "quota_exhausted",
+  serverOverloaded: "overloaded",
+  cyberPolicy: "policy_denied",
+  internalServerError: "internal_error",
+  unauthorized: "auth_required",
+  badRequest: "bad_request",
+  threadRollbackFailed: "provider_error",
+  sandboxError: "provider_error",
+  other: "provider_error"
+};
+var STRUCTURED_CODEX_ERROR_CATEGORIES = {
+  httpConnectionFailed: "transport_lost",
+  responseStreamConnectionFailed: "transport_lost",
+  responseStreamDisconnected: "transport_lost",
+  responseTooManyFailedAttempts: "transport_lost",
+  activeTurnNotSteerable: "provider_error"
+};
 var CodexEventHandler = class _CodexEventHandler {
   static PLAN_UPDATE_INTERVAL_MS = 150;
   sessionState;
   supportsPlanUpdates;
+  supportsTypedSessionFailures;
+  sessionFailureEpoch;
+  pendingErrors = [];
+  failuresById = /* @__PURE__ */ new Map();
+  activeFailureIdByScope = /* @__PURE__ */ new Map();
+  failureTurnIdById = /* @__PURE__ */ new Map();
+  allocatedFailureScopes = /* @__PURE__ */ new Set();
+  lastSessionNotice;
+  nextNoticeId = 1;
   failure = null;
   completedPlan = null;
   activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
@@ -23619,20 +23725,113 @@ var CodexEventHandler = class _CodexEventHandler {
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   agentMessagePhases = /* @__PURE__ */ new Map();
   activeSubAgentActivities = /* @__PURE__ */ new Set();
-  constructor(connection, sessionState, supportsPlanUpdates = false) {
+  constructor(connection, sessionState, supportsPlanUpdates = false, supportsTypedSessionFailures = false, sessionFailureEpoch = randomUUID()) {
     this.sessionState = sessionState;
     this.supportsPlanUpdates = supportsPlanUpdates;
+    this.supportsTypedSessionFailures = supportsTypedSessionFailures;
+    this.sessionFailureEpoch = sessionFailureEpoch;
     this.session = new ACPSessionConnection(connection, sessionState.sessionId);
+    if (sessionState.sessionFailure !== void 0) {
+      this.failuresById.set(sessionState.sessionFailure.id, sessionState.sessionFailure);
+    }
   }
   getFailure() {
     return this.failure;
   }
+  getTerminalSessionFailureMeta(turnId, allowUnattributed = false) {
+    const failure = this.sessionState.sessionFailure;
+    if (!this.supportsTypedSessionFailures || failure === void 0 || (this.failureTurnIdById.get(failure.id) === void 0 ? !allowUnattributed : turnId === null || this.failureTurnIdById.get(failure.id) !== turnId)) {
+      return null;
+    }
+    return this.createSessionFailureMeta(failure);
+  }
+  recordSyntheticTerminalFailure(kind, turnId) {
+    this.recordSessionFailure(kind, turnId ?? void 0, "error", SYNTHETIC_FAILURE_TITLE[kind]);
+  }
+  /**
+   * Handles notifications after the prompt-local handler has been disposed. The app-server subscription
+   * remains installed until the ACP session closes, so terminal errors need a durable session-level path
+   * instead of entering a turn buffer that will never be flushed.
+   */
+  async handleSessionScopedNotification(notification) {
+    if (notification.method !== "error") {
+      await this.handleNotification(notification);
+      return;
+    }
+    if (!this.supportsTypedSessionFailures) {
+      await this.handleNotification(notification);
+      return;
+    }
+    if (notification.params.willRetry) {
+      await this.session.update(this.createSessionFailureUpdate(this.recordRetryWarning(notification.params, false)));
+      return;
+    }
+    const failure = this.recordSessionFailure(
+      this.sessionFailureKind(notification.params.error.codexErrorInfo),
+      notification.params.turnId,
+      "error",
+      notification.params.error.message,
+      void 0,
+      false
+    );
+    await this.session.update(this.createSessionFailureUpdate(failure));
+  }
+  async flushPendingErrors() {
+    if (this.sessionState.currentTurnId === null || this.pendingErrors.length === 0) {
+      return;
+    }
+    const errors = this.pendingErrors.splice(0);
+    for (const error51 of errors) {
+      const update = await this.createErrorEvent(error51);
+      if (update) {
+        await this.session.update(update);
+      }
+    }
+  }
+  async flushPendingErrorsAsSessionScoped() {
+    if (!this.supportsTypedSessionFailures || this.pendingErrors.length === 0) {
+      return;
+    }
+    const errors = this.pendingErrors.splice(0);
+    for (const error51 of errors) {
+      await this.handleSessionScopedNotification({ method: "error", params: error51 });
+    }
+  }
+  async clearSessionFailure() {
+    delete this.sessionState.sessionFailure;
+  }
+  async completeSuccessfulTurn(turnId) {
+    this.lastSessionNotice = void 0;
+    if (!this.supportsTypedSessionFailures || turnId === null) return;
+    const active = this.sessionState.sessionFailure;
+    if (active?.id !== this.activeFailureIdByScope.get(turnId) || active?.severity !== "warning") return;
+    this.activeFailureIdByScope.delete(turnId);
+    delete this.sessionState.sessionFailure;
+  }
+  async handleFailedTurn(turn) {
+    const activeFailure = this.sessionState.sessionFailure;
+    if (!this.supportsTypedSessionFailures || turn.status !== "failed" || this.failure !== null || this.failureTurnIdById.get(activeFailure?.id ?? "") === turn.id && activeFailure?.severity === "error") {
+      return;
+    }
+    const error51 = turn.error ?? {
+      message: "Turn failed",
+      codexErrorInfo: null,
+      additionalDetails: null
+    };
+    this.recordTypedSessionFailure({
+      threadId: this.sessionState.sessionId,
+      turnId: turn.id,
+      willRetry: false,
+      error: error51
+    });
+  }
   takeCompletedPlan() {
     const plan = this.completedPlan;
     this.completedPlan = null;
     return plan;
   }
   async handleNotification(notification) {
+    await this.flushPendingErrors();
     const updateEvent = await this.createUpdateEvent(notification);
     if (updateEvent) {
       await this.session.update(updateEvent);
@@ -23653,6 +23852,14 @@ var CodexEventHandler = class _CodexEventHandler {
   async dispose() {
     if (this.disposed) return;
     await this.flushPendingPlanUpdates();
+    if (this.pendingErrors.length > 0) {
+      logger.log("Discarding app-server errors that arrived before a turn started", {
+        sessionId: this.sessionState.sessionId,
+        count: this.pendingErrors.length,
+        turnIds: this.pendingErrors.map((error51) => error51.turnId)
+      });
+      this.pendingErrors.splice(0);
+    }
     this.disposed = true;
     this.cancelPlanUpdateTimer();
     this.pendingPlanItemIds.clear();
@@ -23662,19 +23869,25 @@ var CodexEventHandler = class _CodexEventHandler {
   async createUpdateEvent(notification) {
     switch (notification.method) {
       case "item/agentMessage/delta":
+        this.completeRetryIncidentOnTurnProgress();
         return await this.createTextEvent(notification.params);
       case "item/plan/delta":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createPlanDeltaEvent(notification.params);
       case "item/started":
+        this.completeRetryIncidentOnTurnProgress();
         return await this.createItemEvent(notification.params);
       case "item/completed":
+        this.completeRetryIncidentOnTurnProgress();
         return await this.completeItemEvent(notification.params);
       case "turn/plan/updated":
+        this.completeRetryIncidentOnTurnProgress();
         return await this.updatePlan(notification.params);
       case "error":
         return await this.createErrorEvent(notification.params);
       case "turn/started":
         this.sessionState.currentTurnId = notification.params.turn.id;
+        await this.flushPendingErrors();
         return null;
       case "turn/completed":
         await this.flushPendingPlanUpdates();
@@ -23707,8 +23920,10 @@ var CodexEventHandler = class _CodexEventHandler {
           closed: true
         });
       case "item/commandExecution/outputDelta":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createCommandOutputDeltaEvent(notification.params);
       case "item/mcpToolCall/progress":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createMcpToolProgressEvent(notification.params);
       case "account/rateLimits/updated":
         this.handleRateLimitsUpdated(notification.params);
@@ -23719,6 +23934,8 @@ var CodexEventHandler = class _CodexEventHandler {
         return this.createWarningEvent(notification.params);
       case "guardianWarning":
         return null;
+      case "deprecationNotice":
+        return this.createDeprecationNoticeEvent(notification.params);
       case "item/autoApprovalReview/started":
         return this.handleGuardianApprovalReviewStarted(notification.params);
       case "item/autoApprovalReview/completed":
@@ -23726,10 +23943,13 @@ var CodexEventHandler = class _CodexEventHandler {
       case "thread/compacted":
         return this.createContextCompactedEvent();
       case "item/reasoning/summaryTextDelta":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createReasoningDeltaEvent(notification.params);
       case "item/reasoning/textDelta":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createReasoningDeltaEvent(notification.params);
       case "item/reasoning/summaryPartAdded":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createReasoningSectionBreakEvent(notification.params);
       case "model/rerouted":
         return this.createModelReroutedEvent(notification.params);
@@ -23772,7 +23992,6 @@ var CodexEventHandler = class _CodexEventHandler {
       case "windowsSandbox/setupCompleted":
       case "account/login/completed":
       case "skills/changed":
-      case "deprecationNotice":
       case "mcpServer/oauthLogin/completed":
       case "externalAgentConfig/import/completed":
       case "rawResponseItem/completed":
@@ -23800,14 +24019,31 @@ var CodexEventHandler = class _CodexEventHandler {
     return createAgentTextMessageChunk(event.delta, event.itemId, createCodexMessagePhaseMeta(phase));
   }
   async createConfigWarningEvent(event) {
-    const detailsText = event.details ? `
+    if (this.supportsTypedSessionFailures) {
+      return this.createSessionFailureUpdate(this.recordSessionNotice(...this.sessionNoticeContent(event.summary, event.details)));
+    }
+    const text = event.details ? `${event.summary}
 
-${event.details}` : "";
-    return createAgentTextMessageChunk(`Config warning: ${event.summary}${detailsText}
+${event.details}` : event.summary;
+    return createAgentTextMessageChunk(`Config warning: ${text}
 
 `);
   }
+  /**
+   * Unlike `warning` and `configWarning`, this notification was dropped outright, so there is no
+   * legacy rendering to preserve. It is surfaced only to clients that negotiated typed records;
+   * every other client keeps seeing exactly what it sees today, which is nothing.
+   */
+  createDeprecationNoticeEvent(event) {
+    if (!this.supportsTypedSessionFailures) return null;
+    return this.createSessionFailureUpdate(
+      this.recordSessionNotice(...this.sessionNoticeContent(event.summary, event.details))
+    );
+  }
   createWarningEvent(event) {
+    if (this.supportsTypedSessionFailures) {
+      return this.createSessionFailureUpdate(this.recordSessionNotice(event.message));
+    }
     return createAgentTextMessageChunk(`Warning: ${event.message}
 
 `);
@@ -24174,7 +24410,33 @@ ${event.stdin}
   }
   async createErrorEvent(params) {
     const error51 = params.error.codexErrorInfo;
+    if (this.sessionState.currentTurnId === null) {
+      this.pendingErrors.push(params);
+      logger.log("Buffered app-server error until the active turn is known", {
+        sessionId: this.sessionState.sessionId,
+        turnId: params.turnId,
+        willRetry: params.willRetry
+      });
+      return null;
+    }
+    if (params.turnId !== this.sessionState.currentTurnId) {
+      if (this.supportsTypedSessionFailures) {
+        const failure = params.willRetry ? this.recordRetryWarning(params) : this.recordSessionFailure(
+          this.sessionFailureKind(params.error.codexErrorInfo),
+          params.turnId,
+          "error",
+          params.error.message
+        );
+        return this.createSessionFailureUpdate(failure);
+      }
+      return this.createCodexSessionInfoUpdate({
+        error: { ...params.error, turnId: params.turnId, willRetry: params.willRetry }
+      });
+    }
     if (params.willRetry) {
+      if (this.supportsTypedSessionFailures) {
+        return this.createSessionFailureUpdate(this.recordRetryWarning(params));
+      }
       return this.createCodexSessionInfoUpdate({
         error: {
           ...params.error,
@@ -24182,7 +24444,12 @@ ${event.stdin}
           willRetry: true
         }
       });
-    } else if (error51 === "usageLimitExceeded") {
+    }
+    if (this.supportsTypedSessionFailures) {
+      this.recordTypedSessionFailure(params);
+      return null;
+    }
+    if (error51 === "usageLimitExceeded") {
       this.failure = RequestError.internalError(
         this.createTurnErrorData(params.error)
       );
@@ -24193,22 +24460,125 @@ ${event.stdin}
 
 `);
   }
+  recordTypedSessionFailure(params) {
+    const kind = this.sessionFailureKind(params.error.codexErrorInfo);
+    this.recordSessionFailure(kind, params.turnId, "error", params.error.message);
+  }
+  recordSessionFailure(kind, turnId, severity, title, actionsOverride, attributeToTurn = true) {
+    const policy = SESSION_FAILURE_POLICY[kind];
+    const scope = turnId ?? this.sessionState.sessionId;
+    const id = this.activeFailureIdByScope.get(scope) ?? this.allocateFailureId(scope, turnId);
+    const previous = this.failuresById.get(id);
+    const failure = {
+      id,
+      revision: nextSessionFailureRevision(previous, id),
+      category: policy.category,
+      severity,
+      title,
+      actions: actionsOverride ?? policy.actions
+    };
+    this.failuresById.set(id, failure);
+    this.failureTurnIdById.set(id, attributeToTurn ? turnId : void 0);
+    this.activeFailureIdByScope.set(scope, id);
+    this.sessionState.sessionFailure = failure;
+    this.lastSessionNotice = void 0;
+    return failure;
+  }
+  allocateFailureId(scope, turnId) {
+    if (turnId !== void 0 && !this.allocatedFailureScopes.has(scope)) {
+      this.allocatedFailureScopes.add(scope);
+      return `${turnId}:error`;
+    }
+    this.allocatedFailureScopes.add(scope);
+    return `${scope}:error:${this.sessionFailureEpoch}:${this.nextNoticeId++}`;
+  }
+  /**
+   * A retry warning remains the active incident until Codex produces turn content again. That content is
+   * the only positive signal available from app-server that the turn recovered; a later error then starts
+   * a new incident instead of overwriting the historical reconnect entry. Terminal errors remain active so
+   * duplicate late notifications cannot append duplicate transcript rows.
+   */
+  completeRetryIncidentOnTurnProgress() {
+    const turnId = this.sessionState.currentTurnId;
+    if (turnId === null) return;
+    const activeId = this.activeFailureIdByScope.get(turnId);
+    if (activeId === void 0 || this.failuresById.get(activeId)?.severity !== "warning") return;
+    this.activeFailureIdByScope.delete(turnId);
+    if (this.sessionState.sessionFailure?.id === activeId) {
+      delete this.sessionState.sessionFailure;
+    }
+  }
+  recordRetryWarning(params, attributeToTurn = true) {
+    const kind = this.sessionFailureKind(params.error.codexErrorInfo);
+    return this.recordSessionFailure(
+      kind,
+      params.turnId,
+      "warning",
+      params.error.message,
+      [],
+      attributeToTurn
+    );
+  }
+  recordSessionNotice(title, details) {
+    const key = `${title}\0${details ?? ""}`;
+    const previous = this.lastSessionNotice?.key === key ? this.lastSessionNotice.failure : void 0;
+    const id = previous?.id ?? `${this.sessionState.sessionId}:notice:${this.sessionFailureEpoch}:${this.nextNoticeId++}`;
+    const notice = {
+      id,
+      revision: nextSessionFailureRevision(previous, id),
+      category: "unknown",
+      severity: "warning",
+      title,
+      ...details === void 0 ? {} : { details },
+      actions: []
+    };
+    this.lastSessionNotice = { key, failure: notice };
+    return notice;
+  }
+  sessionNoticeContent(summary, details) {
+    if (details === null) return [summary];
+    const combinedTitle = `${summary} \u2014 ${details}`;
+    return combinedTitle.length <= MAX_SESSION_FAILURE_TITLE_LENGTH ? [combinedTitle] : [summary, details];
+  }
+  createSessionFailureMeta(failure) {
+    return {
+      [JETBRAINS_META_KEY]: {
+        [AIR_META_KEY]: {
+          [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+          [AIR_SESSION_FAILURE_KEY]: failure
+        }
+      }
+    };
+  }
+  createSessionFailureUpdate(failure) {
+    return {
+      sessionUpdate: "session_info_update",
+      _meta: this.createSessionFailureMeta(failure)
+    };
+  }
+  sessionFailureKind(error51) {
+    if (this.isAuthenticationRequiredError(error51)) return "auth_required";
+    if (this.getHttpStatusCode(error51) === 429) return "rate_limited";
+    if (typeof error51 === "string") {
+      return STRING_CODEX_ERROR_CATEGORIES[error51] ?? "provider_error";
+    }
+    if (error51 !== null) {
+      for (const kind of Object.keys(STRUCTURED_CODEX_ERROR_CATEGORIES)) {
+        if (kind in error51) {
+          return STRUCTURED_CODEX_ERROR_CATEGORIES[kind] ?? "provider_error";
+        }
+      }
+    }
+    return "provider_error";
+  }
   isAuthenticationRequiredError(error51) {
     return error51 === "unauthorized" || this.getHttpStatusCode(error51) === 401;
   }
   getHttpStatusCode(error51) {
-    if (error51 !== null && typeof error51 === "object") {
-      if ("httpConnectionFailed" in error51) {
-        return error51.httpConnectionFailed.httpStatusCode;
-      } else if ("responseStreamConnectionFailed" in error51) {
-        return error51.responseStreamConnectionFailed.httpStatusCode;
-      } else if ("responseStreamDisconnected" in error51) {
-        return error51.responseStreamDisconnected.httpStatusCode;
-      } else if ("responseTooManyFailedAttempts" in error51) {
-        return error51.responseTooManyFailedAttempts.httpStatusCode;
-      }
-    }
-    return null;
+    if (error51 === null || typeof error51 !== "object") return null;
+    const details = Object.values(error51)[0];
+    if (details === null || typeof details !== "object" || !("httpStatusCode" in details)) return null;
+    return typeof details.httpStatusCode === "number" ? details.httpStatusCode : null;
   }
   createTurnErrorData(error51) {
     const data = {
@@ -24637,11 +25007,11 @@ var CodexApprovalHandler = class {
       });
     }
     const fileSystem = permissions.fileSystem;
-    for (const path6 of fileSystem?.read ?? []) {
-      changes.push(this.fileSystemGrantChange(path6, "read", lifetime, suffix));
+    for (const path7 of fileSystem?.read ?? []) {
+      changes.push(this.fileSystemGrantChange(path7, "read", lifetime, suffix));
     }
-    for (const path6 of fileSystem?.write ?? []) {
-      changes.push(this.fileSystemGrantChange(path6, "write", lifetime, suffix));
+    for (const path7 of fileSystem?.write ?? []) {
+      changes.push(this.fileSystemGrantChange(path7, "write", lifetime, suffix));
     }
     for (const entry of fileSystem?.entries ?? []) {
       const matcher = (() => {
@@ -24670,16 +25040,16 @@ var CodexApprovalHandler = class {
     }
     return changes.length > 0 ? { version: 1, changes } : void 0;
   }
-  fileSystemGrantChange(path6, access, lifetime, suffix) {
+  fileSystemGrantChange(path7, access, lifetime, suffix) {
     return {
       type: "grant",
       operation: "grant",
-      description: `Allow ${access} access to ${path6}${suffix}`,
+      description: `Allow ${access} access to ${path7}${suffix}`,
       lifetime,
       targets: [{
         type: "filesystem",
         access: [access],
-        matcher: { type: "exact_path", path: path6 }
+        matcher: { type: "exact_path", path: path7 }
       }]
     };
   }
@@ -25589,15 +25959,15 @@ var wslDefaultBrowser = async () => {
   const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
   return stdout.trim();
 };
-var convertWslPathToWindows = async (path6) => {
-  if (/^[a-z]+:\/\//i.test(path6)) {
-    return path6;
+var convertWslPathToWindows = async (path7) => {
+  if (/^[a-z]+:\/\//i.test(path7)) {
+    return path7;
   }
   try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path6], { encoding: "utf8" });
+    const { stdout } = await execFile2("wslpath", ["-aw", path7], { encoding: "utf8" });
     return stdout.trim();
   } catch {
-    return path6;
+    return path7;
   }
 };
 
@@ -26147,7 +26517,7 @@ var AgentMode = class _AgentMode {
 };
 
 // src/CodexAcpClient.ts
-import path4 from "node:path";
+import path5 from "node:path";
 
 // src/McpServerName.ts
 var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
@@ -26161,7 +26531,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.14",
+  version: "1.3.0",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -26194,6 +26564,7 @@ var package_default = {
     "example:steering": "node --import tsx examples/steering.ts",
     "example:steering:multistep": "node --import tsx examples/steering.ts",
     "generate-types": "./node_modules/.bin/codex app-server generate-ts --out src/app-server",
+    "release:preflight": "bash scripts/release-preflight.sh",
     test: "vitest run",
     "test:e2e": "npm run build && RUN_E2E_TESTS=true vitest run src/__tests__/CodexACPAgent/e2e",
     "test:watch": "vitest",
@@ -26265,8 +26636,58 @@ function createCodexCollaborationMode(mode, currentModelId) {
   };
 }
 
+// src/PathUtils.ts
+import path4 from "node:path";
+function isAbsolutePathLike(value) {
+  const trimmed = value.trim();
+  return path4.isAbsolute(trimmed) || isWindowsAbsolutePath(trimmed);
+}
+function arePathsEqual(left, right) {
+  return normalizePathForComparison(left) === normalizePathForComparison(right);
+}
+function arePathBasenamesEqual(left, right) {
+  const leftBase = path4.posix.basename(normalizePathForComparison(left));
+  const rightBase = path4.posix.basename(normalizePathForComparison(right));
+  if (shouldComparePathCaseInsensitive(left) || shouldComparePathCaseInsensitive(right)) {
+    return leftBase.toLowerCase() === rightBase.toLowerCase();
+  }
+  return leftBase === rightBase;
+}
+function normalizePathForComparison(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return "";
+  }
+  if (isWindowsAbsolutePath(trimmed)) {
+    const normalized2 = path4.win32.normalize(trimmed).replace(/\\/g, "/");
+    return trimTrailingPathSeparators(normalized2).toLowerCase();
+  }
+  const pathForComparison = path4.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
+  const normalized = path4.posix.normalize(pathForComparison);
+  return trimTrailingPathSeparators(normalized);
+}
+function isWindowsAbsolutePath(value) {
+  const portableValue = value.replace(/\\/g, "/");
+  return /^[A-Za-z]:\//.test(portableValue) || /^\/\/[^/]+\/[^/]+/.test(portableValue);
+}
+function shouldComparePathCaseInsensitive(value) {
+  return isWindowsAbsolutePath(value) || /^[A-Za-z]:/.test(value) || value.includes("\\");
+}
+function trimTrailingPathSeparators(value) {
+  let trimmed = value;
+  while (trimmed.endsWith("/") && !isRootPath(trimmed)) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
+}
+function isRootPath(value) {
+  return value === "/" || /^[A-Za-z]:\/$/.test(value) || /^\/\/[^/]+\/[^/]+\/$/.test(value);
+}
+
 // src/CodexAcpClient.ts
 var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
+var OPENAI_PROVIDER_ID = "openai";
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 var SUPPORTED_GATEWAY_PROTOCOLS = {
   openai: "responses"
 };
@@ -26480,34 +26901,47 @@ var CodexAcpClient = class {
     };
   }
   /**
-   * `providers/list`: returns the single client-configurable custom gateway
-   * provider. `current` carries only non-secret routing (never headers), and is
-   * `null` when the provider is not configured/disabled.
+   * `providers/list`: returns Codex's OpenAI slot. With no ACP override, the
+   * slot reports native OpenAI routing; headers are never exposed.
    */
   listProviders() {
     const gatewayConfig = this.gatewayConfig;
     const current = gatewayConfig ? {
       apiType: gatewayApiTypeFromConfig(gatewayConfig),
       baseUrl: gatewayConfig.config.base_url
-    } : null;
+    } : this.getNativeProviderConfig();
     return [
       {
-        providerId: CUSTOM_GATEWAY_PROVIDER_ID,
+        providerId: OPENAI_PROVIDER_ID,
         supported: Object.keys(SUPPORTED_GATEWAY_PROTOCOLS),
         required: false,
         current
       }
     ];
   }
+  getNativeProviderConfig() {
+    const configuredProviderId = this.modelProvider ?? (typeof this.config["model_provider"] === "string" ? this.config["model_provider"] : null);
+    const configuredProviders = this.config["model_providers"];
+    if (configuredProviderId && configuredProviders && typeof configuredProviders === "object" && !Array.isArray(configuredProviders)) {
+      const configuredProvider = configuredProviders[configuredProviderId];
+      if (configuredProvider && typeof configuredProvider === "object" && !Array.isArray(configuredProvider)) {
+        const baseUrl = configuredProvider["base_url"];
+        if (typeof baseUrl === "string" && baseUrl.length > 0) {
+          return { apiType: "openai", baseUrl };
+        }
+      }
+    }
+    return { apiType: "openai", baseUrl: DEFAULT_OPENAI_BASE_URL };
+  }
   /**
    * `providers/set`: replaces the full configuration for the custom gateway
    * provider. Rejects unknown provider ids with `invalid_params`.
    */
   setProvider(request) {
-    if (request.providerId !== CUSTOM_GATEWAY_PROVIDER_ID) {
+    if (request.providerId !== OPENAI_PROVIDER_ID) {
       throw RequestError.invalidParams(
         { providerId: request.providerId },
-        `Unknown providerId "${request.providerId}"; only "${CUSTOM_GATEWAY_PROVIDER_ID}" is configurable`
+        `Unknown providerId "${request.providerId}"; only "${OPENAI_PROVIDER_ID}" is configurable`
       );
     }
     this.applyGatewayConfig({
@@ -26521,7 +26955,7 @@ var CodexAcpClient = class {
    * unknown provider id is idempotent success (RFD behavior §7).
    */
   disableProvider(request) {
-    if (request.providerId === CUSTOM_GATEWAY_PROVIDER_ID) {
+    if (request.providerId === OPENAI_PROVIDER_ID) {
       this.gatewayConfig = null;
     }
   }
@@ -26719,7 +27153,7 @@ var CodexAcpClient = class {
     if (!cwd) {
       return;
     }
-    const skillExtraRoots = additionalRoots.map((root) => path4.join(root, ".agents", "skills"));
+    const skillExtraRoots = additionalRoots.map((root) => path5.join(root, ".agents", "skills"));
     if (!arraysEqual(this.skillExtraRoots, skillExtraRoots)) {
       await this.codexClient.skillsExtraRootsSet({ extraRoots: skillExtraRoots });
       this.skillExtraRoots = skillExtraRoots;
@@ -26910,11 +27344,10 @@ var CodexAcpClient = class {
     const requestedCwd = request.cwd?.trim() ?? null;
     const filterByCwd = (thread) => {
       if (!requestedCwd) return true;
-      if (path4.isAbsolute(requestedCwd)) {
-        return thread.cwd === requestedCwd;
+      if (isAbsolutePathLike(requestedCwd)) {
+        return arePathsEqual(thread.cwd, requestedCwd);
       }
-      const requestedBase = path4.basename(requestedCwd);
-      return path4.basename(thread.cwd) === requestedBase;
+      return arePathBasenamesEqual(thread.cwd, requestedCwd);
     };
     const preferredProvider = this.getModelProvider();
     const modelProviders = preferredProvider ? [preferredProvider] : [];
@@ -26936,7 +27369,7 @@ var CodexAcpClient = class {
     let sessions = listResponse.data.map(mapThreadToSession);
     if (requestedCwd) {
       const filtered = listResponse.data.filter(filterByCwd).map(mapThreadToSession);
-      if (filtered.length > 0 || path4.isAbsolute(requestedCwd)) {
+      if (filtered.length > 0 || isAbsolutePathLike(requestedCwd)) {
         sessions = filtered;
       } else {
         logger.log("Ignoring non-absolute cwd filter for session/list", { cwd: requestedCwd });
@@ -27051,8 +27484,8 @@ function formatUriAsLink(name, uri) {
     return `[@${name}](${uri})`;
   }
   if (uri.startsWith("file://")) {
-    const path6 = uri.replace("file://", "");
-    const fileName = path6.split("/").pop() ?? path6;
+    const path7 = uri.replace("file://", "");
+    const fileName = path7.split("/").pop() ?? path7;
     return `[@${fileName}](${uri})`;
   }
   return uri;
@@ -27082,7 +27515,7 @@ function readAdditionalDirectories(cwd, additionalDirectories, meta3) {
     if (directory.length === 0) {
       throw RequestError.invalidParams(void 0, "additionalDirectories entries must not be empty");
     }
-    if (!path4.isAbsolute(directory)) {
+    if (!path5.isAbsolute(directory)) {
       throw RequestError.invalidParams(void 0, "additionalDirectories entries must be absolute paths");
     }
     if (!seen.has(directory)) {
@@ -27685,7 +28118,7 @@ var SteeringQueue = class {
 
 // src/ResponseItemHistoryFallback.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 function historyFallbackUpdateKey(update) {
   switch (update.sessionUpdate) {
     case "user_message_chunk":
@@ -27925,8 +28358,8 @@ function imageBlocks(images) {
       return [{ type: "text", text: `[@image](${image})` }];
     }
     const record2 = asRecord(image);
-    const path6 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
-    return path6 ? [{ type: "text", text: `[@image](${path6})` }] : [];
+    const path7 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
+    return path7 ? [{ type: "text", text: `[@image](${path7})` }] : [];
   });
 }
 function contentBlocksFromResponseContent(content) {
@@ -28558,10 +28991,10 @@ function baseCommandName(commandName) {
   return commandName.split(/[\\/]/).pop() ?? commandName;
 }
 function absolutizePath(cwd, targetPath) {
-  if (path5.isAbsolute(targetPath) || cwd.length === 0) {
+  if (path6.isAbsolute(targetPath) || cwd.length === 0) {
     return targetPath;
   }
-  return path5.join(cwd, targetPath);
+  return path6.join(cwd, targetPath);
 }
 function withTerminalContent(event, terminalId, cwd) {
   const { rawInput, ...eventWithoutRawInput } = event;
@@ -28717,8 +29150,17 @@ function clientSupportsPlanUpdates(clientCapabilities) {
 }
 
 // src/CodexAcpServer.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
 var IMPLEMENT_PLAN_OPTION_ID = "implement_plan";
 var REVISE_PLAN_OPTION_ID = "revise_plan";
+var CODEX_PROCESS_EXITED_ERROR_CODE = 1001;
+function clientSupportsTypedSessionFailures(capabilities) {
+  const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
+  const air = jetbrains?.[AIR_META_KEY];
+  const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
+  const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
+  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(AIR_SESSION_FAILURE_KEY);
+}
 var CodexAcpServer = class _CodexAcpServer {
   static MODEL_NAME_TOKEN_OVERRIDES = {
     gpt: "GPT",
@@ -28730,6 +29172,7 @@ var CodexAcpServer = class _CodexAcpServer {
   defaultAuthRequest;
   getExitCode;
   getRecentStderr;
+  sessionFailureEpoch;
   availableCommands;
   clientInfo;
   clientCapabilities;
@@ -28759,6 +29202,7 @@ var CodexAcpServer = class _CodexAcpServer {
     this.defaultAuthRequest = defaultAuthRequest ?? null;
     this.getExitCode = getExitCode ?? (() => null);
     this.getRecentStderr = getRecentStderr ?? (() => "");
+    this.sessionFailureEpoch = randomUUID2();
     this.clientInfo = null;
     this.clientCapabilities = null;
     this.terminalOutputMode = "terminal_output_delta";
@@ -28816,6 +29260,12 @@ var CodexAcpServer = class _CodexAcpServer {
           version: GOAL_EXTENSION_VERSION,
           controlMethod: GOAL_CONTROL_METHOD,
           actions: [...GOAL_CONTROL_ACTIONS]
+        },
+        [JETBRAINS_META_KEY]: {
+          [AIR_META_KEY]: {
+            [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+            [AIR_EXTENSION_CAPABILITIES_KEY]: [AIR_SESSION_FAILURE_KEY]
+          }
         }
       }
     };
@@ -29999,8 +30449,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return `[@${name}](${uri})`;
     }
     if (uri.startsWith("file://")) {
-      const path6 = uri.replace("file://", "");
-      const fileName = path6.split("/").pop() ?? path6;
+      const path7 = uri.replace("file://", "");
+      const fileName = path7.split("/").pop() ?? path7;
       return `[@${fileName}](${uri})`;
     }
     return uri;
@@ -30253,6 +30703,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       prompt: params.prompt
     });
     const sessionState = this.getSessionState(params.sessionId);
+    let recoverableSessionFailure = sessionState.sessionFailure;
     sessionState.currentTurnId = null;
     sessionState.lastTokenUsage = null;
     const activePrompt = this.trackActivePrompt(params.sessionId);
@@ -30266,11 +30717,21 @@ Check ${configPath} and project .codex directories, especially their config.toml
     };
     const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
     let eventHandler = null;
+    let promptNotificationsActive = true;
+    const clearRecoveredSessionFailure = async (handler) => {
+      await handler.completeSuccessfulTurn(sessionState.currentTurnId);
+      const current = sessionState.sessionFailure;
+      if (recoverableSessionFailure !== void 0 && current !== void 0 && current.id === recoverableSessionFailure.id && current.revision === recoverableSessionFailure.revision) {
+        await handler.clearSessionFailure();
+      }
+    };
     try {
       const promptEventHandler = new CodexEventHandler(
         this.connection,
         sessionState,
-        clientSupportsPlanUpdates(this.clientCapabilities)
+        clientSupportsPlanUpdates(this.clientCapabilities),
+        clientSupportsTypedSessionFailures(this.clientCapabilities),
+        this.sessionFailureEpoch
       );
       eventHandler = promptEventHandler;
       const approvalHandler = new CodexApprovalHandler(this.connection, sessionState, activePrompt.signal);
@@ -30283,8 +30744,16 @@ Check ${configPath} and project .codex directories, especially their config.toml
       await this.codexAcpClient.subscribeToSessionEvents(
         params.sessionId,
         async (event) => {
+          if (!promptNotificationsActive) {
+            await promptEventHandler.handleSessionScopedNotification(event);
+            return;
+          }
+          const completesActiveTurn = event.method === "turn/completed" && event.params.turn.id === sessionState.currentTurnId;
           await elicitationHandler.handleNotification(event);
-          return promptEventHandler.handleNotification(event);
+          await promptEventHandler.handleNotification(event);
+          if (completesActiveTurn) {
+            promptNotificationsActive = false;
+          }
         },
         approvalHandler,
         elicitationHandler
@@ -30334,8 +30803,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return this.cancelledPromptResponse(sessionState);
       }
       if (commandResult.handled) {
+        promptNotificationsActive = false;
         logger.log("Prompt handled by a command");
         await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+        await eventHandler.flushPendingErrors();
+        await eventHandler.flushPendingErrorsAsSessionScoped();
+        if (commandResult.turnCompleted) {
+          await eventHandler.handleFailedTurn(commandResult.turnCompleted.turn);
+        }
         if (commandResult.turnCompleted?.turn.status === "interrupted") {
           return this.cancelledPromptResponse(sessionState);
         }
@@ -30343,6 +30818,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
         if (error52) {
           throw error52;
         }
+        const terminalFailure2 = this.terminalFailurePromptResponse(
+          sessionState,
+          eventHandler,
+          commandResult.turnCompleted?.turn.id ?? sessionState.currentTurnId
+        );
+        if (terminalFailure2) {
+          return terminalFailure2;
+        }
+        await clearRecoveredSessionFailure(eventHandler);
         return {
           stopReason: "end_turn",
           usage: this.buildPromptUsage(sessionState.lastTokenUsage),
@@ -30408,6 +30892,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return this.cancelledPromptResponse(sessionState);
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+      await eventHandler.flushPendingErrors();
+      await eventHandler.handleFailedTurn(turnCompleted.turn);
+      promptNotificationsActive = false;
       if (turnCompleted.turn.status === "interrupted") {
         await eventHandler.flushPendingPlanUpdates();
         return this.cancelledPromptResponse(sessionState);
@@ -30416,6 +30903,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
       if (error51) {
         throw error51;
       }
+      const terminalFailure = this.terminalFailurePromptResponse(
+        sessionState,
+        eventHandler,
+        turnCompleted.turn.id
+      );
+      if (terminalFailure) {
+        return terminalFailure;
+      }
       await eventHandler.flushPendingPlanUpdates();
       const completedPlan = eventHandler.takeCompletedPlan();
       if (completedPlan !== null && sessionState.collaborationMode === PLAN_COLLABORATION_MODE && !this.promptShouldStop(params.sessionId, activePrompt)) {
@@ -30439,6 +30934,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             prompt: [{ type: "text", text: "Implement the approved plan." }]
           };
           activePrompt.currentTurn = null;
+          sessionState.currentTurnId = null;
           const implementationPromise = this.runWithProcessCheck(
             () => this.codexAcpClient.sendPrompt(
               implementationRequest,
@@ -30456,6 +30952,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
                   return;
                 }
                 sessionState.currentTurnId = turnId;
+                recoverableSessionFailure = sessionState.sessionFailure;
+                promptNotificationsActive = true;
               },
               () => this.promptShouldStop(params.sessionId, activePrompt)
             )
@@ -30474,6 +30972,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
             return this.cancelledPromptResponse(sessionState);
           }
           await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          await eventHandler.flushPendingErrors();
+          await eventHandler.handleFailedTurn(turnCompleted.turn);
+          promptNotificationsActive = false;
           if (turnCompleted.turn.status === "interrupted") {
             await eventHandler.flushPendingPlanUpdates();
             return this.cancelledPromptResponse(sessionState);
@@ -30482,8 +30983,17 @@ Check ${configPath} and project .codex directories, especially their config.toml
           if (implementationError) {
             throw implementationError;
           }
+          const implementationFailure = this.terminalFailurePromptResponse(
+            sessionState,
+            eventHandler,
+            turnCompleted.turn.id
+          );
+          if (implementationFailure) {
+            return implementationFailure;
+          }
         }
       }
+      await clearRecoveredSessionFailure(eventHandler);
       await this.publishFallbackSessionTitle(
         sessionState,
         this.createPromptFallbackTitle(params.prompt)
@@ -30495,8 +31005,29 @@ Check ${configPath} and project .codex directories, especially their config.toml
       };
     } catch (err) {
       logger.error(`Prompt for session ${params.sessionId} failed`, err);
+      if (activePrompt.signal.aborted || this.sessionIsClosing(params.sessionId)) {
+        return this.cancelledPromptResponse(sessionState);
+      }
+      const isProcessExit = err instanceof RequestError && err.code === CODEX_PROCESS_EXITED_ERROR_CODE;
+      const isUnexpectedFailure = !(err instanceof RequestError);
+      if (eventHandler !== null && clientSupportsTypedSessionFailures(this.clientCapabilities) && (isProcessExit || isUnexpectedFailure)) {
+        eventHandler.recordSyntheticTerminalFailure(
+          isProcessExit ? "transport_lost" : "internal_error",
+          sessionState.currentTurnId
+        );
+        const failureResponse = this.terminalFailurePromptResponse(
+          sessionState,
+          eventHandler,
+          sessionState.currentTurnId,
+          true
+        );
+        if (failureResponse !== null) {
+          return failureResponse;
+        }
+      }
       throw err;
     } finally {
+      promptNotificationsActive = false;
       logger.log("Prompt completed", { sessionId: params.sessionId });
       await eventHandler?.dispose();
       disposePromptRequestCancellation();
@@ -30567,6 +31098,20 @@ Check ${configPath} and project .codex directories, especially their config.toml
       _meta: this.buildQuotaMeta(sessionState)
     };
   }
+  terminalFailurePromptResponse(sessionState, eventHandler, turnId, allowUnattributed = false) {
+    const failureMeta = eventHandler.getTerminalSessionFailureMeta(turnId, allowUnattributed);
+    if (failureMeta === null) {
+      return null;
+    }
+    return {
+      stopReason: "end_turn",
+      usage: this.buildPromptUsage(sessionState.lastTokenUsage),
+      _meta: {
+        ...this.buildQuotaMeta(sessionState),
+        ...failureMeta
+      }
+    };
+  }
   buildQuotaMeta(sessionState) {
     const lastTokenUsage = sessionState.lastTokenUsage;
     const modelName = sessionState.currentModelId.replace(/\[.*?]$/, "");
@@ -30589,7 +31134,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return await operation();
     } catch (err) {
       const exitCode = this.getExitCode();
-      const requestErrorCode = 1001;
+      const requestErrorCode = CODEX_PROCESS_EXITED_ERROR_CODE;
       if (exitCode == 3221225781) {
         throw new RequestError(requestErrorCode, `VC++ redistributable should be installed`);
       }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.14",
+  "version": "1.3.0",
   "description": "",
   "main": "dist/index.js",
   "bin": {
@@ -36,6 +36,7 @@
     "example:steering": "node --import tsx examples/steering.ts",
     "example:steering:multistep": "node --import tsx examples/steering.ts",
     "generate-types": "./node_modules/.bin/codex app-server generate-ts --out src/app-server",
+    "release:preflight": "bash scripts/release-preflight.sh",
     "test": "vitest run",
     "test:e2e": "npm run build && RUN_E2E_TESTS=true vitest run src/__tests__/CodexACPAgent/e2e",
     "test:watch": "vitest",