@agentclientprotocol/codex-acp 1.8.0 → 1.10.0

package/dist/index.js

@@ -22131,32 +22131,7 @@ function attachLogs(proc) {
   });
 }
 
-// src/AirExtension.ts
-var JETBRAINS_META_KEY = "jetbrains";
-var AIR_META_KEY = "air";
-var AIR_EXTENSION_VERSION_KEY = "version";
-var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
-var AIR_SESSION_FAILURE_KEY = "sessionFailure";
-var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
-var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
-var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
-var AIR_EXTENSION_VERSION = 1;
-function clientSupportsAirCapability(capabilities, capability) {
-  const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
-  const air = jetbrains?.[AIR_META_KEY];
-  const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
-  const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
-  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
-}
-
-// src/subagents/AcpSubagents.ts
-function clientSupportsSubagents(capabilities) {
-  const subagents = capabilities?.subagents;
-  if (typeof subagents === "object" && subagents !== null && !Array.isArray(subagents)) {
-    return true;
-  }
-  return clientSupportsAirCapability(capabilities, AIR_NATIVE_SUBAGENT_SESSIONS_KEY);
-}
+// src/AcpSessionExtensions.ts
 function asSdkSessionNotification(notification) {
   return notification;
 }
@@ -23676,6 +23651,26 @@ function sameThreadGoalSnapshot(left, right) {
 // src/CodexEventHandler.ts
 import { randomUUID } from "node:crypto";
 
+// src/AirExtension.ts
+var JETBRAINS_META_KEY = "jetbrains";
+var AIR_META_KEY = "air";
+var AIR_EXTENSION_VERSION_KEY = "version";
+var AIR_EXTENSION_CAPABILITIES_KEY = "capabilities";
+var AIR_SESSION_FAILURE_KEY = "sessionFailure";
+var AIR_AGENT_FILE_CHANGE_REPORT_KEY = "agentFileChangeReport";
+var AIR_NATIVE_SUBAGENT_SESSIONS_KEY = "nativeSubagentSessions";
+var AIR_ASYNC_TASKS_KEY = "asyncTasks";
+var AIR_ASYNC_TASKS_BACKGROUNDED_KEY = "backgrounded";
+var AIR_AGENT_FILE_CHANGE_REPORT_REQUEST_KEY = "agentFileChangeReportRequest";
+var AIR_EXTENSION_VERSION = 1;
+function clientSupportsAirCapability(capabilities, capability) {
+  const jetbrains = capabilities?._meta?.[JETBRAINS_META_KEY];
+  const air = jetbrains?.[AIR_META_KEY];
+  const version2 = air?.[AIR_EXTENSION_VERSION_KEY];
+  const supported = air?.[AIR_EXTENSION_CAPABILITIES_KEY];
+  return typeof version2 === "number" && Number.isInteger(version2) && version2 >= AIR_EXTENSION_VERSION && Array.isArray(supported) && supported.includes(capability);
+}
+
 // src/subagents/CodexAgentPath.ts
 function normalizeAgentPath(path9) {
   const normalized = path9.trim().replace(/\/+$/, "");
@@ -23731,14 +23726,14 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
       }
       return childTurn;
     }
-    const notificationThreadId = notification.params.threadId;
-    if (typeof notificationThreadId === "string" && this.pendingSpawns.has(notificationThreadId)) {
-      const pending = this.pendingSpawns.get(notificationThreadId);
+    const notificationThreadId2 = notification.params.threadId;
+    if (typeof notificationThreadId2 === "string" && this.pendingSpawns.has(notificationThreadId2)) {
+      const pending = this.pendingSpawns.get(notificationThreadId2);
       if (pending.buffered.length === _CodexSubagentEventRouter.MAX_PENDING_NOTIFICATIONS) {
         pending.buffered.shift();
         pending.droppedBufferedNotifications += 1;
         if (pending.droppedBufferedNotifications === 1) {
-          logger.log(`Pending subagent ${notificationThreadId} exceeded the notification buffer; dropping oldest updates`);
+          logger.log(`Pending subagent ${notificationThreadId2} exceeded the notification buffer; dropping oldest updates`);
         }
       }
       pending.buffered.push(notification);
@@ -23823,6 +23818,25 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
     const threadId = notification.params.threadId;
     return typeof threadId === "string" && this.children.has(threadId) ? this.children.get(threadId).sessionId : this.rootSessionId;
   }
+  closingChildSessions(notification) {
+    if (!this.supported) return [];
+    if (notification.method === "turn/completed") {
+      if (terminalStateFromTurn(notification.params.turn.status) === void 0) return [];
+      return this.closingChildSession(notification.params.threadId);
+    }
+    if (notification.method !== "item/started" && notification.method !== "item/completed") return [];
+    const item = notification.params.item;
+    if (item.type === "subAgentActivity") {
+      return item.kind === "interrupted" ? this.closingChildSession(item.agentThreadId) : [];
+    }
+    if (item.type !== "collabAgentToolCall") return [];
+    const closing = /* @__PURE__ */ new Map();
+    for (const [threadId, state] of Object.entries(item.agentsStates)) {
+      if (!state || terminalStateOf(state.status) === void 0) continue;
+      for (const child of this.closingChildSession(threadId)) closing.set(threadId, child);
+    }
+    return [...closing.values()];
+  }
   takeBufferedNotifications() {
     return this.replayQueue.splice(0);
   }
@@ -23898,6 +23912,10 @@ var CodexSubagentEventRouter = class _CodexSubagentEventRouter {
   isKnownChild(threadId) {
     return threadId !== this.rootSessionId && (this.children.has(threadId) || this.pendingSpawns.has(threadId) || this.terminalPendingSpawns.has(threadId));
   }
+  closingChildSession(threadId) {
+    const child = this.children.get(threadId);
+    return child && child.terminalState === void 0 ? [{ threadId, sessionId: child.sessionId }] : [];
+  }
   async materialize(childSessionId, path9) {
     if (this.children.has(childSessionId)) return;
     const pending = this.pendingSpawns.get(childSessionId);
@@ -24051,6 +24069,37 @@ function fallbackName(sessionId) {
   return `Agent ${suffix}`;
 }
 
+// src/RateLimitsMap.ts
+function rateLimitId(snapshot, fallback = "codex") {
+  return snapshot.limitId ?? fallback;
+}
+function createRateLimitsMap(response) {
+  const result = /* @__PURE__ */ new Map();
+  const snapshots = Object.entries(response.rateLimitsByLimitId ?? {}).filter((entry) => entry[1] !== void 0);
+  if (snapshots.length === 0) {
+    snapshots.push([rateLimitId(response.rateLimits), response.rateLimits]);
+  }
+  for (const [fallbackId, snapshot] of snapshots) {
+    const limitId = rateLimitId(snapshot, fallbackId);
+    result.set(limitId, {
+      limitId,
+      limitName: snapshot.limitName ?? limitId,
+      snapshot
+    });
+  }
+  return result;
+}
+function mergeRateLimitSnapshot(previous, update) {
+  return {
+    ...update,
+    limitId: update.limitId ?? "codex",
+    credits: update.credits ?? previous.credits,
+    individualLimit: update.individualLimit ?? previous.individualLimit,
+    spendControlReached: update.spendControlReached ?? previous.spendControlReached,
+    planType: update.planType ?? previous.planType
+  };
+}
+
 // src/CodexEventHandler.ts
 var MAX_SESSION_FAILURE_TITLE_LENGTH = 240;
 var SESSION_FAILURE_POLICY = {
@@ -24159,11 +24208,14 @@ var CodexEventHandler = class _CodexEventHandler {
   terminalCommandOutputIds = /* @__PURE__ */ new Set();
   agentMessagePhases = /* @__PURE__ */ new Map();
   subagents;
+  /** Connection-level `authStatus` sink; the app-server account push feeds it. */
+  onAccountUpdated;
   constructor(connection, sessionState, supportsPlanUpdates = false, supportsTypedSessionFailures = false, sessionFailureEpoch = randomUUID(), subagents = new CodexSubagentEventRouter(
     sessionState.sessionId,
     false,
     new ACPSessionConnection(connection, sessionState.sessionId)
-  )) {
+  ), onAccountUpdated) {
+    this.onAccountUpdated = onAccountUpdated;
     this.sessionState = sessionState;
     this.supportsPlanUpdates = supportsPlanUpdates;
     this.supportsTypedSessionFailures = supportsTypedSessionFailures;
@@ -24272,17 +24324,29 @@ var CodexEventHandler = class _CodexEventHandler {
   }
   async handleNotification(notification) {
     await this.flushPendingErrors();
+    const closingChildren = this.subagents.closingChildSessions(notification);
+    for (const child of closingChildren) {
+      await this.sessionState.asyncTasks.reconcile(child.threadId, child.sessionId);
+    }
     const handledBySubagents = await this.subagents.handle(notification);
     for (const buffered of this.subagents.takeBufferedNotifications()) {
       await this.handleNotification(buffered);
     }
-    if (handledBySubagents) {
-      return;
+    const ignoredBySubagents = !handledBySubagents && this.subagents.shouldIgnore(notification);
+    let updateEvent;
+    if (!handledBySubagents && !ignoredBySubagents && notification.method === "item/started" && notification.params.item.type === "commandExecution") {
+      updateEvent = await this.createUpdateEvent(notification);
     }
-    if (this.subagents.shouldIgnore(notification)) {
-      return;
+    if (!handledBySubagents) {
+      await this.sessionState.asyncTasks.handleNotification(
+        notification,
+        this.subagents.notificationSessionId(notification),
+        toolCallTitle(updateEvent)
+      );
     }
-    const updateEvent = await this.createUpdateEvent(notification);
+    if (handledBySubagents) return;
+    if (ignoredBySubagents) return;
+    if (updateEvent === void 0) updateEvent = await this.createUpdateEvent(notification);
     if (updateEvent) {
       await this.session.update(updateEvent, this.subagents.notificationSessionId(notification));
     }
@@ -24387,6 +24451,9 @@ var CodexEventHandler = class _CodexEventHandler {
       case "account/rateLimits/updated":
         this.handleRateLimitsUpdated(notification.params);
         return null;
+      case "account/updated":
+        this.onAccountUpdated?.(notification.params);
+        return null;
       case "configWarning":
         return await this.createConfigWarningEvent(notification.params);
       case "warning":
@@ -24437,7 +24504,6 @@ var CodexEventHandler = class _CodexEventHandler {
       case "turn/moderationMetadata":
       case "item/fileChange/outputDelta":
       case "item/fileChange/patchUpdated":
-      case "account/updated":
       case "fs/changed":
       case "mcpServer/startupStatus/updated":
       case "mcpServer/event/stream/notification":
@@ -25083,11 +25149,13 @@ ${event.stdin}
     if (!this.sessionState.rateLimits) {
       this.sessionState.rateLimits = /* @__PURE__ */ new Map();
     }
-    const limitId = params.rateLimits.limitId ?? params.rateLimits.limitName ?? "unknown";
+    const limitId = params.rateLimits.limitId ?? "codex";
+    const existingEntry = this.sessionState.rateLimits.get(limitId);
+    const snapshot = existingEntry ? mergeRateLimitSnapshot(existingEntry.snapshot, params.rateLimits) : { ...params.rateLimits, limitId };
     this.sessionState.rateLimits.set(limitId, {
       limitId,
-      limitName: params.rateLimits.limitName ?? limitId,
-      snapshot: params.rateLimits
+      limitName: snapshot.limitName ?? existingEntry?.limitName ?? limitId,
+      snapshot
     });
   }
   handleFuzzyFileSearchSessionUpdated(params) {
@@ -25115,6 +25183,10 @@ ${event.stdin}
     return createGuardianApprovalReviewToolCall(params);
   }
 };
+function toolCallTitle(update) {
+  if (update?.sessionUpdate !== "tool_call") return void 0;
+  return update.title;
+}
 
 // src/permissions/option-ids.ts
 var ApprovalOptionId = {
@@ -27247,7 +27319,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.8.0",
+  version: "1.10.0",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -27310,7 +27382,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.4.0",
-    "@openai/codex": "^0.152.0",
+    "@openai/codex": "^0.153.3",
     diff: "^9.0.0",
     open: "^11.0.1",
     "vscode-jsonrpc": "^9.0.1",
@@ -27908,6 +27980,12 @@ var CodexAcpClient = class {
   config;
   modelProvider;
   gatewayConfig;
+  /**
+   * Where the stored gateway routing came from: the `gateway` auth method
+   * (agent-owned authentication) or the ACP `providers/*` API (client-driven
+   * routing). `authStatus` reports only the agent-owned one.
+   */
+  gatewayConfigSource;
   pendingLoginCompleted = null;
   pendingAccountUpdated = null;
   sessionNotificationQueues = /* @__PURE__ */ new Map();
@@ -27919,6 +27997,7 @@ var CodexAcpClient = class {
     this.config = codexConfig ?? {};
     this.modelProvider = modelProvider ?? null;
     this.gatewayConfig = null;
+    this.gatewayConfigSource = null;
     this.subagents = new CodexSubagentSubscriptions(codexClient);
   }
   get appServerClient() {
@@ -27951,6 +28030,7 @@ var CodexAcpClient = class {
       throw RequestError.invalidRequest();
     }
     this.gatewayConfig = null;
+    this.gatewayConfigSource = null;
     switch (authRequest.methodId) {
       case "api-key":
         return await this.authenticateWithApiKey(authRequest);
@@ -28034,7 +28114,7 @@ var CodexAcpClient = class {
       apiType: GatewayAuthMethod._meta.gateway.protocol,
       headers: gatewaySettings.headers,
       providerName: gatewaySettings.providerName
-    });
+    }, "authentication");
     return true;
   }
   readApiKeyFromEnv() {
@@ -28080,6 +28160,11 @@ var CodexAcpClient = class {
         };
     }
   }
+  /**
+   * The provider that actually serves requests, ACP-configured gateway
+   * routing included. Use {@link getAgentConfiguredModelProvider} instead
+   * when asking what the agent itself is configured with (`authStatus`).
+   */
   async getCurrentModelProvider() {
     const sessionModelProvider = this.getModelProvider();
     if (sessionModelProvider !== null) {
@@ -28105,7 +28190,7 @@ var CodexAcpClient = class {
    * method and the ACP `providers/set` method. Throws `invalid_params` for an
    * unsupported protocol or a malformed base URL.
    */
-  applyGatewayConfig(params) {
+  applyGatewayConfig(params, source) {
     const apiType = params.apiType;
     const wireApi = SUPPORTED_GATEWAY_PROTOCOLS[apiType];
     if (!wireApi) {
@@ -28122,6 +28207,7 @@ var CodexAcpClient = class {
       "X-Client-Feature-ID": "codex",
       ...params.headers
     };
+    this.gatewayConfigSource = source;
     this.gatewayConfig = {
       modelProvider: CUSTOM_GATEWAY_PROVIDER_ID,
       config: {
@@ -28186,7 +28272,7 @@ var CodexAcpClient = class {
       apiType: request.apiType,
       baseUrl: request.baseUrl,
       headers: request.headers
-    });
+    }, "acpProviders");
     logger.log("providers/set applied", {
       providerId: request.providerId,
       apiType: request.apiType,
@@ -28202,6 +28288,7 @@ var CodexAcpClient = class {
     const overrideWasActive = this.gatewayConfig !== null;
     if (request.providerId === OPENAI_PROVIDER_ID) {
       this.gatewayConfig = null;
+      this.gatewayConfigSource = null;
     }
     const current = this.gatewayConfig ? {
       apiType: gatewayApiTypeFromConfig(this.gatewayConfig),
@@ -28219,6 +28306,36 @@ var CodexAcpClient = class {
   async getAccount() {
     return this.codexClient.accountRead({ refreshToken: false });
   }
+  async getRateLimits() {
+    return this.codexClient.accountRateLimitsRead();
+  }
+  /**
+   * Presentable name of the gateway the agent itself authenticated against
+   * (the `gateway` auth method), or `null`. Routing that the client
+   * configured through `providers/set` is deliberately not reported here:
+   * `authStatus` describes the agent-owned login only.
+   */
+  getAuthGatewayProviderName() {
+    return this.gatewayConfigSource === "authentication" ? this.gatewayConfig?.config.name ?? null : null;
+  }
+  /** Whether this provider id is client-driven routing set through `providers/set`. */
+  isClientConfiguredProvider(providerId) {
+    return providerId === CUSTOM_GATEWAY_PROVIDER_ID && this.gatewayConfigSource === "acpProviders";
+  }
+  /**
+   * The model provider the agent itself is configured with (launch option or
+   * Codex config), ignoring any ACP-configured gateway routing. The
+   * routing-aware counterpart is {@link getCurrentModelProvider}.
+   */
+  async getAgentConfiguredModelProvider() {
+    const provider = this.getModelProvider();
+    const agentProvider = this.isClientConfiguredProvider(provider) ? this.modelProvider : provider;
+    if (agentProvider !== null) {
+      return agentProvider;
+    }
+    const settingsModelProvider = await this.codexClient.configRead({ includeLayers: false });
+    return settingsModelProvider?.config?.model_provider ?? null;
+  }
   async resumeSession(request, onSubscribed) {
     const additionalDirectories = readAdditionalDirectories(request.cwd, request.additionalDirectories, request._meta);
     await this.refreshSkills(request.cwd, additionalDirectories);
@@ -29408,6 +29525,12 @@ var CodexAppServerClient = class {
   async threadCompactStart(params) {
     return await this.sendRequest({ method: "thread/compact/start", params });
   }
+  async threadBackgroundTerminalsList(params) {
+    return await this.sendRequest({ method: "thread/backgroundTerminals/list", params });
+  }
+  async threadBackgroundTerminalsTerminate(params) {
+    return await this.sendRequest({ method: "thread/backgroundTerminals/terminate", params });
+  }
   async threadGoalSet(params) {
     return await this.sendRequest({ method: "thread/goal/set", params });
   }
@@ -29473,6 +29596,9 @@ var CodexAppServerClient = class {
   async accountRead(params) {
     return await this.sendRequest({ method: "account/read", params });
   }
+  async accountRateLimitsRead() {
+    return await this.sendRequest({ method: "account/rateLimits/read", params: void 0 });
+  }
   //TODO create type-safe helper
   async awaitTurnCompleted(threadId, turnId) {
     return await new Promise((resolve) => {
@@ -30079,6 +30205,7 @@ var CodexCommands = class {
         return { handled: true, turnCompleted };
       }
       case "status": {
+        await this.refreshRateLimits(sessionState);
         const session = new ACPSessionConnection(this.connection, sessionId);
         const message = this.buildStatusMessage(sessionState);
         await session.update(createAgentTextMessageChunk(message));
@@ -30227,6 +30354,16 @@ var CodexCommands = class {
     ];
     return lines.join("  \n");
   }
+  async refreshRateLimits(sessionState) {
+    try {
+      const response = await this.runWithProcessCheck(() => this.codexAcpClient.getRateLimits());
+      if (response) {
+        sessionState.rateLimits = createRateLimitsMap(response);
+      }
+    } catch (err) {
+      logger.error(`Failed to refresh rate limits for session ${sessionState.sessionId}`, err);
+    }
+  }
   formatAccountInfo(account) {
     if (!account) {
       return "not logged in";
@@ -30257,10 +30394,10 @@ var CodexCommands = class {
       return "data not available yet";
     }
     const used = usage.totalTokens;
-    const percentLeft = Math.round((contextWindow - used) / contextWindow * 100);
+    const percentUsed = Math.round(used / contextWindow * 100);
     const usedFormatted = this.formatTokenCount(used);
     const totalFormatted = this.formatTokenCount(contextWindow);
-    return `${percentLeft}% left (${usedFormatted} used / ${totalFormatted})`;
+    return `${percentUsed}% used (${usedFormatted} used / ${totalFormatted})`;
   }
   formatRateLimitLines(rateLimits) {
     if (!rateLimits || rateLimits.size === 0) {
@@ -30294,8 +30431,31 @@ var CodexCommands = class {
         lines.push(`**${prefix}Credits:** ${rateLimits.credits.balance}`);
       }
     }
+    if (rateLimits.individualLimit) {
+      const limit = rateLimits.individualLimit;
+      const used = this.formatCreditAmount(limit.used);
+      const total = this.formatCreditAmount(limit.limit);
+      if (used !== null && total !== null) {
+        const percentLeft = Math.round(Math.min(100, Math.max(0, limit.remainingPercent)));
+        const resetDate = new Date(limit.resetsAt * 1e3).toLocaleDateString("en-US", { month: "short", day: "numeric" });
+        lines.push(
+          `**${prefix}individual spend limit:** ${percentLeft}% left (${used} of ${total} credits used; resets ${resetDate})`
+        );
+      }
+    }
     return lines;
   }
+  formatCreditAmount(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      return null;
+    }
+    const value = Number(trimmed);
+    if (!Number.isFinite(value) || value < 0) {
+      return null;
+    }
+    return Math.round(value).toLocaleString("en-US");
+  }
   formatWindowLabel(windowDurationMins) {
     if (windowDurationMins === null) {
       return "Limit";
@@ -31342,11 +31502,147 @@ function numberValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
+// src/async-tasks/AsyncTaskExtension.ts
+var ASYNC_TASK_STOP_METHOD = "_session/async_task/stop";
+
+// src/AuthStatusMeta.ts
+var AUTH_STATUS_UPDATE_METHOD = "_auth/status_update";
+var AUTH_STATUS_META_KEY = "authStatus";
+function authStatusCapability() {
+  return {};
+}
+var NOT_LOGGED_IN_LABEL = "Not logged in";
+var DEFAULT_GATEWAY_LABEL = "Custom model gateway";
+var PLAN_DISPLAY_NAMES = {
+  free: "Free",
+  go: "Go",
+  plus: "Plus",
+  pro: "Pro",
+  team: "Team",
+  business: "Business",
+  enterprise: "Enterprise",
+  edu: "Edu"
+};
+function planTypePresentable(planType) {
+  if (!planType || planType === "unknown") {
+    return null;
+  }
+  return PLAN_DISPLAY_NAMES[planType] ?? capitalize2(planType);
+}
+function capitalize2(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function chatGptLabel(planType) {
+  const plan = planTypePresentable(planType);
+  return plan === null ? "ChatGPT" : `ChatGPT ${plan}`;
+}
+function gatewayStatus(providerName) {
+  const detail = typeof providerName === "string" && providerName.trim().length > 0 ? providerName.trim() : void 0;
+  return {
+    kind: "gateway",
+    label: DEFAULT_GATEWAY_LABEL,
+    ...detail === void 0 ? {} : { detail }
+  };
+}
+function unauthenticatedStatus() {
+  return {
+    kind: "none",
+    label: NOT_LOGGED_IN_LABEL
+  };
+}
+function fromAccount(account) {
+  if (account === null) {
+    return unauthenticatedStatus();
+  }
+  switch (account.type) {
+    case "chatgpt": {
+      const accountInfo = {};
+      if (account.email) {
+        accountInfo.email = account.email;
+      }
+      if (account.planType) {
+        accountInfo.plan = account.planType;
+      }
+      return {
+        kind: "account",
+        label: chatGptLabel(account.planType),
+        ...Object.keys(accountInfo).length > 0 ? { account: accountInfo } : {}
+      };
+    }
+    case "apiKey":
+      return {
+        kind: "api_key",
+        label: "OpenAI API key"
+      };
+    case "amazonBedrock":
+      return {
+        kind: "external",
+        label: "AWS Bedrock"
+      };
+  }
+}
+function fromAccountUpdated(notification, previous) {
+  const authMode = notification.authMode;
+  if (authMode === null) {
+    return unauthenticatedStatus();
+  }
+  switch (authMode) {
+    case "chatgpt":
+    case "chatgptAuthTokens": {
+      const status = {
+        kind: "account",
+        label: chatGptLabel(notification.planType)
+      };
+      const accountInfo = {};
+      const previousEmail = previous?.kind === "account" ? previous.account?.email : void 0;
+      if (previousEmail) {
+        accountInfo.email = previousEmail;
+      }
+      if (notification.planType) {
+        accountInfo.plan = notification.planType;
+      }
+      if (Object.keys(accountInfo).length > 0) {
+        status.account = accountInfo;
+      }
+      return status;
+    }
+    case "apikey":
+      return {
+        kind: "api_key",
+        label: "OpenAI API key"
+      };
+    case "personalAccessToken":
+      return {
+        kind: "api_key",
+        label: "OpenAI personal access token"
+      };
+    case "bedrockApiKey":
+    case "bedrockAccessKeys":
+      return {
+        kind: "external",
+        label: "AWS Bedrock"
+      };
+    case "agentIdentity":
+      return {
+        kind: "external",
+        label: "Agent identity"
+      };
+    case "headers":
+      return gatewayStatus();
+  }
+}
+function sameAuthStatus(previous, next) {
+  if (!previous) {
+    return false;
+  }
+  return previous.kind === next.kind && previous.label === next.label && previous.detail === next.detail && previous.account?.email === next.account?.email && previous.account?.organization === next.account?.organization && previous.account?.plan === next.account?.plan && JSON.stringify(previous.vendor) === JSON.stringify(next.vendor);
+}
+
 // src/AcpExtensions.ts
 var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
 var SESSION_STEERING_METHOD = "_session/steering";
 function isExtMethodRequest(request) {
-  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === LEGACY_GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD;
+  return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === LEGACY_GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD || request.method === ASYNC_TASK_STOP_METHOD;
 }
 
 // src/FastModeConfig.ts
@@ -31413,6 +31709,15 @@ function clientSupportsPlanUpdates(clientCapabilities) {
   return clientCapabilities?.plan != null;
 }
 
+// src/subagents/AcpSubagents.ts
+function clientSupportsSubagents(capabilities) {
+  const subagents = capabilities?.subagents;
+  if (typeof subagents === "object" && subagents !== null && !Array.isArray(subagents)) {
+    return true;
+  }
+  return clientSupportsAirCapability(capabilities, AIR_NATIVE_SUBAGENT_SESSIONS_KEY);
+}
+
 // src/CodexAcpServer.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
@@ -31501,6 +31806,332 @@ function extractTitle(turn) {
 
 // src/CodexAcpServer.ts
 import { once } from "node:events";
+
+// src/async-tasks/CodexBackgroundTerminalTasks.ts
+var CodexBackgroundTerminalTasks = class {
+  constructor(enabled, rootSessionId, appServer, session) {
+    this.enabled = enabled;
+    this.rootSessionId = rootSessionId;
+    this.appServer = appServer;
+    this.session = session;
+  }
+  enabled;
+  rootSessionId;
+  appServer;
+  session;
+  tasks = /* @__PURE__ */ new Map();
+  syncs = /* @__PURE__ */ new Map();
+  appServerGeneration = 0;
+  appServerQueriesEnabled = true;
+  disposed = false;
+  async handleNotification(notification, sessionId, commandTitle2) {
+    if (!this.isActive()) return;
+    const threadId = notificationThreadId(notification);
+    if (threadId === null) return;
+    if (notification.method === "item/started" && notification.params.item.type === "commandExecution") {
+      this.observeCommandStarted(notification.params.item, threadId, sessionId, commandTitle2);
+      return;
+    }
+    if (notification.method === "item/completed" && notification.params.item.type === "commandExecution") {
+      await this.observeCommandCompleted(notification.params.item, threadId);
+      return;
+    }
+    if (notification.method === "turn/completed") {
+      await this.reconcile(threadId, sessionId);
+      return;
+    }
+    if (notification.method === "item/started") {
+      this.refresh(threadId, sessionId);
+    }
+  }
+  observeCommandStarted(item, threadId, sessionId, commandTitle2) {
+    if (!this.isActive() || item.processId === null) return;
+    this.remember(threadId, sessionId, {
+      itemId: item.id,
+      processId: item.processId,
+      command: item.command
+    }, commandTitle2);
+  }
+  async observeCommandCompleted(item, threadId) {
+    if (!this.isActive()) return;
+    const task = this.tasks.get(wireTaskId(this.rootSessionId, threadId, item.id));
+    if (task) await this.finish(task, item.status === "completed" ? "completed" : "failed");
+  }
+  refresh(threadId = this.rootSessionId, sessionId = this.rootSessionId) {
+    void this.reconcile(threadId, sessionId);
+  }
+  async reconcile(threadId = this.rootSessionId, sessionId = this.rootSessionId) {
+    try {
+      await this.sync(threadId, sessionId);
+    } catch (error51) {
+      if (this.isActive()) logger.error(`Failed to list background terminals for ${threadId}`, error51);
+    }
+  }
+  setAppServer(appServer) {
+    this.appServer = appServer;
+    this.appServerGeneration += 1;
+    this.appServerQueriesEnabled = true;
+  }
+  prepareForAppServerReplacement() {
+    this.appServerGeneration += 1;
+    this.appServerQueriesEnabled = false;
+  }
+  async recover(threadId, sessionId, itemIds) {
+    if (!this.canQueryAppServer() || itemIds.size === 0) return;
+    const snapshot = await this.listAll(threadId);
+    if (snapshot === null) return;
+    for (const terminal of snapshot.terminals) {
+      if (!this.queryIsCurrent(snapshot.generation)) return;
+      if (!itemIds.has(terminal.itemId)) continue;
+      const task = this.remember(threadId, sessionId, terminal);
+      if (task.publication === "unpublished" && task.state === "running") await this.announce(task);
+    }
+  }
+  async finishAll(state) {
+    if (!this.isActive()) return;
+    const errors = [];
+    for (const task of this.tasks.values()) {
+      try {
+        await this.finish(task, state);
+      } catch (error51) {
+        errors.push(error51);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, `Failed to finish ${errors.length} background terminal task(s)`);
+    }
+  }
+  async sync(threadId = this.rootSessionId, sessionId = this.rootSessionId) {
+    if (!this.canQueryAppServer()) return;
+    const current = this.syncs.get(threadId);
+    if (current) {
+      current.requested = true;
+      current.sessionId = sessionId;
+      return await current.promise;
+    }
+    const pending = {
+      requested: false,
+      sessionId,
+      promise: Promise.resolve()
+    };
+    pending.promise = this.syncUntilCurrent(threadId, pending).finally(() => {
+      if (this.syncs.get(threadId) === pending) this.syncs.delete(threadId);
+    });
+    this.syncs.set(threadId, pending);
+    await pending.promise;
+  }
+  async stop(taskId) {
+    if (!this.isActive()) return false;
+    const task = this.tasks.get(taskId);
+    if (!task || task.publication !== "published") return false;
+    if (task.state === "stopped" && !task.terminalPublished) {
+      await this.publishTerminalState(task);
+      return true;
+    }
+    if (task.state !== "running") return false;
+    task.state = "stopping";
+    try {
+      const response = await this.appServer.threadBackgroundTerminalsTerminate({
+        threadId: task.threadId,
+        processId: task.processId
+      });
+      if (!response.terminated) {
+        if (task.state === "stopping") task.state = "running";
+        return false;
+      }
+      await this.finish(task, "stopped");
+      return true;
+    } catch (error51) {
+      if (task.state === "stopping") task.state = "running";
+      throw error51;
+    }
+  }
+  clear() {
+    this.disposed = true;
+    this.appServerGeneration += 1;
+    this.appServerQueriesEnabled = false;
+    this.tasks.clear();
+    this.syncs.clear();
+  }
+  async syncThread(threadId, sessionId) {
+    const snapshot = await this.listAll(threadId);
+    if (snapshot === null || !this.queryIsCurrent(snapshot.generation)) return;
+    const liveTaskIds = /* @__PURE__ */ new Set();
+    for (const terminal of snapshot.terminals) {
+      if (!this.queryIsCurrent(snapshot.generation)) return;
+      liveTaskIds.add(terminal.itemId);
+      const task = this.remember(threadId, sessionId, terminal);
+      if (task.publication === "unpublished" && task.state === "running") await this.announce(task);
+    }
+    for (const task of this.tasks.values()) {
+      if (!this.queryIsCurrent(snapshot.generation)) return;
+      if (task.threadId === threadId && task.publication === "published" && (task.state === "running" || task.state === "stopping") && !liveTaskIds.has(task.itemId)) {
+        await this.finish(task, "stopped");
+      }
+    }
+  }
+  async syncUntilCurrent(threadId, pending) {
+    let hasFailure = false;
+    let failure;
+    do {
+      pending.requested = false;
+      try {
+        await this.syncThread(threadId, pending.sessionId);
+        hasFailure = false;
+      } catch (error51) {
+        hasFailure = true;
+        failure = error51;
+      }
+    } while (pending.requested && this.canQueryAppServer());
+    if (hasFailure) throw failure;
+  }
+  async announce(task) {
+    if (task.publication === "published") return;
+    if (task.announcement !== null) {
+      await task.announcement;
+      return;
+    }
+    task.publication = "publishing";
+    const announcement = this.publishAnnouncement(task);
+    task.announcement = announcement;
+    try {
+      await announcement;
+    } finally {
+      if (task.announcement === announcement) task.announcement = null;
+    }
+    if (isTerminalState(task.state)) await this.publishTerminalState(task);
+  }
+  async publishAnnouncement(task) {
+    try {
+      await this.publishSpawn(task);
+      task.publication = "published";
+    } catch (error51) {
+      task.publication = "unpublished";
+      throw error51;
+    }
+  }
+  async publishSpawn(task) {
+    await this.session.update({
+      sessionUpdate: "tool_call_update",
+      toolCallId: task.itemId,
+      _meta: {
+        [JETBRAINS_META_KEY]: {
+          [AIR_META_KEY]: {
+            [AIR_ASYNC_TASKS_KEY]: {
+              [AIR_ASYNC_TASKS_BACKGROUNDED_KEY]: true
+            }
+          }
+        }
+      }
+    }, task.sessionId);
+    await this.session.update({
+      sessionUpdate: "async_task_spawned",
+      asyncTaskId: task.asyncTaskId,
+      name: task.name,
+      taskType: "shell",
+      showInTranscript: false,
+      canStop: true,
+      toolCallId: task.itemId
+    }, task.sessionId);
+  }
+  remember(threadId, sessionId, terminal, commandTitle2) {
+    const asyncTaskId = wireTaskId(this.rootSessionId, threadId, terminal.itemId);
+    const existing = this.tasks.get(asyncTaskId);
+    if (existing) {
+      existing.processId = terminal.processId;
+      if (commandTitle2 !== void 0) existing.name = commandTitle2;
+      return existing;
+    }
+    const task = {
+      threadId,
+      sessionId,
+      asyncTaskId,
+      processId: terminal.processId,
+      itemId: terminal.itemId,
+      name: commandTitle2 ?? terminal.command,
+      publication: "unpublished",
+      announcement: null,
+      terminalUpdate: null,
+      terminalPublished: false,
+      state: "running"
+    };
+    this.tasks.set(asyncTaskId, task);
+    return task;
+  }
+  async finish(task, state) {
+    if (task.state === "running" || task.state === "stopping") {
+      task.state = state;
+    } else if (task.state !== state) {
+      return;
+    }
+    if (task.announcement !== null) await task.announcement;
+    if (task.publication === "published") await this.publishTerminalState(task);
+  }
+  async publishTerminalState(task) {
+    if (!isTerminalState(task.state) || task.terminalPublished) return;
+    if (task.terminalUpdate !== null) {
+      await task.terminalUpdate;
+      return;
+    }
+    const terminalUpdate = this.session.update({
+      sessionUpdate: "async_task_state_update",
+      asyncTaskId: task.asyncTaskId,
+      state: task.state,
+      toolCallId: task.itemId
+    }, task.sessionId);
+    task.terminalUpdate = terminalUpdate;
+    try {
+      await terminalUpdate;
+      task.terminalPublished = true;
+    } finally {
+      if (task.terminalUpdate === terminalUpdate) task.terminalUpdate = null;
+    }
+  }
+  async listAll(threadId) {
+    const appServer = this.appServer;
+    const generation = this.appServerGeneration;
+    const terminals = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor = null;
+    do {
+      const response = await appServer.threadBackgroundTerminalsList({
+        threadId,
+        cursor
+      });
+      if (!this.queryIsCurrent(generation)) return null;
+      terminals.push(...response.data);
+      cursor = response.nextCursor;
+      if (cursor !== null) {
+        if (seenCursors.has(cursor)) {
+          throw new Error("Codex returned a repeated background terminal cursor");
+        }
+        seenCursors.add(cursor);
+      }
+    } while (cursor !== null);
+    return { generation, terminals };
+  }
+  isActive() {
+    return this.enabled && !this.disposed;
+  }
+  canQueryAppServer() {
+    return this.isActive() && this.appServerQueriesEnabled;
+  }
+  queryIsCurrent(generation) {
+    return this.canQueryAppServer() && generation === this.appServerGeneration;
+  }
+};
+function isTerminalState(state) {
+  return state === "completed" || state === "failed" || state === "stopped";
+}
+function wireTaskId(rootSessionId, threadId, itemId) {
+  return threadId === rootSessionId ? itemId : `${threadId}:${itemId}`;
+}
+function notificationThreadId(notification) {
+  const threadId = notification.params.threadId;
+  return typeof threadId === "string" ? threadId : null;
+}
+
+// src/CodexAcpServer.ts
 var CODEX_PROCESS_EXITED_ERROR_CODE = 1001;
 function clientSupportsTypedSessionFailures(capabilities) {
   return clientSupportsAirCapability(capabilities, AIR_SESSION_FAILURE_KEY);
@@ -31525,6 +32156,8 @@ var CodexAcpServer = class _CodexAcpServer {
   clientCapabilities;
   terminalOutputMode;
   booleanConfigOptionsSupported;
+  /** Last `authStatus` pushed to the client; used to suppress duplicates. */
+  currentAuthStatus;
   sessions;
   pendingMcpStartupSessions;
   pendingTurnStarts;
@@ -31536,6 +32169,7 @@ var CodexAcpServer = class _CodexAcpServer {
   goalControlGenerations;
   permissionLifecycleContexts;
   codexProcessState;
+  codexProcessGeneration = 0;
   initializeRequest = null;
   providerUpdate = null;
   constructor(connection, codexAcpClient, defaultAuthRequest, getExitCode, getRecentStderr, codexProcessState) {
@@ -31561,14 +32195,16 @@ var CodexAcpServer = class _CodexAcpServer {
     this.clientCapabilities = null;
     this.terminalOutputMode = "terminal_output_delta";
     this.booleanConfigOptionsSupported = false;
+    this.currentAuthStatus = null;
     this.availableCommands = this.createAvailableCommands(codexAcpClient);
+    this.observeCodexProcess();
   }
   createAvailableCommands(client) {
     return new CodexCommands(
       this.connection,
       client,
       (operation) => this.runWithProcessCheck(operation),
-      () => this.refreshSessionsAuthState(null)
+      () => this.refreshAuthState(null)
     );
   }
   async initialize(_params) {
@@ -31579,6 +32215,7 @@ var CodexAcpServer = class _CodexAcpServer {
     this.terminalOutputMode = resolveTerminalOutputMode(_params.clientCapabilities);
     this.booleanConfigOptionsSupported = clientSupportsBooleanConfigOptions(_params.clientCapabilities);
     await this.runWithProcessCheck(() => this.codexAcpClient.initialize(_params));
+    this.publishFirstAuthStatusAfterResponse();
     const sessionCapabilities = {
       resume: {},
       list: {},
@@ -31610,6 +32247,11 @@ var CodexAcpServer = class _CodexAcpServer {
           acp: false,
           http: true,
           sse: false
+        },
+        _meta: {
+          // Presence means "this agent pushes `_auth/status_update`". It
+          // never carries a payload, and the client never asks for one.
+          [AUTH_STATUS_META_KEY]: authStatusCapability()
         }
       },
       authMethods: getCodexAuthMethods(_params.clientCapabilities),
@@ -31628,7 +32270,8 @@ var CodexAcpServer = class _CodexAcpServer {
             [AIR_EXTENSION_CAPABILITIES_KEY]: [
               AIR_SESSION_FAILURE_KEY,
               AIR_AGENT_FILE_CHANGE_REPORT_KEY,
-              AIR_NATIVE_SUBAGENT_SESSIONS_KEY
+              AIR_NATIVE_SUBAGENT_SESSIONS_KEY,
+              AIR_ASYNC_TASKS_KEY
             ]
           }
         }
@@ -31651,6 +32294,18 @@ var CodexAcpServer = class _CodexAcpServer {
         return await this.unstable_setSessionModel(this.parseLegacySetSessionModelParams(methodRequest.params));
       case SESSION_STEERING_METHOD:
         return await this.executeOrQueueSteeringRequest(this.parseSessionSteerParams(methodRequest.params));
+      case ASYNC_TASK_STOP_METHOD: {
+        if (this.providerUpdate !== null) {
+          await this.providerUpdate;
+        }
+        const sessionState = this.sessions.get(methodRequest.params.sessionId);
+        if (!sessionState) return { stopped: false };
+        return {
+          stopped: await this.runWithProcessCheck(
+            () => sessionState.asyncTasks.stop(methodRequest.params.asyncTaskId)
+          )
+        };
+      }
       case GOAL_CONTROL_METHOD:
       case LEGACY_GOAL_CONTROL_METHOD: {
         const sessionState = this.sessions.get(methodRequest.params.sessionId);
@@ -31741,7 +32396,7 @@ var CodexAcpServer = class _CodexAcpServer {
   async handleError(e) {
     if (e.message.includes("log out") || e.message.includes("cloud requirements")) {
       await this.runWithProcessCheck(() => this.codexAcpClient.logout());
-      await this.refreshSessionsAuthState(null);
+      await this.refreshAuthState(null);
       throw RequestError.internalError(`${e.message}
 
 You have been logged out. Please try again.`);
@@ -31892,7 +32547,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         sessionId,
         clientSupportsSubagents(this.clientCapabilities),
         new ACPSessionConnection(this.connection, sessionId)
-      )
+      ),
+      asyncTasks: this.createAsyncTasks(sessionId)
     };
     sessionState.titleGen = new TitleGenerator(
       this.codexAcpClient.appServerClient,
@@ -31900,7 +32556,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionState.cwd,
       () => sessionState.sessionTitleSource
     );
-    this.sessions.set(sessionId, sessionState);
+    this.installSessionState(sessionState);
     resumeSubscribed = false;
     const canPublishSessionUpdates = operation !== "fork";
     if (canPublishSessionUpdates && requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
@@ -31915,6 +32571,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
     if (operation === "resume") {
       this.publishCurrentGoalAsync(sessionState, sessionGeneration);
+      this.publishAsyncTasksAsync(sessionState, sessionGeneration);
     }
     const sessionModelState = this.createModelState(models, currentModelId);
     const sessionModeState = sessionState.agentMode.toSessionModeState();
@@ -31922,12 +32579,14 @@ Check ${configPath} and project .codex directories, especially their config.toml
   }
   async getAuthStateForProvider(authProvider) {
     if (!this.authProviderUsesOpenAiAccount(authProvider)) {
+      await this.publishAuthStatus(authProvider, null);
       return {
         account: null,
         authConfigured: true
       };
     }
     const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
+    await this.publishAuthStatus(authProvider, accountResponse.account);
     return {
       account: accountResponse.account,
       authConfigured: accountResponse.account !== null || !accountResponse.requiresOpenaiAuth
@@ -31942,6 +32601,18 @@ Check ${configPath} and project .codex directories, especially their config.toml
     }
     return a === b;
   }
+  createAsyncTasks(sessionId) {
+    return new CodexBackgroundTerminalTasks(
+      clientSupportsAirCapability(this.clientCapabilities, AIR_ASYNC_TASKS_KEY),
+      sessionId,
+      this.codexAcpClient.appServerClient,
+      new ACPSessionConnection(this.connection, sessionId)
+    );
+  }
+  installSessionState(sessionState) {
+    this.sessions.get(sessionState.sessionId)?.asyncTasks.clear();
+    this.sessions.set(sessionState.sessionId, sessionState);
+  }
   getAuthProviderForAuthenticateRequest(request) {
     if (isCodexAuthRequest(request) && request.methodId === "gateway") {
       return "custom-gateway";
@@ -31960,6 +32631,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       thread
     } = await this.getOrCreateSessionWithHistory(params);
     await this.streamThreadHistory(sessionId, thread);
+    await this.getSessionState(sessionId).asyncTasks.reconcile();
     logger.log("Session loaded", {
       sessionId,
       modelId: modelState.currentModelId,
@@ -32033,6 +32705,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     try {
       if (sessionState) {
         await this.interruptSessionTurn(sessionState, "Close", true);
+        sessionState.asyncTasks.clear();
       } else {
         logger.log("Close request received for unknown local session", { sessionId: params.sessionId });
       }
@@ -32106,7 +32779,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       logger.log("Authenticate request failed");
       throw RequestError.invalidParams();
     }
-    await this.refreshSessionsAuthState(this.getAuthProviderForAuthenticateRequest(_params));
+    await this.refreshAuthState(this.getAuthProviderForAuthenticateRequest(_params));
     logger.log("Authenticate request completed");
     return {};
   }
@@ -32137,7 +32810,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
   async logout(_params) {
     logger.log("Logout request received");
     await this.runWithProcessCheck(() => this.codexAcpClient.logout());
-    await this.refreshSessionsAuthState(null);
+    await this.refreshAuthState(null);
     logger.log("Logout request completed");
   }
   listProviders(_params) {
@@ -32168,6 +32841,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
         await Promise.all(activePrompts);
       }
       logger.log("Restarting Codex app-server for provider update", { sessionCount: this.sessions.size });
+      for (const session of this.sessions.values()) {
+        session.asyncTasks.prepareForAppServerReplacement();
+      }
+      await this.finishAllAsyncTasks("stopped", "before the provider restart");
       const replacement = await this.restartCodexClient();
       apply(replacement);
       if (this.initializeRequest === null) {
@@ -32178,6 +32855,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       this.availableCommands = this.createAvailableCommands(replacement);
       const resumeErrors = [];
       for (const session of this.sessions.values()) {
+        session.asyncTasks.setAppServer(replacement.appServerClient);
         try {
           await replacement.resumeSession({
             sessionId: session.sessionId,
@@ -32186,6 +32864,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
             mcpServers: session.mcpServers ?? []
           });
           session.authProvider = replacement.getModelProvider();
+          session.asyncTasks.refresh();
           logger.log("Resumed session after provider restart", { sessionId: session.sessionId });
         } catch (error51) {
           resumeErrors.push(error51);
@@ -32215,12 +32894,22 @@ Check ${configPath} and project .codex directories, especially their config.toml
       state.stderr = (state.stderr + data.toString()).slice(-2 * 1024);
     });
   }
+  observeCodexProcess() {
+    const process12 = this.codexProcessState?.connection.process;
+    if (!process12) return;
+    const generation = ++this.codexProcessGeneration;
+    process12.once("exit", () => {
+      if (generation !== this.codexProcessGeneration) return;
+      void this.finishAllAsyncTasks("failed", "after the Codex process exited");
+    });
+  }
   async restartCodexClient() {
     const state = this.codexProcessState;
     if (state === null) {
       throw new Error("Codex process state is unavailable");
     }
     const previous = state.connection;
+    this.codexProcessGeneration += 1;
     const exited = previous.process.exitCode === null ? once(previous.process, "exit") : Promise.resolve();
     previous.process.stdin.end();
     const forceKill = setTimeout(() => {
@@ -32234,21 +32923,162 @@ Check ${configPath} and project .codex directories, especially their config.toml
     state.stderr = "";
     state.connection = startCodexConnection(state.codexPath);
     this.captureStderr();
+    this.observeCodexProcess();
     return new CodexAcpClient(
       new CodexAppServerClient(state.connection.connection),
       state.config,
       state.modelProvider
     );
   }
+  /** Returns whether the auth state was read (and thus the auth status pushed). */
   async refreshSessionsAuthState(authProvider) {
-    if (this.sessions.size === 0) return;
+    if (this.sessions.size === 0) return false;
     const sessionsToRefresh = [...this.sessions.values()].filter((sessionState) => this.authProvidersMatch(sessionState.authProvider, authProvider));
-    if (sessionsToRefresh.length === 0) return;
+    if (sessionsToRefresh.length === 0) return false;
     const authState = await this.getAuthStateForProvider(authProvider);
     for (const sessionState of sessionsToRefresh) {
       sessionState.account = authState.account;
       sessionState.authConfigured = authState.authConfigured;
     }
+    return true;
+  }
+  /**
+   * Refreshes the sessions of a provider and makes sure the connection-level
+   * `authStatus` is pushed even when no session matched (the empty-screen
+   * login case). Reuses the session refresh read; never adds a second one.
+   */
+  async refreshAuthState(authProvider) {
+    const refreshed = await this.refreshSessionsAuthState(authProvider);
+    if (refreshed) return;
+    try {
+      await this.getAuthStateForProvider(authProvider ?? this.codexAcpClient.getModelProvider());
+    } catch (error51) {
+      logger.log("Failed to refresh auth status", { error: String(error51) });
+    }
+  }
+  /**
+   * Schedules the connection's first `_auth/status_update`: one account read,
+   * pushed whatever it says, including `none`.
+   *
+   * The push must not overtake the `initialize` response. The JSON-RPC layer
+   * writes that response in the microtask that resolves {@link initialize}, so
+   * the read starts from a check-phase callback, which always runs after it.
+   * `initialize` itself never waits for the read.
+   *
+   * "Unconditional" costs nothing extra here: nothing has been pushed yet on
+   * this connection, so {@link setAuthStatus} cannot suppress this one.
+   */
+  publishFirstAuthStatusAfterResponse() {
+    setImmediate(() => void this.publishAuthStatusRead());
+  }
+  /**
+   * Reads the agent-owned identity and pushes it.
+   *
+   * 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.
+   */
+  async publishAuthStatusRead() {
+    let authStatus;
+    try {
+      authStatus = await this.readAgentAuthIdentity();
+    } catch (error51) {
+      logger.log("Cannot determine auth status", { error: String(error51) });
+      return;
+    }
+    await this.setAuthStatus(authStatus);
+  }
+  /**
+   * Builds the agent-owned auth identity. Routing the client configured
+   * through the ACP `providers/*` API is invisible here: the reported state
+   * is what the agent itself is logged in with. `gateway` stays reserved for
+   * agent-owned gateway state — the `gateway` auth method, or a provider the
+   * user configured in Codex's own config.
+   */
+  async readAgentAuthIdentity() {
+    const authGatewayName = this.codexAcpClient.getAuthGatewayProviderName();
+    if (authGatewayName !== null) {
+      return gatewayStatus(authGatewayName);
+    }
+    const modelProvider = await this.runWithProcessCheck(() => this.codexAcpClient.getAgentConfiguredModelProvider());
+    if (!this.authProviderUsesOpenAiAccount(modelProvider)) {
+      return gatewayStatus(modelProvider);
+    }
+    const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
+    return fromAccount(accountResponse.account);
+  }
+  /**
+   * Pushes `_auth/status_update` for the freshly read account of a provider.
+   * Agent-owned gateway authentication wins; a client-driven provider
+   * override is ignored and the agent-owned login is reported instead.
+   */
+  async publishAuthStatus(authProvider, account) {
+    const authGatewayName = this.codexAcpClient.getAuthGatewayProviderName();
+    if (authGatewayName !== null) {
+      await this.setAuthStatus(gatewayStatus(authGatewayName));
+      return;
+    }
+    if (this.authProviderUsesOpenAiAccount(authProvider)) {
+      await this.setAuthStatus(fromAccount(account));
+      return;
+    }
+    if (this.codexAcpClient.isClientConfiguredProvider(authProvider)) {
+      await this.publishAuthStatusRead();
+      return;
+    }
+    await this.setAuthStatus(gatewayStatus(authProvider));
+  }
+  /**
+   * Handles the app-server `account/updated` push: the free freshness channel
+   * for logins and logouts happening outside this connection.
+   */
+  handleAccountUpdated(notification) {
+    void this.applyAccountUpdated(notification);
+  }
+  /**
+   * `account/updated` describes the Codex account only. It must never
+   * overwrite an agent-owned gateway status, which no account event can
+   * invalidate; only a gateway logout or a provider change does.
+   */
+  async applyAccountUpdated(notification) {
+    try {
+      if (this.codexAcpClient.getAuthGatewayProviderName() !== null) {
+        return;
+      }
+      if (this.currentAuthStatus === null) {
+        await this.publishAuthStatusRead();
+        return;
+      }
+      if (this.currentAuthStatus.kind === "gateway") {
+        return;
+      }
+      await this.setAuthStatus(fromAccountUpdated(notification, this.currentAuthStatus));
+    } catch (error51) {
+      logger.log("Failed to apply account update to auth status", { error: String(error51) });
+    }
+  }
+  /**
+   * Stores `next` and pushes `_auth/status_update`.
+   *
+   * A push goes out only when the payload changed. The identity is read on
+   * many occasions — `initialize`, each session create, each `account/updated`
+   * — and almost all of them see the login already reported.
+   * Clients replace their whole state on each update and tolerate duplicates,
+   * so a repeat is harmless, but it is pure noise all the same.
+   *
+   * The first push of a connection always goes out: nothing was reported yet,
+   * so no payload can equal it.
+   */
+  async setAuthStatus(next) {
+    if (sameAuthStatus(this.currentAuthStatus, next)) {
+      return;
+    }
+    this.currentAuthStatus = next;
+    try {
+      await this.connection.notify(AUTH_STATUS_UPDATE_METHOD, { authStatus: next });
+    } catch (error51) {
+      logger.log("Failed to send auth status update", { error: String(error51) });
+    }
   }
   async setSessionMode(_params) {
     logger.log("Set session mode requested", {
@@ -32643,6 +33473,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
   publishCurrentGoalAsync(sessionState, sessionGeneration) {
     void this.publishCurrentGoalBestEffort(sessionState, sessionGeneration, true);
   }
+  publishAsyncTasksAsync(sessionState, sessionGeneration) {
+    if (!this.sessionPublishIsCurrent(sessionState, sessionGeneration)) return;
+    sessionState.asyncTasks.refresh();
+  }
   async publishCurrentGoalBestEffort(sessionState, sessionGeneration, force) {
     try {
       await this.publishCurrentGoal(sessionState, sessionGeneration, force);
@@ -32766,7 +33600,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         sessionId,
         clientSupportsSubagents(this.clientCapabilities),
         new ACPSessionConnection(this.connection, sessionId)
-      )
+      ),
+      asyncTasks: this.createAsyncTasks(sessionId)
     };
     sessionState.titleGen = new TitleGenerator(
       this.codexAcpClient.appServerClient,
@@ -32774,7 +33609,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionState.cwd,
       () => sessionState.sessionTitleSource
     );
-    this.sessions.set(sessionId, sessionState);
+    this.installSessionState(sessionState);
     subscribed = false;
     if (requestedMcpServers.length > 0 && mcpServerStartupVersion !== null) {
       this.pendingMcpStartupSessions.set(sessionId, {
@@ -32866,6 +33701,15 @@ Check ${configPath} and project .codex directories, especially their config.toml
                   /* @__PURE__ */ new Set([...ancestry, item.agentThreadId]),
                   threadCache
                 );
+                try {
+                  await sessionState.asyncTasks.recover(
+                    item.agentThreadId,
+                    childSessionId,
+                    commandItemIds(childTurn.items)
+                  );
+                } catch (error51) {
+                  logger.error(`Failed to restore background terminals for ${item.agentThreadId}`, error51);
+                }
               }
             }
           } else if (activityKind === "completed" || activityKind === "interrupted") {
@@ -33438,7 +34282,6 @@ Check ${configPath} and project .codex directories, especially their config.toml
     let promptWasCancelled = false;
     let recoverableSessionFailure = sessionState.sessionFailure;
     sessionState.currentTurnId = null;
-    sessionState.lastTokenUsage = null;
     const activePrompt = this.trackActivePrompt(params.sessionId);
     let pendingTurnStart = null;
     const ensurePendingTurnStart = () => {
@@ -33471,7 +34314,8 @@ Check ${configPath} and project .codex directories, especially their config.toml
         clientSupportsPlanUpdates(this.clientCapabilities),
         clientSupportsTypedSessionFailures(this.clientCapabilities),
         this.sessionFailureEpoch,
-        sessionState.subagents
+        sessionState.subagents,
+        (accountUpdated) => this.handleAccountUpdated(accountUpdated)
       );
       eventHandler = promptEventHandler;
       const permissionLifecycle = this.permissionLifecycleContext(sessionState);
@@ -33516,6 +34360,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       }
       const commandPromise = this.availableCommands.tryHandleCommand(params.prompt, sessionState, {
         onTurnStartPending: () => {
+          sessionState.lastTokenUsage = null;
           ensurePendingTurnStart();
         },
         onTurnStarted: (turnId, threadId) => {
@@ -33612,6 +34457,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         sessionState.fastModeEnabled,
         sessionState.currentModelSupportsFast
       );
+      sessionState.lastTokenUsage = null;
       ensurePendingTurnStart();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
@@ -33914,6 +34760,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         throw new RequestError(requestErrorCode, `VC++ redistributable should be installed`);
       }
       if (exitCode !== null) {
+        await this.finishAllAsyncTasks("failed", "after the Codex process exited");
         const stderr = this.getRecentStderr().trim();
         const detail = stderr ? `:
 ${stderr}` : "";
@@ -33922,6 +34769,15 @@ ${stderr}` : "";
       throw err;
     }
   }
+  async finishAllAsyncTasks(state, reason) {
+    for (const session of this.sessions.values()) {
+      try {
+        await session.asyncTasks.finishAll(state);
+      } catch (error51) {
+        logger.error(`Failed to finish background terminal tasks ${reason}`, error51);
+      }
+    }
+  }
   async cancel(params) {
     const sessionState = this.sessions.get(params.sessionId);
     if (!sessionState) {
@@ -33971,6 +34827,9 @@ function mergeHistoryUpdates(responseItemFallbackUpdates, threadUpdates) {
   }
   return merged;
 }
+function commandItemIds(items) {
+  return new Set(items.filter((item) => item.type === "commandExecution").map((item) => item.id));
+}
 function historyUpdateKey(update) {
   switch (update.sessionUpdate) {
     case "user_message_chunk":
@@ -34154,6 +35013,10 @@ var goalControlParamsParser = external_exports.discriminatedUnion("action", [
     action: external_exports.enum(["pause", "resume", "clear"])
   }).passthrough()
 ]);
+var asyncTaskStopParamsParser = external_exports.object({
+  sessionId: external_exports.string().trim().min(1),
+  asyncTaskId: external_exports.string().trim().min(1)
+}).passthrough();
 if (process.argv.includes("--version")) {
   console.log(`${package_default.name} ${package_default.version}`);
   process.exit(0);
@@ -34234,5 +35097,5 @@ function startAcpServer() {
         codexAcpServer = null;
       }
     });
-  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params, ctx.requestId)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).connect(acpJsonStream);
+  }).onRequest(methods.agent.initialize, (ctx) => getAgent().initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => getAgent().newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => getAgent().loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => getAgent().forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => getAgent().listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => getAgent().deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => getAgent().resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => getAgent().closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => getAgent().setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => getAgent().setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => getAgent().authenticate(ctx.params, ctx.requestId)).onRequest(methods.agent.logout, (ctx) => getAgent().logout(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => getAgent().listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => getAgent().setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => getAgent().disableProvider(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => getAgent().prompt(ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => getAgent().cancel(ctx.params)).onRequest("authentication/status", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/status", ctx.params)).onRequest("authentication/logout", emptyExtensionParamsParser, (ctx) => getAgent().extMethod("authentication/logout", ctx.params)).onRequest(LEGACY_SET_SESSION_MODEL_METHOD, legacySetSessionModelParamsParser, (ctx) => getAgent().extMethod(LEGACY_SET_SESSION_MODEL_METHOD, ctx.params)).onRequest(SESSION_STEERING_METHOD, sessionSteerParamsParser, (ctx) => getAgent().extMethod(SESSION_STEERING_METHOD, ctx.params)).onRequest(ASYNC_TASK_STOP_METHOD, asyncTaskStopParamsParser, (ctx) => getAgent().extMethod(ASYNC_TASK_STOP_METHOD, ctx.params)).onRequest(GOAL_CONTROL_METHOD, goalControlParamsParser, (ctx) => getAgent().extMethod(GOAL_CONTROL_METHOD, ctx.params)).connect(acpJsonStream);
 }