Introducing new headless local search, terminal resize fix and fixing input lagging

Author: igorcosta

eslint.config.js

@@ -3,7 +3,7 @@ import tsparser from '@typescript-eslint/parser';
 
 export default [
   {
-    ignores: ['dist/**', 'node_modules/**', 'api/**', 'binaries/**']
+    ignores: ['dist/**', 'node_modules/**', 'api/**', 'binaries/**', '.claude/worktrees/**', '.worktrees/**']
   },
   {
     files: ['src/**/*.ts', 'tests/**/*.ts'],

src/ui/inputPrompt.ts

@@ -989,35 +989,30 @@ export function leavePromptSurface(
 function handlePasteComplete(
   pasteState: PasteState,
   rl: readline.Interface,
-  output: NodeJS.WriteStream
+  output: NodeJS.WriteStream,
+  renderActivePrompt: () => void
 ): void {
   const display = getContentDisplay(pasteState.buffer);
-  const rlAny = rl as readline.Interface & { line: string; cursor: number; _refreshLine?: () => void };
+  const rlAny = rl as readline.Interface & { line: string; cursor: number };
 
   // Get any prefix content that was typed before the paste
   const prefix = pasteState.prefixContent || '';
 
-  // Count newlines to know how many extra prompt lines were printed
-  const newlineCount = (pasteState.buffer.match(/\n/g) || []).length;
-
-  // If readline echoed pasted rows, clear that transient output.
-  // When output is suppressed, skip this so we don't move into chat logs.
+  // If readline echoed pasted rows (timeout fallback path where output was
+  // not suppressed), clear those transient lines. On the normal bracketed-
+  // paste path outputSuppressed is true so the box was never disturbed.
   if (!pasteState.outputSuppressed) {
-    // Clear all the extra lines that readline printed during paste
-    // Move cursor up for each newline, clearing as we go
+    const newlineCount = (pasteState.buffer.match(/\n/g) || []).length;
     for (let i = 0; i < newlineCount; i++) {
-      readline.moveCursor(output, 0, -1); // Move up one line
-      readline.clearLine(output, 0); // Clear that line
+      readline.moveCursor(output, 0, -1);
+      readline.clearLine(output, 0);
     }
-
-    // Now we're back at the original prompt line - clear it too
     readline.cursorTo(output, 0);
     readline.clearLine(output, 0);
   }
 
   if (display.isPasted) {
     // Large paste: show indicator, store actual content
-    // Prepend prefix to hidden content so it's included in submission
     pasteState.hiddenContent = prefix + display.actual;
     rlAny.line = prefix + display.visual;
     rlAny.cursor = rlAny.line.length;
@@ -1027,8 +1022,9 @@ function handlePasteComplete(
     rlAny.cursor = rlAny.line.length;
   }
 
-  // Refresh the display with clean prompt
-  rl.prompt(true);
+  // Use the boxed renderer — NOT rl.prompt(true) — so the composer stays
+  // anchored at the bottom and the 3-row layout is preserved.
+  renderActivePrompt();
 
   // Clear the buffer and prefix
   pasteState.buffer = '';
@@ -1045,7 +1041,6 @@ async function promptOnce(options: PromptOnceOptions): Promise<PromptResult> {
   // Initialize paste state for bracketed paste detection
   const pasteState = createPasteState();
   let contextualHelpVisible = false;
-  let renderedContextualHelpLines = 0;
 
   const applyPlanModePrefix = (line: string): string => {
     const planPrefix = getPlanModeManager().isEnabled() ? 'plan:on' : 'plan:off';
@@ -1066,26 +1061,8 @@ async function promptOnce(options: PromptOnceOptions): Promise<PromptResult> {
     return applyPlanModePrefix(statusLine ?? '');
   };
 
-  const getActiveContextualHelpLines = (): string[] => {
-    if (!contextualHelpVisible) {
-      return [];
-    }
-    const rlAny = rl as readline.Interface & { line?: string };
-    const currentLine = rlAny.line ?? '';
-    const width = getPromptBlockWidth(stdOutput.columns);
-    return buildContextualHelpPanelLines(currentLine, width, files, slashCommands);
-  };
-
   const renderPromptSurface = (isResize = false, hasExistingPromptBlock = true): void => {
-    const helpLines = getActiveContextualHelpLines();
-    renderPromptLine(
-      rl,
-      getActiveStatusLine(),
-      stdOutput,
-      isResize,
-      hasExistingPromptBlock,
-      suggestionText
-    );
+    renderPromptLine(rl, getActiveStatusLine(), stdOutput, isResize, hasExistingPromptBlock, suggestionText);
   };
 
   const resizeWatcher = new TerminalResizeWatcher(stdOutput, () => {
@@ -1104,23 +1081,6 @@ async function promptOnce(options: PromptOnceOptions): Promise<PromptResult> {
     renderPromptSurface(false, true);
   }
 
-  // Override readline's _refreshLine to use our renderPromptLine instead.
-  // readline's default _refreshLine miscalculates cursor position when the
-  // prompt contains ANSI escape codes (chalk styling), causing the cursor
-  // to appear on top of typed text rather than after it.
-  const rlInternal = rl as readline.Interface & { _refreshLine?: () => void };
-  const originalRefreshLine = typeof rlInternal._refreshLine === 'function'
-    ? rlInternal._refreshLine.bind(rlInternal)
-    : undefined;
-
-  if (typeof rlInternal._refreshLine === 'function') {
-    rlInternal._refreshLine = () => {
-      if (!pasteState.isInPaste) {
-        renderPromptLine(rl, statusLine, stdOutput);
-      }
-    };
-  }
-
   return new Promise<PromptResult>((resolve) => {
     let ctrlCCount = 0;
     let closed = false;
@@ -1327,7 +1287,7 @@ async function promptOnce(options: PromptOnceOptions): Promise<PromptResult> {
               pasteState.buffer, onImageDetected, { announce: false, output: stdOutput }
             );
           }
-          handlePasteComplete(pasteState, rl, stdOutput);
+          handlePasteComplete(pasteState, rl, stdOutput, renderActivePrompt);
           // Schedule a deferred fallback scan in case the synchronous
           // replacement missed (e.g. file not yet materialized).
           scheduleInlineImageScan(10);
@@ -1358,7 +1318,7 @@ async function promptOnce(options: PromptOnceOptions): Promise<PromptResult> {
                 pasteState.buffer, onImageDetected, { announce: false, output: stdOutput }
               );
             }
-            handlePasteComplete(pasteState, rl, stdOutput);
+            handlePasteComplete(pasteState, rl, stdOutput, renderActivePrompt);
             scheduleInlineImageScan(10);
           }
         }, 50);
@@ -1620,6 +1580,10 @@ function getComposerBorderStyle(line: string): InputBorderStyle {
   return 'default';
 }
 
+// Track the width used by the last renderPromptLine call so we can detect
+// width changes (resize) and compute reflow line counts for clearing.
+let lastRenderedPromptWidth = 0;
+
 function renderPromptLine(
   rl: readline.Interface,
   statusLine: string | { left: string; right: string } | undefined,
@@ -1638,25 +1602,41 @@ function renderPromptLine(
   const bottomBorder = drawInputBottomBorder(width, borderStyle);
   const statusRow = formatPromptStatusRow(statusLine, width);
 
+  // Detect width change even when called from _refreshLine (which passes
+  // isResize=false). Readline triggers _refreshLine on resize before our
+  // debounced handler fires, so we must use the reflow-aware clearing path
+  // whenever the width has actually changed.
+  const widthChanged = lastRenderedPromptWidth > 0 && width !== lastRenderedPromptWidth;
+  const effectiveResize = isResize || widthChanged;
+
   // Keep readline's prompt in sync for line editing internals.
   rl.setPrompt(PROMPT_PREFIX);
 
   // Hide cursor during rendering to prevent flicker/slow blinking.
-  // The cursor visibly jumps as lines are cleared and rewritten;
-  // hiding it produces a clean, natural blink at the final position.
   output.write('\x1b[?25l');
 
-  if (isResize) {
-    // Cursor sits on the input row. Move up to include the top border
-    // before clearing, otherwise old borders at previous width remain.
-    for (let i = 0; i < PROMPT_LINES_ABOVE_INPUT; i++) {
-      readline.moveCursor(output, 0, -1);
-    }
+  if (effectiveResize && hasExistingPromptBlock) {
+    // When the terminal resizes, it reflows all previously written content.
+    // A line of N chars wraps to ceil(N / newCols) physical rows at the new
+    // terminal width. We must move up enough to reach above ALL reflowed
+    // remnants of the old prompt block before clearing.
+    const termCols = output.columns ?? 80;
+    const oldWidth = lastRenderedPromptWidth || width;
+    const logicalLines = PROMPT_BLOCK_LINE_COUNT + STATUS_LINE_COUNT;
+    // Use actual terminal columns (not prompt width) since that's what
+    // the terminal uses for reflow calculations.
+    const rowsPerOldLine = Math.max(1, Math.ceil(oldWidth / Math.max(1, termCols)));
+    const totalReflowedRows = logicalLines * rowsPerOldLine;
+    // Move up generously to reach above all reflowed prompt content.
+    // Add extra margin because the cursor's physical position within the
+    // reflowed input row is uncertain.
+    const moveUp = totalReflowedRows + rowsPerOldLine;
+    readline.moveCursor(output, 0, -moveUp);
     readline.cursorTo(output, 0);
     readline.clearScreenDown(output);
   } else if (hasExistingPromptBlock) {
-    // Cursor normally sits on the input row.
-    // Clear the full prompt block in place before re-drawing.
+    // Same-width redraw: cursor sits on the input row.
+    // Clear the fixed 4-line prompt block in place.
     readline.cursorTo(output, 0);
     for (let i = 0; i < PROMPT_LINES_ABOVE_INPUT; i++) {
       readline.moveCursor(output, 0, -1);
@@ -1673,9 +1653,7 @@ function renderPromptLine(
     }
     readline.cursorTo(output, 0);
   } else {
-    // Initial render: the cursor has been placed on a fresh row by createReadline,
-    // but defensively clear the current line before drawing the top border to
-    // eliminate any residual characters that could cause a one-frame flash.
+    // Initial render: defensively clear current line before drawing.
     readline.cursorTo(output, 0);
     readline.clearLine(output, 0);
   }
@@ -1687,11 +1665,11 @@ function renderPromptLine(
   output.write(statusRow);
 
   // Move cursor back to input row, inside the box.
-  // drawInputBox uses chalk background only (no │ side borders),
-  // so cursorColumn from buildPromptRenderState is already correct.
   readline.moveCursor(output, 0, -(PROMPT_LINES_BELOW_INPUT + STATUS_LINE_COUNT));
   readline.cursorTo(output, prompt.cursorColumn);
 
   // Show cursor at its final, correct position.
   output.write('\x1b[?25h');
+
+  lastRenderedPromptWidth = width;
 }

src/ui/terminalResize.ts

@@ -11,19 +11,30 @@ type ResizeCallback = () => void;
 
 /**
  * Watches a TTY stream for resize events and runs the supplied callback.
+ * Debounces rapid events (e.g. while dragging a window edge) to avoid
+ * redundant redraws that leave ghost prompt artifacts.
  */
 export class TerminalResizeWatcher {
   private readonly stream: ResizableStream;
   private readonly handler: ResizeCallback;
   private disposed = false;
+  private debounceTimer: NodeJS.Timeout | undefined;
 
-  constructor(stream: ResizableStream, callback: ResizeCallback) {
+  constructor(stream: ResizableStream, callback: ResizeCallback, debounceMs = 80) {
     this.stream = stream;
     this.handler = () => {
       if (this.disposed) {
         return;
       }
-      callback();
+      if (this.debounceTimer) {
+        clearTimeout(this.debounceTimer);
+      }
+      this.debounceTimer = setTimeout(() => {
+        this.debounceTimer = undefined;
+        if (!this.disposed) {
+          callback();
+        }
+      }, debounceMs);
     };
     if (this.stream && typeof this.stream.on === 'function') {
       this.stream.on('resize', this.handler);
@@ -35,6 +46,10 @@ export class TerminalResizeWatcher {
       return;
     }
     this.disposed = true;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = undefined;
+    }
     if (this.stream && typeof this.stream.off === 'function') {
       this.stream.off('resize', this.handler);
     }

tests/core/agent.startup-ui.spec.ts

@@ -1120,14 +1120,10 @@ describe('agent startup and active input UI', () => {
       collectWorkspaceFiles: vi.fn(async () => {}),
     };
 
-    // Mock readInstruction to resolve immediately
-    const readInstructionMock = vi.fn(async () => 'test input');
-
     // Replace the private method's dependency on readInstruction
     // by checking the timing: promptForInstruction must NOT wait
     // more than 200ms before invoking readInstruction.
-    const start = Date.now();
-    const promptPromise = (agent as any).promptForInstruction([], []).catch(() => {});
+    const _promptPromise = (agent as any).promptForInstruction([], []).catch(() => {});
 
     // Give it a short window to proceed
     await new Promise((r) => setTimeout(r, 200));

tests/googleHeadlessSearch.spec.ts

@@ -8,7 +8,7 @@
  * and HTML result parsing from rendered DOM.
  */
 
-import { describe, it, expect, vi, afterEach } from 'vitest';
+import { describe, it, expect } from 'vitest';
 
 // We'll test the exported helpers from web.ts
 import { findChromePath, parseGoogleResultsFromDOM } from '../src/actions/web.js';

tests/terminalResize.spec.ts

@@ -18,26 +18,78 @@ class FakeStream extends EventEmitter {
 }
 
 describe('TerminalResizeWatcher', () => {
-  it('invokes the provided callback when resize events occur', () => {
+  it('invokes the provided callback after debounce period', async () => {
+    vi.useFakeTimers();
     const stream = new FakeStream();
     const handler = vi.fn();
 
     const watcher = new TerminalResizeWatcher(stream as any, handler);
     stream.emit('resize');
+
+    // Not called immediately — debounced
+    expect(handler).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(100);
+    expect(handler).toHaveBeenCalledTimes(1);
+
+    watcher.dispose();
+    vi.useRealTimers();
+  });
+
+  it('coalesces rapid resize events into a single callback', async () => {
+    vi.useFakeTimers();
+    const stream = new FakeStream();
+    const handler = vi.fn();
+
+    const watcher = new TerminalResizeWatcher(stream as any, handler);
+
+    // Rapid-fire events (e.g. dragging window edge)
+    stream.emit('resize');
+    vi.advanceTimersByTime(20);
+    stream.emit('resize');
+    vi.advanceTimersByTime(20);
+    stream.emit('resize');
+    vi.advanceTimersByTime(20);
     stream.emit('resize');
 
-    expect(handler).toHaveBeenCalledTimes(2);
+    // Still within debounce window — not called yet
+    expect(handler).not.toHaveBeenCalled();
+
+    // After debounce settles
+    vi.advanceTimersByTime(100);
+    expect(handler).toHaveBeenCalledTimes(1);
+
     watcher.dispose();
+    vi.useRealTimers();
   });
 
   it('stops reacting once disposed', () => {
+    vi.useFakeTimers();
     const stream = new FakeStream();
     const handler = vi.fn();
 
     const watcher = new TerminalResizeWatcher(stream as any, handler);
     watcher.dispose();
     stream.emit('resize');
+    vi.advanceTimersByTime(200);
+
+    expect(handler).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it('cancels pending debounce timer on dispose', () => {
+    vi.useFakeTimers();
+    const stream = new FakeStream();
+    const handler = vi.fn();
+
+    const watcher = new TerminalResizeWatcher(stream as any, handler);
+    stream.emit('resize');
+
+    // Dispose before debounce fires
+    watcher.dispose();
+    vi.advanceTimersByTime(200);
 
     expect(handler).not.toHaveBeenCalled();
+    vi.useRealTimers();
   });
 });