mixdog 0.9.2 → 0.9.4

package/src/tui/components/PromptInput.jsx

@@ -17,7 +17,7 @@
  */
 import React, { useEffect, useLayoutEffect, useState, useRef } from 'react';
 import { Box, Text, useInput, usePaste, useStdin } from 'ink';
-import stringWidth from 'string-width';
+import { displayWidth } from '../display-width.mjs';
 import { theme, surfaceBackground } from '../theme.mjs';
 import {
   caretPosition,
@@ -38,14 +38,21 @@ import {
   replaceSelection,
   selectionRange,
   verticalOffset,
+  wordRangeAt,
 } from '../input-editing.mjs';
-
-function hintStyle(tone) {
-  if (tone === 'error') return { textColor: theme.error };
-  if (tone === 'warn' || tone === 'cancel') return { textColor: theme.warning };
-  if (tone === 'plain') return { textColor: theme.subtle };
-  return { textColor: theme.inactive };
-}
+import {
+  hintStyle,
+  insertText,
+  normalizePastedText,
+  singleTrailingLineBreakPrefix,
+  draftStateEqual,
+  isModifiedEnterSequence,
+  isAnyModifiedEnterSequence,
+} from './prompt-input/edit-helpers.mjs';
+import {
+  VOICE_TICK_MS,
+  voiceIndicatorTextFor,
+} from './prompt-input/voice-indicator.mjs';
 
 // Windows Terminal IME composition can clip a glyph that starts exactly at the
 // left edge of the editable text node. The rounded prompt box already adds a
@@ -56,11 +63,6 @@ const IME_LEFT_GUARD_COLUMNS = 0;
 // needs to immediate-render). Matches transcript selection paint cadence.
 const MOUSE_EXTEND_COALESCE_MS = 24;
 
-function insertText(draft, input) {
-  if (!input) return draft;
-  return replaceSelection(draft, input);
-}
-
 function renderSelectedText(displayValue, range, trailingSpace = false) {
   if (!range) return trailingSpace ? `${displayValue} ` : displayValue;
   const start = Math.max(0, Math.min(displayValue.length, range.start));
@@ -77,57 +79,6 @@ function renderSelectedText(displayValue, range, trailingSpace = false) {
   );
 }
 
-function normalizePastedText(text) {
-  return String(text ?? '').replace(/\r\n?/g, '\n');
-}
-
-function singleTrailingLineBreakPrefix(text) {
-  const normalized = normalizePastedText(text);
-  if (!normalized.endsWith('\n')) return null;
-  const prefix = normalized.slice(0, -1);
-  return prefix.includes('\n') ? null : prefix;
-}
-
-function draftStateEqual(a, b) {
-  return (
-    a.value === b.value
-    && a.cursor === b.cursor
-    && a.selectionAnchor === b.selectionAnchor
-  );
-}
-
-// Recognize a MODIFIED Enter delivered via the kitty keyboard protocol
-// (\x1b[13;<mod>u) or modifyOtherKeys (\x1b[27;<mod>;13~). The xterm modifier
-// param is (1 + bitmask) where the bitmask bits are shift=1, alt=2, ctrl=4. We
-// treat Ctrl+Enter AND Shift+Enter (the two common "insert newline" chords) as a
-// newline, so we match when the shift OR ctrl bit is set. Ctrl+J is handled
-// separately as the protocol-independent fallback.
-const MODIFIED_ENTER_SHIFT_OR_CTRL = 1 | 4;
-function isModifiedEnterSequence(input) {
-  const text = String(input ?? '');
-  const body = text.startsWith('\x1b[') ? text.slice(2) : text.startsWith('[') ? text.slice(1) : '';
-  if (!body) return false;
-  const kitty = /^13;(\d+)(?::\d+)?(?:;[\d:]+)?u$/.exec(body);
-  if (kitty) return ((Number(kitty[1]) - 1) & MODIFIED_ENTER_SHIFT_OR_CTRL) !== 0;
-  const modifyOtherKeys = /^27;(\d+);13~$/.exec(body);
-  return Boolean(modifyOtherKeys && (((Number(modifyOtherKeys[1]) - 1) & MODIFIED_ENTER_SHIFT_OR_CTRL) !== 0));
-}
-
-// Recognize ANY modified Enter (any modifier bitmask, e.g. Alt+Enter \x1b[13;3u
-// / \x1b[27;3;13~). Used to CONSUME modified-Enter sequences we don't map to a
-// newline (Alt-only, etc.) so they aren't typed into the prompt as raw CSI text
-// under modifyOtherKeys. Plain Enter (mod param = 1, bitmask 0) is intentionally
-// NOT matched, so it still submits.
-function isAnyModifiedEnterSequence(input) {
-  const text = String(input ?? '');
-  const body = text.startsWith('\x1b[') ? text.slice(2) : text.startsWith('[') ? text.slice(1) : '';
-  if (!body) return false;
-  const kitty = /^13;(\d+)(?::\d+)?(?:;[\d:]+)?u$/.exec(body);
-  if (kitty) return (Number(kitty[1]) - 1) !== 0;
-  const modifyOtherKeys = /^27;(\d+);13~$/.exec(body);
-  return Boolean(modifyOtherKeys && ((Number(modifyOtherKeys[1]) - 1) !== 0));
-}
-
 export function PromptInput({
   onSubmit,
   disabled = false,
@@ -150,10 +101,12 @@ export function PromptInput({
   onHistoryNavigate,
   onPasteText,
   onVoiceToggle,
+  voiceIndicatorMode = 'off',
   selectionRef,
   valueRef,
   boxRectRef,
   mouseSelectionRef,
+  suppressShiftNavRef,
 }) {
   const [draft, setDraft] = useState(() => {
     const value = String(initialValue || '');
@@ -171,8 +124,32 @@ export function PromptInput({
   const boxRef = useRef(null);
   const cursorEnabledRef = useRef(false); // latest enabled state, read by the anchor fn at render time
   const contentWidthRef = useRef(80);
+  // Cells reserved on the right for the voice indicator glyph(s) (0 when
+  // hidden, 1 idle/spinner-only, 2 recording's "◉"+braille). Read by the
+  // cursor-anchor closure below (installed ONCE, so it must read live state
+  // via a ref rather than close over a render-local variable) to keep the
+  // caret/wrap math in sync with the actual reserved column, same pattern as
+  // IME_LEFT_GUARD_COLUMNS on the left edge.
+  const voiceIndicatorWidthRef = useRef(0);
   const preferredColumnRef = useRef(null);
   const mouseExtendCoalesceRef = useRef({ pendingNext: null, timer: null, t: 0 });
+  // Voice indicator animation tick. Runs a single ~120ms interval ONLY while
+  // an ANIMATED mode is active (installing/recording/transcribing) — 'idle'
+  // renders a static glyph and 'off' renders nothing, so neither keeps a
+  // timer alive (the old idle "breathing" pulse spun constantly whenever
+  // voice was merely enabled, reading as phantom activity).
+  const [voiceTick, setVoiceTick] = useState(0);
+  useEffect(() => {
+    if (voiceIndicatorMode === 'off' || voiceIndicatorMode === 'idle') return undefined;
+    const timer = setInterval(() => setVoiceTick((t) => (t + 1) % 1000000), VOICE_TICK_MS);
+    timer.unref?.();
+    return () => clearInterval(timer);
+  }, [voiceIndicatorMode]);
+  // Undo/redo snapshot stack. Each entry is a { value, cursor, selectionAnchor }
+  // draft snapshot. Continuous typing coalesces (see UNDO_COALESCE_MS) so a run
+  // of characters collapses into one undo step; cursor-only moves are NOT
+  // snapshotted. Reset on submit / draftOverride.
+  const undoRef = useRef({ past: [], future: [], lastPushAt: 0, lastValue: null });
   const { value, cursor } = draft;
   draftRef.current = draft;
   if (selectionRef) {
@@ -204,6 +181,7 @@ export function PromptInput({
     const sameDraft = draftStateEqual(draftRef.current, next);
     if (!options.keepPreferredColumn) preferredColumnRef.current = null;
     if (sameDraft) return;
+    if (!options.skipHistory) recordUndoSnapshot(draftRef.current, next, options);
     draftRef.current = next;
     setDraft(next);
     queueMicrotask(flushImmediate);
@@ -248,11 +226,20 @@ export function PromptInput({
       const d = draftRef.current;
       const w = yogaNode?.getComputedWidth?.() ?? 0;
       const guardColumns = w > IME_LEFT_GUARD_COLUMNS ? IME_LEFT_GUARD_COLUMNS : 0;
-      const contentWidth = Math.max(1, (w ? w - guardColumns : contentWidthRef.current) || 80);
+      // Reserve the voice-indicator's own cells (+1 gap column when visible)
+      // out of the SAME width the caret/wrap math uses, mirroring the left
+      // guard above — otherwise a visible indicator would silently overlap
+      // the caret/typed text at the right edge instead of pushing content in.
+      const voiceReserve = voiceIndicatorWidthRef.current > 0 ? voiceIndicatorWidthRef.current + 1 : 0;
+      const contentWidth = Math.max(1, (w ? w - guardColumns - voiceReserve : contentWidthRef.current) || 80);
       contentWidthRef.current = contentWidth;
       const caret = w > 0
-        ? caretPosition(d.value, d.cursor, contentWidth)
-        : { row: 0, col: stringWidth(d.value.slice(0, d.cursor)) };
+        // PromptInput renders a trailing space cell when the cursor is at
+        // end-of-input, so a caret flush on the last column there still has a
+        // following cell — pass hasTrailingContent=true so it rolls to row N+1
+        // exactly as ink wraps the trailing space.
+        ? caretPosition(d.value, d.cursor, contentWidth, d.cursor >= d.value.length ? true : undefined)
+        : { row: 0, col: displayWidth(d.value.slice(0, d.cursor)) };
       return w > 0
         ? { ...caret, col: caret.col + guardColumns }
         : caret;
@@ -264,6 +251,70 @@ export function PromptInput({
     commitDraft(fn(draftRef.current), options);
   };
 
+  // --- undo/redo -----------------------------------------------------------
+  // Continuous-typing coalesce window: successive value-changing edits within
+  // this window collapse into a single undo step.
+  const UNDO_COALESCE_MS = 500;
+  const UNDO_MAX = 100;
+
+  const snapshotOf = (d) => ({ value: d.value, cursor: d.cursor, selectionAnchor: d.selectionAnchor ?? null });
+
+  const resetUndo = () => {
+    undoRef.current = { past: [], future: [], lastPushAt: 0, lastValue: null };
+  };
+
+  // Record a snapshot of the PREVIOUS state before applying `next`. Cursor-only
+  // moves (value unchanged) are never snapshotted. Consecutive value edits
+  // within UNDO_COALESCE_MS coalesce (we keep only the first snapshot of the
+  // run, so a single undo reverts the whole burst).
+  const recordUndoSnapshot = (prev, next, options = {}) => {
+    const stack = undoRef.current;
+    if (prev.value === next.value) {
+      // Cursor/selection-only move: don't snapshot, but BREAK the coalesce run
+      // so a following edit starts a fresh undo step (typing→move→typing must
+      // not collapse into one undo).
+      stack.lastPushAt = 0;
+      stack.lastValue = next.value;
+      return;
+    }
+    const now = Date.now();
+    const coalesce = !options.undoBreak
+      && stack.past.length > 0
+      && (now - stack.lastPushAt) < UNDO_COALESCE_MS
+      && stack.lastValue === prev.value;
+    if (!coalesce) {
+      stack.past.push(snapshotOf(prev));
+      if (stack.past.length > UNDO_MAX) stack.past.shift();
+    }
+    stack.lastPushAt = now;
+    stack.lastValue = next.value;
+    stack.future = [];
+  };
+
+  const performUndo = () => {
+    const stack = undoRef.current;
+    if (stack.past.length === 0) return false;
+    const prev = stack.past.pop();
+    stack.future.push(snapshotOf(draftRef.current));
+    stack.lastPushAt = 0;
+    stack.lastValue = prev.value;
+    commitDraft(prev, { skipHistory: true });
+    return true;
+  };
+
+  const performRedo = () => {
+    const stack = undoRef.current;
+    if (stack.future.length === 0) return false;
+    const next = stack.future.pop();
+    stack.past.push(snapshotOf(draftRef.current));
+    if (stack.past.length > UNDO_MAX) stack.past.shift();
+    stack.lastPushAt = 0;
+    stack.lastValue = next.value;
+    commitDraft(next, { skipHistory: true });
+    return true;
+  };
+  // -------------------------------------------------------------------------
+
   const cancelMouseExtendCoalesce = () => {
     const state = mouseExtendCoalesceRef.current;
     if (state.timer) {
@@ -332,6 +383,28 @@ export function PromptInput({
         const anchor = Number.isFinite(d.selectionAnchor) ? d.selectionAnchor : d.cursor;
         queueMouseExtendCommit({ ...d, cursor: off, selectionAnchor: anchor }, immediate);
       },
+      hasSelection: () => selectionRange(draftRef.current) != null,
+      // Double-click word select: pick the word/punctuation run under the
+      // clicked offset and set selectionAnchor/cursor to its bounds so it
+      // paints via the normal selection highlight. Triple-click line select
+      // uses lineStart/lineEnd instead (see selectLineAt).
+      selectWordAt: (offset) => {
+        cancelMouseExtendCoalesce();
+        const value = draftRef.current.value;
+        const off = Math.max(0, Math.min(value.length, Math.floor(Number(offset) || 0)));
+        const { start, end } = wordRangeAt(value, off);
+        commitDraft({ ...draftRef.current, cursor: end, selectionAnchor: start });
+        mouseExtendCoalesceRef.current.t = Date.now();
+      },
+      selectLineAt: (offset) => {
+        cancelMouseExtendCoalesce();
+        const value = draftRef.current.value;
+        const off = Math.max(0, Math.min(value.length, Math.floor(Number(offset) || 0)));
+        const start = lineStart(value, off);
+        const end = lineEnd(value, off);
+        commitDraft({ ...draftRef.current, cursor: end, selectionAnchor: start });
+        mouseExtendCoalesceRef.current.t = Date.now();
+      },
       clear: () => {
         cancelMouseExtendCoalesce();
         if (selectionRange(draftRef.current)) commitDraft(clearSelection(draftRef.current));
@@ -405,7 +478,8 @@ export function PromptInput({
 
   useEffect(() => {
     if (!draftOverride || typeof draftOverride.value !== 'string') return;
-    commitDraft({ value: draftOverride.value, cursor: draftOverride.value.length, selectionAnchor: null });
+    commitDraft({ value: draftOverride.value, cursor: draftOverride.value.length, selectionAnchor: null }, { skipHistory: true });
+    resetUndo();
   }, [draftOverride?.id]);
 
   useEffect(() => () => {
@@ -419,7 +493,8 @@ export function PromptInput({
       commitDraft(next);
       return;
     }
-    commitDraft({ value: '', cursor: 0, selectionAnchor: null });
+    commitDraft({ value: '', cursor: 0, selectionAnchor: null }, { skipHistory: true });
+    resetUndo();
   };
 
   const submitEnterChunk = (prefix = '') => {
@@ -450,6 +525,21 @@ export function PromptInput({
     const rawInput = String(input ?? '');
     const inputKey = rawInput.toLowerCase();
 
+    // App owns Shift+Arrow when a transcript/status ink-grid selection is live.
+    // Because the parent (App) useInput handler fires AFTER this child handler
+    // for the same event, a flag SET in App's handler is always one event stale.
+    // Instead call a synchronous predicate derived from dragRef at event time.
+    const gridSelectionActive = typeof suppressShiftNavRef === 'function'
+      ? suppressShiftNavRef()
+      : (typeof suppressShiftNavRef?.current === 'function'
+        ? suppressShiftNavRef.current()
+        : Boolean(suppressShiftNavRef?.current));
+    if (gridSelectionActive) {
+      const isShiftArrow = key.shift
+        && (key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.home || key.end);
+      if (isShiftArrow) return;
+    }
+
     // Drop SGR mouse-tracking sequences (wheel/click). When app mouse tracking
     // is explicitly enabled, App parses these off raw stdin itself;
     // ink still forwards the bytes here as "input", which would otherwise type
@@ -482,7 +572,22 @@ export function PromptInput({
     const rawShiftDown = rawInput === '\x1b[1;2B' || rawInput === '\x1b[b' || rawInput === '[1;2B';
     const rawShiftRight = rawInput === '\x1b[1;2C' || rawInput === '\x1b[c' || rawInput === '[1;2C';
     const rawShiftLeft = rawInput === '\x1b[1;2D' || rawInput === '\x1b[d' || rawInput === '[1;2D';
-    const shiftHeld = key.shift || rawShiftUp || rawShiftDown || rawShiftLeft || rawShiftRight;
+    // Ctrl+Shift+Arrow modifier sequences: xterm mod=6 (1 + shift(1) + ctrl(4))
+    // arrives as `\x1b[1;6<dir>`; kitty keyboard protocol reports the same chord
+    // as `\x1b[<code>;6<dir>` (also mod=6). Ink decodes neither the `;6` for
+    // arrows, so the bytes arrive raw. Fold into a ctrlShiftHeld signal used to
+    // drive whole-word selection-extend below. `\x1b[1;6<dir>` covers both the
+    // classic xterm form and kitty's default (which emits the legacy arrow form
+    // with the CSI-u modifier param for arrow keys).
+    const rawCtrlShiftUp = rawInput === '\x1b[1;6A' || rawInput === '[1;6A';
+    const rawCtrlShiftDown = rawInput === '\x1b[1;6B' || rawInput === '[1;6B';
+    const rawCtrlShiftRight = rawInput === '\x1b[1;6C' || rawInput === '[1;6C';
+    const rawCtrlShiftLeft = rawInput === '\x1b[1;6D' || rawInput === '[1;6D';
+    const ctrlShiftHeld =
+      rawCtrlShiftUp || rawCtrlShiftDown || rawCtrlShiftLeft || rawCtrlShiftRight
+      || (key.shift && key.ctrl && (key.leftArrow || key.rightArrow || key.upArrow || key.downArrow));
+    const shiftHeld = key.shift || rawShiftUp || rawShiftDown || rawShiftLeft || rawShiftRight
+      || rawCtrlShiftUp || rawCtrlShiftDown || rawCtrlShiftLeft || rawCtrlShiftRight;
     const lineBreakIndex = rawInput.search(/[\r\n]/);
     const rawEnter = rawInput === '\r' || rawInput === '\n' || rawInput === '\r\n';
     const trailingEnterPrefix = singleTrailingLineBreakPrefix(rawInput);
@@ -566,25 +671,58 @@ export function PromptInput({
       return;
     }
 
-    if (key.upArrow || rawUpArrow || rawShiftUp) {
+    // Ctrl+Shift+Left/Right → extend selection whole-word. Kept before the plain
+    // shift-arrow branches so the ctrl+shift chord never falls through to a
+    // char-wise extend. (Up/Down ctrl+shift extend to line-relative vertical
+    // move with extend — same as shift alone; handled in the vertical branch.)
+    if (ctrlShiftHeld && (rawCtrlShiftLeft || (key.ctrl && key.shift && key.leftArrow))) {
+      if (!commandPaletteActive) {
+        updateDraft((d) => moveCursor(d, previousWordOffset(d.value, d.cursor), { extend: true }));
+      }
+      return;
+    }
+    if (ctrlShiftHeld && (rawCtrlShiftRight || (key.ctrl && key.shift && key.rightArrow))) {
+      if (!commandPaletteActive) {
+        updateDraft((d) => moveCursor(d, nextWordOffset(d.value, d.cursor), { extend: true }));
+      }
+      return;
+    }
+
+    if (key.upArrow || rawUpArrow || rawShiftUp || rawCtrlShiftUp) {
       if (commandPaletteActive) {
         onCommandPaletteNavigate?.(-1);
       } else {
-        const hasDraftText = String(draftRef.current.value || '').trim().length > 0;
-        if (!hasDraftText) {
-          if (!restoreQueuedToDraft()) applyHistoryNavigation('up', { emptyDraft: true });
-        } else if (!moveDraftVertically(-1, { extend: shiftHeld })) {
-          applyHistoryNavigation('up', { emptyDraft: false });
+        // A Shift-held Up is a SELECTION gesture, never history navigation:
+        // extend the selection up one visual line, and if already on the first
+        // line extend all the way to document start (offset 0). History
+        // navigation (restoreQueued / applyHistoryNavigation) MUST NOT fire.
+        if (shiftHeld) {
+          if (!moveDraftVertically(-1, { extend: true })) {
+            updateDraft((d) => moveCursor(d, 0, { extend: true }));
+          }
+        } else {
+          const hasDraftText = String(draftRef.current.value || '').trim().length > 0;
+          if (!hasDraftText) {
+            if (!restoreQueuedToDraft()) applyHistoryNavigation('up', { emptyDraft: true });
+          } else if (!moveDraftVertically(-1, { extend: false })) {
+            applyHistoryNavigation('up', { emptyDraft: false });
+          }
         }
       }
       return;
     }
 
-    if (key.downArrow || rawDownArrow || rawShiftDown) {
+    if (key.downArrow || rawDownArrow || rawShiftDown || rawCtrlShiftDown) {
       if (commandPaletteActive) {
         onCommandPaletteNavigate?.(1);
       } else {
-        if (!moveDraftVertically(1, { extend: shiftHeld })) {
+        // Shift-held Down: extend selection down one line, or to document end
+        // (value.length) when already on the last line. Never history nav.
+        if (shiftHeld) {
+          if (!moveDraftVertically(1, { extend: true })) {
+            updateDraft((d) => moveCursor(d, d.value.length, { extend: true }));
+          }
+        } else if (!moveDraftVertically(1, { extend: false })) {
           applyHistoryNavigation('down', { emptyDraft: String(draftRef.current.value || '').trim().length === 0 });
         }
       }
@@ -641,8 +779,8 @@ export function PromptInput({
         commitDraft({ value: '', cursor: 0, selectionAnchor: null });
         return;
       }
-      // Active turn takes precedence over queue restore (matches claude-code
-      // useCancelRequest priority): Esc during a running turn interrupts the
+      // Active turn takes precedence over queue restore: Esc during a
+      // running turn interrupts the
       // turn and leaves queued steering prompts intact to run afterward. Queued
       // messages only pop back into the draft when the turn is idle.
       if (interruptActive) {
@@ -702,6 +840,27 @@ export function PromptInput({
 
     const editingKey = String(input || '').toLowerCase();
 
+    // Undo / redo. Covered encodings:
+    //  • kitty protocol: ctrl+z → input 'z' + key.ctrl; ctrl+y → 'y' + key.ctrl;
+    //    ctrl+shift+z → 'z' + key.ctrl + key.shift (redo).
+    //  • legacy control bytes: Ctrl+Z is \x1a (SUB, 0x1A), Ctrl+Y is \x19 (EM,
+    //    0x19). ink may deliver these as raw input without key.ctrl on some
+    //    terminals, so match the byte directly too.
+    const isCtrlZ = (key.ctrl && editingKey === 'z') || rawInput === '\x1a';
+    const isCtrlY = (key.ctrl && editingKey === 'y') || rawInput === '\x19';
+    if (isCtrlZ && (key.shift || shiftHeld)) {
+      performRedo();
+      return;
+    }
+    if (isCtrlZ) {
+      performUndo();
+      return;
+    }
+    if (isCtrlY) {
+      performRedo();
+      return;
+    }
+
     // ctrl+a selects all like a normal text box; ctrl+e keeps readline line-end.
     if (key.ctrl && editingKey === 'a') {
       updateDraft((d) => (d.value ? { ...d, cursor: d.value.length, selectionAnchor: 0 } : clearSelection(d)));
@@ -834,6 +993,15 @@ export function PromptInput({
   const displayValue = mask ? value.replace(/[^\n]/g, '*') : value;
   const renderedValue = renderSelectedText(displayValue, selectionRange(draft), cursor === value.length);
   const hintMeta = hintStyle(hintTone);
+  // Monotone voice indicator glyph text — zero-width (rendered as null) when
+  // mode is 'off'. Braille frame drives installing/recording/transcribing;
+  // 'idle' is a static ○ (no animation, no timer).
+  const voiceIndicatorText = voiceIndicatorTextFor(voiceIndicatorMode, voiceTick);
+  // stringWidth is unnecessary here — every glyph above is a single
+  // 1-column codepoint (○ ● and the braille frames), and 'recording'
+  // concatenates exactly two 1-cell glyphs, so plain .length gives the
+  // correct cell count without pulling in emoji-width special-casing.
+  voiceIndicatorWidthRef.current = voiceIndicatorText.length;
 
   return (
     <Box ref={boxRef} flexDirection="row" width="100%" flexGrow={1} flexShrink={1} backgroundColor={surfaceBackground()}>
@@ -844,6 +1012,17 @@ export function PromptInput({
           <Text color={hintMeta.textColor}>{hint}</Text>
         </Box>
       ) : null}
+      {voiceIndicatorText ? (
+        <>
+          {/* flexGrow spacer pins the indicator to the RIGHT edge of the row
+              even when the typed text is short; without it the glyph would
+              ride directly after the caret instead of the box edge. */}
+          <Box flexGrow={1} backgroundColor={surfaceBackground()} />
+          <Box flexShrink={0} width={voiceIndicatorText.length + 1} justifyContent="flex-end" backgroundColor={surfaceBackground()}>
+            <Text color={theme.subtle}>{voiceIndicatorText}</Text>
+          </Box>
+        </>
+      ) : null}
     </Box>
   );
 }

package/src/tui/components/SlashCommandPalette.jsx

@@ -60,7 +60,11 @@ export function SlashCommandPalette({ commands, selectedIndex = 0, title = 'Comm
     start = Math.max(0, end - MAX_VISIBLE);
   }
   const visible = commands.slice(start, end);
-  const blankRows = Math.max(0, MAX_VISIBLE - visible.length);
+  // No-match frames keep the palette mounted at the SAME fixed height so the
+  // slash session never unmounts/remounts the 14-row panel per keystroke
+  // (Windows fullscreen repaint made that oscillation a hard flicker).
+  const noMatches = total === 0;
+  const blankRows = Math.max(0, MAX_VISIBLE - visible.length - (noMatches ? 1 : 0));
   const labelWidth = Math.max(12, Math.min(COMMAND_LABEL_WIDTH, Math.max(12, Math.floor(columns * 0.45))));
   const descriptionWidth = Math.max(0, columns - labelWidth - 12);
   // Standard panel rhythm: title row, blank, description/hint row, blank, content.
@@ -84,6 +88,9 @@ export function SlashCommandPalette({ commands, selectedIndex = 0, title = 'Comm
         <Text> </Text>
         <Text color={theme.subtle}>{description || ' '}</Text>
         <Text> </Text>
+        {noMatches ? (
+          <Text color={theme.subtle} wrap="truncate">No matching commands</Text>
+        ) : null}
         {visible.map((item, index) => (
           <CommandRow
             key={item.name}

package/src/tui/components/StatusLine.jsx

@@ -482,6 +482,29 @@ function StatusLineView({ sessionId, clientHostPid, provider, model, effort, fas
         Number(activeTools.search?.startedAt) || 0,
       ].join('|')
     : '';
+  // Stable primitive signatures so the render effect's dep array doesn't
+  // churn on new array/object identities carrying unchanged content — a new
+  // `agentWorkers`/`agentJobs` array (or `stats` object) reference on every
+  // render was clearing the pending 150ms debounce timer before it could
+  // fire, starving the boot full-render. Only tag|stage per worker/job and
+  // the numeric stats fields actually consumed here are covered.
+  const agentWorkersSignature = Array.isArray(agentWorkers)
+    ? agentWorkers.map((w) => `${w?.tag || w?.agent || w?.name || ''}|${w?.stage || w?.status || ''}|${localTimeMs(w?.startedAt || w?.startTime || w?.createdAt)}`).join(',')
+    : '';
+  const agentJobsSignature = Array.isArray(agentJobs)
+    ? agentJobs.map((j) => `${j?.tag || j?.agent || j?.name || ''}|${j?.status || j?.stage || ''}|${localTimeMs(j?.startedAt || j?.startTime || j?.createdAt)}`).join(',')
+    : '';
+  const statsForSignature = stats && typeof stats === 'object' ? stats : {};
+  const statsSignature = [
+    localNum(statsForSignature.currentContextTokens),
+    localNum(statsForSignature.currentEstimatedContextTokens),
+    localNum(statsForSignature.inputTokens),
+    localNum(statsForSignature.latestInputTokens),
+    localNum(statsForSignature.promptTokens),
+    localNum(statsForSignature.turns),
+    localNum(statsForSignature.contextTokens),
+    String(statsForSignature.currentContextSource || ''),
+  ].join('|');
   const refreshMs = hasActiveStatuslineWork(line, agentWorkers, agentJobs, activeTools) ? STATUSLINE_ACTIVE_REFRESH_MS : STATUSLINE_REFRESH_MS;
 
   useEffect(() => {
@@ -498,6 +521,7 @@ function StatusLineView({ sessionId, clientHostPid, provider, model, effort, fas
 
   useEffect(() => {
     let alive = true;
+    let bootRetryTimer = null;
     const effectId = renderEffectIdRef.current + 1;
     renderEffectIdRef.current = effectId;
     const isCurrentEffect = () => alive && renderEffectIdRef.current === effectId;
@@ -508,23 +532,27 @@ function StatusLineView({ sessionId, clientHostPid, provider, model, effort, fas
       lastImmediateArgsRef.current,
     );
     // ROUTE identity = the subset that actually changes the async full line's L1
-    // usage/quota segment (provider/model/session/effort/fast + context windows).
-    // agentRevision, compactBoundaryTokens, autoCompactTokenLimit and stats-reset
-    // are NON-ROUTE: they churn while several agents run but DON'T invalidate the
-    // L1 usage windows. Only a true route/session switch may wipe the cached full
-    // line and snap to the usage-less local line; non-route churn must keep the
-    // last good full line so `5H …/7D …` never blinks. (lastImmediateArgsRef holds
-    // exactly these route fields, captured at the end of the previous effect run.)
+    // usage/quota segment (provider/model/session/effort/fast). agentRevision,
+    // compactBoundaryTokens, autoCompactTokenLimit, stats-reset AND the context
+    // window fields (contextWindow/displayContextWindow/rawContextWindow) are
+    // NON-ROUTE: the first prompt's API response publishes displayContextWindow
+    // 0→N (engine syncContextDisplayFields), which only moves the ctx% bar —
+    // never the `5H …/7D …` usage windows. Treating it as route wiped the cached
+    // full line and snapped to the usage-less local line for one frame (the
+    // "usage blinks once on first prompt" bug). A real route switch that changes
+    // usage windows always changes provider/model/session anyway. Only a true
+    // route/session switch may wipe the cached full line; non-route churn keeps
+    // the last good full line (identityChanged still snaps, but via the cached
+    // graft path below, so usage survives and the async render refreshes ctx%
+    // within ~150ms). (lastImmediateArgsRef holds these fields, captured at the
+    // end of the previous effect run.)
     const prevImmediate = lastImmediateArgsRef.current;
     const routeChanged = !prevImmediate
       || prevImmediate.sessionId !== args.sessionId
       || prevImmediate.provider !== args.provider
       || prevImmediate.model !== args.model
       || prevImmediate.effort !== args.effort
-      || prevImmediate.fast !== args.fast
-      || prevImmediate.contextWindow !== args.contextWindow
-      || prevImmediate.displayContextWindow !== args.displayContextWindow
-      || prevImmediate.rawContextWindow !== args.rawContextWindow;
+      || prevImmediate.fast !== args.fast;
     // A theme switch must re-tone the footer immediately: the stored `line`
     // holds already-normalized ANSI with the OLD palette, so re-running
     // normalizeStatusLine on it is a no-op. Force a fresh local rebuild (new
@@ -607,9 +635,31 @@ function StatusLineView({ sessionId, clientHostPid, provider, model, effort, fas
     const timer = setTimeout(() => {
       if (bootFullDoneRef.current !== true) {
         if (!bootFullRenderEligible(mountAtRef.current, lineRef.current, args.agentWorkers, args.agentJobs, args.activeTools)) {
+          // Not eligible yet (boot delay not elapsed). Don't just bail and wait
+          // for the next refreshTick interval (250ms/2000ms) — arm a follow-up
+          // timeout for the REMAINING boot delay so the first full render still
+          // fires on schedule instead of stalling/flickering until the next tick.
+          const active = hasActiveStatuslineWork(lineRef.current, args.agentWorkers, args.agentJobs, args.activeTools);
+          const bootDelay = active ? STATUSLINE_BOOT_FULL_DELAY_ACTIVE_MS : STATUSLINE_BOOT_FULL_DELAY_MS;
+          const elapsed = Date.now() - mountAtRef.current;
+          const remaining = Math.max(150, bootDelay - elapsed);
+          bootRetryTimer = setTimeout(() => {
+            if (!isCurrentEffect()) return;
+            setRefreshTick((tick) => (tick + 1) % 1_000_000);
+          }, remaining);
+          bootRetryTimer.unref?.();
           return;
         }
         if (!canAttemptBootFullRender(bootFullNextAttemptAtRef.current)) {
+          // Backoff window not elapsed yet — arm a follow-up timeout for exactly
+          // the remaining backoff so the retry fires on time instead of waiting
+          // for the next refreshTick interval.
+          const remaining = Math.max(150, bootFullNextAttemptAtRef.current - Date.now());
+          bootRetryTimer = setTimeout(() => {
+            if (!isCurrentEffect()) return;
+            setRefreshTick((tick) => (tick + 1) % 1_000_000);
+          }, remaining);
+          bootRetryTimer.unref?.();
           return;
         }
       }
@@ -644,8 +694,9 @@ function StatusLineView({ sessionId, clientHostPid, provider, model, effort, fas
     return () => {
       alive = false;
       clearTimeout(timer);
+      clearTimeout(bootRetryTimer);
     };
-  }, [sessionId, clientHostPid, provider, model, effort, fast, cwd, stats, contextWindow, displayContextWindow, compactBoundaryTokens, autoCompactTokenLimit, rawContextWindow, resizeEpoch, agentRevision, agentWorkers, agentJobs, activeToolsSignature, refreshTick, themeEpoch]);
+  }, [sessionId, clientHostPid, provider, model, effort, fast, cwd, statsSignature, contextWindow, displayContextWindow, compactBoundaryTokens, autoCompactTokenLimit, rawContextWindow, resizeEpoch, agentRevision, agentWorkersSignature, agentJobsSignature, activeToolsSignature, refreshTick, themeEpoch]);
 
   const lines = line ? line.split('\n').slice(0, 2) : [' ', ' '];
   const workflowLabel = workflowModeLabel(workflow, remoteEnabled);

package/src/tui/components/TextEntryPanel.jsx

@@ -159,6 +159,7 @@ function isAnyModifiedEnterSequence(input) {
 export function TextEntryPanel({
   title,
   hint = '',
+  detail = '',
   initialValue = '',
   mask = false,
   columns = 80,
@@ -465,6 +466,10 @@ export function TextEntryPanel({
   // The hint is collapsed to one line and width-truncated so a long manual
   // OAuth URL can never wrap and push the bordered title off the top.
   const hintText = truncateText(singleLine(hint), Math.max(0, columns - 4));
+  // Optional wrapped detail block (e.g. the manual OAuth URL). Lives INSIDE the
+  // live panel — never pushed to the transcript — so it disappears completely
+  // when the panel closes instead of lingering in terminal scrollback.
+  const detailText = String(detail || '').trim();
 
   return (
     <Box flexDirection="column" flexShrink={0} width="100%">
@@ -475,6 +480,12 @@ export function TextEntryPanel({
         </Box>
         <Text> </Text>
         <Text color={theme.subtle}>{hintText || ' '}</Text>
+        {detailText ? (
+          <Box flexDirection="column" width="100%">
+            <Text> </Text>
+            <Text color={theme.subtle} wrap="wrap">{detailText}</Text>
+          </Box>
+        ) : null}
         <Text> </Text>
         <Box ref={boxRef} flexDirection="row" width="100%" backgroundColor={surfaceBackground()}>
           <Text color={theme.inactive}>{promptLabel}</Text>