@agentclientprotocol/codex-acp 1.1.13 → 1.2.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}`);
     }
@@ -23235,13 +23235,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 +23467,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"
     }
@@ -23560,7 +23560,7 @@ function createAgentTextThoughtChunk(text, messageId, meta3) {
 var GOAL_EXTENSION_VERSION = 1;
 var GOAL_CONTROL_METHOD = "_session/goal";
 var LEGACY_GOAL_CONTROL_METHOD = "_codex/session/goal_control";
-var GOAL_CONTROL_ACTIONS = ["pause", "resume", "clear"];
+var GOAL_CONTROL_ACTIONS = ["set", "pause", "resume", "clear"];
 
 // src/ThreadGoalSnapshot.ts
 function toGoalStatus(status) {
@@ -23597,10 +23597,57 @@ 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 SESSION_FAILURE_PRESENTATION = {
+  transport_lost: { message: "Connection to Codex was lost.", retryable: true, actions: ["reconnect", "retry"] },
+  auth_required: { message: "Sign in to continue using Codex.", retryable: false, actions: ["login"] },
+  rate_limited: { message: "The Codex rate limit was reached.", retryable: true, actions: ["retry"] },
+  quota_exhausted: { message: "The Codex usage quota is exhausted.", retryable: false, actions: ["new_session"] },
+  overloaded: { message: "Codex is temporarily overloaded.", retryable: true, actions: ["retry"] },
+  context_exhausted: { message: "This conversation has reached its context limit.", retryable: false, actions: ["new_turn"] },
+  budget_exhausted: { message: "This session has reached its usage budget.", retryable: false, actions: ["new_session"] },
+  policy_denied: { message: "The request was blocked by provider policy.", retryable: false, actions: [] },
+  bad_request: { message: "Codex could not process this request.", retryable: false, actions: ["new_turn"] },
+  provider_error: { message: "The model provider reported an error.", retryable: true, actions: ["retry"] },
+  internal_error: { message: "Codex encountered an internal error.", retryable: true, actions: ["retry"] }
+};
+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 = [];
   failure = null;
   completedPlan = null;
   activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
@@ -23619,20 +23666,108 @@ 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);
   }
   getFailure() {
     return this.failure;
   }
+  getTerminalSessionFailureMeta(turnId, allowUnattributed = false) {
+    const failure = this.sessionState.sessionFailure;
+    if (!this.supportsTypedSessionFailures || failure?.phase !== "active" || (failure.turnId === void 0 ? !allowUnattributed : turnId === null || failure.turnId !== turnId)) {
+      return null;
+    }
+    return this.createSessionFailureMeta(failure);
+  }
+  recordSyntheticTerminalFailure(category, turnId) {
+    this.recordSessionFailure(category, turnId ?? void 0);
+  }
+  /**
+   * 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.createSafeErrorDiagnostic(notification.params));
+      return;
+    }
+    const failure = this.recordSessionFailure(
+      this.sessionFailureCategory(notification.params.error.codexErrorInfo),
+      void 0
+    );
+    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() {
+    const active = this.sessionState.sessionFailure;
+    if (!this.supportsTypedSessionFailures || active?.phase !== "active") {
+      return;
+    }
+    const cleared = {
+      ...active,
+      revision: active.revision + 1,
+      phase: "cleared"
+    };
+    await this.session.update(this.createSessionFailureUpdate(cleared));
+    this.sessionState.sessionFailure = cleared;
+  }
+  async handleFailedTurn(turn) {
+    const activeFailure = this.sessionState.sessionFailure;
+    if (!this.supportsTypedSessionFailures || turn.status !== "failed" || this.failure !== null || activeFailure?.phase === "active" && activeFailure.turnId === turn.id) {
+      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 +23788,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();
@@ -23675,6 +23818,7 @@ var CodexEventHandler = class _CodexEventHandler {
         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();
@@ -24174,7 +24318,27 @@ ${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) {
+        return this.createSafeErrorDiagnostic(params);
+      }
+      return this.createCodexSessionInfoUpdate({
+        error: { ...params.error, turnId: params.turnId, willRetry: params.willRetry }
+      });
+    }
     if (params.willRetry) {
+      if (this.supportsTypedSessionFailures) {
+        return this.createSafeErrorDiagnostic(params);
+      }
       return this.createCodexSessionInfoUpdate({
         error: {
           ...params.error,
@@ -24182,7 +24346,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 +24362,78 @@ ${event.stdin}
 
 `);
   }
+  createSafeErrorDiagnostic(params) {
+    const category = this.sessionFailureCategory(params.error.codexErrorInfo);
+    return this.createCodexSessionInfoUpdate({
+      error: {
+        category,
+        message: SESSION_FAILURE_PRESENTATION[category].message,
+        turnId: params.turnId,
+        willRetry: params.willRetry
+      }
+    });
+  }
+  recordTypedSessionFailure(params) {
+    const category = this.sessionFailureCategory(params.error.codexErrorInfo);
+    this.recordSessionFailure(category, params.turnId);
+  }
+  recordSessionFailure(category, turnId) {
+    const presentation = SESSION_FAILURE_PRESENTATION[category];
+    const previous = this.sessionState.sessionFailure;
+    const id = previous?.phase === "active" ? previous.id : turnId === void 0 ? `${this.sessionState.sessionId}:error:${this.sessionFailureEpoch}` : `${turnId}:error`;
+    const failure = {
+      id,
+      revision: previous?.id === id ? previous.revision + 1 : 1,
+      phase: "active",
+      category,
+      source: "codex",
+      safeMessage: presentation.message,
+      retryable: presentation.retryable,
+      actions: presentation.actions,
+      ...turnId === void 0 ? {} : { turnId }
+    };
+    this.sessionState.sessionFailure = failure;
+    return failure;
+  }
+  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)
+    };
+  }
+  sessionFailureCategory(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 +24862,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 +24895,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 +25814,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 +26372,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 +26386,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.13",
+  version: "1.2.0",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -26194,6 +26419,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",
@@ -26222,7 +26448,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.3.0",
-    "@openai/codex": "^0.146.1",
+    "@openai/codex": "^0.147.0",
     diff: "^9.0.0",
     open: "^11.0.0",
     "vscode-jsonrpc": "^9.0.1",
@@ -26265,6 +26491,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/CodexAcpClient.ts
 var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
 var SUPPORTED_GATEWAY_PROTOCOLS = {
@@ -26624,12 +26898,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;
@@ -26644,11 +26922,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 });
@@ -26711,7 +26993,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;
@@ -26902,11 +27184,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] : [];
@@ -26928,7 +27209,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 });
@@ -27043,8 +27324,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;
@@ -27074,7 +27355,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)) {
@@ -27189,6 +27470,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;
@@ -27477,7 +27762,7 @@ var CodexCommands = class {
   }
   createGoalCommandResult(turnCompleted) {
     if (turnCompleted === null) {
-      return { handled: true };
+      return { handled: false, prompt: GOAL_CONTINUATION_PROMPT };
     }
     return {
       handled: true,
@@ -27673,7 +27958,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":
@@ -27913,8 +28198,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) {
@@ -28546,10 +28831,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;
@@ -28705,8 +28990,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",
@@ -28718,6 +29012,7 @@ var CodexAcpServer = class _CodexAcpServer {
   defaultAuthRequest;
   getExitCode;
   getRecentStderr;
+  sessionFailureEpoch;
   availableCommands;
   clientInfo;
   clientCapabilities;
@@ -28731,6 +29026,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();
@@ -28740,11 +29036,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";
@@ -28802,6 +29100,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]
+          }
         }
       }
     };
@@ -28829,12 +29133,51 @@ var CodexAcpServer = class _CodexAcpServer {
           throw RequestError.invalidParams(void 0, `Unknown session: ${methodRequest.params.sessionId}`);
         }
         const sessionGeneration = this.getSessionGeneration(sessionState.sessionId);
-        if (methodRequest.params.action === "pause" || methodRequest.params.action === "resume") {
-          const status = methodRequest.params.action === "pause" ? "paused" : "active";
-          const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionState.sessionId, status));
+        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)) {
@@ -28934,6 +29277,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);
@@ -29131,6 +29479,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);
     }
@@ -29488,29 +29837,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);
           }
@@ -29921,8 +30289,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;
@@ -30175,6 +30543,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);
@@ -30188,11 +30557,20 @@ 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) => {
+      const current = sessionState.sessionFailure;
+      if (recoverableSessionFailure?.phase === "active" && current?.phase === "active" && 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);
@@ -30205,8 +30583,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
@@ -30256,8 +30642,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);
         }
@@ -30265,12 +30657,22 @@ 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),
           _meta: this.buildQuotaMeta(sessionState)
         };
       }
+      const effectiveParams = commandResult.prompt === void 0 ? params : { ...params, prompt: commandResult.prompt };
       if (this.sessionIsClosing(params.sessionId)) {
         return this.cancelledPromptResponse(sessionState);
       }
@@ -30283,7 +30685,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;
@@ -30294,7 +30696,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       ensurePendingTurnStart();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
-          params,
+          effectiveParams,
           agentMode,
           modelId,
           serviceTier,
@@ -30329,6 +30731,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);
@@ -30337,6 +30742,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)) {
@@ -30360,6 +30773,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,
@@ -30377,6 +30791,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)
             )
@@ -30395,6 +30811,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);
@@ -30403,8 +30822,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)
@@ -30416,8 +30844,27 @@ 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)) {
+        const category = isProcessExit ? "transport_lost" : "internal_error";
+        eventHandler.recordSyntheticTerminalFailure(category, 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();
@@ -30488,6 +30935,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(/\[.*?]$/, "");
@@ -30510,7 +30971,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`);
       }
@@ -31532,10 +31993,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", "resume", "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);

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.13",
+  "version": "1.2.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",
@@ -64,7 +65,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
-    "@openai/codex": "^0.146.1",
+    "@openai/codex": "^0.147.0",
     "diff": "^9.0.0",
     "open": "^11.0.0",
     "vscode-jsonrpc": "^9.0.1",