@posthog/agent 2.3.67 → 2.3.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.67",
+  "version": "2.3.73",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -78,8 +78,8 @@
     "@posthog/git": "1.0.0"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.15.0",
-    "@anthropic-ai/claude-agent-sdk": "0.2.71",
+    "@agentclientprotocol/sdk": "0.16.1",
+    "@anthropic-ai/claude-agent-sdk": "0.2.76",
     "@anthropic-ai/sdk": "^0.78.0",
     "@hono/node-server": "^1.19.9",
     "@opentelemetry/api-logs": "^0.208.0",

package/src/adapters/base-acp-agent.ts

@@ -20,6 +20,7 @@ import {
   DEFAULT_GATEWAY_MODEL,
   fetchGatewayModels,
   formatGatewayModelName,
+  type GatewayModel,
   isAnthropicModel,
 } from "../gateway-models";
 import { Logger } from "../utils/logger";
@@ -33,6 +34,8 @@ export interface BaseSession {
   settingsManager: SettingsManager;
 }
 
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+
 export abstract class BaseAcpAgent implements Agent {
   abstract readonly adapterName: string;
   protected session!: BaseSession;
@@ -40,6 +43,7 @@ export abstract class BaseAcpAgent implements Agent {
   client: AgentSideConnection;
   logger: Logger;
   fileContentCache: { [key: string]: string } = {};
+  protected gatewayModels: GatewayModel[] = [];
 
   constructor(client: AgentSideConnection) {
     this.client = client;
@@ -119,9 +123,9 @@ export abstract class BaseAcpAgent implements Agent {
     currentModelId: string;
     options: SessionConfigSelectOption[];
   }> {
-    const gatewayModels = await fetchGatewayModels();
+    this.gatewayModels = await fetchGatewayModels();
 
-    const options = gatewayModels
+    const options = this.gatewayModels
       .filter((model) => isAnthropicModel(model))
       .map((model) => ({
         value: model.id,
@@ -150,4 +154,9 @@ export abstract class BaseAcpAgent implements Agent {
 
     return { currentModelId, options };
   }
+
+  getContextWindowForModel(modelId: string): number {
+    const match = this.gatewayModels.find((m) => m.id === modelId);
+    return match?.context_window ?? DEFAULT_CONTEXT_WINDOW;
+  }
 }

package/src/adapters/claude/UPSTREAM.md

@@ -5,8 +5,8 @@ Fork of `@anthropic-ai/claude-agent-acp`. Upstream repo: https://github.com/anth
 ## Fork Point
 
 - **Forked**: v0.10.9, commit `5411e0f4`, Dec 2 2025
-- **Last sync**: v0.21.0, commit `c13edf3b02ddaf49f8e8b9e11b02cbf17869b57d`, March 9 2026
-- **SDK**: `@anthropic-ai/claude-agent-sdk` 0.2.71, `@agentclientprotocol/sdk` 0.15.0
+- **Last sync**: v0.22.2, commit `07db59e`, March 25 2026
+- **SDK**: `@anthropic-ai/claude-agent-sdk` 0.2.76, `@agentclientprotocol/sdk` 0.16.1
 
 ## File Mapping
 
@@ -49,13 +49,12 @@ Fork of `@anthropic-ai/claude-agent-acp`. Upstream repo: https://github.com/anth
 | Model resolution | `initializationResult.models` from SDK | `fetchGatewayModels()` from gateway API | Different model backend |
 | permissionMode | Hardcoded `"default"` | Reads from `meta.permissionMode` | More flexible mode selection |
 | Session storage | `this.sessions[sessionId]` (multi) | `this.session` (single) | Architectural choice |
-| ExitPlanMode denial | `interrupt: true` | `interrupt: false` | Better UX — lets Claude refine plan |
 | bypassPermissions | `updatedPermissions` with `destination: "session"` | No `updatedPermissions` | Different permission persistence |
 | Auth methods | Always returns `claude-login` auth method | Returns empty `authMethods` | Auth handled externally |
 
 ## Next Sync
 
-1. Check upstream changelog since v0.21.0
+1. Check upstream changelog since v0.22.2
 2. Diff upstream source against PostHog Code using the file mapping above
 3. Port in phases: bug fixes first, then features
 4. After each phase: `pnpm --filter agent typecheck && pnpm --filter agent build && pnpm lint`

package/src/adapters/claude/claude-agent.ts

@@ -64,8 +64,8 @@ import { getAvailableSlashCommands } from "./session/commands";
 import { parseMcpServers } from "./session/mcp-config";
 import {
   DEFAULT_MODEL,
-  getDefaultContextWindow,
   getEffortOptions,
+  resolveModelPreference,
   toSdkModelId,
 } from "./session/models";
 import {
@@ -89,6 +89,7 @@ import type {
 
 const SESSION_VALIDATION_TIMEOUT_MS = 10_000;
 const MAX_TITLE_LENGTH = 256;
+const LOCAL_ONLY_COMMANDS = new Set(["/context", "/heapdump", "/extra-usage"]);
 
 function sanitizeTitle(text: string): string {
   const sanitized = text
@@ -141,6 +142,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
           list: {},
           fork: {},
           resume: {},
+          close: {},
         },
         _meta: {
           posthog: {
@@ -195,6 +197,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   async unstable_resumeSession(
     params: ResumeSessionRequest,
   ): Promise<ResumeSessionResponse> {
+    // Reuse existing session if it matches
+    const existing = this.getExistingSessionState(params.sessionId);
+    if (existing) return existing;
+
     const response = await this.createSession(
       {
         cwd: params.cwd,
@@ -210,6 +216,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   }
 
   async loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse> {
+    // Reuse existing session if it matches
+    const existing = this.getExistingSessionState(params.sessionId);
+    if (existing) return existing;
+
     const response = await this.createSession(
       {
         cwd: params.cwd,
@@ -231,7 +241,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     };
   }
 
-  async unstable_listSessions(
+  async listSessions(
     params: ListSessionsRequest,
   ): Promise<ListSessionsResponse> {
     const sdkSessions = await listSessions({ dir: params.cwd ?? undefined });
@@ -251,6 +261,12 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     };
   }
 
+  async unstable_listSessions(
+    params: ListSessionsRequest,
+  ): Promise<ListSessionsResponse> {
+    return this.listSessions(params);
+  }
+
   async prompt(params: PromptRequest): Promise<PromptResponse> {
     this.session.cancelled = false;
     this.session.interruptReason = undefined;
@@ -262,18 +278,40 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     };
 
     const userMessage = promptToClaude(params);
+    const promptUuid = randomUUID();
+    userMessage.uuid = promptUuid;
+    let promptReplayed = false;
+    let isLocalOnlyCommand = false;
+
+    // Detect local-only slash commands that return results without model invocation
+    const msgContent = userMessage.message.content;
+    let firstTextPart = "";
+    if (typeof msgContent === "string") {
+      firstTextPart = msgContent;
+    } else if (Array.isArray(msgContent)) {
+      for (const block of msgContent) {
+        if ("type" in block && block.type === "text" && "text" in block) {
+          firstTextPart = block.text as string;
+          break;
+        }
+      }
+    }
+    const commandMatch = firstTextPart.match(/^(\/\S+)/);
+    if (commandMatch && LOCAL_ONLY_COMMANDS.has(commandMatch[1])) {
+      isLocalOnlyCommand = true;
+      promptReplayed = true;
+    }
 
     if (this.session.promptRunning) {
-      const uuid = randomUUID();
-      userMessage.uuid = uuid;
       this.session.input.push(userMessage);
       const order = this.session.nextPendingOrder++;
       const cancelled = await new Promise<boolean>((resolve) => {
-        this.session.pendingMessages.set(uuid, { resolve, order });
+        this.session.pendingMessages.set(promptUuid, { resolve, order });
       });
       if (cancelled) {
         return { stopReason: "cancelled" };
       }
+      promptReplayed = true;
     } else {
       this.session.input.push(userMessage);
     }
@@ -284,6 +322,16 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     this.session.promptRunning = true;
     let handedOff = false;
     let lastAssistantTotalUsage: number | null = null;
+    if (this.session.lastContextWindowSize == null) {
+      this.session.lastContextWindowSize = this.getContextWindowForModel(
+        this.session.modelId ?? "",
+      );
+      this.logger.debug("Initial context window size from gateway", {
+        modelId: this.session.modelId,
+        contextWindowSize: this.session.lastContextWindowSize,
+      });
+    }
+    let lastContextWindowSize = this.session.lastContextWindowSize;
 
     const supportsTerminalOutput =
       (
@@ -322,11 +370,24 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
           case "system":
             if (message.subtype === "compact_boundary") {
               lastAssistantTotalUsage = 0;
+              promptReplayed = true;
+            }
+            if (message.subtype === "local_command_output") {
+              promptReplayed = true;
             }
             await handleSystemMessage(message, context);
             break;
 
           case "result": {
+            // Skip results from background tasks that finished after our prompt started
+            if (!promptReplayed) {
+              this.logger.debug(
+                "Skipping background task result before prompt replay",
+                { sessionId: params.sessionId },
+              );
+              break;
+            }
+
             if (this.session.cancelled) {
               return { stopReason: "cancelled" };
             }
@@ -341,16 +402,25 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
             this.session.accumulatedUsage.cachedWriteTokens +=
               message.usage.cache_creation_input_tokens;
 
-            // Calculate context window size from modelUsage (minimum across all models used)
+            // SDK can underreport context window (e.g. 200k for 1M models).
+            // Use SDK value only if it's larger than what gateway reported.
             const contextWindows = Object.values(message.modelUsage).map(
               (m) => m.contextWindow,
             );
-            const contextWindowSize =
-              contextWindows.length > 0
-                ? Math.min(...contextWindows)
-                : getDefaultContextWindow(this.session.modelId ?? "");
+            if (contextWindows.length > 0) {
+              const sdkContextWindow = Math.min(...contextWindows);
+              if (sdkContextWindow > lastContextWindowSize) {
+                lastContextWindowSize = sdkContextWindow;
+              }
+            }
+            this.session.lastContextWindowSize = lastContextWindowSize;
+            this.logger.debug("Context window size from result", {
+              sdkReported: contextWindows,
+              resolved: lastContextWindowSize,
+              modelId: this.session.modelId,
+            });
 
-            this.session.contextSize = contextWindowSize;
+            this.session.contextSize = lastContextWindowSize;
             if (lastAssistantTotalUsage !== null) {
               this.session.contextUsed = lastAssistantTotalUsage;
             }
@@ -362,7 +432,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
                 update: {
                   sessionUpdate: "usage_update",
                   used: lastAssistantTotalUsage,
-                  size: contextWindowSize,
+                  size: lastContextWindowSize,
                   cost: {
                     amount: message.total_cost_usd,
                     currency: "USD",
@@ -398,6 +468,21 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
             const result = handleResultMessage(message);
             if (result.error) throw result.error;
 
+            // For local-only commands, forward the result text to the client
+            if (
+              isLocalOnlyCommand &&
+              message.subtype === "success" &&
+              message.result
+            ) {
+              await this.client.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "agent_message_chunk",
+                  content: { type: "text", text: message.result },
+                },
+              });
+            }
+
             return { stopReason: result.stopReason ?? "end_turn", usage };
           }
 
@@ -411,8 +496,13 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
               break;
             }
 
-            // Check for queued prompt replay
+            // Check for prompt replay (our own message echoed back)
             if (message.type === "user" && "uuid" in message && message.uuid) {
+              if (message.uuid === promptUuid) {
+                promptReplayed = true;
+                break;
+              }
+
               const pending = this.session.pendingMessages.get(
                 message.uuid as string,
               );
@@ -449,9 +539,18 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
               };
               lastAssistantTotalUsage =
                 usage.input_tokens +
-                usage.output_tokens +
                 usage.cache_read_input_tokens +
                 usage.cache_creation_input_tokens;
+
+              await this.client.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "usage_update",
+                  used: lastAssistantTotalUsage,
+                  size: lastContextWindowSize,
+                  cost: null,
+                },
+              });
             }
 
             const result = await handleUserAssistantMessage(message, context);
@@ -490,6 +589,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         this.logger.error(`Process died: ${msg}`, {
           sessionId: this.sessionId,
         });
+        this.session.settingsManager.dispose();
         this.session.input.end();
         throw RequestError.internalError(
           undefined,
@@ -522,9 +622,11 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
   async unstable_setSessionModel(
     params: SetSessionModelRequest,
   ): Promise<SetSessionModelResponse | undefined> {
-    const sdkModelId = toSdkModelId(params.modelId);
-    await this.session.query.setModel(sdkModelId);
+    await this.session.query.setModel(toSdkModelId(params.modelId));
     this.session.modelId = params.modelId;
+    this.session.lastContextWindowSize = this.getContextWindowForModel(
+      params.modelId,
+    );
     this.rebuildEffortConfigOption(params.modelId);
     await this.updateConfigOption("model", params.modelId);
     return {};
@@ -548,43 +650,72 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       throw new Error(`Unknown config option: ${params.configId}`);
     }
 
-    const allValues: { value: string }[] =
+    if (typeof params.value !== "string") {
+      throw new Error(
+        `Invalid value type for config option ${params.configId}`,
+      );
+    }
+
+    const allValues: { value: string; name?: string; description?: string }[] =
       "options" in option && Array.isArray(option.options)
         ? (option.options as Array<Record<string, unknown>>).flatMap((o) =>
             "options" in o && Array.isArray(o.options)
-              ? (o.options as { value: string }[])
-              : [o as { value: string }],
+              ? (o.options as {
+                  value: string;
+                  name?: string;
+                  description?: string;
+                }[])
+              : [o as { value: string; name?: string; description?: string }],
           )
         : [];
-    const validValue = allValues.find((o) => o.value === params.value);
+    let validValue = allValues.find((o) => o.value === params.value);
+
+    // For model options, fall back to alias resolution when exact match fails.
+    // This lets callers use human-friendly aliases like "opus" or "sonnet"
+    // instead of full model IDs like "claude-opus-4-6".
+    if (!validValue && params.configId === "model") {
+      const resolved = resolveModelPreference(params.value, allValues);
+      if (resolved) {
+        validValue = allValues.find((o) => o.value === resolved);
+      }
+    }
+
     if (!validValue) {
       throw new Error(
         `Invalid value for config option ${params.configId}: ${params.value}`,
       );
     }
 
+    // Use the canonical option value so downstream code always receives the
+    // model ID rather than the caller-supplied alias.
+    const resolvedValue = validValue.value;
+
     if (params.configId === "mode") {
-      await this.applySessionMode(params.value);
+      await this.applySessionMode(resolvedValue);
       await this.client.sessionUpdate({
         sessionId: this.sessionId,
         update: {
           sessionUpdate: "current_mode_update",
-          currentModeId: params.value,
+          currentModeId: resolvedValue,
         },
       });
     } else if (params.configId === "model") {
-      const sdkModelId = toSdkModelId(params.value);
+      const sdkModelId = toSdkModelId(resolvedValue);
       await this.session.query.setModel(sdkModelId);
-      this.session.modelId = params.value;
-      this.rebuildEffortConfigOption(params.value);
+      this.session.modelId = resolvedValue;
+      this.session.lastContextWindowSize =
+        this.getContextWindowForModel(resolvedValue);
+      this.rebuildEffortConfigOption(resolvedValue);
     } else if (params.configId === "effort") {
-      const newEffort = params.value as EffortLevel;
+      const newEffort = resolvedValue as EffortLevel;
       this.session.effort = newEffort;
       this.session.queryOptions.effort = newEffort;
     }
 
     this.session.configOptions = this.session.configOptions.map((o) =>
-      o.id === params.configId ? { ...o, currentValue: params.value } : o,
+      o.id === params.configId && typeof o.currentValue === "string"
+        ? { ...o, currentValue: resolvedValue }
+        : o,
     );
 
     return { configOptions: this.session.configOptions };
@@ -595,7 +726,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     value: string,
   ): Promise<void> {
     this.session.configOptions = this.session.configOptions.map((o) =>
-      o.id === configId ? { ...o, currentValue: value } : o,
+      o.id === configId && typeof o.currentValue === "string"
+        ? { ...o, currentValue: value }
+        : o,
     );
 
     await this.client.sessionUpdate({
@@ -691,7 +824,10 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       sessionId,
       isResume,
       forkSession,
-      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories,
+      additionalDirectories: [
+        ...(meta?.claudeCode?.options?.additionalDirectories ?? []),
+        ...(meta?.additionalRoots ?? []),
+      ],
       disableBuiltInTools: meta?.disableBuiltInTools,
       settingsManager,
       onModeChange: this.createOnModeChange(),
@@ -788,12 +924,12 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     const modelOptions = await this.getModelConfigOptions();
     const resolvedModelId = settingsModel || modelOptions.currentModelId;
     session.modelId = resolvedModelId;
+    session.lastContextWindowSize =
+      this.getContextWindowForModel(resolvedModelId);
 
-    if (!isResume) {
-      const resolvedSdkModel = toSdkModelId(resolvedModelId);
-      if (resolvedSdkModel !== DEFAULT_MODEL) {
-        await this.session.query.setModel(resolvedSdkModel);
-      }
+    const resolvedSdkModel = toSdkModelId(resolvedModelId);
+    if (!isResume && resolvedSdkModel !== DEFAULT_MODEL) {
+      await this.session.query.setModel(resolvedSdkModel);
     }
 
     const availableModes = getAvailableModes();
@@ -869,6 +1005,50 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     };
   }
 
+  private getExistingSessionState(
+    sessionId: string,
+  ): NewSessionResponse | null {
+    if (this.sessionId !== sessionId || !this.session) return null;
+
+    const availableModes = getAvailableModes();
+    const modes: SessionModeState = {
+      currentModeId: this.session.permissionMode,
+      availableModes: availableModes.map((mode) => ({
+        id: mode.id,
+        name: mode.name,
+        description: mode.description ?? undefined,
+      })),
+    };
+
+    const modelOptions = this.session.configOptions.find(
+      (o) => o.id === "model",
+    );
+    const models: SessionModelState = {
+      currentModelId: this.session.modelId ?? DEFAULT_MODEL,
+      availableModels:
+        modelOptions && "options" in modelOptions
+          ? (
+              modelOptions.options as Array<{
+                value: string;
+                name: string;
+                description?: string;
+              }>
+            ).map((opt) => ({
+              modelId: opt.value,
+              name: opt.name,
+              description: opt.description,
+            }))
+          : [],
+    };
+
+    return {
+      sessionId,
+      modes,
+      models,
+      configOptions: this.session.configOptions,
+    };
+  }
+
   private buildConfigOptions(
     currentModeId: string,
     modelOptions: {
@@ -938,7 +1118,9 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       return;
     }
 
-    const currentValue = existingEffort?.currentValue ?? "high";
+    const rawCurrentValue = existingEffort?.currentValue;
+    const currentValue =
+      typeof rawCurrentValue === "string" ? rawCurrentValue : "high";
     const isValidValue = effortOptions.some((o) => o.value === currentValue);
     const resolvedValue = isValidValue ? currentValue : "high";
 

package/src/adapters/claude/conversion/sdk-to-acp.ts

@@ -544,7 +544,7 @@ export async function handleSystemMessage(
   message: Extract<SDKMessage, { type: "system" }>,
   context: MessageHandlerContext,
 ): Promise<void> {
-  const { sessionId, client, logger } = context;
+  const { session, sessionId, client, logger } = context;
 
   switch (message.subtype) {
     case "init":
@@ -554,6 +554,7 @@ export async function handleSystemMessage(
         sessionId,
         trigger: message.compact_metadata.trigger,
         preTokens: message.compact_metadata.pre_tokens,
+        contextSize: session.contextSize,
       });
       break;
     case "hook_response":
@@ -797,30 +798,6 @@ export async function handleUserAssistantMessage(
     context;
 
   if (shouldSkipUserAssistantMessage(message)) {
-    const content = message.message.content;
-
-    // Handle /context by sending its reply as a regular agent message
-    if (
-      typeof content === "string" &&
-      hasLocalCommandStdout(content) &&
-      content.includes("Context Usage")
-    ) {
-      const stripped = content
-        .replace("<local-command-stdout>", "")
-        .replace("</local-command-stdout>", "");
-      for (const notification of toAcpNotifications(
-        stripped,
-        "assistant",
-        sessionId,
-        toolUseCache,
-        fileContentCache,
-        client,
-        logger,
-      )) {
-        await client.sessionUpdate(notification);
-      }
-    }
-
     logSpecialMessages(message, logger);
 
     if (isLoginRequiredMessage(message)) {

package/src/adapters/claude/permissions/permission-handlers.ts

@@ -34,7 +34,7 @@ export type ToolPermissionResult =
   | {
       behavior: "deny";
       message: string;
-      interrupt: boolean;
+      interrupt?: boolean;
     };
 
 interface ToolHandlerContext {
@@ -164,9 +164,11 @@ async function applyPlanApproval(
   if (
     response.outcome?.outcome === "selected" &&
     (response.outcome.optionId === "default" ||
-      response.outcome.optionId === "acceptEdits")
+      response.outcome.optionId === "acceptEdits" ||
+      response.outcome.optionId === "bypassPermissions")
   ) {
-    session.permissionMode = response.outcome.optionId;
+    session.permissionMode = response.outcome
+      .optionId as typeof session.permissionMode;
     await session.query.setPermissionMode(response.outcome.optionId);
     await context.client.sessionUpdate({
       sessionId: context.sessionId,
@@ -261,7 +263,6 @@ async function handleAskUserQuestionTool(
     return {
       behavior: "deny",
       message: "No questions provided",
-      interrupt: true,
     };
   }
 
@@ -303,7 +304,6 @@ async function handleAskUserQuestionTool(
         typeof customMessage === "string"
           ? customMessage
           : "User cancelled the questions",
-      interrupt: true,
     };
   }
 
@@ -312,7 +312,6 @@ async function handleAskUserQuestionTool(
     return {
       behavior: "deny",
       message: "User did not provide answers",
-      interrupt: true,
     };
   }
 
@@ -393,7 +392,6 @@ async function handleDefaultPermissionFlow(
     return {
       behavior: "deny",
       message,
-      interrupt: true,
     };
   }
 }

package/src/adapters/claude/permissions/permission-options.ts

@@ -1,4 +1,5 @@
 import type { PermissionUpdate } from "@anthropic-ai/claude-agent-sdk";
+import { IS_ROOT } from "../../../utils/common";
 import { BASH_TOOLS, READ_TOOLS, SEARCH_TOOLS, WRITE_TOOLS } from "../tools";
 
 export interface PermissionOption {
@@ -91,8 +92,20 @@ export function buildPermissionOptions(
   return permissionOptions("Yes, always allow");
 }
 
+const ALLOW_BYPASS = !IS_ROOT || !!process.env.IS_SANDBOX;
+
 export function buildExitPlanModePermissionOptions(): PermissionOption[] {
-  return [
+  const options: PermissionOption[] = [];
+
+  if (ALLOW_BYPASS) {
+    options.push({
+      kind: "allow_always",
+      name: "Yes, bypass all permissions",
+      optionId: "bypassPermissions",
+    });
+  }
+
+  options.push(
     {
       kind: "allow_always",
       name: "Yes, and auto-accept edits",
@@ -109,5 +122,7 @@ export function buildExitPlanModePermissionOptions(): PermissionOption[] {
       optionId: "reject_with_feedback",
       _meta: { customInput: true },
     },
-  ];
+  );
+
+  return options;
 }