@agentconnect.md/codex-acp 1.11.0-agentconnect.1 → 1.12.0-agentconnect.1

package/dist/index.js

@@ -22782,6 +22782,111 @@ function reversePatch(structuredPatch) {
   return reversed;
 }
 
+// src/DiffStats.ts
+var DiffStatsCalculator = class {
+  addedFile(text) {
+    return { version: 1, added: this.lineCount(text), removed: 0 };
+  }
+  deletedFile(text) {
+    return { version: 1, added: 0, removed: this.lineCount(text) };
+  }
+  update(patch) {
+    if (patch.isBinary || patch.hunks.length === 0) return null;
+    let added = 0;
+    let removed = 0;
+    let previousOldEnd = 1;
+    let previousNewEnd = 1;
+    for (const hunk of patch.hunks) {
+      const { oldStart, oldLines, newStart, newLines } = hunk;
+      if (![oldStart, oldLines, newStart, newLines].every(Number.isSafeInteger) || oldStart < previousOldEnd || newStart < previousNewEnd || oldLines < 0 || newLines < 0 || newStart - oldStart !== added - removed) return null;
+      let oldConsumed = 0;
+      let newConsumed = 0;
+      let previousWasContent = false;
+      for (const line of hunk.lines) {
+        switch (line[0]) {
+          case "+":
+            added++;
+            newConsumed++;
+            previousWasContent = true;
+            break;
+          case "-":
+            removed++;
+            oldConsumed++;
+            previousWasContent = true;
+            break;
+          case " ":
+          case void 0:
+            oldConsumed++;
+            newConsumed++;
+            previousWasContent = true;
+            break;
+          case "\\":
+            if (!previousWasContent || line.replace(/\r$/, "") !== "\") return null;
+            previousWasContent = false;
+            break;
+          default:
+            return null;
+        }
+      }
+      if (oldConsumed !== oldLines || newConsumed !== newLines) return null;
+      previousOldEnd = oldStart + oldLines;
+      previousNewEnd = newStart + newLines;
+    }
+    return { version: 1, added, removed };
+  }
+  lineCount(text) {
+    let count = 0;
+    for (let offset = text.indexOf("\n"); offset >= 0; offset = text.indexOf("\n", offset + 1)) count++;
+    for (let offset = text.indexOf("\r"); offset >= 0; offset = text.indexOf("\r", offset + 1)) {
+      if (text[offset + 1] !== "\n") count++;
+    }
+    if (text.length > 0 && !text.endsWith("\n") && !text.endsWith("\r")) count++;
+    return count;
+  }
+};
+
+// src/AirExtension.ts
+var JETBRAINS_META_KEY = "jetbrains";
+var AIR_META_KEY = "air";
+var AIR_EXTENSION_VERSION_KEY = "version";
+var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
+var AIR_DIFF_STATS_KEY = "diffStats";
+var AIR_SESSION_FAILURE_KEY = "sessionFailure";
+var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
+var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
+var AIR_ASYNC_TASKS_KEY = "asyncTasks";
+var AIR_RECOMMENDED_CONFIG_VALUE_KEY = "recommendedValue";
+var AIR_ASYNC_TASKS_BACKGROUNDED_KEY = "backgrounded";
+var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
+var AIR_EXTENSION_VERSION = 1;
+function withAirMeta(meta3, key, value) {
+  const root = asRecord(meta3);
+  const jetbrains = asRecord(root[JETBRAINS_META_KEY]);
+  const air = asRecord(jetbrains[AIR_META_KEY]);
+  return {
+    ...root,
+    [JETBRAINS_META_KEY]: {
+      ...jetbrains,
+      [AIR_META_KEY]: {
+        ...air,
+        [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+        [key]: value
+      }
+    }
+  };
+}
+function clientSupportsAirCapability(capabilities, capability) {
+  const meta3 = asRecord(capabilities?._meta);
+  const jetbrains = asRecord(meta3[JETBRAINS_META_KEY]);
+  const air = asRecord(jetbrains[AIR_META_KEY]);
+  const version2 = air[AIR_EXTENSION_VERSION_KEY];
+  const supported = air[AIR_EXTENSION_CAPABILITIES_KEY];
+  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
 // src/CodexToolCallMapper.ts
 import { readFile } from "node:fs/promises";
 import path2 from "node:path";
@@ -22834,8 +22939,26 @@ function createContextCompactionMeta(metadata = {}) {
   };
 }
 
+// src/ToolCallName.ts
+function functionToolName(name, namespace) {
+  return `${namespace ?? ""}${name}`;
+}
+function commandToolName(source) {
+  switch (source) {
+    case "unifiedExecStartup":
+      return "exec_command";
+    case "unifiedExecInteraction":
+      return "write_stdin";
+    // These sources do not identify a unique model tool.
+    case "agent":
+    case "userShell":
+      return void 0;
+  }
+}
+
 // src/CodexToolCallMapper.ts
 var CONTEXT_COMPACTION_META = createContextCompactionMeta();
+var DIFF_STATS = new DiffStatsCalculator();
 function toAcpStatus(status) {
   switch (status) {
     case "inProgress":
@@ -22864,14 +22987,19 @@ async function createFileChangeUpdate(item) {
   };
 }
 async function createCommandExecutionUpdate(item) {
+  const name = commandToolName(item.source);
   const commandAction = item.commandActions.length === 1 ? item.commandActions[0] : void 0;
   if (commandAction) {
-    return createCommandActionEvent(item.id, item.status, item.cwd, commandAction);
+    return {
+      ...createCommandActionEvent(item.id, item.status, item.cwd, commandAction),
+      ...name === void 0 ? {} : { name }
+    };
   }
   const command = stripShellPrefix(item.command);
   return createTerminalCommandEvent({
     sessionUpdate: "tool_call",
     toolCallId: item.id,
+    ...name === void 0 ? {} : { name },
     kind: "execute",
     title: command,
     status: toAcpStatus(item.status),
@@ -22926,7 +23054,10 @@ async function createMcpToolCallUpdate(item) {
   };
 }
 async function createDynamicToolCallUpdate(item) {
-  return createExecuteToolCallUpdate(item, item.tool, { arguments: item.arguments });
+  return {
+    ...await createExecuteToolCallUpdate(item, item.tool, { arguments: item.arguments }),
+    name: functionToolName(item.tool, item.namespace)
+  };
 }
 function createImageViewUpdate(item) {
   const displayPath = item.path;
@@ -22934,6 +23065,7 @@ function createImageViewUpdate(item) {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
     kind: "read",
+    name: "view_image",
     title: `View Image ${displayPath}`,
     status: "completed",
     content: [createContent({
@@ -23491,53 +23623,43 @@ async function createAddFileContent(change) {
     newText: change.diff,
     // app-server always returns file content instead of diff
     path: change.path,
-    _meta: {
-      kind: "add"
-    }
+    _meta: withAirMeta({ kind: "add" }, AIR_DIFF_STATS_KEY, DIFF_STATS.addedFile(change.diff))
   };
 }
 async function createUpdateFileContent(change) {
   if (change.kind.type !== "update") return null;
   const unifiedDiff = recoverCorruptedDiff(change.diff);
+  const patches = parsePatch(unifiedDiff);
+  if (patches.length !== 1) return null;
+  const patch = patches[0];
   const movePath = change.kind.move_path;
   const oldContent = await readFileContent(change.path);
   if (oldContent !== null) {
-    const patchedContent = applyPatch(oldContent, unifiedDiff);
+    const patchedContent = applyPatch(oldContent, patch);
     if (patchedContent === false) {
-      const revertedPatch2 = revertPatch(unifiedDiff);
-      if (revertedPatch2) {
-        const revertedContent2 = applyPatch(oldContent, revertedPatch2);
-        if (revertedContent2 !== false) {
-          return createUpdateDiffContent(change.path, revertedContent2, oldContent);
-        }
+      const revertedContent2 = applyPatch(oldContent, reversePatch(patch));
+      if (revertedContent2 !== false) {
+        return createUpdateDiffContent(change.path, revertedContent2, oldContent, patch);
       }
       return null;
     }
-    return createUpdateDiffContent(movePath ?? change.path, oldContent, patchedContent);
+    return createUpdateDiffContent(movePath ?? change.path, oldContent, patchedContent, patch);
   }
   if (!movePath) return null;
   const newContent = await readFileContent(movePath);
   if (newContent === null) return null;
-  const revertedPatch = revertPatch(unifiedDiff);
-  if (!revertedPatch) return null;
-  const revertedContent = applyPatch(newContent, revertedPatch);
+  const revertedContent = applyPatch(newContent, reversePatch(patch));
   if (revertedContent === false) return null;
-  return createUpdateDiffContent(movePath, revertedContent, newContent);
-}
-function revertPatch(unifiedDiff) {
-  const [patch] = parsePatch(unifiedDiff);
-  if (!patch) return null;
-  return reversePatch(patch);
+  return createUpdateDiffContent(movePath, revertedContent, newContent, patch);
 }
-function createUpdateDiffContent(path9, oldText, newText) {
+function createUpdateDiffContent(path9, oldText, newText, patch) {
+  const stats = DIFF_STATS.update(patch);
   return {
     type: "diff",
     oldText,
     newText,
     path: path9,
-    _meta: {
-      kind: "update"
-    }
+    _meta: stats ? withAirMeta({ kind: "update" }, AIR_DIFF_STATS_KEY, stats) : { kind: "update" }
   };
 }
 async function createDeleteFileContent(change) {
@@ -23547,9 +23669,7 @@ async function createDeleteFileContent(change) {
     // app-server always returns file content instead of diff
     newText: "",
     path: change.path,
-    _meta: {
-      kind: "delete"
-    }
+    _meta: withAirMeta({ kind: "delete" }, AIR_DIFF_STATS_KEY, DIFF_STATS.deletedFile(change.diff))
   };
 }
 async function readFileContent(filePath) {
@@ -23661,47 +23781,6 @@ function sameThreadGoalSnapshot(left, right) {
 // src/CodexEventHandler.ts
 import { randomUUID } from "node:crypto";
 
-// src/AirExtension.ts
-var JETBRAINS_META_KEY = "jetbrains";
-var AIR_META_KEY = "air";
-var AIR_EXTENSION_VERSION_KEY = "version";
-var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
-var AIR_SESSION_FAILURE_KEY = "sessionFailure";
-var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
-var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
-var AIR_ASYNC_TASKS_KEY = "asyncTasks";
-var AIR_RECOMMENDED_CONFIG_VALUE_KEY = "recommendedValue";
-var AIR_ASYNC_TASKS_BACKGROUNDED_KEY = "backgrounded";
-var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
-var AIR_EXTENSION_VERSION = 1;
-function withAirMeta(meta3, key, value) {
-  const root = asRecord(meta3);
-  const jetbrains = asRecord(root[JETBRAINS_META_KEY]);
-  const air = asRecord(jetbrains[AIR_META_KEY]);
-  return {
-    ...root,
-    [JETBRAINS_META_KEY]: {
-      ...jetbrains,
-      [AIR_META_KEY]: {
-        ...air,
-        [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
-        [key]: value
-      }
-    }
-  };
-}
-function clientSupportsAirCapability(capabilities, capability) {
-  const meta3 = asRecord(capabilities?._meta);
-  const jetbrains = asRecord(meta3[JETBRAINS_META_KEY]);
-  const air = asRecord(jetbrains[AIR_META_KEY]);
-  const version2 = air[AIR_EXTENSION_VERSION_KEY];
-  const supported = air[AIR_EXTENSION_CAPABILITIES_KEY];
-  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
-}
-function asRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-
 // src/subagents/CodexAgentPath.ts
 function normalizeAgentPath(path9) {
   const normalized = path9.trim().replace(/\/+$/, "");
@@ -24095,40 +24174,339 @@ function terminalStateFromTurn(status) {
       return void 0;
   }
 }
-function fallbackName(sessionId) {
-  const suffix = sessionId.length > 8 ? sessionId.slice(-8) : sessionId;
-  return `Agent ${suffix}`;
+function fallbackName(sessionId) {
+  const suffix = sessionId.length > 8 ? sessionId.slice(-8) : sessionId;
+  return `Agent ${suffix}`;
+}
+
+// src/RateLimitsMap.ts
+function rateLimitId(snapshot, fallback = "codex") {
+  return snapshot.limitId ?? fallback;
+}
+function createRateLimitsMap(response) {
+  const result = /* @__PURE__ */ new Map();
+  const snapshots = Object.entries(response.rateLimitsByLimitId ?? {}).filter((entry) => entry[1] !== void 0);
+  if (snapshots.length === 0) {
+    snapshots.push([rateLimitId(response.rateLimits), response.rateLimits]);
+  }
+  for (const [fallbackId, snapshot] of snapshots) {
+    const limitId = rateLimitId(snapshot, fallbackId);
+    result.set(limitId, {
+      limitId,
+      limitName: snapshot.limitName ?? limitId,
+      snapshot
+    });
+  }
+  return result;
+}
+function mergeRateLimitSnapshot(previous, update) {
+  return {
+    ...update,
+    limitId: update.limitId ?? "codex",
+    credits: update.credits ?? previous.credits,
+    individualLimit: update.individualLimit ?? previous.individualLimit,
+    spendControlReached: update.spendControlReached ?? previous.spendControlReached,
+    planType: update.planType ?? previous.planType
+  };
+}
+
+// src/AgentFileChangeReport.ts
+import fs2 from "node:fs";
+import path3 from "node:path";
+var AGENT_FILE_CHANGE_REPORT_VERSION = 1;
+var AGENT_FILE_CHANGE_REPORT_MAX_PATHS = 1024;
+var AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH = 4096;
+var AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES = 256 * 1024;
+var AGENT_FILE_CHANGE_REPORT_MAX_DIFF_BYTES = 8 * 1024 * 1024;
+var TURN_DIFF_UNCERTAINTY = "Codex turn diffs may omit same-content renames and changes made outside apply_patch, including shell commands, version-control commands, generators, and child processes.";
+function captureAgentFileChangeWorkspace(cwd, additionalDirectories) {
+  const lexicalCwd = parseWorkspaceRoot(cwd);
+  return {
+    cwd,
+    additionalDirectories: [...additionalDirectories],
+    diffRoot: lexicalCwd === null ? cwd : findDiffDisplayRoot(lexicalCwd).value
+  };
+}
+function parseAgentFileChangeReportRequest(meta3) {
+  const jetbrains = asRecord2(meta3?.[JETBRAINS_META_KEY]);
+  const air = asRecord2(jetbrains?.[AIR_META_KEY]);
+  const request = asRecord2(air?.[AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY]);
+  if (request === null || !hasOnlyKeys(request, ["version", "requestId"]) || request["version"] !== AGENT_FILE_CHANGE_REPORT_VERSION) {
+    return null;
+  }
+  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 (error51) {
+    throw new AgentFileChangeReportError(
+      "invalidOutput",
+      `The turn diff is not valid unified diff: ${error51 instanceof Error ? error51.message : String(error51)}`
+    );
+  }
+  if (patches.length === 0) {
+    throw new AgentFileChangeReportError("invalidOutput", "The turn diff contains no parseable file patches");
+  }
+  const rawFileHeaders = extractRawFileHeaders(diff);
+  const paths = [];
+  for (const [index, patch] of patches.entries()) {
+    const rawHeaders = rawFileHeaders[index];
+    const oldPath = normalizeDiffPath(selectLosslessFileName(rawHeaders?.oldFileName, patch.oldFileName));
+    const newPath = normalizeDiffPath(selectLosslessFileName(rawHeaders?.newFileName, patch.newFileName));
+    if (oldPath === null && newPath === null) {
+      throw new AgentFileChangeReportError("invalidOutput", "The turn diff contains a patch without a file path");
+    }
+    if (oldPath !== null) paths.push(oldPath);
+    if (newPath !== null) paths.push(newPath);
+  }
+  return { paths, complete: false, uncertainty: TURN_DIFF_UNCERTAINTY };
+}
+function extractRawFileHeaders(diff) {
+  return diff.split(/(?=^diff --git )/m).filter((section) => section.trim() !== "").map((section) => {
+    const lines = section.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index];
+      if (line?.startsWith("@@ ")) return null;
+      const nextLine = lines[index + 1];
+      if (line?.startsWith("--- ") && nextLine?.startsWith("+++ ")) {
+        return {
+          oldFileName: line.slice(4),
+          newFileName: nextLine.slice(4)
+        };
+      }
+    }
+    return null;
+  });
+}
+function selectLosslessFileName(rawFileName, parsedFileName) {
+  return rawFileName === void 0 || rawFileName.startsWith('"') ? parsedFileName : rawFileName;
+}
+function normalizeDiffPath(value) {
+  if (value === void 0 || value === "/dev/null") return null;
+  return value.startsWith("a/") || value.startsWith("b/") ? value.slice(2) : value;
+}
+function fitReportedAgentFileChangeReport(report) {
+  const paths = [...report.paths];
+  let truncated = report.truncated;
+  let fitted = report;
+  while (Buffer.byteLength(JSON.stringify(fitted), "utf8") > AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES) {
+    if (paths.length === 0) {
+      throw new AgentFileChangeReportError("invalidOutput", "The audit report exceeds the wire limit");
+    }
+    paths.pop();
+    truncated = true;
+    fitted = {
+      ...report,
+      paths: [...paths],
+      declaredComplete: false,
+      truncated
+    };
+  }
+  return fitted;
+}
+function normalizeFileChangeReport(report, workspace) {
+  const lexicalCwd = parseWorkspaceRoot(workspace.cwd);
+  if (lexicalCwd === null) {
+    throw new AgentFileChangeReportError("providerError", "The session working directory is not absolute");
+  }
+  const cwd = canonicalizeWorkspaceRoot(lexicalCwd);
+  const diffRoot = parseWorkspaceRoot(workspace.diffRoot);
+  if (diffRoot === null || diffRoot.flavor !== cwd.flavor) {
+    throw new AgentFileChangeReportError("providerError", "The captured turn-diff root is invalid");
+  }
+  const roots = [cwd, ...workspace.additionalDirectories.flatMap((directory) => {
+    const root = normalizeWorkspaceRoot(directory);
+    return root === null || root.flavor !== cwd.flavor ? [] : [root];
+  })];
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  let totalBytes = 0;
+  let truncated = false;
+  for (const reportedPath of report.paths) {
+    if (reportedPath.length > AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH) {
+      truncated = true;
+      continue;
+    }
+    const normalized = normalizeReportedPath(reportedPath, diffRoot, roots);
+    if (normalized === null || normalized.value.length > AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH) {
+      truncated = true;
+      continue;
+    }
+    const key = normalized.flavor === "windows" ? normalized.value.toLowerCase() : normalized.value;
+    if (seen.has(key)) {
+      continue;
+    }
+    const bytes = Buffer.byteLength(normalized.value, "utf8");
+    if (paths.length >= AGENT_FILE_CHANGE_REPORT_MAX_PATHS || totalBytes + bytes > AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES) {
+      truncated = true;
+      continue;
+    }
+    seen.add(key);
+    paths.push(normalized.value);
+    totalBytes += bytes;
+  }
+  return {
+    paths,
+    declaredComplete: report.complete && !truncated,
+    truncated,
+    ...report.uncertainty ? { uncertainty: report.uncertainty } : {}
+  };
+}
+function normalizeWorkspaceRoot(value) {
+  const root = parseWorkspaceRoot(value);
+  return root === null ? null : canonicalizeWorkspaceRoot(root);
+}
+function parseWorkspaceRoot(value) {
+  const trimmed = value.trim();
+  if (!isValidPathText(trimmed)) {
+    return null;
+  }
+  if (isWindowsAbsolutePath(trimmed)) {
+    return {
+      value: path3.win32.normalize(trimmed.replace(/\//g, "\\")),
+      flavor: "windows"
+    };
+  }
+  if (path3.posix.isAbsolute(trimmed)) {
+    return {
+      value: path3.posix.normalize(trimmed.replace(/\\/g, "/")),
+      flavor: "posix"
+    };
+  }
+  return null;
+}
+function normalizeReportedPath(value, relativeRoot, roots) {
+  if (!isValidPathText(value) || /^[A-Za-z]:[^\\/]/.test(value) || /^\\\\[?.]\\/.test(value) || /^(?:\\\\|\/\/)/.test(value) && !isWindowsAbsolutePath(value) || relativeRoot.flavor === "windows" && /^\\(?!\\)/.test(value) || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value)) {
+    return null;
+  }
+  let candidate;
+  if (isWindowsAbsolutePath(value)) {
+    candidate = { value: path3.win32.normalize(value.replace(/\//g, "\\")), flavor: "windows" };
+  } else if (path3.posix.isAbsolute(value)) {
+    candidate = { value: path3.posix.normalize(value.replace(/\\/g, "/")), flavor: "posix" };
+  } else if (relativeRoot.flavor === "windows") {
+    candidate = {
+      value: path3.win32.resolve(relativeRoot.value, value.replace(/\//g, "\\")),
+      flavor: "windows"
+    };
+  } else {
+    candidate = {
+      value: path3.posix.resolve(relativeRoot.value, value.replace(/\\/g, "/")),
+      flavor: "posix"
+    };
+  }
+  candidate = canonicalizeReportedPath(candidate);
+  return roots.some((root) => pathIsStrictlyInside(root, candidate)) ? candidate : null;
+}
+function findDiffDisplayRoot(cwd) {
+  if (!isNativePathFlavor(cwd.flavor)) return cwd;
+  const pathImplementation = cwd.flavor === "windows" ? path3.win32 : path3.posix;
+  let current = cwd.value;
+  while (true) {
+    if (fs2.existsSync(pathImplementation.join(current, ".git"))) {
+      return canonicalizeWorkspaceRoot({ value: current, flavor: cwd.flavor });
+    }
+    const parent = pathImplementation.dirname(current);
+    if (parent === current) return cwd;
+    current = parent;
+  }
+}
+function canonicalizeWorkspaceRoot(root) {
+  if (!isNativePathFlavor(root.flavor)) {
+    return root;
+  }
+  return { ...root, value: canonicalizeFromExistingAncestor(root.value) };
+}
+function canonicalizeReportedPath(candidate) {
+  if (!isNativePathFlavor(candidate.flavor)) {
+    return candidate;
+  }
+  const parent = canonicalizeFromExistingAncestor(path3.dirname(candidate.value));
+  return { ...candidate, value: path3.resolve(parent, path3.basename(candidate.value)) };
+}
+function canonicalizeFromExistingAncestor(value) {
+  const original = path3.resolve(value);
+  let current = original;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const canonical = fs2.realpathSync.native(current);
+      return path3.resolve(canonical, ...missingSegments.reverse());
+    } catch (error51) {
+      if (!isMissingPathError(error51)) return original;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) return original;
+    missingSegments.push(path3.basename(current));
+    current = parent;
+  }
+}
+function isMissingPathError(error51) {
+  if (typeof error51 !== "object" || error51 === null || !("code" in error51)) return false;
+  return error51.code === "ENOENT" || error51.code === "ENOTDIR";
 }
-
-// src/RateLimitsMap.ts
-function rateLimitId(snapshot, fallback = "codex") {
-  return snapshot.limitId ?? fallback;
+function isNativePathFlavor(flavor) {
+  return process.platform === "win32" ? flavor === "windows" : flavor === "posix";
 }
-function createRateLimitsMap(response) {
-  const result = /* @__PURE__ */ new Map();
-  const snapshots = Object.entries(response.rateLimitsByLimitId ?? {}).filter((entry) => entry[1] !== void 0);
-  if (snapshots.length === 0) {
-    snapshots.push([rateLimitId(response.rateLimits), response.rateLimits]);
-  }
-  for (const [fallbackId, snapshot] of snapshots) {
-    const limitId = rateLimitId(snapshot, fallbackId);
-    result.set(limitId, {
-      limitId,
-      limitName: snapshot.limitName ?? limitId,
-      snapshot
-    });
+function pathIsStrictlyInside(root, candidate) {
+  if (root.flavor !== candidate.flavor) {
+    return false;
   }
-  return result;
+  const pathImplementation = root.flavor === "windows" ? path3.win32 : path3.posix;
+  const relative = pathImplementation.relative(root.value, candidate.value);
+  return relative.length > 0 && !pathImplementation.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${pathImplementation.sep}`);
 }
-function mergeRateLimitSnapshot(previous, update) {
-  return {
-    ...update,
-    limitId: update.limitId ?? "codex",
-    credits: update.credits ?? previous.credits,
-    individualLimit: update.individualLimit ?? previous.individualLimit,
-    spendControlReached: update.spendControlReached ?? previous.spendControlReached,
-    planType: update.planType ?? previous.planType
-  };
+function isWindowsAbsolutePath(value) {
+  const portable = value.replace(/\\/g, "/");
+  return /^[A-Za-z]:\//.test(portable) || /^\/\/[^/]+\/[^/]+(?:\/|$)/.test(portable);
+}
+function isValidPathText(value) {
+  return value.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
+}
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function hasOnlyKeys(value, allowed) {
+  const allowedKeys = new Set(allowed);
+  return Object.keys(value).every((key) => allowedKeys.has(key));
 }
 
 // src/CodexEventHandler.ts
@@ -24238,6 +24616,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;
@@ -24245,7 +24626,7 @@ var CodexEventHandler = class _CodexEventHandler {
     sessionState.sessionId,
     false,
     new ACPSessionConnection(connection, sessionState.sessionId)
-  ), onAccountUpdated) {
+  ), onAccountUpdated, collectTurnDiffs = false) {
     this.onAccountUpdated = onAccountUpdated;
     this.sessionState = sessionState;
     this.supportsPlanUpdates = supportsPlanUpdates;
@@ -24253,6 +24634,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);
     }
@@ -24260,6 +24642,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)) {
@@ -24419,6 +24807,8 @@ var CodexEventHandler = class _CodexEventHandler {
     this.pendingPlanItemIds.clear();
     this.planDeltaTextByItemId.clear();
     this.lastEmittedPlanTextByItemId.clear();
+    this.turnDiffs.clear();
+    this.oversizedTurnDiffs.clear();
   }
   async createUpdateEvent(notification) {
     switch (notification.method) {
@@ -24437,6 +24827,20 @@ var CodexEventHandler = class _CodexEventHandler {
       case "turn/plan/updated":
         this.completeRetryIncidentOnTurnProgress();
         return await this.updatePlan(notification.params);
+      case "turn/diff/updated":
+        if (notification.params.threadId === this.sessionState.sessionId) {
+          this.completeRetryIncidentOnTurnProgress();
+          if (!this.disposed && this.collectTurnDiffs) {
+            if (Buffer.byteLength(notification.params.diff, "utf8") > AGENT_FILE_CHANGE_REPORT_MAX_DIFF_BYTES) {
+              this.turnDiffs.delete(notification.params.turnId);
+              this.oversizedTurnDiffs.add(notification.params.turnId);
+            } else {
+              this.oversizedTurnDiffs.delete(notification.params.turnId);
+              this.turnDiffs.set(notification.params.turnId, notification.params.diff);
+            }
+          }
+        }
+        return null;
       case "error":
         return await this.createErrorEvent(notification.params);
       case "turn/started":
@@ -24531,7 +24935,6 @@ var CodexEventHandler = class _CodexEventHandler {
       case "command/exec/outputDelta":
       case "hook/started":
       case "hook/completed":
-      case "turn/diff/updated":
       case "turn/moderationMetadata":
       case "item/fileChange/outputDelta":
       case "item/fileChange/patchUpdated":
@@ -24715,10 +25118,16 @@ ${event.details}` : event.summary;
   async completeItemEvent(event) {
     switch (event.item.type) {
       case "fileChange":
+        return {
+          sessionUpdate: "tool_call_update",
+          toolCallId: event.item.id,
+          status: event.item.status === "completed" ? "completed" : "failed"
+        };
       case "dynamicToolCall":
         return {
           sessionUpdate: "tool_call_update",
           toolCallId: event.item.id,
+          name: functionToolName(event.item.tool, event.item.namespace),
           status: event.item.status === "completed" ? "completed" : "failed"
         };
       case "mcpToolCall":
@@ -24930,9 +25339,11 @@ ${event.stdin}
     return `mcp_startup.${encodeURIComponent(serverName)}`;
   }
   completeCommandExecutionEvent(item) {
+    const name = commandToolName(item.source);
     const update = {
       sessionUpdate: "tool_call_update",
       toolCallId: item.id,
+      ...name === void 0 ? {} : { name },
       status: item.status === "completed" ? "completed" : "failed",
       rawOutput: {
         formatted_output: item.aggregatedOutput ?? "",
@@ -25548,7 +25959,8 @@ function nonBlank(value) {
 }
 
 // src/permissions/presentation.ts
-function commandToolCall(params) {
+function commandToolCall(params, permissionContext) {
+  const name = permissionContext.commandName(params.threadId, params.itemId);
   const network = params.networkApprovalContext;
   const rawInput = {
     ...params.command ? { command: stripShellPrefix(params.command) } : {},
@@ -25559,6 +25971,7 @@ function commandToolCall(params) {
   const additionalPermissionContent = params.additionalPermissions ? permissionProfileContent(params.additionalPermissions) : [];
   return {
     toolCallId: params.itemId,
+    ...name !== void 0 ? { name } : {},
     kind: "execute",
     status: "pending",
     title: network ? `${network.protocol} network access to ${network.host}` : commandTitle(params.commandActions),
@@ -25584,6 +25997,7 @@ function additionalPermissionsToolCall(itemId, cwd, environmentId, permissions)
   const content = permissionProfileContent(permissions);
   return {
     toolCallId: itemId,
+    name: "request_permissions",
     kind: "other",
     status: "pending",
     title: "Additional sandbox permissions",
@@ -25682,7 +26096,7 @@ var CodexApprovalHandler = class {
     try {
       const response = await this.requestPermission({
         sessionId: params.threadId,
-        toolCall: commandToolCall(authoritativeParams),
+        toolCall: commandToolCall(authoritativeParams, this.permissionContext),
         options: decisions.map(({ option }) => option),
         _meta: requestPermissionMeta(
           params.networkApprovalContext ? CODEX_NETWORK_PERMISSION_TITLE : CODEX_COMMAND_PERMISSION_TITLE,
@@ -25790,6 +26204,7 @@ var PermissionPromptContext = class {
     this.nextStandaloneId = nextStandaloneId;
   }
   nextStandaloneId;
+  commandNames = /* @__PURE__ */ new Map();
   fileChanges = /* @__PURE__ */ new Map();
   pendingMcpApprovals = /* @__PURE__ */ new Map();
   handleNotification(notification) {
@@ -25813,6 +26228,9 @@ var PermissionPromptContext = class {
   fileChange(threadId, itemId) {
     return this.fileChanges.get(threadId)?.get(itemId);
   }
+  commandName(threadId, itemId) {
+    return this.commandNames.get(threadId)?.get(itemId);
+  }
   popPendingMcpApproval(threadId, serverName) {
     const byServer = this.pendingMcpApprovals.get(threadId);
     if (!byServer) return void 0;
@@ -25827,6 +26245,15 @@ var PermissionPromptContext = class {
     return this.nextStandaloneId(serverName);
   }
   handleItemStarted(threadId, item) {
+    if (item.type === "commandExecution") {
+      const name = commandToolName(item.source);
+      if (name !== void 0) {
+        const byItem = this.commandNames.get(threadId) ?? /* @__PURE__ */ new Map();
+        byItem.set(item.id, name);
+        this.commandNames.set(threadId, byItem);
+      }
+      return;
+    }
     if (item.type === "fileChange") {
       const byItem = this.fileChanges.get(threadId) ?? /* @__PURE__ */ new Map();
       byItem.set(item.id, item);
@@ -25841,6 +26268,12 @@ var PermissionPromptContext = class {
     this.pendingMcpApprovals.set(threadId, byServer);
   }
   handleItemCompleted(threadId, item) {
+    if (item.type === "commandExecution") {
+      const byItem = this.commandNames.get(threadId);
+      byItem?.delete(item.id);
+      if (byItem?.size === 0) this.commandNames.delete(threadId);
+      return;
+    }
     if (item.type === "fileChange") {
       const byItem = this.fileChanges.get(threadId);
       byItem?.delete(item.id);
@@ -25858,6 +26291,7 @@ var PermissionPromptContext = class {
     if (byServer.size === 0) this.pendingMcpApprovals.delete(threadId);
   }
   clearTransientState(threadId) {
+    this.commandNames.delete(threadId);
     this.fileChanges.delete(threadId);
     this.pendingMcpApprovals.delete(threadId);
   }
@@ -26046,7 +26480,9 @@ function cancelledResponse() {
 }
 
 // src/CodexElicitationHandler.ts
-var USER_INPUT_OTHER_FIELD_SUFFIX = "__other";
+var USER_INPUT_NOTE_FIELD_SUFFIX = "_note";
+var USER_INPUT_OTHER_OPTION = "None of the above";
+var USER_INPUT_NOTE_PREFIX = "user_note: ";
 function normalizeElicitationSchema(value) {
   const normalized = normalizeElicitationSchemaValue(value);
   if (!isRecord2(normalized)) {
@@ -26103,16 +26539,14 @@ function elicitationResponseMeta(response, context, persist = void 0) {
   }
   return Object.keys(meta3).length === 0 ? null : meta3;
 }
-function userInputOtherFieldId(questionId, questionIds) {
-  const base = `${questionId}${USER_INPUT_OTHER_FIELD_SUFFIX}`;
-  if (!questionIds.has(base)) {
-    return base;
-  }
+function userInputNoteFieldId(questionId, questionIds) {
+  const base = `${questionId}${USER_INPUT_NOTE_FIELD_SUFFIX}`;
+  let fieldId = base;
   let index = 1;
-  while (questionIds.has(`${base}${index}`)) {
-    index += 1;
+  while (questionIds.has(fieldId)) {
+    fieldId = `${base}${index++}`;
   }
-  return `${base}${index}`;
+  return fieldId;
 }
 function userInputResponseValue(content, fieldId) {
   const value = content[fieldId];
@@ -26349,8 +26783,8 @@ var CodexElicitationHandler = class {
       const hasOptions = options.length > 0;
       const hasOtherAnswer = question.isOther && hasOptions;
       const base = {
-        title: question.header || question.id,
-        description: question.question,
+        title: question.question || question.header || question.id,
+        ...question.header ? { description: question.header } : {},
         _meta: {
           codex: {
             isOther: question.isOther,
@@ -26358,42 +26792,45 @@ var CodexElicitationHandler = class {
           }
         }
       };
-      if (!hasOtherAnswer) {
-        required2.push(question.id);
-      }
+      required2.push(question.id);
       properties[question.id] = hasOptions ? {
         ...base,
         type: "string",
-        oneOf: options.map((option) => ({
-          const: option.label,
-          title: option.label,
-          description: option.description
-        }))
+        oneOf: [
+          ...options.map((option) => ({
+            const: option.label,
+            title: option.label,
+            ...option.description ? { description: option.description } : {}
+          })),
+          ...hasOtherAnswer && !options.some((option) => option.label === USER_INPUT_OTHER_OPTION) ? [{
+            const: USER_INPUT_OTHER_OPTION,
+            title: USER_INPUT_OTHER_OPTION,
+            description: "Provide a different answer in the note field."
+          }] : []
+        ]
       } : {
         ...base,
         type: "string"
       };
       if (hasOtherAnswer) {
-        properties[userInputOtherFieldId(question.id, questionIds)] = {
+        properties[userInputNoteFieldId(question.id, questionIds)] = {
           type: "string",
-          title: "Other",
-          description: "Type your own answer instead of choosing an option above.",
+          title: "Additional answer or note",
           _meta: {
             codex: {
               questionId: question.id,
-              isOtherAnswer: true,
+              role: "user_note",
               isSecret: question.isSecret
             }
           }
         };
       }
     }
-    const firstQuestion = params.questions[0];
     return {
       sessionId: params.threadId,
       toolCallId: params.itemId,
       mode: "form",
-      message: params.questions.length === 1 && firstQuestion ? firstQuestion.question : "Input requested",
+      message: "Codex needs your input to continue.",
       requestedSchema: {
         type: "object",
         properties,
@@ -26444,12 +26881,23 @@ var CodexElicitationHandler = class {
     const content = contentRecord(response.content);
     const questionIds = new Set(params.questions.map((question) => question.id));
     for (const question of params.questions) {
-      const value = question.isOther && question.options != null && question.options.length > 0 ? userInputResponseValue(content, userInputOtherFieldId(question.id, questionIds)) ?? userInputResponseValue(content, question.id) : userInputResponseValue(content, question.id);
-      if (value === void 0) {
+      const answerValues = [];
+      const value = userInputResponseValue(content, question.id);
+      if (value !== void 0) {
+        answerValues.push(...Array.isArray(value) ? value.map(String) : [String(value)]);
+      }
+      if (question.isOther && question.options != null && question.options.length > 0) {
+        const note = userInputResponseValue(content, userInputNoteFieldId(question.id, questionIds));
+        if (note !== void 0) {
+          const notes = Array.isArray(note) ? note : [note];
+          answerValues.push(...notes.map((item) => `${USER_INPUT_NOTE_PREFIX}${String(item).trim()}`));
+        }
+      }
+      if (answerValues.length === 0) {
         continue;
       }
       answers[question.id] = {
-        answers: Array.isArray(value) ? value.map(String) : [String(value)]
+        answers: answerValues
       };
     }
     return { answers };
@@ -26539,31 +26987,31 @@ function isCodexAuthRequest(request) {
 
 // node_modules/open/index.js
 import process11 from "node:process";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import childProcess4 from "node:child_process";
-import fs6, { constants as fsConstants2 } from "node:fs/promises";
+import fs7, { constants as fsConstants2 } from "node:fs/promises";
 
 // node_modules/wsl-utils/index.js
-import path3 from "node:path";
+import path4 from "node:path";
 import { promisify as promisify2 } from "node:util";
 import childProcess2 from "node:child_process";
-import fs5, { constants as fsConstants } from "node:fs/promises";
+import fs6, { constants as fsConstants } from "node:fs/promises";
 
 // node_modules/is-wsl/index.js
 import process3 from "node:process";
 import os from "node:os";
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 
 // node_modules/is-inside-container/index.js
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 
 // node_modules/is-docker/index.js
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    fs2.statSync("/.dockerenv");
+    fs3.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -26571,7 +27019,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
   try {
-    return fs2.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs3.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -26587,7 +27035,7 @@ function isDocker() {
 var cachedResult;
 var hasContainerEnv = () => {
   try {
-    fs3.statSync("/run/.containerenv");
+    fs4.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -26612,12 +27060,12 @@ var isWsl = () => {
     return true;
   }
   try {
-    if (fs4.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+    if (fs5.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
       return !isInsideContainer();
     }
   } catch {
   }
-  if (fs4.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs4.existsSync("/run/WSL")) {
+  if (fs5.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs5.existsSync("/run/WSL")) {
     return !isInsideContainer();
   }
   return false;
@@ -26685,14 +27133,14 @@ var wslDrivesMountPoint = /* @__PURE__ */ (() => {
     const configFilePath = "/etc/wsl.conf";
     let isConfigFileExists = false;
     try {
-      await fs5.access(configFilePath, fsConstants.F_OK);
+      await fs6.access(configFilePath, fsConstants.F_OK);
       isConfigFileExists = true;
     } catch {
     }
     if (!isConfigFileExists) {
       return defaultMountPoint;
     }
-    const configContent = await fs5.readFile(configFilePath, { encoding: "utf8" });
+    const configContent = await fs6.readFile(configFilePath, { encoding: "utf8" });
     const parsedMountPoint = parseMountPointFromConfig(configContent);
     if (parsedMountPoint === void 0) {
       return defaultMountPoint;
@@ -26712,7 +27160,7 @@ var canAccessPowerShell = async () => {
   canAccessPowerShellPromise ??= (async () => {
     try {
       const psPath = await powerShellPath2();
-      await fs5.access(psPath, fsConstants.X_OK);
+      await fs6.access(psPath, fsConstants.X_OK);
       return true;
     } catch {
       return false;
@@ -26725,7 +27173,7 @@ var wslDefaultBrowser = async () => {
   const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
   const { stdout } = await executePowerShell(command, {
     powerShellPath: psPath,
-    cwd: path3.dirname(psPath)
+    cwd: path4.dirname(psPath)
   });
   return stdout.trim();
 };
@@ -26931,8 +27379,8 @@ var is_in_ssh_default = isInSsh;
 
 // node_modules/open/index.js
 var fallbackAttemptSymbol = /* @__PURE__ */ Symbol("fallbackAttempt");
-var __dirname = import.meta.url ? path4.dirname(fileURLToPath(import.meta.url)) : "";
-var localXdgOpenPath = path4.join(__dirname, "xdg-open");
+var __dirname = import.meta.url ? path5.dirname(fileURLToPath(import.meta.url)) : "";
+var localXdgOpenPath = path5.join(__dirname, "xdg-open");
 var { platform, arch } = process11;
 var tryEachApp = async (apps2, opener) => {
   if (apps2.length === 0) {
@@ -27074,7 +27522,7 @@ var baseOpen = async (options) => {
       childProcessOptions.stdio = "ignore";
     }
     if (is_wsl_default) {
-      childProcessOptions.cwd = path4.dirname(command);
+      childProcessOptions.cwd = path5.dirname(command);
     }
   } else {
     if (app) {
@@ -27083,7 +27531,7 @@ var baseOpen = async (options) => {
       const isBundled = !__dirname || __dirname === "/";
       let exeLocalXdgOpen = false;
       try {
-        await fs6.access(localXdgOpenPath, fsConstants2.X_OK);
+        await fs7.access(localXdgOpenPath, fsConstants2.X_OK);
         exeLocalXdgOpen = true;
       } catch {
       }
@@ -27371,7 +27819,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.11.0-agentconnect.1",
+  version: "1.12.0-agentconnect.1",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -27422,402 +27870,106 @@ var package_default = {
   keywords: [],
   author: "Agent Client Protocol",
   license: "Apache-2.0",
-  type: "module",
-  devDependencies: {
-    "@types/node": "^26.1.0",
-    esbuild: "^0.28.2",
-    "mcp-hello-world": "^1.1.2",
-    tsx: "^4.23.12",
-    typescript: "^7.0.2",
-    vitest: "^4.1.11"
-  },
-  dependencies: {
-    "@agentclientprotocol/sdk": "^1.4.0",
-    "@openai/codex": "^0.153.4",
-    diff: "^9.0.0",
-    open: "^11.0.1",
-    "vscode-jsonrpc": "^9.0.1",
-    zod: "^4.0.0"
-  }
-};
-
-// src/CollaborationModeConfig.ts
-var COLLABORATION_MODE_CONFIG_ID = "collaboration_mode";
-var DEFAULT_COLLABORATION_MODE = "default";
-var PLAN_COLLABORATION_MODE = "plan";
-function createCollaborationModeConfigOption(currentValue) {
-  return {
-    id: COLLABORATION_MODE_CONFIG_ID,
-    name: "Collaboration mode",
-    description: "How Codex collaborates for subsequent turns",
-    category: "collaboration_mode",
-    type: "select",
-    currentValue,
-    options: [
-      { value: DEFAULT_COLLABORATION_MODE, name: "Default" },
-      { value: PLAN_COLLABORATION_MODE, name: "Plan", description: "Plan before making changes" }
-    ]
-  };
-}
-function parseCollaborationMode(value) {
-  if (value === DEFAULT_COLLABORATION_MODE) return DEFAULT_COLLABORATION_MODE;
-  if (value === PLAN_COLLABORATION_MODE) return PLAN_COLLABORATION_MODE;
-  return null;
-}
-function createCodexCollaborationMode(mode, currentModelId) {
-  const modelId = ModelId.fromString(currentModelId);
-  return {
-    mode,
-    settings: {
-      model: modelId.model,
-      reasoning_effort: modelId.effort,
-      developer_instructions: null
-    }
-  };
-}
-
-// src/PathUtils.ts
-import path5 from "node:path";
-function isAbsolutePathLike(value) {
-  const trimmed = value.trim();
-  return path5.isAbsolute(trimmed) || isWindowsAbsolutePath(trimmed);
-}
-function arePathsEqual(left, right) {
-  return normalizePathForComparison(left) === normalizePathForComparison(right);
-}
-function arePathBasenamesEqual(left, right) {
-  const leftBase = path5.posix.basename(normalizePathForComparison(left));
-  const rightBase = path5.posix.basename(normalizePathForComparison(right));
-  if (shouldComparePathCaseInsensitive(left) || shouldComparePathCaseInsensitive(right)) {
-    return leftBase.toLowerCase() === rightBase.toLowerCase();
-  }
-  return leftBase === rightBase;
-}
-function normalizePathForComparison(value) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    return "";
-  }
-  if (isWindowsAbsolutePath(trimmed)) {
-    const normalized2 = path5.win32.normalize(trimmed).replace(/\\/g, "/");
-    return trimTrailingPathSeparators(normalized2).toLowerCase();
-  }
-  const pathForComparison = path5.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
-  const normalized = path5.posix.normalize(pathForComparison);
-  return trimTrailingPathSeparators(normalized);
-}
-function isWindowsAbsolutePath(value) {
-  const portableValue = value.replace(/\\/g, "/");
-  return /^[A-Za-z]:\//.test(portableValue) || /^\/\/[^/]+\/[^/]+/.test(portableValue);
-}
-function shouldComparePathCaseInsensitive(value) {
-  return isWindowsAbsolutePath(value) || /^[A-Za-z]:/.test(value) || value.includes("\\");
-}
-function trimTrailingPathSeparators(value) {
-  let trimmed = value;
-  while (trimmed.endsWith("/") && !isRootPath(trimmed)) {
-    trimmed = trimmed.slice(0, -1);
-  }
-  return trimmed;
-}
-function isRootPath(value) {
-  return value === "/" || /^[A-Za-z]:\/$/.test(value) || /^\/\/[^/]+\/[^/]+\/$/.test(value);
-}
-
-// src/AgentFileChangeReport.ts
-import fs7 from "node:fs";
-import path6 from "node:path";
-var AGENT_FILE_CHANGE_REPORT_VERSION = 1;
-var AGENT_FILE_CHANGE_REPORT_TIMEOUT_MS = 3e4;
-var AGENT_FILE_CHANGE_REPORT_MAX_PATHS = 1024;
-var AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH = 4096;
-var AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES = 256 * 1024;
-var AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH = 2e3;
-var AGENT_FILE_CHANGE_REPORT_OUTPUT_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  required: ["paths", "complete", "uncertainty"],
-  properties: {
-    paths: {
-      type: "array",
-      items: { type: "string" }
-    },
-    complete: { type: "boolean" },
-    uncertainty: {
-      anyOf: [{
-        type: "string",
-        maxLength: AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH
-      }, {
-        type: "null"
-      }]
-    }
-  }
-};
-var AGENT_FILE_CHANGE_REPORT_DEVELOPER_INSTRUCTIONS = `You are running an internal, read-only file-change audit for the immediately preceding turn.
-Do not modify files, run commands that can modify files, or ask the user questions.
-Report files that the preceding turn causally created, modified, deleted, or moved, including changes made by shell commands, version-control commands, generators, and child processes.
-Do not report files that were only read or inspected.
-You may use read-only inspection when needed. If the list may be incomplete, set complete to false and briefly explain why in uncertainty.`;
-function createAgentFileChangeReportPrompt(workspace) {
-  return `List the paths changed by the immediately preceding turn.
-Return only the structured result required by the output schema.
-Relative paths are resolved against the working directory.
-Working directory: ${JSON.stringify(workspace.cwd)}
-Additional allowed directories: ${JSON.stringify(workspace.additionalDirectories)}`;
-}
-function parseAgentFileChangeReportRequest(meta3) {
-  const jetbrains = 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, turn, workspace) {
-  const modelReport = parseModelFileChangeReport(turn);
-  const normalized = normalizeModelFileChangeReport(modelReport, workspace);
-  return fitReportedAgentFileChangeReport({
-    version: AGENT_FILE_CHANGE_REPORT_VERSION,
-    requestId,
-    status: "reported",
-    ...normalized
-  });
-}
-function createUnavailableAgentFileChangeReport(requestId, reason) {
-  return {
-    version: AGENT_FILE_CHANGE_REPORT_VERSION,
-    requestId,
-    status: "unavailable",
-    reason
-  };
-}
-var AgentFileChangeReportError = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "AgentFileChangeReportError";
-    this.reason = reason;
-  }
-};
-function parseModelFileChangeReport(turn) {
-  switch (turn.status) {
-    case "interrupted":
-      throw new AgentFileChangeReportError("cancelled", "The audit turn was interrupted");
-    case "failed":
-      throw new AgentFileChangeReportError(
-        "providerError",
-        `The audit turn failed${turn.error?.message ? `: ${turn.error.message}` : ""}`
-      );
-    case "inProgress":
-      throw new AgentFileChangeReportError("notReported", "The audit turn did not complete");
-    case "completed":
-      break;
-  }
-  let text = null;
-  for (let index = turn.items.length - 1; index >= 0; index -= 1) {
-    const item = turn.items[index];
-    if (item?.type === "agentMessage") {
-      text = item.text;
-      break;
-    }
-  }
-  if (text === null) {
-    throw new AgentFileChangeReportError("notReported", "The audit turn returned no agent message");
-  }
-  let value;
-  try {
-    value = JSON.parse(text);
-  } catch {
-    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned invalid JSON");
-  }
-  const report = asRecord2(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");
+  type: "module",
+  devDependencies: {
+    "@types/node": "^26.1.0",
+    esbuild: "^0.28.2",
+    "mcp-hello-world": "^1.1.2",
+    tsx: "^4.23.12",
+    typescript: "^7.0.2",
+    vitest: "^4.1.11"
+  },
+  dependencies: {
+    "@agentclientprotocol/sdk": "^1.4.0",
+    "@openai/codex": "^0.154.0",
+    diff: "^9.0.0",
+    open: "^11.0.1",
+    "vscode-jsonrpc": "^9.0.1",
+    zod: "^4.0.0"
   }
+};
+
+// src/CollaborationModeConfig.ts
+var COLLABORATION_MODE_CONFIG_ID = "collaboration_mode";
+var DEFAULT_COLLABORATION_MODE = "default";
+var PLAN_COLLABORATION_MODE = "plan";
+function createCollaborationModeConfigOption(currentValue) {
   return {
-    paths,
-    complete,
-    ...normalizedUncertainty ? { uncertainty: normalizedUncertainty } : {}
+    id: COLLABORATION_MODE_CONFIG_ID,
+    name: "Collaboration mode",
+    description: "How Codex collaborates for subsequent turns",
+    category: "collaboration_mode",
+    type: "select",
+    currentValue,
+    options: [
+      { value: DEFAULT_COLLABORATION_MODE, name: "Default" },
+      { value: PLAN_COLLABORATION_MODE, name: "Plan", description: "Plan before making changes" }
+    ]
   };
 }
-function 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 parseCollaborationMode(value) {
+  if (value === DEFAULT_COLLABORATION_MODE) return DEFAULT_COLLABORATION_MODE;
+  if (value === PLAN_COLLABORATION_MODE) return PLAN_COLLABORATION_MODE;
+  return null;
 }
-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;
-  }
+function createCodexCollaborationMode(mode, currentModelId) {
+  const modelId = ModelId.fromString(currentModelId);
   return {
-    paths,
-    declaredComplete: report.complete && !truncated,
-    truncated,
-    ...report.uncertainty ? { uncertainty: report.uncertainty } : {}
+    mode,
+    settings: {
+      model: modelId.model,
+      reasoning_effort: modelId.effort,
+      developer_instructions: null
+    }
   };
 }
-function normalizeWorkspaceRoot(value) {
-  const trimmed = value.trim();
-  if (!isValidPathText(trimmed)) {
-    return null;
-  }
-  if (isWindowsAbsolutePath2(trimmed)) {
-    return canonicalizeWorkspaceRoot({
-      value: path6.win32.normalize(trimmed.replace(/\//g, "\\")),
-      flavor: "windows"
-    });
-  }
-  if (path6.posix.isAbsolute(trimmed)) {
-    return canonicalizeWorkspaceRoot({
-      value: path6.posix.normalize(trimmed.replace(/\\/g, "/")),
-      flavor: "posix"
-    });
-  }
-  return null;
-}
-function normalizeReportedPath(value, cwd, roots) {
+
+// src/PathUtils.ts
+import path6 from "node:path";
+function isAbsolutePathLike(value) {
   const trimmed = value.trim();
-  if (!isValidPathText(trimmed) || /^[A-Za-z]:[^\\/]/.test(trimmed) || /^\\\\[?.]\\/.test(trimmed) || /^(?:\\\\|\/\/)/.test(trimmed) && !isWindowsAbsolutePath2(trimmed) || cwd.flavor === "windows" && /^\\(?!\\)/.test(trimmed) || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed)) {
-    return null;
-  }
-  let candidate;
-  if (isWindowsAbsolutePath2(trimmed)) {
-    candidate = { value: path6.win32.normalize(trimmed.replace(/\//g, "\\")), flavor: "windows" };
-  } else if (path6.posix.isAbsolute(trimmed)) {
-    candidate = { value: path6.posix.normalize(trimmed.replace(/\\/g, "/")), flavor: "posix" };
-  } else if (cwd.flavor === "windows") {
-    candidate = {
-      value: path6.win32.resolve(cwd.value, trimmed.replace(/\//g, "\\")),
-      flavor: "windows"
-    };
-  } else {
-    candidate = {
-      value: path6.posix.resolve(cwd.value, trimmed.replace(/\\/g, "/")),
-      flavor: "posix"
-    };
-  }
-  candidate = canonicalizeReportedPath(candidate);
-  return roots.some((root) => pathIsStrictlyInside(root, candidate)) ? candidate : null;
+  return path6.isAbsolute(trimmed) || isWindowsAbsolutePath2(trimmed);
 }
-function canonicalizeWorkspaceRoot(root) {
-  if (!isNativePathFlavor(root.flavor)) {
-    return root;
-  }
-  return { ...root, value: canonicalizeFromExistingAncestor(root.value) };
+function arePathsEqual(left, right) {
+  return normalizePathForComparison(left) === normalizePathForComparison(right);
 }
-function canonicalizeReportedPath(candidate) {
-  if (!isNativePathFlavor(candidate.flavor)) {
-    return candidate;
+function arePathBasenamesEqual(left, right) {
+  const leftBase = path6.posix.basename(normalizePathForComparison(left));
+  const rightBase = path6.posix.basename(normalizePathForComparison(right));
+  if (shouldComparePathCaseInsensitive(left) || shouldComparePathCaseInsensitive(right)) {
+    return leftBase.toLowerCase() === rightBase.toLowerCase();
   }
-  const parent = canonicalizeFromExistingAncestor(path6.dirname(candidate.value));
-  return { ...candidate, value: path6.resolve(parent, path6.basename(candidate.value)) };
+  return leftBase === rightBase;
 }
-function canonicalizeFromExistingAncestor(value) {
-  const original = path6.resolve(value);
-  let current = original;
-  const missingSegments = [];
-  while (true) {
-    try {
-      const canonical = fs7.realpathSync.native(current);
-      return path6.resolve(canonical, ...missingSegments.reverse());
-    } catch (error51) {
-      if (!isMissingPathError(error51)) return original;
-    }
-    const parent = path6.dirname(current);
-    if (parent === current) return original;
-    missingSegments.push(path6.basename(current));
-    current = parent;
+function normalizePathForComparison(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return "";
   }
-}
-function isMissingPathError(error51) {
-  if (typeof error51 !== "object" || error51 === null || !("code" in error51)) return false;
-  return error51.code === "ENOENT" || error51.code === "ENOTDIR";
-}
-function isNativePathFlavor(flavor) {
-  return process.platform === "win32" ? flavor === "windows" : flavor === "posix";
-}
-function pathIsStrictlyInside(root, candidate) {
-  if (root.flavor !== candidate.flavor) {
-    return false;
+  if (isWindowsAbsolutePath2(trimmed)) {
+    const normalized2 = path6.win32.normalize(trimmed).replace(/\\/g, "/");
+    return trimTrailingPathSeparators(normalized2).toLowerCase();
   }
-  const pathImplementation = root.flavor === "windows" ? path6.win32 : path6.posix;
-  const relative = pathImplementation.relative(root.value, candidate.value);
-  return relative.length > 0 && !pathImplementation.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${pathImplementation.sep}`);
+  const pathForComparison = path6.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
+  const normalized = path6.posix.normalize(pathForComparison);
+  return trimTrailingPathSeparators(normalized);
 }
 function isWindowsAbsolutePath2(value) {
-  const portable = value.replace(/\\/g, "/");
-  return /^[A-Za-z]:\//.test(portable) || /^\/\/[^/]+\/[^/]+(?:\/|$)/.test(portable);
+  const portableValue = value.replace(/\\/g, "/");
+  return /^[A-Za-z]:\//.test(portableValue) || /^\/\/[^/]+\/[^/]+/.test(portableValue);
 }
-function isValidPathText(value) {
-  return value.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
+function shouldComparePathCaseInsensitive(value) {
+  return isWindowsAbsolutePath2(value) || /^[A-Za-z]:/.test(value) || value.includes("\\");
 }
-function asRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+function trimTrailingPathSeparators(value) {
+  let trimmed = value;
+  while (trimmed.endsWith("/") && !isRootPath(trimmed)) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
 }
-function hasOnlyKeys(value, allowed) {
-  const allowedKeys = new Set(allowed);
-  return Object.keys(value).every((key) => allowedKeys.has(key));
+function isRootPath(value) {
+  return value === "/" || /^[A-Za-z]:\/$/.test(value) || /^\/\/[^/]+\/[^/]+\/$/.test(value);
 }
 
 // src/subagents/CodexSubagentSubscriptions.ts
@@ -28621,7 +28773,7 @@ var CodexAcpClient = class {
       baseUrl: activeProvider.baseUrl
     });
     const mergedConfig = {
-      ...mergeGatewayConfig(this.config, this.gatewayConfig),
+      ...forceGitRootTurnDiffPaths(mergeGatewayConfig(this.config, this.gatewayConfig)),
       projects: Object.fromEntries(sessionRoots2.map((root) => [root, {
         trust_level: "trusted"
       }]))
@@ -28788,101 +28940,6 @@ var CodexAcpClient = class {
       serviceTier
     }, onTurnStarted);
   }
-  async runAgentFileChangeReport(params) {
-    if (params.signal?.aborted) {
-      return createUnavailableAgentFileChangeReport(params.requestId, "cancelled");
-    }
-    const budget = new AgentFileChangeReportBudget(params.signal);
-    let forkThreadId = null;
-    let auditTurnId = null;
-    let auditTurnCompleted = false;
-    let lateStopReason = null;
-    try {
-      const forkPromise = this.codexClient.threadFork({
-        excludeTurns: true,
-        threadId: params.sessionId,
-        lastTurnId: params.turnId,
-        cwd: params.workspace.cwd,
-        approvalPolicy: "never",
-        sandbox: "read-only",
-        developerInstructions: AGENT_FILE_CHANGE_REPORT_DEVELOPER_INSTRUCTIONS,
-        ephemeral: true
-      });
-      void forkPromise.then((fork2) => {
-        if (lateStopReason !== null && forkThreadId === null) {
-          void this.unsubscribeAgentFileChangeReportThread(fork2.thread.id, budget);
-        }
-      }, () => {
-      });
-      const fork = await budget.wait(forkPromise);
-      forkThreadId = fork.thread.id;
-      const turnPromise = this.codexClient.runTurn({
-        threadId: forkThreadId,
-        input: [{
-          type: "text",
-          text: createAgentFileChangeReportPrompt(params.workspace),
-          text_elements: []
-        }],
-        cwd: params.workspace.cwd,
-        approvalPolicy: "never",
-        sandboxPolicy: { type: "readOnly", networkAccess: false },
-        summary: "none",
-        outputSchema: AGENT_FILE_CHANGE_REPORT_OUTPUT_SCHEMA
-      }, (turnId) => {
-        auditTurnId = turnId;
-        if (lateStopReason !== null && forkThreadId !== null) {
-          void this.interruptAgentFileChangeReport(forkThreadId, turnId, lateStopReason, budget);
-        }
-      });
-      const outcome = await budget.wait(turnPromise);
-      auditTurnCompleted = true;
-      return createReportedAgentFileChangeReport(
-        params.requestId,
-        outcome.turn,
-        params.workspace
-      );
-    } catch (error51) {
-      if (error51 instanceof AgentFileChangeReportBudgetError) {
-        lateStopReason = error51.reason;
-        if (!auditTurnCompleted && forkThreadId !== null && auditTurnId !== null) {
-          await this.interruptAgentFileChangeReport(
-            forkThreadId,
-            auditTurnId,
-            error51.reason,
-            budget
-          );
-        }
-        return createUnavailableAgentFileChangeReport(params.requestId, error51.reason);
-      }
-      if (error51 instanceof AgentFileChangeReportError) {
-        logger.error("Agent file-change report unavailable", error51);
-        return createUnavailableAgentFileChangeReport(params.requestId, error51.reason);
-      }
-      logger.error("Agent file-change report failed", error51);
-      return createUnavailableAgentFileChangeReport(params.requestId, "providerError");
-    } finally {
-      if (forkThreadId !== null) {
-        await this.unsubscribeAgentFileChangeReportThread(forkThreadId, budget);
-      }
-    }
-  }
-  async interruptAgentFileChangeReport(threadId, turnId, reason, budget) {
-    this.codexClient.markTurnStale(threadId, turnId);
-    try {
-      await budget.wait(this.codexClient.turnInterrupt({ threadId, turnId }));
-    } catch (error51) {
-      logger.error(`Failed to interrupt ${reason} agent file-change report`, error51);
-    } finally {
-      this.codexClient.resolveTurnInterrupted(threadId, turnId);
-    }
-  }
-  async unsubscribeAgentFileChangeReportThread(threadId, budget) {
-    try {
-      await budget.wait(this.codexClient.threadUnsubscribe({ threadId }));
-    } catch (error51) {
-      logger.error("Failed to unsubscribe the agent file-change report thread", error51);
-    }
-  }
   async setAgentMode(sessionId, agentMode) {
     const config2 = this.permissionProfileConfig;
     if (!config2) return;
@@ -29048,58 +29105,6 @@ var CodexAcpClient = class {
     };
   }
 };
-var AgentFileChangeReportBudgetError = class extends Error {
-  constructor(reason) {
-    super(`Agent file-change report ${reason}`);
-    this.reason = reason;
-    this.name = "AgentFileChangeReportBudgetError";
-  }
-  reason;
-};
-var AgentFileChangeReportBudget = class {
-  constructor(signal) {
-    this.signal = signal;
-  }
-  signal;
-  deadline = Date.now() + AGENT_FILE_CHANGE_REPORT_TIMEOUT_MS;
-  async wait(operation) {
-    void operation.catch(() => {
-    });
-    const immediateReason = this.stopReason();
-    if (immediateReason !== null) {
-      throw new AgentFileChangeReportBudgetError(immediateReason);
-    }
-    return await new Promise((resolve, reject) => {
-      let settled = false;
-      const finish = (action) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timeout);
-        this.signal?.removeEventListener("abort", onAbort);
-        action();
-      };
-      const onAbort = () => finish(() => reject(new AgentFileChangeReportBudgetError("cancelled")));
-      const timeout = setTimeout(
-        () => finish(() => reject(new AgentFileChangeReportBudgetError("timeout"))),
-        Math.max(1, this.deadline - Date.now())
-      );
-      timeout.unref();
-      this.signal?.addEventListener("abort", onAbort, { once: true });
-      if (this.signal?.aborted) {
-        onAbort();
-      }
-      void operation.then(
-        (value) => finish(() => resolve(value)),
-        (error51) => finish(() => reject(error51))
-      );
-    });
-  }
-  stopReason() {
-    if (this.signal?.aborted) return "cancelled";
-    if (Date.now() >= this.deadline) return "timeout";
-    return null;
-  }
-};
 function buildPromptItems(prompt) {
   return prompt.map((block) => {
     switch (block.type) {
@@ -29214,6 +29219,16 @@ function mergeSandboxWorkspaceWriteRoots(config2, roots) {
     }
   };
 }
+function forceGitRootTurnDiffPaths(config2) {
+  const features = isJsonObject(config2["features"]) ? config2["features"] : {};
+  return {
+    ...config2,
+    features: {
+      ...features,
+      cwd_relative_turn_diffs: false
+    }
+  };
+}
 function addAdditionalDirectoriesToSandboxPolicy(sandboxPolicy, additionalDirectories) {
   if (additionalDirectories.length === 0 || sandboxPolicy.type !== "workspaceWrite") {
     return sandboxPolicy;
@@ -31011,6 +31026,7 @@ function createFunctionCallUpdate(item) {
   if (!toolCallId || !name) {
     return null;
   }
+  const toolName = functionToolName(name, stringValue(item["namespace"]));
   const isExecCommand = name === "exec_command";
   const args = parseFunctionArguments(item["arguments"]);
   const command = isExecCommand ? commandFromFunctionArguments(args) : null;
@@ -31018,7 +31034,10 @@ function createFunctionCallUpdate(item) {
   const commandAction = command ? inferCommandAction(command, cwd) : null;
   if (commandAction) {
     return {
-      update: createCommandActionEvent(toolCallId, "inProgress", cwd, commandAction),
+      update: {
+        ...createCommandActionEvent(toolCallId, "inProgress", cwd, commandAction),
+        name: toolName
+      },
       usesTerminal: false,
       isExecCommand
     };
@@ -31026,6 +31045,7 @@ function createFunctionCallUpdate(item) {
   const update = {
     sessionUpdate: "tool_call",
     toolCallId,
+    name: toolName,
     kind: toolKindForFunctionCall(name),
     title: titleForFunctionCall(name, args),
     status: "in_progress",
@@ -33979,24 +33999,19 @@ Check ${configPath} and project .codex directories, especially their config.toml
       title
     });
   }
-  async publishAgentFileChangeReport(sessionState, turnId, request, unavailableReason, signal) {
+  async publishAgentFileChangeReport(sessionState, turnId, request, unavailableReason, turnDiff, workspace) {
     let report;
     try {
-      report = turnId === null ? createUnavailableAgentFileChangeReport(request.requestId, unavailableReason) : await this.codexAcpClient.runAgentFileChangeReport({
-        sessionId: sessionState.sessionId,
-        turnId,
-        // The client owns request-id correlation and duplicate suppression. The wrapper
-        // stays stateless so a retried ACP prompt still receives a terminal report.
-        requestId: request.requestId,
-        workspace: {
-          cwd: sessionState.cwd,
-          additionalDirectories: sessionState.additionalDirectories
-        },
-        signal
-      });
+      report = turnId === null ? createUnavailableAgentFileChangeReport(request.requestId, unavailableReason) : createReportedAgentFileChangeReport(request.requestId, turnDiff, workspace);
     } catch (error51) {
-      logger.error("Agent file-change report failed unexpectedly", error51);
-      report = createUnavailableAgentFileChangeReport(request.requestId, "providerError");
+      logger.error(
+        error51 instanceof AgentFileChangeReportError ? "Agent file-change report unavailable" : "Agent file-change report failed unexpectedly",
+        error51
+      );
+      report = createUnavailableAgentFileChangeReport(
+        request.requestId,
+        error51 instanceof AgentFileChangeReportError ? error51.reason : "providerError"
+      );
     }
     try {
       const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
@@ -34466,6 +34481,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     });
     const sessionState = this.getSessionState(params.sessionId);
     const agentFileChangeReportRequest = clientSupportsAgentFileChangeReports(this.clientCapabilities) ? parseAgentFileChangeReportRequest(params._meta) : null;
+    const agentFileChangeWorkspace = agentFileChangeReportRequest === null ? null : captureAgentFileChangeWorkspace(sessionState.cwd, sessionState.additionalDirectories);
     let agentFileChangeReportTurnId = null;
     let agentFileChangeReportUnavailableReason = "providerError";
     let promptWasCancelled = false;
@@ -34505,7 +34521,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         clientSupportsTypedSessionFailures(this.clientCapabilities),
         this.sessionFailureEpoch,
         sessionState.subagents,
-        (accountUpdated) => this.handleAccountUpdated(accountUpdated)
+        (accountUpdated) => this.handleAccountUpdated(accountUpdated),
+        agentFileChangeReportRequest !== null
       );
       eventHandler = promptEventHandler;
       const permissionLifecycle = this.permissionLifecycleContext(sessionState);
@@ -34876,13 +34893,21 @@ Check ${configPath} and project .codex directories, especially their config.toml
       } catch (error51) {
         logger.error("Failed to publish terminal subagent state during prompt cleanup", error51);
       }
-      if (agentFileChangeReportRequest !== null) {
+      if (agentFileChangeReportRequest !== null && agentFileChangeWorkspace !== null) {
+        if (promptWasCancelled || activePrompt.signal.aborted || this.sessionIsClosing(params.sessionId)) {
+          agentFileChangeReportTurnId = null;
+          agentFileChangeReportUnavailableReason = "cancelled";
+        } else if (agentFileChangeReportTurnId !== null && eventHandler?.isTurnDiffOversized(agentFileChangeReportTurnId)) {
+          agentFileChangeReportTurnId = null;
+          agentFileChangeReportUnavailableReason = "invalidOutput";
+        }
         await this.publishAgentFileChangeReport(
           sessionState,
           agentFileChangeReportTurnId,
           agentFileChangeReportRequest,
           agentFileChangeReportUnavailableReason,
-          activePrompt.signal
+          agentFileChangeReportTurnId === null || eventHandler === null ? "" : eventHandler.getTurnDiff(agentFileChangeReportTurnId),
+          agentFileChangeWorkspace
         );
       }
       logger.log("Prompt completed", { sessionId: params.sessionId });