fix: resolve infinite loop when using 'Modify with external editor'

packages/cli/src/ui/AppContainer.tsx

@@ -525,12 +525,22 @@ export const AppContainer = (props: AppContainerProps) => {
     refreshStatic();
   }, [refreshStatic, isAlternateBuffer, app, config]);
 
+  const [editorError, setEditorError] = useState<string | null>(null);
+  const {
+    isEditorDialogOpen,
+    openEditorDialog,
+    handleEditorSelect,
+    exitEditorDialog,
+  } = useEditorSettings(settings, setEditorError, historyManager.addItem);
+
   useEffect(() => {
     coreEvents.on(CoreEvent.ExternalEditorClosed, handleEditorClose);
+    coreEvents.on(CoreEvent.RequestEditorSelection, openEditorDialog);
     return () => {
       coreEvents.off(CoreEvent.ExternalEditorClosed, handleEditorClose);
+      coreEvents.off(CoreEvent.RequestEditorSelection, openEditorDialog);
     };
-  }, [handleEditorClose]);
+  }, [handleEditorClose, openEditorDialog]);
 
   useEffect(() => {
     if (
@@ -544,6 +554,9 @@ export const AppContainer = (props: AppContainerProps) => {
     }
   }, [bannerVisible, bannerText, settings, config, refreshStatic]);
 
+  const { isSettingsDialogOpen, openSettingsDialog, closeSettingsDialog } =
+    useSettingsCommand();
+
   const {
     isThemeDialogOpen,
     openThemeDialog,
@@ -739,17 +752,6 @@ Logging in with Google... Restarting Gemini CLI to continue.
     onAuthError,
   ]);
 
-  const [editorError, setEditorError] = useState<string | null>(null);
-  const {
-    isEditorDialogOpen,
-    openEditorDialog,
-    handleEditorSelect,
-    exitEditorDialog,
-  } = useEditorSettings(settings, setEditorError, historyManager.addItem);
-
-  const { isSettingsDialogOpen, openSettingsDialog, closeSettingsDialog } =
-    useSettingsCommand();
-
   const { isModelDialogOpen, openModelDialog, closeModelDialog } =
     useModelCommand();
 

packages/cli/src/ui/editors/editorSettingsManager.ts

@@ -6,7 +6,7 @@
 
 import {
   allowEditorTypeInSandbox,
-  checkHasEditorType,
+  hasValidEditorCommand,
   type EditorType,
   EDITOR_DISPLAY_NAMES,
 } from '@google/gemini-cli-core';
@@ -31,7 +31,7 @@ class EditorSettingsManager {
         disabled: false,
       },
       ...editorTypes.map((type) => {
-        const hasEditor = checkHasEditorType(type);
+        const hasEditor = hasValidEditorCommand(type);
         const isAllowedInSandbox = allowEditorTypeInSandbox(type);
 
         let labelSuffix = !isAllowedInSandbox

packages/cli/src/ui/hooks/useEditorSettings.test.tsx

@@ -24,7 +24,7 @@ import { SettingScope } from '../../config/settings.js';
 import { MessageType } from '../types.js';
 import {
   type EditorType,
-  checkHasEditorType,
+  hasValidEditorCommand,
   allowEditorTypeInSandbox,
 } from '@google/gemini-cli-core';
 import type { UseHistoryManagerReturn } from './useHistoryManager.js';
@@ -35,12 +35,12 @@ vi.mock('@google/gemini-cli-core', async () => {
   const actual = await vi.importActual('@google/gemini-cli-core');
   return {
     ...actual,
-    checkHasEditorType: vi.fn(() => true),
+    hasValidEditorCommand: vi.fn(() => true),
     allowEditorTypeInSandbox: vi.fn(() => true),
   };
 });
 
-const mockCheckHasEditorType = vi.mocked(checkHasEditorType);
+const mockHasValidEditorCommand = vi.mocked(hasValidEditorCommand);
 const mockAllowEditorTypeInSandbox = vi.mocked(allowEditorTypeInSandbox);
 
 describe('useEditorSettings', () => {
@@ -69,7 +69,7 @@ describe('useEditorSettings', () => {
     mockAddItem = vi.fn();
 
     // Reset mock implementations to default
-    mockCheckHasEditorType.mockReturnValue(true);
+    mockHasValidEditorCommand.mockReturnValue(true);
     mockAllowEditorTypeInSandbox.mockReturnValue(true);
   });
 
@@ -224,7 +224,7 @@ describe('useEditorSettings', () => {
   it('should not set preference for unavailable editors', () => {
     render(<TestComponent />);
 
-    mockCheckHasEditorType.mockReturnValue(false);
+    mockHasValidEditorCommand.mockReturnValue(false);
 
     const editorType: EditorType = 'vscode';
     const scope = SettingScope.User;

packages/cli/src/ui/hooks/useEditorSettings.ts

@@ -13,8 +13,10 @@ import { MessageType } from '../types.js';
 import type { EditorType } from '@google/gemini-cli-core';
 import {
   allowEditorTypeInSandbox,
-  checkHasEditorType,
+  hasValidEditorCommand,
   getEditorDisplayName,
+  coreEvents,
+  CoreEvent,
 } from '@google/gemini-cli-core';
 import type { UseHistoryManagerReturn } from './useHistoryManager.js';
 
@@ -45,7 +47,7 @@ export const useEditorSettings = (
     (editorType: EditorType | undefined, scope: LoadableSettingScope) => {
       if (
         editorType &&
-        (!checkHasEditorType(editorType) ||
+        (!hasValidEditorCommand(editorType) ||
           !allowEditorTypeInSandbox(editorType))
       ) {
         return;
@@ -66,6 +68,7 @@ export const useEditorSettings = (
         );
         setEditorError(null);
         setIsEditorDialogOpen(false);
+        coreEvents.emit(CoreEvent.EditorSelected, { editor: editorType });
       } catch (error) {
         setEditorError(`Failed to set editor preference: ${error}`);
       }
@@ -75,6 +78,7 @@ export const useEditorSettings = (
 
   const exitEditorDialog = useCallback(() => {
     setIsEditorDialogOpen(false);
+    coreEvents.emit(CoreEvent.EditorSelected, { editor: undefined });
   }, []);
 
   return {

packages/core/src/scheduler/confirmation.ts

@@ -21,9 +21,14 @@ import type { ValidatingToolCall, WaitingToolCall } from './types.js';
 import type { Config } from '../config/config.js';
 import type { SchedulerStateManager } from './state-manager.js';
 import type { ToolModificationHandler } from './tool-modifier.js';
-import type { EditorType } from '../utils/editor.js';
+import {
+  resolveEditorAsync,
+  type EditorType,
+  NO_EDITOR_AVAILABLE_ERROR,
+} from '../utils/editor.js';
 import type { DiffUpdateResult } from '../ide/ide-client.js';
 import { debugLogger } from '../utils/debugLogger.js';
+import { coreEvents } from '../utils/events.js';
 
 export interface ConfirmationResult {
   outcome: ToolConfirmationOutcome;
@@ -155,7 +160,16 @@ export async function resolveConfirmation(
     }
 
     if (outcome === ToolConfirmationOutcome.ModifyWithEditor) {
-      await handleExternalModification(deps, toolCall, signal);
+      const modResult = await handleExternalModification(
+        deps,
+        toolCall,
+        signal,
+      );
+      // Editor is not available - emit error feedback and stay in the loop
+      // to return to previous confirmation screen.
+      if (modResult.error) {
+        coreEvents.emitFeedback('error', modResult.error);
+      }
     } else if (response.payload && 'newContent' in response.payload) {
       await handleInlineModification(deps, toolCall, response.payload, signal);
       outcome = ToolConfirmationOutcome.ProceedOnce;
@@ -182,8 +196,18 @@ async function notifyHooks(
   }
 }
 
+/**
+ * Result of attempting external modification.
+ * If error is defined, the modification failed.
+ */
+interface ExternalModificationResult {
+  /** Error message if the modification failed */
+  error?: string;
+}
+
 /**
  * Handles modification via an external editor (e.g. Vim).
+ * Returns a result indicating success or failure with an error message.
  */
 async function handleExternalModification(
   deps: {
@@ -193,10 +217,16 @@ async function handleExternalModification(
   },
   toolCall: ValidatingToolCall,
   signal: AbortSignal,
-): Promise<void> {
+): Promise<ExternalModificationResult> {
   const { state, modifier, getPreferredEditor } = deps;
-  const editor = getPreferredEditor();
-  if (!editor) return;
+
+  const preferredEditor = getPreferredEditor();
+  const editor = await resolveEditorAsync(preferredEditor, signal);
+
+  if (!editor) {
+    // No editor available - return failure with error message
+    return { error: NO_EDITOR_AVAILABLE_ERROR };
+  }
 
   const result = await modifier.handleModifyWithEditor(
     state.firstActiveCall as WaitingToolCall,
@@ -211,6 +241,7 @@ async function handleExternalModification(
       newInvocation,
     );
   }
+  return {};
 }
 
 /**