@nyssance/codex-acp-v2 0.3.3 → 0.3.5

package/dist/index.js

@@ -21721,7 +21721,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.3.3",
+  version: "0.3.5",
   description: "Native ACP v2 agent for the OpenAI Codex app-server",
   packageManager: "bun@1.4.0",
   engines: {
@@ -21733,6 +21733,7 @@ var package_default = {
   files: [
     "dist/index.js",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "package.json"
   ],
@@ -21758,7 +21759,9 @@ var package_default = {
     test: "vitest run --exclude src/__tests__/e2e.test.ts",
     "test:watch": "vitest",
     typecheck: "tsc --noEmit",
-    "test:e2e": "RUN_E2E_TESTS=true vitest run src/__tests__/e2e.test.ts"
+    "test:e2e": "RUN_E2E_TESTS=true vitest run src/__tests__/e2e.test.ts",
+    "test:benchmark": "RUN_BENCHMARKS=true vitest run src/__tests__/benchmark.test.ts",
+    "test:soak": "bun --expose-gc src/benchmarks/bridge-soak.ts"
   },
   homepage: "https://github.com/nyssance/codex-acp-v2#readme",
   bugs: {
@@ -21794,6 +21797,46 @@ var package_default = {
   }
 };
 
+// src/agent/turnErrors.ts
+function classifyTurnError(info) {
+  const failure = (category, retryable = false, stopReason = "_error") => ({ category, retryable, stopReason });
+  if (info === null)
+    return failure("unknown");
+  if (typeof info === "object") {
+    if ("activeTurnNotSteerable" in info)
+      return failure("turn_not_steerable");
+    const status = "httpConnectionFailed" in info ? info.httpConnectionFailed.httpStatusCode : ("responseStreamConnectionFailed" in info) ? info.responseStreamConnectionFailed.httpStatusCode : ("responseStreamDisconnected" in info) ? info.responseStreamDisconnected.httpStatusCode : info.responseTooManyFailedAttempts.httpStatusCode;
+    return failure("connection", status === null || status === 408 || status === 429 || status >= 500);
+  }
+  switch (info) {
+    case "contextWindowExceeded":
+      return failure("context_window", false, "max_tokens");
+    case "cyberPolicy":
+    case "misalignmentPolicyViolation":
+      return failure("policy", false, "refusal");
+    case "sessionBudgetExceeded":
+      return failure("budget");
+    case "usageLimitExceeded":
+      return failure("usage_limit");
+    case "rateLimitExceeded":
+      return failure("rate_limit", true);
+    case "serverOverloaded":
+      return failure("overloaded", true);
+    case "internalServerError":
+      return failure("internal", true);
+    case "unauthorized":
+      return failure("authentication");
+    case "badRequest":
+      return failure("invalid_request");
+    case "threadRollbackFailed":
+      return failure("rollback");
+    case "sandboxError":
+      return failure("sandbox");
+    case "other":
+      return failure("unknown");
+  }
+}
+
 // src/agent/CodexAgent.ts
 import path6 from "path";
 
@@ -22756,9 +22799,6 @@ function toAcpStatus(status) {
       return "cancelled";
   }
 }
-function toolCallCancelled(toolCallId) {
-  return frame({ toolCallId, status: "cancelled" });
-}
 function frame(fields) {
   return { sessionUpdate: "tool_call_update", ...fields };
 }
@@ -22847,14 +22887,17 @@ function commandStarted(item) {
   });
 }
 function commandCompleted(item) {
+  const output = item.aggregatedOutput ?? "";
+  const truncated = output.length > 16384;
   return frame({
     toolCallId: item.id,
     status: item.status === "completed" ? "completed" : "failed",
     rawOutput: {
-      output: item.aggregatedOutput ?? "",
+      output: truncated ? output.slice(0, 16384).replace(/[\uD800-\uDBFF]$/, "") : output,
       exitCode: item.exitCode,
       durationMs: item.durationMs
     },
+    ...truncated ? { _meta: { codex: { outputTruncated: true, outputCharacters: output.length, ...usesTerminal(item) ? { terminalId: item.id } : {} } } } : {},
     ...usesTerminal(item) || !item.aggregatedOutput ? {} : { content: [textContent(item.aggregatedOutput)] }
   });
 }
@@ -23071,8 +23114,8 @@ function fuzzySearchUpdated(event, create) {
     rawInput: { query: event.query }
   });
 }
-function fuzzySearchCompleted(event) {
-  return frame({ toolCallId: fuzzySearchToolCallId(event.sessionId), status: "completed" });
+function fuzzySearchCompleted(event, create = false) {
+  return frame({ toolCallId: fuzzySearchToolCallId(event.sessionId), ...create ? { name: ToolName.FuzzySearch, title: "File search", kind: "search" } : {}, status: "completed" });
 }
 function guardianReviewToolCallId(reviewId) {
   return `guardian-review:${reviewId}`;
@@ -23143,6 +23186,7 @@ function mcpStartupFailed(serverName, message) {
 }
 
 // src/codex/sessionConfig.ts
+import { pathToFileURL } from "url";
 import path3 from "path";
 var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
 function sanitizeMcpServerName(name) {
@@ -23263,7 +23307,7 @@ function fromUserInput(input) {
   }
 }
 function toFileUri(value) {
-  return value.startsWith("file://") ? value : `file://${value}`;
+  return value.startsWith("file://") ? value : pathToFileURL(value).href;
 }
 function isSupportedImageUrl(uri) {
   if (!uri)
@@ -23295,6 +23339,65 @@ function promptTitle(prompt) {
   return null;
 }
 
+// src/bridge/itemSnapshot.ts
+function itemSnapshot(item) {
+  switch (item.type) {
+    case "userMessage": {
+      const content = item.content.flatMap(fromUserInput);
+      return content.length > 0 ? [{ sessionUpdate: "user_message", messageId: item.id, content }] : [];
+    }
+    case "agentMessage":
+      return item.text.length > 0 ? [{
+        sessionUpdate: "agent_message",
+        messageId: item.id,
+        content: [{ type: "text", text: item.text }],
+        ...item.phase ? { _meta: { codex: { phase: item.phase } } } : {}
+      }] : [];
+    case "reasoning": {
+      const parts = (item.summary.length > 0 ? item.summary : item.content).filter((part) => part.length > 0);
+      return parts.length > 0 ? [{ sessionUpdate: "agent_thought", messageId: item.id, content: parts.map((text) => ({ type: "text", text })) }] : [];
+    }
+    case "plan":
+      return item.text.length > 0 ? [{ sessionUpdate: "plan_update", plan: { type: "markdown", planId: item.id, content: item.text } }] : [];
+    case "fileChange":
+      return [fileChangeStarted(item)];
+    case "commandExecution": {
+      const updates = [commandStarted(item)];
+      if (usesTerminal(item))
+        updates.unshift(terminalSnapshot(item));
+      if (item.status !== "inProgress")
+        updates.push(commandCompleted(item));
+      return updates;
+    }
+    case "mcpToolCall":
+      return [mcpToolCallStarted(item)];
+    case "dynamicToolCall":
+      return [{ ...dynamicToolCallStarted(item), ...dynamicToolCallCompleted(item) }];
+    case "webSearch":
+      return [webSearchSnapshot(item)];
+    case "imageView":
+      return [imageViewed(item)];
+    case "imageGeneration":
+      return [imageGenerationSnapshot(item)];
+    case "collabAgentToolCall":
+      return [collabToolCall(item, true)];
+    case "subAgentActivity":
+      return [subAgentActivity(item, "completed", true)];
+    case "contextCompaction":
+      return [compactionUpdate(item.id, "completed")];
+    case "enteredReviewMode":
+      return [];
+    case "exitedReviewMode": {
+      const text = item.review.trim();
+      return text.length > 0 ? [{ sessionUpdate: "agent_message", messageId: item.id, content: [{ type: "text", text }] }] : [];
+    }
+    case "hookPrompt":
+    case "functionCallOutput":
+    case "sleep":
+      return [];
+  }
+}
+
 // src/bridge/EventBridge.ts
 var TURN_PLAN_ID = "codex-turn-plan";
 var PLAN_STREAM_INTERVAL_MS = 150;
@@ -23307,6 +23410,7 @@ class EventBridge {
   completedPlan = null;
   noticeSequence = 0;
   openToolCalls = new Set;
+  announcedTools = new Set;
   messagePhases = new Map;
   reasoningWithDeltas = new Set;
   terminalItems = new Set;
@@ -23327,6 +23431,14 @@ class EventBridge {
     this.lastError = null;
     this.completedPlan = null;
     this.openToolCalls.clear();
+    this.announcedTools.clear();
+    this.messagePhases.clear();
+    this.reasoningWithDeltas.clear();
+    this.terminalItems.clear();
+    this.imageGenerations.clear();
+    this.subAgentActivities.clear();
+    this.fuzzySearches.clear();
+    this.guardianReviews.clear();
     this.clearPlanState();
   }
   takeError() {
@@ -23339,24 +23451,47 @@ class EventBridge {
     this.completedPlan = null;
     return plan;
   }
+  async restore(items) {
+    for (const item of items) {
+      if (item.type === "commandExecution" && item.status === "inProgress" && usesTerminal(item))
+        this.terminalItems.add(item.id);
+      for (const update of itemSnapshot(item)) {
+        this.trackToolCall(update);
+        await this.client.update(update);
+      }
+    }
+  }
   async handle(notification) {
-    const updates = await this.translate(notification);
+    let updates = await this.translate(notification);
+    if (notification.method === "item/completed") {
+      const snapshots = itemSnapshot(notification.params.item);
+      const first = snapshots.find((update) => update.sessionUpdate === "tool_call_update");
+      if (first?.sessionUpdate === "tool_call_update" && !this.announcedTools.has(first.toolCallId)) {
+        updates = snapshots;
+      }
+    }
     for (const update of updates) {
       this.trackToolCall(update);
       await this.client.update(update);
     }
   }
-  async cancelOpenToolCalls() {
+  async finishOpenToolCalls(status) {
     const ids = [...this.openToolCalls];
+    const terminals = [...this.terminalItems];
     this.openToolCalls.clear();
+    this.terminalItems.clear();
+    for (const terminalId of terminals) {
+      await this.client.update({ sessionUpdate: "terminal_update", terminalId, exitStatus: { exitCode: null, signal: null }, _meta: { codex: { reconciled: true, turnOutcome: status } } });
+    }
     for (const toolCallId of ids) {
-      await this.client.update(toolCallCancelled(toolCallId));
+      await this.client.update({ sessionUpdate: "tool_call_update", toolCallId, status, _meta: { codex: { reconciled: true } } });
     }
   }
   trackToolCall(update) {
     if (update.sessionUpdate !== "tool_call_update")
       return;
     const { toolCallId, status } = update;
+    this.announcedTools.add(toolCallId);
     if (status === "pending" || status === "in_progress")
       this.openToolCalls.add(toolCallId);
     else if (status !== undefined && status !== null)
@@ -23366,7 +23501,7 @@ class EventBridge {
     await this.flushPlans();
   }
   dispose() {
-    this.clearPlanState();
+    this.beginTurn();
   }
   async translate(notification) {
     switch (notification.method) {
@@ -23398,14 +23533,17 @@ ${stdin}
 `)] : [];
       }
       case "item/fileChange/patchUpdated":
-        return [fileChangePatched({
+        return [(this.announcedTools.has(notification.params.itemId) ? fileChangePatched : fileChangeStarted)({
           type: "fileChange",
           id: notification.params.itemId,
           changes: notification.params.changes,
           status: "inProgress"
         })];
       case "item/mcpToolCall/progress":
-        return [mcpToolCallProgress(notification.params.itemId, notification.params.message)];
+        return [{
+          ...!this.announcedTools.has(notification.params.itemId) ? { name: ToolName.Mcp, title: "MCP tool", kind: "execute", status: "in_progress" } : {},
+          ...mcpToolCallProgress(notification.params.itemId, notification.params.message)
+        }];
       case "item/plan/delta":
         this.planDelta(notification.params.itemId, notification.params.delta);
         return [];
@@ -23427,9 +23565,11 @@ ${stdin}
         this.fuzzySearches.add(id);
         return [fuzzySearchUpdated(notification.params, create)];
       }
-      case "fuzzyFileSearch/sessionCompleted":
+      case "fuzzyFileSearch/sessionCompleted": {
+        const create = !this.fuzzySearches.has(notification.params.sessionId);
         this.fuzzySearches.delete(notification.params.sessionId);
-        return [fuzzySearchCompleted(notification.params)];
+        return [fuzzySearchCompleted(notification.params, create)];
+      }
       case "thread/tokenUsage/updated": {
         const usage = notification.params.tokenUsage;
         this.session.lastUsage = toTokenCount(usage.last);
@@ -23538,7 +23678,7 @@ ${details}` : summary)];
       case "commandExecution":
         if (usesTerminal(item)) {
           this.terminalItems.add(item.id);
-          return [commandStarted(item), terminalStarted(item)];
+          return [terminalStarted(item), commandStarted(item)];
         }
         return [commandStarted(item)];
       case "mcpToolCall":
@@ -23577,7 +23717,7 @@ ${details}` : summary)];
     switch (item.type) {
       case "agentMessage":
         this.messagePhases.delete(item.id);
-        return [];
+        return itemSnapshot(item);
       case "reasoning": {
         if (this.reasoningWithDeltas.delete(item.id))
           return [];
@@ -24749,6 +24889,29 @@ class TurnContext {
   }
 }
 
+// src/util/abort.ts
+function abortable(operation, signal) {
+  if (signal.aborted) {
+    operation.catch(() => {});
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    const cleanup = () => signal.removeEventListener("abort", abort);
+    signal.addEventListener("abort", abort, { once: true });
+    operation.then((value) => {
+      cleanup();
+      resolve(value);
+    }, (error40) => {
+      cleanup();
+      reject(error40);
+    });
+  });
+}
+
 // node_modules/open/index.js
 import process10 from "process";
 import path5 from "path";
@@ -25470,63 +25633,63 @@ async function loginWithApiKey(codex, request, env) {
   if (!apiKey) {
     throw RequestError.invalidParams({ envVars: [CODEX_API_KEY_ENV, OPENAI_API_KEY_ENV] }, `No API key: set ${CODEX_API_KEY_ENV} or ${OPENAI_API_KEY_ENV}, or pass _meta["api-key"].apiKey`);
   }
-  const completed = codex.awaitNotification("account/login/completed");
-  await codex.accountLogin({ type: "apiKey", apiKey });
-  const result = await completed;
-  if (!result.success)
-    throw RequestError.authRequired({ error: result.error }, result.error ?? "API key login failed");
+  await codex.withNotification("account/login/completed", async (completed) => {
+    await codex.accountLogin({ type: "apiKey", apiKey });
+    const result = await completed;
+    if (!result.success)
+      throw RequestError.authRequired({ error: result.error }, result.error ?? "API key login failed");
+  });
 }
 async function loginWithChatGpt(codex) {
   const account = await codex.accountRead({ refreshToken: true });
   if (account.account?.type === "chatgpt")
     return;
-  const completed = codex.awaitNotification("account/login/completed");
-  const started = await codex.accountLogin({ type: "chatgpt" });
-  if (started.type !== "chatgpt")
-    throw RequestError.internalError({ type: started.type }, "Unexpected login response");
-  logger.log("opening browser for ChatGPT login", { loginId: started.loginId });
-  await open_default(started.authUrl);
-  const result = await completed;
-  if (!result.success)
-    throw RequestError.authRequired({ error: result.error }, result.error ?? "ChatGPT login failed");
+  await codex.withNotification("account/login/completed", async (completed) => {
+    const started = await codex.accountLogin({ type: "chatgpt" });
+    if (started.type !== "chatgpt")
+      throw RequestError.internalError({ type: started.type }, "Unexpected login response");
+    logger.log("opening browser for ChatGPT login", { loginId: started.loginId });
+    await open_default(started.authUrl);
+    const result = await completed;
+    if (!result.success)
+      throw RequestError.authRequired({ error: result.error }, result.error ?? "ChatGPT login failed");
+  });
 }
 async function loginWithDeviceCode(codex, link, requestId) {
   const account = await codex.accountRead({ refreshToken: true });
   if (account.account?.type === "chatgpt")
     return;
-  const completed = codex.awaitNotification("account/login/completed");
-  const started = await codex.accountLogin({ type: "chatgptDeviceCode" });
-  if (started.type !== "chatgptDeviceCode")
-    throw RequestError.internalError({ type: started.type }, "Unexpected login response");
-  const elicitation = link.request(methods.client.elicitation.create, {
-    mode: "url",
-    requestId,
-    elicitationId: started.loginId,
-    url: started.verificationUrl,
-    message: `Sign in to ChatGPT and enter this code: ${started.userCode}`
-  });
-  elicitation.catch(() => {});
-  const first = await Promise.race([
-    completed.then((result2) => ({ kind: "completed", result: result2 })),
-    elicitation.then((response) => ({ kind: "elicitation", response }))
-  ]);
-  if (first.kind === "elicitation" && !CreateElicitationResponse.isAccept(first.response)) {
-    await codex.accountLoginCancel({ loginId: started.loginId });
-    throw RequestError.authRequired(undefined, "ChatGPT device code login was cancelled");
-  }
-  const result = first.kind === "completed" ? first.result : await completed;
-  await link.notify(methods.client.elicitation.complete, { elicitationId: started.loginId });
-  if (!result.success)
-    throw RequestError.authRequired({ error: result.error }, result.error ?? "ChatGPT login failed");
+  await codex.withNotification("account/login/completed", async (completed) => {
+    const started = await codex.accountLogin({ type: "chatgptDeviceCode" });
+    if (started.type !== "chatgptDeviceCode")
+      throw RequestError.internalError({ type: started.type }, "Unexpected login response");
+    const elicitation = link.request(methods.client.elicitation.create, {
+      mode: "url",
+      requestId,
+      elicitationId: started.loginId,
+      url: started.verificationUrl,
+      message: `Sign in to ChatGPT and enter this code: ${started.userCode}`
+    });
+    elicitation.catch(() => {});
+    const first = await Promise.race([
+      completed.then((result2) => ({ kind: "completed", result: result2 })),
+      elicitation.then((response) => ({ kind: "elicitation", response }))
+    ]);
+    if (first.kind === "elicitation" && !CreateElicitationResponse.isAccept(first.response)) {
+      await codex.accountLoginCancel({ loginId: started.loginId });
+      throw RequestError.authRequired(undefined, "ChatGPT device code login was cancelled");
+    }
+    const result = first.kind === "completed" ? first.result : await completed;
+    await link.notify(methods.client.elicitation.complete, { elicitationId: started.loginId });
+    if (!result.success)
+      throw RequestError.authRequired({ error: result.error }, result.error ?? "ChatGPT login failed");
+  });
 }
 async function logout(codex) {
-  const updated = codex.awaitNotification("account/updated");
-  await codex.accountLogout();
-  await updated;
-}
-async function authRequired(codex) {
-  const account = await codex.accountRead({ refreshToken: false });
-  return account.requiresOpenaiAuth && account.account === null;
+  await codex.withNotification("account/updated", async (updated) => {
+    await codex.accountLogout();
+    await updated;
+  });
 }
 
 // src/agent/clientSession.ts
@@ -25536,33 +25699,61 @@ class ClientSession {
   capabilities;
   waiting = 0;
   turnActive = false;
+  turnGeneration = 0;
+  disposed = false;
+  output = new AbortController;
+  terminalAttempted = false;
+  get signal() {
+    return this.output.signal;
+  }
   constructor(sessionId, link, capabilities) {
     this.sessionId = sessionId;
     this.link = link;
     this.capabilities = capabilities;
   }
   async update(update) {
-    await this.link.notify(methods.client.session.update, { sessionId: this.sessionId, update });
+    if (this.disposed)
+      return;
+    await abortable(this.link.notify(methods.client.session.update, { sessionId: this.sessionId, update }), this.output.signal);
   }
   async updateAll(updates) {
     for (const update of updates)
       await this.update(update);
   }
   async requestPermission(request, signal) {
-    return await this.waitingOnClient(() => this.link.request(methods.client.session.requestPermission, { sessionId: this.sessionId, ...request }, signal ? { cancellationSignal: signal } : undefined));
+    signal = signal ? AbortSignal.any([signal, this.output.signal]) : this.output.signal;
+    signal.throwIfAborted();
+    return await this.waitingOnClient(() => {
+      signal?.throwIfAborted();
+      const pending = this.link.request(methods.client.session.requestPermission, { sessionId: this.sessionId, ...request }, signal ? { cancellationSignal: signal } : undefined);
+      return signal ? abortable(pending, signal) : pending;
+    }, signal);
   }
   async createElicitation(request, signal) {
-    return await this.waitingOnClient(() => this.link.request(methods.client.elicitation.create, request, signal ? { cancellationSignal: signal } : undefined));
+    signal = signal ? AbortSignal.any([signal, this.output.signal]) : this.output.signal;
+    signal.throwIfAborted();
+    return await this.waitingOnClient(() => {
+      signal?.throwIfAborted();
+      const pending = this.link.request(methods.client.elicitation.create, request, signal ? { cancellationSignal: signal } : undefined);
+      return signal ? abortable(pending, signal) : pending;
+    }, signal);
   }
   async completeElicitation(elicitationId) {
-    await this.link.notify(methods.client.elicitation.complete, { elicitationId });
+    if (this.disposed)
+      return;
+    await abortable(this.link.notify(methods.client.elicitation.complete, { elicitationId }), this.output.signal);
   }
   reportRunning() {
+    this.terminalAttempted = false;
+    this.turnGeneration += 1;
     this.turnActive = true;
     this.waiting = 0;
     this.state({ sessionUpdate: "state_update", state: "running" });
   }
   async reportIdle(stopReason, extra) {
+    if (this.terminalAttempted)
+      return;
+    this.terminalAttempted = true;
     this.turnActive = false;
     this.waiting = 0;
     await this.update({
@@ -25573,18 +25764,21 @@ class ClientSession {
       ...extra?._meta === undefined ? {} : { _meta: extra._meta }
     });
   }
-  async waitingOnClient(operation) {
-    if (this.turnActive && this.waiting++ === 0) {
-      await this.state({ sessionUpdate: "state_update", state: "requires_action" });
-    }
+  async waitingOnClient(operation, signal) {
+    if (this.disposed)
+      throw new Error("Session is closed");
+    const generation = this.turnActive ? this.turnGeneration : null;
     try {
+      if (generation !== null && this.waiting++ === 0) {
+        const pending = this.state({ sessionUpdate: "state_update", state: "requires_action" });
+        await (signal ? abortable(pending, signal) : pending);
+      }
       return await operation();
     } finally {
-      if (this.turnActive && --this.waiting === 0) {
-        await this.state({ sessionUpdate: "state_update", state: "running" });
+      if (this.turnActive && generation === this.turnGeneration && --this.waiting === 0) {
+        const pending = this.state({ sessionUpdate: "state_update", state: "running" });
+        await (signal ? abortable(pending, signal).catch(() => {}) : pending);
       }
-      if (this.waiting < 0)
-        this.waiting = 0;
     }
   }
   async state(update) {
@@ -25594,6 +25788,12 @@ class ClientSession {
       logger.error("Failed to publish session state", error40, { sessionId: this.sessionId });
     }
   }
+  dispose() {
+    this.disposed = true;
+    this.output.abort();
+    this.turnActive = false;
+    this.waiting = 0;
+  }
 }
 
 // src/agent/commands.ts
@@ -25830,7 +26030,7 @@ function historyUpdates(turns) {
   const updates = [];
   for (const turn of turns) {
     for (const item of turn.items) {
-      updates.push(...itemHistory(item));
+      updates.push(...itemSnapshot(item));
     }
   }
   return updates;
@@ -25855,63 +26055,6 @@ function firstLine(text2) {
   const line = text2.split(/\r?\n/).map((part) => part.trim()).find((part) => part.length > 0) ?? text2;
   return line.length > 120 ? `${line.slice(0, 117)}...` : line;
 }
-function itemHistory(item) {
-  switch (item.type) {
-    case "userMessage": {
-      const content = item.content.flatMap(fromUserInput);
-      return content.length > 0 ? [{ sessionUpdate: "user_message", messageId: item.id, content }] : [];
-    }
-    case "agentMessage":
-      return item.text.length > 0 ? [{
-        sessionUpdate: "agent_message",
-        messageId: item.id,
-        content: [{ type: "text", text: item.text }],
-        ...item.phase ? { _meta: { codex: { phase: item.phase } } } : {}
-      }] : [];
-    case "reasoning": {
-      const parts = (item.summary.length > 0 ? item.summary : item.content).filter((part) => part.length > 0);
-      return parts.length > 0 ? [{ sessionUpdate: "agent_thought", messageId: item.id, content: parts.map((text2) => ({ type: "text", text: text2 })) }] : [];
-    }
-    case "plan":
-      return item.text.length > 0 ? [{ sessionUpdate: "plan_update", plan: { type: "markdown", planId: item.id, content: item.text } }] : [];
-    case "fileChange":
-      return [fileChangeStarted(item)];
-    case "commandExecution": {
-      const updates = [commandStarted(item)];
-      if (usesTerminal(item))
-        updates.push(terminalSnapshot(item));
-      if (item.status !== "inProgress")
-        updates.push(commandCompleted(item));
-      return updates;
-    }
-    case "mcpToolCall":
-      return [mcpToolCallStarted(item)];
-    case "dynamicToolCall":
-      return [{ ...dynamicToolCallStarted(item), ...dynamicToolCallCompleted(item) }];
-    case "webSearch":
-      return [webSearchSnapshot(item)];
-    case "imageView":
-      return [imageViewed(item)];
-    case "imageGeneration":
-      return [imageGenerationSnapshot(item)];
-    case "collabAgentToolCall":
-      return [collabToolCall(item, true)];
-    case "subAgentActivity":
-      return [subAgentActivity(item, "completed", true)];
-    case "contextCompaction":
-      return [compactionUpdate(item.id, "completed")];
-    case "enteredReviewMode":
-      return [];
-    case "exitedReviewMode": {
-      const text2 = item.review.trim();
-      return text2.length > 0 ? [{ sessionUpdate: "agent_message", messageId: item.id, content: [{ type: "text", text: text2 }] }] : [];
-    }
-    case "hookPrompt":
-    case "functionCallOutput":
-    case "sleep":
-      return [];
-  }
-}
 
 // src/agent/providers.ts
 var OPENAI_PROVIDER_ID = "openai";
@@ -25926,6 +26069,11 @@ class ProviderRouting {
     this.baseConfig = baseConfig;
     this.configuredProvider = configuredProvider;
   }
+  copy() {
+    const copy = new ProviderRouting(this.baseConfig, this.configuredProvider);
+    copy.gateway = this.gateway;
+    return copy;
+  }
   get active() {
     return this.gateway;
   }
@@ -26046,7 +26194,7 @@ function gatewayModel(model, isDefault, template) {
 function createActiveTurn(threadId) {
   let resolveStarted = () => {};
   let resolveFinished = () => {};
-  const started = new Promise((resolve) => {
+  let started = new Promise((resolve) => {
     resolveStarted = resolve;
   });
   const finished = new Promise((resolve) => {
@@ -26058,7 +26206,18 @@ function createActiveTurn(threadId) {
     turnId: null,
     threadId,
     abort: new AbortController,
-    started,
+    stop: new AbortController,
+    interrupts: new Map,
+    get started() {
+      return started;
+    },
+    resetStarted() {
+      this.turnId = null;
+      startedSettled = false;
+      started = new Promise((resolve) => {
+        resolveStarted = resolve;
+      });
+    },
     resolveStarted(turnId) {
       if (startedSettled)
         return;
@@ -26078,7 +26237,6 @@ function createActiveTurn(threadId) {
 // src/agent/CodexAgent.ts
 var CLOSE_TURN_GRACE_MS = 5000;
 var HISTORY_PAGE_SIZE = 50;
-var ERROR_STOP_REASON = "_error";
 var IMPLEMENT_PLAN_OPTION = "implement_plan";
 var REVISE_PLAN_OPTION = "revise_plan";
 
@@ -26087,13 +26245,27 @@ class CodexAgent {
   codex;
   process;
   providers;
+  switching = false;
+  admissions = 0;
+  pendingUnsubscribes = new Map;
+  sessionMutations = new Set;
+  providerQueue = Promise.resolve();
   info;
   env;
   closeGraceMs;
   sessions = new Map;
   capabilities = null;
   codexInitialized = false;
+  initializing = null;
+  terminalTurns = new WeakSet;
+  completedTurns = new WeakMap;
   skillRoots = [];
+  skillsGeneration = 0;
+  changingSkillRoots = false;
+  publishedSkills = new WeakMap;
+  skillSnapshots = new Map;
+  skillsQueue = Promise.resolve();
+  accountGeneration = 0;
   constructor(link, options) {
     this.link = link;
     this.codex = options.codex;
@@ -26104,22 +26276,40 @@ class CodexAgent {
     this.closeGraceMs = options.closeGraceMs ?? CLOSE_TURN_GRACE_MS;
     this.process?.exited.then(() => this.handleCodexExit());
     this.codex.connection.onClose(() => this.handleCodexExit());
+    const stopObserving = this.codex.observeNotifications((notification) => {
+      if (notification.method === "skills/changed") {
+        this.skillsGeneration += 1;
+        this.skillSnapshots.clear();
+        if (!this.changingSkillRoots)
+          for (const runtime of this.sessions.values())
+            this.refreshAvailableCommands(runtime);
+      }
+      if (notification.method === "account/updated")
+        this.refreshAccounts().catch((error40) => logger.error("refreshing account failed", error40));
+    });
+    this.codex.disconnectSignal.addEventListener("abort", stopObserving, { once: true });
   }
   async initialize(params) {
     if (params.protocolVersion !== PROTOCOL_VERSION) {
       throw RequestError.invalidParams({ protocolVersion: params.protocolVersion }, `Unsupported protocol version ${params.protocolVersion}; this agent speaks ACP v${PROTOCOL_VERSION}`);
     }
-    this.capabilities = {
+    const capabilities = {
       formElicitation: params.capabilities?.elicitation?.form != null,
       urlElicitation: params.capabilities?.elicitation?.url != null
     };
     if (!this.codexInitialized) {
-      await this.withCodex(() => this.codex.initialize({
-        clientInfo: { name: params.info.name, title: params.info.title ?? null, version: params.info.version },
-        capabilities: { experimentalApi: true, requestAttestation: false }
-      }));
-      this.codexInitialized = true;
+      this.initializing ??= this.withCodex(async () => {
+        await this.codex.initialize({
+          clientInfo: { name: params.info.name, title: params.info.title ?? null, version: params.info.version },
+          capabilities: { experimentalApi: true, requestAttestation: false }
+        });
+        this.codexInitialized = true;
+      }).finally(() => {
+        this.initializing = null;
+      });
+      await this.initializing;
     }
+    this.capabilities = capabilities;
     return {
       protocolVersion: PROTOCOL_VERSION,
       info: this.info,
@@ -26156,7 +26346,11 @@ class CodexAgent {
     return {};
   }
   async refreshAccounts() {
+    this.codex.invalidateModels();
+    const generation = ++this.accountGeneration;
     const account = (await this.codex.accountRead({ refreshToken: false })).account;
+    if (generation !== this.accountGeneration)
+      return;
     for (const runtime of this.sessions.values())
       runtime.session.account = account;
   }
@@ -26166,16 +26360,14 @@ class CodexAgent {
   }
   async setProvider(params) {
     this.requireInitialized("providers/set");
-    this.assertNoActiveTurns("providers/set");
-    this.providers.set(params);
-    await this.rebindSessions();
+    await this.changeProvider((candidate) => candidate.set(params));
     return {};
   }
   async disableProvider(params) {
     this.requireInitialized("providers/disable");
-    this.assertNoActiveTurns("providers/disable");
-    this.providers.disable(params);
-    await this.rebindSessions();
+    if (params.providerId !== OPENAI_PROVIDER_ID)
+      return {};
+    await this.changeProvider((candidate) => candidate.disable(params));
     return {};
   }
   assertNoActiveTurns(method) {
@@ -26184,57 +26376,173 @@ class CodexAgent {
       throw RequestError.invalidRequest({ sessions: busy }, `${method} cannot change routing while a turn is running; cancel it or wait for idle`);
     }
   }
-  async rebindSessions() {
-    const gateway = this.providers.active;
-    for (const runtime of this.sessions.values()) {
-      const { session } = runtime;
-      const config2 = buildThreadConfig(this.providers.threadConfig(), session.cwd, session.additionalDirectories, [], new Set);
-      const thread = await this.withCodex(() => this.codex.threadResume({
-        threadId: session.id,
-        cwd: session.cwd,
-        config: config2,
-        modelProvider: this.providers.modelProvider(),
-        excludeTurns: true
-      }));
-      const codexCatalog = await this.withCodex(() => this.codex.allModels());
-      session.catalog = this.providers.catalog(codexCatalog);
-      session.model = resolveModelSelection(session.catalog, gateway?.model ?? thread.model, thread.reasoningEffort);
-      await runtime.client.update({ sessionUpdate: "config_option_update", configOptions: sessionConfigOptions(session) });
-    }
+  assertRoutingAvailable() {
+    if (this.switching)
+      throw RequestError.invalidRequest(undefined, "Provider routing is changing; retry after providers/set or providers/disable finishes");
+  }
+  async admission(operation, sessionId) {
+    this.assertRoutingAvailable();
+    if (sessionId && this.sessionMutations.has(sessionId))
+      throw RequestError.invalidRequest({ sessionId }, "Session lifecycle or configuration work is in progress; retry when it finishes");
+    if (sessionId)
+      this.sessionMutations.add(sessionId);
+    this.admissions += 1;
+    try {
+      return await operation();
+    } finally {
+      this.admissions -= 1;
+      if (sessionId)
+        this.sessionMutations.delete(sessionId);
+    }
+  }
+  async changeProvider(change) {
+    const pending = this.providerQueue.then(async () => {
+      this.assertNoActiveTurns("providers/set or providers/disable");
+      if (this.admissions > 0)
+        throw RequestError.invalidRequest(undefined, "Session configuration or lifecycle work is in progress; retry the provider change when it finishes");
+      this.switching = true;
+      const candidate = this.providers.copy();
+      const attempted = [];
+      const staged = new Map;
+      try {
+        change(candidate);
+        const catalog = await this.withCodex(() => this.codex.allModels(true));
+        const modelProvider = await this.resolveModelProvider(candidate);
+        for (const runtime of this.sessions.values()) {
+          try {
+            await this.codex.threadTurnsList({ threadId: runtime.session.id, limit: 1, itemsView: "notLoaded" });
+          } catch (error40) {
+            throw RequestError.invalidRequest({ sessionId: runtime.session.id, details: errorMessage(error40) }, "Cannot reload this session's history for a provider change; close empty sessions and configure the provider before creating them, or retry after history is available");
+          }
+        }
+        for (const runtime of this.sessions.values()) {
+          const config2 = { ...runtime.config };
+          const providers = candidate.threadConfig()["model_providers"];
+          if (providers === undefined)
+            delete config2["model_providers"];
+          else
+            config2["model_providers"] = providers;
+          const nextCatalog = candidate.catalog(catalog);
+          const requestedModel = candidate.active?.model ?? (findModel(nextCatalog, runtime.session.model.model) ? runtime.session.model.model : null);
+          const selection = resolveModelSelection(nextCatalog, requestedModel, requestedModel === runtime.session.model.model ? runtime.session.model.effort : null);
+          attempted.push(runtime);
+          await this.codex.threadUnsubscribe({ threadId: runtime.session.id });
+          const thread = await this.withCodex(() => this.codex.threadResume({
+            threadId: runtime.session.id,
+            cwd: runtime.session.cwd,
+            config: config2,
+            modelProvider,
+            model: selection.model,
+            excludeTurns: true
+          }));
+          staged.set(runtime, { config: config2, catalog: nextCatalog, model: resolveModelSelection(nextCatalog, candidate.active?.model ?? thread.model, thread.reasoningEffort) });
+        }
+        this.providers = candidate;
+        for (const [runtime, next] of staged) {
+          runtime.config = next.config;
+          runtime.modelProvider = modelProvider;
+          runtime.session.catalog = next.catalog;
+          runtime.session.model = next.model;
+          runtime.stale = false;
+          runtime.client.update({ sessionUpdate: "config_option_update", configOptions: sessionConfigOptions(runtime.session), _meta: { codex: { routing: { stale: false } } } }).catch((error40) => logger.error("Provider config notification failed", error40));
+        }
+      } catch (error40) {
+        if (attempted.length === 0 && error40 instanceof RequestError)
+          throw error40;
+        const staleSessions = [];
+        for (const runtime of attempted) {
+          try {
+            await this.codex.threadUnsubscribe({ threadId: runtime.session.id });
+            await this.codex.threadResume({
+              threadId: runtime.session.id,
+              cwd: runtime.session.cwd,
+              config: runtime.config,
+              modelProvider: runtime.modelProvider,
+              model: runtime.session.model.model,
+              excludeTurns: true
+            });
+          } catch (rollbackError) {
+            runtime.stale = true;
+            staleSessions.push(runtime.session.id);
+            logger.error("Provider rollback failed", rollbackError, { sessionId: runtime.session.id });
+            runtime.client.update({ sessionUpdate: "config_option_update", configOptions: sessionConfigOptions(runtime.session), _meta: { codex: { routing: { stale: true } } } }).catch(() => {});
+          }
+        }
+        throw RequestError.internalError({ staleSessions, attemptedSessions: attempted.map((runtime) => runtime.session.id) }, `Provider change failed: ${errorMessage(error40)}${staleSessions.length ? "; resume affected sessions or retry the provider change before prompting" : "; previous routing restored"}`);
+      } finally {
+        this.switching = false;
+      }
+    });
+    this.providerQueue = pending.catch(() => {});
+    await pending;
   }
-  async newSession(params) {
-    const runtime = await this.openSession({ kind: "new", request: params });
+  async newSession(params, signal) {
+    const runtime = await this.openSession({ kind: "new", request: params }, signal);
     return { sessionId: runtime.session.id, configOptions: sessionConfigOptions(runtime.session) };
   }
-  async resumeSession(params) {
-    const runtime = await this.openSession({ kind: "resume", request: params });
+  async resumeSession(params, signal) {
+    const runtime = await this.openSession({ kind: "resume", request: params }, signal);
     return { configOptions: sessionConfigOptions(runtime.session) };
   }
-  async forkSession(params) {
-    const runtime = await this.openSession({ kind: "fork", request: params });
+  async forkSession(params, signal) {
+    const runtime = await this.openSession({ kind: "fork", request: params }, signal);
     return { sessionId: runtime.session.id, configOptions: sessionConfigOptions(runtime.session) };
   }
-  async openSession(open2) {
+  async openSession(open2, signal) {
+    if (signal?.aborted)
+      throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
+    const pending = this.admission(async () => {
+      const runtime = await this.openSessionInternal(open2, signal);
+      if (signal?.aborted) {
+        await this.closeRuntime(runtime.session.id);
+        throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
+      }
+      return runtime;
+    }, open2.kind === "new" ? undefined : open2.request.sessionId);
+    try {
+      return signal ? await abortable(pending, signal) : await pending;
+    } catch (error40) {
+      if (signal?.aborted)
+        throw RequestError.requestCancelled(undefined, "Session opening was cancelled; any thread returned later will be unsubscribed");
+      throw error40;
+    }
+  }
+  assertUnsubscribeSettled(sessionId) {
+    if (this.pendingUnsubscribes.has(sessionId)) {
+      throw RequestError.invalidRequest({ sessionId }, "A previous unsubscribe is still pending; retry after Codex responds or reconnect the agent");
+    }
+  }
+  async openSessionInternal(open2, signal) {
     const method = { new: "session/new", resume: "session/resume", fork: "session/fork" }[open2.kind];
     const capabilities = this.requireInitialized(method);
+    if (open2.kind !== "new")
+      this.assertUnsubscribeSettled(open2.request.sessionId);
     const { request } = open2;
     if (typeof request.cwd !== "string" || !path6.isAbsolute(request.cwd)) {
       throw RequestError.invalidParams({ cwd: request.cwd }, "cwd must be an absolute path");
     }
-    if (open2.kind !== "new" && this.sessions.has(open2.request.sessionId)) {
-      await this.closeRuntime(open2.request.sessionId);
+    if (open2.kind === "resume" && open2.request.replayFrom != null && open2.request.replayFrom.type !== "start") {
+      throw RequestError.invalidParams({ replayFrom: open2.request.replayFrom }, 'Only replayFrom {type: "start"} is supported');
     }
+    const seed = open2.kind === "new" ? seedHistoryOf(open2.request._meta) : [];
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories);
+    if (open2.kind === "resume" && this.sessions.has(open2.request.sessionId)) {
+      await this.closeRuntime(open2.request.sessionId);
+      this.assertUnsubscribeSettled(open2.request.sessionId);
+    }
     const mcpServers = request.mcpServers ?? [];
-    if (this.providers.active === null && await this.withCodex(() => authRequired(this.codex))) {
+    let accountVersion = this.accountGeneration;
+    const account = await this.withCodex(() => this.codex.accountRead({ refreshToken: false }));
+    if (this.providers.active === null && account.requiresOpenaiAuth && account.account === null) {
       throw RequestError.authRequired(undefined, "Log in to Codex first (auth/login)");
     }
-    await this.withCodex(() => this.refreshSkills(request.cwd, additionalDirectories));
     const existingMcp = mcpServers.length > 0 ? await this.withCodex(() => this.configuredMcpServerNames(request.cwd)) : new Set;
     const config2 = buildThreadConfig(this.providers.threadConfig(), request.cwd, additionalDirectories, mcpServers, existingMcp);
     const mcpStartupGeneration = this.codex.mcpStartupGeneration;
     const modelProvider = await this.withCodex(() => this.resolveModelProvider());
-    const thread = await this.withCodex(async () => {
+    const { thread, skills } = await this.withSkillsContext(request.cwd, additionalDirectories, async (skills2) => ({ skills: skills2, thread: await this.withCodex(async () => {
+      if (signal?.aborted)
+        throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
       switch (open2.kind) {
         case "new":
           return await this.codex.threadStart({ config: config2, cwd: request.cwd, modelProvider });
@@ -26243,13 +26551,32 @@ class CodexAgent {
         case "fork":
           return await this.codex.threadFork({ threadId: open2.request.sessionId, config: config2, cwd: request.cwd, modelProvider, excludeTurns: true });
       }
-    });
+    }) }));
     const sessionId = thread.thread.id;
+    let removeCancellation = () => {};
+    const openingCompletions = new Map;
+    const openingStarts = new Set;
+    const stopObservingOpen = this.codex.observeNotifications((notification) => {
+      if (notification.method === "turn/completed" && notification.params.threadId === sessionId) {
+        if (openingCompletions.size >= 32)
+          openingCompletions.delete(openingCompletions.keys().next().value);
+        openingCompletions.set(notification.params.turn.id, notification.params);
+      }
+      if (notification.method === "turn/started" && notification.params.threadId === sessionId && this.sessions.has(sessionId)) {
+        if (openingStarts.size >= 32)
+          openingStarts.delete(openingStarts.values().next().value);
+        openingStarts.add(notification.params.turn.id);
+      }
+    });
     try {
-      const [codexCatalog, account] = await this.withCodex(() => Promise.all([
-        this.codex.allModels(),
-        this.codex.accountRead({ refreshToken: false })
-      ]));
+      if (signal?.aborted)
+        throw RequestError.requestCancelled(undefined, "Session opening was cancelled");
+      const codexCatalog = await this.withCodex(() => this.codex.allModels());
+      let openedAccount = account.account;
+      while (accountVersion !== this.accountGeneration) {
+        accountVersion = this.accountGeneration;
+        openedAccount = (await this.withCodex(() => this.codex.accountRead({ refreshToken: false }))).account;
+      }
       const gateway = this.providers.active;
       const catalog = this.providers.catalog(codexCatalog);
       const model = resolveModelSelection(catalog, gateway?.model ?? thread.model, thread.reasoningEffort);
@@ -26257,13 +26584,13 @@ class CodexAgent {
         id: sessionId,
         cwd: request.cwd,
         additionalDirectories,
-        mcpServerNames: mcpServerNames(mcpServers),
+        mcpServerNames: mcpServerNames(mcpServers).filter((name) => !existingMcp.has(name)),
         catalog,
         model,
         mode: initialAgentMode(this.env),
         collaborationMode: DEFAULT_COLLABORATION_MODE,
         fastMode: thread.serviceTier === FAST_SERVICE_TIER,
-        account: account.account,
+        account: openedAccount,
         title: null,
         titleIsExplicit: false,
         activeTurn: null,
@@ -26271,40 +26598,66 @@ class CodexAgent {
         contextWindow: null,
         closed: false
       };
-      const runtime = this.installRuntime(session, capabilities);
+      const runtime = this.installRuntime(session, capabilities, config2, thread.modelProvider);
+      const cancelOpening = () => {
+        runtime.session.closed = true;
+        runtime.lifetime.abort();
+        runtime.client.dispose();
+      };
+      signal?.addEventListener("abort", cancelOpening, { once: true });
+      removeCancellation = () => signal?.removeEventListener("abort", cancelOpening);
+      if (signal?.aborted)
+        cancelOpening();
       const replay = open2.kind === "fork" || open2.kind === "resume" && open2.request.replayFrom?.type === "start";
-      if (open2.kind === "resume" && open2.request.replayFrom != null && open2.request.replayFrom.type !== "start") {
-        throw RequestError.invalidParams({ replayFrom: open2.request.replayFrom }, 'Only replayFrom {type: "start"} is supported');
-      }
       if (open2.kind !== "new") {
         await this.replayHistory(runtime, replay, thread.thread);
       } else {
-        const seed = seedHistoryOf(open2.request._meta);
         if (seed.length > 0) {
           await this.withCodex(() => this.codex.threadInjectItems({ threadId: sessionId, items: seed.map(seedItem) }));
         }
       }
+      if (thread.thread.status.type === "active" && runtime.session.activeTurn === null) {
+        const latest = await this.withCodex(() => this.codex.threadTurnsList({ threadId: session.id, limit: 1, sortDirection: "desc", itemsView: "full" }));
+        const active = latest.data.find((turn) => turn.status === "inProgress");
+        if (active && !(openingStarts.has(active.id) && openingCompletions.has(active.id))) {
+          const completed = openingCompletions.get(active.id);
+          this.observeForeignTurn(runtime, active.id, completed ? Promise.resolve(completed) : undefined, active.items);
+        }
+      }
       if (mcpServers.length > 0)
         this.reportMcpStartup(runtime, mcpStartupGeneration);
-      this.publishAvailableCommands(runtime);
+      this.publishAvailableCommands(runtime, skills);
       return runtime;
     } catch (error40) {
+      const runtime = this.sessions.get(sessionId);
+      if (runtime) {
+        runtime.session.closed = true;
+        runtime.lifetime.abort();
+        runtime.bridge.dispose();
+        runtime.client.dispose();
+      }
       this.sessions.delete(sessionId);
       this.codex.detachThread(sessionId);
-      await this.codex.threadUnsubscribe({ threadId: sessionId }).catch(() => {});
+      await within(this.unsubscribeThread(sessionId), this.closeGraceMs).catch(() => {});
       throw error40;
+    } finally {
+      removeCancellation();
+      stopObservingOpen();
     }
   }
-  installRuntime(session, capabilities) {
+  installRuntime(session, capabilities, config2, modelProvider) {
     const client = new ClientSession(session.id, this.link, capabilities);
     const bridge = new EventBridge(client, session);
     const turnContext = new TurnContext(session.id);
-    const signal = () => session.activeTurn?.abort.signal;
+    const signal = () => {
+      const turn = session.activeTurn;
+      return AbortSignal.any([this.codex.disconnectSignal, ...turn ? [turn.abort.signal, turn.stop.signal] : []]);
+    };
     const approval = new CodexApprovalHandler(client, turnContext, signal);
     const elicitation = new CodexElicitationHandler(client, turnContext, signal);
-    const runtime = { session, client, bridge, turnContext, elicitation, queue: Promise.resolve() };
+    const runtime = { config: config2, modelProvider, stale: false, session, client, bridge, turnContext, elicitation, lifetime: new AbortController, queue: Promise.resolve() };
     const drained = (operation) => async (params) => {
-      await this.drain(runtime);
+      await abortable(this.drain(runtime), this.codex.disconnectSignal);
       return await operation(params);
     };
     this.codex.attachThread(session.id, {
@@ -26323,7 +26676,23 @@ class CodexAgent {
     return runtime;
   }
   enqueue(runtime, notification) {
+    if (runtime.lifetime.signal.aborted)
+      return;
+    if (notification.method === "turn/started" && runtime.session.activeTurn === null) {
+      this.observeForeignTurn(runtime, notification.params.turn.id);
+    }
+    const turn = runtime.session.activeTurn;
+    if (notification.method.startsWith("item/") && "turnId" in notification.params && typeof notification.params.turnId === "string") {
+      if (!turn || turn.turnId !== null && notification.params.turnId !== turn.turnId)
+        return;
+    }
+    if (turn && notification.method === "turn/completed")
+      this.completedTurns.set(turn, notification.params.turn.id);
+    if (runtime.lifetime.signal.aborted)
+      return;
     const run = async () => {
+      if (runtime.lifetime.signal.aborted)
+        return;
       try {
         runtime.turnContext.observe(notification);
         await runtime.elicitation.observe(notification);
@@ -26334,11 +26703,21 @@ class CodexAgent {
     };
     runtime.queue = runtime.queue.then(run, run);
   }
+  observeForeignTurn(runtime, turnId, completion, items = []) {
+    if (runtime.session.activeTurn || runtime.session.closed)
+      return;
+    const turn = createActiveTurn(runtime.session.id);
+    runtime.session.activeTurn = turn;
+    this.turnStarted(runtime, turn, turnId, runtime.session.id);
+    runtime.client.reportRunning();
+    const completed = completion ?? this.codex.awaitTurnCompleted(runtime.session.id, turnId, turn.stop.signal);
+    this.runPrompt(runtime, turn, { sessionId: runtime.session.id, prompt: [] }, completed, items);
+  }
   async drain(runtime) {
     let current;
     do {
       current = runtime.queue;
-      await current;
+      await abortable(current, runtime.client.signal);
     } while (runtime.queue !== current);
   }
   async replayHistory(runtime, replay, thread) {
@@ -26361,12 +26740,18 @@ class CodexAgent {
       await publishTitle(firstPage.data);
       return;
     }
+    const cursors = new Set;
     let cursor = null;
     do {
       const page = await this.turnPage(session.id, cursor);
       await publishTitle(page.data);
       await client.updateAll(historyUpdates(page.data));
       cursor = page.nextCursor;
+      if (cursor !== null) {
+        if (cursors.has(cursor))
+          throw RequestError.internalError({ sessionId: session.id }, "Codex history pagination repeated a cursor; retry after restarting Codex");
+        cursors.add(cursor);
+      }
     } while (cursor !== null && !session.closed);
     await publishTitle([]);
   }
@@ -26376,7 +26761,7 @@ class CodexAgent {
   }
   async reportMcpStartup(runtime, afterGeneration) {
     try {
-      const result = await this.codex.awaitMcpStartup(runtime.session.mcpServerNames, afterGeneration);
+      const result = await this.codex.awaitMcpStartup(runtime.session.mcpServerNames, afterGeneration, runtime.lifetime.signal, runtime.session.id);
       if (runtime.session.closed)
         return;
       for (const failure of result.failed) {
@@ -26386,15 +26771,18 @@ class CodexAgent {
         await runtime.client.update(mcpStartupFailed(server, `MCP server "${server}" startup was cancelled.`));
       }
     } catch (error40) {
+      if (runtime.lifetime.signal.aborted)
+        return;
       logger.error("MCP startup reporting failed", error40, { sessionId: runtime.session.id });
     }
   }
-  async publishAvailableCommands(runtime) {
+  async publishAvailableCommands(runtime, snapshot) {
     try {
-      const skills = await this.codex.skillsList({ cwds: [runtime.session.cwd, ...runtime.session.additionalDirectories] });
+      const skills = snapshot ?? await this.codex.skillsList({ cwds: [runtime.session.cwd, ...runtime.session.additionalDirectories] });
       if (runtime.session.closed)
         return;
       await runtime.client.update({ sessionUpdate: "available_commands_update", availableCommands: availableCommands(skills.data) });
+      this.publishedSkills.set(runtime, skills);
     } catch (error40) {
       logger.error("publishing available commands failed", error40, { sessionId: runtime.session.id });
     }
@@ -26421,49 +26809,92 @@ class CodexAgent {
     };
   }
   async closeSession(params) {
+    return await this.admission(() => this.closeSessionInternal(params), params.sessionId);
+  }
+  async closeSessionInternal(params) {
     this.requireInitialized("session/close");
-    await this.closeRuntime(params.sessionId);
-    return {};
+    return await this.closeRuntime(params.sessionId);
   }
   async deleteSession(params) {
+    return await this.admission(() => this.deleteSessionInternal(params), params.sessionId);
+  }
+  async deleteSessionInternal(params) {
     this.requireInitialized("session/delete");
     await this.closeRuntime(params.sessionId);
     await this.withCodex(() => this.codex.threadDelete({ threadId: params.sessionId }));
     return {};
   }
   async archiveSession(params) {
+    return await this.admission(() => this.archiveSessionInternal(params), params.sessionId);
+  }
+  async archiveSessionInternal(params) {
     this.requireInitialized("_codex/session_archive");
     await this.closeRuntime(params.sessionId);
     await this.withCodex(() => this.codex.threadArchive({ threadId: params.sessionId }));
     return {};
   }
   async unarchiveSession(params) {
+    return await this.admission(() => this.unarchiveSessionInternal(params), params.sessionId);
+  }
+  async unarchiveSessionInternal(params) {
     this.requireInitialized("_codex/session_unarchive");
     await this.withCodex(() => this.codex.threadUnarchive({ threadId: params.sessionId }));
     return {};
   }
   async closeRuntime(sessionId) {
+    const deadline = performance.now() + this.closeGraceMs;
     const runtime = this.sessions.get(sessionId);
     if (!runtime)
-      return;
+      return {};
     runtime.session.closed = true;
+    runtime.lifetime.abort();
     const turn = runtime.session.activeTurn;
     if (turn) {
-      await this.interruptTurn(runtime, turn);
-      const timeout = new Promise((resolve) => setTimeout(() => resolve("timeout"), this.closeGraceMs).unref());
-      if (await Promise.race([turn.finished.then(() => "finished"), timeout]) === "timeout" && turn.turnId) {
-        this.codex.resolveTurnInterrupted(turn.threadId, turn.turnId);
-        await turn.finished;
+      this.interruptTurn(runtime, turn);
+      await within(turn.finished, Math.max(0, this.closeGraceMs / 2));
+      if (runtime.session.activeTurn === turn) {
+        await within(this.reportIdle(runtime, turn, "cancelled", { usage: usageOf(runtime.session) }), Math.max(0, (deadline - performance.now()) / 2)).catch(() => {});
       }
+      turn.stop.abort();
     }
-    this.sessions.delete(sessionId);
+    if (this.sessions.get(sessionId) === runtime)
+      this.sessions.delete(sessionId);
     this.codex.detachThread(sessionId);
+    runtime.client.dispose();
     runtime.bridge.dispose();
-    await this.codex.threadUnsubscribe({ threadId: sessionId }).catch((error40) => {
+    if (turn) {
+      turn.resolveStarted(null);
+      runtime.session.activeTurn = null;
+      turn.resolveFinished();
+    }
+    const unsubscribe = this.unsubscribeThread(sessionId);
+    let remoteUnsubscribe = "confirmed";
+    try {
+      if (!await within(unsubscribe, Math.max(0, deadline - performance.now()))) {
+        remoteUnsubscribe = "timed_out";
+      }
+    } catch (error40) {
+      remoteUnsubscribe = "failed";
       logger.error("thread/unsubscribe failed", error40, { sessionId });
-    });
+    }
+    if (remoteUnsubscribe !== "confirmed")
+      logger.log("session close detached locally", { sessionId, remoteUnsubscribe });
+    return { _meta: { codex: { close: { attempted: true, localDetached: true, remoteUnsubscribe } } } };
+  }
+  unsubscribeThread(sessionId) {
+    const unsubscribe = this.codex.threadUnsubscribe({ threadId: sessionId });
+    this.pendingUnsubscribes.set(sessionId, unsubscribe);
+    const release = () => {
+      if (this.pendingUnsubscribes.get(sessionId) === unsubscribe)
+        this.pendingUnsubscribes.delete(sessionId);
+    };
+    unsubscribe.then(release, release);
+    return unsubscribe;
   }
   async setSessionConfigOption(params) {
+    return await this.admission(() => this.setSessionConfigOptionInternal(params), params.sessionId);
+  }
+  async setSessionConfigOptionInternal(params) {
     const runtime = this.runtime(params.sessionId, "session/set_config_option");
     await this.withCodex(() => applyConfigOption(runtime.session, this.codex, params));
     const configOptions = sessionConfigOptions(runtime.session);
@@ -26473,23 +26904,28 @@ class CodexAgent {
   runtime(sessionId, method) {
     this.requireInitialized(method);
     const runtime = this.sessions.get(sessionId);
-    if (!runtime)
-      throw RequestError.invalidParams({ sessionId }, `Unknown session "${sessionId}"`);
+    if (!runtime || runtime.session.closed)
+      throw RequestError.invalidParams({ sessionId }, `Unknown session "${sessionId}" (missing or closed); create or resume it first`);
     return runtime;
   }
   async prompt(params) {
+    this.assertRoutingAvailable();
+    if (this.sessionMutations.has(params.sessionId))
+      throw RequestError.invalidRequest({ sessionId: params.sessionId }, "Session lifecycle or configuration work is in progress; retry when it finishes");
     const runtime = this.runtime(params.sessionId, "session/prompt");
+    if (runtime.stale)
+      throw RequestError.invalidRequest({ sessionId: params.sessionId, _meta: { codex: { routing: { stale: true } } } }, "Session routing is stale; resume the session or successfully change providers before prompting");
     const { session } = runtime;
     if (!Array.isArray(params.prompt) || params.prompt.length === 0) {
       throw RequestError.invalidParams(undefined, "prompt must contain at least one content block");
     }
-    if (session.activeTurn) {
-      return await this.steerActiveTurn(runtime, session.activeTurn, params);
-    }
     const model = findModel(session.catalog, session.model.model);
     if (!modelSupportsImages(model) && params.prompt.some((block) => block.type === "image")) {
       throw RequestError.invalidParams({ model: session.model.model }, "The current model does not support image input");
     }
+    if (session.activeTurn) {
+      return await this.steerActiveTurn(runtime, session.activeTurn, params);
+    }
     const turn = createActiveTurn(session.id);
     session.activeTurn = turn;
     runtime.client.reportRunning();
@@ -26505,71 +26941,55 @@ class CodexAgent {
       await this.codex.turnSteer({ threadId: runtime.session.id, expectedTurnId: turnId, input: toUserInput(params.prompt) });
       return { _meta: { codex: { steered: turnId } } };
     } catch (error40) {
+      if (this.completedTurns.get(turn) === turnId || runtime.session.activeTurn !== turn) {
+        await turn.finished;
+        return await this.prompt(params);
+      }
       throw RequestError.invalidRequest({ sessionId: params.sessionId, turnId }, `Could not steer the running turn: ${errorMessage(error40)}`);
     }
   }
-  async runPrompt(runtime, turn, params) {
-    const { session, client, bridge } = runtime;
+  async runPrompt(runtime, turn, params, observed, items = []) {
+    const { session, bridge } = runtime;
     bridge.beginTurn();
+    if (items.length)
+      runtime.queue = runtime.queue.then(() => bridge.restore(items));
     try {
       const command = parseCommand(params.prompt);
       const outcome = command ? resolveCommand(command, session) : { kind: "prompt" };
-      let completed = null;
-      switch (outcome.kind) {
-        case "prompt":
-          completed = await this.runCodexTurn(runtime, turn, params.prompt);
-          break;
-        case "message":
-          await client.update(agentMessage(`command:${command?.name}:${Date.now()}`, await this.commandText(runtime, command?.name ?? "", outcome.text)));
-          break;
-        case "config":
-          await this.setSessionConfigOption({ sessionId: session.id, configId: outcome.configId, type: "id", value: outcome.value });
-          break;
-        case "compact":
-          await this.runCompaction(runtime, turn);
-          break;
-        case "review":
-          completed = await this.withCodex(() => this.codex.runReview({ threadId: session.id, target: outcome.target, delivery: "inline" }, (turnId, threadId) => {
-            turn.turnId = turnId;
-            turn.threadId = threadId;
-            turn.resolveStarted(turnId);
-          }));
-          break;
-        case "logout":
-          await this.withCodex(() => logout(this.codex));
-          await this.refreshAccounts();
-          await client.update(agentMessage(`command:logout:${Date.now()}`, "Logged out of the Codex account."));
-          break;
-      }
+      let completed = await abortable(observed ?? this.executePrompt(runtime, turn, command, outcome, params), turn.stop.signal);
       await this.drain(runtime);
       await bridge.flush();
-      if (completed?.turn.status === "completed" && !turn.abort.signal.aborted) {
-        completed = await this.maybeImplementPlan(runtime, turn, completed);
+      if (completed?.turn.status === "completed" && !turn.abort.signal.aborted && !this.exitHandled) {
+        completed = await abortable(this.maybeImplementPlan(runtime, turn, completed), turn.stop.signal);
       }
       if (completed?.turn.status === "interrupted" || turn.abort.signal.aborted) {
-        await bridge.cancelOpenToolCalls();
-        await client.reportIdle("cancelled", { usage: usageOf(session) });
+        await this.reportIdle(runtime, turn, "cancelled", { usage: usageOf(session) });
         return;
       }
       if (completed?.turn.status === "failed") {
-        await this.reportTurnFailure(runtime, completed.turn.error ?? bridge.takeError() ?? { message: "Turn failed", codexErrorInfo: null, additionalDetails: null, misalignment: null });
+        await this.reportTurnFailure(runtime, turn, completed.turn.error ?? bridge.takeError() ?? { message: "Turn failed", codexErrorInfo: null, additionalDetails: null, misalignment: null });
         return;
       }
       const pendingError = bridge.takeError();
       if (pendingError) {
-        await this.reportTurnFailure(runtime, pendingError);
+        await this.reportTurnFailure(runtime, turn, pendingError);
         return;
       }
       await this.publishFallbackTitle(runtime, promptTitle(params.prompt));
-      await client.reportIdle("end_turn", { usage: usageOf(session) });
+      await this.reportIdle(runtime, turn, "end_turn", { usage: usageOf(session) });
     } catch (error40) {
+      if (this.terminalTurns.has(turn)) {
+        logger.error("Terminal update failed", error40, { sessionId: session.id });
+        return;
+      }
+      if (turn.stop.signal.aborted && session.closed)
+        return;
       if (turn.abort.signal.aborted || session.closed) {
-        await bridge.cancelOpenToolCalls().catch(() => {});
-        await client.reportIdle("cancelled", { usage: usageOf(session) }).catch(() => {});
+        await this.reportIdle(runtime, turn, "cancelled", { usage: usageOf(session) }).catch(() => {});
         return;
       }
       logger.error("prompt failed", error40, { sessionId: session.id });
-      await this.reportTurnFailure(runtime, { message: this.describeFailure(error40), codexErrorInfo: null, additionalDetails: null, misalignment: null }).catch(() => {});
+      await this.reportTurnFailure(runtime, turn, this.failureOf(error40)).catch(() => {});
     } finally {
       turn.resolveStarted(null);
       if (session.activeTurn === turn)
@@ -26577,49 +26997,106 @@ class CodexAgent {
       turn.resolveFinished();
     }
   }
+  async executePrompt(runtime, turn, command, outcome, params) {
+    const { session, client } = runtime;
+    let completed = null;
+    switch (outcome.kind) {
+      case "prompt":
+        completed = await this.runCodexTurn(runtime, turn, params.prompt);
+        break;
+      case "message":
+        await client.update(agentMessage(`command:${command?.name}:${Date.now()}`, await this.commandText(runtime, command?.name ?? "", outcome.text)));
+        break;
+      case "config":
+        await this.setSessionConfigOption({ sessionId: session.id, configId: outcome.configId, type: "id", value: outcome.value });
+        break;
+      case "compact":
+        await this.runCompaction(runtime, turn);
+        break;
+      case "review":
+        completed = await this.withCodex(() => this.codex.runReview({ threadId: session.id, target: outcome.target, delivery: "inline" }, (turnId, threadId) => {
+          this.turnStarted(runtime, turn, turnId, threadId);
+        }, turn.stop.signal));
+        break;
+      case "logout":
+        await this.withCodex(() => logout(this.codex));
+        await this.refreshAccounts();
+        await client.update(agentMessage(`command:logout:${Date.now()}`, "Logged out of the Codex account."));
+        break;
+    }
+    return completed;
+  }
   async runCodexTurn(runtime, turn, prompt) {
     const { session } = runtime;
     const model = findModel(session.catalog, session.model.model);
     const disableSummary = session.account?.type === "apiKey" || modelLacksReasoning(model);
-    await this.withCodex(() => this.refreshSkills(session.cwd, session.additionalDirectories));
-    if (turn.abort.signal.aborted) {
-      return interruptedTurn(session.id);
-    }
-    return await this.withCodex(() => this.codex.runTurn({
-      threadId: session.id,
-      input: toUserInput(prompt),
-      approvalPolicy: session.mode.approvalPolicy,
-      approvalsReviewer: session.mode.approvalsReviewer,
-      sandboxPolicy: withWritableRoots(session.mode.sandboxPolicy, session.additionalDirectories),
-      model: session.model.model,
-      effort: session.model.effort,
-      summary: disableSummary ? "none" : "auto",
-      serviceTier: session.fastMode ? FAST_SERVICE_TIER : null
-    }, (turnId) => {
-      turn.turnId = turnId;
-      turn.resolveStarted(turnId);
-    }));
+    let startSent = false;
+    const beforeStart = new AbortController;
+    const cancelBeforeStart = () => {
+      if (!startSent)
+        beforeStart.abort(turn.abort.signal.reason);
+    };
+    turn.abort.signal.addEventListener("abort", cancelBeforeStart, { once: true });
+    if (turn.abort.signal.aborted)
+      cancelBeforeStart();
+    try {
+      const result = await abortable(this.withSkillsContext(session.cwd, session.additionalDirectories, async (skills) => {
+        if (this.publishedSkills.get(runtime) !== skills)
+          this.publishAvailableCommands(runtime, skills);
+        if (turn.abort.signal.aborted || turn.stop.signal.aborted)
+          return { completed: Promise.resolve(interruptedTurn(session.id)) };
+        startSent = true;
+        const completed = this.withCodex(() => this.codex.runTurn({
+          threadId: session.id,
+          input: toUserInput(prompt),
+          approvalPolicy: session.mode.approvalPolicy,
+          approvalsReviewer: session.mode.approvalsReviewer,
+          sandboxPolicy: withWritableRoots(session.mode.sandboxPolicy, session.additionalDirectories),
+          model: session.model.model,
+          effort: session.model.effort,
+          summary: disableSummary ? "none" : "auto",
+          serviceTier: session.fastMode ? FAST_SERVICE_TIER : null
+        }, (turnId) => {
+          this.turnStarted(runtime, turn, turnId, session.id);
+        }, turn.stop.signal));
+        await Promise.race([turn.started, completed]);
+        return { completed };
+      }), beforeStart.signal);
+      return await result.completed;
+    } finally {
+      turn.abort.signal.removeEventListener("abort", cancelBeforeStart);
+    }
   }
   async runCompaction(runtime, turn) {
     const threadId = runtime.session.id;
+    turn.resolveStarted(null);
+    const pending = new AbortController;
+    const signal = AbortSignal.any([pending.signal, turn.abort.signal]);
     const completed = Promise.race([
-      this.codex.awaitNotification("item/completed", (params) => params.threadId === threadId && params.item.type === "contextCompaction"),
-      this.codex.awaitNotification("thread/compacted", (params) => params.threadId === threadId)
+      this.codex.awaitNotification("item/completed", (params) => params.threadId === threadId && params.item.type === "contextCompaction", signal),
+      this.codex.awaitNotification("thread/compacted", (params) => params.threadId === threadId, signal)
     ]);
-    await this.withCodex(() => this.codex.threadCompactStart({ threadId }));
-    turn.resolveStarted(null);
-    await completed;
+    completed.catch(() => {});
+    try {
+      signal.throwIfAborted();
+      await abortable(this.withCodex(() => this.codex.threadCompactStart({ threadId })), signal);
+      await completed;
+    } finally {
+      pending.abort();
+    }
   }
   async maybeImplementPlan(runtime, turn, completed) {
     const plan = runtime.bridge.takeCompletedPlan();
     if (!plan || runtime.session.collaborationMode !== PLAN_COLLABORATION_MODE)
       return completed;
-    const approved = await this.requestPlanApproval(runtime, plan, turn.abort.signal);
-    if (!approved || turn.abort.signal.aborted)
+    this.completedTurns.delete(turn);
+    const signal = AbortSignal.any([turn.abort.signal, turn.stop.signal]);
+    const approved = await this.requestPlanApproval(runtime, plan, signal);
+    if (!approved || signal.aborted)
       return completed;
     await this.setSessionConfigOption({ sessionId: runtime.session.id, configId: "collaboration_mode", type: "id", value: DEFAULT_COLLABORATION_MODE });
     runtime.bridge.beginTurn();
-    turn.turnId = null;
+    turn.resetStarted();
     const implementation = await this.runCodexTurn(runtime, turn, [{ type: "text", text: "Implement the approved plan." }]);
     await this.drain(runtime);
     await runtime.bridge.flush();
@@ -26627,13 +27104,12 @@ class CodexAgent {
   }
   async requestPlanApproval(runtime, plan, signal) {
     const toolCallId = `plan-review:${plan.itemId}`;
+    const toolCall = { toolCallId, name: ToolName.PlanReview, title: "Implement this plan?", kind: "switch_mode", status: "pending", rawInput: { plan: plan.text } };
     try {
+      await runtime.client.update({ sessionUpdate: "tool_call_update", ...toolCall });
       const response = await runtime.client.requestPermission({
         title: "Implement this plan?",
-        subject: {
-          type: "tool_call",
-          toolCall: { toolCallId, name: ToolName.PlanReview, title: "Implement this plan?", kind: "switch_mode", status: "pending", rawInput: { plan: plan.text } }
-        },
+        subject: { type: "tool_call", toolCall },
         options: [
           { optionId: IMPLEMENT_PLAN_OPTION, name: "Yes, implement this plan", kind: "allow_once" },
           { optionId: REVISE_PLAN_OPTION, name: "No, and tell Codex what to do differently", kind: "reject_once" }
@@ -26650,6 +27126,7 @@ class CodexAgent {
       return approved;
     } catch (error40) {
       logger.error("plan approval failed", error40, { sessionId: runtime.session.id });
+      await runtime.client.update({ sessionUpdate: "tool_call_update", toolCallId, status: signal.aborted ? "cancelled" : "failed" }).catch(() => {});
       return false;
     }
   }
@@ -26667,7 +27144,17 @@ class CodexAgent {
         return fallback;
     }
   }
-  async reportTurnFailure(runtime, error40) {
+  async reportIdle(runtime, turn, reason, extra) {
+    if (this.terminalTurns.has(turn))
+      return;
+    this.terminalTurns.add(turn);
+    await runtime.bridge.finishOpenToolCalls(reason === "cancelled" ? "cancelled" : reason === "end_turn" ? "completed" : "failed");
+    if (runtime.session.activeTurn === turn)
+      runtime.session.activeTurn = null;
+    await runtime.client.reportIdle(reason, extra);
+  }
+  async reportTurnFailure(runtime, turn, error40) {
+    const { stopReason, ...classification } = classifyTurnError(error40.codexErrorInfo);
     const message = error40.additionalDetails ? `${error40.message}
 
 ${error40.additionalDetails}` : error40.message;
@@ -26675,11 +27162,11 @@ ${error40.additionalDetails}` : error40.message;
       sessionUpdate: "agent_message_chunk",
       messageId: `codex-error:${runtime.session.id}:${Date.now()}`,
       content: { type: "text", text: message },
-      _meta: { codex: { error: { message: error40.message, codexErrorInfo: error40.codexErrorInfo, additionalDetails: error40.additionalDetails } } }
+      _meta: { codex: { error: { ...classification, message: error40.message, codexErrorInfo: error40.codexErrorInfo, additionalDetails: error40.additionalDetails } } }
     });
-    await runtime.client.reportIdle(ERROR_STOP_REASON, {
+    await this.reportIdle(runtime, turn, stopReason, {
       usage: usageOf(runtime.session),
-      _meta: { codex: { error: { message: error40.message, codexErrorInfo: error40.codexErrorInfo } } }
+      _meta: { codex: { error: { ...classification, message: error40.message, codexErrorInfo: error40.codexErrorInfo } } }
     });
   }
   async publishFallbackTitle(runtime, title) {
@@ -26701,19 +27188,77 @@ ${error40.additionalDetails}` : error40.message;
     const turnId = turn.turnId ?? await turn.started;
     if (turnId === null)
       return;
-    try {
-      await this.codex.turnInterrupt({ threadId: turn.threadId, turnId });
-    } catch (error40) {
-      logger.error("turn/interrupt failed", error40, { sessionId: runtime.session.id, turnId });
+    await this.sendInterrupt(runtime, turn, turnId);
+  }
+  sendInterrupt(runtime, turn, turnId) {
+    const key = `${turn.threadId}:${turnId}`;
+    let pending = turn.interrupts.get(key);
+    if (!pending) {
+      pending = this.codex.turnInterrupt({ threadId: turn.threadId, turnId }).then(() => {}, (error40) => {
+        turn.interrupts.delete(key);
+        logger.error("turn/interrupt failed", error40, { sessionId: runtime.session.id, turnId });
+      });
+      turn.interrupts.set(key, pending);
+    }
+    return pending;
+  }
+  turnStarted(runtime, turn, turnId, threadId) {
+    turn.turnId = turnId;
+    turn.threadId = threadId;
+    turn.resolveStarted(turnId);
+    if (turn.abort.signal.aborted)
+      this.sendInterrupt(runtime, turn, turnId);
+  }
+  withSkillsContext(cwd, additionalDirectories, operation) {
+    const run = async () => {
+      const roots = additionalDirectories.map((root) => path6.join(root, ".agents", "skills"));
+      if (roots.length !== this.skillRoots.length || roots.some((root, index) => root !== this.skillRoots[index])) {
+        this.changingSkillRoots = true;
+        try {
+          await this.codex.skillsExtraRootsSet({ extraRoots: roots });
+        } finally {
+          this.changingSkillRoots = false;
+        }
+        this.skillRoots = roots;
+        this.skillSnapshots.clear();
+      }
+      const skills = await this.loadSkills(cwd, additionalDirectories);
+      return await operation(skills);
+    };
+    const result = this.skillsQueue.then(run, run);
+    this.skillsQueue = result.then(() => {}, () => {});
+    return result;
+  }
+  async loadSkills(cwd, additionalDirectories) {
+    const key = JSON.stringify([cwd, ...additionalDirectories]);
+    let skills = this.skillSnapshots.get(key);
+    if (!skills) {
+      const generation = this.skillsGeneration;
+      skills = await this.withCodex(() => this.codex.skillsList({ cwds: [cwd, ...additionalDirectories], forceReload: true }));
+      if (generation === this.skillsGeneration) {
+        if (this.skillSnapshots.size >= 64)
+          this.skillSnapshots.delete(this.skillSnapshots.keys().next().value);
+        this.skillSnapshots.set(key, skills);
+      }
     }
+    return skills;
   }
-  async refreshSkills(cwd, additionalDirectories) {
-    const roots = additionalDirectories.map((root) => path6.join(root, ".agents", "skills"));
-    if (roots.length !== this.skillRoots.length || roots.some((root, index) => root !== this.skillRoots[index])) {
-      await this.codex.skillsExtraRootsSet({ extraRoots: roots });
-      this.skillRoots = roots;
+  async refreshAvailableCommands(runtime) {
+    const run = async () => {
+      const roots = runtime.session.additionalDirectories.map((root) => path6.join(root, ".agents", "skills"));
+      if (runtime.session.closed || roots.length !== this.skillRoots.length || roots.some((root, i) => root !== this.skillRoots[i]))
+        return;
+      return await this.loadSkills(runtime.session.cwd, runtime.session.additionalDirectories);
+    };
+    const pending = this.skillsQueue.then(run, run);
+    this.skillsQueue = pending.then(() => {}, () => {});
+    try {
+      const skills = await pending;
+      if (skills && !runtime.session.closed)
+        await this.publishAvailableCommands(runtime, skills);
+    } catch (error40) {
+      logger.error("refreshing available commands failed", error40, { sessionId: runtime.session.id });
     }
-    await this.codex.skillsList({ cwds: [cwd, ...additionalDirectories], forceReload: true });
   }
   async configuredMcpServerNames(cwd) {
     const response = await this.codex.configRead({ includeLayers: true, cwd });
@@ -26726,13 +27271,13 @@ ${error40.additionalDetails}` : error40.message;
     }
     return names;
   }
-  async resolveModelProvider() {
-    const routed = this.providers.modelProvider();
+  async resolveModelProvider(routing = this.providers) {
+    const routed = routing.modelProvider();
     if (routed)
       return routed;
     const config2 = await this.codex.configRead({ includeLayers: false });
     const provider = config2.config["model_provider"];
-    return typeof provider === "string" && provider.length > 0 ? provider : null;
+    return typeof provider === "string" && provider.length > 0 ? provider : OPENAI_PROVIDER_ID;
   }
   async withCodex(operation) {
     try {
@@ -26749,6 +27294,15 @@ ${stderr}` : ""}`);
       throw RequestError.internalError({ details: errorMessage(error40) }, errorMessage(error40));
     }
   }
+  failureOf(error40) {
+    const details = error40 instanceof Error ? error40.additionalDetails : undefined;
+    return {
+      message: this.describeFailure(error40),
+      codexErrorInfo: null,
+      additionalDetails: typeof details === "string" && details.length > 0 ? details : null,
+      misalignment: null
+    };
+  }
   describeFailure(error40) {
     if (error40 instanceof RequestError) {
       const details = error40.data?.details;
@@ -26763,14 +27317,16 @@ ${stderr}` : ""}`);
     this.exitHandled = true;
     for (const runtime of this.sessions.values()) {
       const turn = runtime.session.activeTurn;
-      if (!turn)
+      if (!turn || this.completedTurns.get(turn) === turn.turnId)
         continue;
+      const stderr = this.process?.recentStderr() || null;
+      turn.stop.abort(Object.assign(new Error("Connection to Codex was lost"), { additionalDetails: stderr }));
       turn.resolveStarted(null);
       if (turn.turnId) {
         this.codex.failTurn(turn.threadId, turn.turnId, {
           message: "Connection to Codex was lost",
           codexErrorInfo: null,
-          additionalDetails: this.process?.recentStderr() || null,
+          additionalDetails: stderr,
           misalignment: null
         });
       }
@@ -26825,6 +27381,19 @@ function seedItem(message) {
     content: [{ type: message.role === "user" ? "input_text" : "output_text", text: message.text }]
   };
 }
+async function within(operation, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      operation.then(() => true),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), ms);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 // src/agent/createAgent.ts
 function createAgentApp(options) {
@@ -26836,7 +27405,7 @@ function createAgentApp(options) {
   };
   return agent({ name: options.info.name }).onConnect((connection) => {
     agent2 = new CodexAgent(connection.client, options);
-  }).onRequest(methods.agent.initialize, (ctx) => current().initialize(ctx.params)).onRequest(methods.agent.auth.login, (ctx) => current().login(ctx.params, ctx.requestId)).onRequest(methods.agent.auth.logout, (ctx) => current().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => current().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => current().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => current().disableProvider(ctx.params)).onRequest(methods.agent.session.new, (ctx) => current().newSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => current().resumeSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => current().forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => current().listSessions(ctx.params)).onRequest(methods.agent.session.close, (ctx) => current().closeSession(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => current().deleteSession(ctx.params)).onRequest("_codex/session_archive", { parse: parseSessionIdParams }, (ctx) => current().archiveSession(ctx.params)).onRequest("_codex/session_unarchive", { parse: parseSessionIdParams }, (ctx) => current().unarchiveSession(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => current().setSessionConfigOption(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => current().prompt(ctx.params)).onNotification(methods.agent.session.cancel, (ctx) => current().cancel(ctx.params));
+  }).onRequest(methods.agent.initialize, (ctx) => current().initialize(ctx.params)).onRequest(methods.agent.auth.login, (ctx) => current().login(ctx.params, ctx.requestId)).onRequest(methods.agent.auth.logout, (ctx) => current().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => current().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => current().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => current().disableProvider(ctx.params)).onRequest(methods.agent.session.new, (ctx) => current().newSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.resume, (ctx) => current().resumeSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.fork, (ctx) => current().forkSession(ctx.params, ctx.signal)).onRequest(methods.agent.session.list, (ctx) => current().listSessions(ctx.params)).onRequest(methods.agent.session.close, (ctx) => current().closeSession(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => current().deleteSession(ctx.params)).onRequest("_codex/session_archive", { parse: parseSessionIdParams }, (ctx) => current().archiveSession(ctx.params)).onRequest("_codex/session_unarchive", { parse: parseSessionIdParams }, (ctx) => current().unarchiveSession(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => current().setSessionConfigOption(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => current().prompt(ctx.params)).onNotification(methods.agent.session.cancel, (ctx) => current().cancel(ctx.params));
 }
 
 // src/codex/AppServerClient.ts
@@ -26854,12 +27423,18 @@ class AppServerClient {
   elicitationHandlers = new Map;
   turnCompletionWaiters = new Map;
   earlyTurnCompletions = new Map;
+  startingThreads = new Map;
+  startingReviews = 0;
+  modelCatalog = null;
   mcpStartupStates = new Map;
   mcpStartupWaiters = [];
   notificationWaiters = [];
   mcpStartupVersion = 0;
+  disconnected = new AbortController;
   constructor(connection) {
     this.connection = connection;
+    connection.onClose(() => this.disconnected.abort(new Error("Connection to Codex was lost")));
+    connection.onDispose(() => this.disconnected.abort(new Error("Connection to Codex was lost")));
     connection.onUnhandledNotification((message) => {
       this.dispatchNotification(message);
     });
@@ -26884,6 +27459,9 @@ class AppServerClient {
       return handler ? await handler.handleUserInput(params) : { answers: {} };
     });
   }
+  get disconnectSignal() {
+    return this.disconnected.signal;
+  }
   attachThread(threadId, handlers) {
     this.threadHandlers.set(threadId, handlers.notification);
     this.approvalHandlers.set(threadId, handlers.approval);
@@ -26893,18 +27471,49 @@ class AppServerClient {
     this.threadHandlers.delete(threadId);
     this.approvalHandlers.delete(threadId);
     this.elicitationHandlers.delete(threadId);
+    for (const key of this.mcpStartupStates.keys()) {
+      if (key.startsWith(`${threadId}\x00`))
+        this.mcpStartupStates.delete(key);
+    }
   }
-  awaitNotification(method, predicate = () => true) {
+  awaitNotification(method, predicate = () => true, signal) {
+    let waiter;
     const settled = new Promise((resolve) => {
-      this.notificationWaiters.push({
+      waiter = {
         method,
         matches: (params) => predicate(params),
         resolve
-      });
+      };
+      this.notificationWaiters.push(waiter);
     });
-    return settled;
+    const result = abortable(settled, signal ? AbortSignal.any([signal, this.disconnected.signal]) : this.disconnected.signal).finally(() => {
+      const index = this.notificationWaiters.indexOf(waiter);
+      if (index >= 0)
+        this.notificationWaiters.splice(index, 1);
+    });
+    result.catch(() => {});
+    return result;
+  }
+  async withNotification(method, operation) {
+    const scope = new AbortController;
+    try {
+      return await operation(this.awaitNotification(method, () => true, scope.signal));
+    } finally {
+      scope.abort();
+    }
+  }
+  observers = new Set;
+  observeNotifications(handler) {
+    this.observers.add(handler);
+    return () => {
+      this.observers.delete(handler);
+    };
   }
   dispatchNotification(notification) {
+    if (notification.method === "account/updated")
+      this.modelCatalog = null;
+    for (const observer of this.observers)
+      observer(notification);
     if (this.notificationWaiters.length > 0) {
       const remaining = [];
       for (const waiter of this.notificationWaiters) {
@@ -26917,7 +27526,7 @@ class AppServerClient {
     }
     if (notification.method === "mcpServer/startupStatus/updated") {
       this.mcpStartupVersion += 1;
-      this.mcpStartupStates.set(notification.params.name, {
+      this.mcpStartupStates.set(mcpKey(notification.params.threadId, notification.params.name), {
         status: notification.params.status,
         error: notification.params.error,
         version: this.mcpStartupVersion
@@ -26936,25 +27545,62 @@ class AppServerClient {
       handler(notification);
     }
   }
-  async runTurn(params, onTurnStarted) {
-    const started = await this.turnStart(params);
-    onTurnStarted?.(started.turn.id);
-    return await this.awaitTurnCompleted(params.threadId, started.turn.id);
+  async runTurn(params, onTurnStarted, signal) {
+    this.startingThreads.set(params.threadId, (this.startingThreads.get(params.threadId) ?? 0) + 1);
+    let completed;
+    try {
+      const started = await this.turnStart(params);
+      onTurnStarted?.(started.turn.id);
+      completed = this.awaitTurnCompleted(params.threadId, started.turn.id, signal);
+    } finally {
+      const remaining = (this.startingThreads.get(params.threadId) ?? 1) - 1;
+      if (remaining === 0)
+        this.startingThreads.delete(params.threadId);
+      else
+        this.startingThreads.set(params.threadId, remaining);
+      this.pruneEarlyCompletions();
+    }
+    return await completed;
   }
-  async runReview(params, onTurnStarted) {
-    const started = await this.reviewStart(params);
-    onTurnStarted?.(started.turn.id, started.reviewThreadId);
-    return await this.awaitTurnCompleted(started.reviewThreadId, started.turn.id);
+  async runReview(params, onTurnStarted, signal) {
+    this.startingReviews += 1;
+    let completed;
+    try {
+      const started = await this.reviewStart(params);
+      onTurnStarted?.(started.turn.id, started.reviewThreadId);
+      completed = this.awaitTurnCompleted(started.reviewThreadId, started.turn.id, signal);
+    } finally {
+      this.startingReviews -= 1;
+      this.pruneEarlyCompletions();
+    }
+    return await completed;
   }
-  awaitTurnCompleted(threadId, turnId) {
+  awaitTurnCompleted(threadId, turnId, signal) {
     const key = turnKey(threadId, turnId);
     const early = this.earlyTurnCompletions.get(key);
     if (early) {
       this.earlyTurnCompletions.delete(key);
       return Promise.resolve(early);
     }
-    return new Promise((resolve) => {
-      this.turnCompletionWaiters.set(key, resolve);
+    const lifetime = signal ? AbortSignal.any([signal, this.disconnected.signal]) : this.disconnected.signal;
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        lifetime.removeEventListener("abort", aborted2);
+        this.turnCompletionWaiters.delete(key);
+      };
+      const aborted2 = () => {
+        cleanup();
+        reject(lifetime.reason);
+      };
+      if (lifetime.aborted) {
+        reject(lifetime.reason);
+        return;
+      }
+      lifetime.addEventListener("abort", aborted2, { once: true });
+      this.turnCompletionWaiters.set(key, (event) => {
+        cleanup();
+        resolve(event);
+      });
     });
   }
   resolveTurnInterrupted(threadId, turnId) {
@@ -26986,26 +27632,42 @@ class AppServerClient {
       waiter(event);
       return;
     }
-    this.earlyTurnCompletions.set(key, event);
+    if (this.startingThreads.has(event.threadId) || this.startingReviews > 0)
+      this.earlyTurnCompletions.set(key, event);
+  }
+  pruneEarlyCompletions() {
+    if (this.startingReviews > 0)
+      return;
+    for (const [key, event] of this.earlyTurnCompletions) {
+      if (!this.startingThreads.has(event.threadId))
+        this.earlyTurnCompletions.delete(key);
+    }
   }
   get mcpStartupGeneration() {
     return this.mcpStartupVersion;
   }
-  awaitMcpStartup(serverNames, afterVersion) {
+  awaitMcpStartup(serverNames, afterVersion, signal, threadId = null) {
     const names = [...new Set(serverNames.map((name) => name.trim()).filter((name) => name.length > 0))];
     if (names.length === 0)
       return Promise.resolve({ ready: [], failed: [], cancelled: [] });
-    const immediate = this.buildMcpStartupResult(names, afterVersion);
+    const immediate = this.buildMcpStartupResult(names, afterVersion, threadId);
     if (immediate)
       return Promise.resolve(immediate);
-    return new Promise((resolve) => {
-      this.mcpStartupWaiters.push({ serverNames: names, afterVersion, resolve });
+    let waiter;
+    const completed = new Promise((resolve) => {
+      waiter = { serverNames: names, afterVersion, threadId, resolve };
+      this.mcpStartupWaiters.push(waiter);
+    });
+    return abortable(completed, signal ? AbortSignal.any([signal, this.disconnected.signal]) : this.disconnected.signal).finally(() => {
+      const index = this.mcpStartupWaiters.indexOf(waiter);
+      if (index >= 0)
+        this.mcpStartupWaiters.splice(index, 1);
     });
   }
   settleMcpStartupWaiters() {
     const pending = [];
     for (const waiter of this.mcpStartupWaiters) {
-      const result = this.buildMcpStartupResult(waiter.serverNames, waiter.afterVersion);
+      const result = this.buildMcpStartupResult(waiter.serverNames, waiter.afterVersion, waiter.threadId);
       if (result)
         waiter.resolve(result);
       else
@@ -27013,10 +27675,12 @@ class AppServerClient {
     }
     this.mcpStartupWaiters.splice(0, this.mcpStartupWaiters.length, ...pending);
   }
-  buildMcpStartupResult(serverNames, afterVersion) {
+  buildMcpStartupResult(serverNames, afterVersion, threadId) {
     const result = { ready: [], failed: [], cancelled: [] };
     for (const name of serverNames) {
-      const state = this.mcpStartupStates.get(name);
+      const scoped = this.mcpStartupStates.get(mcpKey(threadId, name));
+      const global = this.mcpStartupStates.get(mcpKey(null, name));
+      const state = scoped && scoped.version > afterVersion ? scoped : global;
       if (!state || state.version <= afterVersion || state.status === "starting")
         return null;
       if (state.status === "ready")
@@ -27068,8 +27732,9 @@ class AppServerClient {
     return this.send({ method: "thread/compact/start", params });
   }
   async threadSettingsUpdate(params) {
+    this.disconnected.signal.throwIfAborted();
     logger.log("[codex request]", { method: "thread/settings/update" });
-    await this.connection.sendRequest("thread/settings/update", params);
+    await abortable(this.connection.sendRequest("thread/settings/update", params), this.disconnected.signal);
   }
   turnStart(params) {
     return this.send({ method: "turn/start", params });
@@ -27086,13 +27751,34 @@ class AppServerClient {
   modelList(params) {
     return this.send({ method: "model/list", params });
   }
-  async allModels() {
+  invalidateModels() {
+    this.modelCatalog = null;
+  }
+  allModels(refresh = false) {
+    if (!refresh && this.modelCatalog && this.modelCatalog.expires > performance.now())
+      return this.modelCatalog.pending;
+    const pending = this.loadModels();
+    const entry = { expires: performance.now() + 30000, pending };
+    this.modelCatalog = entry;
+    pending.catch(() => {
+      if (this.modelCatalog === entry)
+        this.modelCatalog = null;
+    });
+    return pending;
+  }
+  async loadModels() {
     const models = [];
+    const cursors = new Set;
     let cursor = null;
     do {
       const page = await this.modelList({ cursor, limit: null });
       models.push(...page.data);
       cursor = page.nextCursor;
+      if (cursor) {
+        if (cursors.has(cursor))
+          throw new Error("Codex model/list returned a repeated pagination cursor; retry after restarting Codex");
+        cursors.add(cursor);
+      }
     } while (cursor);
     return models;
   }
@@ -27121,23 +27807,279 @@ class AppServerClient {
     return this.send({ method: "mcpServerStatus/list", params });
   }
   async send(request) {
+    this.disconnected.signal.throwIfAborted();
     logger.log("[codex request]", { method: request.method });
     const params = "params" in request ? request.params : undefined;
-    return params === undefined ? await this.connection.sendRequest(request.method) : await this.connection.sendRequest(request.method, params);
+    return await abortable(params === undefined ? this.connection.sendRequest(request.method) : this.connection.sendRequest(request.method, params), this.disconnected.signal);
   }
 }
 function turnKey(threadId, turnId) {
   return `${threadId}\x00${turnId}`;
 }
+function mcpKey(threadId, name) {
+  return `${threadId ?? ""}\x00${name}`;
+}
 function threadIdOf(notification) {
   const params = notification.params;
   return params && typeof params.threadId === "string" ? params.threadId : null;
 }
 
 // src/codex/process.ts
+import { existsSync } from "fs";
+import path7 from "path";
 import { spawn, spawnSync } from "child_process";
 import { createRequire } from "module";
-var rpc = __toESM(require_main(), 1);
+
+// src/codex/transport.ts
+var import_node2 = __toESM(require_main(), 1);
+import { StringDecoder } from "string_decoder";
+function wireLog(value) {
+  return JSON.stringify(value, (key, nested) => {
+    const normalized = key.replace(/[_-]/g, "").toLowerCase();
+    if (/^(apikey|accesskey|accesstoken|refreshtoken|idtoken|secretaccesskey|sessiontoken|authorization|proxyauthorization|password|secret|token|cookie|setcookie|headers|httpheaders|env|queryparams)$/.test(normalized))
+      return "***";
+    return nested;
+  });
+}
+function createWriter(writable) {
+  const errors3 = new import_node2.Emitter;
+  const closed = new import_node2.Emitter;
+  const pending = new Set;
+  let ended = false;
+  const onError = (error40) => {
+    for (const reject of [...pending])
+      reject(error40);
+    errors3.fire([error40, undefined, undefined]);
+  };
+  const onClose = () => {
+    if (ended)
+      return;
+    ended = true;
+    for (const reject of [...pending])
+      reject(new Error("Codex input stream closed"));
+    closed.fire();
+  };
+  writable.on("error", onError);
+  writable.on("close", onClose);
+  writable.on("finish", onClose);
+  return {
+    write(message) {
+      if (ended || writable.destroyed || writable.writableEnded)
+        return Promise.reject(new Error("Codex input stream is closed"));
+      const { jsonrpc: _jsonrpc, ...frame2 } = message;
+      if (logger.enabled)
+        logger.log("[codex <-]", { line: wireLog(frame2) });
+      return new Promise((resolve, reject) => {
+        const fail = (error40) => {
+          pending.delete(fail);
+          reject(error40);
+        };
+        pending.add(fail);
+        try {
+          writable.write(`${JSON.stringify(frame2)}
+`, (error40) => {
+            pending.delete(fail);
+            if (error40)
+              reject(error40);
+            else
+              resolve();
+          });
+        } catch (error40) {
+          fail(error40 instanceof Error ? error40 : new Error(String(error40)));
+        }
+      });
+    },
+    end() {
+      writable.end();
+    },
+    onError: errors3.event,
+    onClose: closed.event,
+    dispose() {
+      onClose();
+      writable.off("error", onError);
+      writable.off("close", onClose);
+      writable.off("finish", onClose);
+      errors3.dispose();
+      closed.dispose();
+    }
+  };
+}
+function createReader(readable) {
+  const errors3 = new import_node2.Emitter;
+  const closed = new import_node2.Emitter;
+  const partial2 = new import_node2.Emitter;
+  const decoder = new StringDecoder("utf8");
+  let fragments = [];
+  let ended = false;
+  let callback = null;
+  const deliver = (line) => {
+    if (!line.trim())
+      return;
+    let message;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("Expected an object");
+      const frame2 = parsed;
+      if (frame2["jsonrpc"] === undefined)
+        frame2["jsonrpc"] = "2.0";
+      if (logger.enabled)
+        logger.log("[codex ->]", { line: wireLog(frame2) });
+      message = frame2;
+    } catch {
+      const error40 = new Error("Malformed JSON-RPC frame from Codex");
+      logger.error(error40.message, error40);
+      errors3.fire(error40);
+      return;
+    }
+    callback?.(message);
+  };
+  const onData = (chunk) => {
+    const text2 = typeof chunk === "string" ? chunk : decoder.write(chunk);
+    let offset = 0;
+    for (;; ) {
+      const newline2 = text2.indexOf(`
+`, offset);
+      if (newline2 < 0)
+        break;
+      const part = text2.slice(offset, newline2);
+      const line = fragments.length ? fragments.join("") + part : part;
+      fragments = [];
+      deliver(line);
+      offset = newline2 + 1;
+    }
+    if (offset < text2.length)
+      fragments.push(text2.slice(offset));
+  };
+  const onClose = () => {
+    if (ended)
+      return;
+    ended = true;
+    closed.fire();
+  };
+  const onEnd = () => {
+    fragments.push(decoder.end());
+    deliver(fragments.join(""));
+    fragments = [];
+    onClose();
+  };
+  const onError = (error40) => errors3.fire(error40);
+  const stop = () => {
+    readable.off("data", onData);
+    readable.off("end", onEnd);
+    readable.off("close", onClose);
+    readable.off("error", onError);
+    callback = null;
+    fragments = [];
+  };
+  return {
+    listen(receive) {
+      callback = receive;
+      readable.on("data", onData);
+      readable.on("end", onEnd);
+      readable.on("close", onClose);
+      readable.on("error", onError);
+      return { dispose: stop };
+    },
+    onError: errors3.event,
+    onClose: closed.event,
+    onPartialMessage: partial2.event,
+    dispose() {
+      stop();
+      errors3.dispose();
+      closed.dispose();
+      partial2.dispose();
+    }
+  };
+}
+function createCodexConnection(readable, writable) {
+  const reader = createReader(readable);
+  const writer = createWriter(writable);
+  const closed = new import_node2.Emitter;
+  let queued = 0;
+  let eof = false;
+  let finished = false;
+  let timer;
+  let resolveDrained;
+  const drained = new Promise((resolve) => {
+    resolveDrained = resolve;
+  });
+  const finish = () => {
+    if (finished)
+      return;
+    finished = true;
+    clearTimeout(timer);
+    closed.fire();
+    resolveDrained();
+  };
+  const check2 = () => {
+    if (eof && queued === 0)
+      setImmediate(() => {
+        if (queued === 0)
+          finish();
+      });
+  };
+  reader.onClose(() => {
+    eof = true;
+    timer ??= setTimeout(() => {
+      logger.error("Codex dispatch drain deadline exceeded", new Error(`Undispatched frames: ${queued}`));
+      finish();
+    }, 5000);
+    check2();
+  });
+  const inputFailed = () => {
+    if (finished || timer)
+      return;
+    timer = setTimeout(() => {
+      logger.error("Codex stdout did not close after stdin", new Error("Transport shutdown deadline exceeded"));
+      finish();
+    }, 5000);
+  };
+  writer.onClose(inputFailed);
+  const counted = (message) => !(("method" in message) && message.method === "$/cancelRequest");
+  const connection = import_node2.createMessageConnection({
+    ...reader,
+    onClose: closed.event,
+    listen(receive) {
+      return reader.listen((message) => {
+        if (counted(message))
+          queued += 1;
+        receive(message);
+      });
+    }
+  }, {
+    ...writer,
+    onClose: () => ({ dispose() {} }),
+    async write(message) {
+      try {
+        await writer.write(message);
+      } catch (error40) {
+        logger.error("Codex write failed; draining stdout before disconnect", error40);
+        inputFailed();
+        await drained;
+      }
+    }
+  }, undefined, {
+    messageStrategy: { handleMessage(message, next) {
+      try {
+        return next(message);
+      } finally {
+        if (counted(message))
+          queued -= 1;
+        check2();
+      }
+    } }
+  });
+  connection.onDispose(() => {
+    finished = true;
+    clearTimeout(timer);
+    resolveDrained();
+    closed.dispose();
+  });
+  return { connection, drained };
+}
+
+// src/codex/process.ts
 var STDERR_RETAIN_BYTES = 8 * 1024;
 var MINIMUM_CODEX_VERSION = package_default.optionalDependencies["@openai/codex"].replace(/^[\^~]/, "");
 function parseCodexVersion(output) {
@@ -27162,7 +28104,29 @@ function resolveCodexLauncher(codexPath) {
     return process.platform === "win32" ? { command: `"${codexPath}"`, prefixArgs: [], shell: true } : { command: codexPath, prefixArgs: [], shell: false };
   }
   try {
-    return { command: process.execPath, prefixArgs: [createRequire(import.meta.url).resolve("@openai/codex/bin/codex.js")], shell: false };
+    const require2 = createRequire(import.meta.url);
+    const launcher = require2.resolve("@openai/codex/bin/codex.js");
+    const platformRequire = createRequire(launcher);
+    const targets = {
+      "linux-x64": "x86_64-unknown-linux-musl",
+      "linux-arm64": "aarch64-unknown-linux-musl",
+      "darwin-x64": "x86_64-apple-darwin",
+      "darwin-arm64": "aarch64-apple-darwin",
+      "win32-x64": "x86_64-pc-windows-msvc",
+      "win32-arm64": "aarch64-pc-windows-msvc"
+    };
+    const platform2 = `${process.platform}-${process.arch}`;
+    const target = targets[platform2];
+    if (!target)
+      throw new Error(`Unsupported Codex platform: ${platform2}`);
+    let vendor = path7.resolve(path7.dirname(launcher), "..", "vendor");
+    try {
+      vendor = path7.join(path7.dirname(platformRequire.resolve(`@openai/codex-${platform2}/package.json`)), "vendor");
+    } catch {}
+    const command = path7.join(vendor, target, "bin", process.platform === "win32" ? "codex.exe" : "codex");
+    if (!existsSync(command))
+      throw new Error(`Missing Codex platform binary: ${command}`);
+    return { command, prefixArgs: [], shell: false };
   } catch (error40) {
     throw new Error("No Codex CLI: set CODEX_PATH to an installed Codex executable, or install the optional " + `@openai/codex dependency (${String(error40)})`);
   }
@@ -27179,11 +28143,13 @@ function startCodexProcess(codexPath, env = process.env) {
     stderr = (stderr + data.toString()).slice(-STDERR_RETAIN_BYTES);
     logger.log("[codex stderr]", { data: data.toString() });
   });
-  const connection = rpc.createMessageConnection(createReader(child.stdout), createWriter(child.stdin));
+  const { connection, drained } = createCodexConnection(child.stdout, child.stdin);
   connection.listen();
+  drained.then(() => connection.dispose());
   const exited = new Promise((resolve) => {
-    child.on("exit", (code, signal) => {
+    child.on("close", async (code, signal) => {
       logger.log("codex exited", { code, signal });
+      await drained;
       connection.dispose();
       resolve(code);
     });
@@ -27196,65 +28162,6 @@ function startCodexProcess(codexPath, env = process.env) {
     exitCode: () => child.exitCode
   };
 }
-function redactSecrets(line) {
-  return line.replace(/"(apiKey|accessToken|secretAccessKey|sessionToken)":"[^"]*"/g, '"$1":"***"');
-}
-function createWriter(writable) {
-  return {
-    async write(message) {
-      const { jsonrpc: _jsonrpc, ...frame2 } = message;
-      const line = JSON.stringify(frame2);
-      logger.log("[codex <-]", { line: redactSecrets(line) });
-      writable.write(`${line}
-`);
-    },
-    end() {
-      writable.end();
-    },
-    onError: new rpc.Emitter().event,
-    onClose: new rpc.Emitter().event,
-    dispose() {}
-  };
-}
-function createReader(readable) {
-  return {
-    listen(callback) {
-      let buffer = "";
-      const onData = (chunk) => {
-        buffer += chunk.toString();
-        for (;; ) {
-          const newline2 = buffer.indexOf(`
-`);
-          if (newline2 < 0)
-            break;
-          const line = buffer.slice(0, newline2).trim();
-          buffer = buffer.slice(newline2 + 1);
-          if (line.length === 0)
-            continue;
-          logger.log("[codex ->]", { line: redactSecrets(line) });
-          try {
-            const message = JSON.parse(line);
-            if (message["jsonrpc"] === undefined)
-              message["jsonrpc"] = "2.0";
-            callback(message);
-          } catch (error40) {
-            logger.error("Malformed JSON-RPC frame from codex", error40, { line });
-          }
-        }
-      };
-      readable.on("data", onData);
-      return {
-        dispose() {
-          readable.off("data", onData);
-        }
-      };
-    },
-    onError: new rpc.Emitter().event,
-    onClose: new rpc.Emitter().event,
-    onPartialMessage: new rpc.Emitter().event,
-    dispose() {}
-  };
-}
 
 // src/index.ts
 var CODEX_EXIT_GRACE_MS = 2000;