@agentconnect.md/codex-acp 1.1.9-agentconnect.1 → 1.3.0-agentconnect.1

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}`);
     }
@@ -22787,8 +22787,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":
@@ -22935,8 +22947,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
   };
@@ -22945,7 +22957,7 @@ function createContextCompactionCompleteUpdate(item) {
   return {
     sessionUpdate: "tool_call_update",
     toolCallId: item.id,
-    title: "Context compacted",
+    title: "Compact conversation",
     status: "completed",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -22954,8 +22966,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
   };
@@ -23245,13 +23257,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";
 }
@@ -23477,12 +23489,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"
     }
@@ -23566,22 +23578,37 @@ function createAgentTextThoughtChunk(text, messageId, meta3) {
   return createAgentThoughtChunk({ type: "text", text }, messageId, meta3);
 }
 
-// src/AcpExtensions.ts
-var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
-var SESSION_STEERING_METHOD = "_session/steering";
-var GOAL_CONTROL_METHOD = "_codex/session/goal_control";
-function isExtMethodRequest(request) {
-  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD;
-}
+// src/GoalExtension.ts
+var GOAL_EXTENSION_VERSION = 1;
+var GOAL_CONTROL_METHOD = "_session/goal";
+var LEGACY_GOAL_CONTROL_METHOD = "_codex/session/goal_control";
+var GOAL_CONTROL_ACTIONS = ["set", "pause", "resume", "clear"];
 
 // src/ThreadGoalSnapshot.ts
+function toGoalStatus(status) {
+  switch (status) {
+    case "active":
+    case "paused":
+    case "blocked":
+    case "complete":
+      return status;
+    case "usageLimited":
+    case "budgetLimited":
+      return "limited";
+  }
+}
+function toUnixMilliseconds(timestampSeconds) {
+  return timestampSeconds * 1e3;
+}
 function toThreadGoalSnapshot(goal) {
   return {
     objective: goal.objective.trim(),
-    status: goal.status,
+    status: toGoalStatus(goal.status),
     tokenBudget: goal.tokenBudget,
+    tokensUsed: goal.tokensUsed,
     timeUsedSeconds: goal.timeUsedSeconds,
-    createdAt: goal.createdAt,
+    createdAt: toUnixMilliseconds(goal.createdAt),
+    updatedAt: toUnixMilliseconds(goal.updatedAt),
     controlMethod: GOAL_CONTROL_METHOD
   };
 }
@@ -23592,10 +23619,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();
@@ -23614,20 +23735,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);
@@ -23648,6 +23862,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();
@@ -23657,19 +23879,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();
@@ -23702,8 +23930,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);
@@ -23714,6 +23944,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":
@@ -23721,10 +23953,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);
@@ -23767,7 +24002,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":
@@ -23795,14 +24029,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}
 
 `);
@@ -23819,9 +24070,7 @@ ${event.details}` : "";
       return null;
     }
     this.sessionState.currentGoal = goalSnapshot;
-    return this.createCodexSessionInfoUpdate({
-      goal: goalSnapshot
-    });
+    return this.createGoalSessionInfoUpdate(goalSnapshot);
   }
   createThreadGoalClearedEvent(_event) {
     this.sessionState.goalRevision += 1;
@@ -23829,9 +24078,13 @@ ${event.details}` : "";
       return null;
     }
     this.sessionState.currentGoal = null;
-    return this.createCodexSessionInfoUpdate({
-      goal: null
-    });
+    return this.createGoalSessionInfoUpdate(null);
+  }
+  createGoalSessionInfoUpdate(goal) {
+    return {
+      sessionUpdate: "session_info_update",
+      _meta: { goal }
+    };
   }
   createReasoningDeltaEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
@@ -24167,7 +24420,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,
@@ -24175,7 +24454,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)
       );
@@ -24186,22 +24470,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 = {
@@ -24630,11 +25017,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 = (() => {
@@ -24663,16 +25050,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 }
       }]
     };
   }
@@ -25360,6 +25747,11 @@ var ChatGptAuthMethod = {
   name: "ChatGPT",
   description: "Use ChatGPT to authenticate"
 };
+var ChatGptDeviceCodeAuthMethod = {
+  id: "chat-gpt-device-code",
+  name: "ChatGPT (device code)",
+  description: "Sign in to ChatGPT by opening a verification page and entering a one-time code"
+};
 var GatewayAuthMethod = {
   id: "gateway",
   name: "Custom model gateway",
@@ -25376,6 +25768,9 @@ function getCodexAuthMethods(clientCapabilities, env = process.env) {
   if (!env["NO_BROWSER"]) {
     authMethods.push(ChatGptAuthMethod);
   }
+  if (clientSupportsUrlElicitation(clientCapabilities)) {
+    authMethods.push(ChatGptDeviceCodeAuthMethod);
+  }
   const supportsGatewayAuth = clientCapabilities?.auth?._meta?.["gateway"] === true;
   if (supportsGatewayAuth) {
     authMethods.push(GatewayAuthMethod);
@@ -25383,7 +25778,7 @@ function getCodexAuthMethods(clientCapabilities, env = process.env) {
   return authMethods;
 }
 function isCodexAuthRequest(request) {
-  return request.methodId === "api-key" || request.methodId === "chat-gpt" || request.methodId === "gateway";
+  return request.methodId === "api-key" || request.methodId === "chat-gpt" || request.methodId === "chat-gpt-device-code" || request.methodId === "gateway";
 }
 
 // node_modules/open/index.js
@@ -25574,15 +25969,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;
   }
 };
 
@@ -26132,7 +26527,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;
@@ -26146,7 +26541,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.9-agentconnect.1",
+  version: "1.3.0-agentconnect.1",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -26178,6 +26573,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",
@@ -26206,7 +26602,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.3.0",
-    "@openai/codex": "^0.145.0",
+    "@openai/codex": "^0.147.0",
     diff: "^9.0.0",
     open: "^11.0.0",
     "vscode-jsonrpc": "^9.0.1",
@@ -26249,6 +26645,54 @@ 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/ApprovalsReviewerConfig.ts
 var APPROVALS_REVIEWER_CONFIG_ID = "approvals_reviewer";
 var USER_APPROVALS_REVIEWER = "user";
@@ -26313,6 +26757,8 @@ function permissionProfileForMode(config2, modeId) {
 
 // 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"
 };
@@ -26356,43 +26802,24 @@ var CodexAcpClient = class {
   getHomePath() {
     return this.configPath;
   }
-  async authenticate(authRequest) {
+  async authenticate(authRequest, urlElicitationRequester) {
     if (!isCodexAuthRequest(authRequest)) {
       throw RequestError.invalidRequest();
     }
     this.gatewayConfig = null;
     switch (authRequest.methodId) {
-      case "api-key": {
-        const apiKey = authRequest._meta?.["api-key"]?.apiKey ?? this.readApiKeyFromEnv();
-        return await this.authenticateWithApiKey(apiKey);
-      }
-      case "chat-gpt": {
-        const accountResponse = await this.codexClient.accountRead({ refreshToken: true });
-        if (accountResponse.account?.type === "chatgpt") {
-          return true;
-        }
-        const loginCompletedPromise = this.awaitNextLoginCompleted();
-        const loginResponse = await this.codexClient.accountLogin({ type: "chatgpt" });
-        if (loginResponse.type == "chatgpt") {
-          await open_default(loginResponse.authUrl);
-        }
-        const result = await loginCompletedPromise;
-        return result.success;
-      }
+      case "api-key":
+        return await this.authenticateWithApiKey(authRequest);
+      case "chat-gpt":
+        return await this.authenticateWithChatGpt();
+      case "chat-gpt-device-code":
+        return await this.authenticateWithChatGptDeviceCode(urlElicitationRequester);
       case "gateway":
-        if (!authRequest._meta) throw RequestError.invalidRequest();
-        const gatewaySettings = authRequest._meta["gateway"];
-        if (!gatewaySettings) throw RequestError.invalidRequest();
-        this.applyGatewayConfig({
-          baseUrl: gatewaySettings.baseUrl,
-          apiType: GatewayAuthMethod._meta.gateway.protocol,
-          headers: gatewaySettings.headers,
-          providerName: gatewaySettings.providerName
-        });
-        return true;
+        return this.authenticateWithGateway(authRequest);
     }
   }
-  async authenticateWithApiKey(apiKey) {
+  async authenticateWithApiKey(authRequest) {
+    const apiKey = authRequest._meta?.["api-key"]?.apiKey ?? this.readApiKeyFromEnv();
     const loginCompletedPromise = this.awaitNextLoginCompleted();
     await this.codexClient.accountLogin({
       type: "apiKey",
@@ -26401,6 +26828,56 @@ var CodexAcpClient = class {
     const result = await loginCompletedPromise;
     return result.success;
   }
+  async authenticateWithChatGpt() {
+    const accountResponse = await this.codexClient.accountRead({ refreshToken: true });
+    if (accountResponse.account?.type === "chatgpt") {
+      return true;
+    }
+    const loginCompletedPromise = this.awaitNextLoginCompleted();
+    const loginResponse = await this.codexClient.accountLogin({ type: "chatgpt" });
+    if (loginResponse.type == "chatgpt") {
+      await open_default(loginResponse.authUrl);
+    }
+    const result = await loginCompletedPromise;
+    return result.success;
+  }
+  async authenticateWithChatGptDeviceCode(urlElicitationRequester) {
+    const accountResponse = await this.codexClient.accountRead({ refreshToken: true });
+    if (accountResponse.account?.type === "chatgpt") {
+      return true;
+    }
+    if (!urlElicitationRequester) {
+      throw RequestError.invalidRequest(void 0, "Device code authentication requires URL elicitation support");
+    }
+    const loginCompletedPromise = this.awaitNextLoginCompleted();
+    const loginResponse = await this.codexClient.accountLogin({ type: "chatgptDeviceCode" });
+    if (loginResponse.type !== "chatgptDeviceCode") {
+      return false;
+    }
+    const elicitationResponse = await urlElicitationRequester.elicitUrl({
+      url: loginResponse.verificationUrl,
+      message: `Sign in to ChatGPT and enter this code: ${loginResponse.userCode}`,
+      elicitationId: loginResponse.loginId
+    });
+    if (!CreateElicitationResponse.isAccept(elicitationResponse)) {
+      await this.codexClient.accountLoginCancel({ loginId: loginResponse.loginId });
+      return false;
+    }
+    const result = await loginCompletedPromise;
+    return result.success;
+  }
+  authenticateWithGateway(authRequest) {
+    if (!authRequest._meta) throw RequestError.invalidRequest();
+    const gatewaySettings = authRequest._meta["gateway"];
+    if (!gatewaySettings) throw RequestError.invalidRequest();
+    this.applyGatewayConfig({
+      baseUrl: gatewaySettings.baseUrl,
+      apiType: GatewayAuthMethod._meta.gateway.protocol,
+      headers: gatewaySettings.headers,
+      providerName: gatewaySettings.providerName
+    });
+    return true;
+  }
   readApiKeyFromEnv() {
     for (const envVar of [CODEX_API_KEY_ENV_VAR, OPENAI_API_KEY_ENV_VAR]) {
       const value = process.env[envVar]?.trim();
@@ -26497,34 +26974,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({
@@ -26538,7 +27028,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;
     }
   }
@@ -26659,12 +27149,16 @@ var CodexAcpClient = class {
     const response = await this.codexClient.threadGoalGet({ threadId: sessionId });
     return response?.goal ?? null;
   }
-  async setGoal(sessionId, objective, onTurnStarted) {
-    return await this.codexClient.runGoalSet({
+  async setGoal(sessionId, objective, onTurnStarted, onGoalSet) {
+    const params = {
       threadId: sessionId,
       objective,
       status: "active"
-    }, onTurnStarted);
+    };
+    if (onGoalSet === void 0) {
+      return await this.codexClient.runGoalSet(params, onTurnStarted);
+    }
+    return await this.codexClient.runGoalSet(params, onTurnStarted, void 0, onGoalSet);
   }
   async setGoalStatus(sessionId, status) {
     let updatedGoal = null;
@@ -26679,11 +27173,15 @@ var CodexAcpClient = class {
     }
     return updatedGoal;
   }
-  async resumeGoal(sessionId, onTurnStarted) {
-    return await this.codexClient.runGoalSet({
+  async resumeGoal(sessionId, onTurnStarted, onGoalSet) {
+    const params = {
       threadId: sessionId,
       status: "active"
-    }, onTurnStarted);
+    };
+    if (onGoalSet === void 0) {
+      return await this.codexClient.runGoalSet(params, onTurnStarted);
+    }
+    return await this.codexClient.runGoalSet(params, onTurnStarted, void 0, onGoalSet);
   }
   async clearGoal(sessionId) {
     await this.codexClient.runGoalClear({ threadId: sessionId });
@@ -26746,7 +27244,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;
@@ -26952,11 +27450,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] : [];
@@ -26978,7 +27475,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 });
@@ -27093,8 +27590,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;
@@ -27124,7 +27621,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)) {
@@ -27242,6 +27739,10 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
 }
 
 // src/CodexCommands.ts
+var GOAL_CONTINUATION_PROMPT = [{
+  type: "text",
+  text: "Continue working toward the active goal."
+}];
 var CodexCommands = class {
   connection;
   codexAcpClient;
@@ -27530,7 +28031,7 @@ var CodexCommands = class {
   }
   createGoalCommandResult(turnCompleted) {
     if (turnCompleted === null) {
-      return { handled: true };
+      return { handled: false, prompt: GOAL_CONTINUATION_PROMPT };
     }
     return {
       handled: true,
@@ -27726,7 +28227,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":
@@ -27966,8 +28467,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) {
@@ -28599,10 +29100,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;
@@ -28686,6 +29187,13 @@ function numberValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
+// src/AcpExtensions.ts
+var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
+var SESSION_STEERING_METHOD = "_session/steering";
+function isExtMethodRequest(request) {
+  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === LEGACY_GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD;
+}
+
 // src/FastModeConfig.ts
 var FAST_MODE_CONFIG_ID = "fast-mode";
 var FAST_MODE_CATEGORY = "model_config";
@@ -28751,8 +29259,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",
@@ -28764,6 +29281,7 @@ var CodexAcpServer = class _CodexAcpServer {
   defaultAuthRequest;
   getExitCode;
   getRecentStderr;
+  sessionFailureEpoch;
   availableCommands;
   clientInfo;
   clientCapabilities;
@@ -28777,6 +29295,7 @@ var CodexAcpServer = class _CodexAcpServer {
   closingSessions;
   sessionGenerations;
   sessionOpenGenerations;
+  goalControlGenerations;
   constructor(connection, codexAcpClient, defaultAuthRequest, getExitCode, getRecentStderr) {
     this.sessions = /* @__PURE__ */ new Map();
     this.pendingMcpStartupSessions = /* @__PURE__ */ new Map();
@@ -28786,11 +29305,13 @@ var CodexAcpServer = class _CodexAcpServer {
     this.closingSessions = /* @__PURE__ */ new Map();
     this.sessionGenerations = /* @__PURE__ */ new Map();
     this.sessionOpenGenerations = /* @__PURE__ */ new Map();
+    this.goalControlGenerations = /* @__PURE__ */ new Map();
     this.connection = connection;
     this.codexAcpClient = codexAcpClient;
     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";
@@ -28843,6 +29364,17 @@ var CodexAcpServer = class _CodexAcpServer {
       _meta: {
         steering: {
           supported: true
+        },
+        goal: {
+          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]
+          }
         }
       }
     };
@@ -28863,17 +29395,58 @@ var CodexAcpServer = class _CodexAcpServer {
         return await this.unstable_setSessionModel(this.parseLegacySetSessionModelParams(methodRequest.params));
       case SESSION_STEERING_METHOD:
         return await this.executeOrQueueSteeringRequest(this.parseSessionSteerParams(methodRequest.params));
-      case GOAL_CONTROL_METHOD: {
+      case GOAL_CONTROL_METHOD:
+      case LEGACY_GOAL_CONTROL_METHOD: {
         const sessionState = this.sessions.get(methodRequest.params.sessionId);
         if (!sessionState) {
           throw RequestError.invalidParams(void 0, `Unknown session: ${methodRequest.params.sessionId}`);
         }
         const sessionGeneration = this.getSessionGeneration(sessionState.sessionId);
-        if (methodRequest.params.action === "pause") {
+        const goalControlGeneration = this.bumpGoalControlGeneration(sessionState.sessionId);
+        if (methodRequest.params.action === "set") {
+          const objective = methodRequest.params.objective;
+          let updatedGoal = null;
+          const turnCompleted = await this.runWithProcessCheck(() => this.codexAcpClient.setGoal(
+            sessionState.sessionId,
+            objective,
+            void 0,
+            (goal) => {
+              updatedGoal = goal;
+            }
+          ));
+          if (turnCompleted === null && updatedGoal !== null) {
+            await this.startGoalContinuationIfCurrent(
+              sessionState,
+              sessionGeneration,
+              goalControlGeneration,
+              updatedGoal
+            );
+          }
+        } else if (methodRequest.params.action === "pause") {
           const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionState.sessionId, "paused"));
           if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
             await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(goal), false);
           }
+        } else if (methodRequest.params.action === "resume") {
+          let updatedGoal = null;
+          const turnCompleted = await this.runWithProcessCheck(() => this.codexAcpClient.resumeGoal(
+            sessionState.sessionId,
+            void 0,
+            (goal) => {
+              updatedGoal = goal;
+            }
+          ));
+          if (updatedGoal !== null && this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+            await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(updatedGoal), false);
+          }
+          if (turnCompleted === null && updatedGoal !== null) {
+            await this.startGoalContinuationIfCurrent(
+              sessionState,
+              sessionGeneration,
+              goalControlGeneration,
+              updatedGoal
+            );
+          }
         } else if (methodRequest.params.action === "clear") {
           await this.runWithProcessCheck(() => this.codexAcpClient.clearGoal(sessionState.sessionId));
           if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
@@ -28973,6 +29546,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
   getSessionGeneration(sessionId) {
     return this.sessionGenerations.get(sessionId) ?? 0;
   }
+  bumpGoalControlGeneration(sessionId) {
+    const generation = (this.goalControlGenerations.get(sessionId) ?? 0) + 1;
+    this.goalControlGenerations.set(sessionId, generation);
+    return generation;
+  }
   bumpSessionGeneration(sessionId) {
     const generation = this.getSessionGeneration(sessionId) + 1;
     this.sessionGenerations.set(sessionId, generation);
@@ -29171,6 +29749,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         this.pendingTurnStarts.delete(params.sessionId);
         this.activePrompts.delete(params.sessionId);
         this.steeringQueues.delete(params.sessionId);
+        this.goalControlGenerations.delete(params.sessionId);
       }
       this.endSessionCloseFence(params.sessionId);
     }
@@ -29215,9 +29794,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
       ...this.createSessionConfigOptionsResponse(this.getSessionState(sessionId))
     };
   }
-  async authenticate(_params) {
+  async authenticate(_params, requestId) {
     logger.log("Authenticate request received");
-    const isAuthenticated = await this.runWithProcessCheck(() => this.codexAcpClient.authenticate(_params));
+    const elicitationRequester = this.createUrlElicitationRequester(requestId);
+    const isAuthenticated = await this.runWithProcessCheck(() => this.codexAcpClient.authenticate(_params, elicitationRequester));
     if (!isAuthenticated) {
       logger.log("Authenticate request failed");
       throw RequestError.invalidParams();
@@ -29226,6 +29806,18 @@ Check ${configPath} and project .codex directories, especially their config.toml
     logger.log("Authenticate request completed");
     return {};
   }
+  createUrlElicitationRequester(requestId) {
+    if (requestId == null || !clientSupportsUrlElicitation(this.clientCapabilities)) {
+      return void 0;
+    }
+    return {
+      elicitUrl: (request) => this.connection.request(methods.client.elicitation.create, {
+        mode: "url",
+        requestId,
+        ...request
+      })
+    };
+  }
   async logout(_params) {
     logger.log("Logout request received");
     await this.runWithProcessCheck(() => this.codexAcpClient.logout());
@@ -29529,29 +30121,48 @@ Check ${configPath} and project .codex directories, especially their config.toml
    *     fails or is cancelled before the turn starts.
    */
   async startNewTurnFromSteering(params) {
+    await this.startNewTurnFromExternalPrompt(params, "Steering");
+    return { outcome: "startedNewTurn" };
+  }
+  async startGoalContinuationIfCurrent(sessionState, sessionGeneration, goalControlGeneration, expectedGoal) {
+    await this.startNewTurnFromExternalPrompt({
+      sessionId: sessionState.sessionId,
+      prompt: GOAL_CONTINUATION_PROMPT
+    }, "Goal continuation", async () => {
+      if (!this.goalPublishIsCurrent(sessionState, sessionGeneration) || this.goalControlGenerations.get(sessionState.sessionId) !== goalControlGeneration) {
+        return false;
+      }
+      const currentGoal = await this.runWithProcessCheck(() => this.codexAcpClient.getGoal(sessionState.sessionId));
+      return currentGoal?.status === "active" && currentGoal.objective === expectedGoal.objective && currentGoal.createdAt === expectedGoal.createdAt && this.goalControlGenerations.get(sessionState.sessionId) === goalControlGeneration;
+    });
+  }
+  async startNewTurnFromExternalPrompt(params, source, canStart = async () => true) {
     const previousPrompt = this.activePrompts.get(params.sessionId);
     await previousPrompt?.completion;
     if (this.sessionIsClosing(params.sessionId)) {
       throw RequestError.invalidRequest(`Session ${params.sessionId} is closing`);
     }
+    if (!await canStart()) {
+      return false;
+    }
     return await new Promise((resolve, reject) => {
       let turnStarted = false;
       const promptDone = this.prompt(params, void 0, () => {
         turnStarted = true;
-        logger.log("Steering session started a new turn", { sessionId: params.sessionId });
-        resolve({ outcome: "startedNewTurn" });
+        logger.log(`${source} started a new turn`, { sessionId: params.sessionId });
+        resolve(true);
       });
       promptDone.then(
         (response) => {
           if (!turnStarted && response.stopReason === "cancelled") {
             reject(RequestError.invalidRequest(`Session ${params.sessionId} was cancelled before the steering turn started`));
           } else {
-            resolve({ outcome: "startedNewTurn" });
+            resolve(turnStarted);
           }
         },
         (error51) => {
           if (turnStarted) {
-            logger.error(`Steering-started prompt for session ${params.sessionId} failed`, error51);
+            logger.error(`${source} prompt for session ${params.sessionId} failed`, error51);
           } else {
             reject(error51);
           }
@@ -29667,9 +30278,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     await session.update({
       sessionUpdate: "session_info_update",
       _meta: {
-        codex: {
-          goal: snapshot
-        }
+        goal: snapshot
       }
     });
   }
@@ -29966,8 +30575,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;
@@ -30220,6 +30829,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       prompt: params.prompt
     });
     const sessionState = this.getSessionState(params.sessionId);
+    let recoverableSessionFailure = sessionState.sessionFailure;
     const promptStartTotalTokenUsage = sessionState.totalTokenUsage;
     sessionState.currentTurnId = null;
     sessionState.lastTokenUsage = null;
@@ -30234,11 +30844,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);
@@ -30251,8 +30871,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
@@ -30302,22 +30930,38 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return this.cancelledPromptResponse(sessionState, promptStartTotalTokenUsage);
       }
       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") {
-          await this.notifyConversationInterrupted(params.sessionId);
           return this.cancelledPromptResponse(sessionState, promptStartTotalTokenUsage);
         }
         const error52 = eventHandler.getFailure();
         if (error52) {
           throw error52;
         }
+        const terminalFailure2 = this.terminalFailurePromptResponse(
+          sessionState,
+          eventHandler,
+          commandResult.turnCompleted?.turn.id ?? sessionState.currentTurnId,
+          promptStartTotalTokenUsage
+        );
+        if (terminalFailure2) {
+          return terminalFailure2;
+        }
+        await clearRecoveredSessionFailure(eventHandler);
         return {
           stopReason: "end_turn",
           usage: this.buildPromptUsage(sessionState, promptStartTotalTokenUsage),
           _meta: this.buildQuotaMeta(sessionState)
         };
       }
+      const effectiveParams = commandResult.prompt === void 0 ? params : { ...params, prompt: commandResult.prompt };
       if (this.sessionIsClosing(params.sessionId)) {
         return this.cancelledPromptResponse(sessionState, promptStartTotalTokenUsage);
       }
@@ -30330,7 +30974,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           reason: sessionState.account?.type === "apiKey" ? "API key" : "model lacks reasoning"
         });
       }
-      if (!sessionState.supportedInputModalities.includes("image") && params.prompt.some((b) => b.type === "image")) {
+      if (!sessionState.supportedInputModalities.includes("image") && effectiveParams.prompt.some((b) => b.type === "image")) {
         throw RequestError.invalidRequest("The current model does not support image input");
       }
       const agentMode = sessionState.agentMode;
@@ -30341,7 +30985,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       ensurePendingTurnStart();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
-          params,
+          effectiveParams,
           agentMode,
           sessionState.approvalsReviewer,
           modelId,
@@ -30377,15 +31021,26 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return this.cancelledPromptResponse(sessionState, promptStartTotalTokenUsage);
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+      await eventHandler.flushPendingErrors();
+      await eventHandler.handleFailedTurn(turnCompleted.turn);
+      promptNotificationsActive = false;
       if (turnCompleted.turn.status === "interrupted") {
         await eventHandler.flushPendingPlanUpdates();
-        await this.notifyConversationInterrupted(params.sessionId);
         return this.cancelledPromptResponse(sessionState, promptStartTotalTokenUsage);
       }
       const error51 = eventHandler.getFailure();
       if (error51) {
         throw error51;
       }
+      const terminalFailure = this.terminalFailurePromptResponse(
+        sessionState,
+        eventHandler,
+        turnCompleted.turn.id,
+        promptStartTotalTokenUsage
+      );
+      if (terminalFailure) {
+        return terminalFailure;
+      }
       await eventHandler.flushPendingPlanUpdates();
       const completedPlan = eventHandler.takeCompletedPlan();
       if (completedPlan !== null && sessionState.collaborationMode === PLAN_COLLABORATION_MODE && !this.promptShouldStop(params.sessionId, activePrompt)) {
@@ -30409,6 +31064,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,
@@ -30427,6 +31083,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)
             )
@@ -30445,17 +31103,29 @@ Check ${configPath} and project .codex directories, especially their config.toml
             return this.cancelledPromptResponse(sessionState, promptStartTotalTokenUsage);
           }
           await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          await eventHandler.flushPendingErrors();
+          await eventHandler.handleFailedTurn(turnCompleted.turn);
+          promptNotificationsActive = false;
           if (turnCompleted.turn.status === "interrupted") {
             await eventHandler.flushPendingPlanUpdates();
-            await this.notifyConversationInterrupted(params.sessionId);
             return this.cancelledPromptResponse(sessionState, promptStartTotalTokenUsage);
           }
           const implementationError = eventHandler.getFailure();
           if (implementationError) {
             throw implementationError;
           }
+          const implementationFailure = this.terminalFailurePromptResponse(
+            sessionState,
+            eventHandler,
+            turnCompleted.turn.id,
+            promptStartTotalTokenUsage
+          );
+          if (implementationFailure) {
+            return implementationFailure;
+          }
         }
       }
+      await clearRecoveredSessionFailure(eventHandler);
       await this.publishFallbackSessionTitle(
         sessionState,
         this.createPromptFallbackTitle(params.prompt)
@@ -30467,8 +31137,30 @@ 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, promptStartTotalTokenUsage);
+      }
+      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,
+          promptStartTotalTokenUsage,
+          true
+        );
+        if (failureResponse !== null) {
+          return failureResponse;
+        }
+      }
       throw err;
     } finally {
+      promptNotificationsActive = false;
       logger.log("Prompt completed", { sessionId: params.sessionId });
       await eventHandler?.dispose();
       disposePromptRequestCancellation();
@@ -30539,14 +31231,19 @@ Check ${configPath} and project .codex directories, especially their config.toml
       _meta: this.buildQuotaMeta(sessionState)
     };
   }
-  async notifyConversationInterrupted(sessionId) {
-    if (this.sessionIsClosing(sessionId) || !this.sessions.has(sessionId)) {
-      return;
+  terminalFailurePromptResponse(sessionState, eventHandler, turnId, promptStartTotalTokenUsage, allowUnattributed = false) {
+    const failureMeta = eventHandler.getTerminalSessionFailureMeta(turnId, allowUnattributed);
+    if (failureMeta === null) {
+      return null;
     }
-    await this.connection.notify(methods.client.session.update, {
-      sessionId,
-      update: createAgentTextMessageChunk("*Conversation interrupted*")
-    });
+    return {
+      stopReason: "end_turn",
+      usage: this.buildPromptUsage(sessionState, promptStartTotalTokenUsage),
+      _meta: {
+        ...this.buildQuotaMeta(sessionState),
+        ...failureMeta
+      }
+    };
   }
   buildQuotaMeta(sessionState) {
     const lastTokenUsage = sessionState.lastTokenUsage;
@@ -30571,7 +31268,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`);
       }
@@ -31066,6 +31763,9 @@ var CodexAppServerClient = class {
   async accountLogin(params) {
     return await this.sendRequest({ method: "account/login/start", params });
   }
+  async accountLoginCancel(params) {
+    return await this.sendRequest({ method: "account/login/cancel", params });
+  }
   async accountLogout() {
     return await this.sendRequest({ method: "account/logout", params: void 0 });
   }
@@ -31590,10 +32290,17 @@ var sessionSteerParamsParser = external_exports.object({
   sessionId: external_exports.string(),
   prompt: external_exports.array(external_exports.any())
 }).passthrough();
-var goalControlParamsParser = external_exports.object({
-  sessionId: external_exports.string(),
-  action: external_exports.enum(["pause", "clear"])
-}).passthrough();
+var goalControlParamsParser = external_exports.discriminatedUnion("action", [
+  external_exports.object({
+    sessionId: external_exports.string(),
+    action: external_exports.literal("set"),
+    objective: external_exports.string().trim().min(1)
+  }).passthrough(),
+  external_exports.object({
+    sessionId: external_exports.string(),
+    action: external_exports.enum(["pause", "resume", "clear"])
+  }).passthrough()
+]);
 if (process.argv.includes("--version")) {
   console.log(`${package_default.name} ${package_default.version}`);
   process.exit(0);
@@ -31673,5 +32380,5 @@ function startAcpServer() {
         codexAcpServer = null;
       }
     });
-  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).connect(acpJsonStream);
+  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params, ctx.requestId)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).connect(acpJsonStream);
 }