@agentclientprotocol/codex-acp 1.3.0 → 1.4.0

package/dist/index.js

@@ -3453,9 +3453,9 @@ var require_main = __commonJS({
     exports.createMessageConnection = createMessageConnection2;
     var ril_1 = __importDefault(require_ril());
     ril_1.default.install();
-    var path7 = __importStar(__require("path"));
+    var path8 = __importStar(__require("path"));
     var os2 = __importStar(__require("os"));
-    var fs7 = __importStar(__require("fs"));
+    var fs8 = __importStar(__require("fs"));
     var crypto_1 = __require("crypto");
     var net_1 = __require("net");
     var api_1 = require_api();
@@ -3596,7 +3596,7 @@ var require_main = __commonJS({
       }
       let randomLength = 32;
       const fixedLength = "/lsp-.sock".length;
-      const tmpDir = fs7.realpathSync(XDG_RUNTIME_DIR ?? os2.tmpdir());
+      const tmpDir = fs8.realpathSync(XDG_RUNTIME_DIR ?? os2.tmpdir());
       const limit = safeIpcPathLengths.get(process.platform);
       if (limit !== void 0) {
         randomLength = Math.min(limit - tmpDir.length - fixedLength, randomLength);
@@ -3605,7 +3605,7 @@ var require_main = __commonJS({
         throw new Error(`Unable to generate a random pipe name with ${randomLength} characters.`);
       }
       const randomSuffix = (0, crypto_1.randomBytes)(Math.floor(randomLength / 2)).toString("hex");
-      return path7.join(tmpDir, `lsp-${randomSuffix}.sock`);
+      return path8.join(tmpDir, `lsp-${randomSuffix}.sock`);
     }
     function createClientPipeTransport(pipeName, encoding = "utf-8") {
       let connectResolve;
@@ -4509,10 +4509,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path8) {
+  if (!path8)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path8.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4921,11 +4921,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path8, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path8);
     return iss;
   });
 }
@@ -5072,16 +5072,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path8 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -5108,17 +5108,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path8 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5150,8 +5150,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path8) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17843,13 +17843,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.length === 0) {
+  const path8 = ref.slice(1).split("/").filter(Boolean);
+  if (path8.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path8[0] === defsKey) {
+    const key = path8[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -23247,13 +23247,13 @@ function createTerminalCommandEvent(event, terminalId, cwd) {
     }
   };
 }
-function createSearchTitle(query, path7) {
-  if (query && path7) {
-    return `Search for '${query}' in ${path7}`;
+function createSearchTitle(query, path8) {
+  if (query && path8) {
+    return `Search for '${query}' in ${path8}`;
   } else if (query) {
     return `Search for '${query}'`;
-  } else if (path7) {
-    return `Search in '${path7}'`;
+  } else if (path8) {
+    return `Search in '${path8}'`;
   }
   return "Search";
 }
@@ -23479,12 +23479,12 @@ function revertPatch(unifiedDiff) {
   if (!patch) return null;
   return reversePatch(patch);
 }
-function createUpdateDiffContent(path7, oldText, newText) {
+function createUpdateDiffContent(path8, oldText, newText) {
   return {
     type: "diff",
     oldText,
     newText,
-    path: path7,
+    path: path8,
     _meta: {
       kind: "update"
     }
@@ -23617,6 +23617,8 @@ var AIR_META_KEY = "air";
 var AIR_EXTENSION_VERSION_KEY = "version";
 var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
 var AIR_SESSION_FAILURE_KEY = "sessionFailure";
+var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
+var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
 var AIR_EXTENSION_VERSION = 1;
 
 // src/CodexEventHandler.ts
@@ -25007,11 +25009,11 @@ var CodexApprovalHandler = class {
       });
     }
     const fileSystem = permissions.fileSystem;
-    for (const path7 of fileSystem?.read ?? []) {
-      changes.push(this.fileSystemGrantChange(path7, "read", lifetime, suffix));
+    for (const path8 of fileSystem?.read ?? []) {
+      changes.push(this.fileSystemGrantChange(path8, "read", lifetime, suffix));
     }
-    for (const path7 of fileSystem?.write ?? []) {
-      changes.push(this.fileSystemGrantChange(path7, "write", lifetime, suffix));
+    for (const path8 of fileSystem?.write ?? []) {
+      changes.push(this.fileSystemGrantChange(path8, "write", lifetime, suffix));
     }
     for (const entry of fileSystem?.entries ?? []) {
       const matcher = (() => {
@@ -25040,16 +25042,16 @@ var CodexApprovalHandler = class {
     }
     return changes.length > 0 ? { version: 1, changes } : void 0;
   }
-  fileSystemGrantChange(path7, access, lifetime, suffix) {
+  fileSystemGrantChange(path8, access, lifetime, suffix) {
     return {
       type: "grant",
       operation: "grant",
-      description: `Allow ${access} access to ${path7}${suffix}`,
+      description: `Allow ${access} access to ${path8}${suffix}`,
       lifetime,
       targets: [{
         type: "filesystem",
         access: [access],
-        matcher: { type: "exact_path", path: path7 }
+        matcher: { type: "exact_path", path: path8 }
       }]
     };
   }
@@ -25959,15 +25961,15 @@ var wslDefaultBrowser = async () => {
   const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
   return stdout.trim();
 };
-var convertWslPathToWindows = async (path7) => {
-  if (/^[a-z]+:\/\//i.test(path7)) {
-    return path7;
+var convertWslPathToWindows = async (path8) => {
+  if (/^[a-z]+:\/\//i.test(path8)) {
+    return path8;
   }
   try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path7], { encoding: "utf8" });
+    const { stdout } = await execFile2("wslpath", ["-aw", path8], { encoding: "utf8" });
     return stdout.trim();
   } catch {
-    return path7;
+    return path8;
   }
 };
 
@@ -26517,7 +26519,7 @@ var AgentMode = class _AgentMode {
 };
 
 // src/CodexAcpClient.ts
-import path5 from "node:path";
+import path6 from "node:path";
 
 // src/McpServerName.ts
 var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
@@ -26531,7 +26533,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.3.0",
+  version: "1.4.0",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -26684,6 +26686,295 @@ function isRootPath(value) {
   return value === "/" || /^[A-Za-z]:\/$/.test(value) || /^\/\/[^/]+\/[^/]+\/$/.test(value);
 }
 
+// src/AgentFileChangeReport.ts
+import fs7 from "node:fs";
+import path5 from "node:path";
+var AGENT_FILE_CHANGE_REPORT_VERSION = 1;
+var AGENT_FILE_CHANGE_REPORT_TIMEOUT_MS = 3e4;
+var AGENT_FILE_CHANGE_REPORT_MAX_PATHS = 1024;
+var AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH = 4096;
+var AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES = 256 * 1024;
+var AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH = 2e3;
+var AGENT_FILE_CHANGE_REPORT_OUTPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["paths", "complete"],
+  properties: {
+    paths: {
+      type: "array",
+      items: { type: "string" }
+    },
+    complete: { type: "boolean" },
+    uncertainty: {
+      type: "string",
+      maxLength: AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH
+    }
+  }
+};
+var AGENT_FILE_CHANGE_REPORT_DEVELOPER_INSTRUCTIONS = `You are running an internal, read-only file-change audit for the immediately preceding turn.
+Do not modify files, run commands that can modify files, or ask the user questions.
+Report files that the preceding turn causally created, modified, deleted, or moved, including changes made by shell commands, version-control commands, generators, and child processes.
+Do not report files that were only read or inspected.
+You may use read-only inspection when needed. If the list may be incomplete, set complete to false and briefly explain why in uncertainty.`;
+function createAgentFileChangeReportPrompt(workspace) {
+  return `List the paths changed by the immediately preceding turn.
+Return only the structured result required by the output schema.
+Relative paths are resolved against the working directory.
+Working directory: ${JSON.stringify(workspace.cwd)}
+Additional allowed directories: ${JSON.stringify(workspace.additionalDirectories)}`;
+}
+function parseAgentFileChangeReportRequest(meta3) {
+  const jetbrains = asRecord(meta3?.[JETBRAINS_META_KEY]);
+  const air = asRecord(jetbrains?.[AIR_META_KEY]);
+  const request = asRecord(air?.[AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY]);
+  if (request === null || !hasOnlyKeys(request, ["version", "requestId"]) || request["version"] !== AGENT_FILE_CHANGE_REPORT_VERSION) {
+    return null;
+  }
+  const requestId = request["requestId"];
+  if (typeof requestId !== "string" || !/^[A-Za-z0-9._:-]{1,128}$/.test(requestId)) {
+    return null;
+  }
+  return { version: AGENT_FILE_CHANGE_REPORT_VERSION, requestId };
+}
+function createReportedAgentFileChangeReport(requestId, turn, workspace) {
+  const modelReport = parseModelFileChangeReport(turn);
+  const normalized = normalizeModelFileChangeReport(modelReport, workspace);
+  return fitReportedAgentFileChangeReport({
+    version: AGENT_FILE_CHANGE_REPORT_VERSION,
+    requestId,
+    status: "reported",
+    ...normalized
+  });
+}
+function createUnavailableAgentFileChangeReport(requestId, reason) {
+  return {
+    version: AGENT_FILE_CHANGE_REPORT_VERSION,
+    requestId,
+    status: "unavailable",
+    reason
+  };
+}
+var AgentFileChangeReportError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "AgentFileChangeReportError";
+    this.reason = reason;
+  }
+};
+function parseModelFileChangeReport(turn) {
+  switch (turn.status) {
+    case "interrupted":
+      throw new AgentFileChangeReportError("cancelled", "The audit turn was interrupted");
+    case "failed":
+      throw new AgentFileChangeReportError("providerError", "The audit turn failed");
+    case "inProgress":
+      throw new AgentFileChangeReportError("notReported", "The audit turn did not complete");
+    case "completed":
+      break;
+  }
+  let text = null;
+  for (let index = turn.items.length - 1; index >= 0; index -= 1) {
+    const item = turn.items[index];
+    if (item?.type === "agentMessage") {
+      text = item.text;
+      break;
+    }
+  }
+  if (text === null) {
+    throw new AgentFileChangeReportError("notReported", "The audit turn returned no agent message");
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned invalid JSON");
+  }
+  const report = asRecord(value);
+  if (report === null || !hasOnlyKeys(report, ["paths", "complete", "uncertainty"])) {
+    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned an invalid object");
+  }
+  const paths = report["paths"];
+  const complete = report["complete"];
+  const uncertainty = report["uncertainty"];
+  if (!Array.isArray(paths) || !paths.every((item) => typeof item === "string") || typeof complete !== "boolean" || uncertainty !== void 0 && typeof uncertainty !== "string") {
+    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned invalid fields");
+  }
+  const normalizedUncertainty = uncertainty?.trim();
+  if (normalizedUncertainty !== void 0 && normalizedUncertainty.length > AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH) {
+    throw new AgentFileChangeReportError("invalidOutput", "The audit turn returned oversized uncertainty");
+  }
+  return {
+    paths,
+    complete,
+    ...normalizedUncertainty ? { uncertainty: normalizedUncertainty } : {}
+  };
+}
+function fitReportedAgentFileChangeReport(report) {
+  const paths = [...report.paths];
+  let truncated = report.truncated;
+  let fitted = report;
+  while (Buffer.byteLength(JSON.stringify(fitted), "utf8") > AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES) {
+    if (paths.length === 0) {
+      throw new AgentFileChangeReportError("invalidOutput", "The audit report exceeds the wire limit");
+    }
+    paths.pop();
+    truncated = true;
+    fitted = {
+      ...report,
+      paths: [...paths],
+      declaredComplete: false,
+      truncated
+    };
+  }
+  return fitted;
+}
+function normalizeModelFileChangeReport(report, workspace) {
+  const cwd = normalizeWorkspaceRoot(workspace.cwd);
+  if (cwd === null) {
+    throw new AgentFileChangeReportError("providerError", "The session working directory is not absolute");
+  }
+  const roots = [cwd, ...workspace.additionalDirectories.flatMap((directory) => {
+    const root = normalizeWorkspaceRoot(directory);
+    return root === null || root.flavor !== cwd.flavor ? [] : [root];
+  })];
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  let totalBytes = 0;
+  let truncated = false;
+  for (const reportedPath of report.paths) {
+    if (reportedPath.length > AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH) {
+      truncated = true;
+      continue;
+    }
+    const normalized = normalizeReportedPath(reportedPath, cwd, roots);
+    if (normalized === null || normalized.value.length > AGENT_FILE_CHANGE_REPORT_MAX_PATH_LENGTH) {
+      truncated = true;
+      continue;
+    }
+    const key = normalized.flavor === "windows" ? normalized.value.toLowerCase() : normalized.value;
+    if (seen.has(key)) {
+      continue;
+    }
+    const bytes = Buffer.byteLength(normalized.value, "utf8");
+    if (paths.length >= AGENT_FILE_CHANGE_REPORT_MAX_PATHS || totalBytes + bytes > AGENT_FILE_CHANGE_REPORT_MAX_TOTAL_BYTES) {
+      truncated = true;
+      continue;
+    }
+    seen.add(key);
+    paths.push(normalized.value);
+    totalBytes += bytes;
+  }
+  return {
+    paths,
+    declaredComplete: report.complete && !truncated,
+    truncated,
+    ...report.uncertainty ? { uncertainty: report.uncertainty } : {}
+  };
+}
+function normalizeWorkspaceRoot(value) {
+  const trimmed = value.trim();
+  if (!isValidPathText(trimmed)) {
+    return null;
+  }
+  if (isWindowsAbsolutePath2(trimmed)) {
+    return canonicalizeWorkspaceRoot({
+      value: path5.win32.normalize(trimmed.replace(/\//g, "\\")),
+      flavor: "windows"
+    });
+  }
+  if (path5.posix.isAbsolute(trimmed)) {
+    return canonicalizeWorkspaceRoot({
+      value: path5.posix.normalize(trimmed.replace(/\\/g, "/")),
+      flavor: "posix"
+    });
+  }
+  return null;
+}
+function normalizeReportedPath(value, cwd, roots) {
+  const trimmed = value.trim();
+  if (!isValidPathText(trimmed) || /^[A-Za-z]:[^\\/]/.test(trimmed) || /^\\\\[?.]\\/.test(trimmed) || /^(?:\\\\|\/\/)/.test(trimmed) && !isWindowsAbsolutePath2(trimmed) || cwd.flavor === "windows" && /^\\(?!\\)/.test(trimmed) || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed)) {
+    return null;
+  }
+  let candidate;
+  if (isWindowsAbsolutePath2(trimmed)) {
+    candidate = { value: path5.win32.normalize(trimmed.replace(/\//g, "\\")), flavor: "windows" };
+  } else if (path5.posix.isAbsolute(trimmed)) {
+    candidate = { value: path5.posix.normalize(trimmed.replace(/\\/g, "/")), flavor: "posix" };
+  } else if (cwd.flavor === "windows") {
+    candidate = {
+      value: path5.win32.resolve(cwd.value, trimmed.replace(/\//g, "\\")),
+      flavor: "windows"
+    };
+  } else {
+    candidate = {
+      value: path5.posix.resolve(cwd.value, trimmed.replace(/\\/g, "/")),
+      flavor: "posix"
+    };
+  }
+  candidate = canonicalizeReportedPath(candidate);
+  return roots.some((root) => pathIsStrictlyInside(root, candidate)) ? candidate : null;
+}
+function canonicalizeWorkspaceRoot(root) {
+  if (!isNativePathFlavor(root.flavor)) {
+    return root;
+  }
+  return { ...root, value: canonicalizeFromExistingAncestor(root.value) };
+}
+function canonicalizeReportedPath(candidate) {
+  if (!isNativePathFlavor(candidate.flavor)) {
+    return candidate;
+  }
+  const parent = canonicalizeFromExistingAncestor(path5.dirname(candidate.value));
+  return { ...candidate, value: path5.resolve(parent, path5.basename(candidate.value)) };
+}
+function canonicalizeFromExistingAncestor(value) {
+  const original = path5.resolve(value);
+  let current = original;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const canonical = fs7.realpathSync.native(current);
+      return path5.resolve(canonical, ...missingSegments.reverse());
+    } catch (error51) {
+      if (!isMissingPathError(error51)) return original;
+    }
+    const parent = path5.dirname(current);
+    if (parent === current) return original;
+    missingSegments.push(path5.basename(current));
+    current = parent;
+  }
+}
+function isMissingPathError(error51) {
+  if (typeof error51 !== "object" || error51 === null || !("code" in error51)) return false;
+  return error51.code === "ENOENT" || error51.code === "ENOTDIR";
+}
+function isNativePathFlavor(flavor) {
+  return process.platform === "win32" ? flavor === "windows" : flavor === "posix";
+}
+function pathIsStrictlyInside(root, candidate) {
+  if (root.flavor !== candidate.flavor) {
+    return false;
+  }
+  const pathImplementation = root.flavor === "windows" ? path5.win32 : path5.posix;
+  const relative = pathImplementation.relative(root.value, candidate.value);
+  return relative.length > 0 && !pathImplementation.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${pathImplementation.sep}`);
+}
+function isWindowsAbsolutePath2(value) {
+  const portable = value.replace(/\\/g, "/");
+  return /^[A-Za-z]:\//.test(portable) || /^\/\/[^/]+\/[^/]+(?:\/|$)/.test(portable);
+}
+function isValidPathText(value) {
+  return value.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/.test(value);
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function hasOnlyKeys(value, allowed) {
+  const allowedKeys = new Set(allowed);
+  return Object.keys(value).every((key) => allowedKeys.has(key));
+}
+
 // src/CodexAcpClient.ts
 var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
 var OPENAI_PROVIDER_ID = "openai";
@@ -27153,7 +27444,7 @@ var CodexAcpClient = class {
     if (!cwd) {
       return;
     }
-    const skillExtraRoots = additionalRoots.map((root) => path5.join(root, ".agents", "skills"));
+    const skillExtraRoots = additionalRoots.map((root) => path6.join(root, ".agents", "skills"));
     if (!arraysEqual(this.skillExtraRoots, skillExtraRoots)) {
       await this.codexClient.skillsExtraRootsSet({ extraRoots: skillExtraRoots });
       this.skillExtraRoots = skillExtraRoots;
@@ -27275,6 +27566,113 @@ var CodexAcpClient = class {
       serviceTier
     }, onTurnStarted);
   }
+  async runAgentFileChangeReport(params) {
+    if (params.signal?.aborted) {
+      return createUnavailableAgentFileChangeReport(params.requestId, "cancelled");
+    }
+    const budget = new AgentFileChangeReportBudget(params.signal);
+    let forkThreadId = null;
+    let auditTurnId = null;
+    let auditTurnCompleted = false;
+    let lateStopReason = null;
+    try {
+      const forkPromise = this.codexClient.threadFork({
+        threadId: params.sessionId,
+        lastTurnId: params.turnId,
+        cwd: params.workspace.cwd,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+        developerInstructions: AGENT_FILE_CHANGE_REPORT_DEVELOPER_INSTRUCTIONS,
+        ephemeral: true
+      });
+      void forkPromise.then((fork2) => {
+        if (lateStopReason !== null && forkThreadId === null) {
+          void this.unsubscribeAgentFileChangeReportThread(fork2.thread.id, budget);
+        }
+      }, () => {
+      });
+      const fork = await budget.wait(forkPromise);
+      forkThreadId = fork.thread.id;
+      const turnPromise = this.codexClient.runTurn({
+        threadId: forkThreadId,
+        input: [{
+          type: "text",
+          text: createAgentFileChangeReportPrompt(params.workspace),
+          text_elements: []
+        }],
+        cwd: params.workspace.cwd,
+        approvalPolicy: "never",
+        sandboxPolicy: { type: "readOnly", networkAccess: false },
+        summary: "none",
+        outputSchema: AGENT_FILE_CHANGE_REPORT_OUTPUT_SCHEMA
+      }, (turnId) => {
+        auditTurnId = turnId;
+        if (lateStopReason !== null && forkThreadId !== null) {
+          void this.interruptAgentFileChangeReport(forkThreadId, turnId, lateStopReason, budget);
+        }
+      });
+      const outcome = await budget.wait(turnPromise);
+      auditTurnCompleted = true;
+      const thread = await budget.wait(this.codexClient.threadRead({
+        threadId: forkThreadId,
+        includeTurns: true
+      }));
+      const completedTurn = thread.thread.turns.find(
+        (turn) => turn.id === outcome.turn.id
+      );
+      if (completedTurn === void 0) {
+        throw new AgentFileChangeReportError(
+          "notReported",
+          "The completed audit turn was not present in thread history"
+        );
+      }
+      return createReportedAgentFileChangeReport(
+        params.requestId,
+        completedTurn,
+        params.workspace
+      );
+    } catch (error51) {
+      if (error51 instanceof AgentFileChangeReportBudgetError) {
+        lateStopReason = error51.reason;
+        if (!auditTurnCompleted && forkThreadId !== null && auditTurnId !== null) {
+          await this.interruptAgentFileChangeReport(
+            forkThreadId,
+            auditTurnId,
+            error51.reason,
+            budget
+          );
+        }
+        return createUnavailableAgentFileChangeReport(params.requestId, error51.reason);
+      }
+      if (error51 instanceof AgentFileChangeReportError) {
+        logger.log("Agent file-change report unavailable", { reason: error51.reason });
+        return createUnavailableAgentFileChangeReport(params.requestId, error51.reason);
+      }
+      logger.error("Agent file-change report failed", error51);
+      return createUnavailableAgentFileChangeReport(params.requestId, "providerError");
+    } finally {
+      if (forkThreadId !== null) {
+        await this.unsubscribeAgentFileChangeReportThread(forkThreadId, budget);
+      }
+    }
+  }
+  async interruptAgentFileChangeReport(threadId, turnId, reason, budget) {
+    this.codexClient.markTurnStale(threadId, turnId);
+    try {
+      await budget.wait(this.codexClient.turnInterrupt({ threadId, turnId }));
+    } catch (error51) {
+      logger.error(`Failed to interrupt ${reason} agent file-change report`, error51);
+    } finally {
+      this.codexClient.resolveTurnInterrupted(threadId, turnId);
+    }
+  }
+  async unsubscribeAgentFileChangeReportThread(threadId, budget) {
+    try {
+      await budget.wait(this.codexClient.threadUnsubscribe({ threadId }));
+    } catch (error51) {
+      logger.error("Failed to unsubscribe the agent file-change report thread", error51);
+    }
+  }
   async setCollaborationMode(sessionId, mode, currentModelId) {
     await this.codexClient.threadSettingsUpdate({
       threadId: sessionId,
@@ -27425,6 +27823,58 @@ var CodexAcpClient = class {
     };
   }
 };
+var AgentFileChangeReportBudgetError = class extends Error {
+  constructor(reason) {
+    super(`Agent file-change report ${reason}`);
+    this.reason = reason;
+    this.name = "AgentFileChangeReportBudgetError";
+  }
+  reason;
+};
+var AgentFileChangeReportBudget = class {
+  constructor(signal) {
+    this.signal = signal;
+  }
+  signal;
+  deadline = Date.now() + AGENT_FILE_CHANGE_REPORT_TIMEOUT_MS;
+  async wait(operation) {
+    void operation.catch(() => {
+    });
+    const immediateReason = this.stopReason();
+    if (immediateReason !== null) {
+      throw new AgentFileChangeReportBudgetError(immediateReason);
+    }
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (action) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        this.signal?.removeEventListener("abort", onAbort);
+        action();
+      };
+      const onAbort = () => finish(() => reject(new AgentFileChangeReportBudgetError("cancelled")));
+      const timeout = setTimeout(
+        () => finish(() => reject(new AgentFileChangeReportBudgetError("timeout"))),
+        Math.max(1, this.deadline - Date.now())
+      );
+      timeout.unref();
+      this.signal?.addEventListener("abort", onAbort, { once: true });
+      if (this.signal?.aborted) {
+        onAbort();
+      }
+      void operation.then(
+        (value) => finish(() => resolve(value)),
+        (error51) => finish(() => reject(error51))
+      );
+    });
+  }
+  stopReason() {
+    if (this.signal?.aborted) return "cancelled";
+    if (Date.now() >= this.deadline) return "timeout";
+    return null;
+  }
+};
 function buildPromptItems(prompt) {
   return prompt.map((block) => {
     switch (block.type) {
@@ -27484,8 +27934,8 @@ function formatUriAsLink(name, uri) {
     return `[@${name}](${uri})`;
   }
   if (uri.startsWith("file://")) {
-    const path7 = uri.replace("file://", "");
-    const fileName = path7.split("/").pop() ?? path7;
+    const path8 = uri.replace("file://", "");
+    const fileName = path8.split("/").pop() ?? path8;
     return `[@${fileName}](${uri})`;
   }
   return uri;
@@ -27515,7 +27965,7 @@ function readAdditionalDirectories(cwd, additionalDirectories, meta3) {
     if (directory.length === 0) {
       throw RequestError.invalidParams(void 0, "additionalDirectories entries must not be empty");
     }
-    if (!path5.isAbsolute(directory)) {
+    if (!path6.isAbsolute(directory)) {
       throw RequestError.invalidParams(void 0, "additionalDirectories entries must be absolute paths");
     }
     if (!seen.has(directory)) {
@@ -28118,7 +28568,7 @@ var SteeringQueue = class {
 
 // src/ResponseItemHistoryFallback.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 function historyFallbackUpdateKey(update) {
   switch (update.sessionUpdate) {
     case "user_message_chunk":
@@ -28272,14 +28722,14 @@ function parseJsonRecord(line) {
   }
   try {
     const value = JSON.parse(line);
-    return asRecord(value);
+    return asRecord2(value);
   } catch {
     return null;
   }
 }
 function extractResponseItem(record2) {
   if (record2["type"] === "response_item") {
-    return asRecord(record2["payload"]);
+    return asRecord2(record2["payload"]);
   }
   const itemType = record2["type"];
   if (typeof itemType === "string" && isLegacyResponseItemType(itemType)) {
@@ -28313,7 +28763,7 @@ function createEventMsgUpdates(record2) {
   if (record2["type"] !== "event_msg") {
     return null;
   }
-  const payload = asRecord(record2["payload"]);
+  const payload = asRecord2(record2["payload"]);
   if (!payload) {
     return [];
   }
@@ -28357,9 +28807,9 @@ function imageBlocks(images) {
     if (typeof image === "string") {
       return [{ type: "text", text: `[@image](${image})` }];
     }
-    const record2 = asRecord(image);
-    const path7 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
-    return path7 ? [{ type: "text", text: `[@image](${path7})` }] : [];
+    const record2 = asRecord2(image);
+    const path8 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
+    return path8 ? [{ type: "text", text: `[@image](${path8})` }] : [];
   });
 }
 function contentBlocksFromResponseContent(content) {
@@ -28367,7 +28817,7 @@ function contentBlocksFromResponseContent(content) {
     return [];
   }
   return content.flatMap((entry) => {
-    const record2 = asRecord(entry);
+    const record2 = asRecord2(entry);
     if (!record2) {
       return [];
     }
@@ -28400,7 +28850,7 @@ function textParts(value) {
     if (typeof entry === "string") {
       return entry.length > 0 ? [entry] : [];
     }
-    const record2 = asRecord(entry);
+    const record2 = asRecord2(entry);
     if (!record2) {
       return [];
     }
@@ -28492,7 +28942,7 @@ function parseFunctionArguments(value) {
 }
 function rawInputForFunctionCall(name, args) {
   if (name === "exec_command") {
-    const record2 = asRecord(args);
+    const record2 = asRecord2(args);
     if (record2) {
       return {
         command: stringValue(record2["cmd"]) ?? stringValue(record2["command"]),
@@ -28539,14 +28989,14 @@ function functionCallUsesTerminal(item) {
   return item["name"] === "exec_command";
 }
 function commandFromFunctionArguments(args) {
-  const record2 = asRecord(args);
+  const record2 = asRecord2(args);
   if (!record2) {
     return null;
   }
   return stringValue(record2["cmd"]) ?? stringValue(record2["command"]);
 }
 function cwdFromFunctionArguments(args) {
-  const record2 = asRecord(args);
+  const record2 = asRecord2(args);
   if (!record2) {
     return "";
   }
@@ -28991,10 +29441,10 @@ function baseCommandName(commandName) {
   return commandName.split(/[\\/]/).pop() ?? commandName;
 }
 function absolutizePath(cwd, targetPath) {
-  if (path6.isAbsolute(targetPath) || cwd.length === 0) {
+  if (path7.isAbsolute(targetPath) || cwd.length === 0) {
     return targetPath;
   }
-  return path6.join(cwd, targetPath);
+  return path7.join(cwd, targetPath);
 }
 function withTerminalContent(event, terminalId, cwd) {
   const { rawInput, ...eventWithoutRawInput } = event;
@@ -29018,7 +29468,7 @@ function outputText(output) {
     return "";
   }
   return output.flatMap((entry) => {
-    const record2 = asRecord(entry);
+    const record2 = asRecord2(entry);
     if (!record2) {
       return [];
     }
@@ -29034,7 +29484,7 @@ function outputText(output) {
   }).join("\n");
 }
 function parseExitCode(rawOutput, output) {
-  const record2 = asRecord(rawOutput);
+  const record2 = asRecord2(rawOutput);
   if (record2) {
     const exitCode2 = numberValue(record2["exit_code"]) ?? numberValue(record2["exitCode"]);
     if (exitCode2 !== null) {
@@ -29065,7 +29515,7 @@ function looksLikeCommandFailure(output) {
   }
   return /(^|\n)(Error|Failed|Command failed|Sandbox error|No such file or directory|Permission denied|Operation not permitted|ENOENT|EACCES)(:|\b)/i.test(trimmed);
 }
-function asRecord(value) {
+function asRecord2(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return null;
   }
@@ -29154,12 +29604,18 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 var IMPLEMENT_PLAN_OPTION_ID = "implement_plan";
 var REVISE_PLAN_OPTION_ID = "revise_plan";
 var CODEX_PROCESS_EXITED_ERROR_CODE = 1001;
-function clientSupportsTypedSessionFailures(capabilities) {
+function clientSupportsAirCapability(capabilities, capability) {
   const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
   const air = jetbrains?.[AIR_META_KEY];
   const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
   const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
-  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(AIR_SESSION_FAILURE_KEY);
+  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
+}
+function clientSupportsTypedSessionFailures(capabilities) {
+  return clientSupportsAirCapability(capabilities, AIR_SESSION_FAILURE_KEY);
+}
+function clientSupportsAgentFileChangeReports(capabilities) {
+  return clientSupportsAirCapability(capabilities, AIR_AGENT_FILE_CHANGE_REPORT_KEY);
 }
 var CodexAcpServer = class _CodexAcpServer {
   static MODEL_NAME_TOKEN_OVERRIDES = {
@@ -29264,7 +29720,10 @@ var CodexAcpServer = class _CodexAcpServer {
         [JETBRAINS_META_KEY]: {
           [AIR_META_KEY]: {
             [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
-            [AIR_EXTENSION_CAPABILITIES_KEY]: [AIR_SESSION_FAILURE_KEY]
+            [AIR_EXTENSION_CAPABILITIES_KEY]: [
+              AIR_SESSION_FAILURE_KEY,
+              AIR_AGENT_FILE_CHANGE_REPORT_KEY
+            ]
           }
         }
       }
@@ -30315,6 +30774,42 @@ Check ${configPath} and project .codex directories, especially their config.toml
       title
     });
   }
+  async publishAgentFileChangeReport(sessionState, turnId, request, unavailableReason, signal) {
+    let report;
+    try {
+      report = turnId === null ? createUnavailableAgentFileChangeReport(request.requestId, unavailableReason) : await this.codexAcpClient.runAgentFileChangeReport({
+        sessionId: sessionState.sessionId,
+        turnId,
+        // The client owns request-id correlation and duplicate suppression. The wrapper
+        // stays stateless so a retried ACP prompt still receives a terminal report.
+        requestId: request.requestId,
+        workspace: {
+          cwd: sessionState.cwd,
+          additionalDirectories: sessionState.additionalDirectories
+        },
+        signal
+      });
+    } catch (error51) {
+      logger.error("Agent file-change report failed unexpectedly", error51);
+      report = createUnavailableAgentFileChangeReport(request.requestId, "providerError");
+    }
+    try {
+      const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+      await session.update({
+        sessionUpdate: "session_info_update",
+        _meta: {
+          [JETBRAINS_META_KEY]: {
+            [AIR_META_KEY]: {
+              [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
+              [AIR_AGENT_FILE_CHANGE_REPORT_KEY]: report
+            }
+          }
+        }
+      });
+    } catch (error51) {
+      logger.error("Failed to publish agent file-change report", error51);
+    }
+  }
   createPromptFallbackTitle(prompt) {
     return this.normalizeSessionTitle(prompt.filter((block) => block.type === "text").map((block) => block.text).join(" "));
   }
@@ -30449,8 +30944,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return `[@${name}](${uri})`;
     }
     if (uri.startsWith("file://")) {
-      const path7 = uri.replace("file://", "");
-      const fileName = path7.split("/").pop() ?? path7;
+      const path8 = uri.replace("file://", "");
+      const fileName = path8.split("/").pop() ?? path8;
       return `[@${fileName}](${uri})`;
     }
     return uri;
@@ -30703,6 +31198,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
       prompt: params.prompt
     });
     const sessionState = this.getSessionState(params.sessionId);
+    const agentFileChangeReportRequest = clientSupportsAgentFileChangeReports(this.clientCapabilities) ? parseAgentFileChangeReportRequest(params._meta) : null;
+    let agentFileChangeReportTurnId = null;
+    let agentFileChangeReportUnavailableReason = "providerError";
     let recoverableSessionFailure = sessionState.sessionFailure;
     sessionState.currentTurnId = null;
     sessionState.lastTokenUsage = null;
@@ -30725,6 +31223,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
         await handler.clearSessionFailure();
       }
     };
+    const cancelledPromptResponse = () => {
+      agentFileChangeReportTurnId = null;
+      agentFileChangeReportUnavailableReason = "cancelled";
+      return this.cancelledPromptResponse(sessionState);
+    };
     try {
       const promptEventHandler = new CodexEventHandler(
         this.connection,
@@ -30759,7 +31262,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         elicitationHandler
       );
       if (activePrompt.signal.aborted) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
         onTurnStartPending: () => {
@@ -30800,7 +31303,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         this.cancelBeforeTurnStarted(activePrompt)
       ]);
       if (commandResult === null) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       if (commandResult.handled) {
         promptNotificationsActive = false;
@@ -30812,7 +31315,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           await eventHandler.handleFailedTurn(commandResult.turnCompleted.turn);
         }
         if (commandResult.turnCompleted?.turn.status === "interrupted") {
-          return this.cancelledPromptResponse(sessionState);
+          return cancelledPromptResponse();
         }
         const error52 = eventHandler.getFailure();
         if (error52) {
@@ -30826,6 +31329,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
         if (terminalFailure2) {
           return terminalFailure2;
         }
+        if (commandResult.turnCompleted?.turn.status === "completed") {
+          agentFileChangeReportTurnId = commandResult.turnCompleted.turn.id;
+        } else if (commandResult.turnCompleted === void 0) {
+          agentFileChangeReportUnavailableReason = "notReported";
+        }
         await clearRecoveredSessionFailure(eventHandler);
         return {
           stopReason: "end_turn",
@@ -30835,7 +31343,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
       const effectiveParams = commandResult.prompt === void 0 ? params : { ...params, prompt: commandResult.prompt };
       if (this.sessionIsClosing(params.sessionId)) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       const modelId = ModelId.fromString(sessionState.currentModelId);
       const modelLacksReasoning = sessionState.supportedReasoningEfforts.length > 0 && sessionState.supportedReasoningEfforts.every((e) => e.reasoningEffort === "none");
@@ -30889,7 +31397,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         this.cancelBeforeTurnStarted(activePrompt)
       ]);
       if (turnCompleted === null) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       await eventHandler.flushPendingErrors();
@@ -30897,7 +31405,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       promptNotificationsActive = false;
       if (turnCompleted.turn.status === "interrupted") {
         await eventHandler.flushPendingPlanUpdates();
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
       const error51 = eventHandler.getFailure();
       if (error51) {
@@ -30920,7 +31428,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           activePrompt.signal
         );
         if (this.promptShouldStop(params.sessionId, activePrompt)) {
-          return this.cancelledPromptResponse(sessionState);
+          return cancelledPromptResponse();
         }
         if (approved && !this.promptShouldStop(params.sessionId, activePrompt)) {
           await this.applyCollaborationModeChange(sessionState, DEFAULT_COLLABORATION_MODE);
@@ -30969,7 +31477,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             this.cancelBeforeTurnStarted(activePrompt)
           ]);
           if (turnCompleted === null) {
-            return this.cancelledPromptResponse(sessionState);
+            return cancelledPromptResponse();
           }
           await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
           await eventHandler.flushPendingErrors();
@@ -30977,7 +31485,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           promptNotificationsActive = false;
           if (turnCompleted.turn.status === "interrupted") {
             await eventHandler.flushPendingPlanUpdates();
-            return this.cancelledPromptResponse(sessionState);
+            return cancelledPromptResponse();
           }
           const implementationError = eventHandler.getFailure();
           if (implementationError) {
@@ -30993,6 +31501,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
           }
         }
       }
+      if (turnCompleted.turn.status === "completed") {
+        agentFileChangeReportTurnId = turnCompleted.turn.id;
+      }
       await clearRecoveredSessionFailure(eventHandler);
       await this.publishFallbackSessionTitle(
         sessionState,
@@ -31006,8 +31517,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
     } catch (err) {
       logger.error(`Prompt for session ${params.sessionId} failed`, err);
       if (activePrompt.signal.aborted || this.sessionIsClosing(params.sessionId)) {
-        return this.cancelledPromptResponse(sessionState);
+        return cancelledPromptResponse();
       }
+      agentFileChangeReportTurnId = null;
+      agentFileChangeReportUnavailableReason = "providerError";
       const isProcessExit = err instanceof RequestError && err.code === CODEX_PROCESS_EXITED_ERROR_CODE;
       const isUnexpectedFailure = !(err instanceof RequestError);
       if (eventHandler !== null && clientSupportsTypedSessionFailures(this.clientCapabilities) && (isProcessExit || isUnexpectedFailure)) {
@@ -31028,6 +31541,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
       throw err;
     } finally {
       promptNotificationsActive = false;
+      if (agentFileChangeReportRequest !== null) {
+        await this.publishAgentFileChangeReport(
+          sessionState,
+          agentFileChangeReportTurnId,
+          agentFileChangeReportRequest,
+          agentFileChangeReportUnavailableReason,
+          activePrompt.signal
+        );
+      }
       logger.log("Prompt completed", { sessionId: params.sessionId });
       await eventHandler?.dispose();
       disposePromptRequestCancellation();
@@ -31590,6 +32112,9 @@ var CodexAppServerClient = class {
   async threadResume(params) {
     return await this.sendRequest({ method: "thread/resume", params });
   }
+  async threadFork(params) {
+    return await this.sendRequest({ method: "thread/fork", params });
+  }
   getThreadSettings(threadId) {
     return this.threadSettings.get(threadId);
   }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "",
   "main": "dist/index.js",
   "bin": {