@xelauvas/xela-cli 0.1.0

package/src/components/permissions/ExitPlanModePermissionRequest/ExitPlanModePermissionRequest.tsx

@@ -0,0 +1,768 @@
+import { feature } from 'bun:bundle';
+import type { UUID } from 'crypto';
+import figures from 'figures';
+import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import { useAppState, useAppStateStore, useSetAppState } from 'src/state/AppState.js';
+import { getSdkBetas, getSessionId, isSessionPersistenceDisabled, setHasExitedPlanMode, setNeedsAutoModeExitAttachment, setNeedsPlanModeExitAttachment } from '../../../bootstrap/state.js';
+import { generateSessionName } from '../../../commands/rename/generateSessionName.js';
+import { launchUltraplan } from '../../../commands/ultraplan.js';
+import type { KeyboardEvent } from '../../../ink/events/keyboard-event.js';
+import { Box, Text } from '../../../ink.js';
+import type { AppState } from '../../../state/AppStateStore.js';
+import { AGENT_TOOL_NAME } from '../../../tools/AgentTool/constants.js';
+import { EXIT_PLAN_MODE_V2_TOOL_NAME } from '../../../tools/ExitPlanModeTool/constants.js';
+import type { AllowedPrompt } from '../../../tools/ExitPlanModeTool/ExitPlanModeV2Tool.js';
+import { TEAM_CREATE_TOOL_NAME } from '../../../tools/TeamCreateTool/constants.js';
+import { isAgentSwarmsEnabled } from '../../../utils/agentSwarmsEnabled.js';
+import { calculateContextPercentages, getContextWindowForModel } from '../../../utils/context.js';
+import { getExternalEditor } from '../../../utils/editor.js';
+import { getDisplayPath } from '../../../utils/file.js';
+import { toIDEDisplayName } from '../../../utils/ide.js';
+import { logError } from '../../../utils/log.js';
+import { enqueuePendingNotification } from '../../../utils/messageQueueManager.js';
+import { createUserMessage } from '../../../utils/messages.js';
+import { getMainLoopModel, getRuntimeMainLoopModel } from '../../../utils/model/model.js';
+import { createPromptRuleContent, isClassifierPermissionsEnabled, PROMPT_PREFIX } from '../../../utils/permissions/bashClassifier.js';
+import { type PermissionMode, toExternalPermissionMode } from '../../../utils/permissions/PermissionMode.js';
+import type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js';
+import { isAutoModeGateEnabled, restoreDangerousPermissions, stripDangerousPermissionsForAutoMode } from '../../../utils/permissions/permissionSetup.js';
+import { getPewterLedgerVariant, isPlanModeInterviewPhaseEnabled } from '../../../utils/planModeV2.js';
+import { getPlan, getPlanFilePath } from '../../../utils/plans.js';
+import { editFileInEditor, editPromptInEditor } from '../../../utils/promptEditor.js';
+import { getCurrentSessionTitle, getTranscriptPath, saveAgentName, saveCustomTitle } from '../../../utils/sessionStorage.js';
+import { getSettings_DEPRECATED } from '../../../utils/settings/settings.js';
+import { type OptionWithDescription, Select } from '../../CustomSelect/index.js';
+import { Markdown } from '../../Markdown.js';
+import { PermissionDialog } from '../PermissionDialog.js';
+import type { PermissionRequestProps } from '../PermissionRequest.js';
+import { PermissionRuleExplanation } from '../PermissionRuleExplanation.js';
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const autoModeStateModule = feature('TRANSCRIPT_CLASSIFIER') ? require('../../../utils/permissions/autoModeState.js') as typeof import('../../../utils/permissions/autoModeState.js') : null;
+import type { Base64ImageSource, ImageBlockParam } from '@anthropic-ai/sdk/resources/messages.mjs';
+/* eslint-enable @typescript-eslint/no-require-imports */
+import type { PastedContent } from '../../../utils/config.js';
+import type { ImageDimensions } from '../../../utils/imageResizer.js';
+import { maybeResizeAndDownsampleImageBlock } from '../../../utils/imageResizer.js';
+import { cacheImagePath, storeImage } from '../../../utils/imageStore.js';
+type ResponseValue = 'yes-bypass-permissions' | 'yes-accept-edits' | 'yes-accept-edits-keep-context' | 'yes-default-keep-context' | 'yes-resume-auto-mode' | 'yes-auto-clear-context' | 'ultraplan' | 'no';
+
+/**
+ * Build permission updates for plan approval, including prompt-based rules if provided.
+ * Prompt-based rules are only added when classifier permissions are enabled (Ant-only).
+ */
+export function buildPermissionUpdates(mode: PermissionMode, allowedPrompts?: AllowedPrompt[]): PermissionUpdate[] {
+  const updates: PermissionUpdate[] = [{
+    type: 'setMode',
+    mode: toExternalPermissionMode(mode),
+    destination: 'session'
+  }];
+
+  // Add prompt-based permission rules if provided (Ant-only feature)
+  if (isClassifierPermissionsEnabled() && allowedPrompts && allowedPrompts.length > 0) {
+    updates.push({
+      type: 'addRules',
+      rules: allowedPrompts.map(p => ({
+        toolName: p.tool,
+        ruleContent: createPromptRuleContent(p.prompt)
+      })),
+      behavior: 'allow',
+      destination: 'session'
+    });
+  }
+  return updates;
+}
+
+/**
+ * Auto-name the session from the plan content when the user accepts a plan,
+ * if they haven't already named it via /rename or --name. Fire-and-forget.
+ * Mirrors /rename: kebab-case name, updates the prompt-border badge.
+ */
+export function autoNameSessionFromPlan(plan: string, setAppState: (updater: (prev: AppState) => AppState) => void, isClearContext: boolean): void {
+  if (isSessionPersistenceDisabled() || getSettings_DEPRECATED()?.cleanupPeriodDays === 0) {
+    return;
+  }
+  // On clear-context, the current session is about to be abandoned — its
+  // title (which may have been set by a PRIOR auto-name) is irrelevant.
+  // Checking it would make the feature self-defeating after first use.
+  if (!isClearContext && getCurrentSessionTitle(getSessionId())) return;
+  void generateSessionName(
+  // generateSessionName tail-slices to the last 1000 chars (correct for
+  // conversations, where recency matters). Plans front-load the goal and
+  // end with testing steps — head-slice so Haiku sees the summary.
+  [createUserMessage({
+    content: plan.slice(0, 1000)
+  })], new AbortController().signal).then(async name => {
+    // On clear-context acceptance, regenerateSessionId() has run by now —
+    // this intentionally names the NEW execution session. Do not "fix" by
+    // capturing sessionId once; that would name the abandoned planning session.
+    if (!name || getCurrentSessionTitle(getSessionId())) return;
+    const sessionId = getSessionId() as UUID;
+    const fullPath = getTranscriptPath();
+    await saveCustomTitle(sessionId, name, fullPath, 'auto');
+    await saveAgentName(sessionId, name, fullPath, 'auto');
+    setAppState(prev => {
+      if (prev.standaloneAgentContext?.name === name) return prev;
+      return {
+        ...prev,
+        standaloneAgentContext: {
+          ...prev.standaloneAgentContext,
+          name
+        }
+      };
+    });
+  }).catch(logError);
+}
+export function ExitPlanModePermissionRequest({
+  toolUseConfirm,
+  onDone,
+  onReject,
+  workerBadge,
+  setStickyFooter
+}: PermissionRequestProps): React.ReactNode {
+  const toolPermissionContext = useAppState(s => s.toolPermissionContext);
+  const setAppState = useSetAppState();
+  const store = useAppStateStore();
+  const {
+    addNotification
+  } = useNotifications();
+  // Feedback text from the 'No' option's input. Threaded through onAllow as
+  // acceptFeedback when the user approves — lets users annotate the plan
+  // ("also update the README") without a reject+re-plan round-trip.
+  const [planFeedback, setPlanFeedback] = useState('');
+  const [pastedContents, setPastedContents] = useState<Record<number, PastedContent>>({});
+  const nextPasteIdRef = useRef(0);
+  const showClearContext = useAppState(s => s.settings.showClearContextOnPlanAccept) ?? false;
+  const ultraplanSessionUrl = useAppState(s => s.ultraplanSessionUrl);
+  const ultraplanLaunching = useAppState(s => s.ultraplanLaunching);
+  // Hide the Ultraplan button while a session is active or launching —
+  // selecting it would dismiss the dialog and reject locally before
+  // launchUltraplan can notice the session exists and return "already polling".
+  // feature() must sit directly in an if/ternary (bun:bundle DCE constraint).
+  const showUltraplan = feature('ULTRAPLAN') ? !ultraplanSessionUrl && !ultraplanLaunching : false;
+  const usage = toolUseConfirm.assistantMessage.message.usage;
+  const {
+    mode,
+    isAutoModeAvailable,
+    isBypassPermissionsModeAvailable
+  } = toolPermissionContext;
+  const options = useMemo(() => buildPlanApprovalOptions({
+    showClearContext,
+    showUltraplan,
+    usedPercent: showClearContext ? getContextUsedPercent(usage, mode) : null,
+    isAutoModeAvailable,
+    isBypassPermissionsModeAvailable,
+    onFeedbackChange: setPlanFeedback
+  }), [showClearContext, showUltraplan, usage, mode, isAutoModeAvailable, isBypassPermissionsModeAvailable]);
+  function onImagePaste(base64Image: string, mediaType?: string, filename?: string, dimensions?: ImageDimensions, _sourcePath?: string) {
+    const pasteId = nextPasteIdRef.current++;
+    const newContent: PastedContent = {
+      id: pasteId,
+      type: 'image',
+      content: base64Image,
+      mediaType: mediaType || 'image/png',
+      filename: filename || 'Pasted image',
+      dimensions
+    };
+    cacheImagePath(newContent);
+    void storeImage(newContent);
+    setPastedContents(prev => ({
+      ...prev,
+      [pasteId]: newContent
+    }));
+  }
+  const onRemoveImage = useCallback((id: number) => {
+    setPastedContents(prev => {
+      const next = {
+        ...prev
+      };
+      delete next[id];
+      return next;
+    });
+  }, []);
+  const imageAttachments = Object.values(pastedContents).filter(c => c.type === 'image');
+  const hasImages = imageAttachments.length > 0;
+
+  // TODO: Delete the branch after moving to V2
+  // Use tool name to detect V2 instead of checking input.plan, because PR #10394
+  // injects plan content into input.plan for hooks/SDK, which broke the old detection
+  // (see issue #10878)
+  const isV2 = toolUseConfirm.tool.name === EXIT_PLAN_MODE_V2_TOOL_NAME;
+  const inputPlan = isV2 ? undefined : toolUseConfirm.input.plan as string | undefined;
+  const planFilePath = isV2 ? getPlanFilePath() : undefined;
+
+  // Extract allowed prompts requested by the plan (Ant-only feature)
+  const allowedPrompts = toolUseConfirm.input.allowedPrompts as AllowedPrompt[] | undefined;
+
+  // Get the raw plan to check if it's empty
+  const rawPlan = inputPlan ?? getPlan();
+  const isEmpty = !rawPlan || rawPlan.trim() === '';
+
+  // Capture the variant once on mount. GrowthBook reads from a disk cache
+  // so the value is stable across a single planning session. undefined =
+  // control arm. The variant is a fixed 3-value enum of short literals,
+  // not user input.
+  const [planStructureVariant] = useState(() => (getPewterLedgerVariant() ?? undefined) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS);
+  const [currentPlan, setCurrentPlan] = useState(() => {
+    if (inputPlan) return inputPlan;
+    const plan = getPlan();
+    return plan ?? 'No plan found. Please write your plan to the plan file first.';
+  });
+  const [showSaveMessage, setShowSaveMessage] = useState(false);
+  // Track Ctrl+G local edits so updatedInput can include the plan (the tool
+  // only echoes the plan in tool_result when input.plan is set — otherwise
+  // the model already has it in context from writing the plan file).
+  const [planEditedLocally, setPlanEditedLocally] = useState(false);
+
+  // Auto-hide save message after 5 seconds
+  useEffect(() => {
+    if (showSaveMessage) {
+      const timer = setTimeout(setShowSaveMessage, 5000, false);
+      return () => clearTimeout(timer);
+    }
+  }, [showSaveMessage]);
+
+  // Handle Ctrl+G to edit plan in $EDITOR, Shift+Tab for auto-accept edits
+  const handleKeyDown = (e: KeyboardEvent): void => {
+    if (e.ctrl && e.key === 'g') {
+      e.preventDefault();
+      logEvent('tengu_plan_external_editor_used', {});
+      void (async () => {
+        if (isV2 && planFilePath) {
+          const result = await editFileInEditor(planFilePath);
+          if (result.error) {
+            addNotification({
+              key: 'external-editor-error',
+              text: result.error,
+              color: 'warning',
+              priority: 'high'
+            });
+          }
+          if (result.content !== null) {
+            if (result.content !== currentPlan) setPlanEditedLocally(true);
+            setCurrentPlan(result.content);
+            setShowSaveMessage(true);
+          }
+        } else {
+          const result = await editPromptInEditor(currentPlan);
+          if (result.error) {
+            addNotification({
+              key: 'external-editor-error',
+              text: result.error,
+              color: 'warning',
+              priority: 'high'
+            });
+          }
+          if (result.content !== null && result.content !== currentPlan) {
+            setCurrentPlan(result.content);
+            setShowSaveMessage(true);
+          }
+        }
+      })();
+      return;
+    }
+
+    // Shift+Tab immediately selects "auto-accept edits"
+    if (e.shift && e.key === 'tab') {
+      e.preventDefault();
+      void handleResponse(showClearContext ? 'yes-accept-edits' : 'yes-accept-edits-keep-context');
+      return;
+    }
+  };
+  async function handleResponse(value: ResponseValue): Promise<void> {
+    const trimmedFeedback = planFeedback.trim();
+    const acceptFeedback = trimmedFeedback || undefined;
+
+    // Ultraplan: reject locally, teleport the plan to CCR as a seed draft.
+    // Dialog dismisses immediately so the query loop unblocks; the teleport
+    // runs detached and its launch message lands via the command queue.
+    if (value === 'ultraplan') {
+      logEvent('tengu_plan_exit', {
+        planLengthChars: currentPlan.length,
+        outcome: 'ultraplan' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant
+      });
+      onDone();
+      onReject();
+      toolUseConfirm.onReject('Plan being refined via Ultraplan — please wait for the result.');
+      void launchUltraplan({
+        blurb: '',
+        seedPlan: currentPlan,
+        getAppState: store.getState,
+        setAppState: store.setState,
+        signal: new AbortController().signal
+      }).then(msg => enqueuePendingNotification({
+        value: msg,
+        mode: 'task-notification'
+      })).catch(logError);
+      return;
+    }
+
+    // V1: pass plan in input. V2: plan is on disk, but if the user edited it
+    // via Ctrl+G we pass it through so the tool echoes the edit in tool_result
+    // (otherwise the model never sees the user's changes).
+    const updatedInput = isV2 && !planEditedLocally ? {} : {
+      plan: currentPlan
+    };
+
+    // If auto was active during plan (from auto mode or opt-in) and NOT going
+    // to auto, deactivate auto + restore permissions + fire exit attachment.
+    if (feature('TRANSCRIPT_CLASSIFIER')) {
+      const goingToAuto = (value === 'yes-resume-auto-mode' || value === 'yes-auto-clear-context') && isAutoModeGateEnabled();
+      // isAutoModeActive() is the authoritative signal — prePlanMode/
+      // strippedDangerousRules are stale after transitionPlanAutoMode
+      // deactivates mid-plan (would cause duplicate exit attachment).
+      const autoWasUsedDuringPlan = autoModeStateModule?.isAutoModeActive() ?? false;
+      if (value !== 'no' && !goingToAuto && autoWasUsedDuringPlan) {
+        autoModeStateModule?.setAutoModeActive(false);
+        setNeedsAutoModeExitAttachment(true);
+        setAppState(prev => ({
+          ...prev,
+          toolPermissionContext: {
+            ...restoreDangerousPermissions(prev.toolPermissionContext),
+            prePlanMode: undefined
+          }
+        }));
+      }
+    }
+
+    // Clear-context options: set pending plan implementation and reject the dialog
+    // The REPL will handle context clear and trigger a fresh query
+    // Keep-context options skip this block and go through the normal flow below
+    const isResumeAutoOption = feature('TRANSCRIPT_CLASSIFIER') ? value === 'yes-resume-auto-mode' : false;
+    const isKeepContextOption = value === 'yes-accept-edits-keep-context' || value === 'yes-default-keep-context' || isResumeAutoOption;
+    if (value !== 'no') {
+      autoNameSessionFromPlan(currentPlan, setAppState, !isKeepContextOption);
+    }
+    if (value !== 'no' && !isKeepContextOption) {
+      // Determine the permission mode based on the selected option
+      let mode: PermissionMode = 'default';
+      if (value === 'yes-bypass-permissions') {
+        mode = 'bypassPermissions';
+      } else if (value === 'yes-accept-edits') {
+        mode = 'acceptEdits';
+      } else if (feature('TRANSCRIPT_CLASSIFIER') && value === 'yes-auto-clear-context' && isAutoModeGateEnabled()) {
+        // REPL's processInitialMessage handles stripDangerousPermissions + mode,
+        // but does NOT set autoModeActive. Gate-off falls through to 'default'.
+        mode = 'auto';
+        autoModeStateModule?.setAutoModeActive(true);
+      }
+
+      // Log plan exit event
+      logEvent('tengu_plan_exit', {
+        planLengthChars: currentPlan.length,
+        outcome: value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        clearContext: true,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant,
+        hasFeedback: !!acceptFeedback
+      });
+
+      // Set initial message - REPL will handle context clear and fresh query
+      // Add verification instruction if the feature is enabled
+      // Dead code elimination: CLAUDE_CODE_VERIFY_PLAN='false' in external builds, so === 'true' check allows Bun to eliminate the string
+      const verificationInstruction = undefined === 'true' ? `\n\nIMPORTANT: When you have finished implementing the plan, you MUST call the "VerifyPlanExecution" tool directly (NOT the ${AGENT_TOOL_NAME} tool or an agent) to trigger background verification.` : '';
+
+      // Capture the transcript path before context is cleared (session ID will be regenerated)
+      const transcriptPath = getTranscriptPath();
+      const transcriptHint = `\n\nIf you need specific details from before exiting plan mode (like exact code snippets, error messages, or content you generated), read the full transcript at: ${transcriptPath}`;
+      const teamHint = isAgentSwarmsEnabled() ? `\n\nIf this plan can be broken down into multiple independent tasks, consider using the ${TEAM_CREATE_TOOL_NAME} tool to create a team and parallelize the work.` : '';
+      const feedbackSuffix = acceptFeedback ? `\n\nUser feedback on this plan: ${acceptFeedback}` : '';
+      setAppState(prev => ({
+        ...prev,
+        initialMessage: {
+          message: {
+            ...createUserMessage({
+              content: `Implement the following plan:\n\n${currentPlan}${verificationInstruction}${transcriptHint}${teamHint}${feedbackSuffix}`
+            }),
+            planContent: currentPlan
+          },
+          clearContext: true,
+          mode,
+          allowedPrompts
+        }
+      }));
+      setHasExitedPlanMode(true);
+      onDone();
+      onReject();
+      // Reject the tool use to unblock the query loop
+      // The REPL will see pendingInitialQuery and trigger fresh query
+      toolUseConfirm.onReject();
+      return;
+    }
+
+    // Handle auto keep-context option — needs special handling because
+    // buildPermissionUpdates maps auto to 'default' via toExternalPermissionMode.
+    // We set the mode directly via setAppState and sync the bootstrap state.
+    if (feature('TRANSCRIPT_CLASSIFIER') && value === 'yes-resume-auto-mode' && isAutoModeGateEnabled()) {
+      logEvent('tengu_plan_exit', {
+        planLengthChars: currentPlan.length,
+        outcome: value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        clearContext: false,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant,
+        hasFeedback: !!acceptFeedback
+      });
+      setHasExitedPlanMode(true);
+      setNeedsPlanModeExitAttachment(true);
+      autoModeStateModule?.setAutoModeActive(true);
+      setAppState(prev => ({
+        ...prev,
+        toolPermissionContext: stripDangerousPermissionsForAutoMode({
+          ...prev.toolPermissionContext,
+          mode: 'auto',
+          prePlanMode: undefined
+        })
+      }));
+      onDone();
+      toolUseConfirm.onAllow(updatedInput, [], acceptFeedback);
+      return;
+    }
+
+    // Handle keep-context options (goes through normal onAllow flow)
+    // yes-resume-auto-mode falls through here when the auto mode gate is
+    // disabled (e.g. circuit breaker fired after the dialog rendered).
+    // Without this fallback the function would return without resolving the
+    // dialog, leaving the query loop blocked and safety state corrupted.
+    const keepContextModes: Record<string, PermissionMode> = {
+      'yes-accept-edits-keep-context': toolPermissionContext.isBypassPermissionsModeAvailable ? 'bypassPermissions' : 'acceptEdits',
+      'yes-default-keep-context': 'default',
+      ...(feature('TRANSCRIPT_CLASSIFIER') ? {
+        'yes-resume-auto-mode': 'default' as const
+      } : {})
+    };
+    const keepContextMode = keepContextModes[value];
+    if (keepContextMode) {
+      logEvent('tengu_plan_exit', {
+        planLengthChars: currentPlan.length,
+        outcome: value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        clearContext: false,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant,
+        hasFeedback: !!acceptFeedback
+      });
+      setHasExitedPlanMode(true);
+      setNeedsPlanModeExitAttachment(true);
+      onDone();
+      toolUseConfirm.onAllow(updatedInput, buildPermissionUpdates(keepContextMode, allowedPrompts), acceptFeedback);
+      return;
+    }
+
+    // Handle standard approval options
+    const standardModes: Record<string, PermissionMode> = {
+      'yes-bypass-permissions': 'bypassPermissions',
+      'yes-accept-edits': 'acceptEdits'
+    };
+    const standardMode = standardModes[value];
+    if (standardMode) {
+      logEvent('tengu_plan_exit', {
+        planLengthChars: currentPlan.length,
+        outcome: value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant,
+        hasFeedback: !!acceptFeedback
+      });
+      setHasExitedPlanMode(true);
+      setNeedsPlanModeExitAttachment(true);
+      onDone();
+      toolUseConfirm.onAllow(updatedInput, buildPermissionUpdates(standardMode, allowedPrompts), acceptFeedback);
+      return;
+    }
+
+    // Handle 'no' - stay in plan mode
+    if (value === 'no') {
+      if (!trimmedFeedback && !hasImages) {
+        // No feedback yet - user is still on the input field
+        return;
+      }
+      logEvent('tengu_plan_exit', {
+        planLengthChars: currentPlan.length,
+        outcome: 'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant
+      });
+
+      // Convert pasted images to ImageBlockParam[] with resizing
+      let imageBlocks: ImageBlockParam[] | undefined;
+      if (hasImages) {
+        imageBlocks = await Promise.all(imageAttachments.map(async img => {
+          const block: ImageBlockParam = {
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: (img.mediaType || 'image/png') as Base64ImageSource['media_type'],
+              data: img.content
+            }
+          };
+          const resized = await maybeResizeAndDownsampleImageBlock(block);
+          return resized.block;
+        }));
+      }
+      onDone();
+      onReject();
+      toolUseConfirm.onReject(trimmedFeedback || (hasImages ? '(See attached image)' : undefined), imageBlocks && imageBlocks.length > 0 ? imageBlocks : undefined);
+    }
+  }
+  const editor = getExternalEditor();
+  const editorName = editor ? toIDEDisplayName(editor) : null;
+
+  // Sticky footer: when setStickyFooter is provided (fullscreen mode), the
+  // Select options render in FullscreenLayout's `bottom` slot so they stay
+  // visible while the user scrolls through a long plan. handleResponse is
+  // wrapped in a ref so the JSX (set once per options/images change) can call
+  // the latest closure without re-registering on every keystroke. React
+  // reconciles the sticky-footer Select by type, preserving focus/input state.
+  const handleResponseRef = useRef(handleResponse);
+  handleResponseRef.current = handleResponse;
+  const handleCancelRef = useRef<() => void>(undefined);
+  handleCancelRef.current = () => {
+    logEvent('tengu_plan_exit', {
+      planLengthChars: currentPlan.length,
+      outcome: 'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+      planStructureVariant
+    });
+    onDone();
+    onReject();
+    toolUseConfirm.onReject();
+  };
+  const useStickyFooter = !isEmpty && !!setStickyFooter;
+  useLayoutEffect(() => {
+    if (!useStickyFooter) return;
+    setStickyFooter(<Box flexDirection="column" borderStyle="round" borderColor="planMode" borderLeft={false} borderRight={false} borderBottom={false} paddingX={1}>
+        <Text dimColor>Would you like to proceed?</Text>
+        <Box marginTop={1}>
+          <Select options={options} onChange={v => void handleResponseRef.current(v)} onCancel={() => handleCancelRef.current?.()} onImagePaste={onImagePaste} pastedContents={pastedContents} onRemoveImage={onRemoveImage} />
+        </Box>
+        {editorName && <Box flexDirection="row" gap={1} marginTop={1}>
+            <Text dimColor>ctrl-g to edit in </Text>
+            <Text bold dimColor>
+              {editorName}
+            </Text>
+            {isV2 && planFilePath && <Text dimColor> · {getDisplayPath(planFilePath)}</Text>}
+            {showSaveMessage && <>
+                <Text dimColor>{' · '}</Text>
+                <Text color="success">{figures.tick}Plan saved!</Text>
+              </>}
+          </Box>}
+      </Box>);
+    return () => setStickyFooter(null);
+    // onImagePaste/onRemoveImage are stable (useCallback/useRef-backed above)
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [useStickyFooter, setStickyFooter, options, pastedContents, editorName, isV2, planFilePath, showSaveMessage]);
+
+  // Simplified UI for empty plans
+  if (isEmpty) {
+    function handleEmptyPlanResponse(value: 'yes' | 'no'): void {
+      if (value === 'yes') {
+        logEvent('tengu_plan_exit', {
+          planLengthChars: 0,
+          outcome: 'yes-default' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+          planStructureVariant
+        });
+        if (feature('TRANSCRIPT_CLASSIFIER')) {
+          const autoWasUsedDuringPlan = autoModeStateModule?.isAutoModeActive() ?? false;
+          if (autoWasUsedDuringPlan) {
+            autoModeStateModule?.setAutoModeActive(false);
+            setNeedsAutoModeExitAttachment(true);
+            setAppState(prev => ({
+              ...prev,
+              toolPermissionContext: {
+                ...restoreDangerousPermissions(prev.toolPermissionContext),
+                prePlanMode: undefined
+              }
+            }));
+          }
+        }
+        setHasExitedPlanMode(true);
+        setNeedsPlanModeExitAttachment(true);
+        onDone();
+        toolUseConfirm.onAllow({}, [{
+          type: 'setMode',
+          mode: 'default',
+          destination: 'session'
+        }]);
+      } else {
+        logEvent('tengu_plan_exit', {
+          planLengthChars: 0,
+          outcome: 'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+          planStructureVariant
+        });
+        onDone();
+        onReject();
+        toolUseConfirm.onReject();
+      }
+    }
+    return <PermissionDialog color="planMode" title="Exit plan mode?" workerBadge={workerBadge}>
+        <Box flexDirection="column" paddingX={1} marginTop={1}>
+          <Text>Claude wants to exit plan mode</Text>
+          <Box marginTop={1}>
+            <Select options={[{
+            label: 'Yes',
+            value: 'yes' as const
+          }, {
+            label: 'No',
+            value: 'no' as const
+          }]} onChange={handleEmptyPlanResponse} onCancel={() => {
+            logEvent('tengu_plan_exit', {
+              planLengthChars: 0,
+              outcome: 'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+              interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+              planStructureVariant
+            });
+            onDone();
+            onReject();
+            toolUseConfirm.onReject();
+          }} />
+          </Box>
+        </Box>
+      </PermissionDialog>;
+  }
+  return <Box flexDirection="column" tabIndex={0} autoFocus onKeyDown={handleKeyDown}>
+      <PermissionDialog color="planMode" title="Ready to code?" innerPaddingX={0} workerBadge={workerBadge}>
+        <Box flexDirection="column" marginTop={1}>
+          <Box paddingX={1} flexDirection="column">
+            <Text>Here is Claude&apos;s plan:</Text>
+          </Box>
+          <Box borderColor="subtle" borderStyle="dashed" flexDirection="column" borderLeft={false} borderRight={false} paddingX={1} marginBottom={1}
+        // Necessary for Windows Terminal to render properly
+        overflow="hidden">
+            <Markdown>{currentPlan}</Markdown>
+          </Box>
+          <Box flexDirection="column" paddingX={1}>
+            <PermissionRuleExplanation permissionResult={toolUseConfirm.permissionResult} toolType="tool" />
+            {isClassifierPermissionsEnabled() && allowedPrompts && allowedPrompts.length > 0 && <Box flexDirection="column" marginBottom={1}>
+                  <Text bold>Requested permissions:</Text>
+                  {allowedPrompts.map((p, i) => <Text key={i} dimColor>
+                      {'  '}· {p.tool}({PROMPT_PREFIX} {p.prompt})
+                    </Text>)}
+                </Box>}
+            {!useStickyFooter && <>
+                <Text dimColor>
+                  Claude has written up a plan and is ready to execute. Would
+                  you like to proceed?
+                </Text>
+                <Box marginTop={1}>
+                  <Select options={options} onChange={handleResponse} onCancel={() => handleCancelRef.current?.()} onImagePaste={onImagePaste} pastedContents={pastedContents} onRemoveImage={onRemoveImage} />
+                </Box>
+              </>}
+          </Box>
+        </Box>
+      </PermissionDialog>
+      {!useStickyFooter && editorName && <Box flexDirection="row" gap={1} paddingX={1} marginTop={1}>
+          <Box>
+            <Text dimColor>ctrl-g to edit in </Text>
+            <Text bold dimColor>
+              {editorName}
+            </Text>
+            {isV2 && planFilePath && <Text dimColor> · {getDisplayPath(planFilePath)}</Text>}
+          </Box>
+          {showSaveMessage && <Box>
+              <Text dimColor>{' · '}</Text>
+              <Text color="success">{figures.tick}Plan saved!</Text>
+            </Box>}
+        </Box>}
+    </Box>;
+}
+
+/** @internal Exported for testing. */
+export function buildPlanApprovalOptions({
+  showClearContext,
+  showUltraplan,
+  usedPercent,
+  isAutoModeAvailable,
+  isBypassPermissionsModeAvailable,
+  onFeedbackChange
+}: {
+  showClearContext: boolean;
+  showUltraplan: boolean;
+  usedPercent: number | null;
+  isAutoModeAvailable: boolean | undefined;
+  isBypassPermissionsModeAvailable: boolean | undefined;
+  onFeedbackChange: (v: string) => void;
+}): OptionWithDescription<ResponseValue>[] {
+  const options: OptionWithDescription<ResponseValue>[] = [];
+  const usedLabel = usedPercent !== null ? ` (${usedPercent}% used)` : '';
+  if (showClearContext) {
+    if (feature('TRANSCRIPT_CLASSIFIER') && isAutoModeAvailable) {
+      options.push({
+        label: `Yes, clear context${usedLabel} and use auto mode`,
+        value: 'yes-auto-clear-context'
+      });
+    } else if (isBypassPermissionsModeAvailable) {
+      options.push({
+        label: `Yes, clear context${usedLabel} and bypass permissions`,
+        value: 'yes-bypass-permissions'
+      });
+    } else {
+      options.push({
+        label: `Yes, clear context${usedLabel} and auto-accept edits`,
+        value: 'yes-accept-edits'
+      });
+    }
+  }
+
+  // Slot 2: keep-context with elevated mode (same priority: auto > bypass > edits).
+  if (feature('TRANSCRIPT_CLASSIFIER') && isAutoModeAvailable) {
+    options.push({
+      label: 'Yes, and use auto mode',
+      value: 'yes-resume-auto-mode'
+    });
+  } else if (isBypassPermissionsModeAvailable) {
+    options.push({
+      label: 'Yes, and bypass permissions',
+      value: 'yes-accept-edits-keep-context'
+    });
+  } else {
+    options.push({
+      label: 'Yes, auto-accept edits',
+      value: 'yes-accept-edits-keep-context'
+    });
+  }
+  options.push({
+    label: 'Yes, manually approve edits',
+    value: 'yes-default-keep-context'
+  });
+  if (showUltraplan) {
+    options.push({
+      label: 'No, refine with Ultraplan on Claude Code on the web',
+      value: 'ultraplan'
+    });
+  }
+  options.push({
+    type: 'input',
+    label: 'No, keep planning',
+    value: 'no',
+    placeholder: 'Tell Claude what to change',
+    description: 'shift+tab to approve with this feedback',
+    onChange: onFeedbackChange
+  });
+  return options;
+}
+function getContextUsedPercent(usage: {
+  input_tokens: number;
+  cache_creation_input_tokens?: number | null;
+  cache_read_input_tokens?: number | null;
+} | undefined, permissionMode: PermissionMode): number | null {
+  if (!usage) return null;
+  const runtimeModel = getRuntimeMainLoopModel({
+    permissionMode,
+    mainLoopModel: getMainLoopModel(),
+    exceeds200kTokens: false
+  });
+  const contextWindowSize = getContextWindowForModel(runtimeModel, getSdkBetas());
+  const {
+    used
+  } = calculateContextPercentages({
+    input_tokens: usage.input_tokens,
+    cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0,
+    cache_read_input_tokens: usage.cache_read_input_tokens ?? 0
+  }, contextWindowSize);
+  return used;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","UUID","figures","React","useCallback","useEffect","useLayoutEffect","useMemo","useRef","useState","useNotifications","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","useAppState","useAppStateStore","useSetAppState","getSdkBetas","getSessionId","isSessionPersistenceDisabled","setHasExitedPlanMode","setNeedsAutoModeExitAttachment","setNeedsPlanModeExitAttachment","generateSessionName","launchUltraplan","KeyboardEvent","Box","Text","AppState","AGENT_TOOL_NAME","EXIT_PLAN_MODE_V2_TOOL_NAME","AllowedPrompt","TEAM_CREATE_TOOL_NAME","isAgentSwarmsEnabled","calculateContextPercentages","getContextWindowForModel","getExternalEditor","getDisplayPath","toIDEDisplayName","logError","enqueuePendingNotification","createUserMessage","getMainLoopModel","getRuntimeMainLoopModel","createPromptRuleContent","isClassifierPermissionsEnabled","PROMPT_PREFIX","PermissionMode","toExternalPermissionMode","PermissionUpdate","isAutoModeGateEnabled","restoreDangerousPermissions","stripDangerousPermissionsForAutoMode","getPewterLedgerVariant","isPlanModeInterviewPhaseEnabled","getPlan","getPlanFilePath","editFileInEditor","editPromptInEditor","getCurrentSessionTitle","getTranscriptPath","saveAgentName","saveCustomTitle","getSettings_DEPRECATED","OptionWithDescription","Select","Markdown","PermissionDialog","PermissionRequestProps","PermissionRuleExplanation","autoModeStateModule","require","Base64ImageSource","ImageBlockParam","PastedContent","ImageDimensions","maybeResizeAndDownsampleImageBlock","cacheImagePath","storeImage","ResponseValue","buildPermissionUpdates","mode","allowedPrompts","updates","type","destination","length","push","rules","map","p","toolName","tool","ruleContent","prompt","behavior","autoNameSessionFromPlan","plan","setAppState","updater","prev","isClearContext","cleanupPeriodDays","content","slice","AbortController","signal","then","name","sessionId","fullPath","standaloneAgentContext","catch","ExitPlanModePermissionRequest","toolUseConfirm","onDone","onReject","workerBadge","setStickyFooter","ReactNode","toolPermissionContext","s","store","addNotification","planFeedback","setPlanFeedback","pastedContents","setPastedContents","Record","nextPasteIdRef","showClearContext","settings","showClearContextOnPlanAccept","ultraplanSessionUrl","ultraplanLaunching","showUltraplan","usage","assistantMessage","message","isAutoModeAvailable","isBypassPermissionsModeAvailable","options","buildPlanApprovalOptions","usedPercent","getContextUsedPercent","onFeedbackChange","onImagePaste","base64Image","mediaType","filename","dimensions","_sourcePath","pasteId","current","newContent","id","onRemoveImage","next","imageAttachments","Object","values","filter","c","hasImages","isV2","inputPlan","undefined","input","planFilePath","rawPlan","isEmpty","trim","planStructureVariant","currentPlan","setCurrentPlan","showSaveMessage","setShowSaveMessage","planEditedLocally","setPlanEditedLocally","timer","setTimeout","clearTimeout","handleKeyDown","e","ctrl","key","preventDefault","result","error","text","color","priority","shift","handleResponse","value","Promise","trimmedFeedback","acceptFeedback","planLengthChars","outcome","interviewPhaseEnabled","blurb","seedPlan","getAppState","getState","setState","msg","updatedInput","goingToAuto","autoWasUsedDuringPlan","isAutoModeActive","setAutoModeActive","prePlanMode","isResumeAutoOption","isKeepContextOption","clearContext","hasFeedback","verificationInstruction","transcriptPath","transcriptHint","teamHint","feedbackSuffix","initialMessage","planContent","onAllow","keepContextModes","const","keepContextMode","standardModes","standardMode","imageBlocks","all","img","block","source","media_type","data","resized","editor","editorName","handleResponseRef","handleCancelRef","useStickyFooter","v","tick","handleEmptyPlanResponse","label","permissionResult","i","usedLabel","placeholder","description","onChange","input_tokens","cache_creation_input_tokens","cache_read_input_tokens","permissionMode","runtimeModel","mainLoopModel","exceeds200kTokens","contextWindowSize","used"],"sources":["ExitPlanModePermissionRequest.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport type { UUID } from 'crypto'\nimport figures from 'figures'\nimport React, {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport {\n  useAppState,\n  useAppStateStore,\n  useSetAppState,\n} from 'src/state/AppState.js'\nimport {\n  getSdkBetas,\n  getSessionId,\n  isSessionPersistenceDisabled,\n  setHasExitedPlanMode,\n  setNeedsAutoModeExitAttachment,\n  setNeedsPlanModeExitAttachment,\n} from '../../../bootstrap/state.js'\nimport { generateSessionName } from '../../../commands/rename/generateSessionName.js'\nimport { launchUltraplan } from '../../../commands/ultraplan.js'\nimport type { KeyboardEvent } from '../../../ink/events/keyboard-event.js'\nimport { Box, Text } from '../../../ink.js'\nimport type { AppState } from '../../../state/AppStateStore.js'\nimport { AGENT_TOOL_NAME } from '../../../tools/AgentTool/constants.js'\nimport { EXIT_PLAN_MODE_V2_TOOL_NAME } from '../../../tools/ExitPlanModeTool/constants.js'\nimport type { AllowedPrompt } from '../../../tools/ExitPlanModeTool/ExitPlanModeV2Tool.js'\nimport { TEAM_CREATE_TOOL_NAME } from '../../../tools/TeamCreateTool/constants.js'\nimport { isAgentSwarmsEnabled } from '../../../utils/agentSwarmsEnabled.js'\nimport {\n  calculateContextPercentages,\n  getContextWindowForModel,\n} from '../../../utils/context.js'\nimport { getExternalEditor } from '../../../utils/editor.js'\nimport { getDisplayPath } from '../../../utils/file.js'\nimport { toIDEDisplayName } from '../../../utils/ide.js'\nimport { logError } from '../../../utils/log.js'\nimport { enqueuePendingNotification } from '../../../utils/messageQueueManager.js'\nimport { createUserMessage } from '../../../utils/messages.js'\nimport {\n  getMainLoopModel,\n  getRuntimeMainLoopModel,\n} from '../../../utils/model/model.js'\nimport {\n  createPromptRuleContent,\n  isClassifierPermissionsEnabled,\n  PROMPT_PREFIX,\n} from '../../../utils/permissions/bashClassifier.js'\nimport {\n  type PermissionMode,\n  toExternalPermissionMode,\n} from '../../../utils/permissions/PermissionMode.js'\nimport type { PermissionUpdate } from '../../../utils/permissions/PermissionUpdateSchema.js'\nimport {\n  isAutoModeGateEnabled,\n  restoreDangerousPermissions,\n  stripDangerousPermissionsForAutoMode,\n} from '../../../utils/permissions/permissionSetup.js'\nimport {\n  getPewterLedgerVariant,\n  isPlanModeInterviewPhaseEnabled,\n} from '../../../utils/planModeV2.js'\nimport { getPlan, getPlanFilePath } from '../../../utils/plans.js'\nimport {\n  editFileInEditor,\n  editPromptInEditor,\n} from '../../../utils/promptEditor.js'\nimport {\n  getCurrentSessionTitle,\n  getTranscriptPath,\n  saveAgentName,\n  saveCustomTitle,\n} from '../../../utils/sessionStorage.js'\nimport { getSettings_DEPRECATED } from '../../../utils/settings/settings.js'\nimport { type OptionWithDescription, Select } from '../../CustomSelect/index.js'\nimport { Markdown } from '../../Markdown.js'\nimport { PermissionDialog } from '../PermissionDialog.js'\nimport type { PermissionRequestProps } from '../PermissionRequest.js'\nimport { PermissionRuleExplanation } from '../PermissionRuleExplanation.js'\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst autoModeStateModule = feature('TRANSCRIPT_CLASSIFIER')\n  ? (require('../../../utils/permissions/autoModeState.js') as typeof import('../../../utils/permissions/autoModeState.js'))\n  : null\n\nimport type {\n  Base64ImageSource,\n  ImageBlockParam,\n} from '@anthropic-ai/sdk/resources/messages.mjs'\n/* eslint-enable @typescript-eslint/no-require-imports */\nimport type { PastedContent } from '../../../utils/config.js'\nimport type { ImageDimensions } from '../../../utils/imageResizer.js'\nimport { maybeResizeAndDownsampleImageBlock } from '../../../utils/imageResizer.js'\nimport { cacheImagePath, storeImage } from '../../../utils/imageStore.js'\n\ntype ResponseValue =\n  | 'yes-bypass-permissions'\n  | 'yes-accept-edits'\n  | 'yes-accept-edits-keep-context'\n  | 'yes-default-keep-context'\n  | 'yes-resume-auto-mode'\n  | 'yes-auto-clear-context'\n  | 'ultraplan'\n  | 'no'\n\n/**\n * Build permission updates for plan approval, including prompt-based rules if provided.\n * Prompt-based rules are only added when classifier permissions are enabled (Ant-only).\n */\nexport function buildPermissionUpdates(\n  mode: PermissionMode,\n  allowedPrompts?: AllowedPrompt[],\n): PermissionUpdate[] {\n  const updates: PermissionUpdate[] = [\n    {\n      type: 'setMode',\n      mode: toExternalPermissionMode(mode),\n      destination: 'session',\n    },\n  ]\n\n  // Add prompt-based permission rules if provided (Ant-only feature)\n  if (\n    isClassifierPermissionsEnabled() &&\n    allowedPrompts &&\n    allowedPrompts.length > 0\n  ) {\n    updates.push({\n      type: 'addRules',\n      rules: allowedPrompts.map(p => ({\n        toolName: p.tool,\n        ruleContent: createPromptRuleContent(p.prompt),\n      })),\n      behavior: 'allow',\n      destination: 'session',\n    })\n  }\n\n  return updates\n}\n\n/**\n * Auto-name the session from the plan content when the user accepts a plan,\n * if they haven't already named it via /rename or --name. Fire-and-forget.\n * Mirrors /rename: kebab-case name, updates the prompt-border badge.\n */\nexport function autoNameSessionFromPlan(\n  plan: string,\n  setAppState: (updater: (prev: AppState) => AppState) => void,\n  isClearContext: boolean,\n): void {\n  if (\n    isSessionPersistenceDisabled() ||\n    getSettings_DEPRECATED()?.cleanupPeriodDays === 0\n  ) {\n    return\n  }\n  // On clear-context, the current session is about to be abandoned — its\n  // title (which may have been set by a PRIOR auto-name) is irrelevant.\n  // Checking it would make the feature self-defeating after first use.\n  if (!isClearContext && getCurrentSessionTitle(getSessionId())) return\n  void generateSessionName(\n    // generateSessionName tail-slices to the last 1000 chars (correct for\n    // conversations, where recency matters). Plans front-load the goal and\n    // end with testing steps — head-slice so Haiku sees the summary.\n    [createUserMessage({ content: plan.slice(0, 1000) })],\n    new AbortController().signal,\n  )\n    .then(async name => {\n      // On clear-context acceptance, regenerateSessionId() has run by now —\n      // this intentionally names the NEW execution session. Do not \"fix\" by\n      // capturing sessionId once; that would name the abandoned planning session.\n      if (!name || getCurrentSessionTitle(getSessionId())) return\n      const sessionId = getSessionId() as UUID\n      const fullPath = getTranscriptPath()\n      await saveCustomTitle(sessionId, name, fullPath, 'auto')\n      await saveAgentName(sessionId, name, fullPath, 'auto')\n      setAppState(prev => {\n        if (prev.standaloneAgentContext?.name === name) return prev\n        return {\n          ...prev,\n          standaloneAgentContext: { ...prev.standaloneAgentContext, name },\n        }\n      })\n    })\n    .catch(logError)\n}\n\nexport function ExitPlanModePermissionRequest({\n  toolUseConfirm,\n  onDone,\n  onReject,\n  workerBadge,\n  setStickyFooter,\n}: PermissionRequestProps): React.ReactNode {\n  const toolPermissionContext = useAppState(s => s.toolPermissionContext)\n  const setAppState = useSetAppState()\n  const store = useAppStateStore()\n  const { addNotification } = useNotifications()\n  // Feedback text from the 'No' option's input. Threaded through onAllow as\n  // acceptFeedback when the user approves — lets users annotate the plan\n  // (\"also update the README\") without a reject+re-plan round-trip.\n  const [planFeedback, setPlanFeedback] = useState('')\n  const [pastedContents, setPastedContents] = useState<\n    Record<number, PastedContent>\n  >({})\n  const nextPasteIdRef = useRef(0)\n\n  const showClearContext =\n    useAppState(s => s.settings.showClearContextOnPlanAccept) ?? false\n  const ultraplanSessionUrl = useAppState(s => s.ultraplanSessionUrl)\n  const ultraplanLaunching = useAppState(s => s.ultraplanLaunching)\n  // Hide the Ultraplan button while a session is active or launching —\n  // selecting it would dismiss the dialog and reject locally before\n  // launchUltraplan can notice the session exists and return \"already polling\".\n  // feature() must sit directly in an if/ternary (bun:bundle DCE constraint).\n  const showUltraplan = feature('ULTRAPLAN')\n    ? !ultraplanSessionUrl && !ultraplanLaunching\n    : false\n  const usage = toolUseConfirm.assistantMessage.message.usage\n  const { mode, isAutoModeAvailable, isBypassPermissionsModeAvailable } =\n    toolPermissionContext\n  const options = useMemo(\n    () =>\n      buildPlanApprovalOptions({\n        showClearContext,\n        showUltraplan,\n        usedPercent: showClearContext\n          ? getContextUsedPercent(usage, mode)\n          : null,\n        isAutoModeAvailable,\n        isBypassPermissionsModeAvailable,\n        onFeedbackChange: setPlanFeedback,\n      }),\n    [\n      showClearContext,\n      showUltraplan,\n      usage,\n      mode,\n      isAutoModeAvailable,\n      isBypassPermissionsModeAvailable,\n    ],\n  )\n\n  function onImagePaste(\n    base64Image: string,\n    mediaType?: string,\n    filename?: string,\n    dimensions?: ImageDimensions,\n    _sourcePath?: string,\n  ) {\n    const pasteId = nextPasteIdRef.current++\n    const newContent: PastedContent = {\n      id: pasteId,\n      type: 'image',\n      content: base64Image,\n      mediaType: mediaType || 'image/png',\n      filename: filename || 'Pasted image',\n      dimensions,\n    }\n    cacheImagePath(newContent)\n    void storeImage(newContent)\n    setPastedContents(prev => ({ ...prev, [pasteId]: newContent }))\n  }\n\n  const onRemoveImage = useCallback((id: number) => {\n    setPastedContents(prev => {\n      const next = { ...prev }\n      delete next[id]\n      return next\n    })\n  }, [])\n\n  const imageAttachments = Object.values(pastedContents).filter(\n    c => c.type === 'image',\n  )\n  const hasImages = imageAttachments.length > 0\n\n  // TODO: Delete the branch after moving to V2\n  // Use tool name to detect V2 instead of checking input.plan, because PR #10394\n  // injects plan content into input.plan for hooks/SDK, which broke the old detection\n  // (see issue #10878)\n  const isV2 = toolUseConfirm.tool.name === EXIT_PLAN_MODE_V2_TOOL_NAME\n  const inputPlan = isV2\n    ? undefined\n    : (toolUseConfirm.input.plan as string | undefined)\n  const planFilePath = isV2 ? getPlanFilePath() : undefined\n\n  // Extract allowed prompts requested by the plan (Ant-only feature)\n  const allowedPrompts = toolUseConfirm.input.allowedPrompts as\n    | AllowedPrompt[]\n    | undefined\n\n  // Get the raw plan to check if it's empty\n  const rawPlan = inputPlan ?? getPlan()\n  const isEmpty = !rawPlan || rawPlan.trim() === ''\n\n  // Capture the variant once on mount. GrowthBook reads from a disk cache\n  // so the value is stable across a single planning session. undefined =\n  // control arm. The variant is a fixed 3-value enum of short literals,\n  // not user input.\n  const [planStructureVariant] = useState(\n    () =>\n      (getPewterLedgerVariant() ??\n        undefined) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  )\n\n  const [currentPlan, setCurrentPlan] = useState(() => {\n    if (inputPlan) return inputPlan\n    const plan = getPlan()\n    return (\n      plan ?? 'No plan found. Please write your plan to the plan file first.'\n    )\n  })\n  const [showSaveMessage, setShowSaveMessage] = useState(false)\n  // Track Ctrl+G local edits so updatedInput can include the plan (the tool\n  // only echoes the plan in tool_result when input.plan is set — otherwise\n  // the model already has it in context from writing the plan file).\n  const [planEditedLocally, setPlanEditedLocally] = useState(false)\n\n  // Auto-hide save message after 5 seconds\n  useEffect(() => {\n    if (showSaveMessage) {\n      const timer = setTimeout(setShowSaveMessage, 5000, false)\n      return () => clearTimeout(timer)\n    }\n  }, [showSaveMessage])\n\n  // Handle Ctrl+G to edit plan in $EDITOR, Shift+Tab for auto-accept edits\n  const handleKeyDown = (e: KeyboardEvent): void => {\n    if (e.ctrl && e.key === 'g') {\n      e.preventDefault()\n      logEvent('tengu_plan_external_editor_used', {})\n\n      void (async () => {\n        if (isV2 && planFilePath) {\n          const result = await editFileInEditor(planFilePath)\n          if (result.error) {\n            addNotification({\n              key: 'external-editor-error',\n              text: result.error,\n              color: 'warning',\n              priority: 'high',\n            })\n          }\n          if (result.content !== null) {\n            if (result.content !== currentPlan) setPlanEditedLocally(true)\n            setCurrentPlan(result.content)\n            setShowSaveMessage(true)\n          }\n        } else {\n          const result = await editPromptInEditor(currentPlan)\n          if (result.error) {\n            addNotification({\n              key: 'external-editor-error',\n              text: result.error,\n              color: 'warning',\n              priority: 'high',\n            })\n          }\n          if (result.content !== null && result.content !== currentPlan) {\n            setCurrentPlan(result.content)\n            setShowSaveMessage(true)\n          }\n        }\n      })()\n      return\n    }\n\n    // Shift+Tab immediately selects \"auto-accept edits\"\n    if (e.shift && e.key === 'tab') {\n      e.preventDefault()\n      void handleResponse(\n        showClearContext ? 'yes-accept-edits' : 'yes-accept-edits-keep-context',\n      )\n      return\n    }\n  }\n\n  async function handleResponse(value: ResponseValue): Promise<void> {\n    const trimmedFeedback = planFeedback.trim()\n    const acceptFeedback = trimmedFeedback || undefined\n\n    // Ultraplan: reject locally, teleport the plan to CCR as a seed draft.\n    // Dialog dismisses immediately so the query loop unblocks; the teleport\n    // runs detached and its launch message lands via the command queue.\n    if (value === 'ultraplan') {\n      logEvent('tengu_plan_exit', {\n        planLengthChars: currentPlan.length,\n        outcome:\n          'ultraplan' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n        planStructureVariant,\n      })\n      onDone()\n      onReject()\n      toolUseConfirm.onReject(\n        'Plan being refined via Ultraplan — please wait for the result.',\n      )\n      void launchUltraplan({\n        blurb: '',\n        seedPlan: currentPlan,\n        getAppState: store.getState,\n        setAppState: store.setState,\n        signal: new AbortController().signal,\n      })\n        .then(msg =>\n          enqueuePendingNotification({ value: msg, mode: 'task-notification' }),\n        )\n        .catch(logError)\n      return\n    }\n\n    // V1: pass plan in input. V2: plan is on disk, but if the user edited it\n    // via Ctrl+G we pass it through so the tool echoes the edit in tool_result\n    // (otherwise the model never sees the user's changes).\n    const updatedInput = isV2 && !planEditedLocally ? {} : { plan: currentPlan }\n\n    // If auto was active during plan (from auto mode or opt-in) and NOT going\n    // to auto, deactivate auto + restore permissions + fire exit attachment.\n    if (feature('TRANSCRIPT_CLASSIFIER')) {\n      const goingToAuto =\n        (value === 'yes-resume-auto-mode' ||\n          value === 'yes-auto-clear-context') &&\n        isAutoModeGateEnabled()\n      // isAutoModeActive() is the authoritative signal — prePlanMode/\n      // strippedDangerousRules are stale after transitionPlanAutoMode\n      // deactivates mid-plan (would cause duplicate exit attachment).\n      const autoWasUsedDuringPlan =\n        autoModeStateModule?.isAutoModeActive() ?? false\n      if (value !== 'no' && !goingToAuto && autoWasUsedDuringPlan) {\n        autoModeStateModule?.setAutoModeActive(false)\n        setNeedsAutoModeExitAttachment(true)\n        setAppState(prev => ({\n          ...prev,\n          toolPermissionContext: {\n            ...restoreDangerousPermissions(prev.toolPermissionContext),\n            prePlanMode: undefined,\n          },\n        }))\n      }\n    }\n\n    // Clear-context options: set pending plan implementation and reject the dialog\n    // The REPL will handle context clear and trigger a fresh query\n    // Keep-context options skip this block and go through the normal flow below\n    const isResumeAutoOption = feature('TRANSCRIPT_CLASSIFIER')\n      ? value === 'yes-resume-auto-mode'\n      : false\n    const isKeepContextOption =\n      value === 'yes-accept-edits-keep-context' ||\n      value === 'yes-default-keep-context' ||\n      isResumeAutoOption\n\n    if (value !== 'no') {\n      autoNameSessionFromPlan(currentPlan, setAppState, !isKeepContextOption)\n    }\n\n    if (value !== 'no' && !isKeepContextOption) {\n      // Determine the permission mode based on the selected option\n      let mode: PermissionMode = 'default'\n      if (value === 'yes-bypass-permissions') {\n        mode = 'bypassPermissions'\n      } else if (value === 'yes-accept-edits') {\n        mode = 'acceptEdits'\n      } else if (\n        feature('TRANSCRIPT_CLASSIFIER') &&\n        value === 'yes-auto-clear-context' &&\n        isAutoModeGateEnabled()\n      ) {\n        // REPL's processInitialMessage handles stripDangerousPermissions + mode,\n        // but does NOT set autoModeActive. Gate-off falls through to 'default'.\n        mode = 'auto'\n        autoModeStateModule?.setAutoModeActive(true)\n      }\n\n      // Log plan exit event\n      logEvent('tengu_plan_exit', {\n        planLengthChars: currentPlan.length,\n        outcome:\n          value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        clearContext: true,\n        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n        planStructureVariant,\n        hasFeedback: !!acceptFeedback,\n      })\n\n      // Set initial message - REPL will handle context clear and fresh query\n      // Add verification instruction if the feature is enabled\n      // Dead code elimination: CLAUDE_CODE_VERIFY_PLAN='false' in external builds, so === 'true' check allows Bun to eliminate the string\n      const verificationInstruction =\n        undefined === 'true'\n          ? `\\n\\nIMPORTANT: When you have finished implementing the plan, you MUST call the \"VerifyPlanExecution\" tool directly (NOT the ${AGENT_TOOL_NAME} tool or an agent) to trigger background verification.`\n          : ''\n\n      // Capture the transcript path before context is cleared (session ID will be regenerated)\n      const transcriptPath = getTranscriptPath()\n      const transcriptHint = `\\n\\nIf you need specific details from before exiting plan mode (like exact code snippets, error messages, or content you generated), read the full transcript at: ${transcriptPath}`\n\n      const teamHint = isAgentSwarmsEnabled()\n        ? `\\n\\nIf this plan can be broken down into multiple independent tasks, consider using the ${TEAM_CREATE_TOOL_NAME} tool to create a team and parallelize the work.`\n        : ''\n\n      const feedbackSuffix = acceptFeedback\n        ? `\\n\\nUser feedback on this plan: ${acceptFeedback}`\n        : ''\n\n      setAppState(prev => ({\n        ...prev,\n        initialMessage: {\n          message: {\n            ...createUserMessage({\n              content: `Implement the following plan:\\n\\n${currentPlan}${verificationInstruction}${transcriptHint}${teamHint}${feedbackSuffix}`,\n            }),\n            planContent: currentPlan,\n          },\n          clearContext: true,\n          mode,\n          allowedPrompts,\n        },\n      }))\n\n      setHasExitedPlanMode(true)\n      onDone()\n      onReject()\n      // Reject the tool use to unblock the query loop\n      // The REPL will see pendingInitialQuery and trigger fresh query\n      toolUseConfirm.onReject()\n      return\n    }\n\n    // Handle auto keep-context option — needs special handling because\n    // buildPermissionUpdates maps auto to 'default' via toExternalPermissionMode.\n    // We set the mode directly via setAppState and sync the bootstrap state.\n    if (\n      feature('TRANSCRIPT_CLASSIFIER') &&\n      value === 'yes-resume-auto-mode' &&\n      isAutoModeGateEnabled()\n    ) {\n      logEvent('tengu_plan_exit', {\n        planLengthChars: currentPlan.length,\n        outcome:\n          value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        clearContext: false,\n        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n        planStructureVariant,\n        hasFeedback: !!acceptFeedback,\n      })\n      setHasExitedPlanMode(true)\n      setNeedsPlanModeExitAttachment(true)\n      autoModeStateModule?.setAutoModeActive(true)\n      setAppState(prev => ({\n        ...prev,\n        toolPermissionContext: stripDangerousPermissionsForAutoMode({\n          ...prev.toolPermissionContext,\n          mode: 'auto',\n          prePlanMode: undefined,\n        }),\n      }))\n      onDone()\n      toolUseConfirm.onAllow(updatedInput, [], acceptFeedback)\n      return\n    }\n\n    // Handle keep-context options (goes through normal onAllow flow)\n    // yes-resume-auto-mode falls through here when the auto mode gate is\n    // disabled (e.g. circuit breaker fired after the dialog rendered).\n    // Without this fallback the function would return without resolving the\n    // dialog, leaving the query loop blocked and safety state corrupted.\n    const keepContextModes: Record<string, PermissionMode> = {\n      'yes-accept-edits-keep-context':\n        toolPermissionContext.isBypassPermissionsModeAvailable\n          ? 'bypassPermissions'\n          : 'acceptEdits',\n      'yes-default-keep-context': 'default',\n      ...(feature('TRANSCRIPT_CLASSIFIER')\n        ? { 'yes-resume-auto-mode': 'default' as const }\n        : {}),\n    }\n    const keepContextMode = keepContextModes[value]\n    if (keepContextMode) {\n      logEvent('tengu_plan_exit', {\n        planLengthChars: currentPlan.length,\n        outcome:\n          value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        clearContext: false,\n        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n        planStructureVariant,\n        hasFeedback: !!acceptFeedback,\n      })\n      setHasExitedPlanMode(true)\n      setNeedsPlanModeExitAttachment(true)\n      onDone()\n      toolUseConfirm.onAllow(\n        updatedInput,\n        buildPermissionUpdates(keepContextMode, allowedPrompts),\n        acceptFeedback,\n      )\n      return\n    }\n\n    // Handle standard approval options\n    const standardModes: Record<string, PermissionMode> = {\n      'yes-bypass-permissions': 'bypassPermissions',\n      'yes-accept-edits': 'acceptEdits',\n    }\n    const standardMode = standardModes[value]\n    if (standardMode) {\n      logEvent('tengu_plan_exit', {\n        planLengthChars: currentPlan.length,\n        outcome:\n          value as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n        planStructureVariant,\n        hasFeedback: !!acceptFeedback,\n      })\n      setHasExitedPlanMode(true)\n      setNeedsPlanModeExitAttachment(true)\n      onDone()\n      toolUseConfirm.onAllow(\n        updatedInput,\n        buildPermissionUpdates(standardMode, allowedPrompts),\n        acceptFeedback,\n      )\n      return\n    }\n\n    // Handle 'no' - stay in plan mode\n    if (value === 'no') {\n      if (!trimmedFeedback && !hasImages) {\n        // No feedback yet - user is still on the input field\n        return\n      }\n\n      logEvent('tengu_plan_exit', {\n        planLengthChars: currentPlan.length,\n        outcome:\n          'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n        planStructureVariant,\n      })\n\n      // Convert pasted images to ImageBlockParam[] with resizing\n      let imageBlocks: ImageBlockParam[] | undefined\n      if (hasImages) {\n        imageBlocks = await Promise.all(\n          imageAttachments.map(async img => {\n            const block: ImageBlockParam = {\n              type: 'image',\n              source: {\n                type: 'base64',\n                media_type: (img.mediaType ||\n                  'image/png') as Base64ImageSource['media_type'],\n                data: img.content,\n              },\n            }\n            const resized = await maybeResizeAndDownsampleImageBlock(block)\n            return resized.block\n          }),\n        )\n      }\n\n      onDone()\n      onReject()\n      toolUseConfirm.onReject(\n        trimmedFeedback || (hasImages ? '(See attached image)' : undefined),\n        imageBlocks && imageBlocks.length > 0 ? imageBlocks : undefined,\n      )\n    }\n  }\n\n  const editor = getExternalEditor()\n  const editorName = editor ? toIDEDisplayName(editor) : null\n\n  // Sticky footer: when setStickyFooter is provided (fullscreen mode), the\n  // Select options render in FullscreenLayout's `bottom` slot so they stay\n  // visible while the user scrolls through a long plan. handleResponse is\n  // wrapped in a ref so the JSX (set once per options/images change) can call\n  // the latest closure without re-registering on every keystroke. React\n  // reconciles the sticky-footer Select by type, preserving focus/input state.\n  const handleResponseRef = useRef(handleResponse)\n  handleResponseRef.current = handleResponse\n  const handleCancelRef = useRef<() => void>(undefined)\n  handleCancelRef.current = () => {\n    logEvent('tengu_plan_exit', {\n      planLengthChars: currentPlan.length,\n      outcome:\n        'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n      planStructureVariant,\n    })\n    onDone()\n    onReject()\n    toolUseConfirm.onReject()\n  }\n  const useStickyFooter = !isEmpty && !!setStickyFooter\n  useLayoutEffect(() => {\n    if (!useStickyFooter) return\n    setStickyFooter(\n      <Box\n        flexDirection=\"column\"\n        borderStyle=\"round\"\n        borderColor=\"planMode\"\n        borderLeft={false}\n        borderRight={false}\n        borderBottom={false}\n        paddingX={1}\n      >\n        <Text dimColor>Would you like to proceed?</Text>\n        <Box marginTop={1}>\n          <Select\n            options={options}\n            onChange={v => void handleResponseRef.current(v)}\n            onCancel={() => handleCancelRef.current?.()}\n            onImagePaste={onImagePaste}\n            pastedContents={pastedContents}\n            onRemoveImage={onRemoveImage}\n          />\n        </Box>\n        {editorName && (\n          <Box flexDirection=\"row\" gap={1} marginTop={1}>\n            <Text dimColor>ctrl-g to edit in </Text>\n            <Text bold dimColor>\n              {editorName}\n            </Text>\n            {isV2 && planFilePath && (\n              <Text dimColor> · {getDisplayPath(planFilePath)}</Text>\n            )}\n            {showSaveMessage && (\n              <>\n                <Text dimColor>{' · '}</Text>\n                <Text color=\"success\">{figures.tick}Plan saved!</Text>\n              </>\n            )}\n          </Box>\n        )}\n      </Box>,\n    )\n    return () => setStickyFooter(null)\n    // onImagePaste/onRemoveImage are stable (useCallback/useRef-backed above)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [\n    useStickyFooter,\n    setStickyFooter,\n    options,\n    pastedContents,\n    editorName,\n    isV2,\n    planFilePath,\n    showSaveMessage,\n  ])\n\n  // Simplified UI for empty plans\n  if (isEmpty) {\n    function handleEmptyPlanResponse(value: 'yes' | 'no'): void {\n      if (value === 'yes') {\n        logEvent('tengu_plan_exit', {\n          planLengthChars: 0,\n          outcome:\n            'yes-default' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n          planStructureVariant,\n        })\n        if (feature('TRANSCRIPT_CLASSIFIER')) {\n          const autoWasUsedDuringPlan =\n            autoModeStateModule?.isAutoModeActive() ?? false\n          if (autoWasUsedDuringPlan) {\n            autoModeStateModule?.setAutoModeActive(false)\n            setNeedsAutoModeExitAttachment(true)\n            setAppState(prev => ({\n              ...prev,\n              toolPermissionContext: {\n                ...restoreDangerousPermissions(prev.toolPermissionContext),\n                prePlanMode: undefined,\n              },\n            }))\n          }\n        }\n        setHasExitedPlanMode(true)\n        setNeedsPlanModeExitAttachment(true)\n        onDone()\n        toolUseConfirm.onAllow({}, [\n          { type: 'setMode', mode: 'default', destination: 'session' },\n        ])\n      } else {\n        logEvent('tengu_plan_exit', {\n          planLengthChars: 0,\n          outcome:\n            'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n          interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n          planStructureVariant,\n        })\n        onDone()\n        onReject()\n        toolUseConfirm.onReject()\n      }\n    }\n\n    return (\n      <PermissionDialog\n        color=\"planMode\"\n        title=\"Exit plan mode?\"\n        workerBadge={workerBadge}\n      >\n        <Box flexDirection=\"column\" paddingX={1} marginTop={1}>\n          <Text>Claude wants to exit plan mode</Text>\n          <Box marginTop={1}>\n            <Select\n              options={[\n                { label: 'Yes', value: 'yes' as const },\n                { label: 'No', value: 'no' as const },\n              ]}\n              onChange={handleEmptyPlanResponse}\n              onCancel={() => {\n                logEvent('tengu_plan_exit', {\n                  planLengthChars: 0,\n                  outcome:\n                    'no' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n                  interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),\n                  planStructureVariant,\n                })\n                onDone()\n                onReject()\n                toolUseConfirm.onReject()\n              }}\n            />\n          </Box>\n        </Box>\n      </PermissionDialog>\n    )\n  }\n\n  return (\n    <Box\n      flexDirection=\"column\"\n      tabIndex={0}\n      autoFocus\n      onKeyDown={handleKeyDown}\n    >\n      <PermissionDialog\n        color=\"planMode\"\n        title=\"Ready to code?\"\n        innerPaddingX={0}\n        workerBadge={workerBadge}\n      >\n        <Box flexDirection=\"column\" marginTop={1}>\n          <Box paddingX={1} flexDirection=\"column\">\n            <Text>Here is Claude&apos;s plan:</Text>\n          </Box>\n          <Box\n            borderColor=\"subtle\"\n            borderStyle=\"dashed\"\n            flexDirection=\"column\"\n            borderLeft={false}\n            borderRight={false}\n            paddingX={1}\n            marginBottom={1}\n            // Necessary for Windows Terminal to render properly\n            overflow=\"hidden\"\n          >\n            <Markdown>{currentPlan}</Markdown>\n          </Box>\n          <Box flexDirection=\"column\" paddingX={1}>\n            <PermissionRuleExplanation\n              permissionResult={toolUseConfirm.permissionResult}\n              toolType=\"tool\"\n            />\n            {isClassifierPermissionsEnabled() &&\n              allowedPrompts &&\n              allowedPrompts.length > 0 && (\n                <Box flexDirection=\"column\" marginBottom={1}>\n                  <Text bold>Requested permissions:</Text>\n                  {allowedPrompts.map((p, i) => (\n                    <Text key={i} dimColor>\n                      {'  '}· {p.tool}({PROMPT_PREFIX} {p.prompt})\n                    </Text>\n                  ))}\n                </Box>\n              )}\n            {!useStickyFooter && (\n              <>\n                <Text dimColor>\n                  Claude has written up a plan and is ready to execute. Would\n                  you like to proceed?\n                </Text>\n                <Box marginTop={1}>\n                  <Select\n                    options={options}\n                    onChange={handleResponse}\n                    onCancel={() => handleCancelRef.current?.()}\n                    onImagePaste={onImagePaste}\n                    pastedContents={pastedContents}\n                    onRemoveImage={onRemoveImage}\n                  />\n                </Box>\n              </>\n            )}\n          </Box>\n        </Box>\n      </PermissionDialog>\n      {!useStickyFooter && editorName && (\n        <Box flexDirection=\"row\" gap={1} paddingX={1} marginTop={1}>\n          <Box>\n            <Text dimColor>ctrl-g to edit in </Text>\n            <Text bold dimColor>\n              {editorName}\n            </Text>\n            {isV2 && planFilePath && (\n              <Text dimColor> · {getDisplayPath(planFilePath)}</Text>\n            )}\n          </Box>\n          {showSaveMessage && (\n            <Box>\n              <Text dimColor>{' · '}</Text>\n              <Text color=\"success\">{figures.tick}Plan saved!</Text>\n            </Box>\n          )}\n        </Box>\n      )}\n    </Box>\n  )\n}\n\n/** @internal Exported for testing. */\nexport function buildPlanApprovalOptions({\n  showClearContext,\n  showUltraplan,\n  usedPercent,\n  isAutoModeAvailable,\n  isBypassPermissionsModeAvailable,\n  onFeedbackChange,\n}: {\n  showClearContext: boolean\n  showUltraplan: boolean\n  usedPercent: number | null\n  isAutoModeAvailable: boolean | undefined\n  isBypassPermissionsModeAvailable: boolean | undefined\n  onFeedbackChange: (v: string) => void\n}): OptionWithDescription<ResponseValue>[] {\n  const options: OptionWithDescription<ResponseValue>[] = []\n  const usedLabel = usedPercent !== null ? ` (${usedPercent}% used)` : ''\n\n  if (showClearContext) {\n    if (feature('TRANSCRIPT_CLASSIFIER') && isAutoModeAvailable) {\n      options.push({\n        label: `Yes, clear context${usedLabel} and use auto mode`,\n        value: 'yes-auto-clear-context',\n      })\n    } else if (isBypassPermissionsModeAvailable) {\n      options.push({\n        label: `Yes, clear context${usedLabel} and bypass permissions`,\n        value: 'yes-bypass-permissions',\n      })\n    } else {\n      options.push({\n        label: `Yes, clear context${usedLabel} and auto-accept edits`,\n        value: 'yes-accept-edits',\n      })\n    }\n  }\n\n  // Slot 2: keep-context with elevated mode (same priority: auto > bypass > edits).\n  if (feature('TRANSCRIPT_CLASSIFIER') && isAutoModeAvailable) {\n    options.push({\n      label: 'Yes, and use auto mode',\n      value: 'yes-resume-auto-mode',\n    })\n  } else if (isBypassPermissionsModeAvailable) {\n    options.push({\n      label: 'Yes, and bypass permissions',\n      value: 'yes-accept-edits-keep-context',\n    })\n  } else {\n    options.push({\n      label: 'Yes, auto-accept edits',\n      value: 'yes-accept-edits-keep-context',\n    })\n  }\n\n  options.push({\n    label: 'Yes, manually approve edits',\n    value: 'yes-default-keep-context',\n  })\n\n  if (showUltraplan) {\n    options.push({\n      label: 'No, refine with Ultraplan on Claude Code on the web',\n      value: 'ultraplan',\n    })\n  }\n\n  options.push({\n    type: 'input',\n    label: 'No, keep planning',\n    value: 'no',\n    placeholder: 'Tell Claude what to change',\n    description: 'shift+tab to approve with this feedback',\n    onChange: onFeedbackChange,\n  })\n\n  return options\n}\n\nfunction getContextUsedPercent(\n  usage:\n    | {\n        input_tokens: number\n        cache_creation_input_tokens?: number | null\n        cache_read_input_tokens?: number | null\n      }\n    | undefined,\n  permissionMode: PermissionMode,\n): number | null {\n  if (!usage) return null\n  const runtimeModel = getRuntimeMainLoopModel({\n    permissionMode,\n    mainLoopModel: getMainLoopModel(),\n    exceeds200kTokens: false,\n  })\n  const contextWindowSize = getContextWindowForModel(\n    runtimeModel,\n    getSdkBetas(),\n  )\n  const { used } = calculateContextPercentages(\n    {\n      input_tokens: usage.input_tokens,\n      cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0,\n      cache_read_input_tokens: usage.cache_read_input_tokens ?? 0,\n    },\n    contextWindowSize,\n  )\n  return used\n}\n"],"mappings":"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","ignoreList":[]}