@agentclientprotocol/codex-acp 0.0.45 → 0.0.46

package/dist/index.js

@@ -17319,6 +17319,30 @@ function applyStructuredPatch(source, patch, options = {}) {
   return resultLines.join("\n");
 }
 
+// node_modules/diff/libesm/patch/reverse.js
+function reversePatch(structuredPatch) {
+  if (Array.isArray(structuredPatch)) {
+    return structuredPatch.map((patch) => reversePatch(patch)).reverse();
+  }
+  return Object.assign(Object.assign({}, structuredPatch), { oldFileName: structuredPatch.newFileName, oldHeader: structuredPatch.newHeader, newFileName: structuredPatch.oldFileName, newHeader: structuredPatch.oldHeader, hunks: structuredPatch.hunks.map((hunk) => {
+    return {
+      oldLines: hunk.newLines,
+      oldStart: hunk.newStart,
+      newLines: hunk.oldLines,
+      newStart: hunk.oldStart,
+      lines: hunk.lines.map((l) => {
+        if (l.startsWith("-")) {
+          return `+${l.slice(1)}`;
+        }
+        if (l.startsWith("+")) {
+          return `-${l.slice(1)}`;
+        }
+        return l;
+      })
+    };
+  }) });
+}
+
 // src/CodexToolCallMapper.ts
 import { readFile } from "node:fs/promises";
 import path2 from "node:path";
@@ -17521,80 +17545,93 @@ function createSearchTitle(query, path5) {
   return "Search";
 }
 async function createPatchContent(change) {
-  if (change.kind.type === "add" && !isUnifiedDiff(change.diff)) {
-    return {
-      type: "diff",
-      oldText: null,
-      newText: change.diff,
-      path: change.path,
-      _meta: {
-        kind: "add"
-      }
-    };
-  }
-  if (change.kind.type === "delete") {
-    const oldContent2 = await readFile(change.path, { encoding: "utf8" }).catch(
-      () => isUnifiedDiff(change.diff) ? patchToDeletedContent(change.diff) : change.diff
-    );
-    return {
-      type: "diff",
-      oldText: oldContent2,
-      newText: "",
-      path: change.path,
-      _meta: {
-        kind: "delete"
-      }
-    };
-  }
-  const oldContent = change.kind.type === "add" ? "" : await readFile(change.path, { encoding: "utf8" }).catch(() => null);
-  if (oldContent === null) {
-    return null;
-  }
-  const newContent = applyPatch(oldContent, change.diff);
-  if (newContent === false) {
+  try {
+    switch (change.kind.type) {
+      case "add":
+        return await createAddFileContent(change);
+      case "delete":
+        return await createDeleteFileContent(change);
+      case "update":
+        return await createUpdateFileContent(change);
+    }
+  } catch (error40) {
+    logger.log(`Error processing file update change: ${error40}`);
     return null;
   }
+}
+async function createAddFileContent(change) {
   return {
     type: "diff",
-    oldText: change.kind.type === "add" ? null : oldContent,
-    newText: newContent,
+    oldText: null,
+    newText: change.diff,
+    // app-server always returns file content instead of diff
     path: change.path,
     _meta: {
-      kind: change.kind.type
+      kind: "add"
     }
   };
 }
-function isUnifiedDiff(content) {
-  return content.startsWith("--- ") || content.includes("\n--- ");
-}
-function patchToDeletedContent(unifiedDiff) {
-  try {
-    const [patch] = parsePatch(unifiedDiff);
-    if (!patch || patch.hunks.length === 0) {
-      return null;
-    }
-    const oldLines = [];
-    let hasNoTrailingNewlineMarker = false;
-    for (const hunk of patch.hunks) {
-      for (const line of hunk.lines) {
-        if (line === "\") {
-          hasNoTrailingNewlineMarker = true;
-          continue;
-        }
-        if (line.startsWith("-") || line.startsWith(" ")) {
-          oldLines.push(line.slice(1));
+async function createUpdateFileContent(change) {
+  if (change.kind.type !== "update") return null;
+  const unifiedDiff = recoverCorruptedDiff(change.diff);
+  const movePath = change.kind.move_path;
+  const oldContent = await readFileContent(change.path);
+  if (oldContent !== null) {
+    const patchedContent = applyPatch(oldContent, unifiedDiff);
+    if (patchedContent === false) {
+      const revertedPatch2 = revertPatch(unifiedDiff);
+      if (revertedPatch2) {
+        const revertedContent2 = applyPatch(oldContent, revertedPatch2);
+        if (revertedContent2 !== false) {
+          return createUpdateDiffContent(change.path, revertedContent2, oldContent);
         }
       }
+      return null;
     }
-    if (oldLines.length === 0) {
-      return "";
-    }
-    const oldText = oldLines.join("\n");
-    return hasNoTrailingNewlineMarker || !unifiedDiff.endsWith("\n") ? oldText : `${oldText}
-`;
-  } catch {
-    return null;
+    return createUpdateDiffContent(movePath ?? change.path, oldContent, patchedContent);
   }
+  if (!movePath) return null;
+  const newContent = await readFileContent(movePath);
+  if (newContent === null) return null;
+  const revertedPatch = revertPatch(unifiedDiff);
+  if (!revertedPatch) return null;
+  const revertedContent = applyPatch(newContent, revertedPatch);
+  if (revertedContent === false) return null;
+  return createUpdateDiffContent(movePath, revertedContent, newContent);
+}
+function revertPatch(unifiedDiff) {
+  const [patch] = parsePatch(unifiedDiff);
+  if (!patch) return null;
+  return reversePatch(patch);
+}
+function createUpdateDiffContent(path5, oldText, newText) {
+  return {
+    type: "diff",
+    oldText,
+    newText,
+    path: path5,
+    _meta: {
+      kind: "update"
+    }
+  };
+}
+async function createDeleteFileContent(change) {
+  return {
+    type: "diff",
+    oldText: change.diff,
+    // app-server always returns file content instead of diff
+    newText: "",
+    path: change.path,
+    _meta: {
+      kind: "delete"
+    }
+  };
+}
+async function readFileContent(filePath) {
+  return await readFile(filePath, { encoding: "utf8" }).catch(() => null);
+}
+function recoverCorruptedDiff(diff) {
+  return diff.replace(/\n\nMoved to: .*$/, "");
 }
 
 // src/CodexEventHandler.ts
@@ -17725,6 +17762,9 @@ var CodexEventHandler = class {
       case "thread/goal/cleared":
       case "remoteControl/status/changed":
       case "app/list/updated":
+      case "thread/settings/updated":
+      case "process/outputDelta":
+      case "process/exited":
         return null;
     }
   }
@@ -18059,42 +18099,28 @@ var CodexApprovalHandler = class {
     }
   }
   buildCommandPermissionRequest(sessionId, params) {
-    const reasonContent = this.createContentFromReason(params.reason ?? null);
     return {
       sessionId,
       toolCall: {
         toolCallId: params.itemId,
         kind: "execute",
         status: "pending",
-        content: reasonContent ? [reasonContent] : null,
         rawInput: params.command ? { command: stripShellPrefix(params.command), cwd: params.cwd } : null
       },
-      options: APPROVAL_OPTIONS
-    };
-  }
-  createContentFromReason(reason) {
-    if (reason === null || reason === "") {
-      return null;
-    }
-    return {
-      type: "content",
-      content: {
-        type: "text",
-        text: reason
-      }
+      options: APPROVAL_OPTIONS,
+      _meta: { codex: { params } }
     };
   }
   buildFileChangePermissionRequest(sessionId, params) {
-    const reasonContent = this.createContentFromReason(params.reason ?? null);
     return {
       sessionId,
       toolCall: {
         toolCallId: params.itemId,
         kind: "edit",
-        status: "pending",
-        content: reasonContent ? [reasonContent] : null
+        status: "pending"
       },
-      options: APPROVAL_OPTIONS
+      options: APPROVAL_OPTIONS,
+      _meta: { codex: { params } }
     };
   }
   convertCommandResponse(response) {
@@ -19002,6 +19028,7 @@ var ModelId = class _ModelId {
 };
 
 // src/AgentMode.ts
+var MODE_CONFIG_ID = "mode";
 var AgentMode = class _AgentMode {
   id;
   name;
@@ -19064,6 +19091,21 @@ var AgentMode = class _AgentMode {
       currentModeId: this.id
     };
   }
+  toConfigOption() {
+    return {
+      id: MODE_CONFIG_ID,
+      name: "Mode",
+      description: "Approval and sandboxing preset for the session",
+      category: "mode",
+      type: "select",
+      currentValue: this.id,
+      options: _AgentMode.all().map((mode) => ({
+        value: mode.id,
+        name: mode.name,
+        description: mode.description
+      }))
+    };
+  }
   static all() {
     return [_AgentMode.ReadOnly, _AgentMode.Agent, _AgentMode.AgentFullAccess];
   }
@@ -19084,13 +19126,19 @@ var AgentMode = class _AgentMode {
 // src/CodexAcpClient.ts
 import path4 from "node:path";
 
+// src/McpServerName.ts
+var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
+function sanitizeMcpServerName(name) {
+  return name.replace(MCP_SERVER_NAME_WHITESPACE, "_");
+}
+
 // package.json
 var package_default = {
   name: "@agentclientprotocol/codex-acp",
   publishConfig: {
     access: "public"
   },
-  version: "0.0.45",
+  version: "0.0.46",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -19149,7 +19197,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^0.22.1",
-    "@openai/codex": "^0.128.0",
+    "@openai/codex": "^0.137.0",
     diff: "^8.0.3",
     open: "^11.0.0",
     "vscode-jsonrpc": "^8.2.1"
@@ -19164,6 +19212,7 @@ var CodexAcpClient = class {
   gatewayConfig;
   pendingLoginCompleted = null;
   pendingAccountUpdated = null;
+  sessionNotificationQueues = /* @__PURE__ */ new Map();
   constructor(codexClient, codexConfig, modelProvider) {
     this.codexClient = codexClient;
     this.config = codexConfig ?? {};
@@ -19289,7 +19338,7 @@ var CodexAcpClient = class {
   async getAccount() {
     return this.codexClient.accountRead({ refreshToken: false });
   }
-  async resumeSession(request) {
+  async resumeSession(request, onSubscribed) {
     await this.refreshSkills(request.cwd, request._meta);
     const response = await this.codexClient.threadResume({
       config: await this.createSessionConfig(request.cwd, request.mcpServers ?? []),
@@ -19297,6 +19346,7 @@ var CodexAcpClient = class {
       modelProvider: this.getResumeModelProvider(),
       threadId: request.sessionId
     });
+    onSubscribed?.();
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
@@ -19306,13 +19356,14 @@ var CodexAcpClient = class {
       currentServiceTier: response.serviceTier ?? null
     };
   }
-  async loadSession(request) {
+  async loadSession(request, onSubscribed) {
     const response = await this.codexClient.threadResume({
       config: await this.createSessionConfig(request.cwd, request.mcpServers ?? []),
       cwd: request.cwd,
       modelProvider: this.getResumeModelProvider(),
       threadId: request.sessionId
     });
+    onSubscribed?.();
     const codexModels = await this.fetchAvailableModels();
     const currentModelId = this.createModelId(codexModels, response.model, response.reasoningEffort).toString();
     return {
@@ -19342,6 +19393,13 @@ var CodexAcpClient = class {
       currentServiceTier: response.serviceTier ?? null
     };
   }
+  async closeSession(sessionId) {
+    try {
+      await this.codexClient.threadUnsubscribe({ threadId: sessionId });
+    } finally {
+      this.codexClient.clearThreadHandlers(sessionId);
+    }
+  }
   async awaitMcpServerStartup(serverNames, afterVersion) {
     return await this.codexClient.awaitMcpServerStartup(serverNames, afterVersion);
   }
@@ -19361,13 +19419,17 @@ var CodexAcpClient = class {
       return mergedConfig;
     }
     const existingNames = await this.getConfigMcpServerNames(projectPath);
-    const uniqueServers = mcpServers.filter((mcp) => !existingNames.has(mcp.name));
+    const requestedServers = mcpServers.map((mcp) => ({
+      name: sanitizeMcpServerName(mcp.name),
+      server: mcp
+    }));
+    const uniqueServers = requestedServers.filter((mcp) => !existingNames.has(mcp.name));
     if (uniqueServers.length === 0) {
       return mergedConfig;
     }
     return {
       ...mergedConfig,
-      "mcp_servers": Object.fromEntries(uniqueServers.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp)]))
+      "mcp_servers": Object.fromEntries(uniqueServers.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp.server)]))
     };
   }
   async getConfigMcpServerNames(projectPath) {
@@ -19388,14 +19450,13 @@ var CodexAcpClient = class {
     if (!cwd) {
       return;
     }
-    const additionalRoots = readAdditionalRoots(meta);
+    const additionalRoots = readAdditionalRoots(meta).map((root) => path4.join(root, ".agents", "skills"));
+    if (additionalRoots.length > 0) {
+      await this.codexClient.skillsExtraRootsSet({ extraRoots: additionalRoots });
+    }
     await this.codexClient.listSkills({
       cwds: [cwd],
-      forceReload: true,
-      perCwdExtraUserRoots: [{
-        cwd,
-        extraUserRoots: additionalRoots
-      }]
+      forceReload: true
     });
   }
   /**
@@ -19433,14 +19494,57 @@ var CodexAcpClient = class {
     return ModelId.create(selectedModel.id, reasoningEffort ?? selectedModel.defaultReasoningEffort);
   }
   async subscribeToSessionEvents(sessionId, eventHandler, approvalHandler, elicitationHandler) {
-    this.codexClient.onServerNotification(sessionId, eventHandler);
-    this.codexClient.onApprovalRequest(sessionId, approvalHandler);
-    this.codexClient.onElicitationRequest(sessionId, elicitationHandler);
+    this.codexClient.onServerNotification(sessionId, (event) => {
+      this.enqueueSessionNotification(sessionId, () => eventHandler(event));
+    });
+    this.codexClient.onApprovalRequest(sessionId, {
+      handleCommandExecution: async (params) => {
+        await this.waitForSessionNotifications(sessionId);
+        return await approvalHandler.handleCommandExecution(params);
+      },
+      handleFileChange: async (params) => {
+        await this.waitForSessionNotifications(sessionId);
+        return await approvalHandler.handleFileChange(params);
+      }
+    });
+    this.codexClient.onElicitationRequest(sessionId, {
+      handleElicitation: async (params) => {
+        await this.waitForSessionNotifications(sessionId);
+        return await elicitationHandler.handleElicitation(params);
+      }
+    });
+  }
+  async waitForSessionNotifications(sessionId) {
+    while (true) {
+      const queue = this.sessionNotificationQueues.get(sessionId);
+      if (!queue) return;
+      await queue;
+    }
+  }
+  enqueueSessionNotification(sessionId, operation) {
+    const run = async () => {
+      try {
+        await operation();
+      } catch (error40) {
+        logger.error("Error handling Codex session notification", error40);
+      }
+    };
+    const previous = this.sessionNotificationQueues.get(sessionId);
+    const next = previous ? previous.then(run, run) : run();
+    this.sessionNotificationQueues.set(sessionId, next);
+    void next.finally(() => {
+      if (this.sessionNotificationQueues.get(sessionId) === next) {
+        this.sessionNotificationQueues.delete(sessionId);
+      }
+    });
   }
-  async sendPrompt(request, agentMode, modelId, serviceTier, disableSummary, cwd) {
+  async sendPrompt(request, agentMode, modelId, serviceTier, disableSummary, cwd, onTurnStarted, shouldCancel) {
     const input = buildPromptItems(request.prompt);
     const effort = modelId.effort;
     await this.refreshSkills(cwd, request._meta);
+    if (shouldCancel?.()) {
+      return null;
+    }
     return await this.codexClient.runTurn({
       threadId: request.sessionId,
       input,
@@ -19450,7 +19554,13 @@ var CodexAcpClient = class {
       effort,
       model: modelId.model,
       serviceTier
-    });
+    }, onTurnStarted);
+  }
+  resolveTurnInterrupted(params) {
+    this.codexClient.resolveTurnInterrupted(params.threadId, params.turnId);
+  }
+  markTurnStale(params) {
+    this.codexClient.markTurnStale(params.threadId, params.turnId);
   }
   async listSkills(params) {
     return this.codexClient.listSkills(params ?? {});
@@ -19651,6 +19761,44 @@ function mergeGatewayConfig(config2, gatewayConfig) {
   }
 }
 
+// src/ModelConfigOption.ts
+var MODEL_CONFIG_ID = "model";
+var REASONING_EFFORT_CONFIG_ID = "reasoning_effort";
+function findSupportedEffort(options, effort) {
+  if (!effort) return void 0;
+  return options.find((o) => o.reasoningEffort === effort)?.reasoningEffort;
+}
+function createModelConfigOption(availableModels, currentBaseModelId) {
+  return {
+    id: MODEL_CONFIG_ID,
+    name: "Model",
+    description: "Model Codex uses for the session",
+    category: "model",
+    type: "select",
+    currentValue: currentBaseModelId,
+    options: availableModels.map((model) => ({
+      value: model.id,
+      name: model.displayName,
+      description: model.description
+    }))
+  };
+}
+function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEffort) {
+  return {
+    id: REASONING_EFFORT_CONFIG_ID,
+    name: "Reasoning effort",
+    description: "How much reasoning effort the model should use",
+    category: "thought_level",
+    type: "select",
+    currentValue: currentEffort,
+    options: supportedReasoningEfforts.map((option) => ({
+      value: option.reasoningEffort,
+      name: option.reasoningEffort,
+      description: option.description
+    }))
+  };
+}
+
 // src/CodexCommands.ts
 var CodexCommands = class {
   connection;
@@ -19736,6 +19884,7 @@ var CodexCommands = class {
   async tryHandleCommand(prompt, sessionState) {
     const commandName = this.getCommandName(prompt);
     if (commandName === null) return false;
+    if (commandName.startsWith("$")) return false;
     const sessionId = sessionState.sessionId;
     switch (commandName) {
       case "status": {
@@ -19980,6 +20129,17 @@ function createFastModeConfigOption(fastModeEnabled) {
   };
 }
 
+// src/JBUtils.ts
+function isJetBrains2026_1Client(clientInfo) {
+  if (!clientInfo) {
+    return false;
+  }
+  const platform2 = clientInfo._meta?.["platform"];
+  const isIntelliJPlatform = platform2 === "intellij";
+  const isJetBrainsClient = clientInfo.name.startsWith("JetBrains");
+  return (isIntelliJPlatform || isJetBrainsClient) && clientInfo.version.startsWith("2026.1");
+}
+
 // src/CodexAcpServer.ts
 var CodexAcpServer = class _CodexAcpServer {
   static MODEL_NAME_TOKEN_OVERRIDES = {
@@ -19992,15 +20152,27 @@ var CodexAcpServer = class _CodexAcpServer {
   defaultAuthRequest;
   getExitCode;
   availableCommands;
+  clientInfo;
   sessions;
   pendingMcpStartupSessions;
+  pendingTurnStarts;
+  activePrompts;
+  closingSessions;
+  sessionGenerations;
+  sessionOpenGenerations;
   constructor(connection, codexAcpClient, defaultAuthRequest, getExitCode) {
     this.sessions = /* @__PURE__ */ new Map();
     this.pendingMcpStartupSessions = /* @__PURE__ */ new Map();
+    this.pendingTurnStarts = /* @__PURE__ */ new Map();
+    this.activePrompts = /* @__PURE__ */ new Map();
+    this.closingSessions = /* @__PURE__ */ new Map();
+    this.sessionGenerations = /* @__PURE__ */ new Map();
+    this.sessionOpenGenerations = /* @__PURE__ */ new Map();
     this.connection = connection;
     this.codexAcpClient = codexAcpClient;
     this.defaultAuthRequest = defaultAuthRequest ?? null;
     this.getExitCode = getExitCode ?? (() => null);
+    this.clientInfo = null;
     this.availableCommands = new CodexCommands(
       connection,
       codexAcpClient,
@@ -20009,6 +20181,7 @@ var CodexAcpServer = class _CodexAcpServer {
   }
   async initialize(_params) {
     logger.log("Initialize request received");
+    this.clientInfo = _params.clientInfo ?? null;
     await this.runWithProcessCheck(() => this.codexAcpClient.initialize(_params));
     return {
       protocolVersion: PROTOCOL_VERSION,
@@ -20028,7 +20201,8 @@ var CodexAcpServer = class _CodexAcpServer {
         },
         sessionCapabilities: {
           resume: {},
-          list: {}
+          list: {},
+          close: {}
         },
         mcpCapabilities: {
           acp: false,
@@ -20086,26 +20260,107 @@ var CodexAcpServer = class _CodexAcpServer {
 You have been logged out. Please try again.`);
     }
   }
+  beginSessionOpen(sessionId) {
+    const generation = this.getSessionGeneration(sessionId);
+    if (this.sessionIsClosing(sessionId)) {
+      throw RequestError.invalidRequest(`Session ${sessionId} is closing`);
+    }
+    this.sessionOpenGenerations.set(sessionId, generation);
+    return generation;
+  }
+  sessionOpenCanInstall(sessionId, generation) {
+    return !this.sessionIsClosing(sessionId) && this.getSessionGeneration(sessionId) === generation;
+  }
+  async cleanupStaleSessionOpen(sessionId, generation) {
+    if (this.sessionOpenGenerations.get(sessionId) === generation) {
+      if (!this.sessionIsClosing(sessionId)) {
+        this.bumpSessionGeneration(sessionId);
+      }
+      this.beginSessionCloseFence(sessionId);
+      try {
+        await this.runWithProcessCheck(() => this.codexAcpClient.closeSession(sessionId));
+      } catch (err) {
+        logger.error(`Failed to close stale session open for ${sessionId}`, err);
+      } finally {
+        this.endSessionCloseFence(sessionId);
+      }
+      return true;
+    }
+    return false;
+  }
+  async closeStaleSessionOpen(sessionId, generation) {
+    await this.cleanupStaleSessionOpen(sessionId, generation);
+    throw RequestError.invalidRequest(`Session ${sessionId} is closing`);
+  }
+  sessionIsClosing(sessionId) {
+    return (this.closingSessions.get(sessionId) ?? 0) > 0;
+  }
+  beginSessionCloseFence(sessionId) {
+    this.closingSessions.set(sessionId, (this.closingSessions.get(sessionId) ?? 0) + 1);
+  }
+  endSessionCloseFence(sessionId) {
+    const count = this.closingSessions.get(sessionId) ?? 0;
+    if (count <= 1) {
+      this.closingSessions.delete(sessionId);
+      return;
+    }
+    this.closingSessions.set(sessionId, count - 1);
+  }
+  getSessionGeneration(sessionId) {
+    return this.sessionGenerations.get(sessionId) ?? 0;
+  }
+  bumpSessionGeneration(sessionId) {
+    const generation = this.getSessionGeneration(sessionId) + 1;
+    this.sessionGenerations.set(sessionId, generation);
+    return generation;
+  }
   async tryCreateSession(request) {
+    const requestedSessionGeneration = "sessionId" in request ? this.beginSessionOpen(request.sessionId) : null;
     await this.checkAuthorization();
     const requestedMcpServers = request.mcpServers ?? [];
     const mcpServerStartupVersion = requestedMcpServers.length > 0 ? this.codexAcpClient.getMcpServerStartupVersion() : null;
     let sessionMetadata;
+    let resumeSubscribed = false;
     if ("sessionId" in request) {
       logger.log(`Resume existing session: ${request.sessionId}...`);
-      sessionMetadata = await this.runWithProcessCheck(() => this.codexAcpClient.resumeSession(request));
+      try {
+        sessionMetadata = await this.runWithProcessCheck(
+          () => this.codexAcpClient.resumeSession(request, () => {
+            resumeSubscribed = true;
+          })
+        );
+      } catch (err) {
+        if (resumeSubscribed && requestedSessionGeneration !== null) {
+          await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
+        }
+        throw err;
+      }
     } else {
       logger.log(`Create new session...`);
       sessionMetadata = await this.runWithProcessCheck(() => this.codexAcpClient.newSession(request));
     }
-    const account = await this.getActiveAccount();
     const { sessionId, currentModelId, models } = sessionMetadata;
+    let account;
+    try {
+      account = await this.getActiveAccount();
+    } catch (err) {
+      if (resumeSubscribed && requestedSessionGeneration !== null) {
+        await this.cleanupStaleSessionOpen(sessionId, requestedSessionGeneration);
+      }
+      throw err;
+    }
+    const sessionGeneration = requestedSessionGeneration ?? this.beginSessionOpen(sessionId);
+    if (!this.sessionOpenCanInstall(sessionId, sessionGeneration)) {
+      resumeSubscribed = false;
+      await this.closeStaleSessionOpen(sessionId, sessionGeneration);
+    }
     const sessionMcpServers = this.resolveSessionMcpServers(requestedMcpServers, "sessionId" in request);
     const currentModel = this.findCurrentModel(models, currentModelId);
     const currentModelSupportsFast = modelSupportsFast(currentModel);
     const sessionState = {
       sessionId,
       currentModelId,
+      availableModels: models,
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
@@ -20121,9 +20376,10 @@ You have been logged out. Please try again.`);
       sessionMcpServers
     };
     this.sessions.set(sessionId, sessionState);
+    resumeSubscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
       this.pendingMcpStartupSessions.set(sessionId, {
-        requestedServers: new Set(requestedMcpServers.map((server) => server.name)),
+        requestedServers: new Set(getRequestedMcpServerNames(requestedMcpServers)),
         afterVersion: mcpServerStartupVersion
       });
       this.publishMcpStartupStatusAsync(sessionId);
@@ -20157,7 +20413,7 @@ You have been logged out. Please try again.`);
     return {
       models: modelState,
       modes: modeState,
-      configOptions: this.createSessionConfigOptions(this.getSessionState(sessionId))
+      ...this.createSessionConfigOptionsResponse(this.getSessionState(sessionId))
     };
   }
   async resumeSession(params) {
@@ -20171,7 +20427,7 @@ You have been logged out. Please try again.`);
     return {
       models: modelState,
       modes: modeState,
-      configOptions: this.createSessionConfigOptions(this.getSessionState(sessionId))
+      ...this.createSessionConfigOptionsResponse(this.getSessionState(sessionId))
     };
   }
   async listSessions(params) {
@@ -20179,6 +20435,35 @@ You have been logged out. Please try again.`);
     await this.checkAuthorization();
     return await this.runWithProcessCheck(() => this.codexAcpClient.listSessions(params));
   }
+  async closeSession(params) {
+    logger.log("Closing session...", { sessionId: params.sessionId });
+    const closeGeneration = this.bumpSessionGeneration(params.sessionId);
+    const sessionState = this.sessions.get(params.sessionId);
+    this.beginSessionCloseFence(params.sessionId);
+    try {
+      if (sessionState) {
+        await this.interruptSessionTurn(sessionState, "Close", true);
+      } else {
+        logger.log("Close request received for unknown local session", { sessionId: params.sessionId });
+      }
+      const activePrompt = this.activePrompts.get(params.sessionId);
+      if (activePrompt) {
+        activePrompt.requestClose();
+        await activePrompt.completion;
+      }
+      await this.runWithProcessCheck(() => this.codexAcpClient.closeSession(params.sessionId));
+      logger.log("Session closed", { sessionId: params.sessionId });
+    } finally {
+      if (this.getSessionGeneration(params.sessionId) === closeGeneration) {
+        this.sessions.delete(params.sessionId);
+        this.pendingMcpStartupSessions.delete(params.sessionId);
+        this.pendingTurnStarts.delete(params.sessionId);
+        this.activePrompts.delete(params.sessionId);
+      }
+      this.endSessionCloseFence(params.sessionId);
+    }
+    return {};
+  }
   async newSession(params) {
     logger.log("Starting new session...");
     const [sessionId, modelState, modeState] = await this.getOrCreateSession(params);
@@ -20191,7 +20476,7 @@ You have been logged out. Please try again.`);
       sessionId,
       models: modelState,
       modes: modeState,
-      configOptions: this.createSessionConfigOptions(this.getSessionState(sessionId))
+      ...this.createSessionConfigOptionsResponse(this.getSessionState(sessionId))
     };
   }
   async authenticate(_params) {
@@ -20216,11 +20501,7 @@ You have been logged out. Please try again.`);
     });
     const sessionState = this.sessions.get(_params.sessionId);
     if (!sessionState) throw new Error(`Session ${_params.sessionId} not found`);
-    const newMode = AgentMode.find(_params.modeId);
-    if (!newMode) {
-      throw RequestError.invalidParams();
-    }
-    sessionState.agentMode = newMode;
+    this.applyModeChange(sessionState, _params.modeId);
     return {};
   }
   async setSessionConfigOption(params) {
@@ -20230,17 +20511,66 @@ You have been logged out. Please try again.`);
     });
     const sessionState = this.sessions.get(params.sessionId);
     if (!sessionState) throw new Error(`Session ${params.sessionId} not found`);
-    if (params.configId !== FAST_MODE_CONFIG_ID || "type" in params && params.type === "boolean") {
+    if (typeof params.value !== "string") {
       throw RequestError.invalidParams();
     }
-    if (params.value !== FAST_MODE_ON && params.value !== FAST_MODE_OFF) {
-      throw RequestError.invalidParams();
+    const value = params.value;
+    switch (params.configId) {
+      case FAST_MODE_CONFIG_ID:
+        this.applyFastModeChange(sessionState, value);
+        break;
+      case MODE_CONFIG_ID:
+        this.applyModeChange(sessionState, value);
+        break;
+      case MODEL_CONFIG_ID:
+        this.applyModelChange(sessionState, value);
+        break;
+      case REASONING_EFFORT_CONFIG_ID:
+        this.applyReasoningEffortChange(sessionState, value);
+        break;
+      default:
+        throw RequestError.invalidParams();
     }
-    sessionState.fastModeEnabled = params.value === FAST_MODE_ON;
     return {
       configOptions: this.createSessionConfigOptions(sessionState)
     };
   }
+  applyFastModeChange(sessionState, value) {
+    if (value !== FAST_MODE_ON && value !== FAST_MODE_OFF) {
+      throw RequestError.invalidParams();
+    }
+    sessionState.fastModeEnabled = value === FAST_MODE_ON;
+  }
+  applyModeChange(sessionState, value) {
+    const newMode = AgentMode.find(value);
+    if (!newMode) {
+      throw RequestError.invalidParams();
+    }
+    sessionState.agentMode = newMode;
+  }
+  applyModelChange(sessionState, value) {
+    const model = sessionState.availableModels.find((m) => m.id === value);
+    if (!model) {
+      throw RequestError.invalidParams();
+    }
+    const currentEffort = ModelId.fromString(sessionState.currentModelId).effort;
+    const effort = findSupportedEffort(model.supportedReasoningEfforts, currentEffort) ?? model.defaultReasoningEffort;
+    this.applyModelAndEffort(sessionState, model, effort);
+  }
+  applyReasoningEffortChange(sessionState, value) {
+    const effort = findSupportedEffort(sessionState.supportedReasoningEfforts, value);
+    if (!effort) {
+      throw RequestError.invalidParams();
+    }
+    const { model } = ModelId.fromString(sessionState.currentModelId);
+    sessionState.currentModelId = ModelId.create(model, effort).toString();
+  }
+  applyModelAndEffort(sessionState, model, effort) {
+    sessionState.currentModelId = ModelId.fromComponents(model, effort).toString();
+    sessionState.supportedReasoningEfforts = model.supportedReasoningEfforts;
+    sessionState.supportedInputModalities = model.inputModalities;
+    sessionState.currentModelSupportsFast = modelSupportsFast(model);
+  }
   async unstable_setSessionModel(params) {
     logger.log("Set session model requested", {
       sessionId: params.sessionId,
@@ -20248,36 +20578,44 @@ You have been logged out. Please try again.`);
     });
     const sessionState = this.sessions.get(params.sessionId);
     if (!sessionState) throw new Error(`Session ${params.sessionId} not found`);
-    const requestedModelId = ModelId.fromString(params.modelId);
-    const requestedModelName = requestedModelId.model;
-    const requestedEffort = requestedModelId.effort;
+    const { model: requestedModelName, effort: requestedEffort } = ModelId.fromString(params.modelId);
     const models = await this.codexAcpClient.fetchAvailableModels();
     const model = models.find((m) => m.id === requestedModelName);
     if (!model) throw new Error(`Unknown model ${params.modelId}`);
-    const requestedEffortValue = requestedEffort;
     let reasoningEffort;
-    if (requestedEffortValue) {
-      const matchedEffort = model.supportedReasoningEfforts.find(
-        (option) => option.reasoningEffort === requestedEffortValue
-      )?.reasoningEffort;
+    if (requestedEffort) {
+      const matchedEffort = findSupportedEffort(model.supportedReasoningEfforts, requestedEffort);
       if (!matchedEffort) {
-        throw new Error(`Unsupported reasoning effort ${requestedEffortValue} for model ${requestedModelName}`);
+        throw new Error(`Unsupported reasoning effort ${requestedEffort} for model ${requestedModelName}`);
       }
       reasoningEffort = matchedEffort;
     } else {
       reasoningEffort = model.defaultReasoningEffort;
     }
-    sessionState.currentModelId = ModelId.fromComponents(model, reasoningEffort).toString();
-    sessionState.supportedReasoningEfforts = model.supportedReasoningEfforts;
-    sessionState.supportedInputModalities = model.inputModalities;
-    sessionState.currentModelSupportsFast = modelSupportsFast(model);
+    sessionState.availableModels = models;
+    this.applyModelAndEffort(sessionState, model, reasoningEffort);
     return {};
   }
   createSessionConfigOptions(sessionState) {
+    const currentModelId = ModelId.fromString(sessionState.currentModelId);
     return [
+      sessionState.agentMode.toConfigOption(),
+      createModelConfigOption(sessionState.availableModels, currentModelId.model),
+      createReasoningEffortConfigOption(sessionState.supportedReasoningEfforts, currentModelId.effort),
       createFastModeConfigOption(sessionState.fastModeEnabled)
     ];
   }
+  createSessionConfigOptionsResponse(sessionState) {
+    if (!this.isSessionConfigEnabled()) {
+      return {};
+    }
+    return {
+      configOptions: this.createSessionConfigOptions(sessionState)
+    };
+  }
+  isSessionConfigEnabled() {
+    return !isJetBrains2026_1Client(this.clientInfo);
+  }
   publishAvailableCommandsAsync(sessionId) {
     void this.availableCommands.publish(sessionId);
   }
@@ -20302,21 +20640,46 @@ You have been logged out. Please try again.`);
     };
   }
   async getOrCreateSessionWithHistory(request) {
+    const requestedSessionGeneration = this.beginSessionOpen(request.sessionId);
     await this.checkAuthorization();
     const requestedMcpServers = request.mcpServers ?? [];
     const mcpServerStartupVersion = requestedMcpServers.length > 0 ? this.codexAcpClient.getMcpServerStartupVersion() : null;
     logger.log(`Load existing session: ${request.sessionId}...`);
-    const sessionMetadata = await this.runWithProcessCheck(
-      () => this.codexAcpClient.loadSession(request)
-    );
-    const account = await this.getActiveAccount();
+    let subscribed = false;
+    let sessionMetadata;
+    try {
+      sessionMetadata = await this.runWithProcessCheck(
+        () => this.codexAcpClient.loadSession(request, () => {
+          subscribed = true;
+        })
+      );
+    } catch (err) {
+      if (subscribed) {
+        await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
+      }
+      throw err;
+    }
     const { sessionId, currentModelId, models, thread } = sessionMetadata;
+    let account;
+    try {
+      account = await this.getActiveAccount();
+    } catch (err) {
+      if (subscribed) {
+        await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
+      }
+      throw err;
+    }
+    if (!this.sessionOpenCanInstall(sessionId, requestedSessionGeneration)) {
+      subscribed = false;
+      await this.closeStaleSessionOpen(sessionId, requestedSessionGeneration);
+    }
     const sessionMcpServers = this.resolveSessionMcpServers(requestedMcpServers, true);
     const currentModel = this.findCurrentModel(models, currentModelId);
     const currentModelSupportsFast = modelSupportsFast(currentModel);
     const sessionState = {
       sessionId,
       currentModelId,
+      availableModels: models,
       supportedReasoningEfforts: currentModel?.supportedReasoningEfforts ?? [],
       supportedInputModalities: currentModel?.inputModalities ?? ["text", "image"],
       agentMode: AgentMode.getInitialAgentMode(),
@@ -20332,9 +20695,10 @@ You have been logged out. Please try again.`);
       sessionMcpServers
     };
     this.sessions.set(sessionId, sessionState);
+    subscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
       this.pendingMcpStartupSessions.set(sessionId, {
-        requestedServers: new Set(requestedMcpServers.map((server) => server.name)),
+        requestedServers: new Set(getRequestedMcpServerNames(requestedMcpServers)),
         afterVersion: mcpServerStartupVersion
       });
       this.publishMcpStartupStatusAsync(sessionId);
@@ -20580,11 +20944,16 @@ ${item.text}`
           pendingStartup.afterVersion
         )
       );
+      if (!this.sessions.has(sessionId) || this.sessionIsClosing(sessionId) || this.pendingMcpStartupSessions.get(sessionId) !== pendingStartup) {
+        return;
+      }
       await this.publishMcpStartupStatus(sessionId, mcpStartup, pendingStartup.requestedServers);
     } catch (err) {
       logger.error(`Failed to publish MCP startup status for session ${sessionId}`, err);
     } finally {
-      this.pendingMcpStartupSessions.delete(sessionId);
+      if (this.pendingMcpStartupSessions.get(sessionId) === pendingStartup) {
+        this.pendingMcpStartupSessions.delete(sessionId);
+      }
     }
   }
   async publishMcpStartupStatus(sessionId, mcpStartup, requestedServers) {
@@ -20600,6 +20969,125 @@ ${item.text}`
       });
     }
   }
+  trackActivePrompt(sessionId) {
+    let resolveCompletion = () => {
+    };
+    const completion = new Promise((resolve) => {
+      resolveCompletion = resolve;
+    });
+    let resolveCloseSignal = () => {
+    };
+    const closeSignal = new Promise((resolve) => {
+      resolveCloseSignal = resolve;
+    });
+    let completed = false;
+    let closeRequested = false;
+    const activePrompt = {
+      completion,
+      closeSignal,
+      requestClose: () => {
+        if (closeRequested) {
+          return;
+        }
+        closeRequested = true;
+        resolveCloseSignal(null);
+      },
+      complete: () => {
+        if (completed) {
+          return;
+        }
+        completed = true;
+        if (this.activePrompts.get(sessionId) === activePrompt) {
+          this.activePrompts.delete(sessionId);
+        }
+        resolveCompletion();
+      }
+    };
+    this.activePrompts.set(sessionId, activePrompt);
+    return activePrompt;
+  }
+  createPendingTurnStart() {
+    let resolve = () => {
+    };
+    const promise2 = new Promise((innerResolve) => {
+      resolve = innerResolve;
+    });
+    return { promise: promise2, resolve };
+  }
+  interruptLateStartedTurn(sessionId, turnId) {
+    this.codexAcpClient.markTurnStale({
+      threadId: sessionId,
+      turnId
+    });
+    void this.runWithProcessCheck(() => this.codexAcpClient.turnInterrupt({
+      threadId: sessionId,
+      turnId
+    })).catch((err) => {
+      logger.error(`Close - late turnInterrupt failed`, err);
+    }).finally(() => {
+      this.codexAcpClient.resolveTurnInterrupted({
+        threadId: sessionId,
+        turnId
+      });
+    });
+  }
+  promptIsClosedOrStale(sessionId, activePrompt) {
+    return this.activePrompts.get(sessionId) !== activePrompt || this.sessionIsClosing(sessionId);
+  }
+  async interruptSessionTurn(sessionState, requestName, resolveInterruptedTurn) {
+    const turnId = await this.getInterruptibleTurnId(sessionState, requestName);
+    if (!turnId) {
+      return;
+    }
+    logger.log(`${requestName} session requested`, {
+      sessionId: sessionState.sessionId,
+      currentTurnId: turnId
+    });
+    if (resolveInterruptedTurn) {
+      this.codexAcpClient.markTurnStale({
+        threadId: sessionState.sessionId,
+        turnId
+      });
+    }
+    try {
+      await this.runWithProcessCheck(() => this.codexAcpClient.turnInterrupt({
+        threadId: sessionState.sessionId,
+        turnId
+      }));
+      logger.log(`${requestName} - turnInterrupt succeeded`, {
+        sessionId: sessionState.sessionId,
+        currentTurnId: turnId
+      });
+    } catch (err) {
+      logger.error(`${requestName} - turnInterrupt failed`, err);
+    } finally {
+      if (resolveInterruptedTurn) {
+        this.codexAcpClient.resolveTurnInterrupted({
+          threadId: sessionState.sessionId,
+          turnId
+        });
+      }
+    }
+  }
+  async getInterruptibleTurnId(sessionState, requestName) {
+    if (sessionState.currentTurnId) {
+      return sessionState.currentTurnId;
+    }
+    const pendingTurnStart = this.pendingTurnStarts.get(sessionState.sessionId);
+    if (!pendingTurnStart) {
+      logger.log(`${requestName} request rejected: no current turn`, { sessionId: sessionState.sessionId });
+      return null;
+    }
+    if (requestName === "Close") {
+      pendingTurnStart.resolve(null);
+      return null;
+    }
+    const turnId = await pendingTurnStart.promise;
+    if (!turnId) {
+      logger.log(`${requestName} request rejected: no current turn`, { sessionId: sessionState.sessionId });
+    }
+    return turnId;
+  }
   async prompt(params) {
     logger.log("Prompt received", {
       sessionId: params.sessionId,
@@ -20608,6 +21096,8 @@ ${item.text}`
     const sessionState = this.getSessionState(params.sessionId);
     sessionState.currentTurnId = null;
     sessionState.lastTokenUsage = null;
+    const activePrompt = this.trackActivePrompt(params.sessionId);
+    let pendingTurnStart = null;
     try {
       const eventHandler = new CodexEventHandler(this.connection, sessionState);
       const approvalHandler = new CodexApprovalHandler(this.connection, sessionState);
@@ -20629,6 +21119,13 @@ ${item.text}`
           _meta: this.buildQuotaMeta(sessionState)
         };
       }
+      if (this.sessionIsClosing(params.sessionId)) {
+        return {
+          stopReason: "cancelled",
+          usage: this.buildPromptUsage(sessionState.lastTokenUsage),
+          _meta: this.buildQuotaMeta(sessionState)
+        };
+      }
       const modelId = ModelId.fromString(sessionState.currentModelId);
       const modelLacksReasoning = sessionState.supportedReasoningEfforts.length > 0 && sessionState.supportedReasoningEfforts.every((e) => e.reasoningEffort === "none");
       const disableSummary = sessionState.account?.type === "apiKey" || modelLacksReasoning;
@@ -20646,20 +21143,57 @@ ${item.text}`
         sessionState.fastModeEnabled,
         sessionState.currentModelSupportsFast
       );
-      const turnCompleted = await this.runWithProcessCheck(
-        () => this.codexAcpClient.sendPrompt(params, agentMode, modelId, serviceTier, disableSummary, sessionState.cwd)
+      pendingTurnStart = this.createPendingTurnStart();
+      this.pendingTurnStarts.set(params.sessionId, pendingTurnStart);
+      const sendPromptPromise = this.runWithProcessCheck(
+        () => this.codexAcpClient.sendPrompt(
+          params,
+          agentMode,
+          modelId,
+          serviceTier,
+          disableSummary,
+          sessionState.cwd,
+          (turnId) => {
+            if (this.promptIsClosedOrStale(params.sessionId, activePrompt)) {
+              this.interruptLateStartedTurn(params.sessionId, turnId);
+              return;
+            }
+            sessionState.currentTurnId = turnId;
+            pendingTurnStart?.resolve(turnId);
+          },
+          () => this.promptIsClosedOrStale(params.sessionId, activePrompt)
+        )
       );
+      void sendPromptPromise.catch((err) => {
+        if (this.activePrompts.get(params.sessionId) !== activePrompt) {
+          logger.error(`Prompt for closed session ${params.sessionId} failed after close`, err);
+        }
+      });
+      const turnCompleted = await Promise.race([
+        sendPromptPromise,
+        activePrompt.closeSignal
+      ]);
+      if (turnCompleted === null) {
+        return {
+          stopReason: "cancelled",
+          usage: this.buildPromptUsage(sessionState.lastTokenUsage),
+          _meta: this.buildQuotaMeta(sessionState)
+        };
+      }
+      await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
       if (turnCompleted.turn.status === "interrupted") {
-        await this.connection.sessionUpdate({
-          sessionId: params.sessionId,
-          update: {
-            sessionUpdate: "agent_message_chunk",
-            content: {
-              type: "text",
-              text: "*Conversation interrupted*"
+        if (!this.sessionIsClosing(params.sessionId) && this.sessions.has(params.sessionId)) {
+          await this.connection.sessionUpdate({
+            sessionId: params.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: {
+                type: "text",
+                text: "*Conversation interrupted*"
+              }
             }
-          }
-        });
+          });
+        }
         return {
           stopReason: "cancelled",
           usage: this.buildPromptUsage(sessionState.lastTokenUsage),
@@ -20681,6 +21215,11 @@ ${item.text}`
     } finally {
       logger.log("Prompt completed", { sessionId: params.sessionId });
       sessionState.currentTurnId = null;
+      if (pendingTurnStart !== null && this.pendingTurnStarts.get(params.sessionId) === pendingTurnStart) {
+        this.pendingTurnStarts.delete(params.sessionId);
+      }
+      pendingTurnStart?.resolve(null);
+      activePrompt.complete();
     }
   }
   buildQuotaMeta(sessionState) {
@@ -20721,30 +21260,11 @@ ${item.text}`
       logger.log("Cancel request rejected: session not found", { sessionId: params.sessionId });
       return;
     }
-    if (!sessionState.currentTurnId) {
-      logger.log("Cancel request rejected: no current turn", { sessionId: params.sessionId });
-      return;
-    }
-    logger.log("Cancel session requested", {
-      sessionId: params.sessionId,
-      currentTurnId: sessionState.currentTurnId
-    });
-    try {
-      await this.codexAcpClient.turnInterrupt({
-        threadId: params.sessionId,
-        turnId: sessionState.currentTurnId
-      });
-      logger.log("Cancel - turnInterrupt succeeded", {
-        sessionId: params.sessionId,
-        currentTurnId: sessionState.currentTurnId
-      });
-    } catch (err) {
-      logger.error(`Cancel - turnInterrupt failed`, err);
-    }
+    await this.interruptSessionTurn(sessionState, "Cancel", false);
   }
 };
 function getRequestedMcpServerNames(mcpServers) {
-  return Array.from(new Set(mcpServers.map((server) => server.name)));
+  return Array.from(new Set(mcpServers.map((server) => sanitizeMcpServerName(server.name))));
 }
 
 // src/CodexAppServerClient.ts
@@ -20761,6 +21281,7 @@ var CodexAppServerClient = class {
   mcpServerStartupResolvers = [];
   pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
   turnCompletionCaptures = /* @__PURE__ */ new Map();
+  staleTurnIds = /* @__PURE__ */ new Map();
   constructor(connection) {
     this.connection = connection;
     this.connection.onUnhandledNotification((data) => {
@@ -20777,12 +21298,26 @@ var CodexAppServerClient = class {
       if (isTurnCompletedNotification(serverNotification)) {
         this.recordTurnCompleted(serverNotification.params);
       }
+      const routing = extractTurnRouting(serverNotification);
+      const staleTurnNotification = this.isStaleTurn(routing.threadId, routing.turnId);
+      if (staleTurnNotification) {
+        if (isTurnCompletedNotification(serverNotification) && routing.threadId !== null && routing.turnId !== null) {
+          this.clearStaleTurn(routing.threadId, routing.turnId);
+        }
+        for (const callback of this.codexEventHandlers) {
+          callback({ eventType: "notification", ...serverNotification });
+        }
+        return;
+      }
       this.notify(serverNotification);
       for (const callback of this.codexEventHandlers) {
         callback({ eventType: "notification", ...serverNotification });
       }
     });
     this.connection.onRequest(CommandExecutionApprovalRequest, async (params) => {
+      if (this.isStaleTurn(params.threadId, params.turnId)) {
+        return { decision: "cancel" };
+      }
       const handler = this.approvalHandlers.get(params.threadId);
       if (!handler) {
         return { decision: "cancel" };
@@ -20790,6 +21325,9 @@ var CodexAppServerClient = class {
       return await handler.handleCommandExecution(params);
     });
     this.connection.onRequest(FileChangeApprovalRequest, async (params) => {
+      if (this.isStaleTurn(params.threadId, params.turnId)) {
+        return { decision: "cancel" };
+      }
       const handler = this.approvalHandlers.get(params.threadId);
       if (!handler) {
         return { decision: "cancel" };
@@ -20797,6 +21335,9 @@ var CodexAppServerClient = class {
       return await handler.handleFileChange(params);
     });
     this.connection.onRequest(McpServerElicitationRequest, async (params) => {
+      if (this.isStaleTurn(params.threadId, params.turnId)) {
+        return { action: "cancel", content: null, _meta: null };
+      }
       const handler = this.elicitationHandlers.get(params.threadId);
       if (!handler) {
         return { action: "cancel", content: null, _meta: null };
@@ -20810,19 +21351,25 @@ var CodexAppServerClient = class {
   onElicitationRequest(threadId, handler) {
     this.elicitationHandlers.set(threadId, handler);
   }
+  clearThreadHandlers(threadId) {
+    this.notificationHandlers.delete(threadId);
+    this.approvalHandlers.delete(threadId);
+    this.elicitationHandlers.delete(threadId);
+  }
   async initialize(params) {
     return await this.sendRequest({ method: "initialize", params });
   }
   async turnStart(params) {
     return await this.sendRequest({ method: "turn/start", params });
   }
-  async runTurn(params) {
+  async runTurn(params, onTurnStarted) {
     const capturedCompletions = [];
     const releaseCapture = this.captureTurnCompletions(params.threadId, (event) => {
       capturedCompletions.push(event);
     });
     try {
       const turnStarted = await this.turnStart(params);
+      onTurnStarted?.(turnStarted.turn.id);
       const earlyCompletion = capturedCompletions.find((event) => event.turn.id === turnStarted.turn.id);
       releaseCapture();
       if (earlyCompletion) {
@@ -20836,6 +21383,11 @@ var CodexAppServerClient = class {
   async turnInterrupt(params) {
     return await this.sendRequest({ method: "turn/interrupt", params });
   }
+  markTurnStale(threadId, turnId) {
+    const threadStaleTurns = this.staleTurnIds.get(threadId) ?? /* @__PURE__ */ new Set();
+    threadStaleTurns.add(turnId);
+    this.staleTurnIds.set(threadId, threadStaleTurns);
+  }
   async threadStart(params) {
     return await this.sendRequest({ method: "thread/start", params });
   }
@@ -20851,6 +21403,9 @@ var CodexAppServerClient = class {
   async threadRead(params) {
     return await this.sendRequest({ method: "thread/read", params });
   }
+  async threadUnsubscribe(params) {
+    return await this.sendRequest({ method: "thread/unsubscribe", params });
+  }
   async listMcpServerStatus(params) {
     return await this.sendRequest({ method: "mcpServerStatus/list", params });
   }
@@ -20893,9 +21448,27 @@ var CodexAppServerClient = class {
       threadResolvers.set(turnId, resolve);
     });
   }
+  resolveTurnInterrupted(threadId, turnId) {
+    this.recordTurnCompleted({
+      threadId,
+      turn: {
+        id: turnId,
+        items: [],
+        itemsView: "notLoaded",
+        status: "interrupted",
+        error: null,
+        startedAt: null,
+        completedAt: null,
+        durationMs: null
+      }
+    });
+  }
   async listModels(params) {
     return await this.sendRequest({ method: "model/list", params });
   }
+  async skillsExtraRootsSet(params) {
+    return await this.sendRequest({ method: "skills/extraRoots/set", params });
+  }
   async listSkills(params) {
     return await this.sendRequest({ method: "skills/list", params });
   }
@@ -20943,6 +21516,22 @@ var CodexAppServerClient = class {
       capture(event);
     }
   }
+  isStaleTurn(threadId, turnId) {
+    if (threadId === null || turnId === null) {
+      return false;
+    }
+    return this.staleTurnIds.get(threadId)?.has(turnId) ?? false;
+  }
+  clearStaleTurn(threadId, turnId) {
+    const threadStaleTurns = this.staleTurnIds.get(threadId);
+    if (!threadStaleTurns) {
+      return;
+    }
+    threadStaleTurns.delete(turnId);
+    if (threadStaleTurns.size === 0) {
+      this.staleTurnIds.delete(threadId);
+    }
+  }
   getOrCreatePendingTurnCompletionResolvers(threadId) {
     const existing = this.pendingTurnCompletionResolvers.get(threadId);
     if (existing) {
@@ -21037,6 +21626,17 @@ function extractThreadId(notification) {
   }
   return null;
 }
+function extractTurnRouting(notification) {
+  const params = notification.params;
+  const threadId = extractThreadId(notification);
+  if (params && typeof params.turnId === "string") {
+    return { threadId, turnId: params.turnId };
+  }
+  if (params && typeof params.turn?.id === "string") {
+    return { threadId, turnId: params.turn.id };
+  }
+  return { threadId, turnId: null };
+}
 
 // src/login.ts
 function parseArgs(args) {