@agentclientprotocol/codex-acp 1.11.1-preview.5 → 1.12.0

package/dist/index.js

@@ -24200,6 +24200,305 @@ function mergeRateLimitSnapshot(previous, update) {
   };
 }
 
+// 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";
+}
+function isNativePathFlavor(flavor) {
+  return process.platform === "win32" ? flavor === "windows" : flavor === "posix";
+}
+function pathIsStrictlyInside(root, candidate) {
+  if (root.flavor !== candidate.flavor) {
+    return false;
+  }
+  const pathImplementation = root.flavor === "windows" ? path3.win32 : path3.posix;
+  const relative = pathImplementation.relative(root.value, candidate.value);
+  return relative.length > 0 && !pathImplementation.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${pathImplementation.sep}`);
+}
+function isWindowsAbsolutePath(value) {
+  const portable = value.replace(/\\/g, "/");
+  return /^[A-Za-z]:\//.test(portable) || /^\/\/[^/]+\/[^/]+(?:\/|$)/.test(portable);
+}
+function isValidPathText(value) {
+  return value.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
+}
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function hasOnlyKeys(value, allowed) {
+  const allowedKeys = new Set(allowed);
+  return Object.keys(value).every((key) => allowedKeys.has(key));
+}
+
 // src/CodexEventHandler.ts
 var MAX_SESSION_FAILURE_TITLE_LENGTH = 240;
 var SESSION_FAILURE_POLICY = {
@@ -24307,6 +24606,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;
@@ -24314,7 +24616,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;
@@ -24322,6 +24624,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);
     }
@@ -24329,6 +24632,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)) {
@@ -24488,6 +24797,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) {
@@ -24506,6 +24817,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":
@@ -24600,7 +24925,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":
@@ -26652,31 +26976,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;
@@ -26684,7 +27008,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;
   }
@@ -26700,7 +27024,7 @@ function isDocker() {
 var cachedResult;
 var hasContainerEnv = () => {
   try {
-    fs3.statSync("/run/.containerenv");
+    fs4.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -26725,12 +27049,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;
@@ -26798,14 +27122,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;
@@ -26825,7 +27149,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;
@@ -26838,7 +27162,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();
 };
@@ -27044,8 +27368,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) {
@@ -27187,7 +27511,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) {
@@ -27196,7 +27520,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 {
       }
@@ -27484,7 +27808,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.11.1-preview.5",
+  version: "1.12.0",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -27591,17 +27915,17 @@ function createCodexCollaborationMode(mode, currentModelId) {
 }
 
 // src/PathUtils.ts
-import path5 from "node:path";
+import path6 from "node:path";
 function isAbsolutePathLike(value) {
   const trimmed = value.trim();
-  return path5.isAbsolute(trimmed) || isWindowsAbsolutePath(trimmed);
+  return path6.isAbsolute(trimmed) || isWindowsAbsolutePath2(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));
+  const leftBase = path6.posix.basename(normalizePathForComparison(left));
+  const rightBase = path6.posix.basename(normalizePathForComparison(right));
   if (shouldComparePathCaseInsensitive(left) || shouldComparePathCaseInsensitive(right)) {
     return leftBase.toLowerCase() === rightBase.toLowerCase();
   }
@@ -27612,20 +27936,20 @@ function normalizePathForComparison(value) {
   if (trimmed.length === 0) {
     return "";
   }
-  if (isWindowsAbsolutePath(trimmed)) {
-    const normalized2 = path5.win32.normalize(trimmed).replace(/\\/g, "/");
+  if (isWindowsAbsolutePath2(trimmed)) {
+    const normalized2 = path6.win32.normalize(trimmed).replace(/\\/g, "/");
     return trimTrailingPathSeparators(normalized2).toLowerCase();
   }
-  const pathForComparison = path5.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
-  const normalized = path5.posix.normalize(pathForComparison);
+  const pathForComparison = path6.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
+  const normalized = path6.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;
@@ -27638,302 +27962,6 @@ 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");
-  }
-  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: 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) {
-  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;
-}
-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(path6.dirname(candidate.value));
-  return { ...candidate, value: path6.resolve(parent, path6.basename(candidate.value)) };
-}
-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 isMissingPathError(error51) {
-  if (typeof error51 !== "object" || error51 === null || !("code" in error51)) return false;
-  return error51.code === "ENOENT" || error51.code === "ENOTDIR";
-}
-function isNativePathFlavor(flavor) {
-  return process.platform === "win32" ? flavor === "windows" : flavor === "posix";
-}
-function pathIsStrictlyInside(root, candidate) {
-  if (root.flavor !== candidate.flavor) {
-    return false;
-  }
-  const pathImplementation = root.flavor === "windows" ? path6.win32 : path6.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 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/subagents/CodexSubagentSubscriptions.ts
 var CodexSubagentSubscriptions = class {
   constructor(client) {
@@ -28673,7 +28701,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"
       }]))
@@ -28833,101 +28861,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 setCollaborationMode(sessionId, mode, currentModelId) {
     await this.codexClient.threadSettingsUpdate({
       threadId: sessionId,
@@ -29084,58 +29017,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) {
@@ -29250,6 +29131,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;
@@ -34004,24 +33895,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);
@@ -34491,6 +34377,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;
@@ -34529,7 +34416,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);
@@ -34881,13 +34769,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 });

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.11.1-preview.5",
+  "version": "1.12.0",
   "description": "",
   "main": "dist/index.js",
   "bin": {