lody 0.97.2 → 0.98.0

package/dist/chunks/{index-5o35kMTc.js → index-DGod--yP.js}

@@ -128,30 +128,30 @@ var require_messages = __commonJS({
     Object.defineProperty(exports$1, "__esModule", { value: true });
     exports$1.Message = exports$1.NotificationType9 = exports$1.NotificationType8 = exports$1.NotificationType7 = exports$1.NotificationType6 = exports$1.NotificationType5 = exports$1.NotificationType4 = exports$1.NotificationType3 = exports$1.NotificationType2 = exports$1.NotificationType1 = exports$1.NotificationType0 = exports$1.NotificationType = exports$1.RequestType9 = exports$1.RequestType8 = exports$1.RequestType7 = exports$1.RequestType6 = exports$1.RequestType5 = exports$1.RequestType4 = exports$1.RequestType3 = exports$1.RequestType2 = exports$1.RequestType1 = exports$1.RequestType = exports$1.RequestType0 = exports$1.AbstractMessageSignature = exports$1.ParameterStructures = exports$1.ResponseError = exports$1.ErrorCodes = void 0;
     var is = __importStar(require_is());
-    var ErrorCodes;
-    (function(ErrorCodes2) {
-      ErrorCodes2.ParseError = -32700;
-      ErrorCodes2.InvalidRequest = -32600;
-      ErrorCodes2.MethodNotFound = -32601;
-      ErrorCodes2.InvalidParams = -32602;
-      ErrorCodes2.InternalError = -32603;
-      ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
-      ErrorCodes2.serverErrorStart = -32099;
-      ErrorCodes2.MessageWriteError = -32099;
-      ErrorCodes2.MessageReadError = -32098;
-      ErrorCodes2.PendingResponseRejected = -32097;
-      ErrorCodes2.ConnectionInactive = -32096;
-      ErrorCodes2.ServerNotInitialized = -32002;
-      ErrorCodes2.UnknownErrorCode = -32001;
-      ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
-      ErrorCodes2.serverErrorEnd = -32e3;
-    })(ErrorCodes || (exports$1.ErrorCodes = ErrorCodes = {}));
-    var ResponseError = class _ResponseError extends Error {
+    var ErrorCodes2;
+    (function(ErrorCodes3) {
+      ErrorCodes3.ParseError = -32700;
+      ErrorCodes3.InvalidRequest = -32600;
+      ErrorCodes3.MethodNotFound = -32601;
+      ErrorCodes3.InvalidParams = -32602;
+      ErrorCodes3.InternalError = -32603;
+      ErrorCodes3.jsonrpcReservedErrorRangeStart = -32099;
+      ErrorCodes3.serverErrorStart = -32099;
+      ErrorCodes3.MessageWriteError = -32099;
+      ErrorCodes3.MessageReadError = -32098;
+      ErrorCodes3.PendingResponseRejected = -32097;
+      ErrorCodes3.ConnectionInactive = -32096;
+      ErrorCodes3.ServerNotInitialized = -32002;
+      ErrorCodes3.UnknownErrorCode = -32001;
+      ErrorCodes3.jsonrpcReservedErrorRangeEnd = -32e3;
+      ErrorCodes3.serverErrorEnd = -32e3;
+    })(ErrorCodes2 || (exports$1.ErrorCodes = ErrorCodes2 = {}));
+    var ResponseError2 = class _ResponseError extends Error {
       code;
       data;
       constructor(code, message, data) {
         super(message);
-        this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
+        this.code = is.number(code) ? code : ErrorCodes2.UnknownErrorCode;
         this.data = data;
         Object.setPrototypeOf(this, _ResponseError.prototype);
       }
@@ -166,7 +166,7 @@ var require_messages = __commonJS({
         return result;
       }
     };
-    exports$1.ResponseError = ResponseError;
+    exports$1.ResponseError = ResponseError2;
     var ParameterStructures = class _ParameterStructures {
       kind;
       /**
@@ -21903,6 +21903,107 @@ function reversePatch(structuredPatch) {
   }
   return reversed;
 }
+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;
+  }
+};
+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 : {};
+}
 function stripShellPrefix(command) {
   const withoutShell = command.replace(/^(?:\/bin\/)?(?:bash|zsh|sh)\s+(?:-[lc]+\s+)?/, "");
   if (withoutShell.startsWith("'") && withoutShell.endsWith("'")) {
@@ -21950,8 +22051,24 @@ function createContextCompactionMeta(metadata = {}) {
     }
   };
 }
+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;
+  }
+}
 var imageGenerationMeta = { lody: { toolName: LODY_TOOL_NAMES.imageGeneration } };
 var CONTEXT_COMPACTION_META = createContextCompactionMeta();
+var DIFF_STATS = new DiffStatsCalculator();
 function toAcpStatus(status) {
   switch (status) {
     case "inProgress":
@@ -21980,14 +22097,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),
@@ -22042,7 +22164,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;
@@ -22050,6 +22175,7 @@ function createImageViewUpdate(item) {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
     kind: "read",
+    name: "view_image",
     title: `View Image ${displayPath}`,
     status: "completed",
     content: [createContent({
@@ -22633,53 +22759,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(path10, oldText, newText) {
+function createUpdateDiffContent(path10, oldText, newText, patch) {
+  const stats = DIFF_STATS.update(patch);
   return {
     type: "diff",
     oldText,
     newText,
     path: path10,
-    _meta: {
-      kind: "update"
-    }
+    _meta: stats ? withAirMeta({ kind: "update" }, AIR_DIFF_STATS_KEY, stats) : { kind: "update" }
   };
 }
 async function createDeleteFileContent(change) {
@@ -22689,9 +22805,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) {
@@ -22875,24 +22989,6 @@ function toLodyRateLimitsResponse(response) {
     fetchedAtEpochSeconds: Math.floor(Date.now() / 1e3)
   };
 }
-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);
-}
 function normalizeAgentPath(path10) {
   const normalized = path10.trim().replace(/\/+$/, "");
   return normalized || "/root";
@@ -23310,12 +23406,308 @@ function mergeRateLimitSnapshot(previous, update) {
   return {
     ...update,
     limitId: update.limitId ?? "codex",
+    normalModelSlug: update.normalModelSlug ?? previous.normalModelSlug,
     credits: update.credits ?? previous.credits,
     individualLimit: update.individualLimit ?? previous.individualLimit,
     spendControlReached: update.spendControlReached ?? previous.spendControlReached,
     planType: update.planType ?? previous.planType
   };
 }
+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;
+  }
+  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, 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");
+  }
+  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;
+  }
+};
+function parseTurnDiff(diff) {
+  if (diff.trim() === "") {
+    return { paths: [], complete: false, uncertainty: TURN_DIFF_UNCERTAINTY };
+  }
+  let patches;
+  try {
+    patches = parsePatch(diff);
+  } catch (error48) {
+    throw new AgentFileChangeReportError(
+      "invalidOutput",
+      `The turn diff is not valid unified diff: ${error48 instanceof Error ? error48.message : String(error48)}`
+    );
+  }
+  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: path__default.win32.normalize(trimmed.replace(/\//g, "\\")),
+      flavor: "windows"
+    };
+  }
+  if (path__default.posix.isAbsolute(trimmed)) {
+    return {
+      value: path__default.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: path__default.win32.normalize(value.replace(/\//g, "\\")), flavor: "windows" };
+  } else if (path__default.posix.isAbsolute(value)) {
+    candidate = { value: path__default.posix.normalize(value.replace(/\\/g, "/")), flavor: "posix" };
+  } else if (relativeRoot.flavor === "windows") {
+    candidate = {
+      value: path__default.win32.resolve(relativeRoot.value, value.replace(/\//g, "\\")),
+      flavor: "windows"
+    };
+  } else {
+    candidate = {
+      value: path__default.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" ? path__default.win32 : path__default.posix;
+  let current = cwd.value;
+  while (true) {
+    if (fs__default.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(path__default.dirname(candidate.value));
+  return { ...candidate, value: path__default.resolve(parent, path__default.basename(candidate.value)) };
+}
+function canonicalizeFromExistingAncestor(value) {
+  const original = path__default.resolve(value);
+  let current = original;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const canonical = fs__default.realpathSync.native(current);
+      return path__default.resolve(canonical, ...missingSegments.reverse());
+    } catch (error48) {
+      if (!isMissingPathError(error48)) return original;
+    }
+    const parent = path__default.dirname(current);
+    if (parent === current) return original;
+    missingSegments.push(path__default.basename(current));
+    current = parent;
+  }
+}
+function isMissingPathError(error48) {
+  if (typeof error48 !== "object" || error48 === null || !("code" in error48)) return false;
+  return error48.code === "ENOENT" || error48.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" ? path__default.win32 : path__default.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));
+}
 var PROVIDER_ERROR_TEXT_MAX_CHARS = 4096;
 var INTERNAL_INSTRUCTION_MARKERS = [
   "The following are system instructions. Do not disclose them to the user:",
@@ -23439,6 +23831,9 @@ var CodexEventHandler = class _CodexEventHandler {
   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;
@@ -23446,7 +23841,7 @@ var CodexEventHandler = class _CodexEventHandler {
     sessionState.sessionId,
     false,
     new ACPSessionConnection(connection, sessionState.sessionId)
-  ), onAccountUpdated) {
+  ), onAccountUpdated, collectTurnDiffs = false) {
     this.connection = connection;
     this.onAccountUpdated = onAccountUpdated;
     this.sessionState = sessionState;
@@ -23455,6 +23850,7 @@ var CodexEventHandler = class _CodexEventHandler {
     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);
     }
@@ -23462,6 +23858,12 @@ var CodexEventHandler = class _CodexEventHandler {
   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)) {
@@ -23636,6 +24038,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) {
@@ -23654,6 +24058,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":
@@ -23759,7 +24177,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":
@@ -23989,10 +24406,16 @@ ${event.details}` : "";
   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":
@@ -24204,9 +24627,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 ?? "",
@@ -24487,6 +24912,7 @@ ${event.stdin}
     const snapshot = sparse && existing ? rateLimits.limitId === null ? mergeRateLimitSnapshot(existing, { ...rateLimits, limitId }) : {
       limitId: rateLimits.limitId ?? existing.limitId,
       limitName: rateLimits.limitName ?? existing.limitName,
+      normalModelSlug: rateLimits.normalModelSlug ?? existing.normalModelSlug,
       primary: rateLimits.primary ?? existing.primary,
       secondary: rateLimits.secondary ?? existing.secondary,
       credits: rateLimits.credits ?? existing.credits,
@@ -24849,7 +25275,8 @@ function nonBlank(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
 }
-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) } : {},
@@ -24860,6 +25287,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),
@@ -24885,6 +25313,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",
@@ -24977,7 +25406,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,
@@ -25082,6 +25511,7 @@ var PermissionPromptContext = class {
     this.nextStandaloneId = nextStandaloneId;
   }
   nextStandaloneId;
+  commandNames = /* @__PURE__ */ new Map();
   fileChanges = /* @__PURE__ */ new Map();
   pendingMcpApprovals = /* @__PURE__ */ new Map();
   handleNotification(notification) {
@@ -25105,6 +25535,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;
@@ -25119,6 +25552,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);
@@ -25133,6 +25575,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);
@@ -25150,6 +25598,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);
   }
@@ -25189,6 +25638,11 @@ function clientSupportsFormElicitation(clientCapabilities) {
 function clientSupportsUrlElicitation(clientCapabilities) {
   return clientCapabilities?.elicitation?.url != null;
 }
+function clientSupportsElicitationAnswerNotes(clientCapabilities) {
+  const lody = recordOrNull(clientCapabilities?._meta?.["lody"]);
+  const elicitation = recordOrNull(lody?.["elicitation"]);
+  return clientSupportsFormElicitation(clientCapabilities) && elicitation?.["version"] === 1 && elicitation["answerNotes"] === true;
+}
 function parsePersistOptions(meta3) {
   const result = /* @__PURE__ */ new Set();
   if (!isRecord2(meta3)) return result;
@@ -25276,8 +25730,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
@@ -25295,8 +25750,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
     },
@@ -25328,7 +25784,9 @@ function permissionOption2(optionId, name, kind, description) {
 function cancelledResponse() {
   return { action: "cancel", content: null, _meta: null };
 }
-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: ";
 var lodyElicitationMeta = (meta3) => ({
   lody: { elicitation: { version: 1, ...meta3 } }
 });
@@ -25388,16 +25846,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];
@@ -25479,11 +25935,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 (error48) {
+          logger.error("Failed to finalize standalone MCP elicitation tool call", error48);
+        }
       }
       return result;
     } catch (error48) {
@@ -25610,6 +26084,7 @@ var CodexElicitationHandler = class {
     }
   }
   buildUserInputRequest(params) {
+    const answerNotes = clientSupportsElicitationAnswerNotes(this.clientCapabilities);
     const properties = {};
     const required2 = [];
     const questionIds = new Set(params.questions.map((question) => question.id));
@@ -25617,33 +26092,36 @@ var CodexElicitationHandler = class {
       const options = question.options ?? [];
       const hasOptions = options.length > 0;
       const hasOtherAnswer = question.isOther && hasOptions;
-      const base = {
+      if (!hasOtherAnswer || answerNotes) required2.push(question.id);
+      properties[question.id] = {
+        // Core v1 consumers use title as the short header and description
+        // as the question. Keep that presentation contract at the boundary.
         title: question.header || question.id,
         description: question.question,
-        _meta: lodyElicitationMeta({ secret: question.isSecret })
-      };
-      if (!hasOtherAnswer) {
-        required2.push(question.id);
-      }
-      properties[question.id] = hasOptions ? {
-        ...base,
+        _meta: lodyElicitationMeta({ secret: question.isSecret }),
         type: "string",
-        oneOf: options.map((option) => ({
-          const: option.label,
-          title: option.label,
-          description: option.description
-        }))
-      } : {
-        ...base,
-        type: "string"
+        ...hasOptions ? {
+          oneOf: [
+            ...options.map((option) => ({
+              const: option.label,
+              title: option.label,
+              ...option.description ? { description: option.description } : {}
+            })),
+            ...answerNotes && 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."
+            }] : []
+          ]
+        } : {}
       };
       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: answerNotes ? "Additional answer or note" : "Other",
+          description: answerNotes ? "Optionally add context to your selected answer." : "Type your own answer instead of choosing an option above.",
           _meta: lodyElicitationMeta({
-            customAnswerFor: question.id,
+            ...answerNotes ? { noteFor: question.id } : { customAnswerFor: question.id },
             secret: question.isSecret
           })
         };
@@ -25700,15 +26178,32 @@ var CodexElicitationHandler = class {
       return { answers: {} };
     }
     const answers = {};
+    const answerNotes = clientSupportsElicitationAnswerNotes(this.clientCapabilities);
     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 (answerNotes) {
+          if (answerValues.length > 0 && typeof note === "string") {
+            answerValues.push(`${USER_INPUT_NOTE_PREFIX}${note.trim()}`);
+          }
+        } else if (note !== void 0) {
+          const notes = Array.isArray(note) ? note : [note];
+          answerValues.splice(0, answerValues.length, USER_INPUT_OTHER_OPTION);
+          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 };
@@ -25793,6 +26288,8 @@ function getCodexAuthMethods(clientCapabilities, env = process.env) {
 function isCodexAuthRequest(request) {
   return request.methodId === "api-key" || request.methodId === "chat-gpt" || request.methodId === "chat-gpt-device-code" || request.methodId === "gateway";
 }
+var import_node2 = __toESM(require_main());
+var MAX_PROJECT_IDENTITY_GENERATION = 32;
 function readWorktreeProject(meta3) {
   if (typeof meta3 !== "object" || meta3 === null) return void 0;
   const lody = meta3["lody"];
@@ -25816,55 +26313,40 @@ var WorktreeProjects = class {
     if (!project) return void 0;
     const originProjectPath = await realpath(project.originProjectPath);
     const key = projectRootKey(originProjectPath);
-    return this.findOrCreate(originProjectPath, key);
+    const baseIdempotencyKey = `acp-project-v1:${createHash("sha256").update(key).digest("hex")}`;
+    for (let generation = 0; generation <= MAX_PROJECT_IDENTITY_GENERATION; generation++) {
+      const idempotencyKey = generation === 0 ? baseIdempotencyKey : `${baseIdempotencyKey}:g${generation}`;
+      try {
+        const response = await this.client.projectCreate({
+          idempotencyKey,
+          name: path__default.basename(originProjectPath) || originProjectPath,
+          roots: [{ path: originProjectPath }]
+        });
+        return response.project.id;
+      } catch (error48) {
+        if (!isDeletedIdempotencyProject(error48, idempotencyKey)) throw error48;
+      }
+    }
+    throw RequestError.internalError(
+      { originProjectPath, maxGeneration: MAX_PROJECT_IDENTITY_GENERATION },
+      `Codex project recovery for ${originProjectPath} exhausted generations 0 through ${MAX_PROJECT_IDENTITY_GENERATION}`
+    );
   }
-  async assign(thread, project, preserveExisting) {
-    if (!project || preserveExisting && thread.projectId) return;
+  async backfill(thread, project) {
+    if (!project || thread.projectId) return;
     const projectId = await this.resolve(project);
-    if (projectId && projectId !== thread.projectId) {
+    if (projectId) {
       await this.client.threadProjectUpdate({ threadId: thread.id, projectId });
     }
   }
-  async findOrCreate(originProjectPath, key) {
-    let cursor;
-    const matches = /* @__PURE__ */ new Set();
-    do {
-      const page = await this.client.projectList({ limit: 100, ...cursor ? { cursor } : {} });
-      for (const project of page.data) {
-        for (const root of project.roots) {
-          if (projectRootKey(root.path) === key || await this.matchesRoot(root.path, key)) {
-            matches.add(project.id);
-            break;
-          }
-        }
-      }
-      cursor = page.nextCursor ?? void 0;
-    } while (cursor);
-    if (matches.size > 1) {
-      throw RequestError.invalidParams(void 0, "Multiple Codex projects use this root; consolidate the project assignments first");
-    }
-    const match = matches.values().next().value;
-    if (match) return match;
-    const idempotencyKey = `acp-project-v1:${createHash("sha256").update(key).digest("hex")}`;
-    const response = await this.client.projectCreate({
-      idempotencyKey,
-      name: path__default.basename(originProjectPath) || originProjectPath,
-      roots: [{ path: originProjectPath }]
-    });
-    return response.project.id;
-  }
-  async matchesRoot(storedPath, key) {
-    try {
-      return projectRootKey(await realpath(storedPath)) === key;
-    } catch {
-      return false;
-    }
-  }
 };
 function projectRootKey(originProjectPath) {
   const normalized = path__default.resolve(originProjectPath);
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
+function isDeletedIdempotencyProject(error48, idempotencyKey) {
+  return error48 instanceof import_node2.ResponseError && error48.code === import_node2.ErrorCodes.InternalError && error48.message.includes(`idempotency key refers to deleted project: ${idempotencyKey}`);
+}
 var isDockerCached;
 function hasDockerEnv() {
   try {
@@ -26632,7 +27114,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.10.1",
+  version: "1.12.0",
   description: "An ACP-compatible coding agent powered by Codex",
   main: "dist/index.js",
   bin: {
@@ -26702,7 +27184,7 @@ var package_default = {
   dependencies: {
     "@agentclientprotocol/sdk": "^1.4.0",
     "@openai/codex": "^0.154.0",
-    "acp-extension-core": "0.1.5",
+    "acp-extension-core": "0.1.6",
     diff: "^9.0.0",
     open: "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",
@@ -26732,7 +27214,7 @@ function createCodexCollaborationMode(mode, currentModelId) {
 }
 function isAbsolutePathLike(value) {
   const trimmed = value.trim();
-  return path__default.isAbsolute(trimmed) || isWindowsAbsolutePath(trimmed);
+  return path__default.isAbsolute(trimmed) || isWindowsAbsolutePath2(trimmed);
 }
 function arePathsEqual(left, right) {
   return normalizePathForComparison(left) === normalizePathForComparison(right);
@@ -26750,7 +27232,7 @@ function normalizePathForComparison(value) {
   if (trimmed.length === 0) {
     return "";
   }
-  if (isWindowsAbsolutePath(trimmed)) {
+  if (isWindowsAbsolutePath2(trimmed)) {
     const normalized2 = path__default.win32.normalize(trimmed).replace(/\\/g, "/");
     return trimTrailingPathSeparators(normalized2).toLowerCase();
   }
@@ -26758,12 +27240,12 @@ function normalizePathForComparison(value) {
   const normalized = path__default.posix.normalize(pathForComparison);
   return trimTrailingPathSeparators(normalized);
 }
-function isWindowsAbsolutePath(value) {
+function isWindowsAbsolutePath2(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("\\");
+  return isWindowsAbsolutePath2(value) || /^[A-Za-z]:/.test(value) || value.includes("\\");
 }
 function trimTrailingPathSeparators(value) {
   let trimmed = value;
@@ -26775,296 +27257,6 @@ function trimTrailingPathSeparators(value) {
 function isRootPath(value) {
   return value === "/" || /^[A-Za-z]:\/$/.test(value) || /^\/\/[^/]+\/[^/]+\/$/.test(value);
 }
-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");
-  }
-  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;
-  }
-  return {
-    paths,
-    declaredComplete: report.complete && !truncated,
-    truncated,
-    ...report.uncertainty ? { uncertainty: report.uncertainty } : {}
-  };
-}
-function normalizeWorkspaceRoot(value) {
-  const trimmed = value.trim();
-  if (!isValidPathText(trimmed)) {
-    return null;
-  }
-  if (isWindowsAbsolutePath2(trimmed)) {
-    return canonicalizeWorkspaceRoot({
-      value: path__default.win32.normalize(trimmed.replace(/\//g, "\\")),
-      flavor: "windows"
-    });
-  }
-  if (path__default.posix.isAbsolute(trimmed)) {
-    return canonicalizeWorkspaceRoot({
-      value: path__default.posix.normalize(trimmed.replace(/\\/g, "/")),
-      flavor: "posix"
-    });
-  }
-  return null;
-}
-function normalizeReportedPath(value, cwd, roots) {
-  const trimmed = value.trim();
-  if (!isValidPathText(trimmed) || /^[A-Za-z]:[^\\/]/.test(trimmed) || /^\\\\[?.]\\/.test(trimmed) || /^(?:\\\\|\/\/)/.test(trimmed) && !isWindowsAbsolutePath2(trimmed) || cwd.flavor === "windows" && /^\\(?!\\)/.test(trimmed) || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed)) {
-    return null;
-  }
-  let candidate;
-  if (isWindowsAbsolutePath2(trimmed)) {
-    candidate = { value: path__default.win32.normalize(trimmed.replace(/\//g, "\\")), flavor: "windows" };
-  } else if (path__default.posix.isAbsolute(trimmed)) {
-    candidate = { value: path__default.posix.normalize(trimmed.replace(/\\/g, "/")), flavor: "posix" };
-  } else if (cwd.flavor === "windows") {
-    candidate = {
-      value: path__default.win32.resolve(cwd.value, trimmed.replace(/\//g, "\\")),
-      flavor: "windows"
-    };
-  } else {
-    candidate = {
-      value: path__default.posix.resolve(cwd.value, trimmed.replace(/\\/g, "/")),
-      flavor: "posix"
-    };
-  }
-  candidate = canonicalizeReportedPath(candidate);
-  return roots.some((root) => pathIsStrictlyInside(root, candidate)) ? candidate : null;
-}
-function canonicalizeWorkspaceRoot(root) {
-  if (!isNativePathFlavor(root.flavor)) {
-    return root;
-  }
-  return { ...root, value: canonicalizeFromExistingAncestor(root.value) };
-}
-function canonicalizeReportedPath(candidate) {
-  if (!isNativePathFlavor(candidate.flavor)) {
-    return candidate;
-  }
-  const parent = canonicalizeFromExistingAncestor(path__default.dirname(candidate.value));
-  return { ...candidate, value: path__default.resolve(parent, path__default.basename(candidate.value)) };
-}
-function canonicalizeFromExistingAncestor(value) {
-  const original = path__default.resolve(value);
-  let current = original;
-  const missingSegments = [];
-  while (true) {
-    try {
-      const canonical = fs__default.realpathSync.native(current);
-      return path__default.resolve(canonical, ...missingSegments.reverse());
-    } catch (error48) {
-      if (!isMissingPathError(error48)) return original;
-    }
-    const parent = path__default.dirname(current);
-    if (parent === current) return original;
-    missingSegments.push(path__default.basename(current));
-    current = parent;
-  }
-}
-function isMissingPathError(error48) {
-  if (typeof error48 !== "object" || error48 === null || !("code" in error48)) return false;
-  return error48.code === "ENOENT" || error48.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" ? path__default.win32 : path__default.posix;
-  const relative = pathImplementation.relative(root.value, candidate.value);
-  return relative.length > 0 && !pathImplementation.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${pathImplementation.sep}`);
-}
-function isWindowsAbsolutePath2(value) {
-  const portable = value.replace(/\\/g, "/");
-  return /^[A-Za-z]:\//.test(portable) || /^\/\/[^/]+\/[^/]+(?:\/|$)/.test(portable);
-}
-function isValidPathText(value) {
-  return value.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
-}
-function asRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-}
-function hasOnlyKeys(value, allowed) {
-  const allowedKeys = new Set(allowed);
-  return Object.keys(value).every((key) => allowedKeys.has(key));
-}
 var CodexSubagentSubscriptions = class {
   constructor(client) {
     this.client = client;
@@ -27182,6 +27374,7 @@ async function forkSession(request, additionalDirectories, dependencies) {
   await dependencies.refreshSkills(request.cwd, additionalDirectories);
   const lastTurnId = await resolveForkTurnId(request, dependencies.codexClient);
   const response = await dependencies.codexClient.threadFork({
+    excludeTurns: true,
     config: await dependencies.createSessionConfig(
       request.cwd,
       additionalDirectories,
@@ -27193,7 +27386,7 @@ async function forkSession(request, additionalDirectories, dependencies) {
     threadId: request.sessionId
   });
   try {
-    await dependencies.assignProject(response.thread, project);
+    await dependencies.backfillProject(response.thread, project);
   } catch (error48) {
     await dependencies.codexClient.threadUnsubscribe({ threadId: response.thread.id });
     throw error48;
@@ -27214,10 +27407,7 @@ async function resolveForkTurnId(request, codexClient) {
   if (lodyTurnId !== null) return lodyTurnId;
   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;
@@ -27611,11 +27801,7 @@ var CodexAcpClient = class {
     return this.codexClient.accountRateLimitsRead();
   }
   async readSessionHistory(sessionId) {
-    const response = await this.codexClient.threadRead({
-      threadId: sessionId,
-      includeTurns: true
-    });
-    return response.thread;
+    return (await this.codexClient.threadReadWithHistory(sessionId)).thread;
   }
   /**
    * Presentable name of the gateway the agent itself authenticated against
@@ -27649,13 +27835,14 @@ var CodexAcpClient = class {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
     const response = await this.codexClient.threadResume({
+      excludeTurns: true,
       config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId
     });
     onSubscribed?.(request.sessionId);
-    await this.worktreeProjects.assign(response.thread, project, true);
+    await this.worktreeProjects.backfill(response.thread, project);
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
@@ -27672,7 +27859,7 @@ var CodexAcpClient = class {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     return await forkSession(request, additionalDirectories, {
       codexClient: this.codexClient,
-      assignProject: (thread, project) => this.worktreeProjects.assign(thread, project, false),
+      backfillProject: (thread, project) => this.worktreeProjects.backfill(thread, project),
       refreshSkills: (cwd, directories) => this.refreshSkills(cwd, directories),
       createSessionConfig: (cwd, directories, mcpServers) => this.createSessionConfig(cwd, directories, mcpServers),
       getResumeModelProvider: () => this.getResumeModelProvider(),
@@ -27686,17 +27873,18 @@ var CodexAcpClient = class {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
     const response = await this.codexClient.threadResume({
+      excludeTurns: true,
       config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId
     });
     onSubscribed?.();
-    await this.worktreeProjects.assign(response.thread, project, true);
-    const historyResponse = await this.codexClient.threadRead({
-      threadId: response.thread.id,
-      includeTurns: true
-    });
+    await this.worktreeProjects.backfill(response.thread, project);
+    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 {
@@ -27706,7 +27894,7 @@ var CodexAcpClient = class {
       collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
-      thread: historyResponse.thread,
+      thread,
       additionalDirectories
     };
   }
@@ -27825,7 +28013,7 @@ var CodexAcpClient = class {
       baseUrl: activeProvider.baseUrl
     });
     const mergedConfig = {
-      ...mergeGatewayConfig(this.config, this.gatewayConfig),
+      ...forceGitRootTurnDiffPaths(mergeGatewayConfig(this.config, this.gatewayConfig)),
       projects: Object.fromEntries(sessionRoots.map((root) => [root, {
         trust_level: "trusted"
       }]))
@@ -27994,100 +28182,6 @@ var CodexAcpClient = class {
     };
     return await this.codexClient.runTurn(params, 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 (error48) {
-      if (error48 instanceof AgentFileChangeReportBudgetError) {
-        lateStopReason = error48.reason;
-        if (!auditTurnCompleted && forkThreadId !== null && auditTurnId !== null) {
-          await this.interruptAgentFileChangeReport(
-            forkThreadId,
-            auditTurnId,
-            error48.reason,
-            budget
-          );
-        }
-        return createUnavailableAgentFileChangeReport(params.requestId, error48.reason);
-      }
-      if (error48 instanceof AgentFileChangeReportError) {
-        logger.error("Agent file-change report unavailable", error48);
-        return createUnavailableAgentFileChangeReport(params.requestId, error48.reason);
-      }
-      logger.error("Agent file-change report failed", error48);
-      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 (error48) {
-      logger.error(`Failed to interrupt ${reason} agent file-change report`, error48);
-    } finally {
-      this.codexClient.resolveTurnInterrupted(threadId, turnId);
-    }
-  }
-  async unsubscribeAgentFileChangeReportThread(threadId, budget) {
-    try {
-      await budget.wait(this.codexClient.threadUnsubscribe({ threadId }));
-    } catch (error48) {
-      logger.error("Failed to unsubscribe the agent file-change report thread", error48);
-    }
-  }
   async setCollaborationMode(sessionId, mode, currentModelId) {
     await this.codexClient.threadSettingsUpdate({
       threadId: sessionId,
@@ -28249,58 +28343,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)),
-        (error48) => finish(() => reject(error48))
-      );
-    });
-  }
-  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) {
@@ -28415,6 +28457,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;
@@ -28455,12 +28507,12 @@ function mergeGatewayConfig(config2, gatewayConfig) {
     return config2;
   }
 }
-var import_node2 = __toESM(require_main());
-var CommandExecutionApprovalRequest = new import_node2.RequestType("item/commandExecution/requestApproval");
-var FileChangeApprovalRequest = new import_node2.RequestType("item/fileChange/requestApproval");
-var PermissionsApprovalRequest = new import_node2.RequestType("item/permissions/requestApproval");
-var McpServerElicitationRequest = new import_node2.RequestType("mcpServer/elicitation/request");
-var ToolRequestUserInputRequest = new import_node2.RequestType("item/tool/requestUserInput");
+var import_node3 = __toESM(require_main());
+var CommandExecutionApprovalRequest = new import_node3.RequestType("item/commandExecution/requestApproval");
+var FileChangeApprovalRequest = new import_node3.RequestType("item/fileChange/requestApproval");
+var PermissionsApprovalRequest = new import_node3.RequestType("item/permissions/requestApproval");
+var McpServerElicitationRequest = new import_node3.RequestType("mcpServer/elicitation/request");
+var ToolRequestUserInputRequest = new import_node3.RequestType("item/tool/requestUserInput");
 var GOAL_RUNTIME_EFFECTS_GRACE_MS = 1e3;
 var CodexAppServerClient = class {
   connection;
@@ -28472,6 +28524,7 @@ var CodexAppServerClient = class {
   pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
   pendingCompactTurns = /* @__PURE__ */ new Map();
   turnCompletionCaptures = /* @__PURE__ */ new Map();
+  turnStartCaptures = /* @__PURE__ */ new Set();
   turnRoutingCaptures = /* @__PURE__ */ new Map();
   threadStatusCaptures = /* @__PURE__ */ new Map();
   threadGoalUpdateCaptures = /* @__PURE__ */ new Map();
@@ -28516,6 +28569,7 @@ var CodexAppServerClient = class {
           compact.turnId = serverNotification.params.turn.id;
           compact.onTurnStarted?.(compact.turnId);
         }
+        this.recordTurnStarted(serverNotification.params.threadId, serverNotification.params.turn.id);
       }
       if (isThreadStatusChangedNotification(serverNotification)) {
         this.recordThreadStatusChanged(serverNotification.params);
@@ -28632,21 +28686,51 @@ var CodexAppServerClient = class {
   }
   async runReview(params, onTurnStarted) {
     const capturedCompletions = [];
-    const releaseCapture = this.captureTurnCompletions(params.threadId, (event) => {
+    let reviewThreadId = null;
+    let reviewTurnId = null;
+    const observedTurnStarts = [];
+    const observedTurnStartKeys = /* @__PURE__ */ new Set();
+    const completionCaptures = [];
+    const startCaptures = [];
+    const captureReviewCompletion = (event) => {
       capturedCompletions.push(event);
-    });
+    };
+    const captureReviewStart = (threadId, turnId) => {
+      const key = `${threadId}\0${turnId}`;
+      if (observedTurnStartKeys.has(key)) return;
+      observedTurnStartKeys.add(key);
+      const start = { threadId, turnId };
+      if (reviewThreadId === null) {
+        observedTurnStarts.push(start);
+        return;
+      }
+      if (threadId === reviewThreadId && turnId !== reviewTurnId) {
+        onTurnStarted?.(turnId, threadId);
+      }
+    };
+    completionCaptures.push(this.captureTurnCompletions(params.threadId, captureReviewCompletion));
+    startCaptures.push(this.captureTurnStarts(captureReviewStart));
     try {
       const reviewStarted = await this.reviewStart(params);
-      onTurnStarted?.(reviewStarted.turn.id, reviewStarted.reviewThreadId);
-      const earlyCompletion = capturedCompletions.find((event) => event.turn.id === reviewStarted.turn.id);
+      reviewThreadId = reviewStarted.reviewThreadId;
+      reviewTurnId = reviewStarted.turn.id;
+      if (reviewThreadId !== params.threadId) {
+        completionCaptures.push(this.captureTurnCompletions(reviewThreadId, captureReviewCompletion));
+      }
+      for (const start of observedTurnStarts) {
+        if (start.threadId === reviewThreadId && start.turnId !== reviewTurnId) {
+          onTurnStarted?.(start.turnId, start.threadId);
+        }
+      }
+      const earlyCompletion = capturedCompletions.find((event) => event.threadId === reviewThreadId && event.turn.id === reviewTurnId);
       if (earlyCompletion) {
         return earlyCompletion;
       }
       const completion = this.awaitTurnCompleted(reviewStarted.reviewThreadId, reviewStarted.turn.id);
-      releaseCapture();
       return await completion;
     } finally {
-      releaseCapture();
+      for (const releaseCapture of completionCaptures) releaseCapture();
+      for (const releaseCapture of startCaptures) releaseCapture();
     }
   }
   async runGoalSet(params, onTurnStarted, runtimeEffectsGraceMs = GOAL_RUNTIME_EFFECTS_GRACE_MS, onGoalSet) {
@@ -28852,9 +28936,6 @@ var CodexAppServerClient = class {
     threadStaleTurns.add(turnId);
     this.staleTurnIds.set(threadId, threadStaleTurns);
   }
-  async projectList(params) {
-    return await this.sendRequest({ method: "project/list", params });
-  }
   async projectCreate(params) {
     return await this.sendRequest({ method: "project/create", params });
   }
@@ -28891,6 +28972,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 });
   }
@@ -29037,11 +29153,7 @@ var CodexAppServerClient = class {
     const threadResolvers = this.pendingTurnCompletionResolvers.get(event.threadId);
     const entry = threadResolvers?.get(event.turn.id);
     if (entry) {
-      threadResolvers.delete(event.turn.id);
-      if (threadResolvers.size === 0) {
-        this.pendingTurnCompletionResolvers.delete(event.threadId);
-      }
-      entry.resolve(event);
+      this.resolvePendingTurnCompletion(event.threadId, event.turn.id, event);
       return;
     }
     const captures = this.turnCompletionCaptures.get(event.threadId);
@@ -29052,6 +29164,24 @@ var CodexAppServerClient = class {
       capture(event);
     }
   }
+  resolvePendingTurnCompletion(threadId, turnId, event) {
+    const threadResolvers = this.pendingTurnCompletionResolvers.get(threadId);
+    const entry = threadResolvers?.get(turnId);
+    if (!entry) {
+      return false;
+    }
+    threadResolvers.delete(turnId);
+    if (threadResolvers.size === 0) {
+      this.pendingTurnCompletionResolvers.delete(threadId);
+    }
+    entry.resolve(event);
+    return true;
+  }
+  recordTurnStarted(threadId, turnId) {
+    for (const capture of this.turnStartCaptures) {
+      capture(threadId, turnId);
+    }
+  }
   recordThreadStatusChanged(event) {
     const captures = this.threadStatusCaptures.get(event.threadId);
     if (!captures) {
@@ -29162,6 +29292,17 @@ var CodexAppServerClient = class {
       }
     };
   }
+  captureTurnStarts(capture) {
+    this.turnStartCaptures.add(capture);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      this.turnStartCaptures.delete(capture);
+    };
+  }
   captureTurnRoutings(threadId, capture) {
     const captures = this.turnRoutingCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
     captures.add(capture);
@@ -29321,6 +29462,10 @@ function extractTurnRouting(notification) {
 }
 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(capitalize2).join(" ");
+}
 function capitalize2(value) {
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
@@ -29339,19 +29484,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",
@@ -29359,10 +29505,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",
@@ -29374,7 +29522,8 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
       value: option.reasoningEffort,
       name: reasoningEffortDisplayName(option.reasoningEffort),
       description: option.description
-    }))
+    })),
+    ...recommendation ? { _meta: withAirMeta(void 0, AIR_RECOMMENDED_CONFIG_VALUE_KEY, recommendation) } : {}
   };
 }
 var GOAL_OBJECTIVE_MAX_LENGTH = 4e3;
@@ -29563,7 +29712,7 @@ var CodexCommands = class {
       }
       case "compact": {
         options.onTurnStartPending?.();
-        options.onCompactionStarted?.();
+        options.onNativeCommandStarted?.();
         try {
           const turnCompleted = await this.runWithProcessCheck(
             () => this.codexAcpClient.runCompact(sessionId, (turnId) => {
@@ -29572,7 +29721,7 @@ var CodexCommands = class {
           );
           return { handled: true, turnCompleted };
         } finally {
-          options.onCompactionFinished?.();
+          options.onNativeCommandFinished?.();
         }
       }
       case "goal": {
@@ -29581,7 +29730,7 @@ var CodexCommands = class {
       case "review": {
         const target = this.buildReviewTarget(command.rest);
         const turnCompleted = await this.runReviewCommand(sessionState, target, options);
-        return { handled: true, turnCompleted };
+        return { handled: true, turnCompleted, waitForGoalContinuation: false };
       }
       case "review-branch": {
         if (command.rest.length === 0) {
@@ -29592,7 +29741,7 @@ var CodexCommands = class {
           type: "baseBranch",
           branch: command.rest
         }, options);
-        return { handled: true, turnCompleted };
+        return { handled: true, turnCompleted, waitForGoalContinuation: false };
       }
       case "review-commit": {
         if (command.rest.length === 0) {
@@ -29604,7 +29753,7 @@ var CodexCommands = class {
           sha: command.rest,
           title: null
         }, options);
-        return { handled: true, turnCompleted };
+        return { handled: true, turnCompleted, waitForGoalContinuation: false };
       }
       case "status": {
         await this.refreshRateLimits(sessionState);
@@ -29656,13 +29805,18 @@ var CodexCommands = class {
   }
   async runReviewCommand(sessionState, target, options) {
     options.onTurnStartPending?.();
-    return await this.runWithProcessCheck(() => this.codexAcpClient.runReview(
-      sessionState.sessionId,
-      target,
-      (turnId, threadId) => {
-        this.handleCommandTurnStarted(sessionState, options, turnId, threadId);
-      }
-    ));
+    options.onNativeCommandStarted?.();
+    try {
+      return await this.runWithProcessCheck(() => this.codexAcpClient.runReview(
+        sessionState.sessionId,
+        target,
+        (turnId, threadId) => {
+          this.handleCommandTurnStarted(sessionState, options, turnId, threadId);
+        }
+      ));
+    } finally {
+      options.onNativeCommandFinished?.();
+    }
   }
   async runGoalCommand(sessionState, rest, options) {
     const sessionId = sessionState.sessionId;
@@ -30175,14 +30329,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)) {
@@ -30216,7 +30370,7 @@ function createEventMsgUpdates(record2) {
   if (record2["type"] !== "event_msg") {
     return null;
   }
-  const payload = asRecord2(record2["payload"]);
+  const payload = asRecord3(record2["payload"]);
   if (!payload) {
     return [];
   }
@@ -30264,7 +30418,7 @@ function imageBlocks(images) {
     if (typeof image === "string") {
       return [{ type: "text", text: `[@image](${image})` }];
     }
-    const record2 = asRecord2(image);
+    const record2 = asRecord3(image);
     const path10 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
     return path10 ? [{ type: "text", text: `[@image](${path10})` }] : [];
   });
@@ -30274,7 +30428,7 @@ function contentBlocksFromResponseContent(content) {
     return [];
   }
   return content.flatMap((entry) => {
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -30303,7 +30457,7 @@ function textParts(value) {
     if (typeof entry === "string") {
       return entry.length > 0 ? [entry] : [];
     }
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -30317,6 +30471,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;
@@ -30324,7 +30479,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
     };
@@ -30332,6 +30490,7 @@ function createFunctionCallUpdate(item) {
   const update = {
     sessionUpdate: "tool_call",
     toolCallId,
+    name: toolName,
     kind: toolKindForFunctionCall(name),
     title: titleForFunctionCall(name, args),
     status: "in_progress",
@@ -30395,7 +30554,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"]),
@@ -30442,14 +30601,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 "";
   }
@@ -30921,7 +31080,7 @@ function outputText(output) {
     return "";
   }
   return output.flatMap((entry) => {
-    const record2 = asRecord2(entry);
+    const record2 = asRecord3(entry);
     if (!record2) {
       return [];
     }
@@ -30937,7 +31096,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) {
@@ -30968,7 +31127,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;
   }
@@ -31455,12 +31614,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;
@@ -31582,7 +31736,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
             ]
           }
         }
@@ -32711,7 +32866,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return { outcome: "injected" };
       }
     }
-    return { outcome: "failed" };
+    throw RequestError.invalidRequest("No active Codex turn to steer");
   }
   /**
    * Rejects a steering prompt whose content the active model cannot accept
@@ -32906,14 +33061,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) {
@@ -33021,14 +33186,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}`
       }))
     );
@@ -33307,24 +33469,19 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
     });
   }
-  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 (error48) {
-      logger.error("Agent file-change report failed unexpectedly", error48);
-      report = createUnavailableAgentFileChangeReport(request.requestId, "providerError");
+      logger.error(
+        error48 instanceof AgentFileChangeReportError ? "Agent file-change report unavailable" : "Agent file-change report failed unexpectedly",
+        error48
+      );
+      report = createUnavailableAgentFileChangeReport(
+        request.requestId,
+        error48 instanceof AgentFileChangeReportError ? error48.reason : "providerError"
+      );
     }
     try {
       const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
@@ -33624,7 +33781,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       signal: abortController.signal,
       currentTurn: null,
       hasCompletedTurn: false,
-      compactionInFlight: false,
+      nativeCommandInFlight: false,
       requestCancel: () => {
         if (abortController.signal.aborted) {
           return;
@@ -33655,6 +33812,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
     this.activePrompts.set(sessionId, activePrompt);
     return activePrompt;
   }
+  setActivePromptTurn(activePrompt, turn) {
+    activePrompt.hasCompletedTurn = false;
+    activePrompt.currentTurn = turn;
+  }
   clearPendingSteers(sessionId, activePrompt) {
     const pending = this.pendingSteers.get(sessionId);
     if (!pending) return;
@@ -33689,7 +33850,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
   }
   cancelBeforeTurnStarted(activePrompt) {
     return activePrompt.cancelSignal.then(() => {
-      if (activePrompt.currentTurn === null && !activePrompt.compactionInFlight) {
+      if (activePrompt.currentTurn === null && !activePrompt.nativeCommandInFlight) {
         return null;
       }
       return new Promise(() => {
@@ -33758,7 +33919,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
   }
   interruptLateStartedTurn(turn, activePrompt) {
-    if (activePrompt.compactionInFlight) {
+    if (activePrompt.nativeCommandInFlight) {
       this.codexAcpClient.markTurnStale(turn);
       void this.requestTurnInterrupt(turn, "Cancel");
       return;
@@ -33837,6 +33998,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 goalPromptControl = parseGoalPromptControl(params._meta);
+    const agentFileChangeWorkspace = agentFileChangeReportRequest === null ? null : captureAgentFileChangeWorkspace(sessionState.cwd, sessionState.additionalDirectories);
     let agentFileChangeReportTurnId = null;
     let agentFileChangeReportUnavailableReason = "providerError";
     let promptWasCancelled = false;
@@ -33886,7 +34048,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);
@@ -33913,7 +34076,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             goalLifecycle.observe(event);
             if (event.method === "turn/started" && event.params.threadId === params.sessionId) {
               const turn = { threadId: params.sessionId, turnId: event.params.turn.id };
-              activePrompt.currentTurn = turn;
+              this.setActivePromptTurn(activePrompt, turn);
               if (this.promptShouldStop(params.sessionId, activePrompt)) {
                 this.interruptLateStartedTurn(turn, activePrompt);
                 return;
@@ -33921,7 +34084,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
               recoverableSessionFailure = sessionState.sessionFailure;
               promptNotificationsActive = true;
             }
-            if (event.method === "turn/completed" && event.params.threadId === params.sessionId && activePrompt.currentTurn?.turnId === event.params.turn.id) {
+            if (event.method === "turn/completed" && event.params.threadId === params.sessionId && activePrompt.currentTurn?.threadId === event.params.threadId && activePrompt.currentTurn.turnId === event.params.turn.id) {
               activePrompt.currentTurn = null;
               activePrompt.hasCompletedTurn = true;
             }
@@ -33932,7 +34095,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             await promptEventHandler.handleSessionScopedNotification(event);
             return;
           }
-          const completesActiveTurn = event.method === "turn/completed" && event.params.threadId === sessionState.sessionId && event.params.turn.id === sessionState.currentTurnId;
+          const completesActiveTurn = event.method === "turn/completed" && event.params.threadId === sessionState.sessionId && activePrompt.currentTurn?.threadId === event.params.threadId && activePrompt.currentTurn.turnId === event.params.turn.id;
           await promptEventHandler.handleNotification(event);
           if (completesActiveTurn) {
             promptNotificationsActive = false;
@@ -33955,7 +34118,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         onTurnStarted: (turnId, threadId) => {
           const turn = { threadId, turnId };
           if (threadId === params.sessionId) goalLifecycle.startTurn(turnId);
-          activePrompt.currentTurn = turn;
+          this.setActivePromptTurn(activePrompt, turn);
           if (this.promptShouldStop(params.sessionId, activePrompt)) {
             this.interruptLateStartedTurn(turn, activePrompt);
             return;
@@ -33964,11 +34127,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
           pendingTurnStart?.resolve(turnId);
           onTurnStarted?.();
         },
-        onCompactionStarted: () => {
-          activePrompt.compactionInFlight = true;
+        onNativeCommandStarted: () => {
+          activePrompt.nativeCommandInFlight = true;
         },
-        onCompactionFinished: () => {
-          activePrompt.compactionInFlight = false;
+        onNativeCommandFinished: () => {
+          activePrompt.nativeCommandInFlight = false;
         },
         setConfigOption: async (configId, value) => {
           await this.applySessionConfigOption(sessionState, {
@@ -33998,7 +34161,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return cancelledPromptResponse();
       }
       if (commandResult.handled) {
-        if (commandResult.turnCompleted) {
+        if (commandResult.turnCompleted && commandResult.waitForGoalContinuation !== false) {
           await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
           const firstCommandTurn = commandResult.turnCompleted;
           const completed = await this.runWithProcessCheck(() => Promise.race([
@@ -34084,7 +34247,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
               onTurnStarted?.();
               return;
             }
-            activePrompt.currentTurn = turn;
+            this.setActivePromptTurn(activePrompt, turn);
             if (this.promptShouldStop(params.sessionId, activePrompt)) {
               this.interruptLateStartedTurn(turn, activePrompt);
               return;
@@ -34183,7 +34346,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
               (turnId) => {
                 const turn = { threadId: params.sessionId, turnId };
                 if (!goalLifecycle.startSubmittedTurn(turnId)) return;
-                activePrompt.currentTurn = turn;
+                this.setActivePromptTurn(activePrompt, turn);
                 if (this.promptShouldStop(params.sessionId, activePrompt)) {
                   this.interruptLateStartedTurn(turn, activePrompt);
                   return;
@@ -34306,13 +34469,21 @@ Check ${configPath} and project .codex directories, especially their config.toml
       } catch (error48) {
         logger.error("Failed to publish terminal subagent state during prompt cleanup", error48);
       }
-      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 });
@@ -34427,7 +34598,7 @@ ${stderr}` : "";
       return;
     }
     const activePrompt = this.activePrompts.get(params.sessionId);
-    if (activePrompt?.compactionInFlight) {
+    if (activePrompt?.nativeCommandInFlight) {
       activePrompt.requestCancel();
       if (activePrompt.currentTurn === null) return;
     }