@leo000001/codex-mcp 0.2.1 → 2.0.2

package/dist/index.js

@@ -34,6 +34,7 @@ var Methods = {
   THREAD_START: "thread/start",
   THREAD_RESUME: "thread/resume",
   THREAD_FORK: "thread/fork",
+  THREAD_BACKGROUND_TERMINALS_CLEAN: "thread/backgroundTerminals/clean",
   TURN_START: "turn/start",
   TURN_INTERRUPT: "turn/interrupt",
   TURN_STEER: "turn/steer",
@@ -48,19 +49,31 @@ var Methods = {
   // Server → Client notifications
   ERROR: "error",
   THREAD_STARTED: "thread/started",
+  THREAD_ARCHIVED: "thread/archived",
+  THREAD_UNARCHIVED: "thread/unarchived",
+  THREAD_NAME_UPDATED: "thread/name/updated",
+  THREAD_TOKEN_USAGE_UPDATED: "thread/tokenUsage/updated",
   TURN_STARTED: "turn/started",
   TURN_COMPLETED: "turn/completed",
   TURN_DIFF_UPDATED: "turn/diff/updated",
   TURN_PLAN_UPDATED: "turn/plan/updated",
   ITEM_STARTED: "item/started",
   ITEM_COMPLETED: "item/completed",
+  RAW_RESPONSE_ITEM_COMPLETED: "rawResponseItem/completed",
   AGENT_MESSAGE_DELTA: "item/agentMessage/delta",
   COMMAND_OUTPUT_DELTA: "item/commandExecution/outputDelta",
+  COMMAND_TERMINAL_INTERACTION: "item/commandExecution/terminalInteraction",
   FILE_CHANGE_OUTPUT_DELTA: "item/fileChange/outputDelta",
   REASONING_TEXT_DELTA: "item/reasoning/textDelta",
   REASONING_SUMMARY_DELTA: "item/reasoning/summaryTextDelta",
+  REASONING_SUMMARY_PART_ADDED: "item/reasoning/summaryPartAdded",
   PLAN_DELTA: "item/plan/delta",
   MCP_TOOL_PROGRESS: "item/mcpToolCall/progress",
+  MODEL_REROUTED: "model/rerouted",
+  FUZZY_FILE_SEARCH_SESSION_UPDATED: "fuzzyFileSearch/sessionUpdated",
+  FUZZY_FILE_SEARCH_SESSION_COMPLETED: "fuzzyFileSearch/sessionCompleted",
+  WINDOWS_WORLD_WRITABLE_WARNING: "windows/worldWritableWarning",
+  ACCOUNT_LOGIN_COMPLETED: "account/login/completed",
   SESSION_CONFIGURED: "sessionConfigured"
 };
 
@@ -164,7 +177,14 @@ var SANDBOX_MODES = ["read-only", "workspace-write", "danger-full-access"];
 var PERSONALITIES = ["none", "friendly", "pragmatic"];
 var EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"];
 var SUMMARY_MODES = ["auto", "concise", "detailed", "none"];
-var SESSION_ACTIONS = ["list", "get", "cancel", "interrupt", "fork"];
+var SESSION_ACTIONS = [
+  "list",
+  "get",
+  "cancel",
+  "interrupt",
+  "fork",
+  "clean_background_terminals"
+];
 var CHECK_ACTIONS = ["poll", "respond_permission", "respond_user_input"];
 var RESPONSE_MODES = ["minimal", "delta_compact", "full"];
 var COMMAND_DECISIONS = [
@@ -213,7 +233,7 @@ var DEFAULT_TERMINAL_CLEANUP_MS = 5 * 60 * 1e3;
 var CLEANUP_INTERVAL_MS = 6e4;
 
 // src/app-server/client.ts
-var CLIENT_VERSION = true ? "0.2.1" : "0.0.0-dev";
+var CLIENT_VERSION = true ? "2.0.2" : "0.0.0-dev";
 var DEFAULT_REQUEST_TIMEOUT = 3e4;
 var STARTUP_REQUEST_TIMEOUT = 9e4;
 var MAX_WRITE_QUEUE_BYTES = 5 * 1024 * 1024;
@@ -330,6 +350,9 @@ var AppServerClient = class extends EventEmitter {
   async threadResume(params) {
     return this.request(Methods.THREAD_RESUME, params);
   }
+  async threadBackgroundTerminalsClean(params) {
+    return this.request(Methods.THREAD_BACKGROUND_TERMINALS_CLEAN, params);
+  }
   async turnStart(params, timeout = STARTUP_REQUEST_TIMEOUT) {
     return this.request(Methods.TURN_START, params, timeout);
   }
@@ -659,6 +682,9 @@ var COALESCED_PROGRESS_DELTA_METHODS = /* @__PURE__ */ new Set([
   Methods.REASONING_SUMMARY_DELTA
 ]);
 var MAX_COALESCED_DELTA_CHARS = 16384;
+var AUTH_REFRESH_UNSUPPORTED_CODE = -32e3;
+var AUTH_REFRESH_UNSUPPORTED_MESSAGE = "account/chatgptAuthTokens/refresh unsupported: codex-mcp does not manage external ChatGPT auth tokens";
+var AUTH_REFRESH_TERMINAL_MESSAGE = "account/chatgptAuthTokens/refresh unsupported: session is terminal";
 var NOISE_FILTER_ENABLED = process.env.CODEX_MCP_DISABLE_NOISE_FILTER !== "1";
 var WINDOWS_TERMINAL_INTEGRATION_PREFIX = `${String.fromCharCode(27)}]633;`;
 var SHELL_NOISE_LINE_PATTERNS = [
@@ -959,6 +985,32 @@ var SessionManager = class {
       turnId: session.activeTurnId
     });
   }
+  async cleanBackgroundTerminals(sessionId) {
+    const session = this.getSessionOrThrow(sessionId);
+    const client = this.getClientOrThrow(sessionId);
+    if (session.status === "cancelled") {
+      throw new Error(
+        `Error [${"CANCELLED" /* CANCELLED */}]: Session '${sessionId}' has been cancelled and cannot be cleaned`
+      );
+    }
+    if (!session.threadId) {
+      throw new Error(
+        `Error [${"INTERNAL" /* INTERNAL */}]: Session '${sessionId}' has no threadId, cannot clean background terminals`
+      );
+    }
+    await client.threadBackgroundTerminalsClean({ threadId: session.threadId });
+    session.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    pushEvent(
+      session.eventBuffer,
+      "progress",
+      {
+        method: Methods.THREAD_BACKGROUND_TERMINALS_CLEAN,
+        threadId: session.threadId,
+        status: "requested"
+      },
+      true
+    );
+  }
   async forkSession(sessionId) {
     const session = this.getSessionOrThrow(sessionId);
     const originalClient = this.getClientOrThrow(sessionId);
@@ -1064,6 +1116,9 @@ var SessionManager = class {
             params: req.params,
             itemId: req.itemId,
             reason: req.reason,
+            approvalId: req.approvalId,
+            commandActions: req.commandActions,
+            proposedExecpolicyAmendment: req.proposedExecpolicyAmendment,
             createdAt: req.createdAt
           });
         }
@@ -1105,6 +1160,9 @@ var SessionManager = class {
             while (result.actions.length > 1 && payloadByteSize(result) > normalizedMaxBytes) {
               result.actions.pop();
             }
+            if (payloadByteSize(result) > normalizedMaxBytes) {
+              result.actions = compactActionsToMinimum(result.actions);
+            }
             truncatedFields.push("actions");
           }
           if (typeof result.actions !== "undefined" && payloadByteSize(result) > normalizedMaxBytes) {
@@ -1167,9 +1225,9 @@ var SessionManager = class {
           `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: Invalid command decision '${decision}'`
         );
       }
-      if (decision === "acceptWithExecpolicyAmendment" && (!extra?.execpolicyAmendment || extra.execpolicyAmendment.length === 0)) {
+      if (decision === "acceptWithExecpolicyAmendment" && (!extra?.execpolicy_amendment || extra.execpolicy_amendment.length === 0)) {
         throw new Error(
-          `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: execpolicyAmendment required for acceptWithExecpolicyAmendment`
+          `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: execpolicy_amendment required for acceptWithExecpolicyAmendment`
         );
       }
     } else if (req.kind === "fileChange") {
@@ -1185,7 +1243,7 @@ var SessionManager = class {
     }
     let response;
     if (req.kind === "command") {
-      response = buildCommandApprovalResponse(decision, extra?.execpolicyAmendment);
+      response = buildCommandApprovalResponse(decision, extra?.execpolicy_amendment);
     } else if (req.kind === "fileChange") {
       response = { decision };
     }
@@ -1204,6 +1262,7 @@ var SessionManager = class {
       {
         requestId,
         kind: req.kind,
+        approvalId: req.approvalId,
         decision,
         denyMessage: extra?.denyMessage
       },
@@ -1237,6 +1296,7 @@ var SessionManager = class {
       {
         requestId,
         kind: "user_input",
+        approvalId: req.approvalId,
         answers
       },
       true
@@ -1289,15 +1349,44 @@ var SessionManager = class {
       session.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
       const p = params;
       switch (method) {
+        case Methods.THREAD_STARTED: {
+          const thread = isRecord(p.thread) ? p.thread : void 0;
+          pushEvent(session.eventBuffer, "progress", {
+            method,
+            ...p,
+            threadId: normalizeOptionalString(p.threadId) ?? normalizeOptionalString(thread?.id),
+            status: normalizeOptionalString(thread?.status)
+          });
+          break;
+        }
+        case Methods.THREAD_ARCHIVED:
+        case Methods.THREAD_UNARCHIVED:
+        case Methods.THREAD_NAME_UPDATED:
+        case Methods.THREAD_TOKEN_USAGE_UPDATED:
+        case Methods.FUZZY_FILE_SEARCH_SESSION_UPDATED:
+        case Methods.FUZZY_FILE_SEARCH_SESSION_COMPLETED:
+        case Methods.WINDOWS_WORLD_WRITABLE_WARNING:
+        case Methods.ACCOUNT_LOGIN_COMPLETED:
+          pushEvent(session.eventBuffer, "progress", { method, ...p });
+          break;
         case Methods.TURN_STARTED:
           if (session.status === "cancelled") break;
-          session.activeTurnId = p.turn?.id ?? (typeof p.turnId === "string" ? p.turnId : void 0);
-          pushEvent(session.eventBuffer, "progress", { method, ...p });
+          {
+            const turnObj = p.turn;
+            const status = normalizeOptionalString(turnObj?.status);
+            session.activeTurnId = normalizeOptionalString(turnObj?.id);
+            pushEvent(session.eventBuffer, "progress", {
+              method,
+              ...p,
+              turnId: session.activeTurnId,
+              status
+            });
+          }
           break;
         case Methods.TURN_COMPLETED: {
           if (session.status === "cancelled") break;
           const turnObj = p.turn;
-          const completedTurnId = (typeof p.turnId === "string" ? p.turnId : void 0) ?? turnObj?.id ?? session.activeTurnId ?? "";
+          const completedTurnId = turnObj?.id ?? session.activeTurnId ?? "";
           session.status = "idle";
           session.activeTurnId = void 0;
           session.lastResult = {
@@ -1309,7 +1398,17 @@ var SessionManager = class {
             turnError: turnObj?.error,
             completedAt: (/* @__PURE__ */ new Date()).toISOString()
           };
-          pushEvent(session.eventBuffer, "result", { method, ...p }, true);
+          pushEvent(
+            session.eventBuffer,
+            "result",
+            {
+              method,
+              ...p,
+              turnId: completedTurnId,
+              status: normalizeOptionalString(turnObj?.status)
+            },
+            true
+          );
           break;
         }
         case Methods.ERROR: {
@@ -1343,12 +1442,20 @@ var SessionManager = class {
         case Methods.AGENT_MESSAGE_DELTA:
           pushEvent(session.eventBuffer, "output", { method, delta: p.delta, itemId: p.itemId });
           break;
+        case Methods.ITEM_STARTED:
         case Methods.ITEM_COMPLETED:
+        case Methods.RAW_RESPONSE_ITEM_COMPLETED:
           {
             const item = p.item;
             const itemType = item && typeof item.type === "string" ? item.type : void 0;
+            const status = normalizeOptionalString(item?.status);
             const eventType = itemType === "agentMessage" || itemType === "userMessage" ? "output" : "progress";
-            pushEvent(session.eventBuffer, eventType, { method, item: p.item });
+            pushEvent(session.eventBuffer, eventType, {
+              method,
+              ...p,
+              item: p.item,
+              status
+            });
           }
           break;
         case Methods.COMMAND_OUTPUT_DELTA: {
@@ -1361,14 +1468,16 @@ var SessionManager = class {
           }
           break;
         }
+        case Methods.COMMAND_TERMINAL_INTERACTION:
         case Methods.FILE_CHANGE_OUTPUT_DELTA:
         case Methods.REASONING_TEXT_DELTA:
         case Methods.REASONING_SUMMARY_DELTA:
+        case Methods.REASONING_SUMMARY_PART_ADDED:
         case Methods.PLAN_DELTA:
         case Methods.MCP_TOOL_PROGRESS:
-        case Methods.ITEM_STARTED:
         case Methods.TURN_DIFF_UPDATED:
         case Methods.TURN_PLAN_UPDATED:
+        case Methods.MODEL_REROUTED:
           pushEvent(session.eventBuffer, "progress", { method, ...p });
           break;
         default:
@@ -1385,15 +1494,24 @@ var SessionManager = class {
       switch (method) {
         case Methods.COMMAND_APPROVAL: {
           const requestId = `req_${randomUUID().slice(0, 8)}`;
-          const reason = normalizeOptionalString(p.reason);
+          const approvalParams = params;
+          const reason = normalizeOptionalString(approvalParams.reason);
+          const approvalId = normalizeOptionalString(approvalParams.approvalId);
+          const commandActions = Array.isArray(approvalParams.commandActions) ? approvalParams.commandActions : null;
+          const proposedExecpolicyAmendment = normalizeStringArrayOrNull(
+            approvalParams.proposedExecpolicyAmendment
+          );
           const pending = {
             requestId,
             kind: "command",
             params,
-            itemId: p.itemId,
-            threadId: p.threadId,
-            turnId: p.turnId,
+            itemId: normalizeOptionalString(approvalParams.itemId) ?? "",
+            threadId: normalizeOptionalString(approvalParams.threadId) ?? "",
+            turnId: normalizeOptionalString(approvalParams.turnId) ?? "",
             reason,
+            approvalId,
+            commandActions,
+            proposedExecpolicyAmendment,
             createdAt: (/* @__PURE__ */ new Date()).toISOString(),
             resolved: false,
             respond: (result) => client.respondToServer(id, result)
@@ -1415,6 +1533,7 @@ var SessionManager = class {
                 {
                   requestId,
                   kind: "command",
+                  approvalId,
                   decision: "decline",
                   timeout: true
                 },
@@ -1434,9 +1553,13 @@ var SessionManager = class {
             {
               requestId,
               kind: "command",
-              command: p.command,
-              cwd: p.cwd,
-              reason
+              itemId: approvalParams.itemId,
+              approvalId,
+              command: approvalParams.command,
+              cwd: approvalParams.cwd,
+              reason,
+              commandActions,
+              proposedExecpolicyAmendment
             },
             true
           );
@@ -1560,7 +1683,11 @@ var SessionManager = class {
           });
           break;
         case Methods.AUTH_TOKEN_REFRESH:
-          client.respondErrorToServer(id, -32601, "Auth token refresh not supported by codex-mcp");
+          client.respondErrorToServer(
+            id,
+            AUTH_REFRESH_UNSUPPORTED_CODE,
+            AUTH_REFRESH_UNSUPPORTED_MESSAGE
+          );
           break;
         case Methods.LEGACY_PATCH_APPROVAL:
         case Methods.LEGACY_EXEC_APPROVAL:
@@ -1709,7 +1836,7 @@ function respondToTerminalSessionRequest(client, id, method) {
       });
       break;
     case Methods.AUTH_TOKEN_REFRESH:
-      client.respondErrorToServer(id, -32601, "Session is terminal");
+      client.respondErrorToServer(id, AUTH_REFRESH_UNSUPPORTED_CODE, AUTH_REFRESH_TERMINAL_MESSAGE);
       break;
     case Methods.LEGACY_PATCH_APPROVAL:
     case Methods.LEGACY_EXEC_APPROVAL:
@@ -1723,6 +1850,11 @@ function respondToTerminalSessionRequest(client, id, method) {
 function normalizeOptionalString(value) {
   return typeof value === "string" ? value : void 0;
 }
+function normalizeStringArrayOrNull(value) {
+  if (!Array.isArray(value)) return null;
+  const normalized = value.filter((entry) => typeof entry === "string");
+  return normalized;
+}
 function sendPendingRequestResponseOrThrow(req, response, sessionId, requestId) {
   if (!req.respond) {
     throw new Error(
@@ -1744,7 +1876,9 @@ function compactActionsForBudget(actions) {
     kind: action.kind,
     params: compactActionParamsForBudget(action),
     itemId: action.itemId,
-    createdAt: action.createdAt
+    createdAt: action.createdAt,
+    commandActions: action.commandActions,
+    proposedExecpolicyAmendment: action.proposedExecpolicyAmendment
   }));
 }
 function compactActionParamsForBudget(action) {
@@ -1757,12 +1891,30 @@ function compactActionParamsForBudget(action) {
   }
   const compactQuestions = [];
   for (const entry of rawQuestions) {
-    if (isRecord(entry) && typeof entry.questionId === "string") {
-      compactQuestions.push({ questionId: entry.questionId });
+    if (!isRecord(entry)) continue;
+    const id = typeof entry.id === "string" ? entry.id : void 0;
+    if (id) {
+      compactQuestions.push({ id });
     }
   }
   return compactQuestions.length > 0 ? { questions: compactQuestions } : void 0;
 }
+function compactActionsToMinimum(actions) {
+  if (actions.length === 0) return actions;
+  const first = actions[0];
+  return [
+    {
+      type: first.type,
+      requestId: first.requestId,
+      kind: first.kind,
+      params: void 0,
+      itemId: first.itemId,
+      createdAt: first.createdAt,
+      commandActions: first.commandActions,
+      proposedExecpolicyAmendment: first.proposedExecpolicyAmendment
+    }
+  ];
+}
 function clampCursorToLatest(cursor, latestCursor) {
   return Math.max(0, Math.min(cursor, latestCursor));
 }
@@ -1983,17 +2135,17 @@ function toSensitiveInfo(session) {
     config: session.config
   };
 }
-function buildCommandApprovalResponse(decision, execpolicyAmendment) {
+function buildCommandApprovalResponse(decision, execpolicy_amendment) {
   if (decision === "acceptWithExecpolicyAmendment") {
-    if (!execpolicyAmendment || execpolicyAmendment.length === 0) {
+    if (!execpolicy_amendment || execpolicy_amendment.length === 0) {
       throw new Error(
-        `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: execpolicyAmendment required for acceptWithExecpolicyAmendment`
+        `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: execpolicy_amendment required for acceptWithExecpolicyAmendment`
       );
     }
     return {
       decision: {
         acceptWithExecpolicyAmendment: {
-          execpolicy_amendment: execpolicyAmendment
+          execpolicy_amendment
         }
       }
     };
@@ -2094,6 +2246,18 @@ async function executeCodexSession(args, sessionManager) {
         };
       }
       return await sessionManager.forkSession(args.sessionId);
+    case "clean_background_terminals":
+      if (!args.sessionId) {
+        return {
+          error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: sessionId required for 'clean_background_terminals'`,
+          isError: true
+        };
+      }
+      await sessionManager.cleanBackgroundTerminals(args.sessionId);
+      return {
+        success: true,
+        message: `Background terminals cleaned for session ${args.sessionId}`
+      };
     default:
       return {
         error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: Unknown action '${args.action}'`,
@@ -2108,7 +2272,13 @@ function executeCodexCheck(args, sessionManager) {
   const pollOptions = args.pollOptions;
   switch (args.action) {
     case "poll": {
-      const maxEvents = typeof args.maxEvents === "number" ? Math.max(POLL_MIN_MAX_EVENTS, args.maxEvents) : POLL_DEFAULT_MAX_EVENTS;
+      if (args.requestId !== void 0 || args.decision !== void 0 || args.execpolicy_amendment !== void 0 || args.denyMessage !== void 0 || args.answers !== void 0) {
+        return {
+          error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: requestId/decision/execpolicy_amendment/denyMessage/answers are only valid for respond_* actions`,
+          isError: true
+        };
+      }
+      const maxEvents = typeof args.maxEvents === "number" ? Math.max(POLL_MIN_MAX_EVENTS, Math.floor(args.maxEvents)) : POLL_DEFAULT_MAX_EVENTS;
       return sessionManager.pollEvents(args.sessionId, args.cursor, maxEvents, {
         responseMode,
         pollOptions
@@ -2121,16 +2291,41 @@ function executeCodexCheck(args, sessionManager) {
           isError: true
         };
       }
+      if (args.answers !== void 0) {
+        return {
+          error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: answers is only valid for respond_user_input`,
+          isError: true
+        };
+      }
+      if (args.decision === "acceptWithExecpolicyAmendment") {
+        if (!args.execpolicy_amendment || args.execpolicy_amendment.length === 0) {
+          return {
+            error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: execpolicy_amendment required for acceptWithExecpolicyAmendment`,
+            isError: true
+          };
+        }
+      } else if (args.execpolicy_amendment !== void 0) {
+        return {
+          error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: execpolicy_amendment is only valid with decision='acceptWithExecpolicyAmendment'`,
+          isError: true
+        };
+      }
+      if (!ALL_DECISIONS.includes(args.decision)) {
+        return {
+          error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: Unknown decision '${args.decision}'`,
+          isError: true
+        };
+      }
       try {
         sessionManager.resolveApproval(args.sessionId, args.requestId, args.decision, {
-          execpolicyAmendment: args.execpolicyAmendment,
+          execpolicy_amendment: args.execpolicy_amendment,
           denyMessage: args.denyMessage
         });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: message, isError: true };
       }
-      const maxEvents = args.maxEvents ?? RESPOND_DEFAULT_MAX_EVENTS;
+      const maxEvents = typeof args.maxEvents === "number" ? Math.max(0, Math.floor(args.maxEvents)) : RESPOND_DEFAULT_MAX_EVENTS;
       return sessionManager.pollEventsMonotonic(args.sessionId, args.cursor, maxEvents, {
         responseMode,
         pollOptions
@@ -2143,13 +2338,19 @@ function executeCodexCheck(args, sessionManager) {
           isError: true
         };
       }
+      if (args.decision !== void 0 || args.execpolicy_amendment !== void 0 || args.denyMessage !== void 0) {
+        return {
+          error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: decision/execpolicy_amendment/denyMessage are only valid for respond_permission`,
+          isError: true
+        };
+      }
       try {
         sessionManager.resolveUserInput(args.sessionId, args.requestId, args.answers);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: message, isError: true };
       }
-      const maxEvents = args.maxEvents ?? RESPOND_DEFAULT_MAX_EVENTS;
+      const maxEvents = typeof args.maxEvents === "number" ? Math.max(0, Math.floor(args.maxEvents)) : RESPOND_DEFAULT_MAX_EVENTS;
       return sessionManager.pollEventsMonotonic(args.sessionId, args.cursor, maxEvents, {
         responseMode,
         pollOptions
@@ -2436,6 +2637,7 @@ function buildGotchasText() {
     `- Pending approvals/user-input auto-decline after \`approvalTimeoutMs\` (default ${DEFAULT_APPROVAL_TIMEOUT_MS} ms).`,
     "- `untrusted` behavior is enforced by Codex CLI backend and may auto-allow some low-risk commands.",
     "- Do not assume every read-only command will always require approval across CLI versions.",
+    `- **Timeout vs polling conflict**: The recommended polling interval for \`running\` status is >=120 seconds, but the default approval timeout is ${DEFAULT_APPROVAL_TIMEOUT_MS / 1e3} seconds. If a session transitions to \`waiting_approval\` between polls, the approval will auto-decline before the client can respond. Set \`advanced.approvalTimeoutMs\` to at least 300000 (5 minutes) when using \`untrusted\` or \`on-request\` policies.`,
     "",
     "## Event model",
     "",
@@ -2505,6 +2707,7 @@ function buildQuickstartText() {
     "",
     "- Use `pollInterval` as a minimum delay: `running` >=120000ms (and usually longer for big tasks).",
     "- `waiting_approval` is the exception: poll/answer around 1000ms to avoid timeout.",
+    `- When using \`untrusted\` or \`on-request\` policies, set \`advanced.approvalTimeoutMs\` to at least 300000 to prevent approvals from expiring between polling intervals.`,
     "",
     "3. If `actions[]` contains an approval request, respond:",
     "",
@@ -2576,7 +2779,7 @@ function buildCompatReport(deps, codexCliVersion) {
       schemaVersion: "1.0.0",
       features: {
         respondPermission: true,
-        respondApprovalAlias: true,
+        respondApprovalAlias: false,
         respondUserInput: true,
         sessionInterrupt: true,
         responseModeMinimal: true,
@@ -2732,7 +2935,7 @@ function registerResources(server, deps) {
 }
 
 // src/server.ts
-var SERVER_VERSION = true ? "0.2.1" : "0.0.0-dev";
+var SERVER_VERSION = true ? "2.0.2" : "0.0.0-dev";
 function formatErrorMessage(err) {
   const message = err instanceof Error ? err.message : String(err);
   const m = /^Error \[([A-Z_]+)\]:\s*(.*)$/.exec(message);
@@ -2783,6 +2986,119 @@ function createServer(serverCwd) {
     ),
     ...errorOutputShape
   };
+  const codexCheckPollOptionsSchema = z.object({
+    includeEvents: z.boolean().optional().describe("Default: true. Include events[] in response."),
+    includeActions: z.boolean().optional().describe("Default: true. Include actions[] in response."),
+    includeResult: z.boolean().optional().describe("Default: true. Include result in response."),
+    maxBytes: z.number().int().positive().optional().describe("Default: unlimited. Best-effort response payload cap in bytes.")
+  }).optional().describe("Optional poll shaping controls.");
+  const codexCheckInputSchema = z.object({
+    action: z.enum(CHECK_ACTIONS),
+    sessionId: z.string().describe("Target session ID"),
+    cursor: z.number().int().nonnegative().optional().describe("Event cursor (default: session last consumed cursor)."),
+    maxEvents: z.number().int().nonnegative().optional().describe(
+      `Max events. Default: poll=${POLL_DEFAULT_MAX_EVENTS} (min ${POLL_MIN_MAX_EVENTS}), respond_*=${RESPOND_DEFAULT_MAX_EVENTS}.`
+    ),
+    responseMode: z.enum(RESPONSE_MODES).optional().describe("Response mode. Default: minimal. Options: minimal/delta_compact/full."),
+    pollOptions: codexCheckPollOptionsSchema,
+    // respond_permission
+    requestId: z.string().optional().describe("Request ID from actions[]"),
+    decision: z.enum(ALL_DECISIONS).optional().describe(
+      "Approval decision for respond_permission. acceptWithExecpolicyAmendment requires execpolicy_amendment."
+    ),
+    execpolicy_amendment: z.array(z.string()).optional().describe("For acceptWithExecpolicyAmendment only"),
+    denyMessage: z.string().optional().describe("Deny reason (not sent to agent)"),
+    // respond_user_input
+    answers: z.record(
+      z.string(),
+      z.object({
+        answers: z.array(z.string())
+      })
+    ).optional().describe("question-id -> answers map (id from actions[] user_input request).")
+  }).superRefine((value, ctx) => {
+    const addIssue = (path4, message) => {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [path4],
+        message
+      });
+    };
+    switch (value.action) {
+      case "poll": {
+        if (value.maxEvents !== void 0 && value.maxEvents < POLL_MIN_MAX_EVENTS) {
+          addIssue(
+            "maxEvents",
+            `poll requires maxEvents >= ${POLL_MIN_MAX_EVENTS} to avoid no-op loops.`
+          );
+        }
+        if (value.requestId !== void 0) {
+          addIssue("requestId", "requestId is only allowed for respond_* actions.");
+        }
+        if (value.decision !== void 0) {
+          addIssue("decision", "decision is only allowed for action='respond_permission'.");
+        }
+        if (value.execpolicy_amendment !== void 0) {
+          addIssue(
+            "execpolicy_amendment",
+            "execpolicy_amendment is only allowed for action='respond_permission'."
+          );
+        }
+        if (value.denyMessage !== void 0) {
+          addIssue("denyMessage", "denyMessage is only allowed for action='respond_permission'.");
+        }
+        if (value.answers !== void 0) {
+          addIssue("answers", "answers is only allowed for action='respond_user_input'.");
+        }
+        break;
+      }
+      case "respond_permission": {
+        if (!value.requestId) {
+          addIssue("requestId", "requestId is required for action='respond_permission'.");
+        }
+        if (!value.decision) {
+          addIssue("decision", "decision is required for action='respond_permission'.");
+        }
+        if (value.answers !== void 0) {
+          addIssue("answers", "answers is only allowed for action='respond_user_input'.");
+        }
+        const needsExecpolicy = value.decision === "acceptWithExecpolicyAmendment";
+        if (needsExecpolicy && (!value.execpolicy_amendment || value.execpolicy_amendment.length === 0)) {
+          addIssue(
+            "execpolicy_amendment",
+            "execpolicy_amendment is required and must be non-empty when decision='acceptWithExecpolicyAmendment'."
+          );
+        }
+        if (!needsExecpolicy && value.execpolicy_amendment !== void 0) {
+          addIssue(
+            "execpolicy_amendment",
+            "execpolicy_amendment is only allowed when decision='acceptWithExecpolicyAmendment'."
+          );
+        }
+        break;
+      }
+      case "respond_user_input": {
+        if (!value.requestId) {
+          addIssue("requestId", "requestId is required for action='respond_user_input'.");
+        }
+        if (!value.answers) {
+          addIssue("answers", "answers is required for action='respond_user_input'.");
+        }
+        if (value.decision !== void 0) {
+          addIssue("decision", "decision is only allowed for action='respond_permission'.");
+        }
+        if (value.execpolicy_amendment !== void 0) {
+          addIssue(
+            "execpolicy_amendment",
+            "execpolicy_amendment is only allowed for action='respond_permission'."
+          );
+        }
+        if (value.denyMessage !== void 0) {
+          addIssue("denyMessage", "denyMessage is only allowed for action='respond_permission'.");
+        }
+        break;
+      }
+    }
+  });
   server.registerTool(
     "codex",
     {
@@ -2883,16 +3199,17 @@ function createServer(serverCwd) {
     "codex_session",
     {
       title: "Manage Sessions",
-      description: `Session actions: list, get, cancel, interrupt, fork.
+      description: `Session actions: list, get, cancel, interrupt, fork, clean_background_terminals.
 
 - list: sessions in memory.
 - get: details. includeSensitive defaults to false; true adds threadId/cwd/profile/config.
 - cancel: terminal.
 - interrupt: stop current turn.
-- fork: clone current thread into a new session; source remains unchanged.`,
+- fork: clone current thread into a new session; source remains unchanged.
+- clean_background_terminals: ask app-server to clean stale background terminals for this thread.`,
       inputSchema: {
         action: z.enum(SESSION_ACTIONS),
-        sessionId: z.string().optional().describe("Required for get/cancel/interrupt/fork"),
+        sessionId: z.string().optional().describe("Required for get/cancel/interrupt/fork/clean_background_terminals"),
         includeSensitive: z.boolean().default(false).optional().describe("Include cwd/config/threadId/profile in get (default: false)")
       },
       outputSchema: {
@@ -2965,35 +3282,7 @@ respond_user_input: user-input answers. Default maxEvents=${RESPOND_DEFAULT_MAX_
 
 events[].type is coarse-grained; details are in events[].data.method.
 cursor omitted => use session last cursor. cursorResetTo => reset and continue.`,
-      inputSchema: {
-        action: z.enum(CHECK_ACTIONS),
-        sessionId: z.string().describe("Target session ID"),
-        cursor: z.number().int().nonnegative().optional().describe("Event cursor (default: session last consumed cursor)."),
-        maxEvents: z.number().int().nonnegative().optional().describe(
-          `Max events. Default: poll=${POLL_DEFAULT_MAX_EVENTS} (min ${POLL_MIN_MAX_EVENTS}), respond_*=${RESPOND_DEFAULT_MAX_EVENTS}.`
-        ),
-        responseMode: z.enum(RESPONSE_MODES).optional().describe("Response mode. Default: minimal. Options: minimal/delta_compact/full."),
-        pollOptions: z.object({
-          includeEvents: z.boolean().optional().describe("Default: true. Include events[] in response."),
-          includeActions: z.boolean().optional().describe("Default: true. Include actions[] in response."),
-          includeResult: z.boolean().optional().describe("Default: true. Include result in response."),
-          maxBytes: z.number().int().positive().optional().describe("Default: unlimited. Best-effort response payload cap in bytes.")
-        }).optional().describe("Optional poll shaping controls."),
-        // respond_permission
-        requestId: z.string().optional().describe("Request ID from actions[]"),
-        decision: z.enum(ALL_DECISIONS).optional().describe(
-          "Approval decision for respond_permission. acceptWithExecpolicyAmendment requires execpolicyAmendment."
-        ),
-        execpolicyAmendment: z.array(z.string()).optional().describe("For acceptWithExecpolicyAmendment only"),
-        denyMessage: z.string().optional().describe("Deny reason (not sent to agent)"),
-        // respond_user_input
-        answers: z.record(
-          z.string(),
-          z.object({
-            answers: z.array(z.string())
-          })
-        ).optional().describe("questionId -> answers map (questionId from actions[] user_input request).")
-      },
+      inputSchema: codexCheckInputSchema,
       outputSchema: {
         sessionId: z.string().optional(),
         status: z.enum(["running", "idle", "waiting_approval", "error", "cancelled"]).optional(),
@@ -3021,10 +3310,13 @@ cursor omitted => use session last cursor. cursorResetTo => reset and continue.`
           z.object({
             type: z.enum(["approval", "user_input"]),
             requestId: z.string(),
-            kind: z.string(),
+            kind: z.enum(["command", "fileChange", "user_input"]),
             params: z.unknown(),
             itemId: z.string(),
             reason: z.string().optional(),
+            approvalId: z.string().optional(),
+            commandActions: z.array(z.unknown()).nullable().optional(),
+            proposedExecpolicyAmendment: z.array(z.string()).nullable().optional(),
             createdAt: z.string()
           })
         ).optional(),