lcclaude 1.0.0

package/dist/src/components/permissions/ExitPlanModePermissionRequest/ExitPlanModePermissionRequest.js

@@ -0,0 +1,728 @@
+import figures from "figures";
+import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { useNotifications } from "../../../context/notifications.js";
+import { logEvent } from "../../../services/analytics/index.js";
+import { useAppState, useAppStateStore, useSetAppState } from "../../../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 { Box, Text } from "../../../ink.js";
+import { AGENT_TOOL_NAME } from "../../../tools/AgentTool/constants.js";
+import { EXIT_PLAN_MODE_V2_TOOL_NAME } from "../../../tools/ExitPlanModeTool/constants.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 { toExternalPermissionMode } from "../../../utils/permissions/PermissionMode.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 { Select } from "../../CustomSelect/index.js";
+import { Markdown } from "../../Markdown.js";
+import { PermissionDialog } from "../PermissionDialog.js";
+import { PermissionRuleExplanation } from "../PermissionRuleExplanation.js";
+const autoModeStateModule = null;
+import { maybeResizeAndDownsampleImageBlock } from "../../../utils/imageResizer.js";
+import { cacheImagePath, storeImage } from "../../../utils/imageStore.js";
+export function buildPermissionUpdates(mode, allowedPrompts) {
+  const updates = [{
+    type: "setMode",
+    mode: toExternalPermissionMode(mode),
+    destination: "session"
+  }];
+  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;
+}
+export function autoNameSessionFromPlan(plan, setAppState, isClearContext) {
+  if (isSessionPersistenceDisabled() || getSettings_DEPRECATED()?.cleanupPeriodDays === 0) {
+    return;
+  }
+  if (!isClearContext && getCurrentSessionTitle(getSessionId()))
+    return;
+  generateSessionName([createUserMessage({
+    content: plan.slice(0, 1000)
+  })], new AbortController().signal).then(async (name) => {
+    if (!name || getCurrentSessionTitle(getSessionId()))
+      return;
+    const sessionId = getSessionId();
+    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
+}) {
+  const toolPermissionContext = useAppState((s) => s.toolPermissionContext);
+  const setAppState = useSetAppState();
+  const store = useAppStateStore();
+  const {
+    addNotification
+  } = useNotifications();
+  const [planFeedback, setPlanFeedback] = useState("");
+  const [pastedContents, setPastedContents] = useState({});
+  const nextPasteIdRef = useRef(0);
+  const showClearContext = useAppState((s) => s.settings.showClearContextOnPlanAccept) ?? false;
+  const ultraplanSessionUrl = useAppState((s) => s.ultraplanSessionUrl);
+  const ultraplanLaunching = useAppState((s) => s.ultraplanLaunching);
+  const showUltraplan = 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, mediaType, filename, dimensions, _sourcePath) {
+    const pasteId = nextPasteIdRef.current++;
+    const newContent = {
+      id: pasteId,
+      type: "image",
+      content: base64Image,
+      mediaType: mediaType || "image/png",
+      filename: filename || "Pasted image",
+      dimensions
+    };
+    cacheImagePath(newContent);
+    storeImage(newContent);
+    setPastedContents((prev) => ({
+      ...prev,
+      [pasteId]: newContent
+    }));
+  }
+  const onRemoveImage = useCallback((id) => {
+    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;
+  const isV2 = toolUseConfirm.tool.name === EXIT_PLAN_MODE_V2_TOOL_NAME;
+  const inputPlan = isV2 ? undefined : toolUseConfirm.input.plan;
+  const planFilePath = isV2 ? getPlanFilePath() : undefined;
+  const allowedPrompts = toolUseConfirm.input.allowedPrompts;
+  const rawPlan = inputPlan ?? getPlan();
+  const isEmpty = !rawPlan || rawPlan.trim() === "";
+  const [planStructureVariant] = useState(() => getPewterLedgerVariant() ?? undefined);
+  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);
+  const [planEditedLocally, setPlanEditedLocally] = useState(false);
+  useEffect(() => {
+    if (showSaveMessage) {
+      const timer = setTimeout(setShowSaveMessage, 5000, false);
+      return () => clearTimeout(timer);
+    }
+  }, [showSaveMessage]);
+  const handleKeyDown = (e) => {
+    if (e.ctrl && e.key === "g") {
+      e.preventDefault();
+      logEvent("tengu_plan_external_editor_used", {});
+      (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;
+    }
+    if (e.shift && e.key === "tab") {
+      e.preventDefault();
+      handleResponse(showClearContext ? "yes-accept-edits" : "yes-accept-edits-keep-context");
+      return;
+    }
+  };
+  async function handleResponse(value) {
+    const trimmedFeedback = planFeedback.trim();
+    const acceptFeedback = trimmedFeedback || undefined;
+    if (value === "ultraplan") {
+      logEvent("tengu_plan_exit", {
+        planLengthChars: currentPlan.length,
+        outcome: "ultraplan",
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant
+      });
+      onDone();
+      onReject();
+      toolUseConfirm.onReject("Plan being refined via Ultraplan — please wait for the result.");
+      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;
+    }
+    const updatedInput = isV2 && !planEditedLocally ? {} : {
+      plan: currentPlan
+    };
+    if (false) {}
+    const isResumeAutoOption = 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) {
+      let mode = "default";
+      if (value === "yes-bypass-permissions") {
+        mode = "bypassPermissions";
+      } else if (value === "yes-accept-edits") {
+        mode = "acceptEdits";
+      } else if (false) {}
+      logEvent("tengu_plan_exit", {
+        planLengthChars: currentPlan.length,
+        outcome: value,
+        clearContext: true,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant,
+        hasFeedback: !!acceptFeedback
+      });
+      const verificationInstruction = "";
+      const transcriptPath = getTranscriptPath();
+      const transcriptHint = `
+
+If 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() ? `
+
+If 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 ? `
+
+User feedback on this plan: ${acceptFeedback}` : "";
+      setAppState((prev) => ({
+        ...prev,
+        initialMessage: {
+          message: {
+            ...createUserMessage({
+              content: `Implement the following plan:
+
+${currentPlan}${verificationInstruction}${transcriptHint}${teamHint}${feedbackSuffix}`
+            }),
+            planContent: currentPlan
+          },
+          clearContext: true,
+          mode,
+          allowedPrompts
+        }
+      }));
+      setHasExitedPlanMode(true);
+      onDone();
+      onReject();
+      toolUseConfirm.onReject();
+      return;
+    }
+    if (false) {}
+    const keepContextModes = {
+      "yes-accept-edits-keep-context": toolPermissionContext.isBypassPermissionsModeAvailable ? "bypassPermissions" : "acceptEdits",
+      "yes-default-keep-context": "default",
+      ...{}
+    };
+    const keepContextMode = keepContextModes[value];
+    if (keepContextMode) {
+      logEvent("tengu_plan_exit", {
+        planLengthChars: currentPlan.length,
+        outcome: value,
+        clearContext: false,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant,
+        hasFeedback: !!acceptFeedback
+      });
+      setHasExitedPlanMode(true);
+      setNeedsPlanModeExitAttachment(true);
+      onDone();
+      toolUseConfirm.onAllow(updatedInput, buildPermissionUpdates(keepContextMode, allowedPrompts), acceptFeedback);
+      return;
+    }
+    const standardModes = {
+      "yes-bypass-permissions": "bypassPermissions",
+      "yes-accept-edits": "acceptEdits"
+    };
+    const standardMode = standardModes[value];
+    if (standardMode) {
+      logEvent("tengu_plan_exit", {
+        planLengthChars: currentPlan.length,
+        outcome: value,
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant,
+        hasFeedback: !!acceptFeedback
+      });
+      setHasExitedPlanMode(true);
+      setNeedsPlanModeExitAttachment(true);
+      onDone();
+      toolUseConfirm.onAllow(updatedInput, buildPermissionUpdates(standardMode, allowedPrompts), acceptFeedback);
+      return;
+    }
+    if (value === "no") {
+      if (!trimmedFeedback && !hasImages) {
+        return;
+      }
+      logEvent("tengu_plan_exit", {
+        planLengthChars: currentPlan.length,
+        outcome: "no",
+        interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+        planStructureVariant
+      });
+      let imageBlocks;
+      if (hasImages) {
+        imageBlocks = await Promise.all(imageAttachments.map(async (img) => {
+          const block = {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: img.mediaType || "image/png",
+              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;
+  const handleResponseRef = useRef(handleResponse);
+  handleResponseRef.current = handleResponse;
+  const handleCancelRef = useRef(undefined);
+  handleCancelRef.current = () => {
+    logEvent("tengu_plan_exit", {
+      planLengthChars: currentPlan.length,
+      outcome: "no",
+      interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+      planStructureVariant
+    });
+    onDone();
+    onReject();
+    toolUseConfirm.onReject();
+  };
+  const useStickyFooter = !isEmpty && !!setStickyFooter;
+  useLayoutEffect(() => {
+    if (!useStickyFooter)
+      return;
+    setStickyFooter(jsxDEV_7x81h0kn(Box, {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "planMode",
+      borderLeft: false,
+      borderRight: false,
+      borderBottom: false,
+      paddingX: 1,
+      children: [
+        jsxDEV_7x81h0kn(Text, {
+          dimColor: true,
+          children: "Would you like to proceed?"
+        }, undefined, false, undefined, this),
+        jsxDEV_7x81h0kn(Box, {
+          marginTop: 1,
+          children: jsxDEV_7x81h0kn(Select, {
+            options,
+            onChange: (v) => void handleResponseRef.current(v),
+            onCancel: () => handleCancelRef.current?.(),
+            onImagePaste,
+            pastedContents,
+            onRemoveImage
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        editorName && jsxDEV_7x81h0kn(Box, {
+          flexDirection: "row",
+          gap: 1,
+          marginTop: 1,
+          children: [
+            jsxDEV_7x81h0kn(Text, {
+              dimColor: true,
+              children: "ctrl-g to edit in "
+            }, undefined, false, undefined, this),
+            jsxDEV_7x81h0kn(Text, {
+              bold: true,
+              dimColor: true,
+              children: editorName
+            }, undefined, false, undefined, this),
+            isV2 && planFilePath && jsxDEV_7x81h0kn(Text, {
+              dimColor: true,
+              children: [
+                " · ",
+                getDisplayPath(planFilePath)
+              ]
+            }, undefined, true, undefined, this),
+            showSaveMessage && jsxDEV_7x81h0kn(Fragment_8vg9x3sq, {
+              children: [
+                jsxDEV_7x81h0kn(Text, {
+                  dimColor: true,
+                  children: " · "
+                }, undefined, false, undefined, this),
+                jsxDEV_7x81h0kn(Text, {
+                  color: "success",
+                  children: [
+                    figures.tick,
+                    "Plan saved!"
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this));
+    return () => setStickyFooter(null);
+  }, [useStickyFooter, setStickyFooter, options, pastedContents, editorName, isV2, planFilePath, showSaveMessage]);
+  if (isEmpty) {
+    let handleEmptyPlanResponse = function(value) {
+      if (value === "yes") {
+        logEvent("tengu_plan_exit", {
+          planLengthChars: 0,
+          outcome: "yes-default",
+          interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+          planStructureVariant
+        });
+        if (false) {}
+        setHasExitedPlanMode(true);
+        setNeedsPlanModeExitAttachment(true);
+        onDone();
+        toolUseConfirm.onAllow({}, [{
+          type: "setMode",
+          mode: "default",
+          destination: "session"
+        }]);
+      } else {
+        logEvent("tengu_plan_exit", {
+          planLengthChars: 0,
+          outcome: "no",
+          interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+          planStructureVariant
+        });
+        onDone();
+        onReject();
+        toolUseConfirm.onReject();
+      }
+    };
+    return jsxDEV_7x81h0kn(PermissionDialog, {
+      color: "planMode",
+      title: "Exit plan mode?",
+      workerBadge,
+      children: jsxDEV_7x81h0kn(Box, {
+        flexDirection: "column",
+        paddingX: 1,
+        marginTop: 1,
+        children: [
+          jsxDEV_7x81h0kn(Text, {
+            children: "Claude wants to exit plan mode"
+          }, undefined, false, undefined, this),
+          jsxDEV_7x81h0kn(Box, {
+            marginTop: 1,
+            children: jsxDEV_7x81h0kn(Select, {
+              options: [{
+                label: "Yes",
+                value: "yes"
+              }, {
+                label: "No",
+                value: "no"
+              }],
+              onChange: handleEmptyPlanResponse,
+              onCancel: () => {
+                logEvent("tengu_plan_exit", {
+                  planLengthChars: 0,
+                  outcome: "no",
+                  interviewPhaseEnabled: isPlanModeInterviewPhaseEnabled(),
+                  planStructureVariant
+                });
+                onDone();
+                onReject();
+                toolUseConfirm.onReject();
+              }
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  return jsxDEV_7x81h0kn(Box, {
+    flexDirection: "column",
+    tabIndex: 0,
+    autoFocus: true,
+    onKeyDown: handleKeyDown,
+    children: [
+      jsxDEV_7x81h0kn(PermissionDialog, {
+        color: "planMode",
+        title: "Ready to code?",
+        innerPaddingX: 0,
+        workerBadge,
+        children: jsxDEV_7x81h0kn(Box, {
+          flexDirection: "column",
+          marginTop: 1,
+          children: [
+            jsxDEV_7x81h0kn(Box, {
+              paddingX: 1,
+              flexDirection: "column",
+              children: jsxDEV_7x81h0kn(Text, {
+                children: "Here is Claude's plan:"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            jsxDEV_7x81h0kn(Box, {
+              borderColor: "subtle",
+              borderStyle: "dashed",
+              flexDirection: "column",
+              borderLeft: false,
+              borderRight: false,
+              paddingX: 1,
+              marginBottom: 1,
+              overflow: "hidden",
+              children: jsxDEV_7x81h0kn(Markdown, {
+                children: currentPlan
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            jsxDEV_7x81h0kn(Box, {
+              flexDirection: "column",
+              paddingX: 1,
+              children: [
+                jsxDEV_7x81h0kn(PermissionRuleExplanation, {
+                  permissionResult: toolUseConfirm.permissionResult,
+                  toolType: "tool"
+                }, undefined, false, undefined, this),
+                isClassifierPermissionsEnabled() && allowedPrompts && allowedPrompts.length > 0 && jsxDEV_7x81h0kn(Box, {
+                  flexDirection: "column",
+                  marginBottom: 1,
+                  children: [
+                    jsxDEV_7x81h0kn(Text, {
+                      bold: true,
+                      children: "Requested permissions:"
+                    }, undefined, false, undefined, this),
+                    allowedPrompts.map((p, i) => jsxDEV_7x81h0kn(Text, {
+                      dimColor: true,
+                      children: [
+                        "  ",
+                        "· ",
+                        p.tool,
+                        "(",
+                        PROMPT_PREFIX,
+                        " ",
+                        p.prompt,
+                        ")"
+                      ]
+                    }, i, true, undefined, this))
+                  ]
+                }, undefined, true, undefined, this),
+                !useStickyFooter && jsxDEV_7x81h0kn(Fragment_8vg9x3sq, {
+                  children: [
+                    jsxDEV_7x81h0kn(Text, {
+                      dimColor: true,
+                      children: "Claude has written up a plan and is ready to execute. Would you like to proceed?"
+                    }, undefined, false, undefined, this),
+                    jsxDEV_7x81h0kn(Box, {
+                      marginTop: 1,
+                      children: jsxDEV_7x81h0kn(Select, {
+                        options,
+                        onChange: handleResponse,
+                        onCancel: () => handleCancelRef.current?.(),
+                        onImagePaste,
+                        pastedContents,
+                        onRemoveImage
+                      }, undefined, false, undefined, this)
+                    }, undefined, false, undefined, this)
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      !useStickyFooter && editorName && jsxDEV_7x81h0kn(Box, {
+        flexDirection: "row",
+        gap: 1,
+        paddingX: 1,
+        marginTop: 1,
+        children: [
+          jsxDEV_7x81h0kn(Box, {
+            children: [
+              jsxDEV_7x81h0kn(Text, {
+                dimColor: true,
+                children: "ctrl-g to edit in "
+              }, undefined, false, undefined, this),
+              jsxDEV_7x81h0kn(Text, {
+                bold: true,
+                dimColor: true,
+                children: editorName
+              }, undefined, false, undefined, this),
+              isV2 && planFilePath && jsxDEV_7x81h0kn(Text, {
+                dimColor: true,
+                children: [
+                  " · ",
+                  getDisplayPath(planFilePath)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          showSaveMessage && jsxDEV_7x81h0kn(Box, {
+            children: [
+              jsxDEV_7x81h0kn(Text, {
+                dimColor: true,
+                children: " · "
+              }, undefined, false, undefined, this),
+              jsxDEV_7x81h0kn(Text, {
+                color: "success",
+                children: [
+                  figures.tick,
+                  "Plan saved!"
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+export function buildPlanApprovalOptions({
+  showClearContext,
+  showUltraplan,
+  usedPercent,
+  isAutoModeAvailable,
+  isBypassPermissionsModeAvailable,
+  onFeedbackChange
+}) {
+  const options = [];
+  const usedLabel = usedPercent !== null ? ` (${usedPercent}% used)` : "";
+  if (showClearContext) {
+    if (false) {} 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"
+      });
+    }
+  }
+  if (false) {} 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, permissionMode) {
+  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;
+}