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

packages/cli/src/ui/AppContainer.tsx

@@ -524,12 +524,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 (
@@ -543,6 +553,9 @@ export const AppContainer = (props: AppContainerProps) => {
     }
   }, [bannerVisible, bannerText, settings, config, refreshStatic]);
 
+  const { isSettingsDialogOpen, openSettingsDialog, closeSettingsDialog } =
+    useSettingsCommand();
+
   const {
     isThemeDialogOpen,
     openThemeDialog,
@@ -738,17 +751,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/hooks/useEditorSettings.ts

@@ -15,6 +15,8 @@ import {
   allowEditorTypeInSandbox,
   checkHasEditorType,
   getEditorDisplayName,
+  coreEvents,
+  CoreEvent,
 } from '@google/gemini-cli-core';
 import type { UseHistoryManagerReturn } from './useHistoryManager.js';
 
@@ -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/core/coreToolScheduler.test.ts

@@ -41,6 +41,7 @@ import {
   MOCK_TOOL_SHOULD_CONFIRM_EXECUTE,
 } from '../test-utils/mock-tool.js';
 import * as modifiableToolModule from '../tools/modifiable-tool.js';
+import * as editorModule from '../utils/editor.js';
 import { DEFAULT_GEMINI_MODEL } from '../config/models.js';
 import type { PolicyEngine } from '../policy/policy-engine.js';
 import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
@@ -1762,6 +1763,10 @@ describe('CoreToolScheduler Sequential Execution', () => {
   });
 
   it('should pass confirmation diff data into modifyWithEditor overrides', async () => {
+    const resolveEditorAsyncSpy = vi
+      .spyOn(editorModule, 'resolveEditorAsync')
+      .mockResolvedValue('vscode');
+
     const modifyWithEditorSpy = vi
       .spyOn(modifiableToolModule, 'modifyWithEditor')
       .mockResolvedValue({
@@ -1842,6 +1847,7 @@ describe('CoreToolScheduler Sequential Execution', () => {
     });
 
     modifyWithEditorSpy.mockRestore();
+    resolveEditorAsyncSpy.mockRestore();
   });
 
   it('should handle inline modify with empty new content', async () => {

packages/core/src/core/coreToolScheduler.ts

@@ -12,7 +12,12 @@ import {
   type ToolConfirmationPayload,
   ToolConfirmationOutcome,
 } from '../tools/tools.js';
-import type { EditorType } from '../utils/editor.js';
+import {
+  resolveEditorAsync,
+  type EditorType,
+  NO_EDITOR_AVAILABLE_ERROR,
+} from '../utils/editor.js';
+import { coreEvents } from '../utils/events.js';
 import type { Config } from '../config/config.js';
 import { PolicyDecision } from '../policy/types.js';
 import { logToolCall } from '../telemetry/loggers.js';
@@ -751,8 +756,16 @@ export class CoreToolScheduler {
     } else if (outcome === ToolConfirmationOutcome.ModifyWithEditor) {
       const waitingToolCall = toolCall as WaitingToolCall;
 
-      const editorType = this.getPreferredEditor();
-      if (!editorType) {
+      const preferredEditor = this.getPreferredEditor();
+      const editor = await resolveEditorAsync(preferredEditor, signal);
+
+      if (!editor) {
+        // No editor available - emit error feedback and return to previous confirmation screen
+        coreEvents.emitFeedback('error', NO_EDITOR_AVAILABLE_ERROR);
+        this.setStatusInternal(callId, 'awaiting_approval', signal, {
+          ...waitingToolCall.confirmationDetails,
+          isModifying: false,
+        } as ToolCallConfirmationDetails);
         return;
       }
 
@@ -763,7 +776,7 @@ export class CoreToolScheduler {
 
       const result = await this.toolModifier.handleModifyWithEditor(
         waitingToolCall,
-        editorType,
+        editor,
         signal,
       );
 

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,18 @@ export async function resolveConfirmation(
     }
 
     if (outcome === ToolConfirmationOutcome.ModifyWithEditor) {
-      await handleExternalModification(deps, toolCall, signal);
+      const modResult = await handleExternalModification(
+        deps,
+        toolCall,
+        signal,
+      );
+      if (!modResult.success) {
+        // 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 +198,19 @@ async function notifyHooks(
   }
 }
 
+/**
+ * Result of attempting external modification.
+ */
+interface ExternalModificationResult {
+  /** Whether the modification was successful (editor was opened) */
+  success: boolean;
+  /** 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 +220,19 @@ 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 {
+      success: false,
+      error: NO_EDITOR_AVAILABLE_ERROR,
+    };
+  }
 
   const result = await modifier.handleModifyWithEditor(
     state.firstActiveCall as WaitingToolCall,
@@ -211,6 +247,7 @@ async function handleExternalModification(
       newInvocation,
     );
   }
+  return { success: true };
 }
 
 /**