@pellux/goodvibes-tui 1.19.6 → 1.20.0

package/src/input/handler-content-actions.ts

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { copyToClipboard, pasteFromClipboard, pasteImageFromClipboard } from '../utils/clipboard.ts';
 import type { InfiniteBuffer } from '../core/history.ts';
-import type { ConversationManager } from '../core/conversation';
+import type { BlockMeta, ConversationManager } from '../core/conversation';
 import type { PermissionCategory } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers';
 import type { CommandContext } from './command-registry.ts';
@@ -243,6 +243,30 @@ export function findMarkerAtPos(prompt: string, pos: number): { start: number; e
   return null;
 }
 
+/**
+ * describeBlockForReceipt - Honest, human-readable name for a block, used by
+ * every anchor-based action's receipt (Ctrl+Y/B/S/A, Tab, block-actions menu)
+ * so the transcript always says exactly what was acted on — never just an
+ * internal collapseKey or a bare "done".
+ */
+export function describeBlockForReceipt(block: BlockMeta): string {
+  const lineText = `${block.lineCount} line${block.lineCount === 1 ? '' : 's'}`;
+  switch (block.type) {
+    case 'tool':
+      return block.toolName ? `tool result: ${block.toolName} (${lineText})` : `tool result (${lineText})`;
+    case 'tool_group':
+      return `tool result group (${lineText})`;
+    case 'diff':
+      return block.filePath ? `diff: ${block.filePath} (${lineText})` : `diff (${lineText})`;
+    case 'code':
+      return `code block (${lineText})`;
+    case 'thinking':
+      return `thinking (${lineText})`;
+    default:
+      return `${block.type} (${lineText})`;
+  }
+}
+
 export function handleCopy(
   selection: SelectionManager,
   getHistory: () => InfiniteBuffer,
@@ -256,30 +280,42 @@ export function handleCopy(
   setTimeout(() => requestRender(), 2005);
 }
 
+/**
+ * handleBlockCopy - Ctrl+Y: copy the content of the block the user is
+ * actually looking at. `getAnchorLine` resolves to the viewport's
+ * bottom-most visible line (see getViewportBottomLine in
+ * conversation-layout.ts), not the raw scroll position — the top of the
+ * viewport is off-screen-above once the transcript is longer than one page.
+ */
 export function handleBlockCopy(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   requestRender: () => void,
   onCopied: () => void,
 ): void {
   if (!conversationManager) return;
-  const lineIndex = getScrollTop();
-  const content = conversationManager.getBlockContentAtLine(lineIndex);
-  if (!content) return;
-  copyToClipboard(content);
+  const lineIndex = getAnchorLine();
+  const nearest = conversationManager.findNearestBlock(lineIndex);
+  if (!nearest) {
+    conversationManager.log('[Ctrl+Y: No block found nearby]', { fg: '240' });
+    requestRender();
+    return;
+  }
+  copyToClipboard(nearest.rawContent);
   onCopied();
+  conversationManager.log(`[Copied ${describeBlockForReceipt(nearest)}]`, { fg: '#22c55e' });
   requestRender();
   setTimeout(() => requestRender(), 2005);
 }
 
 export function handleBookmark(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   requestRender: () => void,
   bookmarkManager: BookmarkManager,
 ): void {
   if (!conversationManager) return;
-  const lineIndex = getScrollTop();
+  const lineIndex = getAnchorLine();
   const nearest = conversationManager.findNearestBlock(lineIndex);
   if (!nearest) {
     conversationManager.log('[Ctrl+B: No block found nearby]', { fg: '240' });
@@ -288,80 +324,68 @@ export function handleBookmark(
   }
   const label = `${nearest.type}: ${nearest.rawContent.slice(0, 40).replace(/\n/g, ' ')}`;
   const added = bookmarkManager.toggle(nearest.collapseKey, label);
+  const target = describeBlockForReceipt(nearest);
   const msg = added
-    ? `[Bookmarked: ${nearest.collapseKey}]`
-    : `[Bookmark removed: ${nearest.collapseKey}]`;
+    ? `[Bookmarked: ${target}]`
+    : `[Bookmark removed: ${target}]`;
   conversationManager.log(msg, { fg: added ? '#22c55e' : '244' });
   requestRender();
 }
 
 export function handleBlockSave(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   requestRender: () => void,
   bookmarkManager: BookmarkManager,
 ): void {
   if (!conversationManager) return;
-  const lineIndex = getScrollTop();
-  const content = conversationManager.getBlockContentAtLine(lineIndex);
-  if (!content) {
+  const lineIndex = getAnchorLine();
+  const nearest = conversationManager.findNearestBlock(lineIndex);
+  if (!nearest) {
     conversationManager.log('[Ctrl+S: No block found nearby]', { fg: '240' });
     requestRender();
     return;
   }
-  const nearest = conversationManager.findNearestBlock(lineIndex);
-  const label = nearest?.type ?? 'block';
+  const target = describeBlockForReceipt(nearest);
   try {
-    const filePath = bookmarkManager.saveToFile(content, label);
+    const filePath = bookmarkManager.saveToFile(nearest.rawContent, nearest.type);
     const homePath = process.env.HOME || process.env.USERPROFILE || '';
     const displayPath = homePath ? filePath.replace(homePath, '~') : filePath;
-    conversationManager.log(`[Saved to: ${displayPath}]`, { fg: '#22c55e' });
+    conversationManager.log(`[Saved ${target} to: ${displayPath}]`, { fg: '#22c55e' });
   } catch (err) {
     const msg = summarizeError(err);
-    conversationManager.log(`[Save failed: ${msg}]`, { fg: '#ef4444' });
-  }
-  requestRender();
-}
-
-export function handleBlockRerun(
-  conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
-  requestRender: () => void,
-): void {
-  if (!conversationManager) return;
-  const lineIndex = getScrollTop();
-  const nearest = conversationManager.findNearestBlock(lineIndex, 'tool');
-  if (!nearest) {
-    conversationManager.log('[Re-run: No tool block found nearby]', { fg: '240' });
-    requestRender();
-    return;
+    conversationManager.log(`[Save failed (${target}): ${msg}]`, { fg: '#ef4444' });
   }
   requestRender();
 }
 
 export function handleBlockToggle(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   requestRender: () => void,
 ): void {
   if (!conversationManager) return;
-  const lineIndex = getScrollTop();
+  const lineIndex = getAnchorLine();
+  const nearest = conversationManager.findNearestBlock(lineIndex);
+  if (!nearest) return;
+  const wasCollapsed = conversationManager.isCollapsed(nearest.blockIndex);
   const blockIdx = conversationManager.toggleCollapseAtLine(lineIndex);
   if (blockIdx >= 0) {
+    conversationManager.log(`[${wasCollapsed ? 'Expanded' : 'Collapsed'} ${describeBlockForReceipt(nearest)}]`, { fg: '244' });
     requestRender();
   }
 }
 
 export function handleDiffApply(
   conversationManager: ConversationManager | null,
-  getScrollTop: () => number,
+  getAnchorLine: () => number,
   commandContext: CommandContext | undefined,
   requestRender: () => void,
   getCallId: () => string,
   category: PermissionCategory,
 ): boolean {
   if (!conversationManager) return false;
-  const lineIndex = getScrollTop();
+  const lineIndex = getAnchorLine();
   const diff = conversationManager.getDiffAtLine(lineIndex);
   if (!diff || !diff.filePath) return false;
   const projectRoot = commandContext?.workspace.shellPaths?.workingDirectory

package/src/input/handler-feed-routes.ts

@@ -344,6 +344,11 @@ export type KeyRouteState = {
   commandRegistry?: CommandRegistry | null;
   autocomplete: AutocompleteEngine | null;
   blockActionsMenu: { open: (block: BlockMeta) => void };
+  /** The absolute history line of the bottom-most visible block — the block
+   *  the user is actually looking at (see getViewportBottomLine's doc).
+   *  Anchors Enter-on-empty-composer's block-actions menu to that block
+   *  instead of an arbitrary fixed line. */
+  getBlockAnchorLine: () => number;
   /** F2 opens+focuses the Fleet panel (which subsumes the retired process modal). */
   openFleetPanel: () => void;
   modalOpened: (name: string) => void;
@@ -430,7 +435,9 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
 
     const text = prompt.trim();
     if (!text && !commandMode) {
-      const lineIndex = 0;
+      // Target the block the user is actually reading, not the conversation's
+      // oldest block (a fixed lineIndex 0 would always resolve there).
+      const lineIndex = state.getBlockAnchorLine();
       const nearest = state.conversationManager?.findNearestBlock(lineIndex);
       if (nearest) {
         state.modalOpened('blockActions');
@@ -603,6 +610,13 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
   }
 
   if (token.logicalName === 'down') {
+    // Announce the focus move honestly — this handoff is otherwise silent
+    // and easy to miss (the next keystrokes look like they're doing nothing,
+    // because they're now landing on the indicator, not the composer).
+    const announceIndicatorFocus = () => {
+      indicatorFocused = true;
+      state.commandContext?.print('[Down] Focus moved to the process indicator — Up or Esc returns to the composer.');
+    };
     const move = computeCursorVerticalMove(prompt, cursorPos, inputScrollTop, state.contentWidth, state.maxInputRows, 1);
     if (move.moved) {
       cursorPos = move.cursorPos;
@@ -617,10 +631,10 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
           cursorPos = recalled.length;
           ensureLocalInputCursorVisible();
         } else {
-          indicatorFocused = true;
+          announceIndicatorFocus();
         }
       } else {
-        indicatorFocused = true;
+        announceIndicatorFocus();
       }
     }
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };

package/src/input/handler-feed.ts

@@ -34,6 +34,7 @@ import {
 } from './handler-feed-routes.ts';
 import type { PanelBurstGuardState } from './panel-paste-flood-guard.ts';
 import type { WrappedPromptInfo } from './handler-prompt-buffer.ts';
+import { getViewportBottomLine } from '../renderer/conversation-layout.ts';
 import { handleModalTokenRoutes } from './handler-modal-token-routes.ts';
 import { handleCommandModeToken } from './handler-command-route.ts';
 import { handleGlobalShortcutToken } from './handler-shortcuts.ts';
@@ -224,6 +225,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
 
     const modalRoute = handleModalTokenRoutes({
       history,
+      conversationManager: context.conversationManager,
       searchShortcutMatch: token.type === 'key' && keybindings.matches('search', token),
       selectionModal: context.selectionModal,
       selectionCallback: context.selectionCallback,
@@ -477,6 +479,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         submitConcealedInput: context.submitConcealedInput,
         autocomplete: context.autocomplete,
         blockActionsMenu: { open: (block: BlockMeta) => context.blockActionsMenu.open(block) },
+        getBlockAnchorLine: () => getViewportBottomLine(scrollTop, viewportHeight, lineCount),
         openFleetPanel,
         modalOpened: context.modalOpened,
         saveUndoState: context.saveUndoState,

package/src/input/handler-interactions.ts

@@ -2,7 +2,7 @@ import { buildProviderAccountSnapshot } from '@/runtime/index.ts';
 import { enrichProviderAccountsSnapshot } from '../runtime/onboarding/provider-key-capture.ts';
 import type { OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
 import { collectOnboardingSnapshot } from '../runtime/onboarding/index.ts';
-import { cleanupMarkerRegistry, expandPrompt, findMarkerAtPos, handleBlockCopy, handleBlockRerun, handleBlockSave, handleBlockToggle, handleBookmark, handleClipboardPaste, handleCopy, handleCtrlC, handleDiffApply, registerPaste } from './handler-content-actions.ts';
+import { cleanupMarkerRegistry, expandPrompt, findMarkerAtPos, handleBlockCopy, handleBlockSave, handleBlockToggle, handleBookmark, handleClipboardPaste, handleCopy, handleCtrlC, handleDiffApply, registerPaste } from './handler-content-actions.ts';
 import { clearModalStack, handleEscape, modalOpened } from './handler-modal-stack.ts';
 import { openOnboardingWizardState, type OpenOnboardingWizardOptions } from './handler-ui-state.ts';
 import type { InputHandlerLike as InputHandler } from './handler-types.ts';
@@ -110,31 +110,34 @@ export function handleCopyForHandler(handler: InputHandler): void {
   }
 
   /**
-   * handleBlockCopy - Ctrl+Y: Copy the content of the nearest code/tool block.
+   * handleBlockCopy - Ctrl+Y: Copy the content of the block the user is
+   * looking at (the viewport's bottom-most visible block — see
+   * InputHandler.getBlockAnchorLine).
    */
 export function handleBlockCopyForHandler(handler: InputHandler): void {
-    handleBlockCopy(handler.conversationManager, handler.getScrollTop, handler.requestRender, () => {
+    handleBlockCopy(handler.conversationManager, () => handler.getBlockAnchorLine(), handler.requestRender, () => {
       handler.lastBlockCopyTime = Date.now();
     });
   }
 
   /**
-   * handleBookmark - Ctrl+B: Toggle bookmark on the nearest block.
+   * handleBookmark - Ctrl+B: Toggle bookmark on the block the user is looking at.
    */
 export function handleBookmarkForHandler(handler: InputHandler): void {
-    handleBookmark(handler.conversationManager, handler.getScrollTop, handler.requestRender, handler.uiServices.shell.bookmarkManager);
+    handleBookmark(handler.conversationManager, () => handler.getBlockAnchorLine(), handler.requestRender, handler.uiServices.shell.bookmarkManager);
   }
 
   /**
-   * handleBlockSave - Ctrl+S: Save nearest block content to a file.
+   * handleBlockSave - Ctrl+S: Save the block the user is looking at to a file.
    */
 export function handleBlockSaveForHandler(handler: InputHandler): void {
-    handleBlockSave(handler.conversationManager, handler.getScrollTop, handler.requestRender, handler.uiServices.shell.bookmarkManager);
+    handleBlockSave(handler.conversationManager, () => handler.getBlockAnchorLine(), handler.requestRender, handler.uiServices.shell.bookmarkManager);
   }
 
   /**
-   * executeBlockAction - Execute a block action ID on the nearest block.
-   * Called when the user selects an action from the BlockActionsMenu.
+   * executeBlockAction - Execute a block action ID on the block the
+   * BlockActionsMenu was opened for. Called when the user selects an action
+   * from the menu.
    */
 export function executeBlockActionForHandler(handler: InputHandler, actionId: string): void {
     switch (actionId) {
@@ -142,33 +145,26 @@ export function executeBlockActionForHandler(handler: InputHandler, actionId: st
       case 'bookmark': handler.handleBookmark(); break;
       case 'toggle':   handler.handleBlockToggle(); break;
       case 'apply':    handler.handleDiffApply(); break;
-      case 'rerun':    handler.handleBlockRerun(); break;
     }
   }
 
   /**
-   * handleBlockRerun - Re-run the tool call for the nearest tool block.
-   * Emits a tool-rerun event for the orchestrator to handle.
-   */
-export function handleBlockRerunForHandler(handler: InputHandler): void {
-    handleBlockRerun(handler.conversationManager, handler.getScrollTop, handler.requestRender);
-  }
-
-  /**
-   * handleBlockToggle - Tab (non-command mode): Toggle collapse of nearest block.
+   * handleBlockToggle - Tab (non-command mode): Toggle collapse of the block
+   * the user is looking at.
    */
 export function handleBlockToggleForHandler(handler: InputHandler): void {
-    handleBlockToggle(handler.conversationManager, handler.getScrollTop, handler.requestRender);
+    handleBlockToggle(handler.conversationManager, () => handler.getBlockAnchorLine(), handler.requestRender);
   }
 
   /**
-   * handleDiffApply - Ctrl+A when a diff block is nearest: request approval and apply the diff.
-   * Returns true if a diff was found and applied (so caller can skip default Ctrl+A).
+   * handleDiffApply - Ctrl+A when a diff block is the one the user is
+   * looking at: request approval and apply the diff. Returns true if a diff
+   * was found and applied (so caller can skip default Ctrl+A).
    */
 export function handleDiffApplyForHandler(handler: InputHandler): boolean {
     return handleDiffApply(
       handler.conversationManager,
-      handler.getScrollTop,
+      () => handler.getBlockAnchorLine(),
       handler.commandContext,
       handler.requestRender,
       () => `diff-apply-${Date.now()}`,

package/src/input/handler-modal-token-routes.ts

@@ -1,5 +1,6 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import type { InfiniteBuffer } from '../core/history.ts';
+import type { ConversationManager } from '../core/conversation';
 import type { SelectionResult, SelectionModal } from './selection-modal.ts';
 import type { BookmarkModal } from './bookmark-modal.ts';
 import type { SettingsModal } from './settings-modal.ts';
@@ -34,6 +35,9 @@ import {
 
 export type ModalTokenRouteState = {
   history: InfiniteBuffer;
+  /** Threaded into SearchManager.search() so a matching but currently-
+   *  collapsed block gets auto-expanded before the buffer is scanned. */
+  conversationManager?: ConversationManager | null;
   searchShortcutMatch: boolean;
   selectionModal: SelectionModal;
   selectionCallback: ((result: SelectionResult | null) => void) | null;
@@ -108,6 +112,7 @@ export function handleModalTokenRoutes(state: ModalTokenRouteState, token: Input
     scroll: state.scroll,
     getScrollTop: state.getScrollTop,
     getViewportHeight: state.getViewportHeight,
+    conversationManager: state.conversationManager,
   }, token, state.history, state.searchShortcutMatch)) {
     return withState(state, true);
   }

package/src/input/handler-types.ts

@@ -130,7 +130,10 @@ export interface InputHandlerLike {
   handleBookmark(): void;
   handleBlockToggle(): void;
   handleDiffApply(): boolean;
-  handleBlockRerun(): void;
+  /** The absolute history line of the bottom-most visible block — the block
+   *  the user is actually looking at — used to anchor every one of the
+   *  actions above instead of the (possibly off-screen-above) raw scrollTop. */
+  getBlockAnchorLine(): number;
 
   // ── Methods: onboarding ───────────────────────────────────────────────────
   hydrateOnboardingWizardFromRuntime(hydrationSerial: number): Promise<void>;

package/src/input/handler-ui-state.ts

@@ -2,6 +2,7 @@ import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import type { InfiniteBuffer } from '../core/history.ts';
 import type { SearchManager } from './search.ts';
 import type { HistorySearch } from './input-history.ts';
+import type { ConversationManager } from '../core/conversation';
 import type {
   OnboardingWizardController,
   OnboardingWizardMode,
@@ -202,6 +203,9 @@ type SearchRouteState = {
   scroll: (delta: number) => void;
   getScrollTop: () => number;
   getViewportHeight: () => number;
+  /** Optional — when present, search() also expands collapsed blocks whose
+   *  raw content matches (see SearchManager.search's doc). */
+  conversationManager?: ConversationManager | null;
 };
 
 export function handleSearchModeToken(
@@ -216,7 +220,7 @@ export function handleSearchModeToken(
   if (!searchManager.locked) {
     if (token.type === 'text') {
       const newQuery = searchManager.query + token.value;
-      searchManager.search(newQuery, history);
+      searchManager.search(newQuery, history, state.conversationManager);
     } else if (token.type === 'key') {
       if (token.logicalName === 'escape') {
         searchManager.close();
@@ -230,7 +234,7 @@ export function handleSearchModeToken(
         }
       } else if (token.logicalName === 'backspace') {
         const newQuery = searchManager.query.slice(0, -1);
-        searchManager.search(newQuery, history);
+        searchManager.search(newQuery, history, state.conversationManager);
       } else if (matchesSearchShortcut) {
         searchManager.close();
       }

package/src/input/handler.ts

@@ -2,7 +2,8 @@ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node
 import { dirname } from 'node:path';
 import { InputTokenizer } from '@pellux/goodvibes-sdk/platform/core';
 import { createOAuthLocalListener } from '@pellux/goodvibes-sdk/platform/config';
-import { clearModalStackForHandler, cleanupMarkerRegistryForHandler, executeBlockActionForHandler, expandPromptForHandler, findMarkerAtPosForHandler, getImageAttachmentsForHandler, handleBlockCopyForHandler, handleBlockRerunForHandler, handleBlockSaveForHandler, handleBlockToggleForHandler, handleBookmarkForHandler, handleCopyForHandler, handleCtrlCForHandler, handleDiffApplyForHandler, handleEscapeForHandler, hydrateOnboardingWizardFromRuntimeForHandler, modalOpenedForHandler, openOnboardingWizardForHandler, registerPasteForHandler } from './handler-interactions.ts';
+import { clearModalStackForHandler, cleanupMarkerRegistryForHandler, executeBlockActionForHandler, expandPromptForHandler, findMarkerAtPosForHandler, getImageAttachmentsForHandler, handleBlockCopyForHandler, handleBlockSaveForHandler, handleBlockToggleForHandler, handleBookmarkForHandler, handleCopyForHandler, handleCtrlCForHandler, handleDiffApplyForHandler, handleEscapeForHandler, hydrateOnboardingWizardFromRuntimeForHandler, modalOpenedForHandler, openOnboardingWizardForHandler, registerPasteForHandler } from './handler-interactions.ts';
+import { getViewportBottomLine } from '../renderer/conversation-layout.ts';
 import { clearOnboardingModelPickerCancelStateForHandler, clearOnboardingPendingModelPickerTargetForHandler, completeOpenAiSubscriptionFromListenerForHandler, getOnboardingConfigValueForHandler, getOnboardingRuntimePostureForHandler, handleModelPickerCommitForHandler, handleOnboardingActionForHandler, handleOpenAiSubscriptionFinishForHandler, handleOpenAiSubscriptionStartForHandler, openModelPickerWithTargetForHandler, openProviderModelPickerWithTargetForHandler, refreshOnboardingHydrationForHandler, restartOnboardingExternalServicesIfNeededForHandler, restoreOnboardingModelPickerCancelStateForHandler, saveWizardProgressForHandler, syncRuntimeFromOnboardingRequestForHandler, verifyOnboardingRuntimePostureForHandler, } from './handler-onboarding.ts';
 import type { OnboardingRuntimePosture } from './handler-types.ts';
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
@@ -48,7 +49,6 @@ import {
   findMarkerAtPos,
   formatFileSize,
   handleBlockCopy,
-  handleBlockRerun,
   handleBlockSave,
   handleBlockToggle,
   handleBookmark,
@@ -83,6 +83,7 @@ import {
 import { KillRing } from './kill-ring.ts';
 import { maskConcealedText, beginConcealedInputFor, submitConcealedInputFor, cancelConcealedInputFor, type ConcealedInputRequest } from './concealed-input.ts';
 import { clearModalStack, handleEscape, modalOpened } from './handler-modal-stack.ts';
+import { SelectionModalQueue, attachSelectionModalQueue } from './selection-modal-queue.ts';
 import { handleModalTokenRoutes } from './handler-modal-token-routes.ts';
 import {
   captureOnboardingWizardSnapshot,
@@ -222,6 +223,8 @@ export class InputHandler implements InputHandlerLike {
   public conversationManager: ConversationManager | null = null;
   public selectionCallback: SelectionModalCallback | null = null;
   public syncFeedSelectionCallback: ((callback: SelectionModalCallback | null) => void) | null = null;
+  /** FIFO queue for overlapping openSelection() calls — see selection-modal-queue.ts. */
+  private selectionQueue!: SelectionModalQueue;
   /** Time of last [COPIED] block feedback, for brief display. */
   public lastBlockCopyTime = 0;
   public mouseDownRow = -1;
@@ -282,6 +285,7 @@ export class InputHandler implements InputHandlerLike {
     this.bookmarkModal = new BookmarkModal(uiServices.shell.bookmarkManager);
     this.sessionPickerModal = new SessionPickerModal(uiServices.sessions.sessionManager, uiServices.sessions.sessionBroker);
     this.profilePickerModal = new ProfilePickerModal(uiServices.shell.profileManager);
+    this.selectionQueue = attachSelectionModalQueue(this); // wires exitApp teardown too — see selection-modal-queue.ts
     this.initFeedContext();
   }
 
@@ -404,6 +408,8 @@ export class InputHandler implements InputHandlerLike {
   /**
    * openSelection - Open the generic selection modal with a callback.
    * The callback receives SelectionResult on selection, or null on cancel/escape.
+   * A second call while one is already showing queues FIFO instead of
+   * overwriting it — see selection-modal-queue.ts.
    */
   public openSelection(
     title: string,
@@ -416,14 +422,9 @@ export class InputHandler implements InputHandlerLike {
     } | undefined,
     callback: SelectionModalCallback,
   ): void {
-    this.modalOpened('selection');
-    this.selectionModal.open(title, items, opts);
-    this.selectionCallback = callback;
-    this.syncFeedSelectionCallback?.(callback);
-    this.requestRender();
+    this.selectionQueue.request({ title, items, opts, callback });
   }
 
-
   public openOnboardingWizard(
     modeOrOptions: OnboardingWizardMode | OpenOnboardingWizardOptions = 'new',
   ): void { openOnboardingWizardForHandler(this, modeOrOptions); }
@@ -439,7 +440,16 @@ export class InputHandler implements InputHandlerLike {
   public handleBookmark(): void { handleBookmarkForHandler(this); }
   public handleBlockSave(): void { handleBlockSaveForHandler(this); }
   public executeBlockAction(actionId: string): void { executeBlockActionForHandler(this, actionId); }
-  public handleBlockRerun(): void { handleBlockRerunForHandler(this); }
+  /** The block the user is actually looking at: the viewport's bottom-most
+   *  visible line (see getViewportBottomLine's doc) — not the raw scrollTop,
+   *  which is off-screen-above once the transcript exceeds one page. Every
+   *  anchor-based block action (Ctrl+Y/B/S/A, Tab, the block-actions menu)
+   *  resolves its target through this, so they all agree on what "nearest
+   *  block" means. */
+  public getBlockAnchorLine(): number {
+    const lineCount = this.conversationManager?.history.getLineCount() ?? 0;
+    return getViewportBottomLine(this.getScrollTop(), this.getViewportHeight(), lineCount);
+  }
   public handleBlockToggle(): void { handleBlockToggleForHandler(this); }
   public handleDiffApply(): boolean { return handleDiffApplyForHandler(this); }
   public handleCtrlC(): void { handleCtrlCForHandler(this); }

package/src/input/search.ts

@@ -1,4 +1,5 @@
 import type { InfiniteBuffer } from '../core/history.ts';
+import type { ConversationManager } from '../core/conversation';
 
 export interface SearchMatch {
   line: number;
@@ -50,8 +51,37 @@ export class SearchManager {
     this.locked = false;
   }
 
-  /** Update query and find matches in the history buffer. */
-  search(query: string, history: InfiniteBuffer): void {
+  /**
+   * Update query and find matches in the history buffer.
+   *
+   * A collapsed block (or folded tool-result group) renders 1-2 summary
+   * lines, so scanning only the rendered buffer misses text the user watched
+   * stream by before it folded. When `conversationManager` is provided, any
+   * currently-collapsed block whose searchable corpus contains the query is
+   * expanded first (never re-collapsed — a false "No matches" is a lie, an
+   * extra expand is not), so the match becomes a real, navigable line in the
+   * rendered buffer scanned below.
+   *
+   * That corpus is the block's own RAW content, plus — for a folded
+   * tool-result group — the raw content of every one of its member messages.
+   * A group's own rawContent is only its summary header line ("2 tool results
+   * folded (read exec, 18 lines total)") and its members push no BlockMeta of
+   * their own while folded (see conversation-tool-groups.ts), so without the
+   * member corpus a needle living inside a member matches nothing at all and
+   * the user gets "No matches" for text they watched stream by. Member text is
+   * read off the message snapshot, and is the same string the renderer stores
+   * as that member's own block rawContent once the group is expanded.
+   *
+   * A hit anywhere in that corpus expands the group's own collapseKey AND
+   * every member's `msg_<idx>` key — expanding the header alone would leave
+   * the member holding the hit invisible, and expanding all members keeps the
+   * behavior identical whether the hit came from the header or a member.
+   *
+   * `getDisplayBlocks()` is flushed before the buffer is scanned, and the
+   * overlay's match count is always derived from that same rendered scan, so
+   * it never claims more than it can actually navigate to.
+   */
+  search(query: string, history: InfiniteBuffer, conversationManager?: ConversationManager | null): void {
     this.query = query;
     this.matches = [];
     this.currentMatch = 0;
@@ -60,6 +90,68 @@ export class SearchManager {
     if (query.length === 0) return;
 
     const lowerQuery = query.toLowerCase();
+
+    if (conversationManager) {
+      const registry = conversationManager.getBlockRegistry();
+
+      // A folded tool-result group's members render nothing and register no
+      // BlockMeta while collapsed (see conversation-tool-groups.ts), so the
+      // group's searchable corpus is its own header rawContent PLUS each
+      // member's raw content — which only the message snapshot can supply,
+      // since there is no member block to read it from.
+      const memberIndexes: number[] = [];
+      for (const block of registry) {
+        if (block.type !== 'tool_group' || !block.groupMemberIndexes) continue;
+        if (!conversationManager.isCollapsed(block.blockIndex)) continue;
+        memberIndexes.push(...block.groupMemberIndexes);
+      }
+
+      // Read in ONE snapshot pass: getMessageSnapshot() clones the whole
+      // message array (~0.8ms on a 900-message conversation) and search() runs
+      // on every keystroke, so a per-member read would stall typing outright.
+      // Skipped entirely when nothing is folded.
+      const memberContent = new Map<number, string>();
+      if (memberIndexes.length > 0) {
+        const snapshot = conversationManager.getMessageSnapshot();
+        for (const memberIdx of memberIndexes) {
+          // This is the exact string the renderer stores as a member's own
+          // block rawContent (renderConversationToolMessage in
+          // conversation-rendering.ts) — the corpus is what expanding really
+          // reveals, not a second notion of "content". A member index that
+          // outlived its message (undo() splices the messages tail while a
+          // stale registry still names it) reads back undefined and is simply
+          // skipped rather than throwing.
+          const content = snapshot[memberIdx]?.content;
+          if (typeof content === 'string') memberContent.set(memberIdx, content.toLowerCase());
+        }
+      }
+
+      let expandedAny = false;
+      for (const block of registry) {
+        if (!conversationManager.isCollapsed(block.blockIndex)) continue;
+        const members = block.type === 'tool_group' ? (block.groupMemberIndexes ?? []) : [];
+        const hit = block.rawContent.toLowerCase().includes(lowerQuery)
+          || members.some((memberIdx) => (memberContent.get(memberIdx) ?? '').includes(lowerQuery));
+        if (!hit) continue;
+        conversationManager.setCollapsed(block.collapseKey, false);
+        // Expanding just the group header would still hide each member's own
+        // content — including the member the query actually matched — so open
+        // every member's own collapse key in the same pass. Already-expanded
+        // keys are unaffected; setting false over false is a no-op.
+        for (const memberIdx of members) {
+          conversationManager.setCollapsed(`msg_${memberIdx}`, false);
+        }
+        expandedAny = true;
+      }
+      if (expandedAny) {
+        // Flush the pending re-render so `history` (the same buffer
+        // instance) reflects the newly-expanded content before it's scanned
+        // below — mirrors the existing getDisplayBlocks()-before-read idiom
+        // used by jumpToBookmark/scrollToLine.
+        conversationManager.getDisplayBlocks();
+      }
+    }
+
     const lines = history.getAllLines();
 
     for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {