@agentclientprotocol/codex-acp 1.2.0 → 1.4.0

package/dist/index.js

@@ -3453,9 +3453,9 @@ var require_main = __commonJS({
     exports.createMessageConnection = createMessageConnection2;
     var ril_1 = __importDefault(require_ril());
     ril_1.default.install();
-    var path7 = __importStar(__require("path"));
+    var path8 = __importStar(__require("path"));
     var os2 = __importStar(__require("os"));
-    var fs7 = __importStar(__require("fs"));
+    var fs8 = __importStar(__require("fs"));
     var crypto_1 = __require("crypto");
     var net_1 = __require("net");
     var api_1 = require_api();
@@ -3596,7 +3596,7 @@ var require_main = __commonJS({
       }
       let randomLength = 32;
       const fixedLength = "/lsp-.sock".length;
-      const tmpDir = fs7.realpathSync(XDG_RUNTIME_DIR ?? os2.tmpdir());
+      const tmpDir = fs8.realpathSync(XDG_RUNTIME_DIR ?? os2.tmpdir());
       const limit = safeIpcPathLengths.get(process.platform);
       if (limit !== void 0) {
         randomLength = Math.min(limit - tmpDir.length - fixedLength, randomLength);
@@ -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 path7.join(tmpDir, `lsp-${randomSuffix}.sock`);
+      return path8.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, path7) {
-  if (!path7)
+function getElementAtPath(obj, path8) {
+  if (!path8)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path8.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(path7, issues) {
+function prefixIssues(path8, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path8);
     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, path7 = []) => {
+  const processError = (error52, path8 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path8, ...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, path7 = []) => {
+  const processError = (error52, path8 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path8, ...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 path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path8) {
     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 path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.length === 0) {
+  const path8 = ref.slice(1).split("/").filter(Boolean);
+  if (path8.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path8[0] === defsKey) {
+    const key = path8[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -22777,8 +22777,20 @@ function createTerminalOutputMeta(mode, terminalId, data) {
   }
 }
 
+// src/ContextCompactionMeta.ts
+var CONTEXT_COMPACTION_META_KEY = "contextCompaction";
+var CONTEXT_COMPACTION_META_VERSION = 1;
+function createContextCompactionMeta(metadata = {}) {
+  return {
+    [CONTEXT_COMPACTION_META_KEY]: {
+      version: CONTEXT_COMPACTION_META_VERSION,
+      ...metadata
+    }
+  };
+}
+
 // src/CodexToolCallMapper.ts
-var CONTEXT_COMPACTION_META = { contextCompaction: true };
+var CONTEXT_COMPACTION_META = createContextCompactionMeta();
 function toAcpStatus(status) {
   switch (status) {
     case "inProgress":
@@ -22925,8 +22937,8 @@ function createContextCompactionStartUpdate(item) {
   return {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
-    kind: "other",
-    title: "Context compacting",
+    kind: "think",
+    title: "Compact conversation",
     status: "in_progress",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -22935,7 +22947,7 @@ function createContextCompactionCompleteUpdate(item) {
   return {
     sessionUpdate: "tool_call_update",
     toolCallId: item.id,
-    title: "Context compacted",
+    title: "Compact conversation",
     status: "completed",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -22944,8 +22956,8 @@ function createCompletedContextCompactionUpdate(item) {
   return {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
-    kind: "other",
-    title: "Context compacted",
+    kind: "think",
+    title: "Compact conversation",
     status: "completed",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -23235,13 +23247,13 @@ function createTerminalCommandEvent(event, terminalId, cwd) {
     }
   };
 }
-function createSearchTitle(query, path7) {
-  if (query && path7) {
-    return `Search for '${query}' in ${path7}`;
+function createSearchTitle(query, path8) {
+  if (query && path8) {
+    return `Search for '${query}' in ${path8}`;
   } else if (query) {
     return `Search for '${query}'`;
-  } else if (path7) {
-    return `Search in '${path7}'`;
+  } else if (path8) {
+    return `Search in '${path8}'`;
   }
   return "Search";
 }
@@ -23467,12 +23479,12 @@ function revertPatch(unifiedDiff) {
   if (!patch) return null;
   return reversePatch(patch);
 }
-function createUpdateDiffContent(path7, oldText, newText) {
+function createUpdateDiffContent(path8, oldText, newText) {
   return {
     type: "diff",
     oldText,
     newText,
-    path: path7,
+    path: path8,
     _meta: {
       kind: "update"
     }
@@ -23605,22 +23617,65 @@ 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_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
+var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
 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 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",
@@ -23648,6 +23703,12 @@ var CodexEventHandler = class _CodexEventHandler {
   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();
@@ -23672,19 +23733,22 @@ var CodexEventHandler = class _CodexEventHandler {
     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?.phase !== "active" || (failure.turnId === void 0 ? !allowUnattributed : turnId === null || failure.turnId !== turnId)) {
+    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(category, turnId) {
-    this.recordSessionFailure(category, turnId ?? void 0);
+  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
@@ -23701,12 +23765,16 @@ var CodexEventHandler = class _CodexEventHandler {
       return;
     }
     if (notification.params.willRetry) {
-      await this.session.update(this.createSafeErrorDiagnostic(notification.params));
+      await this.session.update(this.createSessionFailureUpdate(this.recordRetryWarning(notification.params, false)));
       return;
     }
     const failure = this.recordSessionFailure(
-      this.sessionFailureCategory(notification.params.error.codexErrorInfo),
-      void 0
+      this.sessionFailureKind(notification.params.error.codexErrorInfo),
+      notification.params.turnId,
+      "error",
+      notification.params.error.message,
+      void 0,
+      false
     );
     await this.session.update(this.createSessionFailureUpdate(failure));
   }
@@ -23732,21 +23800,19 @@ var CodexEventHandler = class _CodexEventHandler {
     }
   }
   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 (!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;
+    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 || activeFailure?.phase === "active" && activeFailure.turnId === turn.id) {
+    if (!this.supportsTypedSessionFailures || turn.status !== "failed" || this.failure !== null || this.failureTurnIdById.get(activeFailure?.id ?? "") === turn.id && activeFailure?.severity === "error") {
       return;
     }
     const error51 = turn.error ?? {
@@ -23805,14 +23871,19 @@ 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);
@@ -23851,8 +23922,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);
@@ -23863,6 +23936,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":
@@ -23870,10 +23945,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);
@@ -23916,7 +23994,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":
@@ -23944,14 +24021,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}
 
 `);
@@ -24329,7 +24423,13 @@ ${event.stdin}
     }
     if (params.turnId !== this.sessionState.currentTurnId) {
       if (this.supportsTypedSessionFailures) {
-        return this.createSafeErrorDiagnostic(params);
+        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 }
@@ -24337,7 +24437,7 @@ ${event.stdin}
     }
     if (params.willRetry) {
       if (this.supportsTypedSessionFailures) {
-        return this.createSafeErrorDiagnostic(params);
+        return this.createSessionFailureUpdate(this.recordRetryWarning(params));
       }
       return this.createCodexSessionInfoUpdate({
         error: {
@@ -24362,39 +24462,86 @@ ${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 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: 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 }
+      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]: {
@@ -24411,7 +24558,7 @@ ${event.stdin}
       _meta: this.createSessionFailureMeta(failure)
     };
   }
-  sessionFailureCategory(error51) {
+  sessionFailureKind(error51) {
     if (this.isAuthenticationRequiredError(error51)) return "auth_required";
     if (this.getHttpStatusCode(error51) === 429) return "rate_limited";
     if (typeof error51 === "string") {
@@ -24862,11 +25009,11 @@ var CodexApprovalHandler = class {
       });
     }
     const fileSystem = permissions.fileSystem;
-    for (const path7 of fileSystem?.read ?? []) {
-      changes.push(this.fileSystemGrantChange(path7, "read", lifetime, suffix));
+    for (const path8 of fileSystem?.read ?? []) {
+      changes.push(this.fileSystemGrantChange(path8, "read", lifetime, suffix));
     }
-    for (const path7 of fileSystem?.write ?? []) {
-      changes.push(this.fileSystemGrantChange(path7, "write", lifetime, suffix));
+    for (const path8 of fileSystem?.write ?? []) {
+      changes.push(this.fileSystemGrantChange(path8, "write", lifetime, suffix));
     }
     for (const entry of fileSystem?.entries ?? []) {
       const matcher = (() => {
@@ -24895,16 +25042,16 @@ var CodexApprovalHandler = class {
     }
     return changes.length > 0 ? { version: 1, changes } : void 0;
   }
-  fileSystemGrantChange(path7, access, lifetime, suffix) {
+  fileSystemGrantChange(path8, access, lifetime, suffix) {
     return {
       type: "grant",
       operation: "grant",
-      description: `Allow ${access} access to ${path7}${suffix}`,
+      description: `Allow ${access} access to ${path8}${suffix}`,
       lifetime,
       targets: [{
         type: "filesystem",
         access: [access],
-        matcher: { type: "exact_path", path: path7 }
+        matcher: { type: "exact_path", path: path8 }
       }]
     };
   }
@@ -25814,15 +25961,15 @@ var wslDefaultBrowser = async () => {
   const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
   return stdout.trim();
 };
-var convertWslPathToWindows = async (path7) => {
-  if (/^[a-z]+:\/\//i.test(path7)) {
-    return path7;
+var convertWslPathToWindows = async (path8) => {
+  if (/^[a-z]+:\/\//i.test(path8)) {
+    return path8;
   }
   try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path7], { encoding: "utf8" });
+    const { stdout } = await execFile2("wslpath", ["-aw", path8], { encoding: "utf8" });
     return stdout.trim();
   } catch {
-    return path7;
+    return path8;
   }
 };
 
@@ -26372,7 +26519,7 @@ var AgentMode = class _AgentMode {
 };
 
 // src/CodexAcpClient.ts
-import path5 from "node:path";
+import path6 from "node:path";
 
 // src/McpServerName.ts
 var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
@@ -26386,7 +26533,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.2.0",
+  version: "1.4.0",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -26539,8 +26686,299 @@ function isRootPath(value) {
   return value === "/" || /^[A-Za-z]:\/$/.test(value) || /^\/\/[^/]+\/[^/]+\/$/.test(value);
 }
 
+// src/AgentFileChangeReport.ts
+import fs7 from "node:fs";
+import path5 from "node:path";
+var AGENT_FILE_CHANGE_REPORT_VERSION = 1;
+var AGENT_FILE_CHANGE_REPORT_TIMEOUT_MS = 3e4;
+var AGENT_FILE_CHANGE_REPORT_MAX_PATHS = 1024;
+var AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH = 4096;
+var AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES = 256 * 1024;
+var AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH = 2e3;
+var AGENT_FILE_CHANGE_REPORT_OUTPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["paths", "complete"],
+  properties: {
+    paths: {
+      type: "array",
+      items: { type: "string" }
+    },
+    complete: { type: "boolean" },
+    uncertainty: {
+      type: "string",
+      maxLength: AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH
+    }
+  }
+};
+var AGENT_FILE_CHANGE_REPORT_DEVELOPER_INSTRUCTIONS = `You are running an internal, read-only file-change audit for the immediately preceding turn.
+Do not modify files, run commands that can modify files, or ask the user questions.
+Report files that the preceding turn causally created, modified, deleted, or moved, including changes made by shell commands, version-control commands, generators, and child processes.
+Do not report files that were only read or inspected.
+You may use read-only inspection when needed. If the list may be incomplete, set complete to false and briefly explain why in uncertainty.`;
+function createAgentFileChangeReportPrompt(workspace) {
+  return `List the paths changed by the immediately preceding turn.
+Return only the structured result required by the output schema.
+Relative paths are resolved against the working directory.
+Working directory: ${JSON.stringify(workspace.cwd)}
+Additional allowed directories: ${JSON.stringify(workspace.additionalDirectories)}`;
+}
+function parseAgentFileChangeReportRequest(meta3) {
+  const jetbrains = asRecord(meta3?.[JETBRAINS_META_KEY]);
+  const air = asRecord(jetbrains?.[AIR_META_KEY]);
+  const request = asRecord(air?.[AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY]);
+  if (request === null || !hasOnlyKeys(request, ["version", "requestId"]) || request["version"] !== AGENT_FILE_CHANGE_REPORT_VERSION) {
+    return null;
+  }
+  const requestId = request["requestId"];
+  if (typeof requestId !== "string" || !/^[A-Za-z0-9._:-]{1,128}$/.test(requestId)) {
+    return null;
+  }
+  return { version: AGENT_FILE_CHANGE_REPORT_VERSION, requestId };
+}
+function createReportedAgentFileChangeReport(requestId, turn, workspace) {
+  const modelReport = parseModelFileChangeReport(turn);
+  const normalized = normalizeModelFileChangeReport(modelReport, workspace);
+  return fitReportedAgentFileChangeReport({
+    version: AGENT_FILE_CHANGE_REPORT_VERSION,
+    requestId,
+    status: "reported",
+    ...normalized
+  });
+}
+function createUnavailableAgentFileChangeReport(requestId, reason) {
+  return {
+    version: AGENT_FILE_CHANGE_REPORT_VERSION,
+    requestId,
+    status: "unavailable",
+    reason
+  };
+}
+var AgentFileChangeReportError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "AgentFileChangeReportError";
+    this.reason = reason;
+  }
+};
+function parseModelFileChangeReport(turn) {
+  switch (turn.status) {
+    case "interrupted":
+      throw new AgentFileChangeReportError("cancelled", "The audit turn was interrupted");
+    case "failed":
+      throw new AgentFileChangeReportError("providerError", "The audit turn failed");
+    case "inProgress":
+      throw new AgentFileChangeReportError("notReported", "The audit turn did not complete");
+    case "completed":
+      break;
+  }
+  let text = null;
+  for (let index = turn.items.length - 1; index >= 0; index -= 1) {
+    const item = turn.items[index];
+    if (item?.type === "agentMessage") {
+      text = item.text;
+      break;
+    }
+  }
+  if (text === null) {
+    throw new AgentFileChangeReportError("notReported", "The audit turn returned no agent message");
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned invalid JSON");
+  }
+  const report = asRecord(value);
+  if (report === null || !hasOnlyKeys(report, ["paths", "complete", "uncertainty"])) {
+    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned an invalid object");
+  }
+  const paths = report["paths"];
+  const complete = report["complete"];
+  const uncertainty = report["uncertainty"];
+  if (!Array.isArray(paths) || !paths.every((item) => typeof item === "string") || typeof complete !== "boolean" || uncertainty !== void 0 && typeof uncertainty !== "string") {
+    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned invalid fields");
+  }
+  const normalizedUncertainty = uncertainty?.trim();
+  if (normalizedUncertainty !== void 0 && normalizedUncertainty.length > AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH) {
+    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned oversized uncertainty");
+  }
+  return {
+    paths,
+    complete,
+    ...normalizedUncertainty ? { uncertainty: normalizedUncertainty } : {}
+  };
+}
+function fitReportedAgentFileChangeReport(report) {
+  const paths = [...report.paths];
+  let truncated = report.truncated;
+  let fitted = report;
+  while (Buffer.byteLength(JSON.stringify(fitted), "utf8") > AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES) {
+    if (paths.length === 0) {
+      throw new AgentFileChangeReportError("invalidOutput", "The audit report exceeds the wire limit");
+    }
+    paths.pop();
+    truncated = true;
+    fitted = {
+      ...report,
+      paths: [...paths],
+      declaredComplete: false,
+      truncated
+    };
+  }
+  return fitted;
+}
+function normalizeModelFileChangeReport(report, workspace) {
+  const cwd = normalizeWorkspaceRoot(workspace.cwd);
+  if (cwd === null) {
+    throw new AgentFileChangeReportError("providerError", "The session working directory is not absolute");
+  }
+  const roots = [cwd, ...workspace.additionalDirectories.flatMap((directory) => {
+    const root = normalizeWorkspaceRoot(directory);
+    return root === null || root.flavor !== cwd.flavor ? [] : [root];
+  })];
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  let totalBytes = 0;
+  let truncated = false;
+  for (const reportedPath of report.paths) {
+    if (reportedPath.length > AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH) {
+      truncated = true;
+      continue;
+    }
+    const normalized = normalizeReportedPath(reportedPath, cwd, roots);
+    if (normalized === null || normalized.value.length > AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH) {
+      truncated = true;
+      continue;
+    }
+    const key = normalized.flavor === "windows" ? normalized.value.toLowerCase() : normalized.value;
+    if (seen.has(key)) {
+      continue;
+    }
+    const bytes = Buffer.byteLength(normalized.value, "utf8");
+    if (paths.length >= AGENT_FILE_CHANGE_REPORT_MAX_PATHS || totalBytes + bytes > AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES) {
+      truncated = true;
+      continue;
+    }
+    seen.add(key);
+    paths.push(normalized.value);
+    totalBytes += bytes;
+  }
+  return {
+    paths,
+    declaredComplete: report.complete && !truncated,
+    truncated,
+    ...report.uncertainty ? { uncertainty: report.uncertainty } : {}
+  };
+}
+function normalizeWorkspaceRoot(value) {
+  const trimmed = value.trim();
+  if (!isValidPathText(trimmed)) {
+    return null;
+  }
+  if (isWindowsAbsolutePath2(trimmed)) {
+    return canonicalizeWorkspaceRoot({
+      value: path5.win32.normalize(trimmed.replace(/\//g, "\\")),
+      flavor: "windows"
+    });
+  }
+  if (path5.posix.isAbsolute(trimmed)) {
+    return canonicalizeWorkspaceRoot({
+      value: path5.posix.normalize(trimmed.replace(/\\/g, "/")),
+      flavor: "posix"
+    });
+  }
+  return null;
+}
+function normalizeReportedPath(value, cwd, roots) {
+  const trimmed = value.trim();
+  if (!isValidPathText(trimmed) || /^[A-Za-z]:[^\\/]/.test(trimmed) || /^\\\\[?.]\\/.test(trimmed) || /^(?:\\\\|\/\/)/.test(trimmed) && !isWindowsAbsolutePath2(trimmed) || cwd.flavor === "windows" && /^\\(?!\\)/.test(trimmed) || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed)) {
+    return null;
+  }
+  let candidate;
+  if (isWindowsAbsolutePath2(trimmed)) {
+    candidate = { value: path5.win32.normalize(trimmed.replace(/\//g, "\\")), flavor: "windows" };
+  } else if (path5.posix.isAbsolute(trimmed)) {
+    candidate = { value: path5.posix.normalize(trimmed.replace(/\\/g, "/")), flavor: "posix" };
+  } else if (cwd.flavor === "windows") {
+    candidate = {
+      value: path5.win32.resolve(cwd.value, trimmed.replace(/\//g, "\\")),
+      flavor: "windows"
+    };
+  } else {
+    candidate = {
+      value: path5.posix.resolve(cwd.value, trimmed.replace(/\\/g, "/")),
+      flavor: "posix"
+    };
+  }
+  candidate = canonicalizeReportedPath(candidate);
+  return roots.some((root) => pathIsStrictlyInside(root, candidate)) ? candidate : null;
+}
+function canonicalizeWorkspaceRoot(root) {
+  if (!isNativePathFlavor(root.flavor)) {
+    return root;
+  }
+  return { ...root, value: canonicalizeFromExistingAncestor(root.value) };
+}
+function canonicalizeReportedPath(candidate) {
+  if (!isNativePathFlavor(candidate.flavor)) {
+    return candidate;
+  }
+  const parent = canonicalizeFromExistingAncestor(path5.dirname(candidate.value));
+  return { ...candidate, value: path5.resolve(parent, path5.basename(candidate.value)) };
+}
+function canonicalizeFromExistingAncestor(value) {
+  const original = path5.resolve(value);
+  let current = original;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const canonical = fs7.realpathSync.native(current);
+      return path5.resolve(canonical, ...missingSegments.reverse());
+    } catch (error51) {
+      if (!isMissingPathError(error51)) return original;
+    }
+    const parent = path5.dirname(current);
+    if (parent === current) return original;
+    missingSegments.push(path5.basename(current));
+    current = parent;
+  }
+}
+function isMissingPathError(error51) {
+  if (typeof error51 !== "object" || error51 === null || !("code" in error51)) return false;
+  return error51.code === "ENOENT" || error51.code === "ENOTDIR";
+}
+function isNativePathFlavor(flavor) {
+  return process.platform === "win32" ? flavor === "windows" : flavor === "posix";
+}
+function pathIsStrictlyInside(root, candidate) {
+  if (root.flavor !== candidate.flavor) {
+    return false;
+  }
+  const pathImplementation = root.flavor === "windows" ? path5.win32 : path5.posix;
+  const relative = pathImplementation.relative(root.value, candidate.value);
+  return relative.length > 0 && !pathImplementation.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${pathImplementation.sep}`);
+}
+function isWindowsAbsolutePath2(value) {
+  const portable = value.replace(/\\/g, "/");
+  return /^[A-Za-z]:\//.test(portable) || /^\/\/[^/]+\/[^/]+(?:\/|$)/.test(portable);
+}
+function isValidPathText(value) {
+  return value.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function hasOnlyKeys(value, allowed) {
+  const allowedKeys = new Set(allowed);
+  return Object.keys(value).every((key) => allowedKeys.has(key));
+}
+
 // 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"
 };
@@ -26754,34 +27192,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({
@@ -26795,7 +27246,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;
     }
   }
@@ -26993,7 +27444,7 @@ var CodexAcpClient = class {
     if (!cwd) {
       return;
     }
-    const skillExtraRoots = additionalRoots.map((root) => path5.join(root, ".agents", "skills"));
+    const skillExtraRoots = additionalRoots.map((root) => path6.join(root, ".agents", "skills"));
     if (!arraysEqual(this.skillExtraRoots, skillExtraRoots)) {
       await this.codexClient.skillsExtraRootsSet({ extraRoots: skillExtraRoots });
       this.skillExtraRoots = skillExtraRoots;
@@ -27115,6 +27566,113 @@ var CodexAcpClient = class {
       serviceTier
     }, onTurnStarted);
   }
+  async runAgentFileChangeReport(params) {
+    if (params.signal?.aborted) {
+      return createUnavailableAgentFileChangeReport(params.requestId, "cancelled");
+    }
+    const budget = new AgentFileChangeReportBudget(params.signal);
+    let forkThreadId = null;
+    let auditTurnId = null;
+    let auditTurnCompleted = false;
+    let lateStopReason = null;
+    try {
+      const forkPromise = this.codexClient.threadFork({
+        threadId: params.sessionId,
+        lastTurnId: params.turnId,
+        cwd: params.workspace.cwd,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+        developerInstructions: AGENT_FILE_CHANGE_REPORT_DEVELOPER_INSTRUCTIONS,
+        ephemeral: true
+      });
+      void forkPromise.then((fork2) => {
+        if (lateStopReason !== null && forkThreadId === null) {
+          void this.unsubscribeAgentFileChangeReportThread(fork2.thread.id, budget);
+        }
+      }, () => {
+      });
+      const fork = await budget.wait(forkPromise);
+      forkThreadId = fork.thread.id;
+      const turnPromise = this.codexClient.runTurn({
+        threadId: forkThreadId,
+        input: [{
+          type: "text",
+          text: createAgentFileChangeReportPrompt(params.workspace),
+          text_elements: []
+        }],
+        cwd: params.workspace.cwd,
+        approvalPolicy: "never",
+        sandboxPolicy: { type: "readOnly", networkAccess: false },
+        summary: "none",
+        outputSchema: AGENT_FILE_CHANGE_REPORT_OUTPUT_SCHEMA
+      }, (turnId) => {
+        auditTurnId = turnId;
+        if (lateStopReason !== null && forkThreadId !== null) {
+          void this.interruptAgentFileChangeReport(forkThreadId, turnId, lateStopReason, budget);
+        }
+      });
+      const outcome = await budget.wait(turnPromise);
+      auditTurnCompleted = true;
+      const thread = await budget.wait(this.codexClient.threadRead({
+        threadId: forkThreadId,
+        includeTurns: true
+      }));
+      const completedTurn = thread.thread.turns.find(
+        (turn) => turn.id === outcome.turn.id
+      );
+      if (completedTurn === void 0) {
+        throw new AgentFileChangeReportError(
+          "notReported",
+          "The completed audit turn was not present in thread history"
+        );
+      }
+      return createReportedAgentFileChangeReport(
+        params.requestId,
+        completedTurn,
+        params.workspace
+      );
+    } catch (error51) {
+      if (error51 instanceof AgentFileChangeReportBudgetError) {
+        lateStopReason = error51.reason;
+        if (!auditTurnCompleted && forkThreadId !== null && auditTurnId !== null) {
+          await this.interruptAgentFileChangeReport(
+            forkThreadId,
+            auditTurnId,
+            error51.reason,
+            budget
+          );
+        }
+        return createUnavailableAgentFileChangeReport(params.requestId, error51.reason);
+      }
+      if (error51 instanceof AgentFileChangeReportError) {
+        logger.log("Agent file-change report unavailable", { reason: error51.reason });
+        return createUnavailableAgentFileChangeReport(params.requestId, error51.reason);
+      }
+      logger.error("Agent file-change report failed", error51);
+      return createUnavailableAgentFileChangeReport(params.requestId, "providerError");
+    } finally {
+      if (forkThreadId !== null) {
+        await this.unsubscribeAgentFileChangeReportThread(forkThreadId, budget);
+      }
+    }
+  }
+  async interruptAgentFileChangeReport(threadId, turnId, reason, budget) {
+    this.codexClient.markTurnStale(threadId, turnId);
+    try {
+      await budget.wait(this.codexClient.turnInterrupt({ threadId, turnId }));
+    } catch (error51) {
+      logger.error(`Failed to interrupt ${reason} agent file-change report`, error51);
+    } finally {
+      this.codexClient.resolveTurnInterrupted(threadId, turnId);
+    }
+  }
+  async unsubscribeAgentFileChangeReportThread(threadId, budget) {
+    try {
+      await budget.wait(this.codexClient.threadUnsubscribe({ threadId }));
+    } catch (error51) {
+      logger.error("Failed to unsubscribe the agent file-change report thread", error51);
+    }
+  }
   async setCollaborationMode(sessionId, mode, currentModelId) {
     await this.codexClient.threadSettingsUpdate({
       threadId: sessionId,
@@ -27265,6 +27823,58 @@ var CodexAcpClient = class {
     };
   }
 };
+var AgentFileChangeReportBudgetError = class extends Error {
+  constructor(reason) {
+    super(`Agent file-change report ${reason}`);
+    this.reason = reason;
+    this.name = "AgentFileChangeReportBudgetError";
+  }
+  reason;
+};
+var AgentFileChangeReportBudget = class {
+  constructor(signal) {
+    this.signal = signal;
+  }
+  signal;
+  deadline = Date.now() + AGENT_FILE_CHANGE_REPORT_TIMEOUT_MS;
+  async wait(operation) {
+    void operation.catch(() => {
+    });
+    const immediateReason = this.stopReason();
+    if (immediateReason !== null) {
+      throw new AgentFileChangeReportBudgetError(immediateReason);
+    }
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (action) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        this.signal?.removeEventListener("abort", onAbort);
+        action();
+      };
+      const onAbort = () => finish(() => reject(new AgentFileChangeReportBudgetError("cancelled")));
+      const timeout = setTimeout(
+        () => finish(() => reject(new AgentFileChangeReportBudgetError("timeout"))),
+        Math.max(1, this.deadline - Date.now())
+      );
+      timeout.unref();
+      this.signal?.addEventListener("abort", onAbort, { once: true });
+      if (this.signal?.aborted) {
+        onAbort();
+      }
+      void operation.then(
+        (value) => finish(() => resolve(value)),
+        (error51) => finish(() => reject(error51))
+      );
+    });
+  }
+  stopReason() {
+    if (this.signal?.aborted) return "cancelled";
+    if (Date.now() >= this.deadline) return "timeout";
+    return null;
+  }
+};
 function buildPromptItems(prompt) {
   return prompt.map((block) => {
     switch (block.type) {
@@ -27324,8 +27934,8 @@ function formatUriAsLink(name, uri) {
     return `[@${name}](${uri})`;
   }
   if (uri.startsWith("file://")) {
-    const path7 = uri.replace("file://", "");
-    const fileName = path7.split("/").pop() ?? path7;
+    const path8 = uri.replace("file://", "");
+    const fileName = path8.split("/").pop() ?? path8;
     return `[@${fileName}](${uri})`;
   }
   return uri;
@@ -27355,7 +27965,7 @@ function readAdditionalDirectories(cwd, additionalDirectories, meta3) {
     if (directory.length === 0) {
       throw RequestError.invalidParams(void 0, "additionalDirectories entries must not be empty");
     }
-    if (!path5.isAbsolute(directory)) {
+    if (!path6.isAbsolute(directory)) {
       throw RequestError.invalidParams(void 0, "additionalDirectories entries must be absolute paths");
     }
     if (!seen.has(directory)) {
@@ -27958,7 +28568,7 @@ var SteeringQueue = class {
 
 // src/ResponseItemHistoryFallback.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 function historyFallbackUpdateKey(update) {
   switch (update.sessionUpdate) {
     case "user_message_chunk":
@@ -28112,14 +28722,14 @@ function parseJsonRecord(line) {
   }
   try {
     const value = JSON.parse(line);
-    return asRecord(value);
+    return asRecord2(value);
   } catch {
     return null;
   }
 }
 function extractResponseItem(record2) {
   if (record2["type"] === "response_item") {
-    return asRecord(record2["payload"]);
+    return asRecord2(record2["payload"]);
   }
   const itemType = record2["type"];
   if (typeof itemType === "string" && isLegacyResponseItemType(itemType)) {
@@ -28153,7 +28763,7 @@ function createEventMsgUpdates(record2) {
   if (record2["type"] !== "event_msg") {
     return null;
   }
-  const payload = asRecord(record2["payload"]);
+  const payload = asRecord2(record2["payload"]);
   if (!payload) {
     return [];
   }
@@ -28197,9 +28807,9 @@ function imageBlocks(images) {
     if (typeof image === "string") {
       return [{ type: "text", text: `[@image](${image})` }];
     }
-    const record2 = asRecord(image);
-    const path7 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
-    return path7 ? [{ type: "text", text: `[@image](${path7})` }] : [];
+    const record2 = asRecord2(image);
+    const path8 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
+    return path8 ? [{ type: "text", text: `[@image](${path8})` }] : [];
   });
 }
 function contentBlocksFromResponseContent(content) {
@@ -28207,7 +28817,7 @@ function contentBlocksFromResponseContent(content) {
     return [];
   }
   return content.flatMap((entry) => {
-    const record2 = asRecord(entry);
+    const record2 = asRecord2(entry);
     if (!record2) {
       return [];
     }
@@ -28240,7 +28850,7 @@ function textParts(value) {
     if (typeof entry === "string") {
       return entry.length > 0 ? [entry] : [];
     }
-    const record2 = asRecord(entry);
+    const record2 = asRecord2(entry);
     if (!record2) {
       return [];
     }
@@ -28332,7 +28942,7 @@ function parseFunctionArguments(value) {
 }
 function rawInputForFunctionCall(name, args) {
   if (name === "exec_command") {
-    const record2 = asRecord(args);
+    const record2 = asRecord2(args);
     if (record2) {
       return {
         command: stringValue(record2["cmd"]) ?? stringValue(record2["command"]),
@@ -28379,14 +28989,14 @@ function functionCallUsesTerminal(item) {
   return item["name"] === "exec_command";
 }
 function commandFromFunctionArguments(args) {
-  const record2 = asRecord(args);
+  const record2 = asRecord2(args);
   if (!record2) {
     return null;
   }
   return stringValue(record2["cmd"]) ?? stringValue(record2["command"]);
 }
 function cwdFromFunctionArguments(args) {
-  const record2 = asRecord(args);
+  const record2 = asRecord2(args);
   if (!record2) {
     return "";
   }
@@ -28831,10 +29441,10 @@ function baseCommandName(commandName) {
   return commandName.split(/[\\/]/).pop() ?? commandName;
 }
 function absolutizePath(cwd, targetPath) {
-  if (path6.isAbsolute(targetPath) || cwd.length === 0) {
+  if (path7.isAbsolute(targetPath) || cwd.length === 0) {
     return targetPath;
   }
-  return path6.join(cwd, targetPath);
+  return path7.join(cwd, targetPath);
 }
 function withTerminalContent(event, terminalId, cwd) {
   const { rawInput, ...eventWithoutRawInput } = event;
@@ -28858,7 +29468,7 @@ function outputText(output) {
     return "";
   }
   return output.flatMap((entry) => {
-    const record2 = asRecord(entry);
+    const record2 = asRecord2(entry);
     if (!record2) {
       return [];
     }
@@ -28874,7 +29484,7 @@ function outputText(output) {
   }).join("\n");
 }
 function parseExitCode(rawOutput, output) {
-  const record2 = asRecord(rawOutput);
+  const record2 = asRecord2(rawOutput);
   if (record2) {
     const exitCode2 = numberValue(record2["exit_code"]) ?? numberValue(record2["exitCode"]);
     if (exitCode2 !== null) {
@@ -28905,7 +29515,7 @@ function looksLikeCommandFailure(output) {
   }
   return /(^|\n)(Error|Failed|Command failed|Sandbox error|No such file or directory|Permission denied|Operation not permitted|ENOENT|EACCES)(:|\b)/i.test(trimmed);
 }
-function asRecord(value) {
+function asRecord2(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return null;
   }
@@ -28994,12 +29604,18 @@ 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) {
+function clientSupportsAirCapability(capabilities, capability) {
   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);
+  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
+}
+function clientSupportsTypedSessionFailures(capabilities) {
+  return clientSupportsAirCapability(capabilities, AIR_SESSION_FAILURE_KEY);
+}
+function clientSupportsAgentFileChangeReports(capabilities) {
+  return clientSupportsAirCapability(capabilities, AIR_AGENT_FILE_CHANGE_REPORT_KEY);
 }
 var CodexAcpServer = class _CodexAcpServer {
   static MODEL_NAME_TOKEN_OVERRIDES = {
@@ -29104,7 +29720,10 @@ var CodexAcpServer = class _CodexAcpServer {
         [JETBRAINS_META_KEY]: {
           [AIR_META_KEY]: {
             [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
-            [AIR_EXTENSION_CAPABILITIES_KEY]: [AIR_SESSION_FAILURE_KEY]
+            [AIR_EXTENSION_CAPABILITIES_KEY]: [
+              AIR_SESSION_FAILURE_KEY,
+              AIR_AGENT_FILE_CHANGE_REPORT_KEY
+            ]
           }
         }
       }
@@ -30155,6 +30774,42 @@ Check ${configPath} and project .codex directories, especially their config.toml
       title
     });
   }
+  async publishAgentFileChangeReport(sessionState, turnId, request, unavailableReason, signal) {
+    let report;
+    try {
+      report = turnId === null ? createUnavailableAgentFileChangeReport(request.requestId, unavailableReason) : await this.codexAcpClient.runAgentFileChangeReport({
+        sessionId: sessionState.sessionId,
+        turnId,
+        // The client owns request-id correlation and duplicate suppression. The wrapper
+        // stays stateless so a retried ACP prompt still receives a terminal report.
+        requestId: request.requestId,
+        workspace: {
+          cwd: sessionState.cwd,
+          additionalDirectories: sessionState.additionalDirectories
+        },
+        signal
+      });
+    } catch (error51) {
+      logger.error("Agent file-change report failed unexpectedly", error51);
+      report = createUnavailableAgentFileChangeReport(request.requestId, "providerError");
+    }
+    try {
+      const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+      await session.update({
+        sessionUpdate: "session_info_update",
+        _meta: {
+          [JETBRAINS_META_KEY]: {
+            [AIR_META_KEY]: {
+              [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+              [AIR_AGENT_FILE_CHANGE_REPORT_KEY]: report
+            }
+          }
+        }
+      });
+    } catch (error51) {
+      logger.error("Failed to publish agent file-change report", error51);
+    }
+  }
   createPromptFallbackTitle(prompt) {
     return this.normalizeSessionTitle(prompt.filter((block) => block.type === "text").map((block) => block.text).join(" "));
   }
@@ -30289,8 +30944,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return `[@${name}](${uri})`;
     }
     if (uri.startsWith("file://")) {
-      const path7 = uri.replace("file://", "");
-      const fileName = path7.split("/").pop() ?? path7;
+      const path8 = uri.replace("file://", "");
+      const fileName = path8.split("/").pop() ?? path8;
       return `[@${fileName}](${uri})`;
     }
     return uri;
@@ -30543,6 +31198,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
       prompt: params.prompt
     });
     const sessionState = this.getSessionState(params.sessionId);
+    const agentFileChangeReportRequest = clientSupportsAgentFileChangeReports(this.clientCapabilities) ? parseAgentFileChangeReportRequest(params._meta) : null;
+    let agentFileChangeReportTurnId = null;
+    let agentFileChangeReportUnavailableReason = "providerError";
     let recoverableSessionFailure = sessionState.sessionFailure;
     sessionState.currentTurnId = null;
     sessionState.lastTokenUsage = null;
@@ -30559,11 +31217,17 @@ Check ${configPath} and project .codex directories, especially their config.toml
     let eventHandler = null;
     let promptNotificationsActive = true;
     const clearRecoveredSessionFailure = async (handler) => {
+      await handler.completeSuccessfulTurn(sessionState.currentTurnId);
       const current = sessionState.sessionFailure;
-      if (recoverableSessionFailure?.phase === "active" && current?.phase === "active" && current.id === recoverableSessionFailure.id && current.revision === recoverableSessionFailure.revision) {
+      if (recoverableSessionFailure !== void 0 && current !== void 0 && current.id === recoverableSessionFailure.id && current.revision === recoverableSessionFailure.revision) {
         await handler.clearSessionFailure();
       }
     };
+    const cancelledPromptResponse = () => {
+      agentFileChangeReportTurnId = null;
+      agentFileChangeReportUnavailableReason = "cancelled";
+      return this.cancelledPromptResponse(sessionState);
+    };
     try {
       const promptEventHandler = new CodexEventHandler(
         this.connection,
@@ -30598,7 +31262,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         elicitationHandler
       );
       if (activePrompt.signal.aborted) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
         onTurnStartPending: () => {
@@ -30639,7 +31303,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         this.cancelBeforeTurnStarted(activePrompt)
       ]);
       if (commandResult === null) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       if (commandResult.handled) {
         promptNotificationsActive = false;
@@ -30651,7 +31315,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           await eventHandler.handleFailedTurn(commandResult.turnCompleted.turn);
         }
         if (commandResult.turnCompleted?.turn.status === "interrupted") {
-          return this.cancelledPromptResponse(sessionState);
+          return cancelledPromptResponse();
         }
         const error52 = eventHandler.getFailure();
         if (error52) {
@@ -30665,6 +31329,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
         if (terminalFailure2) {
           return terminalFailure2;
         }
+        if (commandResult.turnCompleted?.turn.status === "completed") {
+          agentFileChangeReportTurnId = commandResult.turnCompleted.turn.id;
+        } else if (commandResult.turnCompleted === void 0) {
+          agentFileChangeReportUnavailableReason = "notReported";
+        }
         await clearRecoveredSessionFailure(eventHandler);
         return {
           stopReason: "end_turn",
@@ -30674,7 +31343,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
       const effectiveParams = commandResult.prompt === void 0 ? params : { ...params, prompt: commandResult.prompt };
       if (this.sessionIsClosing(params.sessionId)) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       const modelId = ModelId.fromString(sessionState.currentModelId);
       const modelLacksReasoning = sessionState.supportedReasoningEfforts.length > 0 && sessionState.supportedReasoningEfforts.every((e) => e.reasoningEffort === "none");
@@ -30728,7 +31397,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         this.cancelBeforeTurnStarted(activePrompt)
       ]);
       if (turnCompleted === null) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       await eventHandler.flushPendingErrors();
@@ -30736,7 +31405,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       promptNotificationsActive = false;
       if (turnCompleted.turn.status === "interrupted") {
         await eventHandler.flushPendingPlanUpdates();
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       const error51 = eventHandler.getFailure();
       if (error51) {
@@ -30759,7 +31428,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           activePrompt.signal
         );
         if (this.promptShouldStop(params.sessionId, activePrompt)) {
-          return this.cancelledPromptResponse(sessionState);
+          return cancelledPromptResponse();
         }
         if (approved && !this.promptShouldStop(params.sessionId, activePrompt)) {
           await this.applyCollaborationModeChange(sessionState, DEFAULT_COLLABORATION_MODE);
@@ -30808,7 +31477,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             this.cancelBeforeTurnStarted(activePrompt)
           ]);
           if (turnCompleted === null) {
-            return this.cancelledPromptResponse(sessionState);
+            return cancelledPromptResponse();
           }
           await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
           await eventHandler.flushPendingErrors();
@@ -30816,7 +31485,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           promptNotificationsActive = false;
           if (turnCompleted.turn.status === "interrupted") {
             await eventHandler.flushPendingPlanUpdates();
-            return this.cancelledPromptResponse(sessionState);
+            return cancelledPromptResponse();
           }
           const implementationError = eventHandler.getFailure();
           if (implementationError) {
@@ -30832,6 +31501,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
           }
         }
       }
+      if (turnCompleted.turn.status === "completed") {
+        agentFileChangeReportTurnId = turnCompleted.turn.id;
+      }
       await clearRecoveredSessionFailure(eventHandler);
       await this.publishFallbackSessionTitle(
         sessionState,
@@ -30845,13 +31517,17 @@ 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);
+        return cancelledPromptResponse();
       }
+      agentFileChangeReportTurnId = null;
+      agentFileChangeReportUnavailableReason = "providerError";
       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);
+        eventHandler.recordSyntheticTerminalFailure(
+          isProcessExit ? "transport_lost" : "internal_error",
+          sessionState.currentTurnId
+        );
         const failureResponse = this.terminalFailurePromptResponse(
           sessionState,
           eventHandler,
@@ -30865,6 +31541,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
       throw err;
     } finally {
       promptNotificationsActive = false;
+      if (agentFileChangeReportRequest !== null) {
+        await this.publishAgentFileChangeReport(
+          sessionState,
+          agentFileChangeReportTurnId,
+          agentFileChangeReportRequest,
+          agentFileChangeReportUnavailableReason,
+          activePrompt.signal
+        );
+      }
       logger.log("Prompt completed", { sessionId: params.sessionId });
       await eventHandler?.dispose();
       disposePromptRequestCancellation();
@@ -31427,6 +32112,9 @@ var CodexAppServerClient = class {
   async threadResume(params) {
     return await this.sendRequest({ method: "thread/resume", params });
   }
+  async threadFork(params) {
+    return await this.sendRequest({ method: "thread/fork", params });
+  }
   getThreadSettings(threadId) {
     return this.threadSettings.get(threadId);
   }