@agentclientprotocol/codex-acp 2.1.1 → 2.1.2-preview.2

package/dist/index.js

@@ -27132,7 +27132,7 @@ import { createRequire } from "node:module";
 // src/StdUtils.ts
 var import_node = __toESM(require_main(), 1);
 import { StringDecoder } from "node:string_decoder";
-import { Readable, Writable } from "node:stream";
+import { finished, Readable } from "node:stream";
 
 // src/Logger.ts
 import fs from "node:fs";
@@ -27264,9 +27264,37 @@ function createJSONRPCReader(readable) {
   };
 }
 function createJsonStream(readable, writable) {
-  const input2 = Writable.toWeb(writable);
-  const output2 = Readable.toWeb(readable);
-  return ndJsonStream2(input2, output2);
+  const writeLine = createLineWriter(writable);
+  const errorReplies = new WritableStream({ write: (chunk) => writeLine(chunk) });
+  const input2 = Readable.toWeb(readable);
+  const stream = ndJsonStream2(errorReplies, input2);
+  const messages = new WritableStream({
+    write: (message) => writeLine(JSON.stringify(message) + "\n")
+  });
+  return { readable: stream.readable, writable: messages };
+}
+function createLineWriter(writable) {
+  let failure3;
+  const waiting = /* @__PURE__ */ new Set();
+  const stopWatching = finished(writable, (error62) => {
+    stopWatching();
+    writable.on("error", () => {
+    });
+    writable.off("drain", onDrain);
+    failure3 = error62 ?? new Error("The output stream ended");
+    for (const waiter of waiting) waiter.reject(failure3);
+    waiting.clear();
+  });
+  const onDrain = () => {
+    for (const waiter of waiting) waiter.resolve();
+    waiting.clear();
+  };
+  writable.on("drain", onDrain);
+  return (line) => {
+    if (failure3 !== void 0) return Promise.reject(failure3);
+    if (writable.write(line)) return Promise.resolve();
+    return new Promise((resolve, reject) => waiting.add({ resolve, reject }));
+  };
 }
 var LineSplitter = class {
   constructor(onLine) {
@@ -27298,6 +27326,17 @@ var LineSplitter = class {
     }
   }
 };
+async function settledWithin(promise2, ms) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("pending"), Math.max(0, ms));
+  });
+  try {
+    return await Promise.race([promise2, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 // src/CodexJsonRpcConnection.ts
 function startCodexConnection(codexPath, env) {
@@ -27357,6 +27396,17 @@ var ACPSessionConnection = class {
   }
 };
 
+// src/SessionTitle.ts
+var MAX_SESSION_TITLE_LENGTH = 256;
+function normalizeSessionTitle(title) {
+  const normalized = title?.replace(/\s+/g, " ").trim() ?? "";
+  if (normalized.length === 0) return null;
+  if (normalized.length <= MAX_SESSION_TITLE_LENGTH) return normalized;
+  let cut = normalized.slice(0, MAX_SESSION_TITLE_LENGTH - 1);
+  if (/[\uD800-\uDBFF]$/.test(cut)) cut = cut.slice(0, -1);
+  return `${cut.trimEnd()}\u2026`;
+}
+
 // src/TokenCount.ts
 function toTokenCount(usage) {
   return {
@@ -27403,6 +27453,7 @@ var AIR_MESSAGE_PHASE_KEY = "phase";
 var AIR_GOAL_KEY = "goal";
 var AIR_KIND_KEY = "kind";
 var AIR_COMMAND_ACTION_KEY = "commandAction";
+var AIR_SKILL_PATH_KEY = "skillPath";
 var AIR_PERMISSION_KEY = "permission";
 var AIR_CONTEXT_COMPACTION_KEY = "contextCompaction";
 var AIR_RAW_INPUT_RENDERING_KEY = "rawInputRendering";
@@ -30424,12 +30475,12 @@ var CodexEventHandler = class {
       case "thread/tokenUsage/updated":
         return this.createUsageUpdate(notification.params);
       case "thread/name/updated":
-        this.sessionState.sessionTitle = notification.params.threadName ?? null;
+        this.sessionState.sessionTitle = normalizeSessionTitle(notification.params.threadName);
         this.sessionState.sessionTitleSource = notification.params.threadName == null ? "unset" : "explicit";
         this.sessionState.titleGen?.observeRename();
         return {
           sessionUpdate: "session_info_update",
-          title: notification.params.threadName ?? null
+          title: this.sessionState.sessionTitle
         };
       case "thread/status/changed":
         return this.createCodexSessionInfoUpdate({
@@ -32318,6 +32369,255 @@ function isCodexAuthRequest(request) {
   return request.methodId === "api-key" || request.methodId === "chat-gpt" || request.methodId === "chat-gpt-device-code" || request.methodId === "gateway";
 }
 
+// src/mcp/McpServerSignIn.ts
+import { randomUUID } from "node:crypto";
+function createMcpServerSignIn(connection, codexAcpClient, clientCapabilities) {
+  return async (sessionId, serverName, signal) => {
+    if (!clientSupportsUrlElicitation(clientCapabilities())) {
+      return "unsupported";
+    }
+    try {
+      return await signInWithUrlElicitation(connection, codexAcpClient(), sessionId, serverName, signal) ? "signedIn" : "failed";
+    } catch (err) {
+      if (!signal?.aborted) {
+        logger.error(`Failed to authenticate MCP server ${serverName}`, err);
+      }
+      return "failed";
+    }
+  };
+}
+async function signInWithUrlElicitation(connection, codexAcpClient, sessionId, serverName, signal) {
+  signal?.throwIfAborted();
+  const stop = new AbortController();
+  const onAbort = () => stop.abort(signal?.reason);
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const stopped = new Promise((_, reject) => {
+    stop.signal.addEventListener("abort", () => reject(stop.signal.reason), { once: true });
+  });
+  void stopped.catch(() => {
+  });
+  const elicitationId = `mcp-oauth-${randomUUID()}`;
+  let dialogOpen = false;
+  try {
+    const completed = codexAcpClient.awaitMcpServerOauthLoginCompleted(serverName, sessionId, stop.signal);
+    void completed.catch(() => {
+    });
+    const login2 = await Promise.race([
+      codexAcpClient.mcpServerOauthLogin({ name: serverName, threadId: sessionId }),
+      stopped
+    ]);
+    const elicitation = Promise.resolve(connection.request(
+      methods.client.elicitation.create,
+      {
+        mode: "url",
+        sessionId,
+        message: `Authenticate with MCP server ${serverName}`,
+        url: login2.authorizationUrl,
+        elicitationId
+      }
+    ));
+    void elicitation.catch(() => {
+    });
+    dialogOpen = true;
+    const first = await Promise.race([
+      completed.then((result2) => ({ type: "completed", result: result2 })),
+      elicitation.then((response) => ({ type: "elicitation", response })),
+      stopped
+    ]);
+    if (first.type === "elicitation" && !CreateElicitationResponse.isAccept(first.response)) {
+      dialogOpen = false;
+      return false;
+    }
+    const result = first.type === "completed" ? first.result : await Promise.race([completed, stopped]);
+    return result.success;
+  } finally {
+    stop.abort();
+    signal?.removeEventListener("abort", onAbort);
+    if (dialogOpen) {
+      await connection.notify(methods.client.elicitation.complete, { elicitationId });
+    }
+  }
+}
+
+// src/McpServerName.ts
+var MCP_SERVER_NAME_WHITESPACE = /\p{White_Space}/gu;
+function sanitizeMcpServerName(name) {
+  return name.replace(MCP_SERVER_NAME_WHITESPACE, "_");
+}
+
+// src/tool-calls/reporters/McpStartupReporter.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var McpStartupReporter = class {
+  static skipped(serverNames) {
+    return serverNames.map((server) => failure2(
+      server,
+      `[codex-acp] MCP server \`${server}\` was not started, because the Codex config already defines an MCP server with this name. Codex uses its own entry, or no server if that entry is disabled.`
+    ));
+  }
+  static failures(event) {
+    return [
+      ...event.failed.map((server) => failure2(
+        server.server,
+        `[codex-acp forwarded startup error] MCP server \`${server.server}\` failed to start: ${server.error}`
+      )),
+      ...event.cancelled.map((server) => failure2(
+        server,
+        `[codex-acp forwarded startup error] MCP server \`${server}\` startup was cancelled.`
+      ))
+    ];
+  }
+};
+function failure2(serverName, message) {
+  return {
+    // A unique id, so that a later report for the same server cannot replace this one.
+    toolCallId: `mcp_startup.${encodeURIComponent(serverName)}.${randomUUID2()}`,
+    report: "start",
+    kind: "other",
+    title: `mcp__${serverName}__startup`,
+    status: "failed",
+    result: [textContent(message)]
+  };
+}
+
+// src/mcp/McpSessionStartup.ts
+var McpSessionStartup = class {
+  connection;
+  codexAcpClient;
+  runWithProcessCheck;
+  signIn;
+  capabilities;
+  /** True when the session is open and does not close. */
+  isSessionOpen;
+  pendingSessions = /* @__PURE__ */ new Map();
+  constructor(connection, codexAcpClient, runWithProcessCheck, signIn, capabilities, isSessionOpen) {
+    this.connection = connection;
+    this.codexAcpClient = codexAcpClient;
+    this.runWithProcessCheck = runWithProcessCheck;
+    this.signIn = signIn;
+    this.capabilities = capabilities;
+    this.isSessionOpen = isSessionOpen;
+  }
+  /**
+   * Starts the startup wait of the session and publishes the report when the startup ends.
+   * It returns a promise only when it waits for the startup, and returns null otherwise.
+   * The promise rejects when the startup fails before `awaitTimeoutMs`. Then the session has no pending startup.
+   */
+  begin(sessionId, mcpServers, afterVersion, options) {
+    const pendingStartup = this.createPendingSession(sessionId, mcpServers, afterVersion, options.skippedServers ?? []);
+    if (options.publish) {
+      this.pendingSessions.set(sessionId, pendingStartup);
+    }
+    const awaitTimeoutMs = options.awaitTimeoutMs;
+    if (awaitTimeoutMs !== void 0 && awaitTimeoutMs > 0) {
+      const startupWait = settledWithin(pendingStartup.startup, awaitTimeoutMs).then(() => void 0);
+      void startupWait.then(
+        () => this.publishOrAbort(sessionId, pendingStartup, options.publish),
+        () => this.forget(sessionId, pendingStartup)
+      );
+      return startupWait;
+    }
+    this.publishOrAbort(sessionId, pendingStartup, options.publish);
+    return null;
+  }
+  /** Stops the startup wait and the sign-in of the session. */
+  close(sessionId) {
+    this.pendingSessions.get(sessionId)?.abort.abort();
+    this.pendingSessions.delete(sessionId);
+  }
+  isPending(sessionId) {
+    return this.pendingSessions.has(sessionId);
+  }
+  publishOrAbort(sessionId, pendingStartup, publish) {
+    if (publish) {
+      this.publishAsync(sessionId);
+    } else {
+      pendingStartup.abort.abort();
+    }
+  }
+  forget(sessionId, pendingStartup) {
+    if (this.pendingSessions.get(sessionId) === pendingStartup) {
+      this.pendingSessions.delete(sessionId);
+    }
+  }
+  publishAsync(sessionId) {
+    void this.doPublish(sessionId);
+  }
+  createPendingSession(sessionId, mcpServers, afterVersion, skippedServers) {
+    const requestedServers = new Set(getRequestedMcpServerNames(mcpServers).filter((server) => !skippedServers.includes(server)));
+    const abort = new AbortController();
+    const startup = this.runWithProcessCheck(() => this.codexAcpClient().awaitMcpServerStartup(
+      Array.from(requestedServers),
+      afterVersion,
+      { threadId: sessionId, signal: abort.signal }
+    ));
+    void startup.catch(() => {
+    });
+    return { requestedServers, skippedServers, startup, abort };
+  }
+  async doPublish(sessionId) {
+    const pendingStartup = this.pendingSessions.get(sessionId);
+    if (!pendingStartup) {
+      return;
+    }
+    try {
+      const mcpStartup = await pendingStartup.startup;
+      if (!this.isSessionOpen(sessionId) || this.pendingSessions.get(sessionId) !== pendingStartup) {
+        return;
+      }
+      await this.publish(sessionId, mcpStartup, pendingStartup);
+    } catch (err) {
+      if (!pendingStartup.abort.signal.aborted) {
+        logger.error(`Failed to publish MCP startup status for session ${sessionId}`, err);
+      }
+    } finally {
+      this.forget(sessionId, pendingStartup);
+    }
+  }
+  async publish(sessionId, mcpStartup, pendingStartup) {
+    const { requestedServers, skippedServers, abort: { signal } } = pendingStartup;
+    const filteredStartup = {
+      ready: mcpStartup.ready.filter((server) => requestedServers.has(server)),
+      failed: mcpStartup.failed.filter((server) => requestedServers.has(server.server)),
+      cancelled: mcpStartup.cancelled.filter((server) => requestedServers.has(server))
+    };
+    const failuresAfterOauth = [];
+    const readyAfterOauth = [...filteredStartup.ready];
+    for (const failure3 of filteredStartup.failed) {
+      const signIn = failure3.failureReason === "reauthenticationRequired" ? await this.signIn(sessionId, failure3.server, signal) : "unsupported";
+      if (signIn === "signedIn") {
+        readyAfterOauth.push(failure3.server);
+      } else {
+        failuresAfterOauth.push(failure3);
+      }
+    }
+    if (signal.aborted) {
+      return;
+    }
+    const renderer = new AcpToolCallRenderer(this.capabilities());
+    for (const facts4 of [
+      ...McpStartupReporter.skipped(skippedServers),
+      ...McpStartupReporter.failures({
+        ...filteredStartup,
+        ready: readyAfterOauth,
+        failed: failuresAfterOauth
+      })
+    ]) {
+      await this.connection.notify(methods.client.session.update, {
+        sessionId,
+        update: renderer.render(facts4)
+      });
+    }
+  }
+};
+function getRequestedMcpServerNames(mcpServers) {
+  return Array.from(new Set(mcpServers.map((server) => sanitizeMcpServerName(server.name))));
+}
+var MCP_STARTUP_AWAIT_TIMEOUT_META_KEY = "mcpStartupAwaitTimeoutMs";
+function parseMcpStartupAwaitTimeoutMs(meta3) {
+  const value = meta3?.[MCP_STARTUP_AWAIT_TIMEOUT_META_KEY];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
 // node_modules/open/index.js
 import process10 from "node:process";
 import path5 from "node:path";
@@ -33161,10 +33461,70 @@ var AgentMode = class _AgentMode {
 // src/CodexAcpClient.ts
 import path7 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, "_");
+// src/CodexThreadErrors.ts
+function errorText(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (err !== null && typeof err === "object" && "message" in err) {
+    return String(err.message);
+  }
+  return "";
+}
+function isMissingRolloutError(err) {
+  return errorText(err).includes("no rollout found for thread id");
+}
+function isThreadNotLoadedError(err) {
+  return errorText(err).includes("thread not loaded:");
+}
+function isThreadNotFoundError(err) {
+  return errorText(err).includes("thread not found:");
+}
+function isInvalidThreadIdError(err) {
+  const text = errorText(err);
+  return text.includes("invalid thread id:") || text.includes("invalid session id:");
+}
+function isNoActiveTurnError(err) {
+  return errorText(err).includes("no active turn to interrupt");
+}
+function isUnknownThreadError(err) {
+  return isMissingRolloutError(err) || isThreadNotLoadedError(err) || isInvalidThreadIdError(err);
+}
+function isThreadActiveWriterError(err) {
+  return /\bthread \S+ already has an active writer\b/.test(errorText(err));
+}
+function threadActiveWriterRequestError(threadId, err) {
+  return RequestError.invalidRequest(
+    { reason: "thread_active_writer", threadId, details: errorText(err) },
+    "This Codex session is in use by another Codex client (the Codex app, the CLI or an IDE extension). Close the session there or quit that client, then try again."
+  );
+}
+var INTERNAL_ERROR_CODE = -32603;
+var ACCOUNT_READ_UNAVAILABLE_MESSAGES = /* @__PURE__ */ new Set([
+  "workspace routing discovery failed",
+  "workspace routing discovery timed out"
+]);
+var ACCOUNT_READ_AUTH_FAILURE_MESSAGES = /* @__PURE__ */ new Set([
+  "workspace routing discovery unauthorized (401)",
+  "selected workspace missing from routing discovery",
+  "workspace routing requires a ChatGPT account id"
+]);
+var ACCOUNT_READ_ACCOUNT_CHANGED_MESSAGE = "account changed during workspace routing discovery";
+function internalErrorText(err) {
+  if (err === null || typeof err !== "object" || err.code !== INTERNAL_ERROR_CODE) {
+    return null;
+  }
+  return errorText(err);
+}
+function isAccountReadUnavailableError(err) {
+  const text = internalErrorText(err);
+  return text !== null && ACCOUNT_READ_UNAVAILABLE_MESSAGES.has(text);
+}
+function isAccountReadAuthFailureError(err) {
+  const text = internalErrorText(err);
+  return text !== null && ACCOUNT_READ_AUTH_FAILURE_MESSAGES.has(text);
+}
+function isAccountReadAccountChangedError(err) {
+  return internalErrorText(err) === ACCOUNT_READ_ACCOUNT_CHANGED_MESSAGE;
 }
 
 // package.json
@@ -33173,7 +33533,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "2.1.1",
+  version: "2.1.2-preview.2",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -33447,13 +33807,14 @@ import { createHash } from "node:crypto";
 async function forkSession(request, additionalDirectories, dependencies) {
   await dependencies.refreshSkills(request.cwd, additionalDirectories);
   const lastTurnId = await resolveForkTurnId(request, dependencies.codexClient);
+  const sessionConfig = await dependencies.createSessionConfig(
+    request.cwd,
+    additionalDirectories,
+    request.mcpServers ?? []
+  );
   const response = await dependencies.codexClient.threadFork({
     excludeTurns: true,
-    config: await dependencies.createSessionConfig(
-      request.cwd,
-      additionalDirectories,
-      request.mcpServers ?? []
-    ),
+    config: sessionConfig.config,
     cwd: request.cwd,
     ...lastTurnId !== void 0 && { lastTurnId },
     modelProvider: await dependencies.getResumeModelProvider(),
@@ -33468,7 +33829,8 @@ async function forkSession(request, additionalDirectories, dependencies) {
     collaborationMode: dependencies.getCollaborationMode(response.thread.id),
     modelProvider: response.modelProvider,
     currentServiceTier: response.serviceTier ?? null,
-    additionalDirectories
+    additionalDirectories,
+    skippedMcpServers: sessionConfig.skippedMcpServers
   };
 }
 async function resolveForkTurnId(request, codexClient) {
@@ -33525,41 +33887,6 @@ function isUnknownRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/CodexThreadErrors.ts
-function errorText(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
-  if (err !== null && typeof err === "object" && "message" in err) {
-    return String(err.message);
-  }
-  return "";
-}
-function isMissingRolloutError(err) {
-  return errorText(err).includes("no rollout found for thread id");
-}
-function isThreadNotLoadedError(err) {
-  return errorText(err).includes("thread not loaded:");
-}
-function isInvalidThreadIdError(err) {
-  const text = errorText(err);
-  return text.includes("invalid thread id:") || text.includes("invalid session id:");
-}
-function isNoActiveTurnError(err) {
-  return errorText(err).includes("no active turn to interrupt");
-}
-function isUnknownThreadError(err) {
-  return isMissingRolloutError(err) || isThreadNotLoadedError(err) || isInvalidThreadIdError(err);
-}
-function isThreadActiveWriterError(err) {
-  return /\bthread \S+ already has an active writer\b/.test(errorText(err));
-}
-function threadActiveWriterRequestError(threadId, err) {
-  return RequestError.invalidRequest(
-    { reason: "thread_active_writer", threadId, details: errorText(err) },
-    "This Codex session is in use by another Codex client (the Codex app, the CLI or an IDE extension). Close the session there or quit that client, then try again."
-  );
-}
-
 // src/CodexAcpClient.ts
 var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
 var OPENAI_PROVIDER_ID = "openai";
@@ -33645,8 +33972,7 @@ var CodexAcpClient = class {
     return result.success;
   }
   async authenticateWithChatGpt() {
-    const accountResponse = await this.codexClient.accountRead({ refreshToken: true });
-    if (accountResponse.account?.type === "chatgpt") {
+    if (await this.hasWorkingChatGptLogin()) {
       return true;
     }
     const loginCompletedPromise = this.awaitNextLoginCompleted();
@@ -33657,9 +33983,32 @@ var CodexAcpClient = class {
     const result = await loginCompletedPromise;
     return result.success;
   }
+  /**
+   * Reads with a token refresh whether the agent has a ChatGPT login that a new login does not need to replace.
+   *
+   * An unavailable read answers `true`: only a ChatGPT login runs the routing discovery that failed, see
+   * {@link isAccountReadUnavailableError}, and a new login cannot run without the network either.
+   * A read that failed because the login does not work answers `false`, so a new login replaces it, see
+   * {@link isAccountReadAuthFailureError}. Another error rejects.
+   */
+  async hasWorkingChatGptLogin() {
+    try {
+      const accountResponse = await this.codexClient.accountRead({ refreshToken: true });
+      return accountResponse.account?.type === "chatgpt";
+    } catch (error62) {
+      if (isAccountReadUnavailableError(error62)) {
+        logger.log("Account read unavailable, so the stored ChatGPT login stays", { error: String(error62) });
+        return true;
+      }
+      if (isAccountReadAuthFailureError(error62)) {
+        logger.log("The stored ChatGPT login does not work, so a new login starts", { error: String(error62) });
+        return false;
+      }
+      throw error62;
+    }
+  }
   async authenticateWithChatGptDeviceCode(urlElicitationRequester) {
-    const accountResponse = await this.codexClient.accountRead({ refreshToken: true });
-    if (accountResponse.account?.type === "chatgpt") {
+    if (await this.hasWorkingChatGptLogin()) {
       return true;
     }
     if (!urlElicitationRequester) {
@@ -33770,12 +34119,13 @@ var CodexAcpClient = class {
     await this.codexClient.accountLogout();
     await accountUpdatedPromise;
   }
-  async authRequired() {
+  /** Reads whether the agent needs a login, with the account read that gave the answer. */
+  async readAuthRequirement() {
     if (this.gatewayConfig != null) {
-      return false;
+      return { required: false, account: null };
     }
     const response = await this.codexClient.accountRead({ refreshToken: false });
-    return response.requiresOpenaiAuth && !response.account;
+    return { required: response.requiresOpenaiAuth && !response.account, account: response };
   }
   /**
    * Validates and stores custom gateway routing. Shared by the `gateway` auth
@@ -33986,9 +34336,10 @@ var CodexAcpClient = class {
   async resumeSession(request, onSubscribed) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
+    const sessionConfig = await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []);
     const response = await this.resumeThread({
       excludeTurns: true,
-      config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
+      config: sessionConfig.config,
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId
@@ -34004,7 +34355,8 @@ var CodexAcpClient = class {
       collaborationMode: response.collaborationMode ?? this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
-      additionalDirectories
+      additionalDirectories,
+      skippedMcpServers: sessionConfig.skippedMcpServers
     };
   }
   async forkSession(request) {
@@ -34022,9 +34374,10 @@ var CodexAcpClient = class {
   async loadSession(request, onSubscribed) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
+    const sessionConfig = await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []);
     const response = await this.resumeThread({
       excludeTurns: true,
-      config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers ?? []),
+      config: sessionConfig.config,
       cwd: request.cwd,
       modelProvider: await this.getResumeModelProvider(),
       threadId: request.sessionId
@@ -34053,7 +34406,8 @@ var CodexAcpClient = class {
       currentServiceTier: response.serviceTier ?? null,
       thread,
       history,
-      additionalDirectories
+      additionalDirectories,
+      skippedMcpServers: sessionConfig.skippedMcpServers
     };
   }
   /**
@@ -34084,8 +34438,9 @@ var CodexAcpClient = class {
   async newSession(request) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
+    const sessionConfig = await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers);
     const response = await this.codexClient.threadStart({
-      config: await this.createSessionConfig(request.cwd, additionalDirectories, request.mcpServers),
+      config: sessionConfig.config,
       modelProvider: this.getModelProvider(),
       cwd: request.cwd
     });
@@ -34101,7 +34456,8 @@ var CodexAcpClient = class {
       collaborationMode: this.getCollaborationMode(response.thread.id),
       modelProvider: response.modelProvider,
       currentServiceTier: response.serviceTier ?? null,
-      additionalDirectories
+      additionalDirectories,
+      skippedMcpServers: sessionConfig.skippedMcpServers
     };
   }
   async closeSession(sessionId) {
@@ -34178,11 +34534,11 @@ var CodexAcpClient = class {
   async clearGoal(sessionId) {
     await this.codexClient.runGoalClear({ threadId: sessionId });
   }
-  async awaitMcpServerStartup(serverNames, afterVersion) {
-    return await this.codexClient.awaitMcpServerStartup(serverNames, afterVersion);
+  async awaitMcpServerStartup(serverNames, afterVersion, options) {
+    return await this.codexClient.mcpStartup.await(serverNames, afterVersion, options);
   }
   getMcpServerStartupVersion() {
-    return this.codexClient.getMcpServerStartupVersion();
+    return this.codexClient.mcpStartup.version();
   }
   async createSessionConfig(projectPath, additionalDirectories, mcpServers) {
     const sessionRoots = [projectPath, ...additionalDirectories];
@@ -34205,7 +34561,7 @@ var CodexAcpClient = class {
     };
     const configWithWorkspaceRoots = mergeSandboxWorkspaceWriteRoots(mergedConfig, additionalDirectories);
     if (mcpServers.length === 0) {
-      return configWithWorkspaceRoots;
+      return { config: configWithWorkspaceRoots, skippedMcpServers: [] };
     }
     const requestedServers = mcpServers.map((mcp) => ({
       name: sanitizeMcpServerName(mcp.name),
@@ -34216,12 +34572,22 @@ var CodexAcpClient = class {
       const existingNames = await this.getConfigMcpServerNames(projectPath);
       serversToConfigure = requestedServers.filter((mcp) => !existingNames.has(mcp.name));
     }
-    if (serversToConfigure.length === 0) {
-      return configWithWorkspaceRoots;
+    const skippedMcpServers = requestedServers.filter((mcp) => !serversToConfigure.includes(mcp)).map((mcp) => mcp.name);
+    if (skippedMcpServers.length > 0) {
+      logger.log("Skipping requested MCP servers that the Codex config already defines", {
+        projectPath,
+        skippedMcpServers
+      });
+    }
+    if (serversToConfigure.length === 0) {
+      return { config: configWithWorkspaceRoots, skippedMcpServers };
     }
     return {
-      ...configWithWorkspaceRoots,
-      "mcp_servers": Object.fromEntries(serversToConfigure.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp.server)]))
+      config: {
+        ...configWithWorkspaceRoots,
+        "mcp_servers": Object.fromEntries(serversToConfigure.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp.server)]))
+      },
+      skippedMcpServers
     };
   }
   async getConfigMcpServerNames(projectPath) {
@@ -34409,14 +34775,18 @@ var CodexAcpClient = class {
       });
     });
   }
-  async listMcpServers() {
-    return this.codexClient.listMcpServerStatus({});
+  async listMcpServers(params) {
+    return this.codexClient.listMcpServerStatus(params);
+  }
+  /** Reloads the MCP configuration. Codex reconnects the servers of every loaded thread that failed, closed, or changed. */
+  async reloadMcpServers() {
+    await this.codexClient.mcpServerReload();
   }
   async mcpServerOauthLogin(params) {
     return await this.codexClient.mcpServerOauthLogin(params);
   }
-  async awaitMcpServerOauthLoginCompleted(name, threadId) {
-    return await this.codexClient.awaitMcpServerOauthLoginCompleted(name, threadId);
+  async awaitMcpServerOauthLoginCompleted(name, threadId, signal) {
+    return await this.codexClient.mcpOauthCompletions.await(name, threadId, signal);
   }
   async listSessions(request) {
     const sourceKinds = [
@@ -34445,7 +34815,7 @@ var CodexAcpClient = class {
     const mapThreadToSession = (thread) => ({
       sessionId: thread.id,
       cwd: thread.cwd,
-      title: (thread.name ?? thread.preview) || null,
+      title: normalizeSessionTitle(thread.name ?? thread.preview),
       updatedAt: new Date(thread.updatedAt * 1e3).toISOString()
     });
     let sessions = listResponse.data.map(mapThreadToSession);
@@ -34658,6 +35028,204 @@ async function* oneItemPage(items) {
 
 // src/CodexAppServerClient.ts
 var import_node2 = __toESM(require_main(), 1);
+
+// src/mcp/McpOauthCompletions.ts
+var McpOauthCompletions = class {
+  /** The waiters, by server name. */
+  waiters = /* @__PURE__ */ new Map();
+  closedError = null;
+  /** Completes the waiters of the server. A notification without a thread completes the waiters of every thread. */
+  complete(event) {
+    for (const waiter of [...this.waiters.get(event.name) ?? []]) {
+      if (event.threadId === null || event.threadId === waiter.threadId) {
+        waiter.resolve(event);
+      }
+    }
+  }
+  /** Waits for the sign-in completion of the server. The wait rejects when `signal` aborts or when the Codex connection closes. */
+  async await(name, threadId, signal) {
+    signal?.throwIfAborted();
+    if (this.closedError !== null) {
+      throw this.closedError;
+    }
+    return await new Promise((resolve, reject) => {
+      const onAbort = () => waiter.reject(signal?.reason);
+      const release = () => {
+        const waiters2 = this.waiters.get(name);
+        waiters2?.delete(waiter);
+        if (waiters2?.size === 0) {
+          this.waiters.delete(name);
+        }
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const waiter = {
+        threadId,
+        resolve: (event) => {
+          release();
+          resolve(event);
+        },
+        reject: (error62) => {
+          release();
+          reject(error62);
+        }
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      let waiters = this.waiters.get(name);
+      if (waiters === void 0) {
+        waiters = /* @__PURE__ */ new Set();
+        this.waiters.set(name, waiters);
+      }
+      waiters.add(waiter);
+    });
+  }
+  /** Rejects every wait, now and later, because the Codex connection closed. */
+  dispose() {
+    this.closedError ??= new Error("Codex connection closed during the MCP server sign-in.");
+    for (const waiters of [...this.waiters.values()]) {
+      for (const waiter of [...waiters]) {
+        waiter.reject(this.closedError);
+      }
+    }
+  }
+};
+
+// src/mcp/McpStartupTracker.ts
+var McpStartupTracker = class {
+  currentVersion = 0;
+  /** The last startup state of each MCP server, by server name and then by thread id. A `null` thread id is global. */
+  states = /* @__PURE__ */ new Map();
+  waiters = [];
+  closedError = null;
+  /** Returns the version of the last startup event. */
+  version() {
+    return this.currentVersion;
+  }
+  record(params) {
+    this.currentVersion += 1;
+    let states = this.states.get(params.name);
+    if (states === void 0) {
+      states = /* @__PURE__ */ new Map();
+      this.states.set(params.name, states);
+    }
+    states.set(params.threadId ?? null, {
+      status: params.status,
+      error: params.error,
+      failureReason: params.failureReason ?? null,
+      version: this.currentVersion
+    });
+    for (const waiter of [...this.waiters]) {
+      const result = this.tryBuildResult(waiter.serverNames, waiter.afterVersion, waiter.threadId);
+      if (result !== null) {
+        waiter.resolve(result);
+      }
+    }
+  }
+  /**
+   * Waits until each server reaches a terminal startup state after `afterVersion`.
+   * Only the events of `threadId` and the global events count.
+   * The wait rejects when `signal` aborts or when the Codex connection closes.
+   */
+  async await(serverNames, afterVersion, options) {
+    const uniqueServerNames = Array.from(new Set(serverNames.map((name) => name.trim()).filter((name) => name.length > 0)));
+    if (uniqueServerNames.length === 0) {
+      return { ready: [], failed: [], cancelled: [] };
+    }
+    const { threadId, signal } = options;
+    const result = this.tryBuildResult(uniqueServerNames, afterVersion, threadId);
+    if (result !== null) {
+      return result;
+    }
+    signal?.throwIfAborted();
+    if (this.closedError !== null) {
+      throw this.closedError;
+    }
+    return await new Promise((resolve, reject) => {
+      const onAbort = () => waiter.reject(signal?.reason);
+      const release = () => {
+        const index = this.waiters.indexOf(waiter);
+        if (index >= 0) {
+          this.waiters.splice(index, 1);
+        }
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const waiter = {
+        serverNames: uniqueServerNames,
+        afterVersion,
+        threadId,
+        resolve: (startup) => {
+          release();
+          resolve(startup);
+        },
+        reject: (error62) => {
+          release();
+          reject(error62);
+        }
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.waiters.push(waiter);
+    });
+  }
+  /** Drops the startup states of a thread. The global states stay. */
+  forgetThread(threadId) {
+    for (const [serverName, states] of this.states) {
+      states.delete(threadId);
+      if (states.size === 0) {
+        this.states.delete(serverName);
+      }
+    }
+  }
+  /** Rejects every wait, now and later, because the Codex connection closed. */
+  dispose() {
+    this.closedError ??= new Error("Codex connection closed during the MCP server startup.");
+    for (const waiter of [...this.waiters]) {
+      waiter.reject(this.closedError);
+    }
+  }
+  /** Returns the latest startup state of the server for the thread. A global state also counts. */
+  latestState(serverName, threadId) {
+    let latest;
+    for (const [stateThreadId, state] of this.states.get(serverName) ?? []) {
+      if (stateThreadId !== null && stateThreadId !== threadId) {
+        continue;
+      }
+      if (latest === void 0 || state.version > latest.version) {
+        latest = state;
+      }
+    }
+    return latest;
+  }
+  tryBuildResult(serverNames, afterVersion, threadId) {
+    const ready = [];
+    const failed = [];
+    const cancelled = [];
+    for (const serverName of serverNames) {
+      const state = this.latestState(serverName, threadId);
+      if (!state || state.version <= afterVersion) {
+        return null;
+      }
+      switch (state.status) {
+        case "starting":
+          return null;
+        case "ready":
+          ready.push(serverName);
+          break;
+        case "failed":
+          failed.push({
+            server: serverName,
+            error: state.error ?? "unknown MCP startup error",
+            ...state.failureReason === null ? {} : { failureReason: state.failureReason }
+          });
+          break;
+        case "cancelled":
+          cancelled.push(serverName);
+          break;
+      }
+    }
+    return { ready, failed, cancelled };
+  }
+};
+
+// src/CodexAppServerClient.ts
 var CommandExecutionApprovalRequest = new import_node2.RequestType("item/commandExecution/requestApproval");
 var FileChangeApprovalRequest = new import_node2.RequestType("item/fileChange/requestApproval");
 var PermissionsApprovalRequest = new import_node2.RequestType("item/permissions/requestApproval");
@@ -34671,9 +35239,8 @@ var CodexAppServerClient = class {
   connection;
   approvalHandlers = /* @__PURE__ */ new Map();
   elicitationHandlers = /* @__PURE__ */ new Map();
-  mcpServerStartupVersion = 0;
-  mcpServerStartupStates = /* @__PURE__ */ new Map();
-  mcpServerStartupResolvers = [];
+  mcpStartup = new McpStartupTracker();
+  mcpOauthCompletions = new McpOauthCompletions();
   pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
   pendingCompactionCompletionResolvers = /* @__PURE__ */ new Map();
   turnCompletionCaptures = /* @__PURE__ */ new Map();
@@ -34685,17 +35252,15 @@ var CodexAppServerClient = class {
   staleTurnIds = /* @__PURE__ */ new Map();
   constructor(connection) {
     this.connection = connection;
+    this.connection.onClose?.(() => this.disposeMcpWaits());
+    this.connection.onDispose?.(() => this.disposeMcpWaits());
     this.connection.onUnhandledNotification((data) => {
       const serverNotification = data;
       if (isMcpServerStatusUpdatedNotification(serverNotification)) {
-        this.mcpServerStartupVersion += 1;
-        this.mcpServerStartupStates.set(serverNotification.params.name, {
-          status: serverNotification.params.status,
-          error: serverNotification.params.error,
-          failureReason: serverNotification.params.failureReason ?? null,
-          version: this.mcpServerStartupVersion
-        });
-        this.resolveMcpServerStartupResolvers();
+        this.mcpStartup.record(serverNotification.params);
+      }
+      if (serverNotification.method === "mcpServer/oauthLogin/completed") {
+        this.mcpOauthCompletions.complete(serverNotification.params);
       }
       if (isTurnCompletedNotification(serverNotification)) {
         this.recordTurnCompleted(serverNotification.params);
@@ -35014,7 +35579,9 @@ var CodexAppServerClient = class {
     });
     void completed.catch(() => {
     });
-    const closed = this.connection.onClose?.(() => rejectCompleted(new Error("Codex connection closed during compaction.")));
+    const rejectClosed = () => rejectCompleted(new Error("Codex connection closed during compaction."));
+    const closed = this.connection.onClose?.(rejectClosed);
+    const disposed = this.connection.onDispose?.(rejectClosed);
     const completeCompaction = (event) => {
       if (compactTurnId !== null && event.params.turnId !== compactTurnId) return;
       resolveCompleted(event);
@@ -35040,6 +35607,7 @@ var CodexAppServerClient = class {
       releaseRoutingCapture();
       releaseCompactionCapture();
       closed?.dispose();
+      disposed?.dispose();
     }
   }
   async turnInterrupt(params) {
@@ -35119,7 +35687,7 @@ var CodexAppServerClient = class {
       cursor,
       limit: HISTORY_PAGE_ITEMS,
       sortDirection: "asc"
-    }));
+    }), (page) => page.some((entry) => entry.item.id === lastItemId));
     for await (const page of pages) {
       const items = page.map((entry) => entry.item);
       const lastIndex = items.findIndex((item) => item.id === lastItemId);
@@ -35193,24 +35761,12 @@ var CodexAppServerClient = class {
   async listMcpServerStatus(params) {
     return await this.sendRequest({ method: "mcpServerStatus/list", params });
   }
+  async mcpServerReload() {
+    return await this.sendRequest({ method: "config/mcpServer/reload", params: void 0 });
+  }
   async mcpServerOauthLogin(params) {
     return await this.sendRequest({ method: "mcpServer/oauth/login", params });
   }
-  async awaitMcpServerOauthLoginCompleted(name, threadId) {
-    return await new Promise((resolve) => {
-      let disposable;
-      disposable = this.connection.onNotification(
-        "mcpServer/oauthLogin/completed",
-        (event) => {
-          if (event.name !== name || event.threadId !== threadId) {
-            return;
-          }
-          disposable?.dispose();
-          resolve(event);
-        }
-      );
-    });
-  }
   async accountLogin(params) {
     return await this.sendRequest({ method: "account/login/start", params });
   }
@@ -35223,26 +35779,6 @@ var CodexAppServerClient = class {
   async configRead(params) {
     return await this.sendRequest({ method: "config/read", params });
   }
-  getMcpServerStartupVersion() {
-    return this.mcpServerStartupVersion;
-  }
-  async awaitMcpServerStartup(serverNames, afterVersion) {
-    const uniqueServerNames = Array.from(new Set(serverNames.map((serverName) => serverName.trim()).filter((serverName) => serverName.length > 0)));
-    if (uniqueServerNames.length === 0) {
-      return { ready: [], failed: [], cancelled: [] };
-    }
-    const result = this.tryBuildMcpStartupResult(uniqueServerNames, afterVersion);
-    if (result !== null) {
-      return result;
-    }
-    return await new Promise((resolve) => {
-      this.mcpServerStartupResolvers.push({
-        serverNames: uniqueServerNames,
-        afterVersion,
-        resolve
-      });
-    });
-  }
   async accountRead(params) {
     return await this.sendRequest({ method: "account/read", params });
   }
@@ -35515,46 +36051,9 @@ var CodexAppServerClient = class {
       }
     };
   }
-  resolveMcpServerStartupResolvers() {
-    const pendingResolvers = [];
-    for (const resolver of this.mcpServerStartupResolvers) {
-      const result = this.tryBuildMcpStartupResult(resolver.serverNames, resolver.afterVersion);
-      if (result !== null) {
-        resolver.resolve(result);
-      } else {
-        pendingResolvers.push(resolver);
-      }
-    }
-    this.mcpServerStartupResolvers.splice(0, this.mcpServerStartupResolvers.length, ...pendingResolvers);
-  }
-  tryBuildMcpStartupResult(serverNames, afterVersion) {
-    const ready = [];
-    const failed = [];
-    const cancelled = [];
-    for (const serverName of serverNames) {
-      const state = this.mcpServerStartupStates.get(serverName);
-      if (!state || state.version <= afterVersion) {
-        return null;
-      }
-      switch (state.status) {
-        case "starting":
-          return null;
-        case "ready":
-          ready.push(serverName);
-          break;
-        case "failed":
-          failed.push({
-            server: serverName,
-            error: state.error ?? "unknown MCP startup error",
-            ...state.failureReason === null ? {} : { failureReason: state.failureReason }
-          });
-          break;
-        case "cancelled":
-          cancelled.push(serverName);
-          break;
-      }
-    }
-    return { ready, failed, cancelled };
+  disposeMcpWaits() {
+    this.mcpStartup.dispose();
+    this.mcpOauthCompletions.dispose();
   }
   async sendRequest(request) {
     for (const callback of this.codexEventHandlers) {
@@ -35614,18 +36113,28 @@ function extractTurnRouting(notification) {
   }
   return { threadId, turnId: null };
 }
-async function* historyPages(threadId, method, requestPage) {
+async function* historyPages(threadId, method, requestPage, endsHistory) {
+  const request = (cursor2) => {
+    const page = withHistoryTimeout(requestPage(cursor2), method, threadId);
+    page.catch(() => {
+    });
+    return page;
+  };
   const seenCursors = /* @__PURE__ */ new Set();
   let cursor = null;
+  let next = null;
   do {
-    const page = await withHistoryTimeout(requestPage(cursor), method, threadId);
-    yield page.data;
+    const page = await (next ?? request(cursor));
+    next = null;
     cursor = page.nextCursor;
-    if (cursor !== null) {
-      if (seenCursors.has(cursor)) {
-        throw new Error("Codex returned a repeated thread history cursor");
-      }
+    const repeated = cursor !== null && seenCursors.has(cursor);
+    if (cursor !== null && !repeated) {
       seenCursors.add(cursor);
+      if (endsHistory && !endsHistory(page.data)) next = request(cursor);
+    }
+    yield page.data;
+    if (repeated) {
+      throw new Error("Codex returned a repeated thread history cursor");
     }
   } while (cursor !== null);
 }
@@ -35700,6 +36209,338 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
   };
 }
 
+// src/mcp/McpServerStatusList.ts
+async function listMcpServerStatus(codexAcpClient, threadId) {
+  const servers = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor = null;
+  do {
+    const page = await codexAcpClient.listMcpServers({
+      cursor,
+      detail: "toolsAndAuthOnly",
+      ...threadId === void 0 ? {} : { threadId }
+    });
+    servers.push(...page.data);
+    cursor = page.nextCursor;
+    if (cursor !== null) {
+      if (seenCursors.has(cursor)) {
+        logger.log(`MCP server status list repeated the cursor ${cursor}`);
+        break;
+      }
+      seenCursors.add(cursor);
+    }
+  } while (cursor !== null);
+  return servers;
+}
+
+// src/mcp/McpStatusMarkdown.ts
+var NO_SERVERS_MESSAGE = "No MCP servers are configured.";
+var SUMMARY_ORDER = [
+  "connected",
+  "starting",
+  "notStarted",
+  "authenticationRequired",
+  "failed",
+  "cancelled",
+  "disabled",
+  null
+];
+var GROUP_ORDER = [
+  "failed",
+  "cancelled",
+  "authenticationRequired",
+  "notStarted",
+  "starting",
+  "connected",
+  null
+];
+function statusLabel(status) {
+  switch (status) {
+    case "connected":
+      return "Connected";
+    case "starting":
+      return "Connecting";
+    case "notStarted":
+      return "Not started";
+    case "authenticationRequired":
+      return "Needs authentication";
+    case "failed":
+      return "Failed";
+    case "cancelled":
+      return "Cancelled";
+    case "disabled":
+      return "Disabled";
+    case null:
+      return "Unknown";
+  }
+}
+var KNOWN_STATUSES = /* @__PURE__ */ new Set([...GROUP_ORDER.filter((status) => status !== null), "disabled"]);
+function toEntry(server) {
+  const status = server.runtimeStatus;
+  return {
+    name: server.name,
+    status: status !== null && KNOWN_STATUSES.has(status) ? status : null,
+    toolCount: Object.keys(server.tools ?? {}).length,
+    toolsError: server.toolsError,
+    authStatus: server.authStatus,
+    listedByCodex: true
+  };
+}
+function formatStatus(servers, errors) {
+  if (servers.length === 0) {
+    return NO_SERVERS_MESSAGE;
+  }
+  const counts = SUMMARY_ORDER.map((status) => ({ status, count: servers.filter((server) => server.status === status).length })).filter((entry) => entry.count > 0).map((entry) => `${entry.count} ${statusLabel(entry.status).toLowerCase()}`);
+  const lines = [`**MCP servers:** ${servers.length} (${counts.join(", ")})`];
+  for (const status of GROUP_ORDER) {
+    const group = servers.filter((server) => server.status === status);
+    if (group.length === 0) {
+      continue;
+    }
+    lines.push("", `**${statusLabel(status)}**`);
+    for (const server of group) {
+      const detail = serverDetail(server, errors.get(server.name) ?? null);
+      lines.push(detail === null ? `- ${inlineCode(server.name)}` : `- ${inlineCode(server.name)}: ${detail}`);
+    }
+  }
+  const disabled = servers.filter((server) => server.status === "disabled");
+  if (disabled.length > 0) {
+    lines.push("", `**Disabled:** ${disabled.map((server) => inlineCode(server.name)).join(", ")}`);
+  }
+  if (servers.some((server) => server.status !== null && RECONNECT_HINT_STATUSES.has(server.status))) {
+    lines.push("", RECONNECT_HINT);
+  }
+  return lines.join("\n");
+}
+var RECONNECT_HINT = "Run `/mcp reconnect` to restart the servers that are not connected.";
+var RECONNECT_HINT_STATUSES = /* @__PURE__ */ new Set(["failed", "cancelled", "authenticationRequired", "notStarted"]);
+function serverDetail(server, startupError) {
+  if (server.status === "authenticationRequired") {
+    return NOT_SIGNED_IN;
+  }
+  const parts = [];
+  const toolCount = server.toolCount ?? 0;
+  if (server.status === "connected" || toolCount > 0) {
+    parts.push(`${toolCount} ${toolCount === 1 ? "tool" : "tools"}`);
+  }
+  if (server.authStatus === "notLoggedIn" && server.status !== "disabled") {
+    parts.push(NOT_SIGNED_IN);
+  }
+  const error62 = startupError ?? server.toolsError;
+  const cleanedError = error62 === null ? "" : formatNoteDetail(error62);
+  if (cleanedError.length > 0) {
+    parts.push(cleanedError);
+  }
+  return parts.length === 0 ? null : parts.join("; ");
+}
+var NOT_SIGNED_IN = "not signed in";
+var MAX_ERROR_LENGTH = 160;
+var MAX_ERROR_SENTENCES = 2;
+var MAX_INPUT_LENGTH = 2e3;
+var WRAPPER_SEGMENT = /^(?:tool discovery failed|mcp startup failed|handshaking with mcp server failed|json-rpc error|startup error|error|mcp client for .+ failed to start|-32\d{3})$/i;
+var TYPE_PATH = /\S*\w::\w+::\S*/g;
+function cleanErrorMessage(text) {
+  const oneLine = text.slice(0, MAX_INPUT_LENGTH).replace(/\s+/g, " ").trim();
+  const message = oneLine.split(": ").map((segment) => segment.replace(TYPE_PATH, "").replace(/\s+/g, " ").trim()).filter((segment) => segment.length > 0 && !WRAPPER_SEGMENT.test(segment)).join(": ");
+  if (message.length === 0) {
+    return shorten(oneLine);
+  }
+  return shorten(message.split(/(?<=[.!?])\s+/).slice(0, MAX_ERROR_SENTENCES).join(" "));
+}
+function shorten(text) {
+  const codePoints = Array.from(text);
+  return codePoints.length > MAX_ERROR_LENGTH ? `${codePoints.slice(0, MAX_ERROR_LENGTH).join("").trimEnd()}\u2026` : text;
+}
+function formatNoteDetail(text) {
+  return escapeMarkdown(cleanErrorMessage(text));
+}
+function escapeMarkdown(text) {
+  return text.replace(/[\\`*_[\]<>~]/g, (character) => `\\${character}`);
+}
+var UNNAMED_SERVER = "(unnamed)";
+function inlineCode(name) {
+  const text = name.replace(/\s+/g, " ");
+  if (text.length === 0) {
+    return UNNAMED_SERVER;
+  }
+  const longestRun = Math.max(0, ...Array.from(text.matchAll(/`+/g), (match) => match[0].length));
+  const fence = "`".repeat(longestRun + 1);
+  const padding = /^[` ]|[` ]$/.test(text) ? " " : "";
+  return `${fence}${padding}${text}${padding}${fence}`;
+}
+
+// src/mcp/McpCommand.ts
+var MCP_RECONNECT_STARTUP_TIMEOUT_MS = 3e4;
+var MCP_COMMAND_INPUT_HINT = "[reconnect]";
+var McpCommand = class {
+  codexAcpClient;
+  runWithProcessCheck;
+  signIn;
+  constructor(codexAcpClient, runWithProcessCheck, signIn) {
+    this.codexAcpClient = codexAcpClient;
+    this.runWithProcessCheck = runWithProcessCheck;
+    this.signIn = signIn;
+  }
+  /** Returns the answer, or `null` when `signal` aborted. After an abort, the caller must send nothing. */
+  async run(rest, sessionState, signal) {
+    const args = rest.split(/\s+/).filter((arg) => arg.length > 0);
+    if (args.length === 0) {
+      const list = await this.listServers(sessionState);
+      return signal?.aborted ? null : formatStatus(list.servers, /* @__PURE__ */ new Map());
+    }
+    if (args.length === 1 && args[0].toLowerCase() === "reconnect") {
+      return await this.reconnect(sessionState, signal);
+    }
+    return `Command "/mcp" accepts no arguments, or \`reconnect\`.`;
+  }
+  async reconnect(sessionState, signal) {
+    const before = await this.listServers(sessionState);
+    if (before.servers.length === 0) {
+      return NO_SERVERS_MESSAGE;
+    }
+    const notes = [];
+    let reload = await this.reloadAndWait(sessionState, signal);
+    if (reload.error !== null) {
+      notes.push(`Could not reload the MCP configuration: ${formatNoteDetail(reload.error)}`);
+    } else {
+      notes.push(RELOAD_NOTE);
+      const signIn = await this.signInServers(sessionState, reload, signal);
+      notes.push(...signIn.notes);
+      if (signIn.signedIn && !signal?.aborted) {
+        const secondReload = await this.reloadAndWait(sessionState, signal);
+        if (secondReload.error !== null) {
+          notes.push(`Could not reload the MCP configuration after the sign-in: ${formatNoteDetail(secondReload.error)}`);
+          reload = { ...secondReload, startup: reload.startup };
+        } else {
+          reload = secondReload;
+        }
+      }
+    }
+    if (signal?.aborted) {
+      return null;
+    }
+    if (reload.startup === null) {
+      notes.push("Some MCP servers are still starting. Run `/mcp` again later to see their status.");
+    }
+    return `${formatNotes(notes)}
+
+${formatStatus(reload.list.servers, startupErrors(reload.startup))}`;
+  }
+  /** Reloads the MCP configuration, and waits for the startup of the servers that the reloaded list contains. */
+  async reloadAndWait(sessionState, signal) {
+    const afterVersion = this.codexAcpClient.getMcpServerStartupVersion();
+    try {
+      await this.runWithProcessCheck(() => this.codexAcpClient.reloadMcpServers());
+    } catch (err) {
+      logger.error(`Failed to reload the MCP configuration for session ${sessionState.sessionId}`, err);
+      return { error: errorMessage(err), startup: emptyStartupResult(), list: await this.listServers(sessionState) };
+    }
+    const reloaded = await this.listServers(sessionState);
+    if (!reloaded.live) {
+      return { error: null, startup: emptyStartupResult(), list: reloaded };
+    }
+    const serverNames = reloaded.servers.filter((server) => server.listedByCodex && server.status !== "disabled").map((server) => server.name);
+    const startup = await this.waitForStartup(sessionState.sessionId, serverNames, afterVersion, signal);
+    if (signal?.aborted) {
+      return { error: null, startup, list: reloaded };
+    }
+    return { error: null, startup, list: await this.listServers(sessionState) };
+  }
+  /** Returns `null` at the timeout or when `signal` aborts. */
+  async waitForStartup(threadId, serverNames, afterVersion, signal) {
+    if (signal?.aborted) {
+      return null;
+    }
+    const stop = new AbortController();
+    const onAbort = () => stop.abort();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => stop.abort(), MCP_RECONNECT_STARTUP_TIMEOUT_MS);
+    try {
+      return await this.runWithProcessCheck(() => this.codexAcpClient.awaitMcpServerStartup(
+        serverNames,
+        afterVersion,
+        { threadId, signal: stop.signal }
+      ));
+    } catch (err) {
+      if (stop.signal.aborted) {
+        return null;
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async signInServers(sessionState, reload, signal) {
+    const names = new Set(reload.list.servers.filter((server) => server.status === "authenticationRequired").map((server) => server.name));
+    for (const failure3 of reload.startup?.failed ?? []) {
+      if (failure3.failureReason === "reauthenticationRequired") {
+        names.add(failure3.server);
+      }
+    }
+    const notes = [];
+    let signedIn = false;
+    for (const name of names) {
+      if (signal?.aborted) {
+        break;
+      }
+      const label = inlineCode(name);
+      switch (await this.signIn(sessionState.sessionId, name, signal)) {
+        case "unsupported":
+          notes.push(`MCP server ${label} needs authentication, but this client cannot open a sign-in page.`);
+          break;
+        case "signedIn":
+          notes.push(`Signed in to MCP server ${label}.`);
+          signedIn = true;
+          break;
+        case "failed":
+          notes.push(`The sign-in to MCP server ${label} failed or was cancelled.`);
+          break;
+      }
+    }
+    return { notes, signedIn };
+  }
+  async listServers(sessionState) {
+    const { servers, live } = await this.listServerStatus(sessionState.sessionId);
+    const entries = servers.map(toEntry);
+    for (const name of sessionState.sessionMcpServers ?? []) {
+      if (!entries.some((entry) => entry.name === name)) {
+        entries.push({ name, status: null, toolCount: null, toolsError: null, authStatus: null, listedByCodex: false });
+      }
+    }
+    return { servers: entries, live };
+  }
+  async listServerStatus(threadId) {
+    try {
+      const servers = await this.runWithProcessCheck(() => listMcpServerStatus(this.codexAcpClient, threadId));
+      return { servers, live: true };
+    } catch (err) {
+      if (!isThreadNotFoundError(err) && !isUnknownThreadError(err)) {
+        throw err;
+      }
+      logger.log(`Codex does not know thread ${threadId}, so the MCP server list has no live status`);
+      const servers = await this.runWithProcessCheck(() => listMcpServerStatus(this.codexAcpClient));
+      return { servers, live: false };
+    }
+  }
+};
+var RELOAD_NOTE = "Reloaded the MCP configuration of all open sessions. Codex restarted the servers that failed, stopped, or changed. A connected server with unchanged settings keeps its connection.";
+function startupErrors(result) {
+  return new Map((result?.failed ?? []).map((failure3) => [failure3.server, failure3.error]));
+}
+function emptyStartupResult() {
+  return { ready: [], failed: [], cancelled: [] };
+}
+function errorMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return String(err);
+}
+function formatNotes(notes) {
+  return ["**Reconnect:**", ...notes.map((note) => `- ${note}`)].join("\n");
+}
+
 // src/CodexCommands.ts
 var GOAL_CONTINUATION_PROMPT = [{
   type: "text",
@@ -35710,14 +36551,15 @@ var CodexCommands = class {
   codexAcpClient;
   runWithProcessCheck;
   onLogout;
+  mcpCommand;
   /** The commands that each session got last, to skip a publish that changes nothing. */
   published = /* @__PURE__ */ new WeakMap();
-  constructor(connection, codexAcpClient, runWithProcessCheck, onLogout = () => {
-  }) {
+  constructor(connection, codexAcpClient, runWithProcessCheck, onLogout, mcpServerSignIn) {
     this.connection = connection;
     this.codexAcpClient = codexAcpClient;
     this.runWithProcessCheck = runWithProcessCheck;
     this.onLogout = onLogout;
+    this.mcpCommand = new McpCommand(codexAcpClient, runWithProcessCheck, mcpServerSignIn);
   }
   /** Sends the available commands. With `onlyChanges`, it sends nothing when the commands did not change. */
   async publish(sessionState, shouldPublish = () => true, onlyChanges = false) {
@@ -35764,10 +36606,12 @@ var CodexCommands = class {
         const name = `$${skill.name}`;
         if (commands.has(name)) continue;
         const description = skill.shortDescription ?? skill.description ?? skill.name;
+        const meta3 = airOnlyMeta(airClient, AIR_SKILL_PATH_KEY, skill.path);
         commands.set(name, {
           name,
           description,
-          input: null
+          input: null,
+          ...meta3 ? { _meta: meta3 } : {}
         });
       }
     }
@@ -35797,8 +36641,8 @@ var CodexCommands = class {
       },
       {
         name: "mcp",
-        description: "List configured Model Context Protocol (MCP) tools.",
-        input: null
+        description: "Show the status of the MCP servers, or reconnect them.",
+        input: { hint: MCP_COMMAND_INPUT_HINT }
       },
       {
         name: "skills",
@@ -35955,15 +36799,10 @@ var CodexCommands = class {
         return { handled: true };
       }
       case "mcp": {
-        const servers = await this.runWithProcessCheck(() => this.codexAcpClient.listMcpServers());
-        const configuredServers = servers.data.map((server) => {
-          const toolCount = Object.keys(server.tools ?? {}).length;
-          const resourceCount = (server.resources ?? []).length;
-          return `- ${server.name}: ${toolCount} tools, ${resourceCount} resources, auth=${server.authStatus}`;
-        });
-        const sessionServers = sessionState.sessionMcpServers ? sessionState.sessionMcpServers.map((serverName) => `- ${serverName}`) : [];
-        const lines = [...configuredServers, ...sessionServers];
-        const text = lines.length > 0 ? ["Configured MCP servers:", ...lines].join("\n") : "No MCP servers configured.";
+        const text = await this.mcpCommand.run(command.rest, sessionState, options.signal);
+        if (text === null) {
+          return { handled: true };
+        }
         const session = new ACPSessionConnection(this.connection, sessionId);
         await session.update(createAgentTextMessageChunk(text));
         return { handled: true };
@@ -36302,17 +37141,19 @@ var ToolCallReports = class {
   recordStart(key, update) {
     this.finishedToolCalls.delete(key);
     const fields = /* @__PURE__ */ new Map();
-    for (const [name, value] of reportedFields(update, this.compareMeta)) {
+    const terminal = update.status === "completed" || update.status === "failed";
+    const only = terminal ? FINISHED_FIELDS : void 0;
+    for (const [name, value] of reportedFields(update, this.compareMeta && !terminal, only)) {
       fields.set(name, value);
     }
     this.openToolCalls.set(key, fields);
     return update;
   }
   recordUpdate(key, update) {
-    const finished = this.finishedToolCalls.get(key);
-    if (finished !== void 0) {
+    const finished2 = this.finishedToolCalls.get(key);
+    if (finished2 !== void 0) {
       const current = this.withoutLateOutput(update);
-      return current === null ? null : this.withoutUnchangedFields(current, finished, FINISHED_FIELDS);
+      return current === null ? null : this.withoutUnchangedFields(current, finished2, FINISHED_FIELDS);
     }
     const fields = this.openToolCalls.get(key) ?? /* @__PURE__ */ new Map();
     this.openToolCalls.set(key, fields);
@@ -36322,7 +37163,7 @@ var ToolCallReports = class {
   withoutUnchangedFields(update, fields, recorded) {
     const prepared = { ...update };
     const meta3 = isRecord2(update._meta) ? { ...update._meta } : void 0;
-    for (const [name, value] of reportedFields(update, this.compareMeta)) {
+    for (const [name, value] of reportedFields(update, this.compareMeta && recorded === void 0, recorded)) {
       if (fields.get(name) === value) {
         if (name.startsWith(META_FIELD_PREFIX)) {
           delete meta3?.[name.slice(META_FIELD_PREFIX.length)];
@@ -36374,10 +37215,11 @@ var ToolCallReports = class {
     }
   }
 };
-function reportedFields(update, withMeta) {
+function reportedFields(update, withMeta, only) {
   const fields = [];
   const record2 = update;
   for (const name of COMPARED_FIELDS) {
+    if (only !== void 0 && !only.has(name)) continue;
     const value = record2[name];
     if (value !== void 0) fields.push([name, JSON.stringify(value)]);
   }
@@ -36573,6 +37415,26 @@ function fromAccountUpdated(notification, previous) {
       return gatewayStatus();
   }
 }
+function accountFromUpdated(notification, previous) {
+  switch (notification.authMode) {
+    case null:
+      return null;
+    case "chatgpt":
+    case "chatgptAuthTokens": {
+      const previousChatGpt = previous?.type === "chatgpt" ? previous : null;
+      return {
+        type: "chatgpt",
+        email: previousChatGpt?.email ?? null,
+        planType: notification.planType ?? previousChatGpt?.planType ?? "unknown"
+      };
+    }
+    case "apikey":
+    case "personalAccessToken":
+      return { type: "apiKey" };
+    default:
+      return previous;
+  }
+}
 function sameAuthStatus(previous, next) {
   if (!previous) {
     return false;
@@ -36641,34 +37503,6 @@ var ClientCapabilities = class _ClientCapabilities {
   }
 };
 
-// src/tool-calls/reporters/McpStartupReporter.ts
-import { randomUUID } from "node:crypto";
-var McpStartupReporter = class {
-  static failures(event) {
-    return [
-      ...event.failed.map((server) => failure2(
-        server.server,
-        `[codex-acp forwarded startup error] MCP server \`${server.server}\` failed to start: ${server.error}`
-      )),
-      ...event.cancelled.map((server) => failure2(
-        server,
-        `[codex-acp forwarded startup error] MCP server \`${server}\` startup was cancelled.`
-      ))
-    ];
-  }
-};
-function failure2(serverName, message) {
-  return {
-    // A unique id, so that a later report for the same server cannot replace this one.
-    toolCallId: `mcp_startup.${encodeURIComponent(serverName)}.${randomUUID()}`,
-    report: "start",
-    kind: "other",
-    title: `mcp__${serverName}__startup`,
-    status: "failed",
-    result: [textContent(message)]
-  };
-}
-
 // src/tool-calls/reporters/PlanReviewReporter.ts
 var IMPLEMENT_PLAN_OPTION_ID = "implement_plan";
 var REVISE_PLAN_OPTION_ID = "revise_plan";
@@ -36778,7 +37612,7 @@ function clientSupportsSubagents(capabilities) {
 }
 
 // src/CodexAcpServer.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/TitleGenerator.ts
 var TITLE_MODEL = "gpt-5.6-luna";
@@ -37337,15 +38171,20 @@ var CodexSessionCompactions = class {
 var CODEX_PROCESS_EXITED_ERROR_CODE = 1001;
 var TITLE_GENERATION_SETTLE_TIMEOUT_MS = 1e4;
 var NO_ACTIVE_TURN_RETRY_DELAYS_MS = [25, 50, 100, 200, 400];
+var ACCOUNT_READ_LOAD_GRACE_MS = 1e3;
 function clientSupportsTypedSessionFailures(capabilities) {
   return clientSupportsAirCapability(capabilities, AIR_SESSION_FAILURE_KEY);
 }
 function clientSupportsAgentFileChangeReports(capabilities) {
   return clientSupportsAirCapability(capabilities, AIR_AGENT_FILE_CHANGE_REPORT_KEY);
 }
+function isAuthRequiredError(error62) {
+  return error62 instanceof RequestError && error62.code === RequestError.authRequired().code;
+}
 var CodexAcpServer = class {
   codexAcpClient;
   connection;
+  mcpServerSignIn;
   reportingConnection;
   defaultAuthRequest;
   getExitCode;
@@ -37359,8 +38198,18 @@ var CodexAcpServer = class {
   booleanConfigOptionsSupported;
   /** Last `authStatus` pushed to the client; used to suppress duplicates. */
   currentAuthStatus;
+  /**
+   * The last known account of the agent. Every successful account read and every `account/updated` sets it,
+   * and a logout clears it. A session open takes it when the account read is unavailable.
+   */
+  lastReadAccount = null;
+  /**
+   * Counts the calls of {@link setAuthStatus}, also the calls that push nothing. A late account read
+   * compares it with the value at the start of the read: a change means a newer status.
+   */
+  authStatusVersion = 0;
   sessions;
-  pendingMcpStartupSessions;
+  mcpSessionStartup;
   pendingTurnStarts;
   activePrompts;
   steeringQueues;
@@ -37375,7 +38224,6 @@ var CodexAcpServer = class {
   providerUpdate = null;
   constructor(connection, codexAcpClient, defaultAuthRequest, getExitCode, getRecentStderr, codexProcessState) {
     this.sessions = /* @__PURE__ */ new Map();
-    this.pendingMcpStartupSessions = /* @__PURE__ */ new Map();
     this.pendingTurnStarts = /* @__PURE__ */ new Map();
     this.activePrompts = /* @__PURE__ */ new Map();
     this.steeringQueues = /* @__PURE__ */ new Map();
@@ -37387,12 +38235,25 @@ var CodexAcpServer = class {
     this.reportingConnection = new ToolCallReportingConnection(connection);
     this.connection = this.reportingConnection.asClientConnection();
     this.codexAcpClient = codexAcpClient;
+    this.mcpServerSignIn = createMcpServerSignIn(
+      this.connection,
+      () => this.codexAcpClient,
+      () => this.clientCapabilities
+    );
+    this.mcpSessionStartup = new McpSessionStartup(
+      this.connection,
+      () => this.codexAcpClient,
+      (operation) => this.runWithProcessCheck(operation),
+      this.mcpServerSignIn,
+      () => this.capabilities,
+      (sessionId) => this.sessions.has(sessionId) && !this.sessionIsClosing(sessionId)
+    );
     this.defaultAuthRequest = defaultAuthRequest ?? null;
     this.codexProcessState = codexProcessState ?? null;
     this.captureStderr();
     this.getExitCode = getExitCode ?? (() => this.codexProcessState?.connection.process.exitCode ?? null);
     this.getRecentStderr = getRecentStderr ?? (() => this.codexProcessState?.stderr ?? "");
-    this.sessionFailureEpoch = randomUUID2();
+    this.sessionFailureEpoch = randomUUID3();
     this.clientInfo = null;
     this.clientCapabilities = null;
     this.capabilities = ClientCapabilities.DEFAULT;
@@ -37406,7 +38267,8 @@ var CodexAcpServer = class {
       this.connection,
       client,
       (operation) => this.runWithProcessCheck(operation),
-      () => this.refreshAuthState(null)
+      () => this.refreshAuthState(null),
+      this.mcpServerSignIn
     );
   }
   async initialize(_params) {
@@ -37496,7 +38358,7 @@ var CodexAcpServer = class {
     }
     switch (methodRequest.method) {
       case "authentication/status":
-        return await this.runWithProcessCheck(() => this.codexAcpClient.getAuthenticationStatus());
+        return await this.readAuthenticationStatus();
       case "authentication/logout": {
         await this.logout({});
         return {};
@@ -37579,10 +38441,42 @@ var CodexAcpServer = class {
       }
     }
   }
+  /**
+   * Answers `authentication/status`.
+   *
+   * An unavailable account read still tells that the agent has a ChatGPT login, because only such a login
+   * runs the routing discovery, see {@link isAccountReadUnavailableError}. The answer is then `chat-gpt` with
+   * the email of the last known account, or an empty email. A read that failed because the login does not
+   * work answers `unauthenticated`, see {@link isAccountReadAuthFailureError}. Another error rejects.
+   */
+  async readAuthenticationStatus() {
+    try {
+      return await this.runWithProcessCheck(() => this.codexAcpClient.getAuthenticationStatus());
+    } catch (error62) {
+      if (isAccountReadUnavailableError(error62)) {
+        logger.log("Account read unavailable, so the authentication status uses the last known account", { error: String(error62) });
+        const account = this.lastReadAccount;
+        return { type: "chat-gpt", email: account?.type === "chatgpt" ? account.email ?? "" : "" };
+      }
+      if (isAccountReadAuthFailureError(error62)) {
+        logger.log("The account read found that the agent needs a login", { error: String(error62) });
+        return { type: "unauthenticated" };
+      }
+      throw error62;
+    }
+  }
+  /**
+   * Logs in with the default auth request, or throws `auth_required`, when the agent needs a login.
+   * Returns the account read that found no login needed, or `null` when there was no read or a login ran.
+   * Returns `"unavailable"` when the read failed without an answer about the login, see
+   * {@link isAccountReadUnavailableError}. The session open then continues: a missing login fails the
+   * resume or the first turn with the real error.
+   */
   async checkAuthorization() {
-    const authNeeded = await this.runWithProcessCheck(() => this.codexAcpClient.authRequired());
-    logger.log("Auth requirement checked", { authRequired: authNeeded });
-    if (authNeeded) {
+    const requirement = await this.readAccountOrUnavailable(() => this.codexAcpClient.readAuthRequirement());
+    if (requirement === "unavailable") return "unavailable";
+    logger.log("Auth requirement checked", { authRequired: requirement.required });
+    if (requirement.required) {
       if (this.defaultAuthRequest) {
         logger.log("Authenticating with default auth request...", {
           authRequest: this.defaultAuthRequest
@@ -37593,7 +38487,9 @@ var CodexAcpServer = class {
         logger.log("Authentication required but no default auth request provided, return to IDE");
         throw RequestError.authRequired();
       }
+      return null;
     }
+    return requirement.account;
   }
   async getOrCreateSession(request) {
     try {
@@ -37681,7 +38577,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
   async tryCreateSession(request, operation = "sessionId" in request ? "resume" : "new") {
     const existingSessionRequest = request;
     const requestedSessionGeneration = operation === "resume" ? this.beginSessionOpen(existingSessionRequest.sessionId) : null;
-    await this.checkAuthorization();
+    const knownAccount = await this.checkAuthorization();
     const requestedMcpServers = request.mcpServers ?? [];
     const mcpServerStartupVersion = requestedMcpServers.length > 0 ? this.codexAcpClient.getMcpServerStartupVersion() : null;
     let sessionMetadata;
@@ -37713,7 +38609,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const authProvider = sessionMetadata.modelProvider ?? this.codexAcpClient.getModelProvider();
     let authState;
     try {
-      authState = await this.getAuthStateForProvider(authProvider);
+      authState = await this.getAuthStateForProvider(authProvider, knownAccount);
     } catch (err) {
       if (resumeSubscribed && requestedSessionGeneration !== null) {
         await this.cleanupStaleSessionOpen(sessionId, requestedSessionGeneration);
@@ -37774,30 +38670,21 @@ Check ${configPath} and project .codex directories, especially their config.toml
     resumeSubscribed = false;
     const canPublishSessionUpdates = operation !== "fork";
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
-      const pendingStartup = this.createPendingMcpStartupSession(
-        requestedMcpServers,
-        mcpServerStartupVersion
-      );
-      if (canPublishSessionUpdates) {
-        this.pendingMcpStartupSessions.set(sessionId, pendingStartup);
-      }
-      const startupAwaitTimeoutMs = parseMcpStartupAwaitTimeoutMs(request._meta);
-      if (startupAwaitTimeoutMs !== void 0 && startupAwaitTimeoutMs > 0) {
+      const startupWait = this.mcpSessionStartup.begin(sessionId, requestedMcpServers, mcpServerStartupVersion, {
+        publish: canPublishSessionUpdates,
+        awaitTimeoutMs: parseMcpStartupAwaitTimeoutMs(request._meta),
+        skippedServers: sessionMetadata.skippedMcpServers
+      });
+      if (startupWait !== null) {
         try {
-          await raceMcpStartupTimeout(pendingStartup.startup, startupAwaitTimeoutMs);
+          await startupWait;
         } catch (err) {
-          if (this.pendingMcpStartupSessions.get(sessionId) === pendingStartup) {
-            this.pendingMcpStartupSessions.delete(sessionId);
-          }
           await this.closeSession({ sessionId }).catch((closeError) => {
             logger.error(`Failed to close session ${sessionId} after a failed MCP startup wait`, closeError);
           });
           throw err;
         }
       }
-      if (canPublishSessionUpdates) {
-        this.publishMcpStartupStatusAsync(sessionId);
-      }
     }
     if (canPublishSessionUpdates) {
       this.publishAvailableCommandsAsync(sessionState, sessionGeneration);
@@ -37810,7 +38697,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const sessionModeState = sessionState.agentMode.toSessionModeState(sessionState.clientCapabilities.airClient);
     return [sessionId, sessionModelState, sessionModeState];
   }
-  async getAuthStateForProvider(authProvider) {
+  /**
+   * Reads the account of `authProvider` and pushes the auth status. `knownAccount` is an account read that
+   * the caller already has.
+   *
+   * When the read is unavailable, the adapter pushes no status, so the client keeps the last status.
+   * A `none` status would be false here: AIR shows a login request for it. The session keeps the
+   * account of the last read.
+   */
+  async getAuthStateForProvider(authProvider, knownAccount = null) {
     if (!this.authProviderUsesOpenAiAccount(authProvider)) {
       await this.publishAuthStatus(authProvider, null);
       return {
@@ -37818,13 +38713,96 @@ Check ${configPath} and project .codex directories, especially their config.toml
         authConfigured: true
       };
     }
-    const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
+    const accountResponse = knownAccount === "unavailable" ? null : knownAccount ?? await this.readAccountIfAvailable();
+    if (accountResponse === null) {
+      logger.log("No account read, so the auth status stays as it was");
+      return {
+        account: this.lastReadAccount,
+        authConfigured: true
+      };
+    }
+    this.lastReadAccount = accountResponse.account;
     await this.publishAuthStatus(authProvider, accountResponse.account);
     return {
       account: accountResponse.account,
       authConfigured: accountResponse.account !== null || !accountResponse.requiresOpenaiAuth
     };
   }
+  /** Reads the account, or returns `null` when the read failed without an answer about the login. */
+  async readAccountIfAvailable() {
+    const response = await this.readAccountOrUnavailable(() => this.codexAcpClient.getAccount());
+    return response === "unavailable" ? null : response;
+  }
+  /**
+   * Runs an account read, or returns `"unavailable"` when it failed without an answer about the login,
+   * see {@link isAccountReadUnavailableError}. Another error rejects.
+   */
+  async readAccountOrUnavailable(read) {
+    try {
+      return await this.runWithProcessCheck(read);
+    } catch (error62) {
+      if (!isAccountReadUnavailableError(error62)) throw error62;
+      logger.log("Account read unavailable, the login state is unknown", { error: String(error62) });
+      return "unavailable";
+    }
+  }
+  /**
+   * Applies the account read of a load that answered before the read ended.
+   *
+   * The answer applies only while the load is the current open of the session, and while no auth status
+   * was set after the read started. A close or a new load of the session makes the answer old.
+   * A newer status, from any source, also makes it old. An old answer changes nothing.
+   *
+   * - A read that found no login needed sets the account of the session and pushes the auth status.
+   * - A read that found that the agent needs a login (`auth_required`), or that failed because the login
+   *   does not work ({@link isAccountReadAuthFailureError}, for example a revoked token), clears the account
+   *   and pushes the `none` status at once, with no second read. The client then shows a login request,
+   *   as it does for an `auth_required` error of the load.
+   * - A read that failed because another client logged in or out reads the account again and pushes it.
+   * - An unavailable read changes nothing.
+   * - Any other failure is logged as an error and pushes nothing. It tells nothing sure about the login,
+   *   so the client keeps the last status.
+   */
+  applyLateAccountRead(sessionState, authorization, authStatusVersionAtStart) {
+    const sessionIsCurrent = () => this.sessions.get(sessionState.sessionId) === sessionState;
+    const answerIsCurrent = () => {
+      if (!sessionIsCurrent()) {
+        logger.log("A late account read ended after the load closed, so it changes nothing", { sessionId: sessionState.sessionId });
+        return false;
+      }
+      if (this.authStatusVersion !== authStatusVersionAtStart) {
+        logger.log("A late account read ended after a newer auth status, so it changes nothing", { sessionId: sessionState.sessionId });
+        return false;
+      }
+      return true;
+    };
+    void authorization.then(
+      async (knownAccount) => {
+        if (knownAccount === "unavailable" || !answerIsCurrent()) return;
+        const authState = await this.getAuthStateForProvider(sessionState.authProvider, knownAccount);
+        if (!sessionIsCurrent()) return;
+        sessionState.account = authState.account;
+        sessionState.authConfigured = authState.authConfigured;
+      },
+      async (error62) => {
+        if (!answerIsCurrent()) return;
+        if (isAuthRequiredError(error62) || isAccountReadAuthFailureError(error62)) {
+          logger.log("A late account read found that the agent needs a login", { error: String(error62) });
+          this.lastReadAccount = null;
+          sessionState.account = null;
+          sessionState.authConfigured = false;
+          await this.publishAuthStatus(sessionState.authProvider, null);
+          return;
+        }
+        if (isAccountReadAccountChangedError(error62)) {
+          logger.log("The account changed while a late account read ran, so the adapter reads it again");
+          await this.publishAuthStatusRead();
+          return;
+        }
+        logger.error("A late account read failed, so the auth status stays as it was", error62);
+      }
+    ).catch((error62) => logger.error("Failed to apply a late account read", error62));
+  }
   authProviderUsesOpenAiAccount(authProvider) {
     return authProvider === null || authProvider === "openai";
   }
@@ -37965,7 +38943,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
     } finally {
       if (this.getSessionGeneration(params.sessionId) === closeGeneration) {
         this.sessions.delete(params.sessionId);
-        this.pendingMcpStartupSessions.delete(params.sessionId);
+        this.mcpSessionStartup.close(params.sessionId);
+        this.codexAcpClient.appServerClient.mcpStartup.forgetThread(params.sessionId);
         this.pendingTurnStarts.delete(params.sessionId);
         this.activePrompts.delete(params.sessionId);
         this.steeringQueues.delete(params.sessionId);
@@ -37994,7 +38973,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     return {};
   }
   hasLocalSession(sessionId) {
-    return this.sessions.has(sessionId) || this.pendingMcpStartupSessions.has(sessionId) || this.pendingTurnStarts.has(sessionId) || this.activePrompts.has(sessionId) || this.hasPendingSessionOpen(sessionId) || this.sessionIsClosing(sessionId);
+    return this.sessions.has(sessionId) || this.mcpSessionStartup.isPending(sessionId) || this.pendingTurnStarts.has(sessionId) || this.activePrompts.has(sessionId) || this.hasPendingSessionOpen(sessionId) || this.sessionIsClosing(sessionId);
   }
   hasPendingSessionOpen(sessionId) {
     return this.sessionOpenGenerations.get(sessionId) === this.getSessionGeneration(sessionId);
@@ -38223,12 +39202,22 @@ Check ${configPath} and project .codex directories, especially their config.toml
    * Never rejects: an unreadable source means "nothing to report", not an
    * error. The client then keeps showing the last pushed value, or "not
    * reported" when there was none.
+   *
+   * A read that failed because the login does not work, for example a revoked
+   * token, is an answer: it pushes the `none` status, see
+   * {@link isAccountReadAuthFailureError}.
    */
   async publishAuthStatusRead() {
     let authStatus;
     try {
       authStatus = await this.readAgentAuthIdentity();
     } catch (error62) {
+      if (isAccountReadAuthFailureError(error62)) {
+        logger.log("The account read found that the agent needs a login", { error: String(error62) });
+        this.lastReadAccount = null;
+        await this.setAuthStatus(fromAccount(null));
+        return;
+      }
       logger.log("Cannot determine auth status", { error: String(error62) });
       return;
     }
@@ -38251,6 +39240,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return gatewayStatus(modelProvider);
     }
     const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
+    this.lastReadAccount = accountResponse.account;
     return fromAccount(accountResponse.account);
   }
   /**
@@ -38287,6 +39277,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
    * invalidate; only a gateway logout or a provider change does.
    */
   async applyAccountUpdated(notification) {
+    this.lastReadAccount = accountFromUpdated(notification, this.lastReadAccount);
     try {
       if (this.codexAcpClient.getAuthGatewayProviderName() !== null) {
         return;
@@ -38316,6 +39307,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
    * so no payload can equal it.
    */
   async setAuthStatus(next) {
+    this.authStatusVersion += 1;
     if (sameAuthStatus(this.currentAuthStatus, next)) {
       return;
     }
@@ -38783,18 +39775,30 @@ Check ${configPath} and project .codex directories, especially their config.toml
   }
   async getOrCreateSessionWithHistory(request) {
     const requestedSessionGeneration = this.beginSessionOpen(request.sessionId);
-    await this.checkAuthorization();
+    const loadStartedAt = performance.now();
+    const graceLeftMs = () => ACCOUNT_READ_LOAD_GRACE_MS - (performance.now() - loadStartedAt);
+    const authStatusVersionAtStart = this.authStatusVersion;
+    const authorization = this.defaultAuthRequest ? Promise.resolve(await this.checkAuthorization()) : this.checkAuthorization();
+    authorization.catch(() => {
+    });
     const requestedMcpServers = request.mcpServers ?? [];
     const mcpServerStartupVersion = requestedMcpServers.length > 0 ? this.codexAcpClient.getMcpServerStartupVersion() : null;
     logger.log(`Load existing session: ${request.sessionId}...`);
     let subscribed = false;
     let sessionMetadata;
+    let knownAccount;
     try {
-      sessionMetadata = await this.runWithProcessCheck(
-        () => this.codexAcpClient.loadSession(request, () => {
-          subscribed = true;
-        })
-      );
+      try {
+        sessionMetadata = await this.runWithProcessCheck(
+          () => this.codexAcpClient.loadSession(request, () => {
+            subscribed = true;
+          })
+        );
+      } catch (err) {
+        await settledWithin(authorization, graceLeftMs());
+        throw err;
+      }
+      knownAccount = await settledWithin(authorization, graceLeftMs());
     } catch (err) {
       if (subscribed) {
         await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
@@ -38805,7 +39809,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const authProvider = sessionMetadata.modelProvider ?? this.codexAcpClient.getModelProvider();
     let authState;
     try {
-      authState = await this.getAuthStateForProvider(authProvider);
+      authState = await this.getAuthStateForProvider(authProvider, knownAccount === "pending" ? "unavailable" : knownAccount);
     } catch (err) {
       if (subscribed) {
         await this.cleanupStaleSessionOpen(request.sessionId, requestedSessionGeneration);
@@ -38862,13 +39866,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
       () => sessionState.sessionTitleSource
     );
     this.installSessionState(sessionState);
+    if (knownAccount === "pending") {
+      this.applyLateAccountRead(sessionState, authorization, authStatusVersionAtStart);
+    }
     subscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
-      this.pendingMcpStartupSessions.set(
-        sessionId,
-        this.createPendingMcpStartupSession(requestedMcpServers, mcpServerStartupVersion)
-      );
-      this.publishMcpStartupStatusAsync(sessionId);
+      this.mcpSessionStartup.begin(sessionId, requestedMcpServers, mcpServerStartupVersion, {
+        publish: true,
+        skippedServers: sessionMetadata.skippedMcpServers
+      });
     }
     await this.publishAvailableCommands(sessionState, requestedSessionGeneration);
     await this.publishCurrentGoalBestEffort(sessionState, requestedSessionGeneration, true);
@@ -39017,7 +40023,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
   }
   async publishThreadHistoryTitle(session, sessionState, thread, firstItems) {
-    const explicitTitle = this.normalizeSessionTitle(thread.name);
+    const explicitTitle = normalizeSessionTitle(thread.name);
     if (explicitTitle) {
       sessionState.sessionTitle = explicitTitle;
       sessionState.sessionTitleSource = "explicit";
@@ -39028,13 +40034,13 @@ Check ${configPath} and project .codex directories, especially their config.toml
       });
       return;
     }
-    const historyTitle = this.findFirstUserMessageTitle(firstItems) ?? this.normalizeSessionTitle(thread.preview);
+    const historyTitle = this.findFirstUserMessageTitle(firstItems) ?? normalizeSessionTitle(thread.preview);
     await this.publishFallbackSessionTitle(sessionState, historyTitle);
   }
   findFirstUserMessageTitle(items) {
     for (const item of items) {
       if (item.type !== "userMessage") continue;
-      const title = this.normalizeSessionTitle(item.content.filter((input2) => input2.type === "text").map((input2) => input2.text).join(" "));
+      const title = normalizeSessionTitle(item.content.filter((input2) => input2.type === "text").map((input2) => input2.text).join(" "));
       if (title) return title;
     }
     return null;
@@ -39081,11 +40087,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
   }
   createPromptFallbackTitle(prompt) {
-    return this.normalizeSessionTitle(prompt.filter((block) => block.type === "text").map((block) => block.text).join(" "));
-  }
-  normalizeSessionTitle(title) {
-    const normalized = title?.replace(/\s+/g, " ").trim() ?? "";
-    return normalized.length > 0 ? normalized : null;
+    return normalizeSessionTitle(prompt.filter((block) => block.type === "text").map((block) => block.text).join(" "));
   }
   async createHistoryUpdates(item, sessionState) {
     const renderer = new AcpToolCallRenderer(sessionState.clientCapabilities);
@@ -39240,102 +40242,6 @@ Check ${configPath} and project .codex directories, especially their config.toml
     logger.log("Skipping MCP server recovery for load/resume without explicit mcpServers");
     return [];
   }
-  publishMcpStartupStatusAsync(sessionId) {
-    void this.doPublishMcpStartupStatus(sessionId);
-  }
-  createPendingMcpStartupSession(mcpServers, afterVersion) {
-    const requestedServers = new Set(getRequestedMcpServerNames(mcpServers));
-    return {
-      requestedServers,
-      startup: this.runWithProcessCheck(
-        () => this.codexAcpClient.awaitMcpServerStartup(Array.from(requestedServers), afterVersion)
-      )
-    };
-  }
-  async doPublishMcpStartupStatus(sessionId) {
-    const pendingStartup = this.pendingMcpStartupSessions.get(sessionId);
-    if (!pendingStartup) {
-      return;
-    }
-    try {
-      const mcpStartup = await pendingStartup.startup;
-      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 {
-      if (this.pendingMcpStartupSessions.get(sessionId) === pendingStartup) {
-        this.pendingMcpStartupSessions.delete(sessionId);
-      }
-    }
-  }
-  async publishMcpStartupStatus(sessionId, mcpStartup, requestedServers) {
-    const filteredStartup = requestedServers ? {
-      ready: mcpStartup.ready.filter((server) => requestedServers.has(server)),
-      failed: mcpStartup.failed.filter((server) => requestedServers.has(server.server)),
-      cancelled: mcpStartup.cancelled.filter((server) => requestedServers.has(server))
-    } : mcpStartup;
-    const failuresAfterOauth = [];
-    const readyAfterOauth = [...filteredStartup.ready];
-    for (const failure3 of filteredStartup.failed) {
-      if (failure3.failureReason !== "reauthenticationRequired" || !clientSupportsUrlElicitation(this.clientCapabilities)) {
-        failuresAfterOauth.push(failure3);
-        continue;
-      }
-      try {
-        const authenticated = await this.authenticateMcpServer(sessionId, failure3.server);
-        if (authenticated) {
-          readyAfterOauth.push(failure3.server);
-        } else {
-          failuresAfterOauth.push(failure3);
-        }
-      } catch (error62) {
-        logger.error(`Failed to authenticate MCP server ${failure3.server}`, error62);
-        failuresAfterOauth.push(failure3);
-      }
-    }
-    const renderer = new AcpToolCallRenderer(this.capabilities);
-    for (const facts4 of McpStartupReporter.failures({
-      ...filteredStartup,
-      ready: readyAfterOauth,
-      failed: failuresAfterOauth
-    })) {
-      await this.connection.notify(methods.client.session.update, {
-        sessionId,
-        update: renderer.render(facts4)
-      });
-    }
-  }
-  async authenticateMcpServer(sessionId, serverName) {
-    const elicitationId = `mcp-oauth-${randomUUID2()}`;
-    const completed = this.codexAcpClient.awaitMcpServerOauthLoginCompleted(serverName, sessionId);
-    const login2 = await this.codexAcpClient.mcpServerOauthLogin({
-      name: serverName,
-      threadId: sessionId
-    });
-    const elicitation = Promise.resolve(this.connection.request(
-      methods.client.elicitation.create,
-      {
-        mode: "url",
-        sessionId,
-        message: `Authenticate with MCP server ${serverName}`,
-        url: login2.authorizationUrl,
-        elicitationId
-      }
-    ));
-    const first = await Promise.race([
-      completed.then((result2) => ({ type: "completed", result: result2 })),
-      elicitation.then((response) => ({ type: "elicitation", response }))
-    ]);
-    if (first.type === "elicitation" && !CreateElicitationResponse.isAccept(first.response)) {
-      return false;
-    }
-    const result = first.type === "completed" ? first.result : await completed;
-    await this.connection.notify(methods.client.elicitation.complete, { elicitationId });
-    return result.success;
-  }
   trackActivePrompt(sessionId) {
     let resolveCompletion = () => {
     };
@@ -39622,6 +40528,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         return cancelledPromptResponse();
       }
       const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
+        signal: activePrompt.signal,
         onTurnStartPending: () => {
           sessionState.lastTokenUsage = null;
           ensurePendingTurnStart();
@@ -40058,41 +40965,6 @@ ${stderr}` : "";
     await this.interruptSessionTurn(sessionState, "Cancel", false);
   }
 };
-function getRequestedMcpServerNames(mcpServers) {
-  return Array.from(new Set(mcpServers.map((server) => sanitizeMcpServerName(server.name))));
-}
-var MCP_STARTUP_AWAIT_TIMEOUT_META_KEY = "mcpStartupAwaitTimeoutMs";
-function parseMcpStartupAwaitTimeoutMs(meta3) {
-  const value = meta3?.[MCP_STARTUP_AWAIT_TIMEOUT_META_KEY];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function raceMcpStartupTimeout(startup, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        resolve();
-      }
-    }, timeoutMs);
-    startup.then(
-      () => {
-        if (!settled) {
-          settled = true;
-          clearTimeout(timer);
-          resolve();
-        }
-      },
-      (err) => {
-        if (!settled) {
-          settled = true;
-          clearTimeout(timer);
-          reject(err);
-        }
-      }
-    );
-  });
-}
 var SessionClosedDuringLoadError = class extends Error {
   constructor() {
     super("The session closed during the history load");