@agentconnect.md/codex-acp 1.10.0-agentconnect.2 → 1.12.0-agentconnect.1

package/dist/index.js

@@ -22782,6 +22782,111 @@ function reversePatch(structuredPatch) {
   return reversed;
 }
 
+// src/DiffStats.ts
+var DiffStatsCalculator = class {
+  addedFile(text) {
+    return { version: 1, added: this.lineCount(text), removed: 0 };
+  }
+  deletedFile(text) {
+    return { version: 1, added: 0, removed: this.lineCount(text) };
+  }
+  update(patch) {
+    if (patch.isBinary || patch.hunks.length === 0) return null;
+    let added = 0;
+    let removed = 0;
+    let previousOldEnd = 1;
+    let previousNewEnd = 1;
+    for (const hunk of patch.hunks) {
+      const { oldStart, oldLines, newStart, newLines } = hunk;
+      if (![oldStart, oldLines, newStart, newLines].every(Number.isSafeInteger) || oldStart < previousOldEnd || newStart < previousNewEnd || oldLines < 0 || newLines < 0 || newStart - oldStart !== added - removed) return null;
+      let oldConsumed = 0;
+      let newConsumed = 0;
+      let previousWasContent = false;
+      for (const line of hunk.lines) {
+        switch (line[0]) {
+          case "+":
+            added++;
+            newConsumed++;
+            previousWasContent = true;
+            break;
+          case "-":
+            removed++;
+            oldConsumed++;
+            previousWasContent = true;
+            break;
+          case " ":
+          case void 0:
+            oldConsumed++;
+            newConsumed++;
+            previousWasContent = true;
+            break;
+          case "\\":
+            if (!previousWasContent || line.replace(/\r$/, "") !== "\") return null;
+            previousWasContent = false;
+            break;
+          default:
+            return null;
+        }
+      }
+      if (oldConsumed !== oldLines || newConsumed !== newLines) return null;
+      previousOldEnd = oldStart + oldLines;
+      previousNewEnd = newStart + newLines;
+    }
+    return { version: 1, added, removed };
+  }
+  lineCount(text) {
+    let count = 0;
+    for (let offset = text.indexOf("\n"); offset >= 0; offset = text.indexOf("\n", offset + 1)) count++;
+    for (let offset = text.indexOf("\r"); offset >= 0; offset = text.indexOf("\r", offset + 1)) {
+      if (text[offset + 1] !== "\n") count++;
+    }
+    if (text.length > 0 && !text.endsWith("\n") && !text.endsWith("\r")) count++;
+    return count;
+  }
+};
+
+// 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_DIFF_STATS_KEY = "diffStats";
+var AIR_SESSION_FAILURE_KEY = "sessionFailure";
+var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
+var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
+var AIR_ASYNC_TASKS_KEY = "asyncTasks";
+var AIR_RECOMMENDED_CONFIG_VALUE_KEY = "recommendedValue";
+var AIR_ASYNC_TASKS_BACKGROUNDED_KEY = "backgrounded";
+var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
+var AIR_EXTENSION_VERSION = 1;
+function withAirMeta(meta3, key, value) {
+  const root = asRecord(meta3);
+  const jetbrains = asRecord(root[JETBRAINS_META_KEY]);
+  const air = asRecord(jetbrains[AIR_META_KEY]);
+  return {
+    ...root,
+    [JETBRAINS_META_KEY]: {
+      ...jetbrains,
+      [AIR_META_KEY]: {
+        ...air,
+        [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+        [key]: value
+      }
+    }
+  };
+}
+function clientSupportsAirCapability(capabilities, capability) {
+  const meta3 = asRecord(capabilities?._meta);
+  const jetbrains = asRecord(meta3[JETBRAINS_META_KEY]);
+  const air = asRecord(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(capability);
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
 // src/CodexToolCallMapper.ts
 import { readFile } from "node:fs/promises";
 import path2 from "node:path";
@@ -22834,8 +22939,26 @@ function createContextCompactionMeta(metadata = {}) {
   };
 }
 
+// src/ToolCallName.ts
+function functionToolName(name, namespace) {
+  return `${namespace ?? ""}${name}`;
+}
+function commandToolName(source) {
+  switch (source) {
+    case "unifiedExecStartup":
+      return "exec_command";
+    case "unifiedExecInteraction":
+      return "write_stdin";
+    // These sources do not identify a unique model tool.
+    case "agent":
+    case "userShell":
+      return void 0;
+  }
+}
+
 // src/CodexToolCallMapper.ts
 var CONTEXT_COMPACTION_META = createContextCompactionMeta();
+var DIFF_STATS = new DiffStatsCalculator();
 function toAcpStatus(status) {
   switch (status) {
     case "inProgress":
@@ -22864,14 +22987,19 @@ async function createFileChangeUpdate(item) {
   };
 }
 async function createCommandExecutionUpdate(item) {
+  const name = commandToolName(item.source);
   const commandAction = item.commandActions.length === 1 ? item.commandActions[0] : void 0;
   if (commandAction) {
-    return createCommandActionEvent(item.id, item.status, item.cwd, commandAction);
+    return {
+      ...createCommandActionEvent(item.id, item.status, item.cwd, commandAction),
+      ...name === void 0 ? {} : { name }
+    };
   }
   const command = stripShellPrefix(item.command);
   return createTerminalCommandEvent({
     sessionUpdate: "tool_call",
     toolCallId: item.id,
+    ...name === void 0 ? {} : { name },
     kind: "execute",
     title: command,
     status: toAcpStatus(item.status),
@@ -22926,7 +23054,10 @@ async function createMcpToolCallUpdate(item) {
   };
 }
 async function createDynamicToolCallUpdate(item) {
-  return createExecuteToolCallUpdate(item, item.tool, { arguments: item.arguments });
+  return {
+    ...await createExecuteToolCallUpdate(item, item.tool, { arguments: item.arguments }),
+    name: functionToolName(item.tool, item.namespace)
+  };
 }
 function createImageViewUpdate(item) {
   const displayPath = item.path;
@@ -22934,6 +23065,7 @@ function createImageViewUpdate(item) {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
     kind: "read",
+    name: "view_image",
     title: `View Image ${displayPath}`,
     status: "completed",
     content: [createContent({
@@ -23491,53 +23623,43 @@ async function createAddFileContent(change) {
     newText: change.diff,
     // app-server always returns file content instead of diff
     path: change.path,
-    _meta: {
-      kind: "add"
-    }
+    _meta: withAirMeta({ kind: "add" }, AIR_DIFF_STATS_KEY, DIFF_STATS.addedFile(change.diff))
   };
 }
 async function createUpdateFileContent(change) {
   if (change.kind.type !== "update") return null;
   const unifiedDiff = recoverCorruptedDiff(change.diff);
+  const patches = parsePatch(unifiedDiff);
+  if (patches.length !== 1) return null;
+  const patch = patches[0];
   const movePath = change.kind.move_path;
   const oldContent = await readFileContent(change.path);
   if (oldContent !== null) {
-    const patchedContent = applyPatch(oldContent, unifiedDiff);
+    const patchedContent = applyPatch(oldContent, patch);
     if (patchedContent === false) {
-      const revertedPatch2 = revertPatch(unifiedDiff);
-      if (revertedPatch2) {
-        const revertedContent2 = applyPatch(oldContent, revertedPatch2);
-        if (revertedContent2 !== false) {
-          return createUpdateDiffContent(change.path, revertedContent2, oldContent);
-        }
+      const revertedContent2 = applyPatch(oldContent, reversePatch(patch));
+      if (revertedContent2 !== false) {
+        return createUpdateDiffContent(change.path, revertedContent2, oldContent, patch);
       }
       return null;
     }
-    return createUpdateDiffContent(movePath ?? change.path, oldContent, patchedContent);
+    return createUpdateDiffContent(movePath ?? change.path, oldContent, patchedContent, patch);
   }
   if (!movePath) return null;
   const newContent = await readFileContent(movePath);
   if (newContent === null) return null;
-  const revertedPatch = revertPatch(unifiedDiff);
-  if (!revertedPatch) return null;
-  const revertedContent = applyPatch(newContent, revertedPatch);
+  const revertedContent = applyPatch(newContent, reversePatch(patch));
   if (revertedContent === false) return null;
-  return createUpdateDiffContent(movePath, revertedContent, newContent);
-}
-function revertPatch(unifiedDiff) {
-  const [patch] = parsePatch(unifiedDiff);
-  if (!patch) return null;
-  return reversePatch(patch);
+  return createUpdateDiffContent(movePath, revertedContent, newContent, patch);
 }
-function createUpdateDiffContent(path9, oldText, newText) {
+function createUpdateDiffContent(path9, oldText, newText, patch) {
+  const stats = DIFF_STATS.update(patch);
   return {
     type: "diff",
     oldText,
     newText,
     path: path9,
-    _meta: {
-      kind: "update"
-    }
+    _meta: stats ? withAirMeta({ kind: "update" }, AIR_DIFF_STATS_KEY, stats) : { kind: "update" }
   };
 }
 async function createDeleteFileContent(change) {
@@ -23547,9 +23669,7 @@ async function createDeleteFileContent(change) {
     // app-server always returns file content instead of diff
     newText: "",
     path: change.path,
-    _meta: {
-      kind: "delete"
-    }
+    _meta: withAirMeta({ kind: "delete" }, AIR_DIFF_STATS_KEY, DIFF_STATS.deletedFile(change.diff))
   };
 }
 async function readFileContent(filePath) {
@@ -23661,26 +23781,6 @@ 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_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
-var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
-var AIR_ASYNC_TASKS_KEY = "asyncTasks";
-var AIR_ASYNC_TASKS_BACKGROUNDED_KEY = "backgrounded";
-var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
-var AIR_EXTENSION_VERSION = 1;
-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(capability);
-}
-
 // src/subagents/CodexAgentPath.ts
 function normalizeAgentPath(path9) {
   const normalized = path9.trim().replace(/\/+$/, "");
@@ -24110,153 +24210,462 @@ function mergeRateLimitSnapshot(previous, update) {
   };
 }
 
-// src/CodexEventHandler.ts
-var MAX_SESSION_FAILURE_TITLE_LENGTH = 240;
-var SESSION_FAILURE_POLICY = {
-  transport_lost: {
-    category: "connection",
-    actions: ["retry", "new_session"]
-  },
-  auth_required: {
-    category: "access",
-    actions: ["login"]
-  },
-  rate_limited: {
-    category: "limit",
-    actions: ["retry"]
-  },
-  quota_exhausted: {
-    category: "limit",
-    actions: []
-  },
-  overloaded: {
-    category: "service",
-    actions: ["retry"]
-  },
-  context_exhausted: {
-    category: "limit",
-    actions: ["new_session"]
-  },
-  budget_exhausted: {
-    category: "limit",
-    actions: ["new_session"]
-  },
-  policy_denied: {
-    category: "request",
-    actions: []
-  },
-  bad_request: {
-    category: "request",
-    actions: []
-  },
-  provider_error: {
-    category: "service",
-    actions: ["retry"]
-  },
-  internal_error: {
-    category: "service",
-    actions: ["retry", "new_session"]
+// src/AgentFileChangeReport.ts
+import fs2 from "node:fs";
+import path3 from "node:path";
+var AGENT_FILE_CHANGE_REPORT_VERSION = 1;
+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_DIFF_BYTES = 8 * 1024 * 1024;
+var TURN_DIFF_UNCERTAINTY = "Codex turn diffs may omit same-content renames and changes made outside apply_patch, including shell commands, version-control commands, generators, and child processes.";
+function captureAgentFileChangeWorkspace(cwd, additionalDirectories) {
+  const lexicalCwd = parseWorkspaceRoot(cwd);
+  return {
+    cwd,
+    additionalDirectories: [...additionalDirectories],
+    diffRoot: lexicalCwd === null ? cwd : findDiffDisplayRoot(lexicalCwd).value
+  };
+}
+function parseAgentFileChangeReportRequest(meta3) {
+  const jetbrains = asRecord2(meta3?.[JETBRAINS_META_KEY]);
+  const air = asRecord2(jetbrains?.[AIR_META_KEY]);
+  const request = asRecord2(air?.[AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY]);
+  if (request === null || !hasOnlyKeys(request, ["version", "requestId"]) || request["version"] !== AGENT_FILE_CHANGE_REPORT_VERSION) {
+    return null;
   }
-};
-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;
+  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 };
 }
-var STRING_CODEX_ERROR_CATEGORIES = {
-  contextWindowExceeded: "context_exhausted",
-  sessionBudgetExceeded: "budget_exhausted",
-  usageLimitExceeded: "quota_exhausted",
-  rateLimitExceeded: "rate_limited",
-  serverOverloaded: "overloaded",
-  cyberPolicy: "policy_denied",
-  misalignmentPolicyViolation: "policy_denied",
-  internalServerError: "internal_error",
-  unauthorized: "auth_required",
-  badRequest: "bad_request",
-  threadRollbackFailed: "provider_error",
-  sandboxError: "provider_error",
-  other: "provider_error"
-};
-var STRUCTURED_CODEX_ERROR_CATEGORIES = {
-  httpConnectionFailed: "transport_lost",
-  responseStreamConnectionFailed: "transport_lost",
-  responseStreamDisconnected: "transport_lost",
-  responseTooManyFailedAttempts: "transport_lost",
-  activeTurnNotSteerable: "provider_error"
-};
-var CodexEventHandler = class _CodexEventHandler {
-  static PLAN_UPDATE_INTERVAL_MS = 150;
-  sessionState;
-  supportsPlanUpdates;
-  supportsTypedSessionFailures;
-  sessionFailureEpoch;
-  pendingErrors = [];
-  failuresById = /* @__PURE__ */ new Map();
-  activeFailureIdByScope = /* @__PURE__ */ new Map();
-  failureTurnIdById = /* @__PURE__ */ new Map();
-  allocatedFailureScopes = /* @__PURE__ */ new Set();
-  lastSessionNotice;
-  nextNoticeId = 1;
-  failure = null;
-  completedPlan = null;
-  activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
-  activeGuardianApprovalReviews = /* @__PURE__ */ new Set();
-  activeImageGenerationItems = /* @__PURE__ */ new Set();
-  emittedImageViewItems = /* @__PURE__ */ new Set();
-  planDeltaTextByItemId = /* @__PURE__ */ new Map();
-  pendingPlanItemIds = /* @__PURE__ */ new Set();
-  lastEmittedPlanTextByItemId = /* @__PURE__ */ new Map();
-  session;
-  planUpdateTimer = null;
-  planUpdateChain = Promise.resolve();
-  disposed = false;
-  seenReasoningDeltaItemIds = /* @__PURE__ */ new Set();
-  terminalCommandIds = /* @__PURE__ */ new Set();
-  terminalCommandOutputIds = /* @__PURE__ */ new Set();
-  agentMessagePhases = /* @__PURE__ */ new Map();
-  subagents;
-  /** Connection-level `authStatus` sink; the app-server account push feeds it. */
-  onAccountUpdated;
-  constructor(connection, sessionState, supportsPlanUpdates = false, supportsTypedSessionFailures = false, sessionFailureEpoch = randomUUID(), subagents = new CodexSubagentEventRouter(
-    sessionState.sessionId,
-    false,
-    new ACPSessionConnection(connection, sessionState.sessionId)
-  ), onAccountUpdated) {
-    this.onAccountUpdated = onAccountUpdated;
-    this.sessionState = sessionState;
-    this.supportsPlanUpdates = supportsPlanUpdates;
-    this.supportsTypedSessionFailures = supportsTypedSessionFailures;
-    this.sessionFailureEpoch = sessionFailureEpoch;
-    this.session = new ACPSessionConnection(connection, sessionState.sessionId);
-    this.subagents = subagents;
-    if (sessionState.sessionFailure !== void 0) {
-      this.failuresById.set(sessionState.sessionFailure.id, sessionState.sessionFailure);
-    }
+function createReportedAgentFileChangeReport(requestId, diff, workspace) {
+  if (Buffer.byteLength(diff, "utf8") > AGENT_FILE_CHANGE_REPORT_MAX_DIFF_BYTES) {
+    throw new AgentFileChangeReportError("invalidOutput", "The turn diff exceeds the parser input limit");
   }
-  getFailure() {
-    return this.failure;
+  const parsedReport = parseTurnDiff(diff);
+  const normalized = normalizeFileChangeReport(parsedReport, 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;
   }
-  getTerminalSessionFailureMeta(turnId, allowUnattributed = false) {
-    const failure = this.sessionState.sessionFailure;
-    if (!this.supportsTypedSessionFailures || failure === void 0 || (this.failureTurnIdById.get(failure.id) === void 0 ? !allowUnattributed : turnId === null || this.failureTurnIdById.get(failure.id) !== turnId)) {
-      return null;
-    }
-    return this.createSessionFailureMeta(failure);
+};
+function parseTurnDiff(diff) {
+  if (diff.trim() === "") {
+    return { paths: [], complete: false, uncertainty: TURN_DIFF_UNCERTAINTY };
   }
-  recordSyntheticTerminalFailure(kind, turnId) {
-    this.recordSessionFailure(kind, turnId ?? void 0, "error", SYNTHETIC_FAILURE_TITLE[kind]);
+  let patches;
+  try {
+    patches = parsePatch(diff);
+  } catch (error51) {
+    throw new AgentFileChangeReportError(
+      "invalidOutput",
+      `The turn diff is not valid unified diff: ${error51 instanceof Error ? error51.message : String(error51)}`
+    );
   }
-  /**
-   * 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);
+  if (patches.length === 0) {
+    throw new AgentFileChangeReportError("invalidOutput", "The turn diff contains no parseable file patches");
+  }
+  const rawFileHeaders = extractRawFileHeaders(diff);
+  const paths = [];
+  for (const [index, patch] of patches.entries()) {
+    const rawHeaders = rawFileHeaders[index];
+    const oldPath = normalizeDiffPath(selectLosslessFileName(rawHeaders?.oldFileName, patch.oldFileName));
+    const newPath = normalizeDiffPath(selectLosslessFileName(rawHeaders?.newFileName, patch.newFileName));
+    if (oldPath === null && newPath === null) {
+      throw new AgentFileChangeReportError("invalidOutput", "The turn diff contains a patch without a file path");
+    }
+    if (oldPath !== null) paths.push(oldPath);
+    if (newPath !== null) paths.push(newPath);
+  }
+  return { paths, complete: false, uncertainty: TURN_DIFF_UNCERTAINTY };
+}
+function extractRawFileHeaders(diff) {
+  return diff.split(/(?=^diff --git )/m).filter((section) => section.trim() !== "").map((section) => {
+    const lines = section.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index];
+      if (line?.startsWith("@@ ")) return null;
+      const nextLine = lines[index + 1];
+      if (line?.startsWith("--- ") && nextLine?.startsWith("+++ ")) {
+        return {
+          oldFileName: line.slice(4),
+          newFileName: nextLine.slice(4)
+        };
+      }
+    }
+    return null;
+  });
+}
+function selectLosslessFileName(rawFileName, parsedFileName) {
+  return rawFileName === void 0 || rawFileName.startsWith('"') ? parsedFileName : rawFileName;
+}
+function normalizeDiffPath(value) {
+  if (value === void 0 || value === "/dev/null") return null;
+  return value.startsWith("a/") || value.startsWith("b/") ? value.slice(2) : value;
+}
+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 normalizeFileChangeReport(report, workspace) {
+  const lexicalCwd = parseWorkspaceRoot(workspace.cwd);
+  if (lexicalCwd === null) {
+    throw new AgentFileChangeReportError("providerError", "The session working directory is not absolute");
+  }
+  const cwd = canonicalizeWorkspaceRoot(lexicalCwd);
+  const diffRoot = parseWorkspaceRoot(workspace.diffRoot);
+  if (diffRoot === null || diffRoot.flavor !== cwd.flavor) {
+    throw new AgentFileChangeReportError("providerError", "The captured turn-diff root is invalid");
+  }
+  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, diffRoot, 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 root = parseWorkspaceRoot(value);
+  return root === null ? null : canonicalizeWorkspaceRoot(root);
+}
+function parseWorkspaceRoot(value) {
+  const trimmed = value.trim();
+  if (!isValidPathText(trimmed)) {
+    return null;
+  }
+  if (isWindowsAbsolutePath(trimmed)) {
+    return {
+      value: path3.win32.normalize(trimmed.replace(/\//g, "\\")),
+      flavor: "windows"
+    };
+  }
+  if (path3.posix.isAbsolute(trimmed)) {
+    return {
+      value: path3.posix.normalize(trimmed.replace(/\\/g, "/")),
+      flavor: "posix"
+    };
+  }
+  return null;
+}
+function normalizeReportedPath(value, relativeRoot, roots) {
+  if (!isValidPathText(value) || /^[A-Za-z]:[^\\/]/.test(value) || /^\\\\[?.]\\/.test(value) || /^(?:\\\\|\/\/)/.test(value) && !isWindowsAbsolutePath(value) || relativeRoot.flavor === "windows" && /^\\(?!\\)/.test(value) || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value)) {
+    return null;
+  }
+  let candidate;
+  if (isWindowsAbsolutePath(value)) {
+    candidate = { value: path3.win32.normalize(value.replace(/\//g, "\\")), flavor: "windows" };
+  } else if (path3.posix.isAbsolute(value)) {
+    candidate = { value: path3.posix.normalize(value.replace(/\\/g, "/")), flavor: "posix" };
+  } else if (relativeRoot.flavor === "windows") {
+    candidate = {
+      value: path3.win32.resolve(relativeRoot.value, value.replace(/\//g, "\\")),
+      flavor: "windows"
+    };
+  } else {
+    candidate = {
+      value: path3.posix.resolve(relativeRoot.value, value.replace(/\\/g, "/")),
+      flavor: "posix"
+    };
+  }
+  candidate = canonicalizeReportedPath(candidate);
+  return roots.some((root) => pathIsStrictlyInside(root, candidate)) ? candidate : null;
+}
+function findDiffDisplayRoot(cwd) {
+  if (!isNativePathFlavor(cwd.flavor)) return cwd;
+  const pathImplementation = cwd.flavor === "windows" ? path3.win32 : path3.posix;
+  let current = cwd.value;
+  while (true) {
+    if (fs2.existsSync(pathImplementation.join(current, ".git"))) {
+      return canonicalizeWorkspaceRoot({ value: current, flavor: cwd.flavor });
+    }
+    const parent = pathImplementation.dirname(current);
+    if (parent === current) return cwd;
+    current = parent;
+  }
+}
+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(path3.dirname(candidate.value));
+  return { ...candidate, value: path3.resolve(parent, path3.basename(candidate.value)) };
+}
+function canonicalizeFromExistingAncestor(value) {
+  const original = path3.resolve(value);
+  let current = original;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const canonical = fs2.realpathSync.native(current);
+      return path3.resolve(canonical, ...missingSegments.reverse());
+    } catch (error51) {
+      if (!isMissingPathError(error51)) return original;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) return original;
+    missingSegments.push(path3.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" ? path3.win32 : path3.posix;
+  const relative = pathImplementation.relative(root.value, candidate.value);
+  return relative.length > 0 && !pathImplementation.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${pathImplementation.sep}`);
+}
+function isWindowsAbsolutePath(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 asRecord2(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/CodexEventHandler.ts
+var MAX_SESSION_FAILURE_TITLE_LENGTH = 240;
+var SESSION_FAILURE_POLICY = {
+  transport_lost: {
+    category: "connection",
+    actions: ["retry", "new_session"]
+  },
+  auth_required: {
+    category: "access",
+    actions: ["login"]
+  },
+  rate_limited: {
+    category: "limit",
+    actions: ["retry"]
+  },
+  quota_exhausted: {
+    category: "limit",
+    actions: []
+  },
+  overloaded: {
+    category: "service",
+    actions: ["retry"]
+  },
+  context_exhausted: {
+    category: "limit",
+    actions: ["new_session"]
+  },
+  budget_exhausted: {
+    category: "limit",
+    actions: ["new_session"]
+  },
+  policy_denied: {
+    category: "request",
+    actions: []
+  },
+  bad_request: {
+    category: "request",
+    actions: []
+  },
+  provider_error: {
+    category: "service",
+    actions: ["retry"]
+  },
+  internal_error: {
+    category: "service",
+    actions: ["retry", "new_session"]
+  }
+};
+var SYNTHETIC_FAILURE_TITLE = {
+  transport_lost: "Connection to Codex was lost.",
+  internal_error: "Codex encountered an internal error."
+};
+function nextSessionFailureRevision(previous, id) {
+  return previous?.id === id ? previous.revision + 1 : 1;
+}
+var STRING_CODEX_ERROR_CATEGORIES = {
+  contextWindowExceeded: "context_exhausted",
+  sessionBudgetExceeded: "budget_exhausted",
+  usageLimitExceeded: "quota_exhausted",
+  rateLimitExceeded: "rate_limited",
+  serverOverloaded: "overloaded",
+  cyberPolicy: "policy_denied",
+  misalignmentPolicyViolation: "policy_denied",
+  internalServerError: "internal_error",
+  unauthorized: "auth_required",
+  badRequest: "bad_request",
+  threadRollbackFailed: "provider_error",
+  sandboxError: "provider_error",
+  other: "provider_error"
+};
+var STRUCTURED_CODEX_ERROR_CATEGORIES = {
+  httpConnectionFailed: "transport_lost",
+  responseStreamConnectionFailed: "transport_lost",
+  responseStreamDisconnected: "transport_lost",
+  responseTooManyFailedAttempts: "transport_lost",
+  activeTurnNotSteerable: "provider_error"
+};
+var CodexEventHandler = class _CodexEventHandler {
+  static PLAN_UPDATE_INTERVAL_MS = 150;
+  sessionState;
+  supportsPlanUpdates;
+  supportsTypedSessionFailures;
+  sessionFailureEpoch;
+  pendingErrors = [];
+  failuresById = /* @__PURE__ */ new Map();
+  activeFailureIdByScope = /* @__PURE__ */ new Map();
+  failureTurnIdById = /* @__PURE__ */ new Map();
+  allocatedFailureScopes = /* @__PURE__ */ new Set();
+  lastSessionNotice;
+  nextNoticeId = 1;
+  failure = null;
+  completedPlan = null;
+  activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
+  activeGuardianApprovalReviews = /* @__PURE__ */ new Set();
+  activeImageGenerationItems = /* @__PURE__ */ new Set();
+  emittedImageViewItems = /* @__PURE__ */ new Set();
+  planDeltaTextByItemId = /* @__PURE__ */ new Map();
+  pendingPlanItemIds = /* @__PURE__ */ new Set();
+  lastEmittedPlanTextByItemId = /* @__PURE__ */ new Map();
+  session;
+  planUpdateTimer = null;
+  planUpdateChain = Promise.resolve();
+  disposed = false;
+  seenReasoningDeltaItemIds = /* @__PURE__ */ new Set();
+  terminalCommandIds = /* @__PURE__ */ new Set();
+  terminalCommandOutputIds = /* @__PURE__ */ new Set();
+  agentMessagePhases = /* @__PURE__ */ new Map();
+  turnDiffs = /* @__PURE__ */ new Map();
+  oversizedTurnDiffs = /* @__PURE__ */ new Set();
+  collectTurnDiffs;
+  subagents;
+  /** Connection-level `authStatus` sink; the app-server account push feeds it. */
+  onAccountUpdated;
+  constructor(connection, sessionState, supportsPlanUpdates = false, supportsTypedSessionFailures = false, sessionFailureEpoch = randomUUID(), subagents = new CodexSubagentEventRouter(
+    sessionState.sessionId,
+    false,
+    new ACPSessionConnection(connection, sessionState.sessionId)
+  ), onAccountUpdated, collectTurnDiffs = false) {
+    this.onAccountUpdated = onAccountUpdated;
+    this.sessionState = sessionState;
+    this.supportsPlanUpdates = supportsPlanUpdates;
+    this.supportsTypedSessionFailures = supportsTypedSessionFailures;
+    this.sessionFailureEpoch = sessionFailureEpoch;
+    this.session = new ACPSessionConnection(connection, sessionState.sessionId);
+    this.subagents = subagents;
+    this.collectTurnDiffs = collectTurnDiffs;
+    if (sessionState.sessionFailure !== void 0) {
+      this.failuresById.set(sessionState.sessionFailure.id, sessionState.sessionFailure);
+    }
+  }
+  getFailure() {
+    return this.failure;
+  }
+  getTurnDiff(turnId) {
+    return this.turnDiffs.get(turnId) ?? "";
+  }
+  isTurnDiffOversized(turnId) {
+    return this.oversizedTurnDiffs.has(turnId);
+  }
+  getTerminalSessionFailureMeta(turnId, allowUnattributed = false) {
+    const failure = this.sessionState.sessionFailure;
+    if (!this.supportsTypedSessionFailures || failure === void 0 || (this.failureTurnIdById.get(failure.id) === void 0 ? !allowUnattributed : turnId === null || this.failureTurnIdById.get(failure.id) !== turnId)) {
+      return null;
+    }
+    return this.createSessionFailureMeta(failure);
+  }
+  recordSyntheticTerminalFailure(kind, turnId) {
+    this.recordSessionFailure(kind, turnId ?? void 0, "error", SYNTHETIC_FAILURE_TITLE[kind]);
+  }
+  /**
+   * Handles notifications after the prompt-local handler has been disposed. The app-server subscription
+   * remains installed until the ACP session closes, so terminal errors need a durable session-level path
+   * instead of entering a turn buffer that will never be flushed.
+   */
+  async handleSessionScopedNotification(notification) {
+    if (notification.method !== "error") {
+      await this.handleNotification(notification);
       return;
     }
     if (!this.supportsTypedSessionFailures) {
@@ -24398,6 +24807,8 @@ var CodexEventHandler = class _CodexEventHandler {
     this.pendingPlanItemIds.clear();
     this.planDeltaTextByItemId.clear();
     this.lastEmittedPlanTextByItemId.clear();
+    this.turnDiffs.clear();
+    this.oversizedTurnDiffs.clear();
   }
   async createUpdateEvent(notification) {
     switch (notification.method) {
@@ -24416,6 +24827,20 @@ var CodexEventHandler = class _CodexEventHandler {
       case "turn/plan/updated":
         this.completeRetryIncidentOnTurnProgress();
         return await this.updatePlan(notification.params);
+      case "turn/diff/updated":
+        if (notification.params.threadId === this.sessionState.sessionId) {
+          this.completeRetryIncidentOnTurnProgress();
+          if (!this.disposed && this.collectTurnDiffs) {
+            if (Buffer.byteLength(notification.params.diff, "utf8") > AGENT_FILE_CHANGE_REPORT_MAX_DIFF_BYTES) {
+              this.turnDiffs.delete(notification.params.turnId);
+              this.oversizedTurnDiffs.add(notification.params.turnId);
+            } else {
+              this.oversizedTurnDiffs.delete(notification.params.turnId);
+              this.turnDiffs.set(notification.params.turnId, notification.params.diff);
+            }
+          }
+        }
+        return null;
       case "error":
         return await this.createErrorEvent(notification.params);
       case "turn/started":
@@ -24510,7 +24935,6 @@ var CodexEventHandler = class _CodexEventHandler {
       case "command/exec/outputDelta":
       case "hook/started":
       case "hook/completed":
-      case "turn/diff/updated":
       case "turn/moderationMetadata":
       case "item/fileChange/outputDelta":
       case "item/fileChange/patchUpdated":
@@ -24694,10 +25118,16 @@ ${event.details}` : event.summary;
   async completeItemEvent(event) {
     switch (event.item.type) {
       case "fileChange":
+        return {
+          sessionUpdate: "tool_call_update",
+          toolCallId: event.item.id,
+          status: event.item.status === "completed" ? "completed" : "failed"
+        };
       case "dynamicToolCall":
         return {
           sessionUpdate: "tool_call_update",
           toolCallId: event.item.id,
+          name: functionToolName(event.item.tool, event.item.namespace),
           status: event.item.status === "completed" ? "completed" : "failed"
         };
       case "mcpToolCall":
@@ -24909,9 +25339,11 @@ ${event.stdin}
     return `mcp_startup.${encodeURIComponent(serverName)}`;
   }
   completeCommandExecutionEvent(item) {
+    const name = commandToolName(item.source);
     const update = {
       sessionUpdate: "tool_call_update",
       toolCallId: item.id,
+      ...name === void 0 ? {} : { name },
       status: item.status === "completed" ? "completed" : "failed",
       rawOutput: {
         formatted_output: item.aggregatedOutput ?? "",
@@ -25527,7 +25959,8 @@ function nonBlank(value) {
 }
 
 // src/permissions/presentation.ts
-function commandToolCall(params) {
+function commandToolCall(params, permissionContext) {
+  const name = permissionContext.commandName(params.threadId, params.itemId);
   const network = params.networkApprovalContext;
   const rawInput = {
     ...params.command ? { command: stripShellPrefix(params.command) } : {},
@@ -25538,6 +25971,7 @@ function commandToolCall(params) {
   const additionalPermissionContent = params.additionalPermissions ? permissionProfileContent(params.additionalPermissions) : [];
   return {
     toolCallId: params.itemId,
+    ...name !== void 0 ? { name } : {},
     kind: "execute",
     status: "pending",
     title: network ? `${network.protocol} network access to ${network.host}` : commandTitle(params.commandActions),
@@ -25563,6 +25997,7 @@ function additionalPermissionsToolCall(itemId, cwd, environmentId, permissions)
   const content = permissionProfileContent(permissions);
   return {
     toolCallId: itemId,
+    name: "request_permissions",
     kind: "other",
     status: "pending",
     title: "Additional sandbox permissions",
@@ -25661,7 +26096,7 @@ var CodexApprovalHandler = class {
     try {
       const response = await this.requestPermission({
         sessionId: params.threadId,
-        toolCall: commandToolCall(authoritativeParams),
+        toolCall: commandToolCall(authoritativeParams, this.permissionContext),
         options: decisions.map(({ option }) => option),
         _meta: requestPermissionMeta(
           params.networkApprovalContext ? CODEX_NETWORK_PERMISSION_TITLE : CODEX_COMMAND_PERMISSION_TITLE,
@@ -25769,6 +26204,7 @@ var PermissionPromptContext = class {
     this.nextStandaloneId = nextStandaloneId;
   }
   nextStandaloneId;
+  commandNames = /* @__PURE__ */ new Map();
   fileChanges = /* @__PURE__ */ new Map();
   pendingMcpApprovals = /* @__PURE__ */ new Map();
   handleNotification(notification) {
@@ -25792,6 +26228,9 @@ var PermissionPromptContext = class {
   fileChange(threadId, itemId) {
     return this.fileChanges.get(threadId)?.get(itemId);
   }
+  commandName(threadId, itemId) {
+    return this.commandNames.get(threadId)?.get(itemId);
+  }
   popPendingMcpApproval(threadId, serverName) {
     const byServer = this.pendingMcpApprovals.get(threadId);
     if (!byServer) return void 0;
@@ -25806,6 +26245,15 @@ var PermissionPromptContext = class {
     return this.nextStandaloneId(serverName);
   }
   handleItemStarted(threadId, item) {
+    if (item.type === "commandExecution") {
+      const name = commandToolName(item.source);
+      if (name !== void 0) {
+        const byItem = this.commandNames.get(threadId) ?? /* @__PURE__ */ new Map();
+        byItem.set(item.id, name);
+        this.commandNames.set(threadId, byItem);
+      }
+      return;
+    }
     if (item.type === "fileChange") {
       const byItem = this.fileChanges.get(threadId) ?? /* @__PURE__ */ new Map();
       byItem.set(item.id, item);
@@ -25820,6 +26268,12 @@ var PermissionPromptContext = class {
     this.pendingMcpApprovals.set(threadId, byServer);
   }
   handleItemCompleted(threadId, item) {
+    if (item.type === "commandExecution") {
+      const byItem = this.commandNames.get(threadId);
+      byItem?.delete(item.id);
+      if (byItem?.size === 0) this.commandNames.delete(threadId);
+      return;
+    }
     if (item.type === "fileChange") {
       const byItem = this.fileChanges.get(threadId);
       byItem?.delete(item.id);
@@ -25837,6 +26291,7 @@ var PermissionPromptContext = class {
     if (byServer.size === 0) this.pendingMcpApprovals.delete(threadId);
   }
   clearTransientState(threadId) {
+    this.commandNames.delete(threadId);
     this.fileChanges.delete(threadId);
     this.pendingMcpApprovals.delete(threadId);
   }
@@ -25969,8 +26424,9 @@ function buildMcpPermissionRequest(sessionId, params, context, nextStandaloneToo
           toolCallId: nextStandaloneToolCallId(),
           kind: context.isToolApproval ? "execute" : "other",
           status: "pending",
+          title: context.isToolApproval ? "MCP tool call approval" : "Question from MCP server",
           content: [messageContent],
-          rawInput: { serverName: params.serverName, schema: params.requestedSchema }
+          rawInput: { serverName: params.serverName, description: params.message, schema: params.requestedSchema }
         },
         ...context.isToolApproval ? { _meta: { is_mcp_tool_approval: true } } : {},
         options
@@ -25988,8 +26444,9 @@ function buildMcpPermissionRequest(sessionId, params, context, nextStandaloneToo
         toolCallId: `elicitation-${params.elicitationId}`,
         kind: "fetch",
         status: "pending",
+        title: "MCP server requests to open a URL",
         content: [messageContent],
-        rawInput: { serverName: params.serverName, url: params.url }
+        rawInput: { serverName: params.serverName, description: params.message, url: params.url }
       },
       options
     },
@@ -26023,7 +26480,9 @@ function cancelledResponse() {
 }
 
 // src/CodexElicitationHandler.ts
-var USER_INPUT_OTHER_FIELD_SUFFIX = "__other";
+var USER_INPUT_NOTE_FIELD_SUFFIX = "_note";
+var USER_INPUT_OTHER_OPTION = "None of the above";
+var USER_INPUT_NOTE_PREFIX = "user_note: ";
 function normalizeElicitationSchema(value) {
   const normalized = normalizeElicitationSchemaValue(value);
   if (!isRecord2(normalized)) {
@@ -26080,16 +26539,14 @@ function elicitationResponseMeta(response, context, persist = void 0) {
   }
   return Object.keys(meta3).length === 0 ? null : meta3;
 }
-function userInputOtherFieldId(questionId, questionIds) {
-  const base = `${questionId}${USER_INPUT_OTHER_FIELD_SUFFIX}`;
-  if (!questionIds.has(base)) {
-    return base;
-  }
+function userInputNoteFieldId(questionId, questionIds) {
+  const base = `${questionId}${USER_INPUT_NOTE_FIELD_SUFFIX}`;
+  let fieldId = base;
   let index = 1;
-  while (questionIds.has(`${base}${index}`)) {
-    index += 1;
+  while (questionIds.has(fieldId)) {
+    fieldId = `${base}${index++}`;
   }
-  return `${base}${index}`;
+  return fieldId;
 }
 function userInputResponseValue(content, fieldId) {
   const value = content[fieldId];
@@ -26166,11 +26623,29 @@ var CodexElicitationHandler = class {
         context.isToolApproval,
         context.persistOptions
       );
-      if (correlatedCallId !== void 0 && result.action === "accept") {
-        await this.connection.notify(methods.client.session.update, {
-          sessionId: params.threadId,
-          update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
-        });
+      if (correlatedCallId !== void 0) {
+        if (result.action === "accept") {
+          await this.connection.notify(methods.client.session.update, {
+            sessionId: params.threadId,
+            update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
+          });
+        }
+      } else {
+        try {
+          await this.connection.notify(methods.client.session.update, {
+            sessionId: params.threadId,
+            update: {
+              sessionUpdate: "tool_call_update",
+              toolCallId: request.toolCall.toolCallId,
+              status: "completed",
+              title: request.toolCall.title,
+              content: request.toolCall.content,
+              rawOutput: { action: result.action }
+            }
+          });
+        } catch (error51) {
+          logger.error("Failed to finalize standalone MCP elicitation tool call", error51);
+        }
       }
       return result;
     } catch (error51) {
@@ -26308,8 +26783,8 @@ var CodexElicitationHandler = class {
       const hasOptions = options.length > 0;
       const hasOtherAnswer = question.isOther && hasOptions;
       const base = {
-        title: question.header || question.id,
-        description: question.question,
+        title: question.question || question.header || question.id,
+        ...question.header ? { description: question.header } : {},
         _meta: {
           codex: {
             isOther: question.isOther,
@@ -26317,42 +26792,45 @@ var CodexElicitationHandler = class {
           }
         }
       };
-      if (!hasOtherAnswer) {
-        required2.push(question.id);
-      }
+      required2.push(question.id);
       properties[question.id] = hasOptions ? {
         ...base,
         type: "string",
-        oneOf: options.map((option) => ({
-          const: option.label,
-          title: option.label,
-          description: option.description
-        }))
+        oneOf: [
+          ...options.map((option) => ({
+            const: option.label,
+            title: option.label,
+            ...option.description ? { description: option.description } : {}
+          })),
+          ...hasOtherAnswer && !options.some((option) => option.label === USER_INPUT_OTHER_OPTION) ? [{
+            const: USER_INPUT_OTHER_OPTION,
+            title: USER_INPUT_OTHER_OPTION,
+            description: "Provide a different answer in the note field."
+          }] : []
+        ]
       } : {
         ...base,
         type: "string"
       };
       if (hasOtherAnswer) {
-        properties[userInputOtherFieldId(question.id, questionIds)] = {
+        properties[userInputNoteFieldId(question.id, questionIds)] = {
           type: "string",
-          title: "Other",
-          description: "Type your own answer instead of choosing an option above.",
+          title: "Additional answer or note",
           _meta: {
             codex: {
               questionId: question.id,
-              isOtherAnswer: true,
+              role: "user_note",
               isSecret: question.isSecret
             }
           }
         };
       }
     }
-    const firstQuestion = params.questions[0];
     return {
       sessionId: params.threadId,
       toolCallId: params.itemId,
       mode: "form",
-      message: params.questions.length === 1 && firstQuestion ? firstQuestion.question : "Input requested",
+      message: "Codex needs your input to continue.",
       requestedSchema: {
         type: "object",
         properties,
@@ -26403,12 +26881,23 @@ var CodexElicitationHandler = class {
     const content = contentRecord(response.content);
     const questionIds = new Set(params.questions.map((question) => question.id));
     for (const question of params.questions) {
-      const value = question.isOther && question.options != null && question.options.length > 0 ? userInputResponseValue(content, userInputOtherFieldId(question.id, questionIds)) ?? userInputResponseValue(content, question.id) : userInputResponseValue(content, question.id);
-      if (value === void 0) {
+      const answerValues = [];
+      const value = userInputResponseValue(content, question.id);
+      if (value !== void 0) {
+        answerValues.push(...Array.isArray(value) ? value.map(String) : [String(value)]);
+      }
+      if (question.isOther && question.options != null && question.options.length > 0) {
+        const note = userInputResponseValue(content, userInputNoteFieldId(question.id, questionIds));
+        if (note !== void 0) {
+          const notes = Array.isArray(note) ? note : [note];
+          answerValues.push(...notes.map((item) => `${USER_INPUT_NOTE_PREFIX}${String(item).trim()}`));
+        }
+      }
+      if (answerValues.length === 0) {
         continue;
       }
       answers[question.id] = {
-        answers: Array.isArray(value) ? value.map(String) : [String(value)]
+        answers: answerValues
       };
     }
     return { answers };
@@ -26498,31 +26987,31 @@ function isCodexAuthRequest(request) {
 
 // node_modules/open/index.js
 import process11 from "node:process";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import childProcess4 from "node:child_process";
-import fs6, { constants as fsConstants2 } from "node:fs/promises";
+import fs7, { constants as fsConstants2 } from "node:fs/promises";
 
 // node_modules/wsl-utils/index.js
-import path3 from "node:path";
+import path4 from "node:path";
 import { promisify as promisify2 } from "node:util";
 import childProcess2 from "node:child_process";
-import fs5, { constants as fsConstants } from "node:fs/promises";
+import fs6, { constants as fsConstants } from "node:fs/promises";
 
 // node_modules/is-wsl/index.js
 import process3 from "node:process";
 import os from "node:os";
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 
 // node_modules/is-inside-container/index.js
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 
 // node_modules/is-docker/index.js
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    fs2.statSync("/.dockerenv");
+    fs3.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -26530,7 +27019,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
   try {
-    return fs2.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs3.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -26546,7 +27035,7 @@ function isDocker() {
 var cachedResult;
 var hasContainerEnv = () => {
   try {
-    fs3.statSync("/run/.containerenv");
+    fs4.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -26571,12 +27060,12 @@ var isWsl = () => {
     return true;
   }
   try {
-    if (fs4.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+    if (fs5.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
       return !isInsideContainer();
     }
   } catch {
   }
-  if (fs4.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs4.existsSync("/run/WSL")) {
+  if (fs5.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs5.existsSync("/run/WSL")) {
     return !isInsideContainer();
   }
   return false;
@@ -26644,14 +27133,14 @@ var wslDrivesMountPoint = /* @__PURE__ */ (() => {
     const configFilePath = "/etc/wsl.conf";
     let isConfigFileExists = false;
     try {
-      await fs5.access(configFilePath, fsConstants.F_OK);
+      await fs6.access(configFilePath, fsConstants.F_OK);
       isConfigFileExists = true;
     } catch {
     }
     if (!isConfigFileExists) {
       return defaultMountPoint;
     }
-    const configContent = await fs5.readFile(configFilePath, { encoding: "utf8" });
+    const configContent = await fs6.readFile(configFilePath, { encoding: "utf8" });
     const parsedMountPoint = parseMountPointFromConfig(configContent);
     if (parsedMountPoint === void 0) {
       return defaultMountPoint;
@@ -26671,7 +27160,7 @@ var canAccessPowerShell = async () => {
   canAccessPowerShellPromise ??= (async () => {
     try {
       const psPath = await powerShellPath2();
-      await fs5.access(psPath, fsConstants.X_OK);
+      await fs6.access(psPath, fsConstants.X_OK);
       return true;
     } catch {
       return false;
@@ -26684,7 +27173,7 @@ var wslDefaultBrowser = async () => {
   const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
   const { stdout } = await executePowerShell(command, {
     powerShellPath: psPath,
-    cwd: path3.dirname(psPath)
+    cwd: path4.dirname(psPath)
   });
   return stdout.trim();
 };
@@ -26890,8 +27379,8 @@ var is_in_ssh_default = isInSsh;
 
 // node_modules/open/index.js
 var fallbackAttemptSymbol = /* @__PURE__ */ Symbol("fallbackAttempt");
-var __dirname = import.meta.url ? path4.dirname(fileURLToPath(import.meta.url)) : "";
-var localXdgOpenPath = path4.join(__dirname, "xdg-open");
+var __dirname = import.meta.url ? path5.dirname(fileURLToPath(import.meta.url)) : "";
+var localXdgOpenPath = path5.join(__dirname, "xdg-open");
 var { platform, arch } = process11;
 var tryEachApp = async (apps2, opener) => {
   if (apps2.length === 0) {
@@ -27033,7 +27522,7 @@ var baseOpen = async (options) => {
       childProcessOptions.stdio = "ignore";
     }
     if (is_wsl_default) {
-      childProcessOptions.cwd = path4.dirname(command);
+      childProcessOptions.cwd = path5.dirname(command);
     }
   } else {
     if (app) {
@@ -27042,7 +27531,7 @@ var baseOpen = async (options) => {
       const isBundled = !__dirname || __dirname === "/";
       let exeLocalXdgOpen = false;
       try {
-        await fs6.access(localXdgOpenPath, fsConstants2.X_OK);
+        await fs7.access(localXdgOpenPath, fsConstants2.X_OK);
         exeLocalXdgOpen = true;
       } catch {
       }
@@ -27330,7 +27819,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.10.0-agentconnect.2",
+  version: "1.12.0-agentconnect.1",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -27355,428 +27844,132 @@ var package_default = {
     "package:linux-x64": "cd dist/bin && zip codex-acp-x64-linux.zip codex-acp-x64-linux",
     "package:linux-arm64": "cd dist/bin && zip codex-acp-arm64-linux.zip codex-acp-arm64-linux",
     "package:darwin-x64": "cd dist/bin && zip codex-acp-x64-darwin.zip codex-acp-x64-darwin",
-    "package:darwin-arm64": "cd dist/bin && zip codex-acp-arm64-darwin.zip codex-acp-arm64-darwin",
-    "package:win-x64": "cd dist/bin && zip codex-acp-x64-windows.zip codex-acp-x64-windows.exe",
-    "package:win-arm64": "cd dist/bin && zip codex-acp-arm64-windows.zip codex-acp-arm64-windows.exe",
-    start: "node --import tsx src/index.ts",
-    "example:simple-client": "node --import tsx examples/simple-client.ts",
-    "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 --no-file-parallelism --retry=2",
-    "test:e2e": "npm run build && RUN_E2E_TESTS=true vitest run --no-file-parallelism --retry=2 src/__tests__/CodexACPAgent/e2e",
-    "test:watch": "vitest",
-    typecheck: "tsc --noEmit && tsc --noEmit -p examples/tsconfig.json",
-    "codex-test": "tsx .claude/skills/run-codex/scripts/run-codex-test.ts"
-  },
-  homepage: "https://github.com/agentconnect-md/codex-acp#readme",
-  bugs: {
-    url: "https://github.com/agentconnect-md/codex-acp/issues"
-  },
-  repository: {
-    type: "git",
-    url: "git+https://github.com/agentconnect-md/codex-acp.git"
-  },
-  keywords: [],
-  author: "Agent Client Protocol",
-  license: "Apache-2.0",
-  type: "module",
-  devDependencies: {
-    "@types/node": "^26.1.0",
-    esbuild: "^0.28.2",
-    "mcp-hello-world": "^1.1.2",
-    tsx: "^4.23.12",
-    typescript: "^7.0.2",
-    vitest: "^4.1.11"
-  },
-  dependencies: {
-    "@agentclientprotocol/sdk": "^1.4.0",
-    "@openai/codex": "^0.153.3",
-    diff: "^9.0.0",
-    open: "^11.0.1",
-    "vscode-jsonrpc": "^9.0.1",
-    zod: "^4.0.0"
-  }
-};
-
-// src/CollaborationModeConfig.ts
-var COLLABORATION_MODE_CONFIG_ID = "collaboration_mode";
-var DEFAULT_COLLABORATION_MODE = "default";
-var PLAN_COLLABORATION_MODE = "plan";
-function createCollaborationModeConfigOption(currentValue) {
-  return {
-    id: COLLABORATION_MODE_CONFIG_ID,
-    name: "Collaboration mode",
-    description: "How Codex collaborates for subsequent turns",
-    category: "collaboration_mode",
-    type: "select",
-    currentValue,
-    options: [
-      { value: DEFAULT_COLLABORATION_MODE, name: "Default" },
-      { value: PLAN_COLLABORATION_MODE, name: "Plan", description: "Plan before making changes" }
-    ]
-  };
-}
-function parseCollaborationMode(value) {
-  if (value === DEFAULT_COLLABORATION_MODE) return DEFAULT_COLLABORATION_MODE;
-  if (value === PLAN_COLLABORATION_MODE) return PLAN_COLLABORATION_MODE;
-  return null;
-}
-function createCodexCollaborationMode(mode, currentModelId) {
-  const modelId = ModelId.fromString(currentModelId);
-  return {
-    mode,
-    settings: {
-      model: modelId.model,
-      reasoning_effort: modelId.effort,
-      developer_instructions: null
-    }
-  };
-}
-
-// src/PathUtils.ts
-import path5 from "node:path";
-function isAbsolutePathLike(value) {
-  const trimmed = value.trim();
-  return path5.isAbsolute(trimmed) || isWindowsAbsolutePath(trimmed);
-}
-function arePathsEqual(left, right) {
-  return normalizePathForComparison(left) === normalizePathForComparison(right);
-}
-function arePathBasenamesEqual(left, right) {
-  const leftBase = path5.posix.basename(normalizePathForComparison(left));
-  const rightBase = path5.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 = path5.win32.normalize(trimmed).replace(/\\/g, "/");
-    return trimTrailingPathSeparators(normalized2).toLowerCase();
-  }
-  const pathForComparison = path5.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
-  const normalized = path5.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/AgentFileChangeReport.ts
-import fs7 from "node:fs";
-import path6 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", "uncertainty"],
-  properties: {
-    paths: {
-      type: "array",
-      items: { type: "string" }
-    },
-    complete: { type: "boolean" },
-    uncertainty: {
-      anyOf: [{
-        type: "string",
-        maxLength: AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH
-      }, {
-        type: "null"
-      }]
-    }
-  }
-};
-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${turn.error?.message ? `: ${turn.error.message}` : ""}`
-      );
-    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 && uncertainty !== null && typeof uncertainty !== "string") {
-    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned invalid fields");
-  }
-  const normalizedUncertainty = typeof uncertainty === "string" ? uncertainty.trim() : void 0;
-  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;
+    "package:darwin-arm64": "cd dist/bin && zip codex-acp-arm64-darwin.zip codex-acp-arm64-darwin",
+    "package:win-x64": "cd dist/bin && zip codex-acp-x64-windows.zip codex-acp-x64-windows.exe",
+    "package:win-arm64": "cd dist/bin && zip codex-acp-arm64-windows.zip codex-acp-arm64-windows.exe",
+    start: "node --import tsx src/index.ts",
+    "example:simple-client": "node --import tsx examples/simple-client.ts",
+    "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 --no-file-parallelism --retry=2",
+    "test:e2e": "npm run build && RUN_E2E_TESTS=true vitest run --no-file-parallelism --retry=2 src/__tests__/CodexACPAgent/e2e",
+    "test:watch": "vitest",
+    typecheck: "tsc --noEmit && tsc --noEmit -p examples/tsconfig.json",
+    "codex-test": "tsx .claude/skills/run-codex/scripts/run-codex-test.ts"
+  },
+  homepage: "https://github.com/agentconnect-md/codex-acp#readme",
+  bugs: {
+    url: "https://github.com/agentconnect-md/codex-acp/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/agentconnect-md/codex-acp.git"
+  },
+  keywords: [],
+  author: "Agent Client Protocol",
+  license: "Apache-2.0",
+  type: "module",
+  devDependencies: {
+    "@types/node": "^26.1.0",
+    esbuild: "^0.28.2",
+    "mcp-hello-world": "^1.1.2",
+    tsx: "^4.23.12",
+    typescript: "^7.0.2",
+    vitest: "^4.1.11"
+  },
+  dependencies: {
+    "@agentclientprotocol/sdk": "^1.4.0",
+    "@openai/codex": "^0.154.0",
+    diff: "^9.0.0",
+    open: "^11.0.1",
+    "vscode-jsonrpc": "^9.0.1",
+    zod: "^4.0.0"
   }
+};
+
+// src/CollaborationModeConfig.ts
+var COLLABORATION_MODE_CONFIG_ID = "collaboration_mode";
+var DEFAULT_COLLABORATION_MODE = "default";
+var PLAN_COLLABORATION_MODE = "plan";
+function createCollaborationModeConfigOption(currentValue) {
   return {
-    paths,
-    declaredComplete: report.complete && !truncated,
-    truncated,
-    ...report.uncertainty ? { uncertainty: report.uncertainty } : {}
+    id: COLLABORATION_MODE_CONFIG_ID,
+    name: "Collaboration mode",
+    description: "How Codex collaborates for subsequent turns",
+    category: "collaboration_mode",
+    type: "select",
+    currentValue,
+    options: [
+      { value: DEFAULT_COLLABORATION_MODE, name: "Default" },
+      { value: PLAN_COLLABORATION_MODE, name: "Plan", description: "Plan before making changes" }
+    ]
   };
 }
-function normalizeWorkspaceRoot(value) {
-  const trimmed = value.trim();
-  if (!isValidPathText(trimmed)) {
-    return null;
-  }
-  if (isWindowsAbsolutePath2(trimmed)) {
-    return canonicalizeWorkspaceRoot({
-      value: path6.win32.normalize(trimmed.replace(/\//g, "\\")),
-      flavor: "windows"
-    });
-  }
-  if (path6.posix.isAbsolute(trimmed)) {
-    return canonicalizeWorkspaceRoot({
-      value: path6.posix.normalize(trimmed.replace(/\\/g, "/")),
-      flavor: "posix"
-    });
-  }
+function parseCollaborationMode(value) {
+  if (value === DEFAULT_COLLABORATION_MODE) return DEFAULT_COLLABORATION_MODE;
+  if (value === PLAN_COLLABORATION_MODE) return PLAN_COLLABORATION_MODE;
   return null;
 }
-function normalizeReportedPath(value, cwd, roots) {
+function createCodexCollaborationMode(mode, currentModelId) {
+  const modelId = ModelId.fromString(currentModelId);
+  return {
+    mode,
+    settings: {
+      model: modelId.model,
+      reasoning_effort: modelId.effort,
+      developer_instructions: null
+    }
+  };
+}
+
+// src/PathUtils.ts
+import path6 from "node:path";
+function isAbsolutePathLike(value) {
   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: path6.win32.normalize(trimmed.replace(/\//g, "\\")), flavor: "windows" };
-  } else if (path6.posix.isAbsolute(trimmed)) {
-    candidate = { value: path6.posix.normalize(trimmed.replace(/\\/g, "/")), flavor: "posix" };
-  } else if (cwd.flavor === "windows") {
-    candidate = {
-      value: path6.win32.resolve(cwd.value, trimmed.replace(/\//g, "\\")),
-      flavor: "windows"
-    };
-  } else {
-    candidate = {
-      value: path6.posix.resolve(cwd.value, trimmed.replace(/\\/g, "/")),
-      flavor: "posix"
-    };
-  }
-  candidate = canonicalizeReportedPath(candidate);
-  return roots.some((root) => pathIsStrictlyInside(root, candidate)) ? candidate : null;
+  return path6.isAbsolute(trimmed) || isWindowsAbsolutePath2(trimmed);
 }
-function canonicalizeWorkspaceRoot(root) {
-  if (!isNativePathFlavor(root.flavor)) {
-    return root;
-  }
-  return { ...root, value: canonicalizeFromExistingAncestor(root.value) };
+function arePathsEqual(left, right) {
+  return normalizePathForComparison(left) === normalizePathForComparison(right);
 }
-function canonicalizeReportedPath(candidate) {
-  if (!isNativePathFlavor(candidate.flavor)) {
-    return candidate;
+function arePathBasenamesEqual(left, right) {
+  const leftBase = path6.posix.basename(normalizePathForComparison(left));
+  const rightBase = path6.posix.basename(normalizePathForComparison(right));
+  if (shouldComparePathCaseInsensitive(left) || shouldComparePathCaseInsensitive(right)) {
+    return leftBase.toLowerCase() === rightBase.toLowerCase();
   }
-  const parent = canonicalizeFromExistingAncestor(path6.dirname(candidate.value));
-  return { ...candidate, value: path6.resolve(parent, path6.basename(candidate.value)) };
+  return leftBase === rightBase;
 }
-function canonicalizeFromExistingAncestor(value) {
-  const original = path6.resolve(value);
-  let current = original;
-  const missingSegments = [];
-  while (true) {
-    try {
-      const canonical = fs7.realpathSync.native(current);
-      return path6.resolve(canonical, ...missingSegments.reverse());
-    } catch (error51) {
-      if (!isMissingPathError(error51)) return original;
-    }
-    const parent = path6.dirname(current);
-    if (parent === current) return original;
-    missingSegments.push(path6.basename(current));
-    current = parent;
+function normalizePathForComparison(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return "";
   }
-}
-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;
+  if (isWindowsAbsolutePath2(trimmed)) {
+    const normalized2 = path6.win32.normalize(trimmed).replace(/\\/g, "/");
+    return trimTrailingPathSeparators(normalized2).toLowerCase();
   }
-  const pathImplementation = root.flavor === "windows" ? path6.win32 : path6.posix;
-  const relative = pathImplementation.relative(root.value, candidate.value);
-  return relative.length > 0 && !pathImplementation.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${pathImplementation.sep}`);
+  const pathForComparison = path6.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
+  const normalized = path6.posix.normalize(pathForComparison);
+  return trimTrailingPathSeparators(normalized);
 }
 function isWindowsAbsolutePath2(value) {
-  const portable = value.replace(/\\/g, "/");
-  return /^[A-Za-z]:\//.test(portable) || /^\/\/[^/]+\/[^/]+(?:\/|$)/.test(portable);
+  const portableValue = value.replace(/\\/g, "/");
+  return /^[A-Za-z]:\//.test(portableValue) || /^\/\/[^/]+\/[^/]+/.test(portableValue);
 }
-function isValidPathText(value) {
-  return value.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
+function shouldComparePathCaseInsensitive(value) {
+  return isWindowsAbsolutePath2(value) || /^[A-Za-z]:/.test(value) || value.includes("\\");
 }
-function asRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+function trimTrailingPathSeparators(value) {
+  let trimmed = value;
+  while (trimmed.endsWith("/") && !isRootPath(trimmed)) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
 }
-function hasOnlyKeys(value, allowed) {
-  const allowedKeys = new Set(allowed);
-  return Object.keys(value).every((key) => allowedKeys.has(key));
+function isRootPath(value) {
+  return value === "/" || /^[A-Za-z]:\/$/.test(value) || /^\/\/[^/]+\/[^/]+\/$/.test(value);
 }
 
 // src/subagents/CodexSubagentSubscriptions.ts
@@ -27900,6 +28093,7 @@ async function forkSession(request, additionalDirectories, dependencies) {
   const lastTurnId = await resolveForkTurnId(request, dependencies.codexClient);
   const prepared = await dependencies.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []);
   const response = await dependencies.codexClient.threadFork({
+    excludeTurns: true,
     config: prepared.config,
     cwd: request.cwd,
     ...lastTurnId !== void 0 && { lastTurnId },
@@ -27922,10 +28116,7 @@ async function forkSession(request, additionalDirectories, dependencies) {
 async function resolveForkTurnId(request, codexClient) {
   const forkPoint = readAirForkPoint(request._meta);
   if (!forkPoint) return void 0;
-  const history = await codexClient.threadRead({
-    threadId: request.sessionId,
-    includeTurns: true
-  });
+  const history = await codexClient.threadReadWithHistory(request.sessionId);
   const candidateIds = airForkMessageIdCandidates(forkPoint.messageId);
   const itemTurnId = candidateIds.map((candidateId) => history.thread.turns.find((turn) => turn.items.some((item) => item.id === candidateId))?.id).find((turnId) => turnId !== void 0);
   if (itemTurnId) return itemTurnId;
@@ -28380,6 +28571,7 @@ var CodexAcpClient = class {
     const prepared = await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []);
     await this.restrictResumedHttpMcpServers(request.sessionId, prepared);
     const response = await this.codexClient.threadResume({
+      excludeTurns: true,
       config: prepared.config,
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
@@ -28419,6 +28611,7 @@ var CodexAcpClient = class {
     const prepared = await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []);
     await this.restrictResumedHttpMcpServers(request.sessionId, prepared);
     const response = await this.codexClient.threadResume({
+      excludeTurns: true,
       config: prepared.config,
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
@@ -28426,10 +28619,10 @@ var CodexAcpClient = class {
       ...this.permissionProfileSelection(initialAgentMode, request.cwd, additionalDirectories)
     });
     onSubscribed?.();
-    const historyResponse = await this.codexClient.threadRead({
-      threadId: response.thread.id,
-      includeTurns: true
-    });
+    const thread = response.thread.historyMode === "paginated" ? {
+      ...response.thread,
+      turns: response.turnsBackwardsCursor === null ? [] : await this.codexClient.threadReadHistory(response.thread.id, response.turnsBackwardsCursor)
+    } : (await this.codexClient.threadReadWithHistory(response.thread.id)).thread;
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
@@ -28439,16 +28632,13 @@ var CodexAcpClient = class {
       collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
-      thread: historyResponse.thread,
+      thread,
       additionalDirectories,
       fullAccessHttpMcpServers: prepared.fullAccessHttpMcpServers
     };
   }
   async readSessionThread(sessionId) {
-    return (await this.codexClient.threadRead({
-      threadId: sessionId,
-      includeTurns: true
-    })).thread;
+    return (await this.codexClient.threadReadWithHistory(sessionId)).thread;
   }
   async newSession(request) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
@@ -28583,7 +28773,7 @@ var CodexAcpClient = class {
       baseUrl: activeProvider.baseUrl
     });
     const mergedConfig = {
-      ...mergeGatewayConfig(this.config, this.gatewayConfig),
+      ...forceGitRootTurnDiffPaths(mergeGatewayConfig(this.config, this.gatewayConfig)),
       projects: Object.fromEntries(sessionRoots2.map((root) => [root, {
         trust_level: "trusted"
       }]))
@@ -28750,100 +28940,6 @@ 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;
-      return createReportedAgentFileChangeReport(
-        params.requestId,
-        outcome.turn,
-        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.error("Agent file-change report unavailable", error51);
-        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 setAgentMode(sessionId, agentMode) {
     const config2 = this.permissionProfileConfig;
     if (!config2) return;
@@ -29009,58 +29105,6 @@ 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) {
@@ -29175,6 +29219,16 @@ function mergeSandboxWorkspaceWriteRoots(config2, roots) {
     }
   };
 }
+function forceGitRootTurnDiffPaths(config2) {
+  const features = isJsonObject(config2["features"]) ? config2["features"] : {};
+  return {
+    ...config2,
+    features: {
+      ...features,
+      cwd_relative_turn_diffs: false
+    }
+  };
+}
 function addAdditionalDirectoriesToSandboxPolicy(sandboxPolicy, additionalDirectories) {
   if (additionalDirectories.length === 0 || sandboxPolicy.type !== "workspaceWrite") {
     return sandboxPolicy;
@@ -29607,6 +29661,41 @@ var CodexAppServerClient = class {
   async threadRead(params) {
     return await this.sendRequest({ method: "thread/read", params });
   }
+  async threadTurnsList(params) {
+    return await this.sendRequest({ method: "thread/turns/list", params });
+  }
+  async threadReadWithHistory(threadId) {
+    const response = await this.threadRead({ threadId });
+    if (response.thread.historyMode === "legacy") {
+      return await this.threadRead({ threadId, includeTurns: true });
+    }
+    const turns = await this.threadReadHistory(threadId);
+    return { ...response, thread: { ...response.thread, turns } };
+  }
+  async threadReadHistory(threadId, initialCursor = null) {
+    const turns = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    if (initialCursor !== null) seenCursors.add(initialCursor);
+    let cursor = initialCursor;
+    do {
+      const page = await this.threadTurnsList({
+        threadId,
+        cursor,
+        limit: 50,
+        sortDirection: "desc",
+        itemsView: "full"
+      });
+      turns.push(...page.data);
+      cursor = page.nextCursor;
+      if (cursor !== null) {
+        if (seenCursors.has(cursor)) {
+          throw new Error("Codex returned a repeated thread history cursor");
+        }
+        seenCursors.add(cursor);
+      }
+    } while (cursor !== null);
+    return turns.reverse();
+  }
   async threadArchive(params) {
     return await this.sendRequest({ method: "thread/archive", params });
   }
@@ -30045,6 +30134,10 @@ function extractTurnRouting(notification) {
 // src/ModelConfigOption.ts
 var MODEL_CONFIG_ID = "model";
 var REASONING_EFFORT_CONFIG_ID = "reasoning_effort";
+function formatModelDisplayName(displayName) {
+  if (!/^gpt-/i.test(displayName)) return displayName;
+  return displayName.replace(/^gpt-/i, "").split(/[-/]+/).filter(Boolean).map(capitalize).join(" ");
+}
 function capitalize(value) {
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
@@ -30052,19 +30145,20 @@ function findSupportedEffort(options, effort) {
   if (!effort) return void 0;
   return options.find((o) => o.reasoningEffort === effort)?.reasoningEffort;
 }
-function createModelConfigOption(availableModels, currentBaseModelId) {
+function createModelConfigOption(availableModels, currentBaseModelId, recommendedModelId) {
   const options = availableModels.map((model) => ({
     value: model.id,
-    name: model.displayName,
+    name: formatModelDisplayName(model.displayName),
     description: model.description
   }));
   if (!availableModels.some((model) => model.id === currentBaseModelId)) {
     options.unshift({
       value: currentBaseModelId,
-      name: currentBaseModelId,
+      name: formatModelDisplayName(currentBaseModelId),
       description: null
     });
   }
+  const recommendation = recommendedModelId && options.some((option) => option.value === recommendedModelId) ? recommendedModelId : void 0;
   return {
     id: MODEL_CONFIG_ID,
     name: "Model",
@@ -30072,10 +30166,12 @@ function createModelConfigOption(availableModels, currentBaseModelId) {
     category: "model",
     type: "select",
     currentValue: currentBaseModelId,
-    options
+    options,
+    ...recommendation ? { _meta: withAirMeta(void 0, AIR_RECOMMENDED_CONFIG_VALUE_KEY, recommendation) } : {}
   };
 }
-function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEffort) {
+function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEffort, recommendedEffort) {
+  const recommendation = findSupportedEffort(supportedReasoningEfforts, recommendedEffort);
   return {
     id: REASONING_EFFORT_CONFIG_ID,
     name: "Reasoning effort",
@@ -30087,7 +30183,8 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
       value: option.reasoningEffort,
       name: capitalize(option.reasoningEffort),
       description: option.description
-    }))
+    })),
+    ...recommendation ? { _meta: withAirMeta(void 0, AIR_RECOMMENDED_CONFIG_VALUE_KEY, recommendation) } : {}
   };
 }
 
@@ -30787,14 +30884,14 @@ function parseJsonRecord(line) {
   }
   try {
     const value = JSON.parse(line);
-    return asRecord2(value);
+    return asRecord3(value);
   } catch {
     return null;
   }
 }
 function extractResponseItem(record2) {
   if (record2["type"] === "response_item") {
-    return asRecord2(record2["payload"]);
+    return asRecord3(record2["payload"]);
   }
   const itemType = record2["type"];
   if (typeof itemType === "string" && isLegacyResponseItemType(itemType)) {
@@ -30828,7 +30925,7 @@ function createEventMsgUpdates(record2) {
   if (record2["type"] !== "event_msg") {
     return null;
   }
-  const payload = asRecord2(record2["payload"]);
+  const payload = asRecord3(record2["payload"]);
   if (!payload) {
     return [];
   }
@@ -30872,7 +30969,7 @@ function imageBlocks(images) {
     if (typeof image === "string") {
       return [{ type: "text", text: `[@image](${image})` }];
     }
-    const record2 = asRecord2(image);
+    const record2 = asRecord3(image);
     const path9 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
     return path9 ? [{ type: "text", text: `[@image](${path9})` }] : [];
   });
@@ -30882,7 +30979,7 @@ function contentBlocksFromResponseContent(content) {
     return [];
   }
   return content.flatMap((entry) => {
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -30915,7 +31012,7 @@ function textParts(value) {
     if (typeof entry === "string") {
       return entry.length > 0 ? [entry] : [];
     }
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -30929,6 +31026,7 @@ function createFunctionCallUpdate(item) {
   if (!toolCallId || !name) {
     return null;
   }
+  const toolName = functionToolName(name, stringValue(item["namespace"]));
   const isExecCommand = name === "exec_command";
   const args = parseFunctionArguments(item["arguments"]);
   const command = isExecCommand ? commandFromFunctionArguments(args) : null;
@@ -30936,7 +31034,10 @@ function createFunctionCallUpdate(item) {
   const commandAction = command ? inferCommandAction(command, cwd) : null;
   if (commandAction) {
     return {
-      update: createCommandActionEvent(toolCallId, "inProgress", cwd, commandAction),
+      update: {
+        ...createCommandActionEvent(toolCallId, "inProgress", cwd, commandAction),
+        name: toolName
+      },
       usesTerminal: false,
       isExecCommand
     };
@@ -30944,6 +31045,7 @@ function createFunctionCallUpdate(item) {
   const update = {
     sessionUpdate: "tool_call",
     toolCallId,
+    name: toolName,
     kind: toolKindForFunctionCall(name),
     title: titleForFunctionCall(name, args),
     status: "in_progress",
@@ -31007,7 +31109,7 @@ function parseFunctionArguments(value) {
 }
 function rawInputForFunctionCall(name, args) {
   if (name === "exec_command") {
-    const record2 = asRecord2(args);
+    const record2 = asRecord3(args);
     if (record2) {
       return {
         command: stringValue(record2["cmd"]) ?? stringValue(record2["command"]),
@@ -31054,14 +31156,14 @@ function functionCallUsesTerminal(item) {
   return item["name"] === "exec_command";
 }
 function commandFromFunctionArguments(args) {
-  const record2 = asRecord2(args);
+  const record2 = asRecord3(args);
   if (!record2) {
     return null;
   }
   return stringValue(record2["cmd"]) ?? stringValue(record2["command"]);
 }
 function cwdFromFunctionArguments(args) {
-  const record2 = asRecord2(args);
+  const record2 = asRecord3(args);
   if (!record2) {
     return "";
   }
@@ -31533,7 +31635,7 @@ function outputText(output) {
     return "";
   }
   return output.flatMap((entry) => {
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -31549,7 +31651,7 @@ function outputText(output) {
   }).join("\n");
 }
 function parseExitCode(rawOutput, output) {
-  const record2 = asRecord2(rawOutput);
+  const record2 = asRecord3(rawOutput);
   if (record2) {
     const exitCode2 = numberValue(record2["exit_code"]) ?? numberValue(record2["exitCode"]);
     if (exitCode2 !== null) {
@@ -31580,7 +31682,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 asRecord2(value) {
+function asRecord3(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return null;
   }
@@ -32230,12 +32332,7 @@ function clientSupportsTypedSessionFailures(capabilities) {
 function clientSupportsAgentFileChangeReports(capabilities) {
   return clientSupportsAirCapability(capabilities, AIR_AGENT_FILE_CHANGE_REPORT_KEY);
 }
-var CodexAcpServer = class _CodexAcpServer {
-  static MODEL_NAME_TOKEN_OVERRIDES = {
-    gpt: "GPT",
-    mini: "Mini",
-    codex: "Codex"
-  };
+var CodexAcpServer = class {
   codexAcpClient;
   connection;
   defaultAuthRequest;
@@ -32362,7 +32459,8 @@ var CodexAcpServer = class _CodexAcpServer {
               AIR_SESSION_FAILURE_KEY,
               AIR_AGENT_FILE_CHANGE_REPORT_KEY,
               AIR_NATIVE_SUBAGENT_SESSIONS_KEY,
-              AIR_ASYNC_TASKS_KEY
+              AIR_ASYNC_TASKS_KEY,
+              AIR_RECOMMENDED_CONFIG_VALUE_KEY
             ]
           }
         }
@@ -33535,14 +33633,24 @@ Check ${configPath} and project .codex directories, especially their config.toml
   }
   createSessionConfigOptions(sessionState) {
     const currentModelId = ModelId.fromString(sessionState.currentModelId);
+    const useRecommendedValue = clientSupportsAirCapability(
+      this.clientCapabilities,
+      AIR_RECOMMENDED_CONFIG_VALUE_KEY
+    );
+    const currentModel = this.findCurrentModel(sessionState.availableModels, sessionState.currentModelId);
+    const recommendedModelId = useRecommendedValue ? sessionState.availableModels.find((model) => model.isDefault)?.id : void 0;
     const configOptions = [
       sessionState.agentMode.toConfigOption(),
       createCollaborationModeConfigOption(sessionState.collaborationMode),
-      createModelConfigOption(sessionState.availableModels, currentModelId.model)
+      createModelConfigOption(sessionState.availableModels, currentModelId.model, recommendedModelId)
     ];
     if (sessionState.supportedReasoningEfforts.length > 0) {
       configOptions.push(
-        createReasoningEffortConfigOption(sessionState.supportedReasoningEfforts, currentModelId.effort)
+        createReasoningEffortConfigOption(
+          sessionState.supportedReasoningEfforts,
+          currentModelId.effort,
+          useRecommendedValue ? currentModel?.defaultReasoningEffort : void 0
+        )
       );
     }
     if (sessionState.currentModelSupportsFast) {
@@ -33619,14 +33727,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const modelId = ModelId.fromString(currentModelId);
     return models.find((m) => m.id === modelId.model);
   }
-  normalizeModelDisplayName(displayName) {
-    return displayName.split("-").map((token) => _CodexAcpServer.MODEL_NAME_TOKEN_OVERRIDES[token.toLowerCase()] ?? token).join("-");
-  }
   createModelState(availableModels, selectedModelId) {
     const allowedModels = availableModels.flatMap(
       (model) => model.supportedReasoningEfforts.map((effort) => ({
         modelId: ModelId.fromComponents(model, effort.reasoningEffort).toString(),
-        name: `${this.normalizeModelDisplayName(model.displayName)} (${effort.reasoningEffort})`,
+        name: `${formatModelDisplayName(model.displayName)} (${effort.reasoningEffort})`,
         description: `${model.description} ${effort.description}`
       }))
     );
@@ -33894,24 +33999,19 @@ Check ${configPath} and project .codex directories, especially their config.toml
       title
     });
   }
-  async publishAgentFileChangeReport(sessionState, turnId, request, unavailableReason, signal) {
+  async publishAgentFileChangeReport(sessionState, turnId, request, unavailableReason, turnDiff, workspace) {
     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
-      });
+      report = turnId === null ? createUnavailableAgentFileChangeReport(request.requestId, unavailableReason) : createReportedAgentFileChangeReport(request.requestId, turnDiff, workspace);
     } catch (error51) {
-      logger.error("Agent file-change report failed unexpectedly", error51);
-      report = createUnavailableAgentFileChangeReport(request.requestId, "providerError");
+      logger.error(
+        error51 instanceof AgentFileChangeReportError ? "Agent file-change report unavailable" : "Agent file-change report failed unexpectedly",
+        error51
+      );
+      report = createUnavailableAgentFileChangeReport(
+        request.requestId,
+        error51 instanceof AgentFileChangeReportError ? error51.reason : "providerError"
+      );
     }
     try {
       const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
@@ -34381,6 +34481,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     });
     const sessionState = this.getSessionState(params.sessionId);
     const agentFileChangeReportRequest = clientSupportsAgentFileChangeReports(this.clientCapabilities) ? parseAgentFileChangeReportRequest(params._meta) : null;
+    const agentFileChangeWorkspace = agentFileChangeReportRequest === null ? null : captureAgentFileChangeWorkspace(sessionState.cwd, sessionState.additionalDirectories);
     let agentFileChangeReportTurnId = null;
     let agentFileChangeReportUnavailableReason = "providerError";
     let promptWasCancelled = false;
@@ -34420,7 +34521,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         clientSupportsTypedSessionFailures(this.clientCapabilities),
         this.sessionFailureEpoch,
         sessionState.subagents,
-        (accountUpdated) => this.handleAccountUpdated(accountUpdated)
+        (accountUpdated) => this.handleAccountUpdated(accountUpdated),
+        agentFileChangeReportRequest !== null
       );
       eventHandler = promptEventHandler;
       const permissionLifecycle = this.permissionLifecycleContext(sessionState);
@@ -34791,13 +34893,21 @@ Check ${configPath} and project .codex directories, especially their config.toml
       } catch (error51) {
         logger.error("Failed to publish terminal subagent state during prompt cleanup", error51);
       }
-      if (agentFileChangeReportRequest !== null) {
+      if (agentFileChangeReportRequest !== null && agentFileChangeWorkspace !== null) {
+        if (promptWasCancelled || activePrompt.signal.aborted || this.sessionIsClosing(params.sessionId)) {
+          agentFileChangeReportTurnId = null;
+          agentFileChangeReportUnavailableReason = "cancelled";
+        } else if (agentFileChangeReportTurnId !== null && eventHandler?.isTurnDiffOversized(agentFileChangeReportTurnId)) {
+          agentFileChangeReportTurnId = null;
+          agentFileChangeReportUnavailableReason = "invalidOutput";
+        }
         await this.publishAgentFileChangeReport(
           sessionState,
           agentFileChangeReportTurnId,
           agentFileChangeReportRequest,
           agentFileChangeReportUnavailableReason,
-          activePrompt.signal
+          agentFileChangeReportTurnId === null || eventHandler === null ? "" : eventHandler.getTurnDiff(agentFileChangeReportTurnId),
+          agentFileChangeWorkspace
         );
       }
       logger.log("Prompt completed", { sessionId: params.sessionId });