lody 0.74.0 → 0.76.0

package/dist/chunks/{index-Cuqd9gip.js → index-VHXDv9iy.js}

@@ -17519,6 +17519,7 @@ var zToolCallUpdate = object({
   kind: defaultOnError(zToolKind.nullish(), () => void 0),
   status: defaultOnError(zToolCallStatus.nullish(), () => void 0),
   title: defaultOnError(string2().nullish(), () => void 0),
+  name: defaultOnError(string2().nullish(), () => void 0),
   content: defaultOnError(vecSkipError(zToolCallContent).nullish(), () => void 0),
   locations: defaultOnError(vecSkipError(zToolCallLocation).nullish(), () => void 0),
   rawInput: defaultOnError(unknown().optional(), () => void 0),
@@ -18284,6 +18285,7 @@ var zContentChunk = object({
 var zToolCall = object({
   toolCallId: zToolCallId,
   title: string2(),
+  name: defaultOnError(string2().nullish(), () => void 0),
   kind: defaultOnError(zToolKind.optional(), () => void 0),
   status: defaultOnError(zToolCallStatus.optional(), () => void 0),
   content: defaultOnError(vecSkipError(zToolCallContent).optional(), () => []),
@@ -18964,63 +18966,70 @@ object({
   requestId: zRequestId,
   _meta: defaultOnError(record(string2(), unknown()).nullish(), () => void 0)
 });
-function tagOf(value, key) {
-  return typeof value === "object" && value !== null ? value[key] : void 0;
+var CANCEL_REQUEST_METHOD = "$/cancel_request";
+function isRequestMessage(value) {
+  return isJsonRpcEnvelope(value) && "id" in value && typeof value["method"] === "string" && isJsonRpcId(value["id"]);
 }
-zElicitationFormMode.and(object({ mode: literal("form") })).and(object({ message: string2() }));
-zElicitationUrlMode.and(object({ mode: literal("url") })).and(object({ message: string2() }));
-union([zElicitationSessionScope, zElicitationRequestScope]).and(object({ message: string2() }));
-zStringPropertySchema.and(object({ type: literal("string") }));
-zNumberPropertySchema.and(object({ type: literal("number") }));
-zIntegerPropertySchema.and(object({ type: literal("integer") }));
-zBooleanPropertySchema.and(object({ type: literal("boolean") }));
-zMultiSelectPropertySchema.and(object({ type: literal("array") }));
-zStringMultiSelectItems.and(object({ type: literal("string") }));
-var zGuardCreateElicitationResponseAccept = zElicitationAcceptAction.and(object({ action: literal("accept") }));
-var zGuardCreateElicitationResponseDecline = object({
-  action: literal("decline")
-});
-var zGuardCreateElicitationResponseCancel = object({
-  action: literal("cancel")
-});
-var CreateElicitationResponse = {
-  /** Narrow to the `accept` variant, validating its payload. */
-  isAccept(value) {
-    return tagOf(value, "action") === "accept" && zGuardCreateElicitationResponseAccept.safeParse(value).success;
-  },
-  /** Narrow to the `decline` variant, validating its payload. */
-  isDecline(value) {
-    return tagOf(value, "action") === "decline" && zGuardCreateElicitationResponseDecline.safeParse(value).success;
-  },
-  /** Narrow to the `cancel` variant, validating its payload. */
-  isCancel(value) {
-    return tagOf(value, "action") === "cancel" && zGuardCreateElicitationResponseCancel.safeParse(value).success;
-  },
-  /**
-   * Narrow to a custom or future variant: the `action` tag matches no known variant.
-   *
-   * TypeScript keeps the known variants in the narrowed union (they are
-   * structural subtypes of the catch-all), so read vendor payload keys
-   * via a widening cast: `(value as Record<string, unknown>).someKey`.
-   */
-  isCustom(value) {
-    const tag = tagOf(value, "action");
-    return typeof tag === "string" && !["accept", "cancel", "decline"].includes(tag);
+function isResponseMessage(value) {
+  if (!isJsonRpcEnvelope(value) || "method" in value) {
+    return false;
   }
-};
-var CANCEL_REQUEST_METHOD = "$/cancel_request";
+  if (!("id" in value) || !isJsonRpcId(value["id"])) {
+    return false;
+  }
+  const hasResult = Object.hasOwn(value, "result");
+  const hasError = Object.hasOwn(value, "error");
+  if (hasResult === hasError) {
+    return false;
+  }
+  return !hasError || isErrorResponse(value["error"]);
+}
+function isNotificationMessage(value) {
+  return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
+function isJsonRpcEnvelope(value) {
+  return isRecord(value) && value["jsonrpc"] === "2.0";
+}
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
+function isResponseShapedMessage(value) {
+  return isRecord(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
+}
+function isResponseBatch(batch) {
+  let hasValidCall = false;
+  let hasValidResponse = false;
+  let hasCallShape = false;
+  let hasResponseShape = false;
+  for (const entry of batch) {
+    hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
+    hasValidResponse ||= isResponseMessage(entry);
+    if (!isRecord(entry)) {
+      continue;
+    }
+    hasCallShape ||= "method" in entry;
+    hasResponseShape ||= "result" in entry || "error" in entry;
+  }
+  if (hasValidCall) {
+    return false;
+  }
+  if (hasValidResponse) {
+    return true;
+  }
+  return hasResponseShape && !hasCallShape;
+}
 function cancelRequestId(params) {
   if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
     return void 0;
   }
   return params["requestId"];
 }
+function isErrorResponse(value) {
+  return isRecord(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
+}
 var Handled = {
   /**
    * Marks a message as handled.
@@ -19180,6 +19189,12 @@ var ConnectionContext = class {
   sendNotification(method, params) {
     return this.connection.sendNotification(method, params);
   }
+  /**
+   * Sends a non-empty JSON-RPC batch in one transport message.
+   */
+  sendBatch(entries) {
+    return this.connection.sendBatch(entries);
+  }
   /**
    * Sends a protocol-level request cancellation notification.
    */
@@ -19218,6 +19233,7 @@ var Connection = class {
   retryQueue = [];
   context = new ConnectionContext(this);
   receiveReader;
+  allowBatches = true;
   constructor(requestHandlerOrStream, notificationHandlerOrHandlers, streamOrOptions, options) {
     if (typeof requestHandlerOrStream === "function") {
       const requestHandler = requestHandlerOrStream;
@@ -19226,16 +19242,13 @@ var Connection = class {
       this.initialize(stream2, [
         ...options?.handlers ?? [],
         this.legacyHandler(requestHandler, notificationHandler)
-      ]);
+      ], options);
       return;
     }
     const stream = requestHandlerOrStream;
     const handlers = notificationHandlerOrHandlers;
     const connectionOptions = streamOrOptions;
-    this.initialize(stream, [
-      ...connectionOptions?.handlers ?? [],
-      ...handlers
-    ]);
+    this.initialize(stream, [...connectionOptions?.handlers ?? [], ...handlers], connectionOptions);
   }
   /**
    * Creates a builder for configuring a handler-based connection.
@@ -19309,15 +19322,89 @@ var Connection = class {
     if (this.abortController.signal.aborted) {
       return rejectedPromise(this.closedReason());
     }
+    const request = this.prepareRequest(method, params, mapResponse, options);
+    const requestSent = this.sendWireMessage(request.message);
+    void requestSent.catch(() => {
+    });
+    if (options.cancellationSignal?.aborted) {
+      request.cancel();
+    }
+    return request.response;
+  }
+  /**
+   * Sends a non-empty JSON-RPC batch in one transport message.
+   *
+   * Requests and notifications are processed independently by the peer. The
+   * returned tuple preserves the input order: request entries resolve to their
+   * mapped response, while notification entries resolve to `undefined`.
+   */
+  sendBatch(entries) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
+    if (!this.allowBatches) {
+      return rejectedPromise(new TypeError("JSON-RPC batches are not supported on this connection"));
+    }
+    if (entries.length === 0) {
+      return rejectedPromise(new TypeError("JSON-RPC batch must contain at least one entry"));
+    }
+    const messages = [];
+    const cancellations = [];
+    const outputs = [];
+    for (const entry of entries) {
+      if (entry.kind === "notification") {
+        messages.push({
+          jsonrpc: "2.0",
+          method: entry.method,
+          params: entry.params
+        });
+        outputs.push(Promise.resolve(void 0));
+        continue;
+      }
+      const request = this.prepareRequest(entry.method, entry.params, entry.mapResponse, entry.options);
+      messages.push(request.message);
+      outputs.push(request.response);
+      cancellations.push({
+        signal: entry.options?.cancellationSignal,
+        cancel: request.cancel
+      });
+    }
+    const batch = messages;
+    const batchSent = this.sendWireMessage(batch);
+    for (const cancellation of cancellations) {
+      if (cancellation.signal?.aborted) {
+        cancellation.cancel();
+      }
+    }
+    const response = Promise.all([batchSent, ...outputs]).then(([, ...resolved]) => resolved);
+    response.catch(() => {
+    });
+    return response;
+  }
+  /**
+   * Sends a protocol-level request cancellation notification.
+   */
+  sendCancelRequest(requestId) {
+    return this.sendNotification(CANCEL_REQUEST_METHOD, { requestId });
+  }
+  /**
+   * Sends a JSON-RPC notification.
+   */
+  sendNotification(method, params) {
+    if (this.abortController.signal.aborted) {
+      return rejectedPromise(this.closedReason());
+    }
+    return this.sendWireMessage({ jsonrpc: "2.0", method, params });
+  }
+  prepareRequest(method, params, mapResponse, options = {}) {
     const id = this.nextRequestId++;
     let cancel = () => {
     };
-    const responsePromise = new Promise((resolve, reject) => {
+    const response = new Promise((resolve, reject) => {
       const pendingResponse = {
-        resolve: (response) => {
+        resolve: (value) => {
           try {
-            const value = mapResponse ? mapResponse(response) : response;
-            resolve(value);
+            resolve(mapResponse ? mapResponse(value) : value);
           } catch (error48) {
             reject(error48);
           }
@@ -19341,35 +19428,13 @@ var Connection = class {
       };
       this.pendingResponses.set(id, pendingResponse);
     });
-    responsePromise.catch(() => {
+    response.catch(() => {
     });
-    const requestSent = this.sendMessage({
-      jsonrpc: "2.0",
-      id,
-      method,
-      params
-    });
-    void requestSent.catch(() => {
-    });
-    if (options.cancellationSignal?.aborted) {
-      cancel();
-    }
-    return responsePromise;
-  }
-  /**
-   * Sends a protocol-level request cancellation notification.
-   */
-  sendCancelRequest(requestId) {
-    return this.sendNotification(CANCEL_REQUEST_METHOD, { requestId });
-  }
-  /**
-   * Sends a JSON-RPC notification.
-   */
-  sendNotification(method, params) {
-    if (this.abortController.signal.aborted) {
-      return rejectedPromise(this.closedReason());
-    }
-    return this.sendMessage({ jsonrpc: "2.0", method, params });
+    return {
+      message: { jsonrpc: "2.0", id, method, params },
+      response,
+      cancel: () => cancel()
+    };
   }
   /**
    * Closes the connection and rejects pending requests.
@@ -19392,9 +19457,10 @@ var Connection = class {
     void this.receiveReader?.cancel(closeError).catch(() => {
     });
   }
-  initialize(stream, handlers) {
+  initialize(stream, handlers, options) {
     this.stream = stream;
     this.staticHandlers = handlers;
+    this.allowBatches = options?.allowBatches ?? true;
     this.closedPromise = new Promise((resolve) => {
       this.abortController.signal.addEventListener("abort", () => resolve());
     });
@@ -19430,7 +19496,7 @@ var Connection = class {
           if (!message) {
             continue;
           }
-          this.receiveMessage(message);
+          this.receiveWireMessage(message);
         }
       } finally {
         if (this.receiveReader === reader) {
@@ -19444,24 +19510,93 @@ var Connection = class {
       this.close(closeError);
     }
   }
-  receiveMessage(message) {
-    if (this.abortController.signal.aborted) {
+  receiveWireMessage(message) {
+    if (Array.isArray(message)) {
+      if (!this.allowBatches) {
+        this.close(new TypeError("JSON-RPC batches are not supported on this connection"));
+        return;
+      }
+      this.receiveBatch(message);
       return;
     }
     if (!isRecord(message)) {
       console.error("Invalid message", { message });
       return;
     }
+    this.receiveMessage(message);
+  }
+  receiveBatch(batch) {
+    if (batch.length === 0) {
+      void this.sendWireMessage({
+        jsonrpc: "2.0",
+        id: null,
+        error: RequestError.invalidRequest(batch).toErrorResponse()
+      }).catch(() => {
+      });
+      return;
+    }
+    const responseBatch = isResponseBatch(batch);
+    const responseCount = responseBatch ? 0 : batch.reduce((count, message) => count + (isNotificationMessage(message) ? 0 : 1), 0);
+    let remaining = responseCount;
+    let remainingNotifications = batch.reduce((count, message) => count + (isNotificationMessage(message) ? 1 : 0), 0);
+    let responseSent = false;
+    const responses = [];
+    const sendResponsesIfReady = async () => {
+      if (responseSent || remaining !== 0 || remainingNotifications !== 0 || responses.length === 0) {
+        return;
+      }
+      responseSent = true;
+      await this.sendWireMessage(responses);
+    };
+    const collectResponse = async (response) => {
+      responses.push(response);
+      remaining -= 1;
+      await sendResponsesIfReady();
+    };
+    for (const message of batch) {
+      if (responseBatch) {
+        if (isResponseShapedMessage(message)) {
+          this.receiveMessage(message);
+        }
+        continue;
+      }
+      if (!isRequestMessage(message) && !isNotificationMessage(message)) {
+        void collectResponse({
+          jsonrpc: "2.0",
+          id: null,
+          error: RequestError.invalidRequest(message).toErrorResponse()
+        }).catch(() => {
+        });
+        continue;
+      }
+      const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : void 0);
+      if (isNotificationMessage(message)) {
+        void processing.finally(() => {
+          remainingNotifications -= 1;
+          void sendResponsesIfReady().catch((error48) => this.close(error48));
+        });
+      }
+    }
+  }
+  receiveMessage(message, sendResponse) {
+    if (this.abortController.signal.aborted) {
+      return Promise.resolve();
+    }
+    if (!isRecord(message)) {
+      console.error("Invalid message", { message });
+      return Promise.resolve();
+    }
     if ("method" in message) {
       if (!("id" in message)) {
         this.handleProtocolNotification(message);
       }
-      void this.processIncomingMessage(this.toIncomingMessage(message)).catch((error48) => this.close(error48));
+      return this.processIncomingMessage(this.toIncomingMessage(message, sendResponse)).catch((error48) => this.close(error48));
     } else if ("id" in message) {
       this.handleResponse(message);
     } else {
       console.error("Invalid message", { message });
     }
+    return Promise.resolve();
   }
   async processIncomingMessage(message) {
     if (this.abortController.signal.aborted) {
@@ -19505,7 +19640,7 @@ var Connection = class {
       }
     }
   }
-  toIncomingMessage(message) {
+  toIncomingMessage(message, sendResponse) {
     if ("id" in message) {
       const abortController = new AbortController();
       this.incomingRequests.set(message.id, abortController);
@@ -19520,11 +19655,14 @@ var Connection = class {
         params: message.params,
         raw: message,
         signal: abortController.signal,
-        responder: new RequestResponder(message.id, (result) => this.sendMessage({
-          jsonrpc: "2.0",
-          id: message.id,
-          ...result
-        }), abortController.signal, finishRequest)
+        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)
       };
     }
     return {
@@ -19539,13 +19677,13 @@ var Connection = class {
     if (pendingResponse) {
       this.pendingResponses.delete(response.id);
       pendingResponse.cleanup?.();
-      if ("result" in response) {
+      if (!isResponseMessage(response)) {
+        pendingResponse.reject(RequestError.invalidRequest(response));
+      } else if ("result" in response) {
         pendingResponse.resolve(response.result);
-      } else if ("error" in response && isRecord(response.error)) {
+      } else {
         const { code, message, data } = response.error;
         pendingResponse.reject(new RequestError(code, message, data));
-      } else {
-        pendingResponse.reject(RequestError.invalidRequest(response));
       }
     } else {
       console.error("Got response to unknown request", response.id);
@@ -19568,7 +19706,7 @@ var Connection = class {
   closedReason() {
     return this.abortController.signal.reason ?? new Error("ACP connection closed");
   }
-  async sendMessage(message) {
+  async sendWireMessage(message) {
     if (this.abortController.signal.aborted) {
       return rejectedPromise(this.closedReason());
     }
@@ -19810,7 +19948,7 @@ function ndJsonStream(output, input) {
         if (trimmedLine) {
           try {
             const message = JSON.parse(trimmedLine);
-            if (isRecord(message)) {
+            if (isRecord(message) || Array.isArray(message)) {
               controller.enqueue(message);
             } else {
               console.warn("Skipping JSON line that is not an object:", trimmedLine);
@@ -19883,6 +20021,53 @@ function ndJsonStream(output, input) {
   });
   return { readable, writable };
 }
+function tagOf(value, key) {
+  return typeof value === "object" && value !== null ? value[key] : void 0;
+}
+zElicitationFormMode.and(object({ mode: literal("form") })).and(object({ message: string2() }));
+zElicitationUrlMode.and(object({ mode: literal("url") })).and(object({ message: string2() }));
+union([zElicitationSessionScope, zElicitationRequestScope]).and(object({ message: string2() }));
+zStringPropertySchema.and(object({ type: literal("string") }));
+zNumberPropertySchema.and(object({ type: literal("number") }));
+zIntegerPropertySchema.and(object({ type: literal("integer") }));
+zBooleanPropertySchema.and(object({ type: literal("boolean") }));
+zMultiSelectPropertySchema.and(object({ type: literal("array") }));
+zStringMultiSelectItems.and(object({ type: literal("string") }));
+var zGuardCreateElicitationResponseAccept = zElicitationAcceptAction.and(object({ action: literal("accept") }));
+var zGuardCreateElicitationResponseDecline = object({
+  action: literal("decline")
+});
+var zGuardCreateElicitationResponseCancel = object({
+  action: literal("cancel")
+});
+var CreateElicitationResponse = {
+  /** Narrow to the `accept` variant, validating its payload. */
+  isAccept(value) {
+    return tagOf(value, "action") === "accept" && zGuardCreateElicitationResponseAccept.safeParse(value).success;
+  },
+  /** Narrow to the `decline` variant, validating its payload. */
+  isDecline(value) {
+    return tagOf(value, "action") === "decline" && zGuardCreateElicitationResponseDecline.safeParse(value).success;
+  },
+  /** Narrow to the `cancel` variant, validating its payload. */
+  isCancel(value) {
+    return tagOf(value, "action") === "cancel" && zGuardCreateElicitationResponseCancel.safeParse(value).success;
+  },
+  /**
+   * Narrow to a custom or future variant: the `action` tag matches no known variant.
+   *
+   * TypeScript keeps the known variants in the narrowed union (they are
+   * structural subtypes of the catch-all), so read vendor payload keys
+   * via a widening cast: `(value as Record<string, unknown>).someKey`.
+   */
+  isCustom(value) {
+    const tag = tagOf(value, "action");
+    return typeof tag === "string" && !["accept", "cancel", "decline"].includes(tag);
+  }
+};
+function ndJsonStream2(output, input) {
+  return ndJsonStream(output, input);
+}
 function emptyObjectResponse(response) {
   return response ?? {};
 }
@@ -20529,6 +20714,7 @@ function runConnectHandlers(connection, handlers) {
 var appBuilder = /* @__PURE__ */ Symbol("appBuilder");
 var runAgentConnectHandlers = /* @__PURE__ */ Symbol("runAgentConnectHandlers");
 var runClientConnectHandlers = /* @__PURE__ */ Symbol("runClientConnectHandlers");
+var stableConnectionOptions = { allowBatches: false };
 function agent(options) {
   return new AgentApp(options);
 }
@@ -20602,7 +20788,7 @@ var AgentApp = class {
       return state2;
     }
     const [thisStream, peerStream] = memoryStreamPair();
-    const peerRawConnection = target[appBuilder]().connect(peerStream);
+    const peerRawConnection = target[appBuilder]().connect(peerStream, stableConnectionOptions);
     const peerConnection = clientConnection(peerRawConnection);
     const state = this.openStreamConnection(thisStream);
     void state.rawConnection.closed.then(() => peerConnection.close());
@@ -20618,7 +20804,7 @@ var AgentApp = class {
     return state;
   }
   openStreamConnection(stream) {
-    const rawConnection = this.builder.connect(stream);
+    const rawConnection = this.builder.connect(stream, stableConnectionOptions);
     return {
       rawConnection,
       connection: agentConnection(rawConnection, this.connectHandlers)
@@ -20688,7 +20874,7 @@ function createJSONRPCReader(readable) {
 function createJsonStream(readable, writable) {
   const input = Writable.toWeb(writable);
   const output = Readable.toWeb(readable);
-  return ndJsonStream(input, output);
+  return ndJsonStream2(input, output);
 }
 var Logger = class {
   logFilePath;
@@ -20804,6 +20990,8 @@ var ACP_EXT_SESSION_USAGE_UPDATE_METHOD = "_acp_ext:session_usage_update";
 var ACP_EXT_SESSION_RATE_LIMITS_METHOD = "_acp_ext:session_rate_limits";
 var ACP_EXT_CODEX_PROPOSED_PLAN_METHOD = "_acp_ext:codex_proposed_plan";
 var CODEX_STEER_APPLIED_METHOD = "_codex/steerApplied";
+var SESSION_STEERING_METHOD = "_session/steering";
+var GOAL_CONTROL_METHOD = "_codex/session/goal_control";
 function getLodyForkTurnId(meta3) {
   if (typeof meta3 !== "object" || meta3 === null) return null;
   const lody = meta3["lody"];
@@ -20816,21 +21004,13 @@ function getLodyForkTurnId(meta3) {
 }
 var CODEX_STEER_CAPABILITY = {
   version: 1,
+  method: SESSION_STEERING_METHOD,
   appliedNotification: CODEX_STEER_APPLIED_METHOD,
   upstreamTurn: "same",
   configPolicy: "active"
 };
-function getCodexSteerId(meta3) {
-  if (typeof meta3 !== "object" || meta3 === null) return null;
-  const codex = meta3["codex"];
-  if (typeof codex !== "object" || codex === null) return null;
-  const steer = codex["steer"];
-  if (typeof steer !== "object" || steer === null) return null;
-  const id = steer["id"];
-  return typeof id === "string" && id.length > 0 ? id : null;
-}
 function isExtMethodRequest(request) {
-  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD;
+  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD;
 }
 function toTokenCount(usage) {
   return {
@@ -21737,7 +21917,7 @@ function createWebSearchStartUpdate(item) {
     kind: "search",
     title: formatWebSearchTitle(item),
     status: "in_progress",
-    rawInput
+    rawInput: createWebSearchRawInput(item)
   };
 }
 function createWebSearchCompleteUpdate(item) {
@@ -21747,7 +21927,15 @@ function createWebSearchCompleteUpdate(item) {
     toolCallId: item.id,
     title: formatWebSearchTitle(item),
     status: "completed",
-    rawInput
+    rawInput: createWebSearchRawInput(item)
+  };
+}
+function createWebSearchRawInput(item) {
+  return {
+    type: item.type,
+    id: item.id,
+    query: item.query,
+    action: item.action
   };
 }
 function createCollabAgentToolCallUpdate(item) {
@@ -21757,7 +21945,8 @@ function createCollabAgentToolCallUpdate(item) {
     kind: "other",
     title: item.tool,
     status: toAcpStatus(item.status),
-    rawInput: createCollabAgentToolCallRawInput(item)
+    rawInput: createCollabAgentToolCallRawInput(item),
+    _meta: createCollabAgentToolCallMeta(item)
   };
 }
 function createCollabAgentToolCallCompleteUpdate(item) {
@@ -21766,7 +21955,8 @@ function createCollabAgentToolCallCompleteUpdate(item) {
     toolCallId: item.id,
     title: item.tool,
     status: toAcpStatus(item.status),
-    rawInput: createCollabAgentToolCallRawInput(item)
+    rawInput: createCollabAgentToolCallRawInput(item),
+    _meta: createCollabAgentToolCallMeta(item)
   };
 }
 function createCollabAgentToolCallRawInput(item) {
@@ -21775,9 +21965,66 @@ function createCollabAgentToolCallRawInput(item) {
     senderThreadId: item.senderThreadId,
     receiverThreadIds: item.receiverThreadIds,
     agentsStates: item.agentsStates,
+    model: item.model,
+    reasoningEffort: item.reasoningEffort,
     status: item.status
   };
 }
+function createCollabAgentToolCallMeta(item) {
+  return {
+    codex: {
+      collaboration: {
+        tool: item.tool,
+        senderThreadId: item.senderThreadId,
+        receiverThreadIds: item.receiverThreadIds
+      }
+    }
+  };
+}
+function createSubAgentActivityUpdate(item, status, sessionUpdate) {
+  const name = item.agentPath.split("/").filter(Boolean).at(-1) ?? "subagent";
+  const title = formatSubAgentActivityTitle(item.kind, name);
+  const common = {
+    toolCallId: item.id,
+    status,
+    rawInput: {
+      agentThreadId: item.agentThreadId,
+      agentPath: item.agentPath,
+      activityKind: item.kind
+    },
+    _meta: {
+      codex: {
+        subagent: {
+          threadId: item.agentThreadId,
+          path: item.agentPath,
+          activity: item.kind
+        }
+      }
+    }
+  };
+  if (sessionUpdate === "tool_call") {
+    return {
+      sessionUpdate,
+      title,
+      kind: "other",
+      ...common
+    };
+  }
+  return {
+    sessionUpdate,
+    ...common
+  };
+}
+function formatSubAgentActivityTitle(kind, name) {
+  switch (kind) {
+    case "started":
+      return `Start subagent ${name}`;
+    case "interacted":
+      return `Interact with subagent ${name}`;
+    case "interrupted":
+      return `Interrupt subagent ${name}`;
+  }
+}
 function formatWebSearchTitle(item) {
   const action = item.action;
   if (!action) {
@@ -22249,14 +22496,39 @@ function createAgentTextMessageChunk(text, messageId, meta3) {
 function createAgentTextThoughtChunk(text, messageId, meta3) {
   return createAgentThoughtChunk({ type: "text", text }, messageId);
 }
-var CodexEventHandler = class {
+function toThreadGoalSnapshot(goal) {
+  return {
+    objective: goal.objective.trim(),
+    status: goal.status,
+    tokenBudget: goal.tokenBudget,
+    timeUsedSeconds: goal.timeUsedSeconds,
+    createdAt: goal.createdAt,
+    controlMethod: GOAL_CONTROL_METHOD
+  };
+}
+function sameThreadGoalSnapshot(left, right) {
+  if (left === void 0) return false;
+  if (left === null || right === null) return left === right;
+  return left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget && left.createdAt === right.createdAt;
+}
+var CodexEventHandler = class _CodexEventHandler {
+  static PLAN_UPDATE_INTERVAL_MS = 150;
   connection;
   sessionState;
+  supportsPlanUpdates;
   failure = null;
+  completedPlan = null;
   activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
   activeGuardianApprovalReviews = /* @__PURE__ */ new Set();
   activeImageGenerationItems = /* @__PURE__ */ new Set();
   emittedImageViewItems = /* @__PURE__ */ new Set();
+  planDeltaTextByItemId = /* @__PURE__ */ new Map();
+  pendingPlanItemIds = /* @__PURE__ */ new Set();
+  lastEmittedPlanTextByItemId = /* @__PURE__ */ new Map();
+  session;
+  planUpdateTimer = null;
+  planUpdateChain = Promise.resolve();
+  disposed = false;
   seenReasoningDeltaItemIds = /* @__PURE__ */ new Set();
   reasoningSummaryFilters = /* @__PURE__ */ new Map();
   terminalCommandIds = /* @__PURE__ */ new Set();
@@ -22264,29 +22536,59 @@ var CodexEventHandler = class {
   proposedPlanMarkdown = "";
   proposedPlanTurnId = null;
   agentMessagePhases = /* @__PURE__ */ new Map();
-  constructor(connection, sessionState) {
+  activeSubAgentActivities = /* @__PURE__ */ new Set();
+  constructor(connection, sessionState, supportsPlanUpdates = false) {
     this.connection = connection;
     this.sessionState = sessionState;
+    this.supportsPlanUpdates = supportsPlanUpdates;
+    this.session = new ACPSessionConnection(connection, sessionState.sessionId);
   }
   getFailure() {
     return this.failure;
   }
+  takeCompletedPlan() {
+    const plan = this.completedPlan;
+    this.completedPlan = null;
+    return plan;
+  }
   async handleNotification(notification) {
     if (notification.method === "account/rateLimits/updated") {
       await this.handleRateLimitsSnapshot(notification.params.rateLimits, true);
       return;
     }
-    const session = new ACPSessionConnection(this.connection, this.sessionState.sessionId);
     const updateEvent = await this.createUpdateEvent(notification);
     if (updateEvent) {
-      await session.update(updateEvent);
+      await this.session.update(updateEvent);
     }
     await this.emitExtNotification(notification);
   }
+  async flushPendingPlanUpdates() {
+    this.cancelPlanUpdateTimer();
+    do {
+      const itemIds = [...this.pendingPlanItemIds];
+      this.pendingPlanItemIds.clear();
+      await Promise.all(itemIds.map((itemId) => {
+        const text = this.planDeltaTextByItemId.get(itemId) ?? "";
+        return text.length > 0 ? this.enqueuePlanSnapshot(itemId, text) : Promise.resolve();
+      }));
+      await this.planUpdateChain;
+    } while (this.pendingPlanItemIds.size > 0);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    await this.flushPendingPlanUpdates();
+    this.disposed = true;
+    this.cancelPlanUpdateTimer();
+    this.pendingPlanItemIds.clear();
+    this.planDeltaTextByItemId.clear();
+    this.lastEmittedPlanTextByItemId.clear();
+  }
   async createUpdateEvent(notification) {
     switch (notification.method) {
       case "item/agentMessage/delta":
         return await this.createTextEvent(notification.params);
+      case "item/plan/delta":
+        return this.createPlanDeltaEvent(notification.params);
       case "item/started":
         return await this.createItemEvent(notification.params);
       case "item/completed":
@@ -22299,6 +22601,8 @@ var CodexEventHandler = class {
         this.sessionState.currentTurnId = notification.params.turn.id;
         return null;
       case "turn/completed":
+        await this.flushPendingPlanUpdates();
+        this.clearPlanTurnState();
         this.sessionState.currentTurnId = null;
         return null;
       case "thread/tokenUsage/updated":
@@ -22397,7 +22701,6 @@ var CodexEventHandler = class {
       case "rawResponseItem/completed":
       case "rawResponse/completed":
       case "thread/started":
-      case "item/plan/delta":
       case "remoteControl/status/changed":
       case "app/list/updated":
       case "thread/settings/updated":
@@ -22416,10 +22719,14 @@ var CodexEventHandler = class {
         );
         return;
       case "item/plan/delta":
-        await this.emitCodexProposedPlanDelta(notification.params);
+        if (!this.supportsPlanUpdates) {
+          await this.emitCodexProposedPlanDelta(notification.params);
+        }
         return;
       case "turn/completed":
-        await this.emitCodexProposedPlanCompleted(notification.params);
+        if (!this.supportsPlanUpdates) {
+          await this.emitCodexProposedPlanCompleted(notification.params);
+        }
         return;
       default:
         return;
@@ -22518,14 +22825,20 @@ var CodexEventHandler = class {
     const detailsText = event.details ? `
 
 ${event.details}` : "";
-    return createAgentTextMessageChunk(`Config warning: ${event.summary}${detailsText}
-
-`);
+    return this.createCodexSessionInfoUpdate({
+      warning: {
+        message: `${event.summary}${detailsText}`,
+        source: "configWarning"
+      }
+    });
   }
   createWarningEvent(event) {
-    return createAgentTextMessageChunk(`Warning: ${event.message}
-
-`);
+    return this.createCodexSessionInfoUpdate({
+      warning: {
+        message: event.message,
+        source: "warning"
+      }
+    });
   }
   createModelReroutedEvent(event) {
     return createAgentTextThoughtChunk(`Model rerouted from ${event.fromModel} to ${event.toModel} (${event.reason}).
@@ -22533,8 +22846,9 @@ ${event.details}` : "";
 `);
   }
   createThreadGoalUpdatedEvent(event) {
-    const goalSnapshot = this.createThreadGoalSnapshot(event);
-    if (this.sameThreadGoalSnapshot(this.sessionState.currentGoal, goalSnapshot)) {
+    this.sessionState.goalRevision += 1;
+    const goalSnapshot = toThreadGoalSnapshot(event.goal);
+    if (sameThreadGoalSnapshot(this.sessionState.currentGoal, goalSnapshot)) {
       return null;
     }
     this.sessionState.currentGoal = goalSnapshot;
@@ -22543,6 +22857,7 @@ ${event.details}` : "";
     });
   }
   createThreadGoalClearedEvent(_event) {
+    this.sessionState.goalRevision += 1;
     if (this.sessionState.currentGoal === null) {
       return null;
     }
@@ -22551,16 +22866,6 @@ ${event.details}` : "";
       goal: null
     });
   }
-  createThreadGoalSnapshot(event) {
-    return {
-      objective: event.goal.objective.trim(),
-      status: event.goal.status,
-      tokenBudget: event.goal.tokenBudget
-    };
-  }
-  sameThreadGoalSnapshot(left, right) {
-    return left !== null && left !== void 0 && left.objective === right.objective && left.status === right.status && left.tokenBudget === right.tokenBudget;
-  }
   createReasoningSummaryDeltaEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
     let filter = this.reasoningSummaryFilters.get(event.itemId);
@@ -22575,6 +22880,19 @@ ${event.details}` : "";
     this.seenReasoningDeltaItemIds.add(event.itemId);
     return this.createAgentThoughtEvent(event.delta, event.itemId);
   }
+  createPlanDeltaEvent(event) {
+    if (event.delta.length === 0) {
+      return null;
+    }
+    const text = this.planDeltaTextByItemId.get(event.itemId) ?? "";
+    const updatedText = text + event.delta;
+    this.planDeltaTextByItemId.set(event.itemId, updatedText);
+    if (this.supportsPlanUpdates) {
+      this.pendingPlanItemIds.add(event.itemId);
+      this.schedulePlanUpdate();
+    }
+    return null;
+  }
   createReasoningSectionBreakEvent(event) {
     this.seenReasoningDeltaItemIds.add(event.itemId);
     const trailingText = this.finishReasoningSummaryFilter(event.itemId);
@@ -22626,6 +22944,8 @@ ${event.details}` : "";
       case "contextCompaction":
         return createContextCompactionStartUpdate(event.item);
       case "subAgentActivity":
+        this.activeSubAgentActivities.add(event.item.id);
+        return createSubAgentActivityUpdate(event.item, "in_progress", "tool_call");
       case "sleep":
       case "userMessage":
       case "hookPrompt":
@@ -22678,17 +22998,23 @@ ${event.details}` : "";
       case "agentMessage":
         this.rememberAgentMessagePhase(event.item);
         return null;
+      case "plan": {
+        const deltaText = this.planDeltaTextByItemId.get(event.item.id) ?? "";
+        return await this.createCompletedPlanEvent(event.item, deltaText);
+      }
       case "exitedReviewMode":
         return this.createExitedReviewModeEvent(event.item);
       case "contextCompaction":
         return createContextCompactionCompleteUpdate(event.item);
       //ignored types
-      case "subAgentActivity":
+      case "subAgentActivity": {
+        const sessionUpdate = this.activeSubAgentActivities.delete(event.item.id) ? "tool_call_update" : "tool_call";
+        return createSubAgentActivityUpdate(event.item, "completed", sessionUpdate);
+      }
       case "sleep":
       case "userMessage":
       case "hookPrompt":
       case "enteredReviewMode":
-      case "plan":
         return null;
     }
   }
@@ -22702,6 +23028,71 @@ ${event.details}` : "";
     }
     return this.createAgentThoughtEvent(text, item.id);
   }
+  async createCompletedPlanEvent(item, deltaText) {
+    const text = item.text.length > 0 ? item.text : deltaText;
+    this.pendingPlanItemIds.delete(item.id);
+    if (this.pendingPlanItemIds.size === 0) {
+      this.cancelPlanUpdateTimer();
+    }
+    this.planDeltaTextByItemId.delete(item.id);
+    if (text.length === 0) {
+      return null;
+    }
+    this.completedPlan = { itemId: item.id, text };
+    if (this.supportsPlanUpdates) {
+      await this.enqueuePlanSnapshot(item.id, text);
+      return null;
+    }
+    return this.createPlanTextEvent(text, item.id);
+  }
+  schedulePlanUpdate() {
+    if (this.disposed || this.planUpdateTimer !== null) return;
+    this.planUpdateTimer = setTimeout(() => {
+      this.planUpdateTimer = null;
+      void this.flushPendingPlanUpdates().catch((error48) => {
+        logger.error("Failed to flush throttled plan updates", error48);
+      });
+    }, _CodexEventHandler.PLAN_UPDATE_INTERVAL_MS);
+  }
+  cancelPlanUpdateTimer() {
+    if (this.planUpdateTimer === null) return;
+    clearTimeout(this.planUpdateTimer);
+    this.planUpdateTimer = null;
+  }
+  enqueuePlanSnapshot(itemId, text) {
+    const send = async () => {
+      if (this.lastEmittedPlanTextByItemId.get(itemId) === text) return;
+      await this.session.update(this.createPlanUpdateEvent(text, itemId));
+      this.lastEmittedPlanTextByItemId.set(itemId, text);
+    };
+    const result = this.planUpdateChain.then(send);
+    this.planUpdateChain = result.catch(() => {
+    });
+    return result;
+  }
+  clearPlanTurnState() {
+    this.cancelPlanUpdateTimer();
+    this.pendingPlanItemIds.clear();
+    this.planDeltaTextByItemId.clear();
+    this.lastEmittedPlanTextByItemId.clear();
+  }
+  createPlanUpdateEvent(text, planId) {
+    return {
+      sessionUpdate: "plan_update",
+      plan: {
+        type: "markdown",
+        planId,
+        content: text
+      }
+    };
+  }
+  createPlanTextEvent(text, messageId) {
+    return createAgentTextMessageChunk(
+      text,
+      messageId,
+      createCodexMessagePhaseMeta("final_answer")
+    );
+  }
   createExitedReviewModeEvent(item) {
     const text = item.review.trim();
     if (text.length === 0) {
@@ -22963,12 +23354,17 @@ var ApprovalOptionId = {
   AllowPermissionsForSession: "allow_permissions_session",
   RejectPermissions: "reject_permissions"
 };
-function permissionOption(optionId, name, kind, codexMeta) {
+function permissionOption(optionId, name, kind, codexMeta, permission) {
   return {
     optionId,
     name,
     kind,
-    ...codexMeta ? { _meta: { codex: codexMeta } } : {}
+    ...codexMeta || permission ? {
+      _meta: {
+        ...permission ? { permission } : {},
+        ...codexMeta ? { codex: codexMeta } : {}
+      }
+    } : {}
   };
 }
 var CodexApprovalHandler = class {
@@ -23075,13 +23471,15 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowPermissionsForSession,
           "Allow for Session",
           "allow_always",
-          { decision: "allowPermissionsForSession", permissions: params.permissions }
+          { decision: "allowPermissionsForSession", permissions: params.permissions },
+          this.permissionGrantMetadata(params.permissions, "session")
         ),
         permissionOption(
           ApprovalOptionId.AllowPermissionsForTurn,
           "Allow Once",
           "allow_once",
-          { decision: "allowPermissionsForTurn", permissions: params.permissions }
+          { decision: "allowPermissionsForTurn", permissions: params.permissions },
+          this.permissionGrantMetadata(params.permissions, "turn")
         ),
         permissionOption(
           ApprovalOptionId.RejectPermissions,
@@ -23143,7 +23541,24 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowAlways,
           params.networkApprovalContext ? "Allow Host for Session" : "Allow for Session",
           "allow_always",
-          { decision: "acceptForSession" }
+          { 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"
       }
@@ -23157,6 +23572,22 @@ var CodexApprovalHandler = class {
           {
             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: {
@@ -23175,6 +23606,22 @@ var CodexApprovalHandler = class {
           {
             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: {
@@ -23201,7 +23648,21 @@ var CodexApprovalHandler = class {
           ApprovalOptionId.AllowAlways,
           params.grantRoot ? "Allow Root for Session" : "Allow for Session",
           "allow_always",
-          { decision: "acceptForSession", grantRoot: params.grantRoot ?? null }
+          { 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"
       },
@@ -23224,6 +23685,68 @@ 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 path6 of fileSystem?.read ?? []) {
+      changes.push(this.fileSystemGrantChange(path6, "read", lifetime, suffix));
+    }
+    for (const path6 of fileSystem?.write ?? []) {
+      changes.push(this.fileSystemGrantChange(path6, "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;
+  }
+  fileSystemGrantChange(path6, access, lifetime, suffix) {
+    return {
+      type: "grant",
+      operation: "grant",
+      description: `Allow ${access} access to ${path6}${suffix}`,
+      lifetime,
+      targets: [{
+        type: "filesystem",
+        access: [access],
+        matcher: { type: "exact_path", path: path6 }
+      }]
+    };
+  }
   networkPolicyAmendmentOptionId(index) {
     return `${ApprovalOptionId.ApplyNetworkPolicyAmendment}:${index}`;
   }
@@ -24655,20 +25178,22 @@ var package_default = {
     "package:win-x64": "cd dist/bin && zip acp-extension-codex-x64-windows.zip acp-extension-codex-x64-windows.exe",
     "package:win-arm64": "cd dist/bin && zip acp-extension-codex-arm64-windows.zip acp-extension-codex-arm64-windows.exe",
     start: "node --import tsx src/index.ts",
+    "example:steering": "node --import tsx examples/steering.ts",
+    "example:steering:multistep": "node --import tsx examples/steering.ts",
     "generate-types": "./node_modules/.bin/codex app-server generate-ts --out src/app-server",
     test: "vitest run",
     "test:e2e": "npm run build && RUN_E2E_TESTS=true vitest run src/__tests__/CodexACPAgent/e2e",
     "test:watch": "vitest",
-    typecheck: "tsc --noEmit",
+    typecheck: "tsc --noEmit && tsc --noEmit -p examples/tsconfig.json",
     "codex-test": "tsx .claude/skills/run-codex/scripts/run-codex-test.ts"
   },
-  homepage: "https://github.com/Leeeon233/acp-extension-codex#readme",
+  homepage: "https://github.com/loro-dev/acp-extension-codex#readme",
   bugs: {
-    url: "https://github.com/Leeeon233/acp-extension-codex/issues"
+    url: "https://github.com/loro-dev/acp-extension-codex/issues"
   },
   repository: {
     type: "git",
-    url: "git+https://github.com/Leeeon233/acp-extension-codex.git"
+    url: "git+https://github.com/loro-dev/acp-extension-codex.git"
   },
   keywords: [
     "codex",
@@ -24685,12 +25210,12 @@ var package_default = {
     "@types/node": "^26.1.0",
     esbuild: "^0.28.1",
     "mcp-hello-world": "^1.1.2",
-    tsx: "^4.23.0",
-    typescript: "^6.0.3",
+    tsx: "^4.23.1",
+    typescript: "^7.0.2",
     vitest: "^4.1.10"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "^1.2.1",
+    "@agentclientprotocol/sdk": "^1.3.0",
     "@openai/codex": "^0.145.0",
     diff: "^9.0.0",
     open: "^11.0.0",
@@ -24698,6 +25223,39 @@ var package_default = {
     zod: "^4.0.0"
   }
 };
+var COLLABORATION_MODE_CONFIG_ID = "collaboration_mode";
+var DEFAULT_COLLABORATION_MODE = "default";
+var PLAN_COLLABORATION_MODE = "plan";
+function createCollaborationModeConfigOption(currentValue) {
+  return {
+    id: COLLABORATION_MODE_CONFIG_ID,
+    name: "Collaboration mode",
+    description: "How Codex collaborates for subsequent turns",
+    category: "collaboration_mode",
+    type: "select",
+    currentValue,
+    options: [
+      { value: DEFAULT_COLLABORATION_MODE, name: "Default" },
+      { value: PLAN_COLLABORATION_MODE, name: "Plan", description: "Plan before making changes" }
+    ]
+  };
+}
+function parseCollaborationMode(value) {
+  if (value === DEFAULT_COLLABORATION_MODE) return DEFAULT_COLLABORATION_MODE;
+  if (value === PLAN_COLLABORATION_MODE) return PLAN_COLLABORATION_MODE;
+  return null;
+}
+function createCodexCollaborationMode(mode, currentModelId) {
+  const modelId = ModelId.fromString(currentModelId);
+  return {
+    mode,
+    settings: {
+      model: modelId.model,
+      reasoning_effort: modelId.effort,
+      developer_instructions: null
+    }
+  };
+}
 var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
 var SESSION_LIST_PAGE_SIZE = 100;
 var SUPPORTED_GATEWAY_PROTOCOLS = {
@@ -24712,6 +25270,7 @@ var CodexAcpClient = class {
   pendingAccountUpdated = null;
   sessionNotificationQueues = /* @__PURE__ */ new Map();
   skillExtraRoots = [];
+  configPath = null;
   constructor(codexClient, codexConfig, modelProvider) {
     this.codexClient = codexClient;
     this.config = codexConfig ?? {};
@@ -24724,7 +25283,7 @@ var CodexAcpClient = class {
     version: `${package_default.version}`
   };
   async initialize(request) {
-    await this.codexClient.initialize({
+    const response = await this.codexClient.initialize({
       capabilities: {
         experimentalApi: true,
         requestAttestation: false
@@ -24735,6 +25294,10 @@ var CodexAcpClient = class {
         title: request.clientInfo?.title ?? this.defaultClientInfo.title
       }
     });
+    this.configPath = response?.codexHome ?? null;
+  }
+  getHomePath() {
+    return this.configPath;
   }
   async authenticate(authRequest) {
     if (!isCodexAuthRequest(authRequest)) {
@@ -24944,6 +25507,7 @@ var CodexAcpClient = class {
       sessionId: request.sessionId,
       currentModelId,
       models: codexModels,
+      collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       additionalDirectories
@@ -24968,6 +25532,7 @@ var CodexAcpClient = class {
       sessionId: response.thread.id,
       currentModelId,
       models: codexModels,
+      collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       additionalDirectories
@@ -24993,6 +25558,7 @@ var CodexAcpClient = class {
       sessionId: request.sessionId,
       currentModelId,
       models: codexModels,
+      collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       thread: historyResponse.thread,
@@ -25017,6 +25583,7 @@ var CodexAcpClient = class {
       sessionId: response.thread.id,
       currentModelId,
       models: codexModels,
+      collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
       additionalDirectories
@@ -25042,6 +25609,10 @@ var CodexAcpClient = class {
   async runCompact(sessionId) {
     await this.codexClient.runCompact({ threadId: sessionId });
   }
+  async getGoal(sessionId) {
+    const response = await this.codexClient.threadGoalGet({ threadId: sessionId });
+    return response?.goal ?? null;
+  }
   async setGoal(sessionId, objective, onTurnStarted) {
     return await this.codexClient.runGoalSet({
       threadId: sessionId,
@@ -25050,10 +25621,17 @@ var CodexAcpClient = class {
     }, onTurnStarted);
   }
   async setGoalStatus(sessionId, status) {
+    let updatedGoal = null;
     await this.codexClient.runGoalSet({
       threadId: sessionId,
       status
+    }, void 0, void 0, (goal) => {
+      updatedGoal = goal;
     });
+    if (updatedGoal === null) {
+      throw new Error(`Goal update for session ${sessionId} returned no goal`);
+    }
+    return updatedGoal;
   }
   async resumeGoal(sessionId, onTurnStarted) {
     return await this.codexClient.runGoalSet({
@@ -25101,11 +25679,16 @@ var CodexAcpClient = class {
   }
   async getConfigMcpServerNames(projectPath) {
     const response = await this.codexClient.configRead({ includeLayers: true, cwd: projectPath });
-    const mcpServers = response?.config?.["mcp_servers"];
-    if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    const effectiveMcpServers = response?.config?.["mcp_servers"];
+    const configLayers = response?.layers ?? [];
+    const layerMcpServers = configLayers.map((layer) => {
+      return isJsonObject(layer.config) ? layer.config["mcp_servers"] : void 0;
+    });
+    const configuredMcpServers = [effectiveMcpServers, ...layerMcpServers].filter(isJsonObject);
+    if (configuredMcpServers.length === 0) {
       return /* @__PURE__ */ new Set();
     }
-    return new Set(Object.keys(mcpServers));
+    return new Set(configuredMcpServers.flatMap((server) => Object.keys(server)));
   }
   getModelProvider() {
     return this.gatewayConfig?.modelProvider ?? this.modelProvider;
@@ -25221,7 +25804,7 @@ var CodexAcpClient = class {
       }
     });
   }
-  async sendPrompt(request, agentMode, modelId, serviceTier, collaborationMode, disableSummary, cwd, additionalDirectories, onTurnStarted, shouldCancel) {
+  async sendPrompt(request, agentMode, modelId, serviceTier, disableSummary, cwd, additionalDirectories, onTurnStarted, shouldCancel) {
     const input = buildPromptItems(request.prompt);
     const effort = modelId.effort;
     await this.refreshSkills(cwd, additionalDirectories);
@@ -25239,19 +25822,16 @@ var CodexAcpClient = class {
       model: modelId.model,
       serviceTier
     };
-    if (collaborationMode !== null) {
-      params.collaborationMode = collaborationMode;
-    }
     return await this.codexClient.runTurn(params, onTurnStarted);
   }
-  async sendSteer(request, expectedTurnId, steerId) {
-    const response = await this.codexClient.turnSteer({
-      threadId: request.sessionId,
-      input: buildPromptItems(request.prompt),
-      expectedTurnId,
-      clientUserMessageId: steerId
+  async setCollaborationMode(sessionId, mode, currentModelId) {
+    await this.codexClient.threadSettingsUpdate({
+      threadId: sessionId,
+      collaborationMode: createCodexCollaborationMode(mode, currentModelId)
     });
-    return response.turnId;
+  }
+  getCollaborationMode(sessionId) {
+    return this.codexClient.getThreadSettings(sessionId)?.collaborationMode.mode ?? "default";
   }
   resolveTurnInterrupted(params) {
     this.codexClient.resolveTurnInterrupted(params.threadId, params.turnId);
@@ -25360,6 +25940,14 @@ var CodexAcpClient = class {
       turnId: params.turnId
     });
   }
+  async steerTurn(params) {
+    return await this.codexClient.turnSteer({
+      threadId: params.threadId,
+      expectedTurnId: params.turnId,
+      input: buildPromptItems(params.prompt),
+      ...params.steerId ? { clientUserMessageId: params.steerId } : {}
+    });
+  }
   async fetchAvailableModels() {
     const models = [];
     let cursor = null;
@@ -25670,6 +26258,20 @@ var CodexCommands = class {
    */
   getBuiltinCommands() {
     return [
+      {
+        name: "plan",
+        description: "Turn plan mode on.",
+        input: null,
+        _meta: {
+          commandAction: {
+            kind: "setConfigOption",
+            configId: COLLABORATION_MODE_CONFIG_ID,
+            value: PLAN_COLLABORATION_MODE,
+            resetValue: DEFAULT_COLLABORATION_MODE,
+            presentation: "state"
+          }
+        }
+      },
       {
         name: "mcp",
         description: "List configured Model Context Protocol (MCP) tools.",
@@ -25707,8 +26309,14 @@ var CodexCommands = class {
       },
       {
         name: "goal",
-        description: "Set, pause, resume, or clear a task goal.",
-        input: { hint: "[<objective>|clear|pause|resume]" }
+        description: "Set a goal to keep pursuing.",
+        input: { hint: "[<objective>|clear|pause|resume]" },
+        _meta: {
+          commandAction: {
+            kind: "prefixPrompt",
+            presentation: "state"
+          }
+        }
       },
       {
         name: "logout",
@@ -25738,6 +26346,15 @@ var CodexCommands = class {
     if (commandName.startsWith("$")) return { handled: false };
     const sessionId = sessionState.sessionId;
     switch (commandName) {
+      case "plan": {
+        if (command.rest.length > 0) {
+          await this.sendCommandUsageMessage(commandName, "no arguments", sessionId);
+          return { handled: true };
+        }
+        const mode = sessionState.collaborationMode === PLAN_COLLABORATION_MODE ? DEFAULT_COLLABORATION_MODE : PLAN_COLLABORATION_MODE;
+        await options.setConfigOption?.(COLLABORATION_MODE_CONFIG_ID, mode);
+        return { handled: options.setConfigOption !== void 0 };
+      }
       case "compact": {
         await this.runWithProcessCheck(() => this.codexAcpClient.runCompact(sessionId));
         return { handled: true };
@@ -26023,6 +26640,45 @@ var CodexCommands = class {
     return count.toString();
   }
 };
+var SteeringQueue = class {
+  constructor(handle) {
+    this.handle = handle;
+  }
+  handle;
+  pending = [];
+  processing = false;
+  enqueue(params) {
+    return new Promise((resolve, reject) => {
+      this.pending.push({ params, resolve, reject });
+      this.startConsumer();
+    });
+  }
+  /** No request is queued and the consumer is not running. */
+  get isIdle() {
+    return !this.processing && this.pending.length === 0;
+  }
+  startConsumer() {
+    if (this.processing) {
+      return;
+    }
+    this.processing = true;
+    void this.consume();
+  }
+  async consume() {
+    try {
+      while (this.pending.length > 0) {
+        const next = this.pending.shift();
+        try {
+          next.resolve(await this.handle(next.params));
+        } catch (error48) {
+          next.reject(error48);
+        }
+      }
+    } finally {
+      this.processing = false;
+    }
+  }
+};
 function historyFallbackUpdateKey(update) {
   switch (update.sessionUpdate) {
     case "user_message_chunk":
@@ -27025,32 +27681,6 @@ function createFastModeConfigOption(fastModeEnabled, useBooleanConfigOption = fa
     ]
   };
 }
-var PLAN_MODE_CONFIG_ID = "plan-mode";
-var PLAN_MODE_ON = "on";
-var PLAN_MODE_OFF = "off";
-var PLAN_MODE_DESCRIPTION = "Plan without modifying files; switch off to implement the approved plan";
-function createPlanModeConfigOption(planModeEnabled) {
-  return {
-    id: PLAN_MODE_CONFIG_ID,
-    name: "Plan mode",
-    description: PLAN_MODE_DESCRIPTION,
-    category: PLAN_MODE_CONFIG_ID,
-    type: "select",
-    currentValue: planModeEnabled ? PLAN_MODE_ON : PLAN_MODE_OFF,
-    options: [
-      {
-        value: PLAN_MODE_OFF,
-        name: "Off",
-        description: "Implement changes normally"
-      },
-      {
-        value: PLAN_MODE_ON,
-        name: "On",
-        description: PLAN_MODE_DESCRIPTION
-      }
-    ]
-  };
-}
 function isJetBrains2026_1Client(clientInfo) {
   if (!clientInfo) {
     return false;
@@ -27060,6 +27690,11 @@ function isJetBrains2026_1Client(clientInfo) {
   const isJetBrainsClient = clientInfo.name.startsWith("JetBrains");
   return (isIntelliJPlatform || isJetBrainsClient) && clientInfo.version.startsWith("2026.1");
 }
+function clientSupportsPlanUpdates(clientCapabilities) {
+  return clientCapabilities?.plan != null;
+}
+var IMPLEMENT_PLAN_OPTION_ID = "implement_plan";
+var REVISE_PLAN_OPTION_ID = "revise_plan";
 var CodexAcpServer = class _CodexAcpServer {
   static MODEL_NAME_TOKEN_OVERRIDES = {
     gpt: "GPT",
@@ -27081,6 +27716,7 @@ var CodexAcpServer = class _CodexAcpServer {
   pendingTurnStarts;
   activePrompts;
   pendingSteers;
+  steeringQueues;
   closingSessions;
   sessionGenerations;
   sessionOpenGenerations;
@@ -27090,6 +27726,7 @@ var CodexAcpServer = class _CodexAcpServer {
     this.pendingTurnStarts = /* @__PURE__ */ new Map();
     this.activePrompts = /* @__PURE__ */ new Map();
     this.pendingSteers = /* @__PURE__ */ new Map();
+    this.steeringQueues = /* @__PURE__ */ new Map();
     this.closingSessions = /* @__PURE__ */ new Map();
     this.sessionGenerations = /* @__PURE__ */ new Map();
     this.sessionOpenGenerations = /* @__PURE__ */ new Map();
@@ -27155,7 +27792,12 @@ var CodexAcpServer = class _CodexAcpServer {
           }
         }
       },
-      authMethods: getCodexAuthMethods(_params.clientCapabilities)
+      authMethods: getCodexAuthMethods(_params.clientCapabilities),
+      _meta: {
+        steering: {
+          supported: true
+        }
+      }
     };
   }
   async extMethod(method, params) {
@@ -27172,6 +27814,27 @@ var CodexAcpServer = class _CodexAcpServer {
       }
       case LEGACY_SET_SESSION_MODEL_METHOD:
         return await this.unstable_setSessionModel(this.parseLegacySetSessionModelParams(methodRequest.params));
+      case SESSION_STEERING_METHOD:
+        return await this.executeOrQueueSteeringRequest(this.parseSessionSteerParams(methodRequest.params));
+      case GOAL_CONTROL_METHOD: {
+        const sessionState = this.sessions.get(methodRequest.params.sessionId);
+        if (!sessionState) {
+          throw RequestError.invalidParams(void 0, `Unknown session: ${methodRequest.params.sessionId}`);
+        }
+        const sessionGeneration = this.getSessionGeneration(sessionState.sessionId);
+        if (methodRequest.params.action === "pause") {
+          const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionState.sessionId, "paused"));
+          if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+            await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(goal), false);
+          }
+        } else if (methodRequest.params.action === "clear") {
+          await this.runWithProcessCheck(() => this.codexAcpClient.clearGoal(sessionState.sessionId));
+          if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+            await this.publishGoalSnapshot(sessionState, null, false);
+          }
+        }
+        return {};
+      }
     }
   }
   async checkAuthorization() {
@@ -27216,6 +27879,12 @@ var CodexAcpServer = class _CodexAcpServer {
 
 You have been logged out. Please try again.`);
     }
+    const configPath = this.codexAcpClient.getHomePath() ?? "global";
+    if (e.message.includes("load config")) {
+      throw RequestError.internalError(`${e.message}
+
+Check ${configPath} and project .codex directories, especially their config.toml files, or any CODEX_CONFIG override.`);
+    }
   }
   beginSessionOpen(sessionId) {
     const generation = this.getSessionGeneration(sessionId);
@@ -27368,6 +28037,7 @@ You have been logged out. Please try again.`);
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
+      collaborationMode: sessionMetadata.collaborationMode,
       currentTurnId: null,
       lastTokenUsage: null,
       totalTokenUsage: null,
@@ -27380,10 +28050,9 @@ You have been logged out. Please try again.`);
       additionalDirectories: sessionMetadata.additionalDirectories,
       fastModeEnabled: sessionMetadata.currentServiceTier === "fast",
       currentModelSupportsFast,
-      planModeEnabled: false,
-      planModeExplicitlySet: false,
       sessionMcpServers,
       terminalOutputMode: this.terminalOutputMode,
+      goalRevision: 0,
       sessionTitle: null,
       sessionTitleSource: operation.kind === "new" ? "unset" : "unknown"
     };
@@ -27398,6 +28067,9 @@ You have been logged out. Please try again.`);
       this.publishMcpStartupStatusAsync(sessionId);
     }
     const availableCommands = await this.availableCommands.getAvailableCommands(sessionState);
+    if ("sessionId" in request) {
+      this.publishCurrentGoalAsync(sessionState, openedSession.generation);
+    }
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return [sessionId, sessionModelState, sessionModeState, availableCommands];
@@ -27546,6 +28218,8 @@ You have been logged out. Please try again.`);
         this.pendingMcpStartupSessions.delete(params.sessionId);
         this.pendingTurnStarts.delete(params.sessionId);
         this.activePrompts.delete(params.sessionId);
+        this.pendingSteers.delete(params.sessionId);
+        this.steeringQueues.delete(params.sessionId);
       }
       this.endSessionCloseFence(params.sessionId);
     }
@@ -27657,16 +28331,22 @@ You have been logged out. Please try again.`);
     });
     const sessionState = this.sessions.get(params.sessionId);
     if (!sessionState) throw new Error(`Session ${params.sessionId} not found`);
+    await this.applySessionConfigOption(sessionState, params);
+    return {
+      configOptions: this.createSessionConfigOptions(sessionState)
+    };
+  }
+  async applySessionConfigOption(sessionState, params) {
     switch (params.configId) {
       case FAST_MODE_CONFIG_ID:
         this.applyFastModeChange(sessionState, params);
         break;
-      case PLAN_MODE_CONFIG_ID:
-        this.applyPlanModeChange(sessionState, this.stringConfigValue(params));
-        break;
       case MODE_CONFIG_ID:
         this.applyModeChange(sessionState, this.stringConfigValue(params));
         break;
+      case COLLABORATION_MODE_CONFIG_ID:
+        await this.applyCollaborationModeChange(sessionState, this.stringConfigValue(params));
+        break;
       case MODEL_CONFIG_ID:
         this.applyModelChange(sessionState, this.stringConfigValue(params));
         break;
@@ -27676,9 +28356,6 @@ You have been logged out. Please try again.`);
       default:
         throw RequestError.invalidParams();
     }
-    return {
-      configOptions: this.createSessionConfigOptions(sessionState)
-    };
   }
   applyFastModeChange(sessionState, params) {
     const value = params.value;
@@ -27691,13 +28368,6 @@ You have been logged out. Please try again.`);
     }
     sessionState.fastModeEnabled = value === FAST_MODE_ON;
   }
-  applyPlanModeChange(sessionState, value) {
-    if (value !== PLAN_MODE_ON && value !== PLAN_MODE_OFF) {
-      throw RequestError.invalidParams();
-    }
-    sessionState.planModeEnabled = value === PLAN_MODE_ON;
-    sessionState.planModeExplicitlySet = true;
-  }
   stringConfigValue(params) {
     if (typeof params.value !== "string") {
       throw RequestError.invalidParams();
@@ -27711,6 +28381,14 @@ You have been logged out. Please try again.`);
     }
     sessionState.agentMode = newMode;
   }
+  async applyCollaborationModeChange(sessionState, value) {
+    const mode = parseCollaborationMode(value);
+    if (mode === null) {
+      throw RequestError.invalidParams();
+    }
+    await this.codexAcpClient.setCollaborationMode(sessionState.sessionId, mode, sessionState.currentModelId);
+    sessionState.collaborationMode = mode;
+  }
   applyModelChange(sessionState, value) {
     const model = sessionState.availableModels.find((m) => m.id === value);
     if (!model) {
@@ -27774,10 +28452,239 @@ You have been logged out. Please try again.`);
       modelId
     };
   }
+  /**
+   * Handles one incoming steering request, serialising it against any other
+   * steer already in flight for the same session.
+   *
+   * Every session gets its own {@link SteeringQueue}: the request is enqueued
+   * and awaited, so concurrent steers for one session run strictly one at a
+   * time, in arrival order, and can never race to inject into — or start —
+   * rival turns. Steers for different sessions use different queues and run
+   * concurrently. Once the queue drains to idle it is removed from the map,
+   * so no per-session entry leaks after the session goes quiet (the identity
+   * check guards against deleting a queue a later request has since reused).
+   *
+   * @param params The target session id and the prompt to steer with.
+   * @returns Whether the prompt joined the active turn ("injected"), started a
+   *     new one ("startedNewTurn"), or could not be applied ("failed"); see
+   *     {@link performSteeringRequest}.
+   */
+  async executeOrQueueSteeringRequest(params) {
+    const queue = this.getSteeringQueue(params.sessionId);
+    try {
+      return await queue.enqueue(params);
+    } catch (error48) {
+      if (error48 instanceof RequestError) {
+        throw error48;
+      }
+      logger.error(`Steering request for session ${params.sessionId} failed`, error48);
+      return { outcome: "failed" };
+    } finally {
+      if (queue.isIdle && this.steeringQueues.get(params.sessionId) === queue) {
+        this.steeringQueues.delete(params.sessionId);
+      }
+    }
+  }
+  /**
+   * Returns the steering queue for a session, creating and registering it on
+   * first use.
+   *
+   * @param sessionId The session whose steering queue is required.
+   * @returns The session's existing queue, or a freshly created one.
+   */
+  getSteeringQueue(sessionId) {
+    let queue = this.steeringQueues.get(sessionId);
+    if (!queue) {
+      queue = new SteeringQueue((params) => this.performSteeringRequest(params));
+      this.steeringQueues.set(sessionId, queue);
+    }
+    return queue;
+  }
+  /**
+   * Delivers a steering prompt to the session: injects it into the live turn
+   * when there is one, otherwise starts a new turn.
+   *
+   * @param params The target session id and the prompt to steer with.
+   * @returns "injected" when the prompt joined an existing turn, otherwise the
+   *     outcome of starting a new turn.
+   */
+  async performSteeringRequest(params) {
+    logger.log("Steering session requested", {
+      sessionId: params.sessionId,
+      prompt: params.prompt
+    });
+    const sessionState = this.getSessionState(params.sessionId);
+    this.assertSteerInputSupported(params, sessionState);
+    const turnId = await this.getSteerableTurnId(sessionState);
+    if (turnId) {
+      const injected = await this.injectSteerIntoActiveTurn(params, turnId, sessionState);
+      if (injected) {
+        logger.log("Steering session injected", { sessionId: params.sessionId, turnId });
+        return { outcome: "injected" };
+      }
+    }
+    if (params.steerId) {
+      throw RequestError.invalidRequest("No active Codex turn to steer");
+    }
+    return await this.startNewTurnFromSteering(params);
+  }
+  /**
+   * Rejects a steering prompt whose content the active model cannot accept
+   * (currently: image blocks on a text-only model).
+   */
+  assertSteerInputSupported(params, sessionState) {
+    const hasImage = params.prompt.some((block) => block.type === "image");
+    if (hasImage && !sessionState.supportedInputModalities.includes("image")) {
+      throw RequestError.invalidRequest("The current model does not support image input");
+    }
+  }
+  /**
+   * Attempts to inject the prompt into the given running turn.
+   *
+   * A failed injection is fatal only when the turn is still the session's
+   * current turn and Codex reported something other than "no active turn to
+   * steer". Otherwise the turn has already ended underneath us and the caller
+   * should start a new turn instead.
+   *
+   * @returns true when the prompt was injected; false when the caller should
+   *     fall back to starting a new turn.
+   */
+  async injectSteerIntoActiveTurn(params, turnId, sessionState) {
+    const activePrompt = this.activePrompts.get(params.sessionId);
+    const activeTurn = activePrompt?.currentTurn;
+    if (params.steerId) {
+      const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
+      if (firstText.startsWith("/")) {
+        throw RequestError.invalidRequest("Slash commands cannot steer an active Codex turn");
+      }
+      if (!activePrompt || !activeTurn || activeTurn.turnId !== turnId || activePrompt.signal.aborted) {
+        return false;
+      }
+    }
+    const pending = params.steerId ? this.pendingSteers.get(params.sessionId) ?? /* @__PURE__ */ new Map() : null;
+    if (params.steerId && activePrompt && pending) {
+      if (pending.has(params.steerId)) {
+        throw RequestError.invalidRequest(`Duplicate Codex steer id: ${params.steerId}`);
+      }
+      pending.set(params.steerId, { activePrompt, turnId });
+      this.pendingSteers.set(params.sessionId, pending);
+    }
+    try {
+      const response = await this.runWithProcessCheck(() => this.codexAcpClient.steerTurn({
+        threadId: params.steerId && activeTurn ? activeTurn.threadId : params.sessionId,
+        turnId,
+        prompt: params.prompt,
+        ...params.steerId ? { steerId: params.steerId } : {}
+      }));
+      if (response.turnId !== turnId) {
+        throw RequestError.internalError(
+          { expectedTurnId: turnId, actualTurnId: response.turnId },
+          `Codex steered unexpected turn ${response.turnId}; expected ${turnId}`
+        );
+      }
+      return true;
+    } catch (err) {
+      if (params.steerId && activePrompt && pending?.get(params.steerId)?.activePrompt === activePrompt) {
+        pending.delete(params.steerId);
+        if (pending.size === 0) this.pendingSteers.delete(params.sessionId);
+      }
+      await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+      const turnStillActive = sessionState.currentTurnId === turnId;
+      if (turnStillActive && !this.isNoActiveTurnToSteerError(err)) {
+        throw err;
+      }
+      return false;
+    }
+  }
+  /**
+   * Starts a new turn from a steering prompt when there is no live turn to
+   * inject into, and returns as soon as that turn is running.
+   *
+   * Waits for any previous prompt to drain first, then re-checks that the
+   * session is not closing — the await above is a window during which a close
+   * request can arrive.
+   *
+   * @param params The target session id and the prompt to steer with.
+   * @returns "startedNewTurn" once the turn is running; throws if the prompt
+   *     fails or is cancelled before the turn starts.
+   */
+  async startNewTurnFromSteering(params) {
+    const previousPrompt = this.activePrompts.get(params.sessionId);
+    await previousPrompt?.completion;
+    if (this.sessionIsClosing(params.sessionId)) {
+      throw RequestError.invalidRequest(`Session ${params.sessionId} is closing`);
+    }
+    return await new Promise((resolve, reject) => {
+      let turnStarted = false;
+      const promptDone = this.prompt(params, void 0, () => {
+        turnStarted = true;
+        logger.log("Steering session started a new turn", { sessionId: params.sessionId });
+        resolve({ outcome: "startedNewTurn" });
+      });
+      promptDone.then(
+        (response) => {
+          if (!turnStarted && response.stopReason === "cancelled") {
+            reject(RequestError.invalidRequest(`Session ${params.sessionId} was cancelled before the steering turn started`));
+          } else {
+            resolve({ outcome: "startedNewTurn" });
+          }
+        },
+        (error48) => {
+          if (turnStarted) {
+            logger.error(`Steering-started prompt for session ${params.sessionId} failed`, error48);
+          } else {
+            reject(error48);
+          }
+        }
+      );
+    });
+  }
+  isNoActiveTurnToSteerError(error48) {
+    const messages = error48 instanceof Error ? [error48.message] : [];
+    if (typeof error48 === "object" && error48 !== null && "data" in error48) {
+      const data = error48.data;
+      if (typeof data === "string") {
+        messages.push(data);
+      } else if (typeof data === "object" && data !== null && "details" in data) {
+        const details = data.details;
+        if (typeof details === "string") {
+          messages.push(details);
+        }
+      }
+    }
+    return messages.some((message) => message.toLowerCase().includes("no active turn to steer"));
+  }
+  async getSteerableTurnId(sessionState) {
+    if (this.sessionIsClosing(sessionState.sessionId)) {
+      return null;
+    }
+    if (sessionState.currentTurnId) {
+      return sessionState.currentTurnId;
+    }
+    const pendingTurnStart = this.pendingTurnStarts.get(sessionState.sessionId);
+    if (!pendingTurnStart) {
+      return null;
+    }
+    return await pendingTurnStart.promise;
+  }
+  parseSessionSteerParams(params) {
+    const sessionId = params["sessionId"];
+    const prompt = params["prompt"];
+    const steerId = params["steerId"];
+    if (typeof sessionId !== "string" || !Array.isArray(prompt) || steerId !== void 0 && (typeof steerId !== "string" || steerId.length === 0)) {
+      throw RequestError.invalidParams();
+    }
+    return {
+      sessionId,
+      prompt,
+      ...typeof steerId === "string" ? { steerId } : {}
+    };
+  }
   createSessionConfigOptions(sessionState) {
     const currentModelId = ModelId.fromString(sessionState.currentModelId);
     const configOptions = [
       sessionState.agentMode.toConfigOption(),
+      createCollaborationModeConfigOption(sessionState.collaborationMode),
       createModelConfigOption(sessionState.availableModels, currentModelId.model)
     ];
     if (sessionState.supportedReasoningEfforts.length > 0) {
@@ -27791,7 +28698,6 @@ You have been logged out. Please try again.`);
         this.booleanConfigOptionsSupported
       ));
     }
-    configOptions.push(createPlanModeConfigOption(sessionState.planModeEnabled));
     return configOptions;
   }
   createSessionConfigOptionsResponse(sessionState) {
@@ -27805,18 +28711,45 @@ You have been logged out. Please try again.`);
   isSessionConfigEnabled() {
     return !isJetBrains2026_1Client(this.clientInfo);
   }
-  createPlanModeCollaborationMode(sessionState, modelId) {
-    if (!sessionState.planModeEnabled && !sessionState.planModeExplicitlySet) {
-      return null;
+  publishCurrentGoalAsync(sessionState, sessionGeneration) {
+    void this.publishCurrentGoalBestEffort(sessionState, sessionGeneration, true);
+  }
+  async publishCurrentGoalBestEffort(sessionState, sessionGeneration, force) {
+    try {
+      await this.publishCurrentGoal(sessionState, sessionGeneration, force);
+    } catch (err) {
+      logger.error(`Failed to publish current goal for session ${sessionState.sessionId}`, err);
     }
-    return {
-      mode: sessionState.planModeEnabled ? "plan" : "default",
-      settings: {
-        model: modelId.model,
-        reasoning_effort: modelId.effort,
-        developer_instructions: null
+  }
+  async publishCurrentGoal(sessionState, sessionGeneration, force) {
+    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) {
+      return;
+    }
+    await this.publishGoalSnapshot(sessionState, snapshot, force, false);
+  }
+  goalPublishIsCurrent(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) {
+    if (incrementRevision) {
+      sessionState.goalRevision += 1;
+    }
+    if (!force && sameThreadGoalSnapshot(sessionState.currentGoal, snapshot)) {
+      return;
+    }
+    sessionState.currentGoal = snapshot;
+    const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+    await session.update({
+      sessionUpdate: "session_info_update",
+      _meta: {
+        codex: {
+          goal: snapshot
+        }
       }
-    };
+    });
   }
   findCurrentModel(models, currentModelId) {
     const modelId = ModelId.fromString(currentModelId);
@@ -27883,6 +28816,7 @@ You have been logged out. Please try again.`);
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
+      collaborationMode: sessionMetadata.collaborationMode,
       currentTurnId: null,
       lastTokenUsage: null,
       totalTokenUsage: null,
@@ -27895,10 +28829,9 @@ You have been logged out. Please try again.`);
       additionalDirectories: sessionMetadata.additionalDirectories,
       fastModeEnabled: sessionMetadata.currentServiceTier === "fast",
       currentModelSupportsFast,
-      planModeEnabled: false,
-      planModeExplicitlySet: false,
       sessionMcpServers,
       terminalOutputMode: this.terminalOutputMode,
+      goalRevision: 0,
       sessionTitle: null,
       sessionTitleSource: "unset"
     };
@@ -27913,6 +28846,7 @@ You have been logged out. Please try again.`);
       this.publishMcpStartupStatusAsync(sessionId);
     }
     const availableCommands = await this.availableCommands.getAvailableCommands(sessionState);
+    await this.publishCurrentGoalBestEffort(sessionState, requestedSessionGeneration, true);
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return {
@@ -27989,9 +28923,10 @@ You have been logged out. Please try again.`);
       case "userMessage":
         return this.createUserMessageUpdates(item);
       case "hookPrompt":
-      case "subAgentActivity":
       case "sleep":
         return [];
+      case "subAgentActivity":
+        return [createSubAgentActivityUpdate(item, "completed", "tool_call")];
       case "agentMessage": {
         return [{
           sessionUpdate: "agent_message_chunk",
@@ -28031,7 +28966,7 @@ You have been logged out. Please try again.`);
       case "contextCompaction":
         return [createCompletedContextCompactionUpdate(item)];
       case "plan":
-        return [this.createPlanUpdate(item)];
+        return item.text.length > 0 ? [this.createPlanHistoryUpdate(item)] : [];
     }
   }
   createUserMessageUpdates(item) {
@@ -28071,15 +29006,22 @@ You have been logged out. Please try again.`);
       }
     };
   }
-  createPlanUpdate(item) {
-    return {
-      sessionUpdate: "agent_message_chunk",
-      content: {
-        type: "text",
-        text: `Plan:
-${item.text}`
-      }
-    };
+  createPlanHistoryUpdate(item) {
+    if (clientSupportsPlanUpdates(this.clientCapabilities)) {
+      return {
+        sessionUpdate: "plan_update",
+        plan: {
+          type: "markdown",
+          planId: item.id,
+          content: item.text
+        }
+      };
+    }
+    return createAgentTextMessageChunk(
+      item.text,
+      item.id,
+      createCodexMessagePhaseMeta("final_answer")
+    );
   }
   userInputToContentBlocks(input) {
     switch (input.type) {
@@ -28190,7 +29132,6 @@ ${item.text}`
       cancelSignal,
       signal: abortController.signal,
       currentTurn: null,
-      outcome: null,
       requestCancel: () => {
         if (abortController.signal.aborted) {
           return;
@@ -28241,51 +29182,6 @@ ${item.text}`
     if (pending.size === 0) this.pendingSteers.delete(sessionId);
     await this.connection.notify(CODEX_STEER_APPLIED_METHOD, { sessionId, steerId });
   }
-  async steerPrompt(params) {
-    const steerId = getCodexSteerId(params._meta);
-    if (!steerId) throw RequestError.invalidRequest("Missing Codex steer id");
-    const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
-    if (firstText.startsWith("/")) {
-      throw RequestError.invalidRequest("Slash commands cannot steer an active Codex turn");
-    }
-    let activePrompt = this.activePrompts.get(params.sessionId);
-    if (!activePrompt) throw RequestError.invalidRequest("No active Codex turn to steer");
-    if (!activePrompt.currentTurn) {
-      await this.pendingTurnStarts.get(params.sessionId)?.promise;
-      activePrompt = this.activePrompts.get(params.sessionId);
-    }
-    const turn = activePrompt?.currentTurn;
-    if (!activePrompt || !turn || activePrompt.signal.aborted) {
-      throw RequestError.invalidRequest("No active Codex turn to steer");
-    }
-    const pending = this.pendingSteers.get(params.sessionId) ?? /* @__PURE__ */ new Map();
-    if (pending.has(steerId)) {
-      throw RequestError.invalidRequest(`Duplicate Codex steer id: ${steerId}`);
-    }
-    pending.set(steerId, { activePrompt, turnId: turn.turnId });
-    this.pendingSteers.set(params.sessionId, pending);
-    try {
-      const steeredTurnId = await this.runWithProcessCheck(
-        () => this.codexAcpClient.sendSteer(params, turn.turnId, steerId)
-      );
-      if (steeredTurnId !== turn.turnId) {
-        throw RequestError.internalError(
-          void 0,
-          `Codex steered unexpected turn ${steeredTurnId}; expected ${turn.turnId}`
-        );
-      }
-    } catch (error48) {
-      if (pending.get(steerId)?.activePrompt === activePrompt) {
-        pending.delete(steerId);
-        if (pending.size === 0) this.pendingSteers.delete(params.sessionId);
-      }
-      throw error48;
-    }
-    if (!activePrompt.outcome) {
-      throw RequestError.internalError(void 0, "Active Codex prompt has no tracked outcome");
-    }
-    return await activePrompt.outcome;
-  }
   cancelBeforeTurnStarted(activePrompt) {
     return activePrompt.cancelSignal.then(() => {
       if (activePrompt.currentTurn === null) {
@@ -28363,43 +29259,40 @@ ${item.text}`
     return activePrompt.signal.aborted || this.activePrompts.get(sessionId) !== activePrompt || this.sessionIsClosing(sessionId);
   }
   async interruptSessionTurn(sessionState, requestName, resolveInterruptedTurn) {
-    const turnId = await this.getInterruptibleTurnId(sessionState, requestName);
-    if (!turnId) {
+    const turn = await this.getInterruptibleTurn(sessionState, requestName);
+    if (!turn) {
       return;
     }
     logger.log(`${requestName} session requested`, {
       sessionId: sessionState.sessionId,
-      currentTurnId: turnId
+      threadId: turn.threadId,
+      currentTurnId: turn.turnId
     });
     if (resolveInterruptedTurn) {
-      this.codexAcpClient.markTurnStale({
-        threadId: sessionState.sessionId,
-        turnId
-      });
+      this.codexAcpClient.markTurnStale(turn);
     }
     try {
-      await this.runWithProcessCheck(() => this.codexAcpClient.turnInterrupt({
-        threadId: sessionState.sessionId,
-        turnId
-      }));
+      await this.runWithProcessCheck(() => this.codexAcpClient.turnInterrupt(turn));
       logger.log(`${requestName} - turnInterrupt succeeded`, {
         sessionId: sessionState.sessionId,
-        currentTurnId: turnId
+        threadId: turn.threadId,
+        currentTurnId: turn.turnId
       });
     } catch (err) {
       logger.error(`${requestName} - turnInterrupt failed`, err);
     } finally {
       if (resolveInterruptedTurn) {
-        this.codexAcpClient.resolveTurnInterrupted({
-          threadId: sessionState.sessionId,
-          turnId
-        });
+        this.codexAcpClient.resolveTurnInterrupted(turn);
       }
     }
   }
-  async getInterruptibleTurnId(sessionState, requestName) {
+  async getInterruptibleTurn(sessionState, requestName) {
+    const currentTurn = this.activePrompts.get(sessionState.sessionId)?.currentTurn;
+    if (currentTurn) {
+      return currentTurn;
+    }
     if (sessionState.currentTurnId) {
-      return sessionState.currentTurnId;
+      return { threadId: sessionState.sessionId, turnId: sessionState.currentTurnId };
     }
     const pendingTurnStart = this.pendingTurnStarts.get(sessionState.sessionId);
     if (!pendingTurnStart) {
@@ -28413,26 +29306,17 @@ ${item.text}`
     const turnId = await pendingTurnStart.promise;
     if (!turnId) {
       logger.log(`${requestName} request rejected: no current turn`, { sessionId: sessionState.sessionId });
+      return null;
     }
-    return turnId;
+    const startedTurn = this.activePrompts.get(sessionState.sessionId)?.currentTurn;
+    return startedTurn ?? { threadId: sessionState.sessionId, turnId };
   }
-  async prompt(params, signal) {
-    if (getCodexSteerId(params._meta)) {
-      return await this.steerPrompt(params);
-    }
+  async prompt(params, signal, onTurnStarted) {
     if (this.activePrompts.has(params.sessionId)) {
       throw RequestError.invalidRequest(
         "A Codex prompt is already active; use the advertised steer extension"
       );
     }
-    const outcome = this.runPrompt(params, signal);
-    const activePrompt = this.activePrompts.get(params.sessionId);
-    if (activePrompt) {
-      activePrompt.outcome = outcome;
-    }
-    return await outcome;
-  }
-  async runPrompt(params, signal) {
     logger.log("Prompt received", {
       sessionId: params.sessionId,
       prompt: params.prompt
@@ -28441,11 +29325,23 @@ ${item.text}`
     sessionState.currentTurnId = null;
     sessionState.lastTokenUsage = null;
     const activePrompt = this.trackActivePrompt(params.sessionId);
-    const pendingTurnStart = this.createPendingTurnStart();
-    this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+    let pendingTurnStart = null;
+    const ensurePendingTurnStart = () => {
+      if (pendingTurnStart === null) {
+        pendingTurnStart = this.createPendingTurnStart();
+        this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+      }
+      return pendingTurnStart;
+    };
     const disposePromptRequestCancellation = this.observePromptRequestCancellation(signal, sessionState, activePrompt);
+    let eventHandler = null;
     try {
-      const eventHandler = new CodexEventHandler(this.connection, sessionState);
+      const promptEventHandler = new CodexEventHandler(
+        this.connection,
+        sessionState,
+        clientSupportsPlanUpdates(this.clientCapabilities)
+      );
+      eventHandler = promptEventHandler;
       const approvalHandler = new CodexApprovalHandler(this.connection, sessionState, activePrompt.signal);
       const elicitationHandler = new CodexElicitationHandler(
         this.connection,
@@ -28458,7 +29354,7 @@ ${item.text}`
         async (event) => {
           await this.handleSteerAppliedNotification(params.sessionId, event, activePrompt);
           await elicitationHandler.handleNotification(event);
-          return eventHandler.handleNotification(event);
+          return promptEventHandler.handleNotification(event);
         },
         approvalHandler,
         elicitationHandler
@@ -28467,6 +29363,9 @@ ${item.text}`
         return this.cancelledPromptResponse(sessionState);
       }
       const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
+        onTurnStartPending: () => {
+          ensurePendingTurnStart();
+        },
         onTurnStarted: (turnId, threadId) => {
           const turn = { threadId, turnId };
           activePrompt.currentTurn = turn;
@@ -28475,7 +29374,20 @@ ${item.text}`
             return;
           }
           sessionState.currentTurnId = turnId;
-          pendingTurnStart.resolve(turnId);
+          pendingTurnStart?.resolve(turnId);
+          onTurnStarted?.();
+        },
+        setConfigOption: async (configId, value) => {
+          await this.applySessionConfigOption(sessionState, {
+            sessionId: sessionState.sessionId,
+            configId,
+            value
+          });
+          const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+          await session.update({
+            sessionUpdate: "config_option_update",
+            configOptions: this.createSessionConfigOptions(sessionState)
+          });
         }
       });
       void commandPromise.catch((err) => {
@@ -28495,7 +29407,6 @@ ${item.text}`
         logger.log("Prompt handled by a command");
         await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
         if (commandResult.turnCompleted?.turn.status === "interrupted") {
-          await this.notifyConversationInterrupted(params.sessionId);
           return this.cancelledPromptResponse(sessionState);
         }
         const error49 = eventHandler.getFailure();
@@ -28528,14 +29439,13 @@ ${item.text}`
         sessionState.fastModeEnabled,
         sessionState.currentModelSupportsFast
       );
-      const collaborationMode = this.createPlanModeCollaborationMode(sessionState, modelId);
+      ensurePendingTurnStart();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
           params,
           agentMode,
           modelId,
           serviceTier,
-          collaborationMode,
           disableSummary,
           sessionState.cwd,
           sessionState.additionalDirectories,
@@ -28547,7 +29457,8 @@ ${item.text}`
               return;
             }
             sessionState.currentTurnId = turnId;
-            pendingTurnStart.resolve(turnId);
+            pendingTurnStart?.resolve(turnId);
+            onTurnStarted?.();
           },
           () => this.promptShouldStop(params.sessionId, activePrompt)
         )
@@ -28557,7 +29468,7 @@ ${item.text}`
           logger.error(`Prompt for cancelled session ${params.sessionId} failed after prompt returned`, err);
         }
       });
-      const turnCompleted = await Promise.race([
+      let turnCompleted = await Promise.race([
         sendPromptPromise,
         activePrompt.closeSignal,
         this.cancelBeforeTurnStarted(activePrompt)
@@ -28567,13 +29478,81 @@ ${item.text}`
       }
       await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       if (turnCompleted.turn.status === "interrupted") {
-        await this.notifyConversationInterrupted(params.sessionId);
+        await eventHandler.flushPendingPlanUpdates();
         return this.cancelledPromptResponse(sessionState);
       }
       const error48 = eventHandler.getFailure();
       if (error48) {
         throw error48;
       }
+      await eventHandler.flushPendingPlanUpdates();
+      const completedPlan = eventHandler.takeCompletedPlan();
+      if (completedPlan !== null && sessionState.collaborationMode === PLAN_COLLABORATION_MODE && !this.promptShouldStop(params.sessionId, activePrompt)) {
+        const approved = await this.requestPlanImplementationPermission(
+          sessionState,
+          completedPlan,
+          activePrompt.signal
+        );
+        if (this.promptShouldStop(params.sessionId, activePrompt)) {
+          return this.cancelledPromptResponse(sessionState);
+        }
+        if (approved && !this.promptShouldStop(params.sessionId, activePrompt)) {
+          await this.applyCollaborationModeChange(sessionState, DEFAULT_COLLABORATION_MODE);
+          const session = new ACPSessionConnection(this.connection, sessionState.sessionId);
+          await session.update({
+            sessionUpdate: "config_option_update",
+            configOptions: this.createSessionConfigOptions(sessionState)
+          });
+          const implementationRequest = {
+            sessionId: params.sessionId,
+            prompt: [{ type: "text", text: "Implement the approved plan." }]
+          };
+          activePrompt.currentTurn = null;
+          const implementationPromise = this.runWithProcessCheck(
+            () => this.codexAcpClient.sendPrompt(
+              implementationRequest,
+              agentMode,
+              modelId,
+              serviceTier,
+              disableSummary,
+              sessionState.cwd,
+              sessionState.additionalDirectories,
+              (turnId) => {
+                const turn = { threadId: params.sessionId, turnId };
+                activePrompt.currentTurn = turn;
+                if (this.promptShouldStop(params.sessionId, activePrompt)) {
+                  this.interruptLateStartedTurn(turn);
+                  return;
+                }
+                sessionState.currentTurnId = turnId;
+              },
+              () => this.promptShouldStop(params.sessionId, activePrompt)
+            )
+          );
+          void implementationPromise.catch((err) => {
+            if (this.activePrompts.get(params.sessionId) !== activePrompt) {
+              logger.error(`Implementation turn for cancelled prompt ${params.sessionId} failed after prompt returned`, err);
+            }
+          });
+          turnCompleted = await Promise.race([
+            implementationPromise,
+            activePrompt.closeSignal,
+            this.cancelBeforeTurnStarted(activePrompt)
+          ]);
+          if (turnCompleted === null) {
+            return this.cancelledPromptResponse(sessionState);
+          }
+          await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+          if (turnCompleted.turn.status === "interrupted") {
+            await eventHandler.flushPendingPlanUpdates();
+            return this.cancelledPromptResponse(sessionState);
+          }
+          const implementationError = eventHandler.getFailure();
+          if (implementationError) {
+            throw implementationError;
+          }
+        }
+      }
       await this.publishFallbackSessionTitle(
         sessionState,
         this.createPromptFallbackTitle(params.prompt)
@@ -28588,6 +29567,7 @@ ${item.text}`
       throw err;
     } finally {
       logger.log("Prompt completed", { sessionId: params.sessionId });
+      await eventHandler?.dispose();
       disposePromptRequestCancellation();
       sessionState.currentTurnId = null;
       const registeredPendingTurnStart = this.pendingTurnStarts.get(params.sessionId);
@@ -28598,6 +29578,57 @@ ${item.text}`
       activePrompt.complete();
     }
   }
+  async requestPlanImplementationPermission(sessionState, plan, cancellationSignal) {
+    const toolCallId = `plan-review:${plan.itemId}`;
+    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
+            }
+          }
+        },
+        { cancellationSignal }
+      );
+      const approved = response.outcome.outcome === "selected" && response.outcome.optionId === IMPLEMENT_PLAN_OPTION_ID;
+      await this.connection.notify(methods.client.session.update, {
+        sessionId: sessionState.sessionId,
+        update: {
+          sessionUpdate: "tool_call_update",
+          toolCallId,
+          status: "completed",
+          rawOutput: approved ? "User approved the plan." : "User kept the session in plan mode."
+        }
+      });
+      return approved;
+    } catch (error48) {
+      logger.error("Error requesting plan implementation permission", error48);
+      return false;
+    }
+  }
   cancelledPromptResponse(sessionState) {
     return {
       stopReason: "cancelled",
@@ -28605,15 +29636,6 @@ ${item.text}`
       _meta: this.buildQuotaMeta(sessionState)
     };
   }
-  async notifyConversationInterrupted(sessionId) {
-    if (this.sessionIsClosing(sessionId) || !this.sessions.has(sessionId)) {
-      return;
-    }
-    await this.connection.notify(methods.client.session.update, {
-      sessionId,
-      update: createAgentTextMessageChunk("*Conversation interrupted*")
-    });
-  }
   buildQuotaMeta(sessionState) {
     const lastTokenUsage = sessionState.lastTokenUsage;
     const modelName = sessionState.currentModelId.replace(/\[.*?]$/, "");
@@ -28746,9 +29768,16 @@ var CodexAppServerClient = class {
   threadStatusCaptures = /* @__PURE__ */ new Map();
   threadGoalUpdateCaptures = /* @__PURE__ */ new Map();
   threadGoalClearedCaptures = /* @__PURE__ */ new Map();
+  threadSettings = /* @__PURE__ */ new Map();
   staleTurnIds = /* @__PURE__ */ new Map();
+  turnCompletionTerminalError = null;
   constructor(connection) {
     this.connection = connection;
+    const failPendingTurns = () => this.rejectAllPendingTurnCompletions(
+      new Error("Codex process exited before completing the turn")
+    );
+    this.connection.onClose(failPendingTurns);
+    this.connection.onDispose(failPendingTurns);
     this.connection.onUnhandledNotification((data) => {
       const serverNotification = data;
       if (isMcpServerStatusUpdatedNotification(serverNotification)) {
@@ -28775,6 +29804,9 @@ var CodexAppServerClient = class {
       if (isThreadGoalClearedNotification(serverNotification)) {
         this.recordThreadGoalCleared(serverNotification.params);
       }
+      if (serverNotification.method === "thread/settings/updated") {
+        this.threadSettings.set(serverNotification.params.threadId, serverNotification.params.threadSettings);
+      }
       const routing = extractTurnRouting(serverNotification);
       if (this.handleStaleTurnNotification(serverNotification, routing)) {
         return;
@@ -28856,9 +29888,6 @@ var CodexAppServerClient = class {
   async turnStart(params) {
     return await this.sendRequest({ method: "turn/start", params });
   }
-  async turnSteer(params) {
-    return await this.sendRequest({ method: "turn/steer", params });
-  }
   async runTurn(params, onTurnStarted) {
     const capturedCompletions = [];
     const releaseCapture = this.captureTurnCompletions(params.threadId, (event) => {
@@ -28868,11 +29897,12 @@ var CodexAppServerClient = class {
       const turnStarted = await this.turnStart(params);
       onTurnStarted?.(turnStarted.turn.id);
       const earlyCompletion = capturedCompletions.find((event) => event.turn.id === turnStarted.turn.id);
-      releaseCapture();
       if (earlyCompletion) {
         return earlyCompletion;
       }
-      return await this.awaitTurnCompleted(params.threadId, turnStarted.turn.id);
+      const completion = this.awaitTurnCompleted(params.threadId, turnStarted.turn.id);
+      releaseCapture();
+      return await completion;
     } finally {
       releaseCapture();
     }
@@ -28886,16 +29916,17 @@ var CodexAppServerClient = class {
       const reviewStarted = await this.reviewStart(params);
       onTurnStarted?.(reviewStarted.turn.id, reviewStarted.reviewThreadId);
       const earlyCompletion = capturedCompletions.find((event) => event.turn.id === reviewStarted.turn.id);
-      releaseCapture();
       if (earlyCompletion) {
         return earlyCompletion;
       }
-      return await this.awaitTurnCompleted(reviewStarted.reviewThreadId, reviewStarted.turn.id);
+      const completion = this.awaitTurnCompleted(reviewStarted.reviewThreadId, reviewStarted.turn.id);
+      releaseCapture();
+      return await completion;
     } finally {
       releaseCapture();
     }
   }
-  async runGoalSet(params, onTurnStarted, runtimeEffectsGraceMs = GOAL_RUNTIME_EFFECTS_GRACE_MS) {
+  async runGoalSet(params, onTurnStarted, runtimeEffectsGraceMs = GOAL_RUNTIME_EFFECTS_GRACE_MS, onGoalSet) {
     let goalTurnId = null;
     const capturedCompletions = [];
     let resolveGoalTurnCompleted = () => {
@@ -28948,6 +29979,7 @@ var CodexAppServerClient = class {
     try {
       const goalSetResponse = await this.threadGoalSet(params);
       expectedGoal = goalSetResponse.goal;
+      onGoalSet?.(expectedGoal);
       if (capturedGoalUpdates.some((event) => goalsMatch(event.goal, expectedGoal))) {
         goalUpdateHandled = true;
         resolveGoalUpdateHandled();
@@ -29071,6 +30103,9 @@ var CodexAppServerClient = class {
   async turnInterrupt(params) {
     return await this.sendRequest({ method: "turn/interrupt", params });
   }
+  async turnSteer(params) {
+    return await this.sendRequest({ method: "turn/steer", params });
+  }
   async reviewStart(params) {
     return await this.sendRequest({ method: "review/start", params });
   }
@@ -29088,6 +30123,12 @@ var CodexAppServerClient = class {
   async threadFork(params) {
     return await this.sendRequest({ method: "thread/fork", params });
   }
+  getThreadSettings(threadId) {
+    return this.threadSettings.get(threadId);
+  }
+  async threadSettingsUpdate(params) {
+    await this.connection.sendRequest("thread/settings/update", params);
+  }
   async threadList(params) {
     return await this.sendRequest({ method: "thread/list", params });
   }
@@ -29109,6 +30150,9 @@ var CodexAppServerClient = class {
   async threadGoalSet(params) {
     return await this.sendRequest({ method: "thread/goal/set", params });
   }
+  async threadGoalGet(params) {
+    return await this.sendRequest({ method: "thread/goal/get", params });
+  }
   async threadGoalClear(params) {
     return await this.sendRequest({ method: "thread/goal/clear", params });
   }
@@ -29152,9 +30196,12 @@ var CodexAppServerClient = class {
   }
   //TODO create type-safe helper
   async awaitTurnCompleted(threadId, turnId) {
-    return await new Promise((resolve) => {
+    if (this.turnCompletionTerminalError) {
+      throw this.turnCompletionTerminalError;
+    }
+    return await new Promise((resolve, reject) => {
       const threadResolvers = this.getOrCreatePendingTurnCompletionResolvers(threadId);
-      threadResolvers.set(turnId, resolve);
+      threadResolvers.set(turnId, { resolve, reject });
     });
   }
   async awaitCompactionCompleted(threadId) {
@@ -29215,13 +30262,13 @@ var CodexAppServerClient = class {
   }
   recordTurnCompleted(event) {
     const threadResolvers = this.pendingTurnCompletionResolvers.get(event.threadId);
-    const resolve = threadResolvers?.get(event.turn.id);
-    if (resolve) {
+    const entry = threadResolvers?.get(event.turn.id);
+    if (entry) {
       threadResolvers.delete(event.turn.id);
       if (threadResolvers.size === 0) {
         this.pendingTurnCompletionResolvers.delete(event.threadId);
       }
-      resolve(event);
+      entry.resolve(event);
       return;
     }
     const captures = this.turnCompletionCaptures.get(event.threadId);
@@ -29322,6 +30369,22 @@ var CodexAppServerClient = class {
     this.pendingTurnCompletionResolvers.set(threadId, created);
     return created;
   }
+  /**
+   * The codex process exiting mid-turn means `turn/completed` will never
+   * arrive. Without this, `awaitTurnCompleted` hangs forever, the prompt
+   * promise never settles, and the session rejects every future prompt with
+   * "A Codex prompt is already active".
+   */
+  rejectAllPendingTurnCompletions(error48) {
+    this.turnCompletionTerminalError ??= error48;
+    const threads = [...this.pendingTurnCompletionResolvers.values()];
+    this.pendingTurnCompletionResolvers.clear();
+    for (const threadResolvers of threads) {
+      for (const entry of threadResolvers.values()) {
+        entry.reject(error48);
+      }
+    }
+  }
   captureTurnCompletions(threadId, capture) {
     const captures = this.turnCompletionCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
     captures.add(capture);
@@ -29633,6 +30696,15 @@ var legacySetSessionModelParamsParser = external_exports.object({
   sessionId: external_exports.string(),
   modelId: external_exports.string()
 }).passthrough();
+var sessionSteerParamsParser = external_exports.object({
+  sessionId: external_exports.string(),
+  prompt: external_exports.array(external_exports.any()),
+  steerId: external_exports.string().min(1).optional()
+}).passthrough();
+var goalControlParamsParser = external_exports.object({
+  sessionId: external_exports.string(),
+  action: external_exports.enum(["pause", "clear"])
+}).passthrough();
 if (process.argv.includes("--version")) {
   console.log(`${package_default.name} ${package_default.version}`);
   process.exit(0);
@@ -29704,5 +30776,5 @@ function startAcpServer() {
         codexAcpServer = null;
       }
     });
-  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().unstable_forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).connect(acpJsonStream);
+  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().unstable_forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).connect(acpJsonStream);
 }