@agentclientprotocol/codex-acp 1.6.0 → 1.7.0

package/dist/index.js

@@ -3453,7 +3453,7 @@ var require_main = __commonJS({
     exports.createMessageConnection = createMessageConnection2;
     var ril_1 = __importDefault(require_ril());
     ril_1.default.install();
-    var path8 = __importStar(__require("path"));
+    var path9 = __importStar(__require("path"));
     var os2 = __importStar(__require("os"));
     var fs8 = __importStar(__require("fs"));
     var crypto_1 = __require("crypto");
@@ -3462,9 +3462,9 @@ var require_main = __commonJS({
     __exportStar(require_api(), exports);
     var IPCMessageReader = class extends api_1.AbstractMessageReader {
       process;
-      constructor(process10) {
+      constructor(process12) {
         super();
-        this.process = process10;
+        this.process = process12;
         const eventEmitter = this.process;
         eventEmitter.on("error", (error51) => this.fireError(error51));
         eventEmitter.on("close", () => this.fireClose());
@@ -3478,9 +3478,9 @@ var require_main = __commonJS({
     var IPCMessageWriter = class extends api_1.AbstractMessageWriter {
       process;
       errorCount;
-      constructor(process10) {
+      constructor(process12) {
         super();
-        this.process = process10;
+        this.process = process12;
         this.errorCount = 0;
         const eventEmitter = this.process;
         eventEmitter.on("error", (error51) => this.fireError(error51));
@@ -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 path8.join(tmpDir, `lsp-${randomSuffix}.sock`);
+      return path9.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, path8) {
-  if (!path8)
+function getElementAtPath(obj, path9) {
+  if (!path9)
     return obj;
-  return path8.reduce((acc, key) => acc?.[key], obj);
+  return path9.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(path8, issues) {
+function prefixIssues(path9, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path8);
+    iss.path.unshift(path9);
     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, path8 = []) => {
+  const processError = (error52, path9 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path9, ...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, path8 = []) => {
+  const processError = (error52, path9 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path9, ...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 path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path8) {
+  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path9) {
     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 path8 = ref.slice(1).split("/").filter(Boolean);
-  if (path8.length === 0) {
+  const path9 = ref.slice(1).split("/").filter(Boolean);
+  if (path9.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path8[0] === defsKey) {
-    const key = path8[1];
+  if (path9[0] === defsKey) {
+    const key = path9[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18856,21 +18856,6 @@ var zAgentCapabilities = object({
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
 var zAuthMethodId = string2();
-var zAuthEnvVar = object({
-  name: string2(),
-  label: defaultOnError(string2().nullish(), () => void 0),
-  secret: defaultOnError(boolean2().optional().default(true), () => true),
-  optional: defaultOnError(boolean2().optional().default(false), () => false),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
-});
-var zAuthMethodEnvVar = object({
-  id: zAuthMethodId,
-  name: string2(),
-  description: defaultOnError(string2().nullish(), () => void 0),
-  vars: requiredDefaultOnError(vecSkipError(zAuthEnvVar), () => []),
-  link: defaultOnError(string2().nullish(), () => void 0),
-  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
-});
 var zAuthMethodTerminal = object({
   id: zAuthMethodId,
   name: string2(),
@@ -18886,9 +18871,6 @@ var zAuthMethodAgent = object({
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
 var zAuthMethod = union([
-  zAuthMethodEnvVar.and(object({
-    type: literal("env_var")
-  })),
   zAuthMethodTerminal.and(object({
     type: literal("terminal")
   })),
@@ -19339,6 +19321,26 @@ var zUsageUpdate = object({
   cost: defaultOnError(zCost.nullish(), () => void 0),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
+var zCompactionId = string2();
+var zCompactionStatus = union([
+  literal("in_progress"),
+  literal("completed"),
+  literal("failed"),
+  literal("cancelled"),
+  string2()
+]);
+var zCompactionUpdate = object({
+  compactionId: zCompactionId,
+  status: zCompactionStatus,
+  summary: defaultOnError(vecSkipError(zContentBlock).nullish(), () => void 0),
+  error: defaultOnError(string2().nullish(), () => void 0),
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
+});
+var zCompactionSummaryChunk = object({
+  compactionId: zCompactionId,
+  content: zContentBlock,
+  _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
+});
 var zSessionUpdate = union([
   zContentChunk.and(object({
     sessionUpdate: literal("user_message_chunk")
@@ -19378,6 +19380,12 @@ var zSessionUpdate = union([
   })),
   zUsageUpdate.and(object({
     sessionUpdate: literal("usage_update")
+  })),
+  zCompactionUpdate.and(object({
+    sessionUpdate: literal("compaction_update")
+  })),
+  zCompactionSummaryChunk.and(object({
+    sessionUpdate: literal("compaction_summary_chunk")
   }))
 ]);
 var zSessionNotification = object({
@@ -19410,6 +19418,7 @@ var zFileSystemCapabilities = object({
   writeTextFile: defaultOnError(boolean2().optional().default(false), () => false),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
+var zCompactionCapabilities = record(string2(), unknown());
 var zBooleanConfigOptionCapabilities = object({
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
@@ -19418,6 +19427,7 @@ var zSessionConfigOptionsCapabilities = object({
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
 var zClientSessionCapabilities = object({
+  compaction: defaultOnError(zCompactionCapabilities.nullish(), () => void 0),
   configOptions: defaultOnError(zSessionConfigOptionsCapabilities.nullish(), () => void 0),
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
@@ -20096,6 +20106,7 @@ var RequestResponder = class {
     });
   }
 };
+var requestBatchSizes = /* @__PURE__ */ new WeakMap();
 var HandlerRegistration = class {
   disposeHandler;
   active = true;
@@ -20446,9 +20457,6 @@ var Connection = class {
           if (done) {
             break;
           }
-          if (!message) {
-            continue;
-          }
           this.receiveWireMessage(message);
         }
       } finally {
@@ -20472,19 +20480,16 @@ var Connection = class {
       this.receiveBatch(message);
       return;
     }
-    if (!isRecord(message)) {
-      console.error("Invalid message", { message });
+    if (!isRequestMessage(message) && !isNotificationMessage(message) && !isResponseShapedMessage(message)) {
+      void this.sendWireMessage(protocolErrorResponse(RequestError.invalidRequest(message))).catch(() => {
+      });
       return;
     }
     this.receiveMessage(message);
   }
   receiveBatch(batch) {
     if (batch.length === 0) {
-      void this.sendWireMessage({
-        jsonrpc: "2.0",
-        id: null,
-        error: RequestError.invalidRequest(batch).toErrorResponse()
-      }).catch(() => {
+      void this.sendWireMessage(protocolErrorResponse(RequestError.invalidRequest(batch))).catch(() => {
       });
       return;
     }
@@ -20514,15 +20519,11 @@ var Connection = class {
         continue;
       }
       if (!isRequestMessage(message) && !isNotificationMessage(message)) {
-        void collectResponse({
-          jsonrpc: "2.0",
-          id: null,
-          error: RequestError.invalidRequest(message).toErrorResponse()
-        }).catch(() => {
+        void collectResponse(protocolErrorResponse(RequestError.invalidRequest(message))).catch(() => {
         });
         continue;
       }
-      const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : void 0);
+      const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : void 0, batch.length);
       if (isNotificationMessage(message)) {
         void processing.finally(() => {
           remainingNotifications -= 1;
@@ -20531,7 +20532,7 @@ var Connection = class {
       }
     }
   }
-  receiveMessage(message, sendResponse) {
+  receiveMessage(message, sendResponse, batchSize) {
     if (this.abortController.signal.aborted) {
       return Promise.resolve();
     }
@@ -20543,7 +20544,7 @@ var Connection = class {
       if (!("id" in message)) {
         this.handleProtocolNotification(message);
       }
-      return this.processIncomingMessage(this.toIncomingMessage(message, sendResponse)).catch((error51) => this.close(error51));
+      return this.processIncomingMessage(this.toIncomingMessage(message, sendResponse, batchSize)).catch((error51) => this.close(error51));
     } else if ("id" in message) {
       this.handleResponse(message);
     } else {
@@ -20593,7 +20594,7 @@ var Connection = class {
       }
     }
   }
-  toIncomingMessage(message, sendResponse) {
+  toIncomingMessage(message, sendResponse, batchSize) {
     if ("id" in message) {
       const abortController = new AbortController();
       this.incomingRequests.set(message.id, abortController);
@@ -20602,20 +20603,24 @@ var Connection = class {
           this.incomingRequests.delete(message.id);
         }
       };
+      const responder = new RequestResponder(message.id, (result) => {
+        const response = {
+          jsonrpc: "2.0",
+          id: message.id,
+          ...result
+        };
+        return sendResponse ? sendResponse(response) : this.sendWireMessage(response);
+      }, abortController.signal, finishRequest);
+      if (batchSize !== void 0) {
+        requestBatchSizes.set(responder, batchSize);
+      }
       return {
         kind: "request",
         method: message.method,
         params: message.params,
         raw: message,
         signal: abortController.signal,
-        responder: new RequestResponder(message.id, (result) => {
-          const response = {
-            jsonrpc: "2.0",
-            id: message.id,
-            ...result
-          };
-          return sendResponse ? sendResponse(response) : this.sendWireMessage(response);
-        }, abortController.signal, finishRequest)
+        responder
       };
     }
     return {
@@ -20837,6 +20842,13 @@ var RequestError = class _RequestError extends Error {
     };
   }
 };
+function protocolErrorResponse(error51) {
+  return {
+    jsonrpc: "2.0",
+    id: null,
+    error: error51.toErrorResponse()
+  };
+}
 
 // node_modules/@agentclientprotocol/sdk/dist/line-buffer.js
 var newline = 10;
@@ -20897,22 +20909,40 @@ function ndJsonStream(output, input) {
   const textDecoder = new TextDecoder();
   let cancelled = false;
   let inputReader;
+  let outputWrite = Promise.resolve();
+  const writeJson = (message) => {
+    const content = JSON.stringify(message) + "\n";
+    const write = outputWrite.then(async () => {
+      const writer = output.getWriter();
+      try {
+        await writer.write(textEncoder.encode(content));
+      } finally {
+        writer.releaseLock();
+      }
+    });
+    outputWrite = write.catch(() => {
+    });
+    return write;
+  };
   const readable = new ReadableStream({
     async start(controller) {
       const lines = new LineBuffer();
-      const enqueueLine = (lineBytes) => {
+      const enqueueLine = async (lineBytes) => {
         const trimmedLine = textDecoder.decode(lineBytes).trim();
-        if (trimmedLine) {
-          try {
-            const message = JSON.parse(trimmedLine);
-            if (isRecord(message) || Array.isArray(message)) {
-              controller.enqueue(message);
-            } else {
-              console.warn("Skipping JSON line that is not an object:", trimmedLine);
-            }
-          } catch (err) {
-            console.error("Failed to parse JSON message:", trimmedLine, err);
-          }
+        if (!trimmedLine) {
+          return;
+        }
+        let message;
+        try {
+          message = JSON.parse(trimmedLine);
+        } catch {
+          await writeJson(protocolErrorResponse(RequestError.parseError()));
+          return;
+        }
+        if (isRecord(message) || Array.isArray(message)) {
+          controller.enqueue(message);
+        } else {
+          await writeJson(protocolErrorResponse(RequestError.invalidRequest(message)));
         }
       };
       const reader = input.getReader();
@@ -20930,7 +20960,7 @@ function ndJsonStream(output, input) {
             continue;
           }
           for (const line of lines.push(value)) {
-            enqueueLine(line);
+            await enqueueLine(line);
             if (cancelled) {
               return;
             }
@@ -20941,7 +20971,7 @@ function ndJsonStream(output, input) {
         }
         const lastLine = lines.flush();
         if (lastLine) {
-          enqueueLine(lastLine);
+          await enqueueLine(lastLine);
         }
       } catch (err) {
         if (cancelled) {
@@ -20966,14 +20996,8 @@ function ndJsonStream(output, input) {
     }
   });
   const writable = new WritableStream({
-    async write(message) {
-      const content = JSON.stringify(message) + "\n";
-      const writer = output.getWriter();
-      try {
-        await writer.write(textEncoder.encode(content));
-      } finally {
-        writer.releaseLock();
-      }
+    write(message) {
+      return writeJson(message);
     }
   });
   return { readable, writable };
@@ -21592,11 +21616,11 @@ var clientRequestSpecs = {
   releaseTerminal: requestSpec(CLIENT_METHODS.terminal_release, zReleaseTerminalRequest, emptyObjectResponse),
   waitForTerminalExit: requestSpec(CLIENT_METHODS.terminal_wait_for_exit, zWaitForTerminalExitRequest),
   killTerminal: requestSpec(CLIENT_METHODS.terminal_kill, zKillTerminalRequest, emptyObjectResponse),
-  unstable_createElicitation: requestSpec(CLIENT_METHODS.elicitation_create, zCreateElicitationRequest)
+  createElicitation: requestSpec(CLIENT_METHODS.elicitation_create, zCreateElicitationRequest)
 };
 var clientNotificationSpecs = {
   sessionUpdate: notificationSpec(CLIENT_METHODS.session_update, zSessionNotification),
-  unstable_completeElicitation: notificationSpec(CLIENT_METHODS.elicitation_complete, zCompleteElicitationNotification)
+  completeElicitation: notificationSpec(CLIENT_METHODS.elicitation_complete, zCompleteElicitationNotification)
 };
 var agentRequestSpecsByMethod = specsByMethod(agentRequestSpecs);
 var agentNotificationSpecsByMethod = specsByMethod(agentNotificationSpecs);
@@ -22021,7 +22045,12 @@ var Logger = class {
     }
   }
   error(message, err) {
-    this.log(`[SYSTEM_ERROR] ${message}`, { exception: this.formatError(err) });
+    const formattedError = this.formatError(err);
+    if (!this.logFilePath) {
+      console.error(`[SYSTEM_ERROR] ${message}: ${formattedError}`);
+      return;
+    }
+    this.log(`[SYSTEM_ERROR] ${message}`, { exception: formattedError });
   }
   log(message, context) {
     if (!this.logFilePath) return;
@@ -22102,6 +22131,36 @@ function attachLogs(proc) {
   });
 }
 
+// src/AirExtension.ts
+var JETBRAINS_META_KEY = "jetbrains";
+var AIR_META_KEY = "air";
+var AIR_EXTENSION_VERSION_KEY = "version";
+var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
+var AIR_SESSION_FAILURE_KEY = "sessionFailure";
+var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
+var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
+var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
+var AIR_EXTENSION_VERSION = 1;
+function clientSupportsAirCapability(capabilities, capability) {
+  const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
+  const air = jetbrains?.[AIR_META_KEY];
+  const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
+  const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
+  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
+}
+
+// src/subagents/AcpSubagents.ts
+function clientSupportsSubagents(capabilities) {
+  const subagents = capabilities?.subagents;
+  if (typeof subagents === "object" && subagents !== null && !Array.isArray(subagents)) {
+    return true;
+  }
+  return clientSupportsAirCapability(capabilities, AIR_NATIVE_SUBAGENT_SESSIONS_KEY);
+}
+function asSdkSessionNotification(notification) {
+  return notification;
+}
+
 // src/ACPSessionConnection.ts
 var ACPSessionConnection = class {
   connection;
@@ -22110,11 +22169,11 @@ var ACPSessionConnection = class {
     this.connection = connection;
     this.sessionId = sessionId;
   }
-  async update(update) {
-    await this.connection.notify(methods.client.session.update, {
-      sessionId: this.sessionId,
+  async update(update, sessionId = this.sessionId) {
+    await this.connection.notify(methods.client.session.update, asSdkSessionNotification({
+      sessionId,
       update
-    });
+    }));
   }
 };
 
@@ -23248,13 +23307,13 @@ function createTerminalCommandEvent(event, terminalId, cwd) {
     }
   };
 }
-function createSearchTitle(query, path8) {
-  if (query && path8) {
-    return `Search for '${query}' in ${path8}`;
+function createSearchTitle(query, path9) {
+  if (query && path9) {
+    return `Search for '${query}' in ${path9}`;
   } else if (query) {
     return `Search for '${query}'`;
-  } else if (path8) {
-    return `Search in '${path8}'`;
+  } else if (path9) {
+    return `Search in '${path9}'`;
   }
   return "Search";
 }
@@ -23480,12 +23539,12 @@ function revertPatch(unifiedDiff) {
   if (!patch) return null;
   return reversePatch(patch);
 }
-function createUpdateDiffContent(path8, oldText, newText) {
+function createUpdateDiffContent(path9, oldText, newText) {
   return {
     type: "diff",
     oldText,
     newText,
-    path: path8,
+    path: path9,
     _meta: {
       kind: "update"
     }
@@ -23612,15 +23671,380 @@ function sameThreadGoalSnapshot(left, right) {
 // src/CodexEventHandler.ts
 import { randomUUID } from "node:crypto";
 
-// src/AirExtension.ts
-var JETBRAINS_META_KEY = "jetbrains";
-var AIR_META_KEY = "air";
-var AIR_EXTENSION_VERSION_KEY = "version";
-var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
-var AIR_SESSION_FAILURE_KEY = "sessionFailure";
-var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
-var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
-var AIR_EXTENSION_VERSION = 1;
+// src/subagents/CodexAgentPath.ts
+function normalizeAgentPath(path9) {
+  const normalized = path9.trim().replace(/\/+$/, "");
+  return normalized || "/root";
+}
+function isRootAgentPath(path9) {
+  const normalized = normalizeAgentPath(path9);
+  return normalized === "/root" || normalized === "root";
+}
+function nameFromAgentPath(path9, fallback) {
+  const normalized = normalizeAgentPath(path9);
+  const name = normalized.slice(normalized.lastIndexOf("/") + 1).trim();
+  if (!name) return fallback;
+  const words = name.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+  return words ? words.charAt(0).toUpperCase() + words.slice(1) : fallback;
+}
+
+// src/subagents/CodexSubagentEventRouter.ts
+var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
+  constructor(rootSessionId, supported, session) {
+    this.rootSessionId = rootSessionId;
+    this.supported = supported;
+    this.session = session;
+  }
+  rootSessionId;
+  supported;
+  session;
+  static DEFAULT_WAIT_TIMEOUT_MS = 10 * 60 * 1e3;
+  static MAX_PENDING_NOTIFICATIONS = 256;
+  children = /* @__PURE__ */ new Map();
+  pendingSpawns = /* @__PURE__ */ new Map();
+  terminalPendingSpawns = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Set();
+  materializationWaiters = /* @__PURE__ */ new Map();
+  replayQueue = [];
+  activeLegacyActivities = /* @__PURE__ */ new Set();
+  async handle(notification) {
+    if (notification.method === "turn/started") {
+      return this.isKnownChild(notification.params.threadId);
+    }
+    if (notification.method === "turn/completed") {
+      const childTurn = this.isKnownChild(notification.params.threadId);
+      const state = terminalStateFromTurn(notification.params.turn.status);
+      if (!state) return childTurn;
+      if (notification.params.threadId === this.rootSessionId) {
+        if (state !== "completed") await this.finishOutstanding(state);
+      } else {
+        if (this.pendingSpawns.has(notification.params.threadId)) {
+          this.finishPending(notification.params.threadId);
+        } else {
+          await this.finish(notification.params.threadId, state);
+        }
+      }
+      return childTurn;
+    }
+    const notificationThreadId = notification.params.threadId;
+    if (typeof notificationThreadId === "string" && this.pendingSpawns.has(notificationThreadId)) {
+      const pending = this.pendingSpawns.get(notificationThreadId);
+      if (pending.buffered.length === _CodexSubagentEventRouter.MAX_PENDING_NOTIFICATIONS) {
+        pending.buffered.shift();
+        pending.droppedBufferedNotifications += 1;
+        if (pending.droppedBufferedNotifications === 1) {
+          logger.log(`Pending subagent ${notificationThreadId} exceeded the notification buffer; dropping oldest updates`);
+        }
+      }
+      pending.buffered.push(notification);
+      return true;
+    }
+    if (notification.method !== "item/started" && notification.method !== "item/completed") {
+      return false;
+    }
+    const item = notification.params.item;
+    if (!this.supported) {
+      return false;
+    }
+    if (item.type === "subAgentActivity") {
+      if (isRootAgentPath(item.agentPath)) return true;
+      if (this.terminalPendingSpawns.has(item.agentThreadId)) return true;
+      let hasNativeRepresentation = this.children.has(item.agentThreadId);
+      if (!hasNativeRepresentation) {
+        await this.materialize(item.agentThreadId, item.agentPath);
+        hasNativeRepresentation = this.children.has(item.agentThreadId);
+      }
+      if (hasNativeRepresentation && item.kind === "interrupted") {
+        await this.finish(item.agentThreadId, "cancelled");
+      }
+      return hasNativeRepresentation;
+    }
+    if (item.type !== "collabAgentToolCall") return false;
+    if (item.tool === "resumeAgent" || item.tool === "sendInput") {
+      for (const [childThreadId, state] of Object.entries(item.agentsStates)) {
+        if (state?.status === "running" || state?.status === "pendingInit") {
+          await this.reopen(childThreadId);
+        }
+      }
+    }
+    let representedSpawn = false;
+    if (item.tool === "spawnAgent") {
+      const parent = this.children.get(item.senderThreadId);
+      const parentThreadId = parent ? item.senderThreadId : this.rootSessionId;
+      const parentSessionId = parent?.sessionId ?? this.rootSessionId;
+      for (const childSessionId of item.receiverThreadIds) {
+        if (childSessionId.trim().length === 0) {
+          logger.log("Ignoring spawned subagent with an empty thread id");
+          continue;
+        }
+        if (childSessionId === parentSessionId || childSessionId === this.rootSessionId) {
+          logger.log(`Ignoring self-referential spawned subagent ${childSessionId}`);
+          continue;
+        }
+        if (this.children.has(childSessionId) || this.pendingSpawns.has(childSessionId) || this.terminalPendingSpawns.has(childSessionId)) {
+          representedSpawn = true;
+          continue;
+        }
+        this.pendingSpawns.set(childSessionId, {
+          parentThreadId,
+          parentSessionId,
+          task: item.prompt?.trim() || "Delegated task",
+          buffered: [],
+          droppedBufferedNotifications: 0
+        });
+        representedSpawn = true;
+      }
+    }
+    for (const [childSessionId, state] of Object.entries(item.agentsStates)) {
+      const terminalState = state && terminalStateOf(state.status);
+      if (!terminalState) continue;
+      if (this.children.has(childSessionId)) await this.finish(childSessionId, terminalState);
+      else if (this.pendingSpawns.has(childSessionId)) this.finishPending(childSessionId);
+    }
+    if (item.tool === "spawnAgent" && item.status === "failed") {
+      for (const childSessionId of item.receiverThreadIds) {
+        if (this.pendingSpawns.has(childSessionId)) this.finishPending(childSessionId);
+      }
+    }
+    return item.tool === "spawnAgent" && representedSpawn;
+  }
+  shouldIgnore(notification) {
+    const threadId = notification.params.threadId;
+    const ignored = typeof threadId === "string" && (this.children.get(threadId)?.terminalState !== void 0 || this.terminalPendingSpawns.has(threadId));
+    if (ignored) logger.log(`Ignoring update for terminal subagent ${threadId}`);
+    return ignored;
+  }
+  notificationSessionId(notification) {
+    const threadId = notification.params.threadId;
+    return typeof threadId === "string" && this.children.has(threadId) ? this.children.get(threadId).sessionId : this.rootSessionId;
+  }
+  takeBufferedNotifications() {
+    return this.replayQueue.splice(0);
+  }
+  async waitForMaterializedSession(childThreadId) {
+    const child = this.children.get(childThreadId);
+    if (child) return child.terminalState === void 0 ? child.sessionId : null;
+    if (this.terminalPendingSpawns.has(childThreadId)) return null;
+    if (!this.pendingSpawns.has(childThreadId)) return null;
+    return await new Promise((resolve) => {
+      const waiters = this.materializationWaiters.get(childThreadId) ?? /* @__PURE__ */ new Set();
+      waiters.add(resolve);
+      this.materializationWaiters.set(childThreadId, waiters);
+    });
+  }
+  legacyActivityStarted(item) {
+    this.activeLegacyActivities.add(item.id);
+    return createSubAgentActivityUpdate(item, "in_progress", "tool_call");
+  }
+  legacyCollaborationStarted(item) {
+    return createCollabAgentToolCallUpdate(item);
+  }
+  legacyCollaborationCompleted(item) {
+    return createCollabAgentToolCallCompleteUpdate(item);
+  }
+  legacyActivityCompleted(item) {
+    const sessionUpdate = this.activeLegacyActivities.delete(item.id) ? "tool_call_update" : "tool_call";
+    return createSubAgentActivityUpdate(item, "completed", sessionUpdate);
+  }
+  async wait(signal, timeoutMs = _CodexSubagentEventRouter.DEFAULT_WAIT_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (this.hasOutstanding()) {
+      if (signal.aborted) return;
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        logger.log(`Timed out waiting for subagents in session ${this.rootSessionId}; marking them failed`);
+        await this.finishOutstanding("failed");
+        return;
+      }
+      const changed = await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          this.waiters.delete(onChange);
+          signal.removeEventListener("abort", onAbort);
+          resolve(false);
+        }, remainingMs);
+        const onAbort = () => {
+          clearTimeout(timeout);
+          this.waiters.delete(onChange);
+          resolve(true);
+        };
+        const onChange = () => {
+          clearTimeout(timeout);
+          signal.removeEventListener("abort", onAbort);
+          resolve(true);
+        };
+        this.waiters.add(onChange);
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      if (!changed) {
+        logger.log(`Timed out waiting for subagents in session ${this.rootSessionId}; marking them failed`);
+        await this.finishOutstanding("failed");
+        return;
+      }
+    }
+  }
+  async finishOutstanding(state) {
+    for (const childSessionId of [...this.pendingSpawns.keys()]) {
+      this.finishPending(childSessionId);
+    }
+    for (const childSessionId of [...this.children.keys()].reverse()) {
+      await this.finish(childSessionId, state);
+    }
+  }
+  isKnownChild(threadId) {
+    return threadId !== this.rootSessionId && (this.children.has(threadId) || this.pendingSpawns.has(threadId) || this.terminalPendingSpawns.has(threadId));
+  }
+  async materialize(childSessionId, path9) {
+    if (this.children.has(childSessionId)) return;
+    const pending = this.pendingSpawns.get(childSessionId);
+    const name = nameFromAgentPath(path9, fallbackName(childSessionId));
+    const inferredParent = this.parentForPath(path9);
+    const parentThreadId = pending?.parentThreadId ?? inferredParent.threadId;
+    const parentSessionId = pending?.parentSessionId ?? inferredParent.sessionId;
+    const task = pending?.task ?? `Delegated task for ${name}`;
+    await this.session.update({
+      sessionUpdate: "subagent_spawned",
+      subagentSessionId: childSessionId,
+      name,
+      task,
+      capabilities: {}
+    }, parentSessionId);
+    this.children.set(childSessionId, {
+      parentThreadId,
+      parentSessionId,
+      sessionId: childSessionId,
+      name,
+      task,
+      path: normalizeAgentPath(path9),
+      generation: 1
+    });
+    this.pendingSpawns.delete(childSessionId);
+    this.replayQueue.push(...pending?.buffered ?? []);
+    this.resolveMaterialization(childSessionId, childSessionId);
+  }
+  finishPending(childSessionId) {
+    const pending = this.pendingSpawns.get(childSessionId);
+    if (!pending) return;
+    this.pendingSpawns.delete(childSessionId);
+    this.terminalPendingSpawns.set(childSessionId, pending);
+    this.resolveMaterialization(childSessionId, null);
+    this.notifyWaiters();
+  }
+  async finish(childSessionId, state) {
+    const child = this.children.get(childSessionId);
+    if (!child || child.terminalState !== void 0) return;
+    child.terminalState = state;
+    try {
+      await this.session.update({
+        sessionUpdate: "subagent_state_update",
+        subagentSessionId: child.sessionId,
+        state
+      }, child.parentSessionId);
+    } catch (error51) {
+      if (child.terminalState === state) delete child.terminalState;
+      throw error51;
+    }
+    this.notifyWaiters();
+  }
+  async reopen(childThreadId) {
+    const child = this.children.get(childThreadId);
+    if (!child) {
+      const pending = this.terminalPendingSpawns.get(childThreadId);
+      if (!pending) return;
+      const parentSessionId = this.children.get(pending.parentThreadId)?.sessionId ?? this.rootSessionId;
+      const reopened = {
+        parentThreadId: pending.parentThreadId,
+        parentSessionId,
+        sessionId: `${childThreadId}:generation:2`,
+        name: fallbackName(childThreadId),
+        task: pending.task,
+        generation: 2
+      };
+      await this.session.update({
+        sessionUpdate: "subagent_spawned",
+        subagentSessionId: reopened.sessionId,
+        name: reopened.name,
+        task: reopened.task,
+        capabilities: {}
+      }, parentSessionId);
+      this.children.set(childThreadId, reopened);
+      this.terminalPendingSpawns.delete(childThreadId);
+      return;
+    }
+    if (!child.terminalState) return;
+    const previousSessionId = child.sessionId;
+    const previousParentSessionId = child.parentSessionId;
+    const previousState = child.terminalState;
+    child.parentSessionId = this.children.get(child.parentThreadId)?.sessionId ?? this.rootSessionId;
+    child.generation += 1;
+    child.sessionId = `${childThreadId}:generation:${child.generation}`;
+    delete child.terminalState;
+    try {
+      await this.session.update({
+        sessionUpdate: "subagent_spawned",
+        subagentSessionId: child.sessionId,
+        name: child.name,
+        task: child.task,
+        capabilities: {}
+      }, child.parentSessionId);
+    } catch (error51) {
+      child.generation -= 1;
+      child.sessionId = previousSessionId;
+      child.parentSessionId = previousParentSessionId;
+      child.terminalState = previousState;
+      throw error51;
+    }
+  }
+  resolveMaterialization(childThreadId, sessionId) {
+    for (const resolve of this.materializationWaiters.get(childThreadId) ?? []) resolve(sessionId);
+    this.materializationWaiters.delete(childThreadId);
+  }
+  hasOutstanding() {
+    return this.pendingSpawns.size > 0 || [...this.children.values()].some((child) => child.terminalState === void 0);
+  }
+  notifyWaiters() {
+    for (const waiter of this.waiters) waiter();
+    this.waiters.clear();
+  }
+  parentForPath(path9) {
+    const normalized = normalizeAgentPath(path9);
+    const separator = normalized.lastIndexOf("/");
+    if (separator <= 0) return { threadId: this.rootSessionId, sessionId: this.rootSessionId };
+    const parentPath = normalized.slice(0, separator);
+    const parent = [...this.children.entries()].find(([, child]) => child.path === parentPath);
+    return parent ? { threadId: parent[0], sessionId: parent[1].sessionId } : { threadId: this.rootSessionId, sessionId: this.rootSessionId };
+  }
+};
+function terminalStateOf(status) {
+  switch (status) {
+    case "completed":
+      return "completed";
+    case "interrupted":
+      return "cancelled";
+    case "errored":
+    case "shutdown":
+    case "notFound":
+      return "failed";
+    case "pendingInit":
+    case "running":
+      return void 0;
+  }
+}
+function terminalStateFromTurn(status) {
+  switch (status) {
+    case "completed":
+      return "completed";
+    case "interrupted":
+      return "cancelled";
+    case "failed":
+      return "failed";
+    case "inProgress":
+      return void 0;
+  }
+}
+function fallbackName(sessionId) {
+  const suffix = sessionId.length > 8 ? sessionId.slice(-8) : sessionId;
+  return `Agent ${suffix}`;
+}
 
 // src/CodexEventHandler.ts
 var MAX_SESSION_FAILURE_TITLE_LENGTH = 240;
@@ -23728,13 +24152,18 @@ var CodexEventHandler = class _CodexEventHandler {
   terminalCommandIds = /* @__PURE__ */ new Set();
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   agentMessagePhases = /* @__PURE__ */ new Map();
-  activeSubAgentActivities = /* @__PURE__ */ new Set();
-  constructor(connection, sessionState, supportsPlanUpdates = false, supportsTypedSessionFailures = false, sessionFailureEpoch = randomUUID()) {
+  subagents;
+  constructor(connection, sessionState, supportsPlanUpdates = false, supportsTypedSessionFailures = false, sessionFailureEpoch = randomUUID(), subagents = new CodexSubagentEventRouter(
+    sessionState.sessionId,
+    false,
+    new ACPSessionConnection(connection, sessionState.sessionId)
+  )) {
     this.sessionState = sessionState;
     this.supportsPlanUpdates = supportsPlanUpdates;
     this.supportsTypedSessionFailures = supportsTypedSessionFailures;
     this.sessionFailureEpoch = sessionFailureEpoch;
     this.session = new ACPSessionConnection(connection, sessionState.sessionId);
+    this.subagents = subagents;
     if (sessionState.sessionFailure !== void 0) {
       this.failuresById.set(sessionState.sessionFailure.id, sessionState.sessionFailure);
     }
@@ -23836,11 +24265,30 @@ var CodexEventHandler = class _CodexEventHandler {
   }
   async handleNotification(notification) {
     await this.flushPendingErrors();
+    const handledBySubagents = await this.subagents.handle(notification);
+    for (const buffered of this.subagents.takeBufferedNotifications()) {
+      await this.handleNotification(buffered);
+    }
+    if (handledBySubagents) {
+      return;
+    }
+    if (this.subagents.shouldIgnore(notification)) {
+      return;
+    }
     const updateEvent = await this.createUpdateEvent(notification);
     if (updateEvent) {
-      await this.session.update(updateEvent);
+      await this.session.update(updateEvent, this.subagents.notificationSessionId(notification));
     }
   }
+  async waitForNativeSubagentSession(childThreadId) {
+    return await this.subagents.waitForMaterializedSession(childThreadId);
+  }
+  async waitForNativeSubagents(signal) {
+    await this.subagents.wait(signal);
+  }
+  async finishOutstandingNativeSubagents(state) {
+    await this.subagents.finishOutstanding(state);
+  }
   async flushPendingPlanUpdates() {
     this.cancelPlanUpdateTimer();
     do {
@@ -24132,15 +24580,14 @@ ${event.details}` : event.summary;
         this.activeImageGenerationItems.add(event.item.id);
         return createImageGenerationStartUpdate(event.item);
       case "collabAgentToolCall":
-        return createCollabAgentToolCallUpdate(event.item);
+        return this.subagents.legacyCollaborationStarted(event.item);
       case "agentMessage":
         this.rememberAgentMessagePhase(event.item);
         return null;
       case "contextCompaction":
         return createContextCompactionStartUpdate(event.item);
       case "subAgentActivity":
-        this.activeSubAgentActivities.add(event.item.id);
-        return createSubAgentActivityUpdate(event.item, "in_progress", "tool_call");
+        return this.subagents.legacyActivityStarted(event.item);
       case "sleep":
       case "userMessage":
       case "hookPrompt":
@@ -24188,7 +24635,7 @@ ${event.details}` : event.summary;
       case "webSearch":
         return createWebSearchCompleteUpdate(event.item);
       case "collabAgentToolCall":
-        return createCollabAgentToolCallCompleteUpdate(event.item);
+        return this.subagents.legacyCollaborationCompleted(event.item);
       case "agentMessage":
         this.rememberAgentMessagePhase(event.item);
         return null;
@@ -24201,10 +24648,8 @@ ${event.details}` : event.summary;
       case "contextCompaction":
         return createContextCompactionCompleteUpdate(event.item);
       //ignored types
-      case "subAgentActivity": {
-        const sessionUpdate = this.activeSubAgentActivities.delete(event.item.id) ? "tool_call_update" : "tool_call";
-        return createSubAgentActivityUpdate(event.item, "completed", sessionUpdate);
-      }
+      case "subAgentActivity":
+        return this.subagents.legacyActivityCompleted(event.item);
       case "sleep":
       case "userMessage":
       case "hookPrompt":
@@ -24653,343 +25098,545 @@ ${event.stdin}
   }
 };
 
-// src/ApprovalOptionId.ts
+// src/permissions/option-ids.ts
 var ApprovalOptionId = {
   AllowOnce: "allow_once",
-  AllowAlways: "allow_always",
-  RejectOnce: "reject_once",
+  AllowForSession: "allow_for_session",
+  Decline: "decline",
+  Cancel: "cancel",
   AcceptWithExecpolicyAmendment: "accept_execpolicy_amendment",
   ApplyNetworkPolicyAmendment: "apply_network_policy_amendment",
   AllowPermissionsForTurn: "allow_permissions_turn",
+  AllowPermissionsForTurnWithStrictAutoReview: "allow_permissions_turn_strict_auto_review",
   AllowPermissionsForSession: "allow_permissions_session",
   RejectPermissions: "reject_permissions"
 };
+var McpApprovalOptionId = {
+  AllowOnce: "allow_once",
+  AllowSession: "allow_session",
+  AllowAlways: "allow_always",
+  Decline: "decline",
+  Cancel: "cancel"
+};
 
-// src/CodexApprovalHandler.ts
-function permissionOption(optionId, name, kind, codexMeta, permission) {
-  return {
-    optionId,
-    name,
-    kind,
-    ...codexMeta || permission ? {
-      _meta: {
-        ...permission ? { permission } : {},
-        ...codexMeta ? { codex: codexMeta } : {}
-      }
-    } : {}
-  };
+// src/permissions/json.ts
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-var CodexApprovalHandler = class {
-  connection;
-  sessionState;
-  cancellationSignal;
-  constructor(connection, sessionState, cancellationSignal) {
-    this.connection = connection;
-    this.sessionState = sessionState;
-    this.cancellationSignal = cancellationSignal;
+function recordOrNull(value) {
+  return isRecord2(value) ? value : null;
+}
+function normalizeJsonValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "bigint") return Number(value);
+  if (Array.isArray(value)) return value.map(normalizeJsonValue);
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, nested]) => nested !== void 0).map(([key, nested]) => [key, normalizeJsonValue(nested)])
+    );
   }
-  async handleCommandExecution(params) {
-    try {
-      const sessionId = this.sessionState.sessionId;
-      const acpRequest = this.buildCommandPermissionRequest(sessionId, params);
-      const response = await this.connection.request(
-        methods.client.session.requestPermission,
-        acpRequest,
-        this.requestOptions()
-      );
-      return this.convertCommandResponse(params, response);
-    } catch (error51) {
-      logger.error("Error requesting command execution permission", error51);
-      return { decision: "cancel" };
-    }
+  return String(value);
+}
+function normalizeJsonObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, nested]) => nested !== void 0).map(([key, nested]) => [key, normalizeJsonValue(nested)])
+  );
+}
+
+// src/permissions/command-decision-contract.ts
+function parseAvailableCommandDecisions(params) {
+  if (params.availableDecisions === void 0 || params.availableDecisions === null) {
+    return defaultCommandDecisions(params);
+  }
+  if (!Array.isArray(params.availableDecisions) || params.availableDecisions.length === 0) return void 0;
+  const decisions = [];
+  for (const candidate of params.availableDecisions) {
+    const decision = parseCommandDecision(candidate, params);
+    if (!decision) return void 0;
+    decisions.push(decision);
+  }
+  return decisions;
+}
+function defaultCommandDecisions(params) {
+  if (params.networkApprovalContext) {
+    const decisions2 = ["accept", "acceptForSession"];
+    for (const amendment of params.proposedNetworkPolicyAmendments ?? []) {
+      decisions2.push({ applyNetworkPolicyAmendment: { network_policy_amendment: amendment } });
+    }
+    decisions2.push("decline", "cancel");
+    return decisions2;
+  }
+  if (params.additionalPermissions) return ["accept", "cancel"];
+  const decisions = ["accept", "acceptForSession"];
+  if (params.proposedExecpolicyAmendment && params.proposedExecpolicyAmendment.length > 0) {
+    decisions.push({
+      acceptWithExecpolicyAmendment: { execpolicy_amendment: params.proposedExecpolicyAmendment }
+    });
   }
-  async handleFileChange(params) {
-    try {
-      const sessionId = this.sessionState.sessionId;
-      const acpRequest = this.buildFileChangePermissionRequest(sessionId, params);
-      const response = await this.connection.request(
-        methods.client.session.requestPermission,
-        acpRequest,
-        this.requestOptions()
-      );
-      return this.convertFileChangeResponse(params, response);
-    } catch (error51) {
-      logger.error("Error requesting file change permission", error51);
-      return { decision: "cancel" };
+  decisions.push("decline", "cancel");
+  return decisions;
+}
+function parseCommandDecision(candidate, params) {
+  if (candidate === "accept" || candidate === "acceptForSession" || candidate === "decline" || candidate === "cancel") {
+    return candidate;
+  }
+  if (!isRecord2(candidate)) return void 0;
+  if ("acceptWithExecpolicyAmendment" in candidate) {
+    const value = candidate["acceptWithExecpolicyAmendment"];
+    if (!isRecord2(value)) return void 0;
+    const amendment = value["execpolicy_amendment"];
+    if (!isStringArray(amendment) || amendment.length === 0) return void 0;
+    if (!sameStrings(amendment, params.proposedExecpolicyAmendment)) return void 0;
+    return { acceptWithExecpolicyAmendment: { execpolicy_amendment: [...amendment] } };
+  }
+  if ("applyNetworkPolicyAmendment" in candidate) {
+    const value = candidate["applyNetworkPolicyAmendment"];
+    if (!isRecord2(value)) return void 0;
+    const amendment = parseNetworkAmendment(value["network_policy_amendment"]);
+    if (!amendment || !params.networkApprovalContext) return void 0;
+    if (amendment.host !== params.networkApprovalContext.host) return void 0;
+    if (!(params.proposedNetworkPolicyAmendments ?? []).some((proposed) => sameNetworkAmendment(proposed, amendment))) {
+      return void 0;
     }
+    return { applyNetworkPolicyAmendment: { network_policy_amendment: amendment } };
   }
-  async handlePermissionsRequest(params) {
-    try {
-      const sessionId = this.sessionState.sessionId;
-      const acpRequest = this.buildPermissionsRequest(sessionId, params);
-      const response = await this.connection.request(
-        methods.client.session.requestPermission,
-        acpRequest,
-        this.requestOptions()
-      );
-      return this.convertPermissionsResponse(params, response);
-    } catch (error51) {
-      logger.error("Error requesting permissions", error51);
-      return this.rejectPermissionsResponse();
+  return void 0;
+}
+function parseNetworkAmendment(value) {
+  if (!isRecord2(value) || typeof value["host"] !== "string") return void 0;
+  const action = value["action"];
+  if (action !== "allow" && action !== "deny") return void 0;
+  return { host: value["host"], action };
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function sameStrings(left, right) {
+  return !!right && left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameNetworkAmendment(left, right) {
+  return left.host === right.host && left.action === right.action;
+}
+
+// src/permissions/options.ts
+function commandDecisionOptions(params) {
+  const decisions = parseAvailableCommandDecisions(params);
+  if (!decisions) return void 0;
+  const options = [];
+  let networkIndex = 0;
+  for (const decision of decisions) {
+    if (decision === "accept") {
+      options.push(decisionOption(
+        ApprovalOptionId.AllowOnce,
+        params.networkApprovalContext ? "Yes, just this once" : "Yes, proceed",
+        "allow_once",
+        decision
+      ));
+    } else if (decision === "acceptForSession") {
+      options.push(decisionOption(
+        ApprovalOptionId.AllowForSession,
+        params.networkApprovalContext ? "Yes, and allow this host for this conversation" : params.additionalPermissions ? "Yes, and allow these permissions for this session" : "Yes, and don't ask again for this command in this session",
+        "allow_always",
+        decision
+      ));
+    } else if (decision === "decline") {
+      options.push(decisionOption(
+        ApprovalOptionId.Decline,
+        "No, continue without running it",
+        "reject_once",
+        decision
+      ));
+    } else if (decision === "cancel") {
+      options.push(decisionOption(
+        ApprovalOptionId.Cancel,
+        "No, and tell Codex what to do differently",
+        "reject_once",
+        decision
+      ));
+    } else if ("acceptWithExecpolicyAmendment" in decision) {
+      const prefix = renderExecPolicyPrefix(decision.acceptWithExecpolicyAmendment.execpolicy_amendment);
+      if (prefix.includes("\n") || prefix.includes("\r")) continue;
+      options.push(decisionOption(
+        ApprovalOptionId.AcceptWithExecpolicyAmendment,
+        `Yes, and don't ask again for commands that start with \`${prefix}\``,
+        "allow_always",
+        decision
+      ));
+    } else {
+      const amendment = decision.applyNetworkPolicyAmendment.network_policy_amendment;
+      options.push(decisionOption(
+        `${ApprovalOptionId.ApplyNetworkPolicyAmendment}:${networkIndex++}`,
+        amendment.action === "allow" ? "Yes, and allow this host in the future" : "No, and block this host in the future",
+        amendment.action === "allow" ? "allow_always" : "reject_always",
+        decision
+      ));
     }
   }
-  requestOptions() {
-    return this.cancellationSignal ? { cancellationSignal: this.cancellationSignal } : void 0;
+  const orderedOptions = [...options].sort(
+    (left, right) => permissionOptionOrder(left.option) - permissionOptionOrder(right.option)
+  );
+  const hasAllow = orderedOptions.some(({ option }) => option.kind === "allow_once" || option.kind === "allow_always");
+  const hasReject = orderedOptions.some(({ option }) => option.kind === "reject_once" || option.kind === "reject_always");
+  const optionIds = orderedOptions.map(({ option }) => option.optionId);
+  const hasUniqueOptionIds = new Set(optionIds).size === optionIds.length;
+  return hasAllow && hasReject && hasUniqueOptionIds ? orderedOptions : void 0;
+}
+function permissionOptionOrder(option) {
+  if (option.kind === "allow_once") return 0;
+  if (option.kind === "allow_always") return 1;
+  return 2;
+}
+function fileChangeDecisionOptions() {
+  return [
+    decisionOption(ApprovalOptionId.AllowOnce, "Yes, proceed", "allow_once", "accept"),
+    decisionOption(
+      ApprovalOptionId.AllowForSession,
+      "Yes, and don't ask again for these files",
+      "allow_always",
+      "acceptForSession"
+    ),
+    decisionOption(
+      ApprovalOptionId.Cancel,
+      "No, and tell Codex what to do differently",
+      "reject_once",
+      "cancel"
+    )
+  ];
+}
+function permissionProfileOptions() {
+  return [
+    permissionOption(
+      ApprovalOptionId.AllowPermissionsForTurn,
+      "Yes, grant these permissions for this turn",
+      "allow_once"
+    ),
+    permissionOption(
+      ApprovalOptionId.AllowPermissionsForTurnWithStrictAutoReview,
+      "Yes, grant for this turn with strict auto review",
+      "allow_once"
+    ),
+    permissionOption(
+      ApprovalOptionId.AllowPermissionsForSession,
+      "Yes, grant these permissions for this session",
+      "allow_always"
+    ),
+    permissionOption(
+      ApprovalOptionId.RejectPermissions,
+      "No, continue without permissions",
+      "reject_once"
+    )
+  ];
+}
+function decisionOption(optionId, name, kind, decision) {
+  return { option: permissionOption(optionId, name, kind), decision };
+}
+function permissionOption(optionId, name, kind) {
+  return { optionId, name, kind };
+}
+function renderExecPolicyPrefix(command) {
+  const script = extractWrappedScript(command);
+  if (script !== void 0) return script;
+  if (command.some((value) => value.includes("\0"))) return command.join(" ");
+  return command.map(shlexQuote).join(" ");
+}
+function extractWrappedScript(command) {
+  const executable = executableName(command[0]);
+  if ((executable === "bash" || executable === "zsh" || executable === "sh") && command.length === 3 && (command[1] === "-lc" || command[1] === "-c")) {
+    return command[2];
   }
-  buildCommandPermissionRequest(sessionId, params) {
-    const options = this.buildCommandOptions(params).map(({ option }) => option);
-    return {
-      sessionId,
-      toolCall: {
-        toolCallId: params.itemId,
-        kind: "execute",
-        status: "pending",
-        rawInput: params.command ? { command: stripShellPrefix(params.command), cwd: params.cwd } : null
-      },
-      options,
-      _meta: { codex: { params } }
-    };
+  if (executable !== "pwsh" && executable !== "powershell") return void 0;
+  const allowedFlags = /* @__PURE__ */ new Set(["-nologo", "-noprofile", "-command", "-c"]);
+  for (let index = 1; index + 1 < command.length; index++) {
+    const flag = command[index]?.toLowerCase();
+    if (flag === void 0 || !allowedFlags.has(flag)) return void 0;
+    if (flag === "-command" || flag === "-c") return command[index + 1];
   }
-  buildFileChangePermissionRequest(sessionId, params) {
-    const options = this.buildFileChangeOptions(params).map(({ option }) => option);
-    return {
-      sessionId,
-      toolCall: {
-        toolCallId: params.itemId,
-        kind: "edit",
-        status: "pending"
-      },
-      options,
-      _meta: { codex: { params } }
-    };
+  return void 0;
+}
+function executableName(command) {
+  let filename = command?.replaceAll("\\", "/").split("/").at(-1);
+  while (filename !== void 0) {
+    if (["bash", "zsh", "sh", "pwsh", "powershell"].includes(filename)) return filename;
+    const dot = filename.lastIndexOf(".");
+    if (dot <= 0) return void 0;
+    filename = filename.slice(0, dot);
   }
-  buildPermissionsRequest(sessionId, params) {
-    const content = this.createContent([
-      params.reason,
-      this.formatRequestedPermissions(params.permissions)
-    ]);
-    return {
-      sessionId,
-      toolCall: {
-        toolCallId: params.itemId,
-        kind: "other",
-        status: "pending",
-        title: params.reason ?? "Permissions Request",
-        rawInput: params,
-        ...content ? { content } : {}
-      },
-      options: [
-        permissionOption(
-          ApprovalOptionId.AllowPermissionsForSession,
-          "Allow for Session",
-          "allow_always",
-          { decision: "allowPermissionsForSession", permissions: params.permissions },
-          this.permissionGrantMetadata(params.permissions, "session")
-        ),
-        permissionOption(
-          ApprovalOptionId.AllowPermissionsForTurn,
-          "Allow Once",
-          "allow_once",
-          { decision: "allowPermissionsForTurn", permissions: params.permissions },
-          this.permissionGrantMetadata(params.permissions, "turn")
-        ),
-        permissionOption(
-          ApprovalOptionId.RejectPermissions,
-          "Reject",
-          "reject_once",
-          { decision: "rejectPermissions" }
-        )
-      ],
-      _meta: { codex: { params } }
-    };
+  return void 0;
+}
+function shlexQuote(value) {
+  if (value.length === 0) return "''";
+  const UNQUOTED = 1;
+  const SINGLE_QUOTED = 2;
+  const DOUBLE_QUOTED = 4;
+  let offset = 0;
+  let result = "";
+  while (offset < value.length) {
+    const start = offset;
+    let allowed = UNQUOTED | SINGLE_QUOTED | DOUBLE_QUOTED;
+    if (value[offset] === "^") {
+      allowed = SINGLE_QUOTED;
+      offset++;
+    }
+    while (offset < value.length) {
+      const character = value[offset];
+      let nextAllowed = allowed;
+      if (!isShlexUnquoted(character)) nextAllowed &= ~UNQUOTED;
+      if (character === "'" || character === "^" || character === "\\") nextAllowed &= ~SINGLE_QUOTED;
+      if (character === "`" || character === "$" || character === "!" || character === "^") {
+        nextAllowed &= ~DOUBLE_QUOTED;
+      }
+      if (nextAllowed === 0) break;
+      allowed = nextAllowed;
+      offset++;
+    }
+    const chunk = value.slice(start, offset);
+    if ((allowed & UNQUOTED) !== 0) result += chunk;
+    else if ((allowed & SINGLE_QUOTED) !== 0) result += `'${chunk}'`;
+    else result += `"${chunk.replace(/["\\]/g, "\\$&")}"`;
+  }
+  return result;
+}
+function isShlexUnquoted(character) {
+  return /^[0-9A-Za-z]$/.test(character) || "+-./:@]_".includes(character);
+}
+
+// src/permissions/metadata.ts
+var CODEX_COMMAND_PERMISSION_TITLE = "Run command?";
+var CODEX_NETWORK_PERMISSION_TITLE = "Allow network access?";
+var CODEX_FILE_CHANGE_PERMISSION_TITLE = "Make edits?";
+var CODEX_ADDITIONAL_PERMISSIONS_TITLE = "Grant permissions?";
+function requestPermissionMeta(title, reason) {
+  const description = nonBlank(reason);
+  const permission = {
+    version: 1,
+    title,
+    ...description ? { description } : {}
+  };
+  return { permission };
+}
+function optionPermissionMeta(description) {
+  const normalized = nonBlank(description);
+  if (!normalized) return void 0;
+  const permission = { version: 1, description: normalized };
+  return { permission };
+}
+function nonBlank(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+
+// src/permissions/presentation.ts
+function commandToolCall(params) {
+  const network = params.networkApprovalContext;
+  const rawInput = {
+    ...params.command ? { command: stripShellPrefix(params.command) } : {},
+    ...params.cwd ? { cwd: params.cwd } : {},
+    ...network?.protocol === "http" || network?.protocol === "https" ? { url: `${network.protocol}://${network.host}` } : {},
+    ...params.additionalPermissions ? { additionalPermissions: params.additionalPermissions } : {}
+  };
+  const additionalPermissionContent = params.additionalPermissions ? permissionProfileContent(params.additionalPermissions) : [];
+  return {
+    toolCallId: params.itemId,
+    kind: "execute",
+    status: "pending",
+    title: network ? `${network.protocol} network access to ${network.host}` : commandTitle(params.commandActions),
+    ...Object.keys(rawInput).length > 0 ? { rawInput } : {},
+    ...locationsField(unique([
+      ...commandActionPaths(params.commandActions),
+      ...permissionProfilePaths(params.additionalPermissions)
+    ])),
+    ...network ? { content: [textContent(`${network.protocol} access to ${network.host}`), ...additionalPermissionContent] } : additionalPermissionContent.length > 0 ? { content: additionalPermissionContent } : {}
+  };
+}
+function fileChangeToolCall(params, permissionContext) {
+  const item = permissionContext.fileChange(params.threadId, params.itemId);
+  return {
+    toolCallId: params.itemId,
+    kind: "edit",
+    status: "pending",
+    title: "Edit files",
+    ...locationsField(fileChangePaths(item))
+  };
+}
+function additionalPermissionsToolCall(itemId, cwd, environmentId, permissions) {
+  const content = permissionProfileContent(permissions);
+  return {
+    toolCallId: itemId,
+    kind: "other",
+    status: "pending",
+    title: "Additional sandbox permissions",
+    rawInput: { permissions, cwd, environmentId },
+    ...locationsField(permissionProfilePaths(permissions)),
+    ...content.length > 0 ? { content } : {}
+  };
+}
+function commandTitle(actions) {
+  const first = actions?.[0];
+  if (!first) return "Run command";
+  switch (first.type) {
+    case "read":
+      return actions?.length === 1 ? "Read file" : "Run command with file reads";
+    case "listFiles":
+      return "List files";
+    case "search":
+      return "Search files";
+    case "unknown":
+      return "Run command";
+  }
+}
+function commandActionPaths(actions) {
+  return unique((actions ?? []).flatMap((action) => {
+    switch (action.type) {
+      case "read":
+        return [action.path];
+      case "listFiles":
+      case "search":
+        return action.path ? [action.path] : [];
+      case "unknown":
+        return [];
+    }
+  }));
+}
+function fileChangePaths(item) {
+  return unique(item?.changes.map((change) => change.path) ?? []);
+}
+function permissionProfilePaths(permissions) {
+  const fileSystem = permissions?.fileSystem;
+  return unique([
+    ...fileSystem?.read ?? [],
+    ...fileSystem?.write ?? [],
+    ...(fileSystem?.entries ?? []).flatMap((entry) => entry.path.type === "path" ? [entry.path.path] : [])
+  ]);
+}
+function permissionProfileContent(permissions) {
+  const lines = [];
+  const networkEnabled = permissions.network?.enabled;
+  if (networkEnabled !== null && networkEnabled !== void 0) {
+    lines.push(networkEnabled ? "Enable network access" : "Disable network access");
+  }
+  for (const entry of permissions.fileSystem?.entries ?? []) {
+    switch (entry.path.type) {
+      case "glob_pattern":
+        lines.push(`${entry.access} filesystem pattern ${entry.path.pattern}`);
+        break;
+      case "special":
+        lines.push(`${entry.access} Codex filesystem scope ${JSON.stringify(entry.path.value)}`);
+        break;
+      case "path":
+        break;
+    }
+  }
+  return lines.length > 0 ? [textContent(lines.join("\n"))] : [];
+}
+function locationsField(paths) {
+  return paths.length > 0 ? { locations: paths.map((path9) => ({ path: path9 })) } : {};
+}
+function textContent(text) {
+  return { type: "content", content: { type: "text", text } };
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+// src/permissions/CodexApprovalHandler.ts
+var CodexApprovalHandler = class {
+  constructor(connection, permissionContext, cancellationSignal) {
+    this.connection = connection;
+    this.permissionContext = permissionContext;
+    this.cancellationSignal = cancellationSignal;
   }
-  convertCommandResponse(params, response) {
-    if (response.outcome.outcome === "cancelled") {
+  connection;
+  permissionContext;
+  cancellationSignal;
+  async handleCommandExecution(params) {
+    const authoritativeParams = params;
+    const decisions = commandDecisionOptions(authoritativeParams);
+    if (!decisions) {
+      logger.error("Cancelling command approval without a complete authoritative decision set", void 0);
+      return { decision: "cancel" };
+    }
+    try {
+      const response = await this.requestPermission({
+        sessionId: params.threadId,
+        toolCall: commandToolCall(authoritativeParams),
+        options: decisions.map(({ option }) => option),
+        _meta: requestPermissionMeta(
+          params.networkApprovalContext ? CODEX_NETWORK_PERMISSION_TITLE : CODEX_COMMAND_PERMISSION_TITLE,
+          params.reason
+        )
+      });
+      return { decision: this.selectedDecision(response, decisions) ?? "cancel" };
+    } catch (error51) {
+      logger.error("Error requesting command execution permission", error51);
       return { decision: "cancel" };
     }
-    const optionId = response.outcome.optionId;
-    const decision = this.buildCommandOptions(params).find(({ option }) => option.optionId === optionId)?.decision;
-    return { decision: decision ?? "decline" };
   }
-  convertFileChangeResponse(params, response) {
-    if (response.outcome.outcome === "cancelled") {
+  async handleFileChange(params) {
+    const decisions = fileChangeDecisionOptions();
+    try {
+      const response = await this.requestPermission({
+        sessionId: params.threadId,
+        toolCall: fileChangeToolCall(params, this.permissionContext),
+        options: decisions.map(({ option }) => option),
+        _meta: requestPermissionMeta(CODEX_FILE_CHANGE_PERMISSION_TITLE, params.reason)
+      });
+      return { decision: this.selectedDecision(response, decisions) ?? "cancel" };
+    } catch (error51) {
+      logger.error("Error requesting file change permission", error51);
       return { decision: "cancel" };
     }
-    const optionId = response.outcome.optionId;
-    const decision = this.buildFileChangeOptions(params).find(({ option }) => option.optionId === optionId)?.decision;
-    return { decision: decision ?? "decline" };
   }
-  convertPermissionsResponse(params, response) {
-    if (response.outcome.outcome === "cancelled") {
+  async handlePermissionsRequest(params) {
+    try {
+      const response = await this.requestPermission({
+        sessionId: params.threadId,
+        toolCall: additionalPermissionsToolCall(
+          params.itemId,
+          params.cwd,
+          params.environmentId,
+          params.permissions
+        ),
+        options: permissionProfileOptions(),
+        _meta: requestPermissionMeta(CODEX_ADDITIONAL_PERMISSIONS_TITLE, params.reason)
+      });
+      return this.permissionsResponse(params.permissions, response);
+    } catch (error51) {
+      logger.error("Error requesting permissions", error51);
       return this.rejectPermissionsResponse();
     }
+  }
+  requestPermission(request) {
+    return this.connection.request(
+      methods.client.session.requestPermission,
+      request,
+      this.cancellationSignal ? { cancellationSignal: this.cancellationSignal } : void 0
+    );
+  }
+  selectedDecision(response, decisions) {
+    if (response.outcome.outcome === "cancelled") return void 0;
+    const optionId = response.outcome.optionId;
+    return decisions.find(({ option }) => option.optionId === optionId)?.decision;
+  }
+  permissionsResponse(permissions, response) {
+    if (response.outcome.outcome === "cancelled") return this.rejectPermissionsResponse();
     switch (response.outcome.optionId) {
-      case ApprovalOptionId.AllowPermissionsForSession:
-      case ApprovalOptionId.AllowAlways:
-        return {
-          permissions: this.grantedPermissions(params.permissions),
-          scope: "session",
-          strictAutoReview: false
-        };
       case ApprovalOptionId.AllowPermissionsForTurn:
-      case ApprovalOptionId.AllowOnce:
-        return {
-          permissions: this.grantedPermissions(params.permissions),
-          scope: "turn",
-          strictAutoReview: false
-        };
+        return this.grantedPermissionsResponse(permissions, "turn", false);
+      case ApprovalOptionId.AllowPermissionsForTurnWithStrictAutoReview:
+        return this.grantedPermissionsResponse(permissions, "turn", true);
+      case ApprovalOptionId.AllowPermissionsForSession:
+        return this.grantedPermissionsResponse(permissions, "session", false);
+      case ApprovalOptionId.RejectPermissions:
       default:
         return this.rejectPermissionsResponse();
     }
   }
-  buildCommandOptions(params) {
-    const options = [
-      {
-        option: permissionOption(ApprovalOptionId.AllowOnce, "Allow Once", "allow_once", { decision: "accept" }),
-        decision: "accept"
-      },
-      {
-        option: permissionOption(
-          ApprovalOptionId.AllowAlways,
-          params.networkApprovalContext ? "Allow Host for Session" : "Allow for Session",
-          "allow_always",
-          { decision: "acceptForSession" },
-          params.networkApprovalContext ? {
-            version: 1,
-            changes: [{
-              type: "grant",
-              operation: "grant",
-              description: `Allow access to ${params.networkApprovalContext.host} for this session`,
-              lifetime: { scope: "session" },
-              targets: [{
-                type: "network",
-                matcher: {
-                  type: "host",
-                  host: params.networkApprovalContext.host,
-                  protocol: params.networkApprovalContext.protocol
-                }
-              }]
-            }]
-          } : void 0
-        ),
-        decision: "acceptForSession"
-      }
-    ];
-    if (params.proposedExecpolicyAmendment && params.proposedExecpolicyAmendment.length > 0) {
-      options.push({
-        option: permissionOption(
-          ApprovalOptionId.AcceptWithExecpolicyAmendment,
-          this.execpolicyAmendmentLabel(params.proposedExecpolicyAmendment),
-          "allow_always",
-          {
-            decision: "acceptWithExecpolicyAmendment",
-            execpolicyAmendment: params.proposedExecpolicyAmendment
-          },
-          {
-            version: 1,
-            changes: [{
-              type: "policy_rule",
-              operation: "add",
-              ruleBehavior: "allow",
-              description: `Allow commands starting with ${params.proposedExecpolicyAmendment.join(" ")}`,
-              targets: [{
-                type: "command",
-                matcher: {
-                  type: "argv_prefix",
-                  argv: params.proposedExecpolicyAmendment
-                }
-              }]
-            }]
-          }
-        ),
-        decision: {
-          acceptWithExecpolicyAmendment: {
-            execpolicy_amendment: params.proposedExecpolicyAmendment
-          }
-        }
-      });
-    }
-    params.proposedNetworkPolicyAmendments?.forEach((amendment, index) => {
-      options.push({
-        option: permissionOption(
-          this.networkPolicyAmendmentOptionId(index),
-          this.networkPolicyAmendmentLabel(amendment),
-          amendment.action === "allow" ? "allow_always" : "reject_always",
-          {
-            decision: "applyNetworkPolicyAmendment",
-            networkPolicyAmendment: amendment
-          },
-          {
-            version: 1,
-            changes: [{
-              type: "policy_rule",
-              operation: "add",
-              ruleBehavior: amendment.action,
-              description: amendment.action === "allow" ? `Allow access to ${amendment.host}` : `Block access to ${amendment.host}`,
-              targets: [{
-                type: "network",
-                matcher: {
-                  type: "host",
-                  host: amendment.host
-                }
-              }]
-            }]
-          }
-        ),
-        decision: {
-          applyNetworkPolicyAmendment: {
-            network_policy_amendment: amendment
-          }
-        }
-      });
-    });
-    options.push({
-      option: permissionOption(ApprovalOptionId.RejectOnce, "Reject", "reject_once", { decision: "decline" }),
-      decision: "decline"
-    });
-    return options;
-  }
-  buildFileChangeOptions(params) {
-    return [
-      {
-        option: permissionOption(ApprovalOptionId.AllowOnce, "Allow Once", "allow_once", { decision: "accept" }),
-        decision: "accept"
-      },
-      {
-        option: permissionOption(
-          ApprovalOptionId.AllowAlways,
-          params.grantRoot ? "Allow Root for Session" : "Allow for Session",
-          "allow_always",
-          { decision: "acceptForSession", grantRoot: params.grantRoot ?? null },
-          params.grantRoot ? {
-            version: 1,
-            changes: [{
-              type: "grant",
-              operation: "grant",
-              description: `Allow writes under ${params.grantRoot} for this session`,
-              lifetime: { scope: "session" },
-              targets: [{
-                type: "filesystem",
-                access: ["write"],
-                matcher: { type: "directory", path: params.grantRoot }
-              }]
-            }]
-          } : void 0
-        ),
-        decision: "acceptForSession"
-      },
-      {
-        option: permissionOption(ApprovalOptionId.RejectOnce, "Reject", "reject_once", { decision: "decline" }),
-        decision: "decline"
-      }
-    ];
+  grantedPermissionsResponse(permissions, scope, strictAutoReview) {
+    return { permissions: this.grantedPermissions(permissions), scope, strictAutoReview };
   }
   rejectPermissionsResponse() {
-    return {
-      permissions: {},
-      scope: "turn",
-      strictAutoReview: true
-    };
+    return { permissions: {}, scope: "turn", strictAutoReview: false };
   }
   grantedPermissions(permissions) {
     return {
@@ -24997,117 +25644,131 @@ var CodexApprovalHandler = class {
       ...permissions.fileSystem ? { fileSystem: permissions.fileSystem } : {}
     };
   }
-  permissionGrantMetadata(permissions, scope) {
-    const changes = [];
-    const lifetime = { scope };
-    const suffix = scope === "session" ? " for this session" : " for this turn";
-    if (permissions.network?.enabled !== null && permissions.network?.enabled !== void 0) {
-      const allowed = permissions.network.enabled;
-      changes.push({
-        type: allowed ? "grant" : "policy_rule",
-        operation: allowed ? "grant" : "add",
-        ...allowed ? {} : { ruleBehavior: "deny" },
-        description: `${allowed ? "Allow" : "Deny"} network access${suffix}`,
-        lifetime,
-        targets: [{ type: "network", matcher: { type: "any" } }]
-      });
-    }
-    const fileSystem = permissions.fileSystem;
-    for (const path8 of fileSystem?.read ?? []) {
-      changes.push(this.fileSystemGrantChange(path8, "read", lifetime, suffix));
-    }
-    for (const path8 of fileSystem?.write ?? []) {
-      changes.push(this.fileSystemGrantChange(path8, "write", lifetime, suffix));
-    }
-    for (const entry of fileSystem?.entries ?? []) {
-      const matcher = (() => {
-        switch (entry.path.type) {
-          case "path":
-            return { type: "exact_path", path: entry.path.path };
-          case "glob_pattern":
-            return { type: "glob", pattern: entry.path.pattern };
-          case "special":
-            return { type: "special", provider: "codex", value: entry.path.value };
-        }
-      })();
-      const pathDescription = entry.path.type === "path" ? entry.path.path : entry.path.type === "glob_pattern" ? entry.path.pattern : JSON.stringify(entry.path.value);
-      changes.push({
-        type: entry.access === "deny" ? "policy_rule" : "grant",
-        operation: entry.access === "deny" ? "add" : "grant",
-        ...entry.access === "deny" ? { ruleBehavior: "deny" } : {},
-        description: entry.access === "deny" ? `Deny filesystem access to ${pathDescription}${suffix}` : `Allow ${entry.access} access to ${pathDescription}${suffix}`,
-        lifetime,
-        targets: [{
-          type: "filesystem",
-          ...entry.access === "deny" ? {} : { access: [entry.access] },
-          matcher
-        }]
-      });
-    }
-    return changes.length > 0 ? { version: 1, changes } : void 0;
+};
+
+// src/permissions/lifecycle.ts
+var PermissionLifecycleContext = class {
+  constructor(session) {
+    this.session = session;
   }
-  fileSystemGrantChange(path8, access, lifetime, suffix) {
-    return {
-      type: "grant",
-      operation: "grant",
-      description: `Allow ${access} access to ${path8}${suffix}`,
-      lifetime,
-      targets: [{
-        type: "filesystem",
-        access: [access],
-        matcher: { type: "exact_path", path: path8 }
-      }]
-    };
+  session;
+  permissionRequestSequence = 0;
+  beginPrompt() {
+    return new PermissionPromptContext((serverName) => this.nextStandaloneMcpToolCallId(serverName));
   }
-  networkPolicyAmendmentOptionId(index) {
-    return `${ApprovalOptionId.ApplyNetworkPolicyAmendment}:${index}`;
+  nextStandaloneMcpToolCallId(serverName) {
+    this.permissionRequestSequence += 1;
+    return ["elicitation", this.session.sessionId, serverName, this.permissionRequestSequence].join(":");
   }
-  execpolicyAmendmentLabel(amendment) {
-    const commandPrefix = amendment.join(" ");
-    if (!commandPrefix || commandPrefix.includes("\n") || commandPrefix.includes("\r")) {
-      return "Allow and Remember Command Pattern";
+};
+var PermissionPromptContext = class {
+  constructor(nextStandaloneId) {
+    this.nextStandaloneId = nextStandaloneId;
+  }
+  nextStandaloneId;
+  fileChanges = /* @__PURE__ */ new Map();
+  pendingMcpApprovals = /* @__PURE__ */ new Map();
+  handleNotification(notification) {
+    switch (notification.method) {
+      case "item/started":
+        this.handleItemStarted(notification.params.threadId, notification.params.item);
+        return;
+      case "item/completed":
+        this.handleItemCompleted(notification.params.threadId, notification.params.item);
+        return;
+      case "turn/completed":
+        this.clearTransientState(notification.params.threadId);
+        return;
+      case "serverRequest/resolved":
+        this.pendingMcpApprovals.delete(notification.params.threadId);
+        return;
+      default:
+        return;
     }
-    return `Allow Commands Starting With \`${commandPrefix}\``;
   }
-  networkPolicyAmendmentLabel(amendment) {
-    return amendment.action === "allow" ? `Allow ${amendment.host} in the Future` : `Block ${amendment.host} in the Future`;
+  fileChange(threadId, itemId) {
+    return this.fileChanges.get(threadId)?.get(itemId);
   }
-  formatRequestedPermissions(permissions) {
-    const content = [];
-    if (permissions.network?.enabled !== void 0 && permissions.network.enabled !== null) {
-      content.push(`Network Access: ${permissions.network.enabled}`);
-    }
-    if (permissions.fileSystem?.read?.length) {
-      content.push(`File System Read Access: ${permissions.fileSystem.read.join(", ")}`);
-    }
-    if (permissions.fileSystem?.write?.length) {
-      content.push(`File System Write Access: ${permissions.fileSystem.write.join(", ")}`);
+  popPendingMcpApproval(threadId, serverName) {
+    const byServer = this.pendingMcpApprovals.get(threadId);
+    if (!byServer) return void 0;
+    const pending = byServer.get(serverName);
+    if (pending?.length !== 1) return void 0;
+    const callId = pending[0];
+    byServer.delete(serverName);
+    if (byServer.size === 0) this.pendingMcpApprovals.delete(threadId);
+    return callId;
+  }
+  nextStandaloneMcpToolCallId(serverName) {
+    return this.nextStandaloneId(serverName);
+  }
+  handleItemStarted(threadId, item) {
+    if (item.type === "fileChange") {
+      const byItem = this.fileChanges.get(threadId) ?? /* @__PURE__ */ new Map();
+      byItem.set(item.id, item);
+      this.fileChanges.set(threadId, byItem);
+      return;
     }
-    if (permissions.fileSystem?.entries?.length) {
-      content.push(`File System Entries: ${JSON.stringify(permissions.fileSystem.entries)}`);
+    if (item.type !== "mcpToolCall") return;
+    const byServer = this.pendingMcpApprovals.get(threadId) ?? /* @__PURE__ */ new Map();
+    const pending = byServer.get(item.server);
+    if (pending) pending.push(item.id);
+    else byServer.set(item.server, [item.id]);
+    this.pendingMcpApprovals.set(threadId, byServer);
+  }
+  handleItemCompleted(threadId, item) {
+    if (item.type === "fileChange") {
+      const byItem = this.fileChanges.get(threadId);
+      byItem?.delete(item.id);
+      if (byItem?.size === 0) this.fileChanges.delete(threadId);
+      return;
     }
-    return content.length > 0 ? content.join("\n\n") : null;
+    if (item.type !== "mcpToolCall") return;
+    const byServer = this.pendingMcpApprovals.get(threadId);
+    if (!byServer) return;
+    const pending = byServer.get(item.server);
+    if (!pending) return;
+    const index = pending.indexOf(item.id);
+    if (index >= 0) pending.splice(index, 1);
+    if (pending.length === 0) byServer.delete(item.server);
+    if (byServer.size === 0) this.pendingMcpApprovals.delete(threadId);
   }
-  createContent(lines) {
-    const text = lines.filter((line) => !!line).join("\n\n");
-    if (!text) return void 0;
-    return [{
-      type: "content",
-      content: {
-        type: "text",
-        text
-      }
-    }];
+  clearTransientState(threadId) {
+    this.fileChanges.delete(threadId);
+    this.pendingMcpApprovals.delete(threadId);
   }
 };
 
-// src/McpApprovalOptionId.ts
-var McpApprovalOptionId = {
-  AllowOnce: "allow_once",
-  AllowSession: "allow_session",
-  AllowAlways: "allow_always",
-  Decline: "decline"
-};
+// src/permissions/plan-review.ts
+var IMPLEMENT_PLAN_OPTION_ID = "implement_plan";
+var REVISE_PLAN_OPTION_ID = "revise_plan";
+function planImplementationPermissionRequest(sessionId, plan) {
+  return {
+    sessionId,
+    toolCall: {
+      toolCallId: planImplementationToolCallId(plan),
+      title: "Implement this plan?",
+      kind: "switch_mode",
+      status: "pending",
+      rawInput: { plan: plan.text }
+    },
+    options: [
+      { optionId: IMPLEMENT_PLAN_OPTION_ID, name: "Yes, implement this plan", kind: "allow_once" },
+      {
+        optionId: REVISE_PLAN_OPTION_ID,
+        name: "No, and tell Codex what to do differently",
+        kind: "reject_once"
+      }
+    ],
+    _meta: { codex: { kind: "plan_review", planItemId: plan.itemId } }
+  };
+}
+function planImplementationApproved(response) {
+  return response.outcome.outcome === "selected" && response.outcome.optionId === IMPLEMENT_PLAN_OPTION_ID;
+}
+function planImplementationToolCallId(plan) {
+  return `plan-review:${plan.itemId}`;
+}
 
 // src/ElicitationCapabilities.ts
 function clientSupportsFormElicitation(clientCapabilities) {
@@ -25117,57 +25778,146 @@ function clientSupportsUrlElicitation(clientCapabilities) {
   return clientCapabilities?.elicitation?.url != null;
 }
 
-// src/CodexElicitationHandler.ts
-var ELICITATION_OPTIONS = [
-  { optionId: "accept", name: "Accept", kind: "allow_once" },
-  { optionId: "decline", name: "Decline", kind: "reject_once" }
-];
-var USER_INPUT_OTHER_FIELD_SUFFIX = "__other";
+// src/permissions/mcp.ts
 function parsePersistOptions(meta3) {
   const result = /* @__PURE__ */ new Set();
-  if (!meta3 || typeof meta3 !== "object") return result;
+  if (!isRecord2(meta3)) return result;
   const persist = meta3["persist"];
-  if (persist === "session") {
-    result.add("session");
-  } else if (persist === "always") {
-    result.add("always");
-  } else if (Array.isArray(persist)) {
+  if (persist === "session") result.add("session");
+  else if (persist === "always") result.add("always");
+  else if (Array.isArray(persist)) {
     if (persist.includes("session")) result.add("session");
     if (persist.includes("always")) result.add("always");
   }
   return result;
 }
 function isMcpToolCallApproval(meta3) {
-  return meta3 !== null && typeof meta3 === "object" && meta3["codex_approval_kind"] === "mcp_tool_call";
-}
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeJsonValue(value) {
-  if (value === null || value === void 0) {
-    return null;
+  return isRecord2(meta3) && meta3["codex_approval_kind"] === "mcp_tool_call";
+}
+function buildMcpPermissionOptions(isToolApproval, persistOptions) {
+  const options = [permissionOption2(
+    isToolApproval ? McpApprovalOptionId.AllowOnce : "accept",
+    "Allow",
+    "allow_once",
+    isToolApproval ? "Run the tool and continue." : "Allow this request and continue."
+  )];
+  if (persistOptions.has("session")) {
+    options.push(permissionOption2(
+      McpApprovalOptionId.AllowSession,
+      "Allow for this session",
+      "allow_always",
+      isToolApproval ? "Run the tool and remember this choice for this session." : "Allow this request and remember this choice for this session."
+    ));
   }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
+  if (persistOptions.has("always")) {
+    options.push(permissionOption2(
+      McpApprovalOptionId.AllowAlways,
+      "Always allow",
+      "allow_always",
+      isToolApproval ? "Run the tool and remember this choice for future tool calls." : "Allow this request and remember this choice for future requests."
+    ));
   }
-  if (typeof value === "bigint") {
-    return Number(value);
+  if (isToolApproval) {
+    options.push(permissionOption2(
+      McpApprovalOptionId.Cancel,
+      "Cancel",
+      "reject_once",
+      "Cancel this tool call"
+    ));
+  } else {
+    options.push(
+      permissionOption2(
+        McpApprovalOptionId.Decline,
+        "Deny",
+        "reject_once",
+        "Decline this request and continue."
+      ),
+      permissionOption2(McpApprovalOptionId.Cancel, "Cancel", "reject_once", "Cancel this request")
+    );
   }
-  if (Array.isArray(value)) {
-    return value.map(normalizeJsonValue);
+  return options;
+}
+function buildMcpPermissionRequest(sessionId, params, context, nextStandaloneToolCallId) {
+  const messageContent = {
+    type: "content",
+    content: { type: "text", text: params.message }
+  };
+  const options = buildMcpPermissionOptions(context.isToolApproval, context.persistOptions);
+  if (params.mode === "form" || params.mode === "openai/form") {
+    if (context.correlatedCallId !== void 0) {
+      return {
+        request: {
+          sessionId,
+          toolCall: {
+            toolCallId: context.correlatedCallId,
+            kind: "execute",
+            status: "pending"
+          },
+          _meta: { is_mcp_tool_approval: true },
+          options
+        },
+        correlatedCallId: context.correlatedCallId
+      };
+    }
+    return {
+      request: {
+        sessionId,
+        toolCall: {
+          toolCallId: nextStandaloneToolCallId(),
+          kind: context.isToolApproval ? "execute" : "other",
+          status: "pending",
+          content: [messageContent],
+          rawInput: { serverName: params.serverName, schema: params.requestedSchema }
+        },
+        ...context.isToolApproval ? { _meta: { is_mcp_tool_approval: true } } : {},
+        options
+      },
+      correlatedCallId: void 0
+    };
   }
-  if (typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).filter(([, nested]) => nested !== void 0).map(([key, nested]) => [key, normalizeJsonValue(nested)])
-    );
+  return {
+    request: {
+      sessionId,
+      toolCall: {
+        toolCallId: `elicitation-${params.elicitationId}`,
+        kind: "fetch",
+        status: "pending",
+        content: [messageContent],
+        rawInput: { serverName: params.serverName, url: params.url }
+      },
+      options
+    },
+    correlatedCallId: void 0
+  };
+}
+function convertMcpPermissionResponse(response, isToolApproval, persistOptions) {
+  if (response.outcome.outcome === "cancelled") return cancelledResponse();
+  switch (response.outcome.optionId) {
+    case McpApprovalOptionId.AllowSession:
+      return persistOptions.has("session") ? { action: "accept", content: null, _meta: { persist: "session" } } : cancelledResponse();
+    case McpApprovalOptionId.AllowAlways:
+      return persistOptions.has("always") ? { action: "accept", content: null, _meta: { persist: "always" } } : cancelledResponse();
+    case McpApprovalOptionId.AllowOnce:
+      return isToolApproval ? { action: "accept", content: null, _meta: null } : cancelledResponse();
+    case "accept":
+      return !isToolApproval ? { action: "accept", content: null, _meta: null } : cancelledResponse();
+    case McpApprovalOptionId.Decline:
+      return !isToolApproval ? { action: "decline", content: null, _meta: null } : cancelledResponse();
+    case McpApprovalOptionId.Cancel:
+    default:
+      return cancelledResponse();
   }
-  return String(value);
 }
-function normalizeJsonObject(value) {
-  return Object.fromEntries(
-    Object.entries(value).filter(([, nested]) => nested !== void 0).map(([key, nested]) => [key, normalizeJsonValue(nested)])
-  );
+function permissionOption2(optionId, name, kind, description) {
+  const meta3 = optionPermissionMeta(description);
+  return { optionId, name, kind, ...meta3 ? { _meta: meta3 } : {} };
+}
+function cancelledResponse() {
+  return { action: "cancel", content: null, _meta: null };
 }
+
+// src/CodexElicitationHandler.ts
+var USER_INPUT_OTHER_FIELD_SUFFIX = "__other";
 function normalizeElicitationSchema(value) {
   const normalized = normalizeElicitationSchemaValue(value);
   if (!isRecord2(normalized)) {
@@ -25203,40 +25953,6 @@ function normalizeElicitationSchemaValue(value) {
   }
   return result;
 }
-function metaRecord(meta3) {
-  return isRecord2(meta3) ? meta3 : null;
-}
-function persistChoiceOption(value) {
-  switch (value) {
-    case "once":
-      return { const: "once", title: "Allow once" };
-    case "session":
-      return { const: "session", title: "Allow for this session" };
-    case "always":
-      return { const: "always", title: "Allow and don't ask again" };
-  }
-}
-function addPersistChoiceToSchema(schema, persistOptions) {
-  if (persistOptions.size === 0) {
-    return schema;
-  }
-  const choices = ["once"];
-  if (persistOptions.has("session")) choices.push("session");
-  if (persistOptions.has("always")) choices.push("always");
-  return {
-    ...schema,
-    properties: {
-      ...schema.properties,
-      persist: {
-        type: "string",
-        title: "Approval scope",
-        oneOf: choices.map(persistChoiceOption),
-        default: "once"
-      }
-    },
-    required: Array.from(/* @__PURE__ */ new Set([...schema.required ?? [], "persist"]))
-  };
-}
 function contentRecord(content) {
   return isRecord2(content) ? content : {};
 }
@@ -25248,7 +25964,7 @@ function jsonObjectOrNull(content) {
   return Object.fromEntries(entries.map(([key, value]) => [key, normalizeJsonValue(value)]));
 }
 function elicitationResponseMeta(response, context, persist = void 0) {
-  const responseMeta = metaRecord(response._meta);
+  const responseMeta = recordOrNull(response._meta);
   const meta3 = responseMeta ? normalizeJsonObject(responseMeta) : {};
   if (context.isToolApproval) {
     delete meta3["persist"];
@@ -25279,22 +25995,9 @@ function userInputResponseValue(content, fieldId) {
   }
   return value;
 }
-function buildToolApprovalOptions(persistOptions) {
-  const options = [
-    { optionId: McpApprovalOptionId.AllowOnce, name: "Allow", kind: "allow_once" }
-  ];
-  if (persistOptions.has("session")) {
-    options.push({ optionId: McpApprovalOptionId.AllowSession, name: "Allow for This Session", kind: "allow_always" });
-  }
-  if (persistOptions.has("always")) {
-    options.push({ optionId: McpApprovalOptionId.AllowAlways, name: "Allow and Don't Ask Again", kind: "allow_always" });
-  }
-  options.push({ optionId: McpApprovalOptionId.Decline, name: "Decline", kind: "reject_once" });
-  return options;
-}
 var CodexElicitationHandler = class {
   connection;
-  sessionState;
+  permissionContext;
   clientCapabilities;
   cancellationSignal;
   // In Rust, the MCP elicitation handler receives ElicitationRequestEvent directly from the MCP
@@ -25306,32 +26009,21 @@ var CodexElicitationHandler = class {
   // reaches the client.
   //
   // Workaround: before requesting approval, Codex emits an item/started notification with an
-  // mcpToolCall item carrying the call id and server name. We store (threadId, serverName) → callId
-  // here so the elicitation request can correlate back to the already-rendered tool call item.
+  // mcpToolCall item carrying the call id and server name. The shared permission lifecycle stores
+  // (threadId, serverName) → callId so this request can correlate to the rendered tool call item.
   //
-  // Multiple calls are safe because Codex requests approval synchronously — it blocks on one tool
-  // call's elicitation before starting the next, so there is at most one pending approval per
-  // (threadId, serverName).
-  pendingMcpApprovals = /* @__PURE__ */ new Map();
   // The app-server handler exposes URL elicitationId, while serverRequest/resolved only exposes
   // threadId here, so accepted URL elicitations are completed at thread scope.
   pendingUrlElicitations = /* @__PURE__ */ new Map();
-  constructor(connection, sessionState, clientCapabilities = null, cancellationSignal) {
+  constructor(connection, permissionContext, clientCapabilities = null, cancellationSignal) {
     this.connection = connection;
-    this.sessionState = sessionState;
+    this.permissionContext = permissionContext;
     this.clientCapabilities = clientCapabilities;
     this.cancellationSignal = cancellationSignal;
   }
   async handleNotification(notification) {
     switch (notification.method) {
-      case "item/started":
-        this.handleItemStarted(notification.params);
-        return;
-      case "item/completed":
-        this.handleItemCompleted(notification.params);
-        return;
       case "serverRequest/resolved":
-        this.clearThread(notification.params.threadId);
         await this.completeUrlElicitations(notification.params.threadId);
         return;
       default:
@@ -25347,29 +26039,39 @@ var CodexElicitationHandler = class {
           this.buildElicitationRequest(params, context),
           this.requestOptions()
         );
-        const result = this.convertElicitationResponse(response2, context);
-        if (params.mode === "url" && result.action === "accept") {
+        const result2 = this.convertElicitationResponse(response2, context);
+        if (params.mode === "url" && result2.action === "accept") {
           this.trackUrlElicitation(params.threadId, params.elicitationId);
         }
-        await this.publishAcceptedMcpToolApproval(context, result.action === "accept");
-        return result;
+        await this.publishAcceptedMcpToolApproval(params.threadId, context, result2.action === "accept");
+        return result2;
       }
-      const { request, correlatedCallId } = this.buildPermissionRequest(params, context);
+      if (!this.canUsePermissionFallback(params)) {
+        return { action: "cancel", content: null, _meta: null };
+      }
+      const { request, correlatedCallId } = buildMcpPermissionRequest(
+        params.threadId,
+        params,
+        context,
+        () => this.permissionContext.nextStandaloneMcpToolCallId(params.serverName)
+      );
       const response = await this.connection.request(
         methods.client.session.requestPermission,
         request,
         this.requestOptions()
       );
-      if (correlatedCallId !== void 0 && response.outcome.outcome !== "cancelled") {
-        const optionId = response.outcome.optionId;
-        if (optionId !== McpApprovalOptionId.Decline) {
-          await this.connection.notify(methods.client.session.update, {
-            sessionId: this.sessionState.sessionId,
-            update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
-          });
-        }
+      const result = convertMcpPermissionResponse(
+        response,
+        context.isToolApproval,
+        context.persistOptions
+      );
+      if (correlatedCallId !== void 0 && result.action === "accept") {
+        await this.connection.notify(methods.client.session.update, {
+          sessionId: params.threadId,
+          update: { sessionUpdate: "tool_call_update", toolCallId: correlatedCallId, status: "in_progress" }
+        });
       }
-      return this.convertPermissionResponse(response);
+      return result;
     } catch (error51) {
       logger.error("Error handling MCP elicitation request", error51);
       return { action: "cancel", content: null, _meta: null };
@@ -25439,12 +26141,17 @@ var CodexElicitationHandler = class {
     }
   }
   createMcpElicitationContext(params) {
-    const isToolApproval = isMcpToolCallApproval(params._meta);
+    const isToolApproval = isMcpToolCallApproval(params._meta) && this.isMessageOnlyForm(params);
     const persistOptions = parsePersistOptions(params._meta);
-    const correlatedCallId = isToolApproval && (params.mode === "form" || params.mode === "openai/form") ? this.popPendingApproval(params.threadId, params.serverName) : void 0;
-    return { isToolApproval, persistOptions, correlatedCallId };
+    const correlatedCallId = isToolApproval ? this.permissionContext.popPendingMcpApproval(params.threadId, params.serverName) : void 0;
+    return {
+      isToolApproval,
+      persistOptions,
+      correlatedCallId
+    };
   }
   shouldUseAcpElicitation(params) {
+    if (this.isMessageOnlyForm(params)) return false;
     switch (params.mode) {
       case "form":
         return clientSupportsFormElicitation(this.clientCapabilities);
@@ -25454,23 +26161,28 @@ var CodexElicitationHandler = class {
         return false;
     }
   }
+  canUsePermissionFallback(params) {
+    return params.mode === "url" || this.isMessageOnlyForm(params);
+  }
+  isMessageOnlyForm(params) {
+    if (params.mode !== "form" && params.mode !== "openai/form") return false;
+    if (params.requestedSchema === null) return true;
+    if (!isRecord2(params.requestedSchema)) return false;
+    return params.requestedSchema["type"] === "object" && isRecord2(params.requestedSchema["properties"]) && Object.keys(params.requestedSchema["properties"]).length === 0;
+  }
   buildElicitationRequest(params, context) {
     const base = {
-      sessionId: this.sessionState.sessionId,
+      sessionId: params.threadId,
       ...context.correlatedCallId ? { toolCallId: context.correlatedCallId } : {},
       message: params.message,
-      _meta: metaRecord(params._meta)
+      _meta: recordOrNull(params._meta)
     };
     switch (params.mode) {
       case "form": {
-        const requestedSchema = context.isToolApproval ? addPersistChoiceToSchema(
-          normalizeElicitationSchema(params.requestedSchema),
-          context.persistOptions
-        ) : normalizeElicitationSchema(params.requestedSchema);
         return {
           ...base,
           mode: "form",
-          requestedSchema
+          requestedSchema: normalizeElicitationSchema(params.requestedSchema)
         };
       }
       case "url":
@@ -25526,105 +26238,35 @@ var CodexElicitationHandler = class {
               isOtherAnswer: true,
               isSecret: question.isSecret
             }
-          }
-        };
-      }
-    }
-    const firstQuestion = params.questions[0];
-    return {
-      sessionId: this.sessionState.sessionId,
-      toolCallId: params.itemId,
-      mode: "form",
-      message: params.questions.length === 1 && firstQuestion ? firstQuestion.question : "Input requested",
-      requestedSchema: {
-        type: "object",
-        properties,
-        required: required2
-      },
-      _meta: {
-        codex: {
-          autoResolutionMs: params.autoResolutionMs
-        }
-      }
-    };
-  }
-  buildPermissionRequest(params, context) {
-    const sessionId = this.sessionState.sessionId;
-    const messageContent = {
-      type: "content",
-      content: { type: "text", text: params.message }
-    };
-    const options = context.isToolApproval ? buildToolApprovalOptions(context.persistOptions) : ELICITATION_OPTIONS;
-    if (params.mode === "form" || params.mode === "openai/form") {
-      if (context.correlatedCallId !== void 0) {
-        return {
-          request: {
-            sessionId,
-            toolCall: {
-              toolCallId: context.correlatedCallId,
-              kind: "execute",
-              status: "pending"
-              // content: [messageContent],   — omitted: already rendered via item/started
-              // rawInput: { ... }            — omitted: same reason
-            },
-            _meta: { is_mcp_tool_approval: true },
-            options
-          },
-          correlatedCallId: context.correlatedCallId
-        };
-      }
-      return {
-        request: {
-          sessionId,
-          toolCall: {
-            toolCallId: `elicitation-${params.serverName}`,
-            kind: context.isToolApproval ? "execute" : "other",
-            status: "pending",
-            content: [messageContent],
-            rawInput: { serverName: params.serverName, schema: params.requestedSchema }
-          },
-          ...context.isToolApproval ? { _meta: { is_mcp_tool_approval: true } } : {},
-          options
-        },
-        correlatedCallId: void 0
-      };
-    } else {
-      return {
-        request: {
-          sessionId,
-          toolCall: {
-            toolCallId: `elicitation-${params.elicitationId}`,
-            kind: "fetch",
-            status: "pending",
-            content: [messageContent],
-            rawInput: { serverName: params.serverName, url: params.url }
-          },
-          options
-        },
-        correlatedCallId: void 0
-      };
-    }
-  }
-  convertPermissionResponse(response) {
-    if (response.outcome.outcome === "cancelled") {
-      return { action: "cancel", content: null, _meta: null };
-    }
-    const optionId = response.outcome.optionId;
-    if (optionId === McpApprovalOptionId.AllowSession) {
-      return { action: "accept", content: null, _meta: { persist: "session" } };
-    }
-    if (optionId === McpApprovalOptionId.AllowAlways) {
-      return { action: "accept", content: null, _meta: { persist: "always" } };
-    }
-    if (optionId === McpApprovalOptionId.AllowOnce || optionId === "accept") {
-      return { action: "accept", content: null, _meta: null };
+          }
+        };
+      }
     }
-    return { action: "decline", content: null, _meta: null };
+    const firstQuestion = params.questions[0];
+    return {
+      sessionId: params.threadId,
+      toolCallId: params.itemId,
+      mode: "form",
+      message: params.questions.length === 1 && firstQuestion ? firstQuestion.question : "Input requested",
+      requestedSchema: {
+        type: "object",
+        properties,
+        required: required2
+      },
+      _meta: {
+        codex: {
+          autoResolutionMs: params.autoResolutionMs
+        }
+      }
+    };
   }
   convertElicitationResponse(response, context) {
     if (CreateElicitationResponse.isAccept(response)) {
       const content = contentRecord(response.content);
       const persist = context.isToolApproval ? content["persist"] : void 0;
+      if (context.isToolApproval && !this.isAllowedToolApprovalPersist(persist, context.persistOptions)) {
+        return { action: "cancel", content: null, _meta: null };
+      }
       if (persist === "session" || persist === "always" || persist === "once") {
         delete content["persist"];
       }
@@ -25635,7 +26277,7 @@ var CodexElicitationHandler = class {
       };
     }
     if (CreateElicitationResponse.isDecline(response)) {
-      return { action: "decline", content: null, _meta: elicitationResponseMeta(response, context) };
+      return context.isToolApproval ? { action: "cancel", content: null, _meta: elicitationResponseMeta(response, context) } : { action: "decline", content: null, _meta: elicitationResponseMeta(response, context) };
     }
     if (CreateElicitationResponse.isCancel(response)) {
       return { action: "cancel", content: null, _meta: elicitationResponseMeta(response, context) };
@@ -25645,6 +26287,9 @@ var CodexElicitationHandler = class {
     }
     return { action: "cancel", content: null, _meta: null };
   }
+  isAllowedToolApprovalPersist(persist, persistOptions) {
+    return persist === void 0 || persist === "once" || persist === "session" && persistOptions.has("session") || persist === "always" && persistOptions.has("always");
+  }
   convertUserInputResponse(response, params) {
     if (!CreateElicitationResponse.isAccept(response)) {
       return { answers: {} };
@@ -25663,12 +26308,12 @@ var CodexElicitationHandler = class {
     }
     return { answers };
   }
-  async publishAcceptedMcpToolApproval(context, accepted) {
+  async publishAcceptedMcpToolApproval(sessionId, context, accepted) {
     if (!accepted || context.correlatedCallId === void 0) {
       return;
     }
     await this.connection.notify(methods.client.session.update, {
-      sessionId: this.sessionState.sessionId,
+      sessionId,
       update: { sessionUpdate: "tool_call_update", toolCallId: context.correlatedCallId, status: "in_progress" }
     });
   }
@@ -25692,37 +26337,6 @@ var CodexElicitationHandler = class {
       });
     }
   }
-  handleItemStarted(event) {
-    if (event.item.type !== "mcpToolCall") {
-      return;
-    }
-    this.pendingMcpApprovals.set(this.key(event.threadId, event.item.server), event.item.id);
-  }
-  handleItemCompleted(event) {
-    if (event.item.type !== "mcpToolCall") {
-      return;
-    }
-    this.popPendingApproval(event.threadId, event.item.server);
-  }
-  popPendingApproval(threadId, serverName) {
-    const key = this.key(threadId, serverName);
-    const callId = this.pendingMcpApprovals.get(key);
-    this.pendingMcpApprovals.delete(key);
-    return callId;
-  }
-  clearThread(threadId) {
-    for (const key of this.pendingMcpApprovals.keys()) {
-      if (this.belongsToThread(key, threadId)) {
-        this.pendingMcpApprovals.delete(key);
-      }
-    }
-  }
-  key(threadId, serverName) {
-    return `${threadId}:${serverName}`;
-  }
-  belongsToThread(key, threadId) {
-    return key.startsWith(`${threadId}:`);
-  }
 };
 
 // src/CodexAuthMethod.ts
@@ -25778,13 +26392,14 @@ function isCodexAuthRequest(request) {
 }
 
 // node_modules/open/index.js
-import process9 from "node:process";
-import path3 from "node:path";
+import process11 from "node:process";
+import path4 from "node:path";
 import { fileURLToPath } from "node:url";
-import childProcess3 from "node:child_process";
+import childProcess4 from "node:child_process";
 import fs6, { constants as fsConstants2 } from "node:fs/promises";
 
 // node_modules/wsl-utils/index.js
+import path3 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";
@@ -25863,7 +26478,7 @@ var isWsl = () => {
 };
 var is_wsl_default = process3.env.__IS_WSL_TEST__ ? isWsl : isWsl();
 
-// node_modules/powershell-utils/index.js
+// node_modules/wsl-utils/node_modules/powershell-utils/index.js
 import process4 from "node:process";
 import { Buffer as Buffer2 } from "node:buffer";
 import { promisify } from "node:util";
@@ -25962,20 +26577,73 @@ var canAccessPowerShell = async () => {
 var wslDefaultBrowser = async () => {
   const psPath = await powerShellPath2();
   const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
-  const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+  const { stdout } = await executePowerShell(command, {
+    powerShellPath: psPath,
+    cwd: path3.dirname(psPath)
+  });
   return stdout.trim();
 };
-var convertWslPathToWindows = async (path8) => {
-  if (/^[a-z]+:\/\//i.test(path8)) {
-    return path8;
-  }
-  try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path8], { encoding: "utf8" });
-    return stdout.trim();
-  } catch {
-    return path8;
+var isUrl = (path9) => /^[a-z]+:\/\//i.test(path9);
+var convertWslPathToWindows = async (paths) => {
+  const isBatch = Array.isArray(paths);
+  const pathArray = isBatch ? paths : [paths];
+  const indicesToConvert = [];
+  const pathsToConvert = [];
+  for (const [index, path9] of pathArray.entries()) {
+    if (!isUrl(path9)) {
+      indicesToConvert.push(index);
+      pathsToConvert.push(path9);
+    }
+  }
+  const results = [...pathArray];
+  if (pathsToConvert.length > 0) {
+    try {
+      const { stdout } = await execFile2("wslpath", ["-aw", ...pathsToConvert], { encoding: "utf8" });
+      const convertedPaths = stdout.split(/\r?\n/).filter(Boolean);
+      for (const [index, originalIndex] of indicesToConvert.entries()) {
+        results[originalIndex] = convertedPaths[index] ?? pathArray[originalIndex];
+      }
+    } catch {
+    }
   }
+  return isBatch ? results : results[0];
+};
+
+// node_modules/powershell-utils/index.js
+import process5 from "node:process";
+import { Buffer as Buffer3 } from "node:buffer";
+import { promisify as promisify3 } from "node:util";
+import childProcess3 from "node:child_process";
+var execFile3 = promisify3(childProcess3.execFile);
+var powerShellPath3 = () => `${process5.env.SYSTEMROOT || process5.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+var argumentsPrefix = [
+  "-NoProfile",
+  "-NonInteractive",
+  "-ExecutionPolicy",
+  "Bypass",
+  "-EncodedCommand"
+];
+var encodeCommand = (command) => Buffer3.from(command, "utf16le").toString("base64");
+var escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+var createArguments = (command) => [...argumentsPrefix, encodeCommand(command)];
+var executePowerShell2 = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  return execFile3(
+    psPath ?? powerShellPath3(),
+    createArguments(command),
+    {
+      encoding: "utf8",
+      ...execFileOptions
+    }
+  );
 };
+executePowerShell2.argumentsPrefix = argumentsPrefix;
+executePowerShell2.encodeCommand = encodeCommand;
+executePowerShell2.escapeArgument = escapeArgument;
+executePowerShell2.createArguments = createArguments;
 
 // node_modules/define-lazy-prop/index.js
 function defineLazyProperty(object2, propertyName, valueGetter) {
@@ -25996,17 +26664,17 @@ function defineLazyProperty(object2, propertyName, valueGetter) {
 }
 
 // node_modules/default-browser/index.js
-import { promisify as promisify6 } from "node:util";
-import process7 from "node:process";
-import { execFile as execFile6 } from "node:child_process";
+import { promisify as promisify7 } from "node:util";
+import process9 from "node:process";
+import { execFile as execFile7 } from "node:child_process";
 
 // node_modules/default-browser-id/index.js
-import { promisify as promisify3 } from "node:util";
-import process5 from "node:process";
-import { execFile as execFile3 } from "node:child_process";
-var execFileAsync = promisify3(execFile3);
+import { promisify as promisify4 } from "node:util";
+import process6 from "node:process";
+import { execFile as execFile4 } from "node:child_process";
+var execFileAsync = promisify4(execFile4);
 async function defaultBrowserId() {
-  if (process5.platform !== "darwin") {
+  if (process6.platform !== "darwin") {
     throw new Error("macOS only");
   }
   const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
@@ -26019,12 +26687,12 @@ async function defaultBrowserId() {
 }
 
 // node_modules/run-applescript/index.js
-import process6 from "node:process";
-import { promisify as promisify4 } from "node:util";
-import { execFile as execFile4, execFileSync } from "node:child_process";
-var execFileAsync2 = promisify4(execFile4);
+import process7 from "node:process";
+import { promisify as promisify5 } from "node:util";
+import { execFile as execFile5, execFileSync } from "node:child_process";
+var execFileAsync2 = promisify5(execFile5);
 async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
-  if (process6.platform !== "darwin") {
+  if (process7.platform !== "darwin") {
     throw new Error("macOS only");
   }
   const outputArguments = humanReadableOutput ? [] : ["-ss"];
@@ -26043,9 +26711,10 @@ tell application "System Events" to get value of property list item "CFBundleNam
 }
 
 // node_modules/default-browser/windows.js
-import { promisify as promisify5 } from "node:util";
-import { execFile as execFile5 } from "node:child_process";
-var execFileAsync3 = promisify5(execFile5);
+import process8 from "node:process";
+import { promisify as promisify6 } from "node:util";
+import { execFile as execFile6 } from "node:child_process";
+var execFileAsync3 = promisify6(execFile6);
 var windowsBrowserProgIds = {
   MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
   // The missing `L` is correct.
@@ -26069,7 +26738,8 @@ var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
 var UnknownBrowserError = class extends Error {
 };
 async function defaultBrowser(_execFileAsync = execFileAsync3) {
-  const { stdout } = await _execFileAsync("reg", [
+  const regPath = `${process8.env.SYSTEMROOT ?? process8.env.windir ?? "C:\\Windows"}\\System32\\reg.exe`;
+  const { stdout } = await _execFileAsync(regPath, [
     "QUERY",
     " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
     "/v",
@@ -26088,36 +26758,36 @@ async function defaultBrowser(_execFileAsync = execFileAsync3) {
 }
 
 // node_modules/default-browser/index.js
-var execFileAsync4 = promisify6(execFile6);
+var execFileAsync4 = promisify7(execFile7);
 var titleize = (string4) => string4.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
 async function defaultBrowser2() {
-  if (process7.platform === "darwin") {
+  if (process9.platform === "darwin") {
     const id = await defaultBrowserId();
     const name = await bundleName(id);
     return { name, id };
   }
-  if (process7.platform === "linux") {
+  if (process9.platform === "linux") {
     const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
     const id = stdout.trim();
     const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
     return { name, id };
   }
-  if (process7.platform === "win32") {
+  if (process9.platform === "win32") {
     return defaultBrowser();
   }
   throw new Error("Only macOS, Linux, and Windows are supported");
 }
 
 // node_modules/is-in-ssh/index.js
-import process8 from "node:process";
-var isInSsh = Boolean(process8.env.SSH_CONNECTION || process8.env.SSH_CLIENT || process8.env.SSH_TTY);
+import process10 from "node:process";
+var isInSsh = Boolean(process10.env.SSH_CONNECTION || process10.env.SSH_CLIENT || process10.env.SSH_TTY);
 var is_in_ssh_default = isInSsh;
 
 // node_modules/open/index.js
 var fallbackAttemptSymbol = /* @__PURE__ */ Symbol("fallbackAttempt");
-var __dirname = import.meta.url ? path3.dirname(fileURLToPath(import.meta.url)) : "";
-var localXdgOpenPath = path3.join(__dirname, "xdg-open");
-var { platform, arch } = process9;
+var __dirname = import.meta.url ? path4.dirname(fileURLToPath(import.meta.url)) : "";
+var localXdgOpenPath = path4.join(__dirname, "xdg-open");
+var { platform, arch } = process11;
 var tryEachApp = async (apps2, opener) => {
   if (apps2.length === 0) {
     return;
@@ -26230,7 +26900,7 @@ var baseOpen = async (options) => {
     }
   } else if (platform === "win32" || shouldUseWindowsInWsl) {
     command = await powerShellPath2();
-    cliArguments.push(...executePowerShell.argumentsPrefix);
+    cliArguments.push(...executePowerShell2.argumentsPrefix);
     if (!is_wsl_default) {
       childProcessOptions.windowsVerbatimArguments = true;
     }
@@ -26242,21 +26912,24 @@ var baseOpen = async (options) => {
       encodedArguments.push("-Wait");
     }
     if (app) {
-      encodedArguments.push(executePowerShell.escapeArgument(app));
+      encodedArguments.push(executePowerShell2.escapeArgument(app));
       if (options.target) {
         appArguments.push(options.target);
       }
     } else if (options.target) {
-      encodedArguments.push(executePowerShell.escapeArgument(options.target));
+      encodedArguments.push(executePowerShell2.escapeArgument(options.target));
     }
     if (appArguments.length > 0) {
-      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+      appArguments = appArguments.map((argument) => executePowerShell2.escapeArgument(argument));
       encodedArguments.push("-ArgumentList", appArguments.join(","));
     }
-    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    options.target = executePowerShell2.encodeCommand(encodedArguments.join(" "));
     if (!options.wait) {
       childProcessOptions.stdio = "ignore";
     }
+    if (is_wsl_default) {
+      childProcessOptions.cwd = path4.dirname(command);
+    }
   } else {
     if (app) {
       command = app;
@@ -26268,7 +26941,7 @@ var baseOpen = async (options) => {
         exeLocalXdgOpen = true;
       } catch {
       }
-      const useSystemXdgOpen = process9.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      const useSystemXdgOpen = process11.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
       command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
     }
     if (appArguments.length > 0) {
@@ -26285,7 +26958,7 @@ var baseOpen = async (options) => {
   if (options.target) {
     cliArguments.push(options.target);
   }
-  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
+  const subprocess = childProcess4.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
     return new Promise((resolve, reject) => {
       subprocess.once("error", reject);
@@ -26432,33 +27105,44 @@ var AgentMode = class _AgentMode {
   id;
   name;
   description;
+  kind;
   approvalPolicy;
+  approvalsReviewer;
   sandboxPolicy;
   sandboxMode;
-  constructor(id, name, description, approval, sandbox, sandboxMode) {
+  constructor(id, name, description, kind, approvalPolicy, approvalsReviewer, sandboxPolicy, sandboxMode) {
     this.id = id;
     this.name = name;
     this.description = description;
-    this.approvalPolicy = approval;
-    this.sandboxPolicy = sandbox;
+    this.kind = kind;
+    this.approvalPolicy = approvalPolicy;
+    this.approvalsReviewer = approvalsReviewer;
+    this.sandboxPolicy = sandboxPolicy;
     this.sandboxMode = sandboxMode;
   }
   static ReadOnly = new _AgentMode(
     "read-only",
-    "Read-only",
-    "Requires approval to edit files and run commands.",
+    "Ask for approval",
+    "Always ask to edit external files and use the internet",
+    "standard",
     "on-request",
+    "user",
     {
-      "type": "readOnly",
-      "networkAccess": false
+      type: "workspaceWrite",
+      writableRoots: [],
+      networkAccess: false,
+      excludeTmpdirEnvVar: false,
+      excludeSlashTmp: false
     },
-    "read-only"
+    "workspace-write"
   );
   static Agent = new _AgentMode(
     "agent",
-    "Agent",
-    "Read and edit files, and run commands.",
+    "Approve for me",
+    "Only ask for actions detected as potentially unsafe",
+    "auto_review",
     "on-request",
+    "auto_review",
     {
       type: "workspaceWrite",
       writableRoots: [],
@@ -26470,9 +27154,11 @@ var AgentMode = class _AgentMode {
   );
   static AgentFullAccess = new _AgentMode(
     "agent-full-access",
-    "Agent (full access)",
-    "Codex can edit files outside this workspace and run commands with network access. Exercise caution when using.",
+    "Full access",
+    "Unrestricted access to the internet and any file on your computer",
+    "full_access",
     "never",
+    "user",
     { "type": "dangerFullAccess" },
     "danger-full-access"
   );
@@ -26481,7 +27167,8 @@ var AgentMode = class _AgentMode {
     return {
       id: this.id,
       name: this.name,
-      description: this.description
+      description: this.description,
+      _meta: { kind: this.kind }
     };
   }
   toSessionModeState() {
@@ -26501,7 +27188,8 @@ var AgentMode = class _AgentMode {
       options: _AgentMode.all().map((mode) => ({
         value: mode.id,
         name: mode.name,
-        description: mode.description
+        description: mode.description,
+        _meta: { kind: mode.kind }
       }))
     };
   }
@@ -26523,7 +27211,7 @@ var AgentMode = class _AgentMode {
 };
 
 // src/CodexAcpClient.ts
-import path6 from "node:path";
+import path7 from "node:path";
 
 // src/McpServerName.ts
 var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
@@ -26537,7 +27225,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.6.0",
+  version: "1.7.0",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -26571,7 +27259,7 @@ var package_default = {
     "example:steering:multistep": "node --import tsx examples/steering.ts",
     "generate-types": "./node_modules/.bin/codex app-server generate-ts --out src/app-server",
     "release:preflight": "bash scripts/release-preflight.sh",
-    test: "vitest run",
+    test: "vitest run --no-file-parallelism --retry=2",
     "test:e2e": "npm run build && RUN_E2E_TESTS=true vitest run --no-file-parallelism --retry=2 src/__tests__/CodexACPAgent/e2e",
     "test:watch": "vitest",
     typecheck: "tsc --noEmit && tsc --noEmit -p examples/tsconfig.json",
@@ -26591,17 +27279,17 @@ var package_default = {
   type: "module",
   devDependencies: {
     "@types/node": "^26.1.0",
-    esbuild: "^0.28.1",
+    esbuild: "^0.28.2",
     "mcp-hello-world": "^1.1.2",
-    tsx: "^4.23.1",
+    tsx: "^4.23.12",
     typescript: "^7.0.2",
-    vitest: "^4.1.10"
+    vitest: "^4.1.11"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "^1.3.0",
+    "@agentclientprotocol/sdk": "^1.4.0",
     "@openai/codex": "^0.148.0",
     diff: "^9.0.0",
-    open: "^11.0.0",
+    open: "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",
     zod: "^4.0.0"
   }
@@ -26643,17 +27331,17 @@ function createCodexCollaborationMode(mode, currentModelId) {
 }
 
 // src/PathUtils.ts
-import path4 from "node:path";
+import path5 from "node:path";
 function isAbsolutePathLike(value) {
   const trimmed = value.trim();
-  return path4.isAbsolute(trimmed) || isWindowsAbsolutePath(trimmed);
+  return path5.isAbsolute(trimmed) || isWindowsAbsolutePath(trimmed);
 }
 function arePathsEqual(left, right) {
   return normalizePathForComparison(left) === normalizePathForComparison(right);
 }
 function arePathBasenamesEqual(left, right) {
-  const leftBase = path4.posix.basename(normalizePathForComparison(left));
-  const rightBase = path4.posix.basename(normalizePathForComparison(right));
+  const leftBase = path5.posix.basename(normalizePathForComparison(left));
+  const rightBase = path5.posix.basename(normalizePathForComparison(right));
   if (shouldComparePathCaseInsensitive(left) || shouldComparePathCaseInsensitive(right)) {
     return leftBase.toLowerCase() === rightBase.toLowerCase();
   }
@@ -26665,11 +27353,11 @@ function normalizePathForComparison(value) {
     return "";
   }
   if (isWindowsAbsolutePath(trimmed)) {
-    const normalized2 = path4.win32.normalize(trimmed).replace(/\\/g, "/");
+    const normalized2 = path5.win32.normalize(trimmed).replace(/\\/g, "/");
     return trimTrailingPathSeparators(normalized2).toLowerCase();
   }
-  const pathForComparison = path4.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
-  const normalized = path4.posix.normalize(pathForComparison);
+  const pathForComparison = path5.isAbsolute(trimmed) ? trimmed : trimmed.replace(/\\/g, "/");
+  const normalized = path5.posix.normalize(pathForComparison);
   return trimTrailingPathSeparators(normalized);
 }
 function isWindowsAbsolutePath(value) {
@@ -26692,7 +27380,7 @@ function isRootPath(value) {
 
 // src/AgentFileChangeReport.ts
 import fs7 from "node:fs";
-import path5 from "node:path";
+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;
@@ -26702,7 +27390,7 @@ var AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH = 2e3;
 var AGENT_FILE_CHANGE_REPORT_OUTPUT_SCHEMA = {
   type: "object",
   additionalProperties: false,
-  required: ["paths", "complete"],
+  required: ["paths", "complete", "uncertainty"],
   properties: {
     paths: {
       type: "array",
@@ -26710,8 +27398,12 @@ var AGENT_FILE_CHANGE_REPORT_OUTPUT_SCHEMA = {
     },
     complete: { type: "boolean" },
     uncertainty: {
-      type: "string",
-      maxLength: AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH
+      anyOf: [{
+        type: "string",
+        maxLength: AGENT_FILE_CHANGE_REPORT_MAX_UNCERTAINTY_LENGTH
+      }, {
+        type: "null"
+      }]
     }
   }
 };
@@ -26771,7 +27463,10 @@ function parseModelFileChangeReport(turn) {
     case "interrupted":
       throw new AgentFileChangeReportError("cancelled", "The audit turn was interrupted");
     case "failed":
-      throw new AgentFileChangeReportError("providerError", "The audit turn 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":
@@ -26801,10 +27496,10 @@ function parseModelFileChangeReport(turn) {
   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") {
+  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 = uncertainty?.trim();
+  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");
   }
@@ -26883,13 +27578,13 @@ function normalizeWorkspaceRoot(value) {
   }
   if (isWindowsAbsolutePath2(trimmed)) {
     return canonicalizeWorkspaceRoot({
-      value: path5.win32.normalize(trimmed.replace(/\//g, "\\")),
+      value: path6.win32.normalize(trimmed.replace(/\//g, "\\")),
       flavor: "windows"
     });
   }
-  if (path5.posix.isAbsolute(trimmed)) {
+  if (path6.posix.isAbsolute(trimmed)) {
     return canonicalizeWorkspaceRoot({
-      value: path5.posix.normalize(trimmed.replace(/\\/g, "/")),
+      value: path6.posix.normalize(trimmed.replace(/\\/g, "/")),
       flavor: "posix"
     });
   }
@@ -26902,17 +27597,17 @@ function normalizeReportedPath(value, cwd, roots) {
   }
   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" };
+    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: path5.win32.resolve(cwd.value, trimmed.replace(/\//g, "\\")),
+      value: path6.win32.resolve(cwd.value, trimmed.replace(/\//g, "\\")),
       flavor: "windows"
     };
   } else {
     candidate = {
-      value: path5.posix.resolve(cwd.value, trimmed.replace(/\\/g, "/")),
+      value: path6.posix.resolve(cwd.value, trimmed.replace(/\\/g, "/")),
       flavor: "posix"
     };
   }
@@ -26929,23 +27624,23 @@ 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)) };
+  const parent = canonicalizeFromExistingAncestor(path6.dirname(candidate.value));
+  return { ...candidate, value: path6.resolve(parent, path6.basename(candidate.value)) };
 }
 function canonicalizeFromExistingAncestor(value) {
-  const original = path5.resolve(value);
+  const original = path6.resolve(value);
   let current = original;
   const missingSegments = [];
   while (true) {
     try {
       const canonical = fs7.realpathSync.native(current);
-      return path5.resolve(canonical, ...missingSegments.reverse());
+      return path6.resolve(canonical, ...missingSegments.reverse());
     } catch (error51) {
       if (!isMissingPathError(error51)) return original;
     }
-    const parent = path5.dirname(current);
+    const parent = path6.dirname(current);
     if (parent === current) return original;
-    missingSegments.push(path5.basename(current));
+    missingSegments.push(path6.basename(current));
     current = parent;
   }
 }
@@ -26960,7 +27655,7 @@ function pathIsStrictlyInside(root, candidate) {
   if (root.flavor !== candidate.flavor) {
     return false;
   }
-  const pathImplementation = root.flavor === "windows" ? path5.win32 : path5.posix;
+  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}`);
 }
@@ -26979,6 +27674,120 @@ function hasOnlyKeys(value, allowed) {
   return Object.keys(value).every((key) => allowedKeys.has(key));
 }
 
+// src/subagents/CodexSubagentSubscriptions.ts
+var CodexSubagentSubscriptions = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  sessions = /* @__PURE__ */ new Map();
+  subscribe(subscription) {
+    const existing = this.sessions.get(subscription.rootSessionId);
+    if (existing) {
+      existing.current = subscription;
+      return;
+    }
+    const session = { current: subscription, children: /* @__PURE__ */ new Set() };
+    this.sessions.set(subscription.rootSessionId, session);
+    this.client.onServerNotification(subscription.rootSessionId, (event) => {
+      this.discover(session, event);
+      session.current.dispatch(event);
+    });
+    this.registerInteractiveHandlers(session, subscription.rootSessionId);
+  }
+  clear(rootSessionId) {
+    for (const childSessionId of this.sessions.get(rootSessionId)?.children ?? []) {
+      this.client.clearThreadHandlers(childSessionId);
+    }
+    this.sessions.delete(rootSessionId);
+  }
+  discover(session, event) {
+    if (event.method !== "item/started" && event.method !== "item/completed") {
+      return;
+    }
+    const item = event.params.item;
+    const childSessionIds = item.type === "collabAgentToolCall" && item.tool === "spawnAgent" ? item.receiverThreadIds : item.type === "subAgentActivity" && item.kind !== "interrupted" && !isRootAgentPath(item.agentPath) ? [item.agentThreadId] : [];
+    for (const childSessionId of childSessionIds) {
+      if (childSessionId.trim() === "") continue;
+      if (childSessionId === session.current.rootSessionId || childSessionId === event.params.threadId || session.children.has(childSessionId)) {
+        continue;
+      }
+      session.children.add(childSessionId);
+      this.client.onServerNotification(childSessionId, (childEvent) => {
+        const eventThreadId = childEvent.params.threadId;
+        if (eventThreadId !== childSessionId) return;
+        this.discover(session, childEvent);
+        if (session.current.supportsSubagents) session.current.dispatch(childEvent);
+        else session.current.enqueueInteraction(this.rootAttributed(childEvent, session.current.rootSessionId));
+      });
+      this.registerInteractiveHandlers(session, childSessionId);
+    }
+  }
+  registerInteractiveHandlers(session, targetSessionId) {
+    this.client.onApprovalRequest(targetSessionId, {
+      handleCommandExecution: async (params) => {
+        const current = session.current;
+        await current.waitForRootNotifications();
+        const sessionId = await this.interactionSessionId(current, targetSessionId);
+        if (sessionId === null) return { decision: "cancel" };
+        return await current.approvalHandler.handleCommandExecution(
+          { ...params, threadId: sessionId }
+        );
+      },
+      handleFileChange: async (params) => {
+        const current = session.current;
+        await current.waitForRootNotifications();
+        const sessionId = await this.interactionSessionId(current, targetSessionId);
+        if (sessionId === null) return { decision: "cancel" };
+        return await current.approvalHandler.handleFileChange(
+          { ...params, threadId: sessionId }
+        );
+      },
+      handlePermissionsRequest: async (params) => {
+        const current = session.current;
+        await current.waitForRootNotifications();
+        const sessionId = await this.interactionSessionId(current, targetSessionId);
+        if (sessionId === null) return { permissions: {}, scope: "turn", strictAutoReview: false };
+        return await current.approvalHandler.handlePermissionsRequest(
+          { ...params, threadId: sessionId }
+        );
+      }
+    });
+    this.client.onElicitationRequest(targetSessionId, {
+      handleElicitation: async (params) => {
+        const current = session.current;
+        await current.waitForRootNotifications();
+        const sessionId = await this.interactionSessionId(current, targetSessionId);
+        if (sessionId === null) return { action: "cancel", content: null, _meta: null };
+        return await current.elicitationHandler.handleElicitation(
+          { ...params, threadId: sessionId }
+        );
+      },
+      handleUserInput: async (params) => {
+        const current = session.current;
+        await current.waitForRootNotifications();
+        const sessionId = await this.interactionSessionId(current, targetSessionId);
+        if (sessionId === null) return { answers: {} };
+        return await current.elicitationHandler.handleUserInput(
+          { ...params, threadId: sessionId }
+        );
+      }
+    });
+  }
+  async interactionSessionId(subscription, targetSessionId) {
+    if (targetSessionId === subscription.rootSessionId) return targetSessionId;
+    if (!subscription.supportsSubagents) return subscription.rootSessionId;
+    return await subscription.waitForChildSession(targetSessionId);
+  }
+  rootAttributed(event, rootSessionId) {
+    if (typeof event.params.threadId !== "string") return event;
+    return {
+      ...event,
+      params: { ...event.params, threadId: rootSessionId }
+    };
+  }
+};
+
 // src/CodexAcpClient.ts
 var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
 var OPENAI_PROVIDER_ID = "openai";
@@ -26994,6 +27803,7 @@ var CodexAcpClient = class {
   pendingLoginCompleted = null;
   pendingAccountUpdated = null;
   sessionNotificationQueues = /* @__PURE__ */ new Map();
+  subagents;
   skillExtraRoots = [];
   configPath = null;
   constructor(codexClient, codexConfig, modelProvider) {
@@ -27001,6 +27811,7 @@ var CodexAcpClient = class {
     this.config = codexConfig ?? {};
     this.modelProvider = modelProvider ?? null;
     this.gatewayConfig = null;
+    this.subagents = new CodexSubagentSubscriptions(codexClient);
   }
   defaultClientInfo = {
     name: `${package_default.name}`,
@@ -27076,16 +27887,31 @@ var CodexAcpClient = class {
     if (loginResponse.type !== "chatgptDeviceCode") {
       return false;
     }
-    const elicitationResponse = await urlElicitationRequester.elicitUrl({
+    const elicitationResponsePromise = Promise.resolve(urlElicitationRequester.elicitUrl({
       url: loginResponse.verificationUrl,
       message: `Sign in to ChatGPT and enter this code: ${loginResponse.userCode}`,
       elicitationId: loginResponse.loginId
-    });
-    if (!CreateElicitationResponse.isAccept(elicitationResponse)) {
+    }));
+    const first = await Promise.race([
+      loginCompletedPromise.then((result2) => ({
+        type: "loginCompleted",
+        result: result2
+      })),
+      elicitationResponsePromise.then((response) => ({
+        type: "elicitationResponse",
+        response
+      }))
+    ]);
+    if (first.type === "loginCompleted") {
+      await urlElicitationRequester.completeElicitation();
+      return first.result.success;
+    }
+    if (!CreateElicitationResponse.isAccept(first.response)) {
       await this.codexClient.accountLoginCancel({ loginId: loginResponse.loginId });
       return false;
     }
     const result = await loginCompletedPromise;
+    await urlElicitationRequester.completeElicitation();
     return result.success;
   }
   authenticateWithGateway(authRequest) {
@@ -27331,6 +28157,12 @@ var CodexAcpClient = class {
       additionalDirectories
     };
   }
+  async readSessionThread(sessionId) {
+    return (await this.codexClient.threadRead({
+      threadId: sessionId,
+      includeTurns: true
+    })).thread;
+  }
   async newSession(request) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
@@ -27359,6 +28191,7 @@ var CodexAcpClient = class {
       await this.codexClient.threadUnsubscribe({ threadId: sessionId });
     } finally {
       this.codexClient.clearThreadHandlers(sessionId);
+      this.subagents.clear(sessionId);
     }
   }
   async deleteSession(sessionId) {
@@ -27484,7 +28317,7 @@ var CodexAcpClient = class {
     if (!cwd) {
       return;
     }
-    const skillExtraRoots = additionalRoots.map((root) => path6.join(root, ".agents", "skills"));
+    const skillExtraRoots = additionalRoots.map((root) => path7.join(root, ".agents", "skills"));
     if (!arraysEqual(this.skillExtraRoots, skillExtraRoots)) {
       await this.codexClient.skillsExtraRootsSet({ extraRoots: skillExtraRoots });
       this.skillExtraRoots = skillExtraRoots;
@@ -27535,33 +28368,21 @@ var CodexAcpClient = class {
     }
     return ModelId.create(defaultModel.id, reasoningEffort ?? defaultModel.defaultReasoningEffort);
   }
-  async subscribeToSessionEvents(sessionId, eventHandler, approvalHandler, elicitationHandler) {
-    this.codexClient.onServerNotification(sessionId, (event) => {
+  async subscribeToSessionEvents(sessionId, eventHandler, approvalHandler, elicitationHandler, supportsSubagents, observeInteraction, waitForChildSession) {
+    const dispatch = (event) => {
       this.enqueueSessionNotification(sessionId, () => eventHandler(event));
-    });
-    this.codexClient.onApprovalRequest(sessionId, {
-      handleCommandExecution: async (params) => {
-        await this.waitForSessionNotifications(sessionId);
-        return await approvalHandler.handleCommandExecution(params);
-      },
-      handleFileChange: async (params) => {
-        await this.waitForSessionNotifications(sessionId);
-        return await approvalHandler.handleFileChange(params);
-      },
-      handlePermissionsRequest: async (params) => {
-        await this.waitForSessionNotifications(sessionId);
-        return await approvalHandler.handlePermissionsRequest(params);
-      }
-    });
-    this.codexClient.onElicitationRequest(sessionId, {
-      handleElicitation: async (params) => {
-        await this.waitForSessionNotifications(sessionId);
-        return await elicitationHandler.handleElicitation(params);
+    };
+    this.subagents.subscribe({
+      rootSessionId: sessionId,
+      supportsSubagents,
+      dispatch,
+      enqueueInteraction: (event) => {
+        this.enqueueSessionNotification(sessionId, () => observeInteraction(event));
       },
-      handleUserInput: async (params) => {
-        await this.waitForSessionNotifications(sessionId);
-        return await elicitationHandler.handleUserInput(params);
-      }
+      approvalHandler,
+      elicitationHandler,
+      waitForRootNotifications: () => this.waitForSessionNotifications(sessionId),
+      waitForChildSession
     });
   }
   async waitForSessionNotifications(sessionId) {
@@ -27599,6 +28420,7 @@ var CodexAcpClient = class {
       threadId: request.sessionId,
       input,
       approvalPolicy: agentMode.approvalPolicy,
+      approvalsReviewer: agentMode.approvalsReviewer,
       sandboxPolicy: addAdditionalDirectoriesToSandboxPolicy(agentMode.sandboxPolicy, additionalDirectories),
       summary: disableSummary ? "none" : "auto",
       effort,
@@ -27653,22 +28475,9 @@ var CodexAcpClient = class {
       });
       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,
+        outcome.turn,
         params.workspace
       );
     } catch (error51) {
@@ -27685,7 +28494,7 @@ var CodexAcpClient = class {
         return createUnavailableAgentFileChangeReport(params.requestId, error51.reason);
       }
       if (error51 instanceof AgentFileChangeReportError) {
-        logger.log("Agent file-change report unavailable", { reason: error51.reason });
+        logger.error("Agent file-change report unavailable", error51);
         return createUnavailableAgentFileChangeReport(params.requestId, error51.reason);
       }
       logger.error("Agent file-change report failed", error51);
@@ -27974,8 +28783,8 @@ function formatUriAsLink(name, uri) {
     return `[@${name}](${uri})`;
   }
   if (uri.startsWith("file://")) {
-    const path8 = uri.replace("file://", "");
-    const fileName = path8.split("/").pop() ?? path8;
+    const path9 = uri.replace("file://", "");
+    const fileName = path9.split("/").pop() ?? path9;
     return `[@${fileName}](${uri})`;
   }
   return uri;
@@ -28005,7 +28814,7 @@ function readAdditionalDirectories(cwd, additionalDirectories, meta3) {
     if (directory.length === 0) {
       throw RequestError.invalidParams(void 0, "additionalDirectories entries must not be empty");
     }
-    if (!path6.isAbsolute(directory)) {
+    if (!path7.isAbsolute(directory)) {
       throw RequestError.invalidParams(void 0, "additionalDirectories entries must be absolute paths");
     }
     if (!seen.has(directory)) {
@@ -28160,11 +28969,11 @@ var CodexAppServerClient = class {
     });
     this.connection.onRequest(PermissionsApprovalRequest, async (params) => {
       if (this.isStaleTurn(params.threadId, params.turnId)) {
-        return { permissions: {}, scope: "turn", strictAutoReview: true };
+        return { permissions: {}, scope: "turn", strictAutoReview: false };
       }
       const handler = this.approvalHandlers.get(params.threadId);
       if (!handler) {
-        return { permissions: {}, scope: "turn", strictAutoReview: true };
+        return { permissions: {}, scope: "turn", strictAutoReview: false };
       }
       return await handler.handlePermissionsRequest(params);
     });
@@ -28927,11 +29736,14 @@ var CodexCommands = class {
     this.runWithProcessCheck = runWithProcessCheck;
     this.onLogout = onLogout;
   }
-  async publish(sessionState) {
+  async publish(sessionState, shouldPublish = () => true) {
     try {
+      if (!shouldPublish()) {
+        return;
+      }
       const skillsResponse = await this.runWithProcessCheck(() => this.codexAcpClient.listSkills(this.createSkillsListParams(sessionState)));
       const availableCommands = this.buildAvailableCommands(skillsResponse?.data ?? []);
-      if (availableCommands.length === 0) {
+      if (availableCommands.length === 0 || !shouldPublish()) {
         return;
       }
       const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
@@ -28940,7 +29752,9 @@ var CodexCommands = class {
         availableCommands
       });
     } catch (err) {
-      logger.error(`Failed to publish available commands for session ${sessionState.sessionId}`, err);
+      if (shouldPublish()) {
+        logger.error(`Failed to publish available commands for session ${sessionState.sessionId}`, err);
+      }
     }
   }
   createSkillsListParams(sessionState) {
@@ -29399,7 +30213,7 @@ var SteeringQueue = class {
 
 // src/ResponseItemHistoryFallback.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 function historyFallbackUpdateKey(update) {
   switch (update.sessionUpdate) {
     case "user_message_chunk":
@@ -29639,8 +30453,8 @@ function imageBlocks(images) {
       return [{ type: "text", text: `[@image](${image})` }];
     }
     const record2 = asRecord2(image);
-    const path8 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
-    return path8 ? [{ type: "text", text: `[@image](${path8})` }] : [];
+    const path9 = record2 ? stringValue(record2["path"]) ?? stringValue(record2["url"]) : null;
+    return path9 ? [{ type: "text", text: `[@image](${path9})` }] : [];
   });
 }
 function contentBlocksFromResponseContent(content) {
@@ -30272,10 +31086,10 @@ function baseCommandName(commandName) {
   return commandName.split(/[\\/]/).pop() ?? commandName;
 }
 function absolutizePath(cwd, targetPath) {
-  if (path7.isAbsolute(targetPath) || cwd.length === 0) {
+  if (path8.isAbsolute(targetPath) || cwd.length === 0) {
     return targetPath;
   }
-  return path7.join(cwd, targetPath);
+  return path8.join(cwd, targetPath);
 }
 function withTerminalContent(event, terminalId, cwd) {
   const { rawInput, ...eventWithoutRawInput } = event;
@@ -30433,16 +31247,7 @@ function clientSupportsPlanUpdates(clientCapabilities) {
 // src/CodexAcpServer.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { once } from "node:events";
-var IMPLEMENT_PLAN_OPTION_ID = "implement_plan";
-var REVISE_PLAN_OPTION_ID = "revise_plan";
 var CODEX_PROCESS_EXITED_ERROR_CODE = 1001;
-function clientSupportsAirCapability(capabilities, capability) {
-  const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
-  const air = jetbrains?.[AIR_META_KEY];
-  const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
-  const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
-  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
-}
 function clientSupportsTypedSessionFailures(capabilities) {
   return clientSupportsAirCapability(capabilities, AIR_SESSION_FAILURE_KEY);
 }
@@ -30475,6 +31280,7 @@ var CodexAcpServer = class _CodexAcpServer {
   sessionGenerations;
   sessionOpenGenerations;
   goalControlGenerations;
+  permissionLifecycleContexts;
   codexProcessState;
   initializeRequest = null;
   providerUpdate = null;
@@ -30488,6 +31294,7 @@ var CodexAcpServer = class _CodexAcpServer {
     this.sessionGenerations = /* @__PURE__ */ new Map();
     this.sessionOpenGenerations = /* @__PURE__ */ new Map();
     this.goalControlGenerations = /* @__PURE__ */ new Map();
+    this.permissionLifecycleContexts = /* @__PURE__ */ new WeakMap();
     this.connection = connection;
     this.codexAcpClient = codexAcpClient;
     this.defaultAuthRequest = defaultAuthRequest ?? null;
@@ -30518,6 +31325,14 @@ var CodexAcpServer = class _CodexAcpServer {
     this.terminalOutputMode = resolveTerminalOutputMode(_params.clientCapabilities);
     this.booleanConfigOptionsSupported = clientSupportsBooleanConfigOptions(_params.clientCapabilities);
     await this.runWithProcessCheck(() => this.codexAcpClient.initialize(_params));
+    const sessionCapabilities = {
+      resume: {},
+      list: {},
+      close: {},
+      delete: {},
+      additionalDirectories: {},
+      subagents: {}
+    };
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -30535,13 +31350,7 @@ var CodexAcpServer = class _CodexAcpServer {
           embeddedContext: true,
           image: true
         },
-        sessionCapabilities: {
-          resume: {},
-          list: {},
-          close: {},
-          delete: {},
-          additionalDirectories: {}
-        },
+        sessionCapabilities,
         mcpCapabilities: {
           acp: false,
           http: true,
@@ -30563,7 +31372,8 @@ var CodexAcpServer = class _CodexAcpServer {
             [AIR_EXTENSION_VERSION_KEY]: AIR_EXTENSION_VERSION,
             [AIR_EXTENSION_CAPABILITIES_KEY]: [
               AIR_SESSION_FAILURE_KEY,
-              AIR_AGENT_FILE_CHANGE_REPORT_KEY
+              AIR_AGENT_FILE_CHANGE_REPORT_KEY,
+              AIR_NATIVE_SUBAGENT_SESSIONS_KEY
             ]
           }
         }
@@ -30615,7 +31425,7 @@ var CodexAcpServer = class _CodexAcpServer {
           }
         } else if (methodRequest.params.action === "pause") {
           const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionState.sessionId, "paused"));
-          if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+          if (this.sessionPublishIsCurrent(sessionState, sessionGeneration)) {
             await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(goal), false);
           }
         } else if (methodRequest.params.action === "resume") {
@@ -30627,7 +31437,7 @@ var CodexAcpServer = class _CodexAcpServer {
               updatedGoal = goal;
             }
           ));
-          if (updatedGoal !== null && this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+          if (updatedGoal !== null && this.sessionPublishIsCurrent(sessionState, sessionGeneration)) {
             await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(updatedGoal), false);
           }
           if (turnCompleted === null && updatedGoal !== null) {
@@ -30640,7 +31450,7 @@ var CodexAcpServer = class _CodexAcpServer {
           }
         } else if (methodRequest.params.action === "clear") {
           await this.runWithProcessCheck(() => this.codexAcpClient.clearGoal(sessionState.sessionId));
-          if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+          if (this.sessionPublishIsCurrent(sessionState, sessionGeneration)) {
             await this.publishGoalSnapshot(sessionState, null, false);
           }
         }
@@ -30816,7 +31626,12 @@ Check ${configPath} and project .codex directories, especially their config.toml
       terminalOutputMode: this.terminalOutputMode,
       goalRevision: 0,
       sessionTitle: null,
-      sessionTitleSource: "sessionId" in request ? "unknown" : "unset"
+      sessionTitleSource: "sessionId" in request ? "unknown" : "unset",
+      subagents: new CodexSubagentEventRouter(
+        sessionId,
+        clientSupportsSubagents(this.clientCapabilities),
+        new ACPSessionConnection(this.connection, sessionId)
+      )
     };
     this.sessions.set(sessionId, sessionState);
     resumeSubscribed = false;
@@ -30827,7 +31642,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       });
       this.publishMcpStartupStatusAsync(sessionId);
     }
-    this.publishAvailableCommandsAsync(sessionState);
+    this.publishAvailableCommandsAsync(sessionState, sessionGeneration);
     if ("sessionId" in request) {
       this.publishCurrentGoalAsync(sessionState, sessionGeneration);
     }
@@ -31010,12 +31825,24 @@ Check ${configPath} and project .codex directories, especially their config.toml
     if (requestId == null || !clientSupportsUrlElicitation(this.clientCapabilities)) {
       return void 0;
     }
+    let elicitationId = null;
     return {
-      elicitUrl: (request) => this.connection.request(methods.client.elicitation.create, {
-        mode: "url",
-        requestId,
-        ...request
-      })
+      elicitUrl: (request) => {
+        elicitationId = request.elicitationId;
+        return this.connection.request(methods.client.elicitation.create, {
+          mode: "url",
+          requestId,
+          ...request
+        });
+      },
+      completeElicitation: async () => {
+        if (elicitationId === null) {
+          return;
+        }
+        await this.connection.notify(methods.client.elicitation.complete, {
+          elicitationId
+        });
+      }
     };
   }
   async logout(_params) {
@@ -31404,7 +32231,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionId: sessionState.sessionId,
       prompt: GOAL_CONTINUATION_PROMPT
     }, "Goal continuation", async () => {
-      if (!this.goalPublishIsCurrent(sessionState, sessionGeneration) || this.goalControlGenerations.get(sessionState.sessionId) !== goalControlGeneration) {
+      if (!this.sessionPublishIsCurrent(sessionState, sessionGeneration) || this.goalControlGenerations.get(sessionState.sessionId) !== goalControlGeneration) {
         return false;
       }
       const currentGoal = await this.runWithProcessCheck(() => this.codexAcpClient.getGoal(sessionState.sessionId));
@@ -31515,8 +32342,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
   isSessionConfigEnabled() {
     return !isJetBrains2026_1Client(this.clientInfo);
   }
-  publishAvailableCommandsAsync(sessionState) {
-    void this.availableCommands.publish(sessionState);
+  publishAvailableCommandsAsync(sessionState, sessionGeneration) {
+    void this.publishAvailableCommands(sessionState, sessionGeneration);
+  }
+  async publishAvailableCommands(sessionState, sessionGeneration) {
+    await this.availableCommands.publish(
+      sessionState,
+      () => this.sessionPublishIsCurrent(sessionState, sessionGeneration)
+    );
   }
   publishCurrentGoalAsync(sessionState, sessionGeneration) {
     void this.publishCurrentGoalBestEffort(sessionState, sessionGeneration, true);
@@ -31532,12 +32365,12 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const requestRevision = ++sessionState.goalRevision;
     const goal = await this.runWithProcessCheck(() => this.codexAcpClient.getGoal(sessionState.sessionId));
     const snapshot = goal === null ? null : toThreadGoalSnapshot(goal);
-    if (!this.goalPublishIsCurrent(sessionState, sessionGeneration) || sessionState.goalRevision !== requestRevision) {
+    if (!this.sessionPublishIsCurrent(sessionState, sessionGeneration) || sessionState.goalRevision !== requestRevision) {
       return;
     }
     await this.publishGoalSnapshot(sessionState, snapshot, force, false);
   }
-  goalPublishIsCurrent(sessionState, sessionGeneration) {
+  sessionPublishIsCurrent(sessionState, sessionGeneration) {
     return this.sessions.get(sessionState.sessionId) === sessionState && this.getSessionGeneration(sessionState.sessionId) === sessionGeneration && !this.sessionIsClosing(sessionState.sessionId);
   }
   async publishGoalSnapshot(sessionState, snapshot, force, incrementRevision = true) {
@@ -31639,7 +32472,12 @@ Check ${configPath} and project .codex directories, especially their config.toml
       terminalOutputMode: this.terminalOutputMode,
       goalRevision: 0,
       sessionTitle: null,
-      sessionTitleSource: "unset"
+      sessionTitleSource: "unset",
+      subagents: new CodexSubagentEventRouter(
+        sessionId,
+        clientSupportsSubagents(this.clientCapabilities),
+        new ACPSessionConnection(this.connection, sessionId)
+      )
     };
     this.sessions.set(sessionId, sessionState);
     subscribed = false;
@@ -31650,7 +32488,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       });
       this.publishMcpStartupStatusAsync(sessionId);
     }
-    await this.availableCommands.publish(sessionState);
+    await this.publishAvailableCommands(sessionState, requestedSessionGeneration);
     await this.publishCurrentGoalBestEffort(sessionState, requestedSessionGeneration, true);
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
@@ -31665,6 +32503,16 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const session = new ACPSessionConnection(this.connection, sessionId);
     const sessionState = this.getSessionState(sessionId);
     await this.publishThreadHistoryTitle(session, sessionState, thread);
+    if (clientSupportsSubagents(this.clientCapabilities)) {
+      await this.streamNativeThreadHistory(
+        sessionId,
+        thread,
+        sessionState,
+        /* @__PURE__ */ new Set([sessionId]),
+        /* @__PURE__ */ new Map([[sessionId, thread]])
+      );
+      return;
+    }
     const responseItemFallbackUpdates = await createResponseItemHistoryFallbackUpdates(
       thread,
       sessionState.terminalOutputMode
@@ -31681,6 +32529,93 @@ Check ${configPath} and project .codex directories, especially their config.toml
       await session.update(update);
     }
   }
+  async streamNativeThreadHistory(sessionId, thread, sessionState, ancestry, threadCache) {
+    const session = new ACPSessionConnection(this.connection, sessionId);
+    const announced = /* @__PURE__ */ new Map();
+    for (const turn of thread.turns) {
+      for (const item of turn.items) {
+        if (item.type === "subAgentActivity") {
+          const activityKind = item.kind;
+          if (activityKind === "started") {
+            const previous = announced.get(item.agentThreadId);
+            if (previous && !previous.terminal) continue;
+            const generation = (previous?.generation ?? 0) + 1;
+            const childSessionId = generation === 1 ? item.agentThreadId : `${item.agentThreadId}:generation:${generation}`;
+            const name = nameFromAgentPath(item.agentPath, `Agent ${item.agentThreadId.slice(-8)}`);
+            await session.update({
+              sessionUpdate: "subagent_spawned",
+              subagentSessionId: childSessionId,
+              name,
+              task: `Delegated task for ${name}`,
+              capabilities: {}
+            });
+            announced.set(item.agentThreadId, { generation, sessionId: childSessionId, terminal: false });
+            if (!ancestry.has(item.agentThreadId)) {
+              let child = threadCache.get(item.agentThreadId);
+              if (child === void 0) {
+                try {
+                  child = await this.codexAcpClient.readSessionThread(item.agentThreadId);
+                  threadCache.set(item.agentThreadId, child);
+                } catch (error51) {
+                  threadCache.set(item.agentThreadId, null);
+                  logger.error(`Failed to read subagent history ${item.agentThreadId}`, error51);
+                  child = null;
+                }
+              }
+              const childTurn = child?.turns[generation - 1];
+              if (child && childTurn) {
+                await this.streamNativeThreadHistory(
+                  childSessionId,
+                  { ...child, turns: [childTurn] },
+                  sessionState,
+                  /* @__PURE__ */ new Set([...ancestry, item.agentThreadId]),
+                  threadCache
+                );
+              }
+            }
+          } else if (activityKind === "completed" || activityKind === "interrupted") {
+            const child = announced.get(item.agentThreadId);
+            if (!child) {
+              const name = nameFromAgentPath(item.agentPath, `Agent ${item.agentThreadId.slice(-8)}`);
+              await session.update({
+                sessionUpdate: "subagent_spawned",
+                subagentSessionId: item.agentThreadId,
+                name,
+                task: `Delegated task for ${name}`,
+                capabilities: {}
+              });
+              announced.set(item.agentThreadId, {
+                generation: 1,
+                sessionId: item.agentThreadId,
+                terminal: false
+              });
+              continue;
+            }
+            if (child.terminal) continue;
+            await session.update({
+              sessionUpdate: "subagent_state_update",
+              subagentSessionId: child.sessionId,
+              state: activityKind === "completed" ? "completed" : "cancelled"
+            });
+            child.terminal = true;
+          }
+          continue;
+        }
+        if (item.type === "collabAgentToolCall") continue;
+        for (const update of await this.createHistoryUpdates(item, sessionState)) {
+          await session.update(update);
+        }
+      }
+    }
+    for (const child of announced.values()) {
+      if (child.terminal) continue;
+      await session.update({
+        sessionUpdate: "subagent_state_update",
+        subagentSessionId: child.sessionId,
+        state: "disconnected"
+      });
+    }
+  }
   async publishThreadHistoryTitle(session, sessionState, thread) {
     const explicitTitle = this.normalizeSessionTitle(thread.name);
     if (explicitTitle) {
@@ -31885,8 +32820,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return `[@${name}](${uri})`;
     }
     if (uri.startsWith("file://")) {
-      const path8 = uri.replace("file://", "");
-      const fileName = path8.split("/").pop() ?? path8;
+      const path9 = uri.replace("file://", "");
+      const fileName = path9.split("/").pop() ?? path9;
       return `[@${fileName}](${uri})`;
     }
     return uri;
@@ -31898,6 +32833,13 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
     return sessionState;
   }
+  permissionLifecycleContext(sessionState) {
+    const existing = this.permissionLifecycleContexts.get(sessionState);
+    if (existing) return existing;
+    const context = new PermissionLifecycleContext(sessionState);
+    this.permissionLifecycleContexts.set(sessionState, context);
+    return context;
+  }
   resolveSessionMcpServers(mcpServers, recoverFromStartup) {
     const requestedServerNames = getRequestedMcpServerNames(mcpServers);
     if (requestedServerNames.length > 0) {
@@ -32145,6 +33087,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const agentFileChangeReportRequest = clientSupportsAgentFileChangeReports(this.clientCapabilities) ? parseAgentFileChangeReportRequest(params._meta) : null;
     let agentFileChangeReportTurnId = null;
     let agentFileChangeReportUnavailableReason = "providerError";
+    let promptWasCancelled = false;
     let recoverableSessionFailure = sessionState.sessionFailure;
     sessionState.currentTurnId = null;
     sessionState.lastTokenUsage = null;
@@ -32168,6 +33111,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
     };
     const cancelledPromptResponse = () => {
+      promptWasCancelled = true;
       agentFileChangeReportTurnId = null;
       agentFileChangeReportUnavailableReason = "cancelled";
       return this.cancelledPromptResponse(sessionState);
@@ -32178,32 +33122,46 @@ Check ${configPath} and project .codex directories, especially their config.toml
         sessionState,
         clientSupportsPlanUpdates(this.clientCapabilities),
         clientSupportsTypedSessionFailures(this.clientCapabilities),
-        this.sessionFailureEpoch
+        this.sessionFailureEpoch,
+        sessionState.subagents
       );
       eventHandler = promptEventHandler;
-      const approvalHandler = new CodexApprovalHandler(this.connection, sessionState, activePrompt.signal);
+      const permissionLifecycle = this.permissionLifecycleContext(sessionState);
+      const permissionContext = permissionLifecycle.beginPrompt();
+      const approvalHandler = new CodexApprovalHandler(
+        this.connection,
+        permissionContext,
+        activePrompt.signal
+      );
       const elicitationHandler = new CodexElicitationHandler(
         this.connection,
-        sessionState,
+        permissionContext,
         this.clientCapabilities,
         activePrompt.signal
       );
+      const observeInteraction = async (event) => {
+        permissionContext.handleNotification(event);
+        await elicitationHandler.handleNotification(event);
+      };
       await this.codexAcpClient.subscribeToSessionEvents(
         params.sessionId,
         async (event) => {
+          await observeInteraction(event);
           if (!promptNotificationsActive) {
             await promptEventHandler.handleSessionScopedNotification(event);
             return;
           }
-          const completesActiveTurn = event.method === "turn/completed" && event.params.turn.id === sessionState.currentTurnId;
-          await elicitationHandler.handleNotification(event);
+          const completesActiveTurn = event.method === "turn/completed" && event.params.threadId === sessionState.sessionId && event.params.turn.id === sessionState.currentTurnId;
           await promptEventHandler.handleNotification(event);
           if (completesActiveTurn) {
             promptNotificationsActive = false;
           }
         },
         approvalHandler,
-        elicitationHandler
+        elicitationHandler,
+        clientSupportsSubagents(this.clientCapabilities),
+        observeInteraction,
+        (childThreadId) => promptEventHandler.waitForNativeSubagentSession(childThreadId)
       );
       if (activePrompt.signal.aborted) {
         return cancelledPromptResponse();
@@ -32344,6 +33302,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return cancelledPromptResponse();
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+      if (turnCompleted.turn.status === "completed") {
+        await eventHandler.waitForNativeSubagents(activePrompt.signal);
+        if (activePrompt.signal.aborted) return cancelledPromptResponse();
+        await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+      } else {
+        await eventHandler.finishOutstandingNativeSubagents(
+          turnCompleted.turn.status === "interrupted" ? "cancelled" : "failed"
+        );
+      }
       await eventHandler.flushPendingErrors();
       await eventHandler.handleFailedTurn(turnCompleted.turn);
       promptNotificationsActive = false;
@@ -32424,6 +33391,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
             return cancelledPromptResponse();
           }
           await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          if (turnCompleted.turn.status === "completed") {
+            await eventHandler.waitForNativeSubagents(activePrompt.signal);
+            if (activePrompt.signal.aborted) return cancelledPromptResponse();
+            await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          } else {
+            await eventHandler.finishOutstandingNativeSubagents(
+              turnCompleted.turn.status === "interrupted" ? "cancelled" : "failed"
+            );
+          }
           await eventHandler.flushPendingErrors();
           await eventHandler.handleFailedTurn(turnCompleted.turn);
           promptNotificationsActive = false;
@@ -32485,6 +33461,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
       throw err;
     } finally {
       promptNotificationsActive = false;
+      try {
+        await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+        await eventHandler?.finishOutstandingNativeSubagents(
+          promptWasCancelled || activePrompt.signal.aborted || this.sessionIsClosing(params.sessionId) ? "cancelled" : "failed"
+        );
+      } catch (error51) {
+        logger.error("Failed to publish terminal subagent state during prompt cleanup", error51);
+      }
       if (agentFileChangeReportRequest !== null) {
         await this.publishAgentFileChangeReport(
           sessionState,
@@ -32507,41 +33491,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
   }
   async requestPlanImplementationPermission(sessionState, plan, cancellationSignal) {
-    const toolCallId = `plan-review:${plan.itemId}`;
+    const toolCallId = planImplementationToolCallId(plan);
     try {
       const response = await this.connection.request(
         methods.client.session.requestPermission,
-        {
-          sessionId: sessionState.sessionId,
-          toolCall: {
-            toolCallId,
-            title: "Implement this plan?",
-            kind: "switch_mode",
-            status: "pending",
-            rawInput: { plan: plan.text }
-          },
-          options: [
-            {
-              optionId: IMPLEMENT_PLAN_OPTION_ID,
-              name: "Yes, implement this plan",
-              kind: "allow_once"
-            },
-            {
-              optionId: REVISE_PLAN_OPTION_ID,
-              name: "No, and tell Codex what to do differently",
-              kind: "reject_once"
-            }
-          ],
-          _meta: {
-            codex: {
-              kind: "plan_review",
-              planItemId: plan.itemId
-            }
-          }
-        },
+        planImplementationPermissionRequest(sessionState.sessionId, plan),
         { cancellationSignal }
       );
-      const approved = response.outcome.outcome === "selected" && response.outcome.optionId === IMPLEMENT_PLAN_OPTION_ID;
+      const approved = planImplementationApproved(response);
       await this.connection.notify(methods.client.session.update, {
         sessionId: sessionState.sessionId,
         update: {