@nyssance/codex-acp-v2 0.3.4 → 0.3.5

package/dist/index.js

@@ -21721,7 +21721,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.3.4",
+  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 [];
@@ -25551,10 +25691,6 @@ async function logout(codex) {
     await updated;
   });
 }
-async function authRequired(codex) {
-  const account = await codex.accountRead({ refreshToken: false });
-  return account.requiresOpenaiAuth && account.account === null;
-}
 
 // src/agent/clientSession.ts
 class ClientSession {
@@ -25565,6 +25701,11 @@ class ClientSession {
   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;
@@ -25573,38 +25714,46 @@ class ClientSession {
   async update(update) {
     if (this.disposed)
       return;
-    await this.link.notify(methods.client.session.update, { sessionId: this.sessionId, update });
+    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) {
-    signal?.throwIfAborted();
+    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) {
-    signal?.throwIfAborted();
+    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) {
     if (this.disposed)
       return;
-    await this.link.notify(methods.client.elicitation.complete, { elicitationId });
+    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({
@@ -25615,18 +25764,20 @@ class ClientSession {
       ...extra?._meta === undefined ? {} : { _meta: extra._meta }
     });
   }
-  async waitingOnClient(operation) {
+  async waitingOnClient(operation, signal) {
     if (this.disposed)
       throw new Error("Session is closed");
     const generation = this.turnActive ? this.turnGeneration : null;
-    if (generation !== null && this.waiting++ === 0) {
-      await this.state({ sessionUpdate: "state_update", state: "requires_action" });
-    }
     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 && generation === this.turnGeneration && --this.waiting === 0) {
-        await this.state({ sessionUpdate: "state_update", state: "running" });
+        const pending = this.state({ sessionUpdate: "state_update", state: "running" });
+        await (signal ? abortable(pending, signal).catch(() => {}) : pending);
       }
     }
   }
@@ -25639,6 +25790,7 @@ class ClientSession {
   }
   dispose() {
     this.disposed = true;
+    this.output.abort();
     this.turnActive = false;
     this.waiting = 0;
   }
@@ -25878,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;
@@ -25903,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";
@@ -25974,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;
   }
@@ -26137,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";
 
@@ -26146,6 +26245,11 @@ class CodexAgent {
   codex;
   process;
   providers;
+  switching = false;
+  admissions = 0;
+  pendingUnsubscribes = new Map;
+  sessionMutations = new Set;
+  providerQueue = Promise.resolve();
   info;
   env;
   closeGraceMs;
@@ -26153,7 +26257,15 @@ class CodexAgent {
   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;
@@ -26164,6 +26276,18 @@ 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) {
@@ -26222,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;
   }
@@ -26232,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) {
@@ -26250,39 +26376,147 @@ 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");
@@ -26294,17 +26528,21 @@ class CodexAgent {
     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 });
@@ -26313,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);
@@ -26333,7 +26590,7 @@ class CodexAgent {
         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,
@@ -26341,7 +26598,16 @@ 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 !== "new") {
         await this.replayHistory(runtime, replay, thread.thread);
@@ -26350,9 +26616,17 @@ class CodexAgent {
           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);
@@ -26364,23 +26638,26 @@ class CodexAgent {
       }
       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 = () => {
       const turn = session.activeTurn;
-      return turn ? AbortSignal.any([turn.abort.signal, turn.stop.signal]) : undefined;
+      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, lifetime: new AbortController, 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, {
@@ -26399,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);
@@ -26410,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) {
@@ -26437,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([]);
   }
@@ -26467,12 +26776,13 @@ class CodexAgent {
       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 });
     }
@@ -26499,58 +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) {
       this.interruptTurn(runtime, turn);
-      let timer;
-      const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve("timeout"), this.closeGraceMs);
-      });
-      try {
-        if (await Promise.race([turn.finished.then(() => "finished"), timeout]) === "timeout") {
-          turn.stop.abort();
-          await turn.finished;
-        }
-      } finally {
-        clearTimeout(timer);
+      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.bridge.dispose();
     runtime.client.dispose();
-    await this.codex.threadUnsubscribe({ threadId: sessionId }).catch((error40) => {
+    runtime.bridge.dispose();
+    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);
@@ -26565,7 +26909,12 @@ class CodexAgent {
     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");
@@ -26592,23 +26941,28 @@ 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) {
+  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 = await abortable(this.executePrompt(runtime, turn, command, outcome, params), turn.stop.signal);
+      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) {
+      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 this.reportIdle(runtime, turn, "cancelled", { usage: usageOf(session) });
         return;
       }
@@ -26624,8 +26978,13 @@ class CodexAgent {
       await this.publishFallbackTitle(runtime, promptTitle(params.prompt));
       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 this.reportIdle(runtime, turn, "cancelled", { usage: usageOf(session) }).catch(() => {});
         return;
       }
@@ -26671,23 +27030,42 @@ class CodexAgent {
     const { session } = runtime;
     const model = findModel(session.catalog, session.model.model);
     const disableSummary = session.account?.type === "apiKey" || modelLacksReasoning(model);
-    await abortable(this.withCodex(() => this.refreshSkills(session.cwd, session.additionalDirectories)), turn.abort.signal);
-    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) => {
-      this.turnStarted(runtime, turn, turnId, session.id);
-    }, turn.stop.signal));
+    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;
@@ -26711,6 +27089,7 @@ class CodexAgent {
     const plan = runtime.bridge.takeCompletedPlan();
     if (!plan || runtime.session.collaborationMode !== PLAN_COLLABORATION_MODE)
       return completed;
+    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)
@@ -26766,11 +27145,16 @@ class CodexAgent {
     }
   }
   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;
@@ -26778,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 this.reportIdle(runtime, turn, 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) {
@@ -26811,6 +27195,7 @@ ${error40.additionalDetails}` : error40.message;
     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);
@@ -26824,13 +27209,56 @@ ${error40.additionalDetails}` : error40.message;
     if (turn.abort.signal.aborted)
       this.sendInterrupt(runtime, turn, turnId);
   }
-  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;
+  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 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 });
@@ -26843,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 {
@@ -26889,7 +27317,7 @@ ${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 }));
@@ -26953,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) {
@@ -26964,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
@@ -26984,6 +27425,7 @@ class AppServerClient {
   earlyTurnCompletions = new Map;
   startingThreads = new Map;
   startingReviews = 0;
+  modelCatalog = null;
   mcpStartupStates = new Map;
   mcpStartupWaiters = [];
   notificationWaiters = [];
@@ -27017,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);
@@ -27057,7 +27502,18 @@ class AppServerClient {
       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) {
@@ -27126,10 +27582,26 @@ class AppServerClient {
       this.earlyTurnCompletions.delete(key);
       return Promise.resolve(early);
     }
-    const completed = 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);
+      });
     });
-    return abortable(completed, signal ? AbortSignal.any([signal, this.disconnected.signal]) : this.disconnected.signal).finally(() => this.turnCompletionWaiters.delete(key));
   }
   resolveTurnInterrupted(threadId, turnId) {
     this.recordTurnCompleted({
@@ -27279,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;
   }
@@ -27332,9 +27825,10 @@ function threadIdOf(notification) {
 }
 
 // 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);
@@ -27342,7 +27836,7 @@ 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)$/.test(normalized))
+    if (/^(apikey|accesskey|accesstoken|refreshtoken|idtoken|secretaccesskey|sessiontoken|authorization|proxyauthorization|password|secret|token|cookie|setcookie|headers|httpheaders|env|queryparams)$/.test(normalized))
       return "***";
     return nested;
   });
@@ -27415,7 +27909,7 @@ function createReader(readable) {
   const closed = new import_node2.Emitter;
   const partial2 = new import_node2.Emitter;
   const decoder = new StringDecoder("utf8");
-  let buffer = "";
+  let fragments = [];
   let ended = false;
   let callback = null;
   const deliver = (line) => {
@@ -27441,16 +27935,21 @@ function createReader(readable) {
     callback?.(message);
   };
   const onData = (chunk) => {
-    buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+    const text2 = typeof chunk === "string" ? chunk : decoder.write(chunk);
+    let offset = 0;
     for (;; ) {
-      const newline2 = buffer.indexOf(`
-`);
+      const newline2 = text2.indexOf(`
+`, offset);
       if (newline2 < 0)
         break;
-      const line = buffer.slice(0, newline2);
-      buffer = buffer.slice(newline2 + 1);
+      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)
@@ -27459,9 +27958,9 @@ function createReader(readable) {
     closed.fire();
   };
   const onEnd = () => {
-    buffer += decoder.end();
-    deliver(buffer);
-    buffer = "";
+    fragments.push(decoder.end());
+    deliver(fragments.join(""));
+    fragments = [];
     onClose();
   };
   const onError = (error40) => errors3.fire(error40);
@@ -27471,7 +27970,7 @@ function createReader(readable) {
     readable.off("close", onClose);
     readable.off("error", onError);
     callback = null;
-    buffer = "";
+    fragments = [];
   };
   return {
     listen(receive) {
@@ -27493,6 +27992,92 @@ function createReader(readable) {
     }
   };
 }
+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;
@@ -27519,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)})`);
   }
@@ -27536,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);
     });