feat(cli): show follow-up suggestion in input placeholder

packages/cli/src/config/settingsSchema.ts

@@ -778,9 +778,9 @@ const SETTINGS_SCHEMA = {
         label: 'Enable Follow-up Suggestions',
         category: 'UI',
         requiresRestart: false,
-        default: false,
+        default: true,
         description:
-          'Show context-aware follow-up suggestions after task completion. Press Tab or Right Arrow to accept, Enter to accept and submit.',
+          'Show context-aware follow-up suggestions after task completion. Press Tab, Right Arrow, or Enter to accept into the input buffer.',
         showInDialog: true,
       },
       enableCacheSharing: {

packages/cli/src/ui/AppContainer.tsx

@@ -1470,11 +1470,19 @@ export const AppContainer = (props: AppContainerProps) => {
   const speculationRef = useRef<SpeculationState>(IDLE_SPECULATION);
   const suggestionAbortRef = useRef<AbortController | null>(null);
 
-  // Dismiss callback — clears suggestion + aborts in-flight generation/speculation
-  const dismissPromptSuggestion = useCallback(() => {
-    setPromptSuggestion(null);
+  // Aborts in-flight suggestion generation/speculation only. It deliberately
+  // does NOT clear `promptSuggestion`, so the placeholder can restore the
+  // suggestion when the buffer becomes empty again (user types then deletes).
+  // Named "abort" (not "dismiss") precisely because the suggestion text
+  // survives — see #5145 review.
+  const abortPromptSuggestion = useCallback(() => {
     suggestionAbortRef.current?.abort();
     suggestionAbortRef.current = null;
+    // Also abort the speculation so it doesn't continue running after abort.
+    if (speculationRef.current.status !== 'idle') {
+      abortSpeculation(speculationRef.current).catch(() => {});
+      speculationRef.current = IDLE_SPECULATION;
+    }
   }, []);
 
   // Auto-accept indicator — disabled on agent tabs (agents handle their own)
@@ -2207,9 +2215,10 @@ export const AppContainer = (props: AppContainerProps) => {
     settingInputRequests,
   ]);
 
-  // Abort speculation when promptSuggestion is cleared (new turn, feature toggle, or
-  // user-initiated dismiss via typing/paste). InputPrompt calls onPromptSuggestionDismiss
-  // on user input, which clears promptSuggestion, triggering this effect to abort speculation.
+  // Abort speculation when promptSuggestion is cleared (new turn or feature toggle).
+  // promptSuggestion is only cleared when the model responds or the feature is disabled;
+  // user typing/paste no longer dismisses it — the AbortController in InputPrompt handles
+  // that path, so this effect only fires on state changes from non-user-input sources.
   useEffect(() => {
     if (!promptSuggestion && speculationRef.current.status !== 'idle') {
       abortSpeculation(speculationRef.current).catch(() => {});
@@ -3385,7 +3394,7 @@ export const AppContainer = (props: AppContainerProps) => {
       setSessionName,
       // Prompt suggestion
       promptSuggestion,
-      dismissPromptSuggestion,
+      abortPromptSuggestion,
       // Rewind selector
       isRewindSelectorOpen,
       rewindEscPending,
@@ -3518,7 +3527,7 @@ export const AppContainer = (props: AppContainerProps) => {
       setSessionName,
       // Prompt suggestion
       promptSuggestion,
-      dismissPromptSuggestion,
+      abortPromptSuggestion,
       // Rewind selector
       isRewindSelectorOpen,
       rewindEscPending,

packages/cli/src/ui/components/Composer.tsx

@@ -161,7 +161,7 @@ export const Composer = () => {
               : '  ' + t('Type your message or @path/to/file')
           }
           promptSuggestion={uiState.promptSuggestion}
-          onPromptSuggestionDismiss={uiState.dismissPromptSuggestion}
+          onPromptSuggestionDismiss={uiState.abortPromptSuggestion}
         />
       )}
 

packages/cli/src/ui/components/InputPrompt.test.tsx

@@ -379,7 +379,10 @@ describe('InputPrompt', () => {
     // generous buffer (renderWithProviders cold start can be 100-200ms).
     const SUGGESTION_VISIBLE_WAIT_MS = 700;
 
-    it('accepts and submits the prompt suggestion on Enter when the buffer is empty', async () => {
+    // Regression: Enter on suggestion should fill buffer, NOT submit — matches
+    // Tab/Right-arrow behavior and Claude Code's design. This prevents accidental
+    // execution of destructive slash commands (/clear, /quit).
+    it('fills buffer on Enter when suggestion is available (does not submit)', async () => {
       vi.useFakeTimers();
       const { stdin, unmount } = renderWithProviders(
         <InputPrompt {...props} promptSuggestion="commit this" />,
@@ -392,11 +395,9 @@ describe('InputPrompt', () => {
         });
         await flush();
 
-        expect(props.onSubmit).toHaveBeenCalledWith('commit this');
-        // Enter path must NOT call buffer.insert — it passes text directly to
-        // handleSubmitAndClear. Calling insert would re-fill the buffer after
-        // it was already cleared (the microtask race bug).
-        expect(mockBuffer.insert).not.toHaveBeenCalled();
+        // Enter on suggestion should fill buffer, NOT submit
+        expect(props.onSubmit).not.toHaveBeenCalled();
+        expect(mockBuffer.insert).toHaveBeenCalledWith('commit this');
       } finally {
         vi.useRealTimers();
         unmount();
@@ -452,6 +453,86 @@ describe('InputPrompt', () => {
         unmount();
       }
     });
+
+    // Regression for #5145: the `promptSuggestion` prop fallback path must work
+    // when `followup.state.suggestion` is null (e.g. after user typed and
+    // deleted — the followup controller was dismissed but the placeholder
+    // text is still available via the prop).
+    //
+    // These tests deliberately advance LESS than SUGGESTION_DELAY_MS (300ms),
+    // so the followup controller's show-timer never fires and
+    // `followup.state.suggestion` stays null — exercising the prop fallback
+    // branch rather than the normal visible-suggestion path. (Earlier versions
+    // waited 700ms here, which silently tested the normal flow instead.)
+    describe('promptSuggestion prop fallback (when followup.state.suggestion is null)', () => {
+      // Comfortably under the 300ms SUGGESTION_DELAY_MS so the controller's
+      // state.suggestion remains null.
+      const BEFORE_SUGGESTION_VISIBLE_MS = 100;
+
+      it('accepts promptSuggestion via Tab when followup.state.suggestion is null', async () => {
+        vi.useFakeTimers();
+        const { stdin, unmount } = renderWithProviders(
+          <InputPrompt {...props} promptSuggestion="commit this" />,
+        );
+        try {
+          await advanceTimers(BEFORE_SUGGESTION_VISIBLE_MS);
+
+          act(() => {
+            stdin.write('\t');
+          });
+          await flush();
+
+          // Tab should insert the suggestion text into the buffer
+          expect(mockBuffer.insert).toHaveBeenCalledWith('commit this');
+        } finally {
+          vi.useRealTimers();
+          unmount();
+        }
+      });
+
+      it('accepts promptSuggestion via Right arrow when followup.state.suggestion is null', async () => {
+        vi.useFakeTimers();
+        const { stdin, unmount } = renderWithProviders(
+          <InputPrompt {...props} promptSuggestion="commit this" />,
+        );
+        try {
+          await advanceTimers(BEFORE_SUGGESTION_VISIBLE_MS);
+
+          act(() => {
+            stdin.write('\x1b[C'); // right arrow
+          });
+          await flush();
+
+          // Right arrow should insert the suggestion text into the buffer
+          expect(mockBuffer.insert).toHaveBeenCalledWith('commit this');
+        } finally {
+          vi.useRealTimers();
+          unmount();
+        }
+      });
+
+      it('fills buffer on Enter (does not submit) when followup.state.suggestion is null', async () => {
+        vi.useFakeTimers();
+        const { stdin, unmount } = renderWithProviders(
+          <InputPrompt {...props} promptSuggestion="commit this" />,
+        );
+        try {
+          await advanceTimers(BEFORE_SUGGESTION_VISIBLE_MS);
+
+          act(() => {
+            stdin.write('\r');
+          });
+          await flush();
+
+          // Enter on suggestion should fill buffer, NOT submit (matches Tab/Right-arrow behavior)
+          expect(props.onSubmit).not.toHaveBeenCalled();
+          expect(mockBuffer.insert).toHaveBeenCalledWith('commit this');
+        } finally {
+          vi.useRealTimers();
+          unmount();
+        }
+      });
+    });
   });
 
   // Regression for #4171: `onTabConsumerChange` (consumed by AppContainer
@@ -478,6 +559,50 @@ describe('InputPrompt', () => {
       unmount();
     });
 
+    // Regression for #5145: `hasTabConsumer` must be true when ONLY
+    // `promptSuggestion` prop is set (followup.state.suggestion is null),
+    // so Windows Tab approval-mode cycling is blocked even before the
+    // followup controller's debounce fires.
+    it('reports true immediately when promptSuggestion prop is set (no followup debounce needed)', async () => {
+      const onTabConsumerChange = vi.fn();
+      const { unmount } = renderWithProviders(
+        <InputPrompt
+          {...props}
+          promptSuggestion="commit this"
+          onTabConsumerChange={onTabConsumerChange}
+        />,
+      );
+      // Must report true immediately — no need to wait for followup debounce
+      // because `hasTabConsumer` includes `Boolean(promptSuggestion)`.
+      expect(onTabConsumerChange).toHaveBeenCalledWith(true);
+      unmount();
+    });
+
+    // Regression for #5145 (wenshao review): `hasTabConsumer` is now gated on
+    // `buffer.text.length === 0` instead of the old sticky `suggestionDismissed`
+    // flag, so it reacts to the *current* buffer. With a promptSuggestion present
+    // but a NON-empty buffer (the user is mid-typing), Tab must NOT be consumed —
+    // Windows approval-mode cycling stays enabled. The old `Boolean(promptSuggestion)`
+    // gate wrongly reported true here. The complementary empty-buffer → true
+    // direction (i.e. restored after deleting back to empty) is pinned by
+    // "reports true immediately when promptSuggestion prop is set" above.
+    it('reports false when a promptSuggestion is set but the buffer is non-empty', async () => {
+      mockBuffer.text = 'commit';
+      const onTabConsumerChange = vi.fn();
+      const { unmount } = renderWithProviders(
+        <InputPrompt
+          {...props}
+          promptSuggestion="commit this"
+          onTabConsumerChange={onTabConsumerChange}
+        />,
+      );
+      await wait();
+
+      expect(onTabConsumerChange).toHaveBeenCalledWith(false);
+      expect(onTabConsumerChange).not.toHaveBeenCalledWith(true);
+      unmount();
+    });
+
     it('reports true while mid-input ghost text offers an accept', async () => {
       mockCommandCompletion.midInputGhostText = {
         text: 'ile.txt',

packages/cli/src/ui/components/InputPrompt.tsx

@@ -531,6 +531,16 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
     setAgentTabBarFocused,
   ]);
 
+  // Single source of truth for "is there a suggestion the user can accept right
+  // now": the live followup suggestion if visible, otherwise the persisted
+  // `promptSuggestion` prop (type-then-delete / pre-show-delay). Tab/Right/Enter
+  // accept, the typing-dismiss guards, and the placeholder all derive from this
+  // so they can never drift apart.
+  const availableSuggestion: string | null =
+    followup.state.isVisible || promptSuggestion
+      ? (followup.state.suggestion ?? promptSuggestion ?? null)
+      : null;
+
   const handleInput = useCallback(
     (key: Key): boolean => {
       // When the Arena tab bar or background pill has focus, block
@@ -646,7 +656,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
 
       if (key.paste) {
         // Dismiss follow-up suggestion when user starts typing/pasting
-        if (buffer.text.length === 0 && followup.state.isVisible) {
+        if (buffer.text.length === 0 && availableSuggestion) {
           followup.dismiss();
           onPromptSuggestionDismiss?.();
         }
@@ -987,10 +997,12 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         !showCompletionSuggestions &&
         !reverseSearchActive &&
         !commandSearchActive &&
-        followup.state.isVisible &&
-        followup.state.suggestion
+        availableSuggestion
       ) {
-        followup.accept('tab');
+        // Use the normal accept path. When the followup controller has no live
+        // suggestion (e.g. after type-then-delete), `fallbackText` carries the
+        // still-available placeholder text so telemetry is logged either way.
+        followup.accept('tab', { fallbackText: promptSuggestion ?? undefined });
         return true;
       }
 
@@ -1000,10 +1012,11 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         !key.ctrl &&
         !key.meta &&
         buffer.text.length === 0 &&
-        followup.state.isVisible &&
-        followup.state.suggestion
+        availableSuggestion
       ) {
-        followup.accept('right');
+        followup.accept('right', {
+          fallbackText: promptSuggestion ?? undefined,
+        });
         return true;
       }
 
@@ -1239,19 +1252,15 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
       }
 
       if (keyMatchers[Command.SUBMIT](key)) {
-        // Accept and submit prompt suggestion on Enter when input is truly empty
-        if (
-          buffer.text.length === 0 &&
-          followup.state.isVisible &&
-          followup.state.suggestion
-        ) {
-          const text = followup.state.suggestion;
-          // Skip onAccept (buffer.insert) — we pass the text directly to
-          // handleSubmitAndClear which clears the buffer synchronously.
-          // Without skipOnAccept the microtask in accept() would re-insert
-          // the suggestion into the buffer after it was already cleared.
-          followup.accept('enter', { skipOnAccept: true });
-          handleSubmitAndClear(text);
+        // When buffer is empty and a suggestion is available, Enter fills the
+        // buffer instead of submitting — matching Tab/Right-arrow behavior.
+        // This prevents accidental execution of destructive slash commands
+        // (/clear, /quit) and aligns with Claude Code's design: suggestion
+        // acceptance requires explicit Tab or arrow-key action.
+        if (buffer.text.length === 0 && availableSuggestion) {
+          followup.accept('enter', {
+            fallbackText: promptSuggestion ?? undefined,
+          });
           return true;
         }
         if (buffer.text.trim()) {
@@ -1344,7 +1353,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
       // Dismiss follow-up suggestion only on printable character input
       if (
         buffer.text.length === 0 &&
-        followup.state.isVisible &&
+        availableSuggestion &&
         key.sequence &&
         key.sequence.length === 1 &&
         !key.ctrl &&
@@ -1425,7 +1434,9 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
       enterBgDetailFromPanel,
       setBgSelectedIndex,
       followup,
+      availableSuggestion,
       onPromptSuggestionDismiss,
+      promptSuggestion,
       exportCompletion,
       isHistoryRestoredText,
       showCompletionSuggestions,
@@ -1578,9 +1589,17 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
   // consumed (ACCEPT_SUGGESTION_REVERSE_SEARCH). When they are active with no
   // matches, Tab is not consumed — so the bare `reverseSearchActive` /
   // `commandSearchActive` flags are intentionally NOT included here.
+  // Mirror exactly when the Tab/Right/Enter handlers actually consume the key:
+  // the buffer must be empty and a suggestion must be available (either from the
+  // followup controller or the `promptSuggestion` prop after type-then-delete).
+  // Tying this to `buffer.text.length === 0` — the same gate the handlers use —
+  // keeps Windows Tab approval-mode cycling correct: as soon as the user types,
+  // this drops to false; deleting back to empty restores it.
   const hasTabConsumer =
     shouldShowSuggestions ||
-    (followup.state.isVisible && Boolean(followup.state.suggestion)) ||
+    (buffer.text.length === 0 &&
+      ((followup.state.isVisible && Boolean(followup.state.suggestion)) ||
+        Boolean(promptSuggestion))) ||
     Boolean(completion.midInputGhostText?.acceptText);
 
   // Narrow signal — autocomplete dropdown only. Composer hides Footer /
@@ -1678,11 +1697,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
         onSubmit={handleSubmitAndClear}
         onKeypress={handleInput}
         showCursor={showCursor}
-        placeholder={
-          followup.state.isVisible && followup.state.suggestion
-            ? followup.state.suggestion
-            : placeholder
-        }
+        placeholder={availableSuggestion ?? placeholder}
         prefix={prefixNode}
         borderColor={borderColor}
         topRightLabel={uiState.sessionName || undefined}

packages/cli/src/ui/components/MainContent.test.tsx

@@ -225,7 +225,7 @@ const createUIState = (overrides: Partial<UIState> = {}): UIState =>
     sessionName: null,
     setSessionName: vi.fn(),
     promptSuggestion: null,
-    dismissPromptSuggestion: vi.fn(),
+    abortPromptSuggestion: vi.fn(),
     isRewindSelectorOpen: false,
     rewindEscPending: false,
     ...overrides,

packages/cli/src/ui/contexts/UIStateContext.tsx

@@ -187,7 +187,7 @@ export interface UIState {
   // Prompt suggestion
   promptSuggestion: string | null;
   /** Dismiss prompt suggestion (clears state, aborts speculation) */
-  dismissPromptSuggestion: () => void;
+  abortPromptSuggestion: () => void;
   // Rewind selector
   isRewindSelectorOpen: boolean;
   rewindEscPending: boolean;