mixdog 0.9.18 → 0.9.20

package/src/tui/app/use-prompt-handlers.mjs

@@ -2,12 +2,12 @@
  * use-prompt-handlers.mjs — the PROMPT HANDLER cluster extracted from App.jsx
  * (pass-7 split).
  *
- * Exports usePromptHandlers(), which owns the five useCallback handlers wired to
- * PromptInput: handleVoiceToggle / handlePromptPaste / handlePromptHistoryNavigate
- * / handlePromptEscape / handlePromptInterrupt. Every ref, setter, store value and
- * derived value the handlers close over is threaded in explicitly so the deps
- * arrays stay byte-identical to the original inline hooks. Import-level helpers
- * (voice recorder + paste attachments) are imported directly here.
+ * Exports usePromptHandlers(), which owns the four useCallback handlers wired to
+ * PromptInput: handlePromptPaste / handlePromptHistoryNavigate / handlePromptEscape
+ * / handlePromptInterrupt. Every ref, setter, store value and derived value the
+ * handlers close over is threaded in explicitly so the deps arrays stay
+ * byte-identical to the original inline hooks. Import-level helpers (paste
+ * attachments) are imported directly here.
  */
 import { useCallback } from 'react';
 import {
@@ -18,13 +18,6 @@ import {
 import {
   shouldFoldPastedText,
 } from '../paste-attachments.mjs';
-import {
-  isVoiceEnabled,
-  getRecorderState,
-  startRecording,
-  stopRecording,
-  cancelRecording,
-} from '../lib/voice-recorder.mjs';
 import { promptHistoryKey } from '../prompt-history-store.mjs';
 
 export function usePromptHandlers({
@@ -42,10 +35,8 @@ export function usePromptHandlers({
   setPastedImages,
   setPastedTexts,
   setPromptDraftOverride,
-  setVoiceRecPhase,
   setContextPanel,
   // derived / helper values + callbacks
-  setVoiceStatusHint,
   syncPromptLayoutRows,
   showPromptHint,
   clearPromptHint,
@@ -63,70 +54,6 @@ export function usePromptHandlers({
   clearPastedTextsSnapshot,
   registerPastedText,
 }) {
-  // Ctrl+Space handler wired to PromptInput's onVoiceToggle. Dispatches on the
-  // recorder's CURRENT state (idle/recording/transcribing) — see
-  // src/tui/lib/voice-recorder.mjs for the state machine itself.
-  const handleVoiceToggle = useCallback(async () => {
-    if (!isVoiceEnabled()) {
-      store.pushNotice('Voice is off — run /voice to turn it on', 'warn');
-      return;
-    }
-    const recState = getRecorderState();
-    if (recState === 'transcribing') {
-      store.pushNotice('Voice: already transcribing…', 'info');
-      return;
-    }
-    if (recState === 'recording') {
-      setVoiceStatusHint('… transcribing', 'info');
-      setVoiceRecPhase('transcribing');
-      let result;
-      try {
-        result = await stopRecording();
-      } catch (e) {
-        result = { ok: false, reason: e?.message || String(e) };
-      }
-      setVoiceStatusHint('', 'info');
-      setVoiceRecPhase('idle');
-      if (!result) return; // race: recorder was no longer RECORDING
-      if (!result.ok) {
-        store.pushNotice(`Voice: ${result.reason || 'transcription failed'}`, 'error');
-        return;
-      }
-      const text = String(result.text || '').trim();
-      if (!text) {
-        store.pushNotice('Voice: no speech detected', 'warn');
-        return;
-      }
-      // End-of-draft insertion via promptDraftOverride (approved design —
-      // no cursor-position insert; see gamerscroll skill's out-of-scope note
-      // on PromptInput's imperative surface).
-      // Med-4: promptValueRef.current is read HERE — after `await
-      // stopRecording()` has already resolved — not captured earlier before
-      // the await. PromptInput keeps valueRef.current live on every
-      // keystroke (commitDraft), so this always reflects whatever the user
-      // typed during the recording+transcribe window; nothing typed in that
-      // gap is overwritten.
-      const current = promptValueRef.current || '';
-      const next = current ? `${current}${/\s$/.test(current) ? '' : ' '}${text}` : text;
-      syncPromptLayoutRows(next);
-      setPromptDraftOverride({ id: Date.now(), value: next });
-      return;
-    }
-    // idle -> recording
-    let result;
-    try {
-      result = await startRecording();
-    } catch (e) {
-      result = { ok: false, reason: e?.message || String(e) };
-    }
-    if (!result?.ok) {
-      store.pushNotice(`Voice: ${result?.reason || 'failed to start recording'}`, 'error');
-      return;
-    }
-    setVoiceStatusHint('● REC', 'error');
-    setVoiceRecPhase('recording');
-  }, [store, setVoiceStatusHint, syncPromptLayoutRows]);
-
   const handlePromptPaste = useCallback((text, meta = {}) => {
     const source = String(meta?.source || 'paste');
     const value = String(text ?? '');
@@ -256,19 +183,6 @@ export function usePromptHandlers({
   //   the active turn on the same Esc press.
   // - empty prompt + active turn interrupts the active turn.
   const handlePromptEscape = useCallback((text = '', meta = {}) => {
-    // Recording takes priority over every other Esc branch (usage/context
-    // panels, slash-clear, queue-restore, turn-interrupt): a live mic capture
-    // must never silently keep running because Esc was consumed by something
-    // else first. Only consumes Esc while actually RECORDING — transcribing
-    // (already stopped, awaiting the HTTP round-trip) and idle fall through
-    // to the existing branches unchanged.
-    if (getRecorderState() === 'recording') {
-      cancelRecording();
-      setVoiceStatusHint('', 'info');
-      setVoiceRecPhase('idle');
-      store.pushNotice('Voice: recording cancelled', 'plain');
-      return true;
-    }
     if (usagePanel) { closeUsagePanel(); return true; }
     if (contextPanel) { setContextPanel(null); return true; }
 
@@ -283,7 +197,7 @@ export function usePromptHandlers({
     // Idle + empty + nothing to restore: nothing (double-press from empty
     // opens message selector, but we don't have that feature yet).
     return false;
-  }, [contextPanel, usagePanel, closeUsagePanel, restoreQueuedToPrompt, clearPromptHint, clearPastedImagesSnapshot, setVoiceStatusHint, store]);
+  }, [contextPanel, usagePanel, closeUsagePanel, restoreQueuedToPrompt, clearPromptHint, clearPastedImagesSnapshot, store]);
 
   const handlePromptInterrupt = useCallback((currentText = '') => {
     const result = store.abort?.();
@@ -301,7 +215,6 @@ export function usePromptHandlers({
   }, [store, clearPromptHint, installPastedImages, clearPastedImagesSnapshot]);
 
   return {
-    handleVoiceToggle,
     handlePromptPaste,
     handlePromptHistoryNavigate,
     handlePromptEscape,

package/src/tui/app/use-transcript-scroll.mjs

@@ -44,6 +44,71 @@ export function useTranscriptScroll({
   // SCROLL_COALESCE_MS). Both call sites accumulate into pendingRows.
   const scrollCoalesceRef = useRef({ pendingRows: 0, timer: null });
   const selectionTextTimerRef = useRef(null);
+  // Stitch buffer: accumulates harvested transcript selection rows across scroll
+  // positions so Ctrl+C copies the FULL drag even after it auto-scrolled past the
+  // viewport. Keyed by scroll-invariant content row = screenY - scrollTarget at
+  // harvest time; value = row text. Only transcript-region drags accumulate.
+  const stitchBufferRef = useRef(new Map());
+  const stitchHarvestTimerRef = useRef(null);
+  // Scroll offset captured at the SCHEDULE (paint) time of the pending harvest —
+  // the deferred timer must key rows by the frame's scroll, not by whatever
+  // scrollTargetRef holds when the timer eventually fires (a scroll in between
+  // would mis-key the rows). Latest schedule wins (latest paint = latest frame).
+  const stitchHarvestScrollRef = useRef(0);
+
+  const clearStitchBuffer = useCallback(() => {
+    stitchBufferRef.current.clear();
+    if (stitchHarvestTimerRef.current) {
+      clearTimeout(stitchHarvestTimerRef.current);
+      stitchHarvestTimerRef.current = null;
+    }
+  }, []);
+
+  // Deferred (like rememberSelectionTextSoon) harvest of the currently visible
+  // selection rows into the stitch buffer. Runs on EVERY transcript selection
+  // paint AND on scroll-shift repaints (the rememberText:false path) so rows
+  // revealed only mid-scroll are captured. Later harvest of a key overwrites,
+  // handling partial↔full endpoint rows on retraction.
+  const harvestStitchRowsSoon = useCallback(() => {
+    if (dragRef.current.region !== 'transcript') return;
+    // Capture the scroll offset for THIS paint (schedule time). If a timer is
+    // already pending, only refresh the captured offset to the latest frame and
+    // reuse the existing timer.
+    stitchHarvestScrollRef.current = Number(scrollTargetRef.current) || 0;
+    if (stitchHarvestTimerRef.current) return;
+    stitchHarvestTimerRef.current = setTimeout(() => {
+      stitchHarvestTimerRef.current = null;
+      if (dragRef.current.region !== 'transcript') return;
+      const rows = store.getRenderSelectionRows?.();
+      if (!Array.isArray(rows)) return;
+      const scroll = stitchHarvestScrollRef.current;
+      for (const row of rows) {
+        if (!row || typeof row.y !== 'number') continue;
+        stitchBufferRef.current.set(row.y - scroll, typeof row.text === 'string' ? row.text : '');
+      }
+    }, 0);
+  }, [store]);
+
+  // Map the CURRENT rect + current scrollTarget onto the content-key range and
+  // join buffered rows sorted by key with '\n' (skipping missing keys). Returns
+  // '' when unusable so callers can fall back to render/remembered text.
+  const getStitchedSelectionText = useCallback(() => {
+    const buf = stitchBufferRef.current;
+    if (!buf.size) return '';
+    if (dragRef.current.region !== 'transcript') return '';
+    const rect = dragRef.current.rect;
+    if (!rect) return '';
+    const y1 = Number(rect.y1);
+    const y2 = Number(rect.y2);
+    if (!Number.isFinite(y1) || !Number.isFinite(y2)) return '';
+    const scroll = Number(scrollTargetRef.current) || 0;
+    const lo = Math.min(y1, y2) - scroll;
+    const hi = Math.max(y1, y2) - scroll;
+    const keys = [...buf.keys()].filter((k) => k >= lo && k <= hi).sort((a, b) => a - b);
+    if (!keys.length) return '';
+    const text = keys.map((k) => buf.get(k)).filter((t) => t != null).join('\n');
+    return text.trim() ? text : '';
+  }, []);
 
   const stopSmoothScroll = useCallback(() => {
     if (!scrollAnimationRef.current) return;
@@ -145,19 +210,24 @@ export function useTranscriptScroll({
         store.setRenderSelection?.(nextRect, { immediate: true });
       }
       if (needsCapture) rememberSelectionTextSoon();
+      if (nextRect) harvestStitchRowsSoon();
       return true;
     }
     state.rect = nextRect;
     state.t = Date.now();
     store.setRenderSelection?.(nextRect, immediate ? { immediate: true } : undefined);
     if (nextRect && rememberText && nextRect.captureText !== false) rememberSelectionTextSoon();
+    if (nextRect) harvestStitchRowsSoon();
     return true;
-  }, [store, rememberSelectionTextSoon]);
+  }, [store, rememberSelectionTextSoon, harvestStitchRowsSoon]);
 
   const applySelectionRect = useCallback((rect) => {
     const clippedRect = withSelectionClip(rect);
     dragRef.current.rect = clippedRect || null;
-    if (!clippedRect) selectionTextRef.current = '';
+    if (!clippedRect) {
+      selectionTextRef.current = '';
+      clearStitchBuffer();
+    }
     const state = selectionPaintRef.current;
     if (state.timer) {
       clearTimeout(state.timer);
@@ -165,7 +235,7 @@ export function useTranscriptScroll({
       state.pending = null;
     }
     paintSelectionRect(clippedRect, { rememberText: true, immediate: true });
-  }, [paintSelectionRect, withSelectionClip]);
+  }, [paintSelectionRect, withSelectionClip, clearStitchBuffer]);
 
   const applySelectionRectThrottled = useCallback((rect) => {
     const clippedRect = withSelectionClip(rect, { captureText: false });
@@ -274,6 +344,8 @@ export function useTranscriptScroll({
     paintState.pending = null;
     if (selectionTextTimerRef.current) clearTimeout(selectionTextTimerRef.current);
     selectionTextTimerRef.current = null;
+    if (stitchHarvestTimerRef.current) clearTimeout(stitchHarvestTimerRef.current);
+    stitchHarvestTimerRef.current = null;
     const coalesceState = scrollCoalesceRef.current;
     if (coalesceState.timer) clearTimeout(coalesceState.timer);
     coalesceState.timer = null;
@@ -341,7 +413,11 @@ export function useTranscriptScroll({
       }
       const clippedRect = withSelectionClip(rect);
       dragRef.current = { ...dragRef.current, rect: clippedRect };
-      paintSelectionRect(clippedRect, { rememberText: !dragRef.current.active });
+      // Never re-harvest selection text from a scroll-shifted rect: the shift
+      // clips the rect to the viewport, so a harvest here would OVERWRITE the
+      // full text remembered at drag-release with only the still-visible rows
+      // (Ctrl+C after scrolling then copied just that fragment).
+      paintSelectionRect(clippedRect, { rememberText: false });
     }
     if (options.smooth) {
       startSmoothScroll();
@@ -508,5 +584,7 @@ export function useTranscriptScroll({
     scrollTranscriptRows,
     queueScrollCoalesced,
     moveSelectionFocus,
+    getStitchedSelectionText,
+    clearStitchBuffer,
   };
 }

package/src/tui/app/use-transcript-window.mjs

@@ -22,6 +22,9 @@ import {
   setStreamingBottomPinned,
   transcriptRenderWindow,
   resolveAnchorScrollOffset,
+  streamingTailMountedGrowth,
+  streamingEstimateRows,
+  TRANSCRIPT_WINDOW_OVERSCAN_ROWS,
   upperBound,
   shiftSelectionRectY,
 } from './transcript-window.mjs';
@@ -347,6 +350,37 @@ export function useTranscriptWindow({
     contentHeight: lockViewRows,
     floatingPanelRows: Number(floatingPanelRows) || 0,
   };
+  // ── Same-frame streaming-tail growth compensation (scrolled-up only) ───────
+  // When the user reads older transcript, the row index freezes the trailing
+  // streaming item at its last Yoga-confirmed height (defer-growth), but the
+  // mounted Box lays out at the live-grown height THIS frame. renderScrollOffset
+  // was just resolved against that frozen row index, so the extra physical rows
+  // are unaccounted-for and the visible window jumps up one frame until the
+  // harvest bumps measuredRowsVersion. Fold the mounted growth delta into the
+  // offset NOW so marginBottom slides those extra rows off the bottom and the
+  // window holds still. Bottom-pinned/following is stable (flex-end owns it) and
+  // is excluded by the scrolledUp gate. No double-compensation next frame: once
+  // measuredRowsVersion bumps, the row index absorbs the growth (idEntry.rows ==
+  // the new measured height) and the live estimate matches it, so delta → 0.
+  if (scrolledUp && !followingRef.current) {
+    const growth = streamingTailMountedGrowth(items, frameColumns, toolOutputExpanded);
+    // Only compensate when the tail is actually mounted in the rendered slice
+    // (viewport + overscan). Off-slice it is represented by a row-index-sized
+    // bottom spacer that does NOT physically grow this frame, so shifting the
+    // offset there would itself introduce a jump. In-slice its Box grows now.
+    // Gate/clamp on the POST-compensation offset: transcriptRenderWindow drops
+    // the tail once effectiveScrollOffset >= tailRows + overscan, so adding the
+    // full delta could push the offset past that edge and unmount the very row
+    // we are compensating for (a reverse jump at the boundary). Cap the applied
+    // delta so the final offset keeps the tail mounted; any residual growth left
+    // uncompensated sits in the overscan below the viewport (not visible).
+    if (growth && growth.delta > 0) {
+      const maxOffsetKeepingTailMounted = growth.tailRows + TRANSCRIPT_WINDOW_OVERSCAN_ROWS - 1;
+      if (renderScrollOffset <= maxOffsetKeepingTailMounted) {
+        renderScrollOffset += Math.min(growth.delta, maxOffsetKeepingTailMounted - renderScrollOffset);
+      }
+    }
+  }
   const transcriptWindow = useMemo(() => transcriptRenderWindow(items, {
     scrollOffset: renderScrollOffset,
     viewportHeight: transcriptContentHeight,
@@ -367,8 +401,11 @@ export function useTranscriptWindow({
     // CAPTURE for a missing/dirty anchor (above) reads this from the PREVIOUS
     // frame to reconstruct the exact top-edge row that was on screen, so the
     // capture matches what the user saw rather than the stale scrollOffset
-    // state. Bottom-relative, matching transcriptRenderWindow's window math.
-    renderOffset: Math.max(0, Number(renderScrollOffset) || 0),
+    // state. Publish the CLAMPED effective offset (transcriptRenderWindow clamps
+    // renderScrollOffset to maxScrollRows internally) so the reconstruction uses
+    // the value the window math actually rendered with, not the raw compensated
+    // offset. Bottom-relative, matching transcriptRenderWindow's window math.
+    renderOffset: Math.max(0, Number(transcriptWindow.effectiveScrollOffset) || 0),
     suppressMeasuredRowHeights,
   };
   // The window memo is keyed on a structure signature that intentionally
@@ -456,8 +493,24 @@ export function useTranscriptWindow({
       const variantKey = transcriptItemVariantKey(item);
       if (isStreamingAssistant) {
         const idPrev = streamingMeasuredRowsById.get(item.id);
+        // Baseline = the estimate for the text at THIS commit's measured state.
+        // Refresh it on EVERY harvest pass (not only on an id-store change): if
+        // the estimator's row count drifts while the Yoga height is unchanged
+        // (or a same-id text reset), a stale baseline would make
+        // streamingTailMountedGrowth compensate with no physical growth.
+        const estimateAtMeasure = streamingEstimateRows(item, frameColumns, toolOutputExpanded);
         if (!idPrev || idPrev.rows !== measured || idPrev.columns !== frameColumns || idPrev.toolExpanded !== toolExpandedFlag) {
-          streamingMeasuredRowsById.set(item.id, { rows: measured, columns: frameColumns, toolExpanded: toolExpandedFlag });
+          // Record the estimate for the EXACT text just measured alongside the
+          // real Yoga height, so streamingTailMountedGrowth can measure later
+          // growth in the estimate metric (live_now − estimateAtMeasure) and the
+          // estimator's steady bias cancels instead of leaking into a permanent
+          // over-compensation once measuredRowsVersion has absorbed this height.
+          streamingMeasuredRowsById.set(item.id, {
+            rows: measured,
+            columns: frameColumns,
+            toolExpanded: toolExpandedFlag,
+            estimateRows: estimateAtMeasure,
+          });
           // ALWAYS bump on a real id-store change, bottom-pinned or not.
           // estimateTranscriptItemRowsCached (transcript-window.mjs) now
           // returns ONLY this id-store floor for a streaming item (defer-
@@ -470,6 +523,8 @@ export function useTranscriptWindow({
           // stream settles — invisible growth for anything reading rowIndex
           // (windowing, maxScrollRows, an anchor captured mid-stream).
           changed = true;
+        } else {
+          idPrev.estimateRows = estimateAtMeasure;
         }
       }
       const prev = transcriptMeasuredRowsCache.get(item);
@@ -662,13 +717,18 @@ export function useTranscriptWindow({
     if (deltaY === 0) return;
     const clippedRect = withSelectionClip(shiftSelectionRectY(dragRef.current.rect, deltaY));
     dragRef.current = { ...dragRef.current, rect: clippedRect };
-    paintSelectionRect(clippedRect, { rememberText: true, immediate: true });
+    // rememberText:false — the shifted rect is viewport-clipped, so harvesting
+    // here would replace the full selection text remembered at drag-release
+    // with only the still-visible fragment (partial Ctrl+C after scrolling).
+    paintSelectionRect(clippedRect, { rememberText: false, immediate: true });
   }, [transcriptContentHeight, transcriptWindow.totalRows, transcriptWindow.effectiveScrollOffset, withSelectionClip, paintSelectionRect]);
   useEffect(() => {
     if (!dragRef.current.rect) return;
     const clippedRect = withSelectionClip(dragRef.current.rect);
     dragRef.current = { ...dragRef.current, rect: clippedRect };
-    paintSelectionRect(clippedRect, { rememberText: true, immediate: true });
+    // Theme repaint: same cells, same text — no need to re-harvest (and a
+    // clipped rect would clobber the remembered full text with a fragment).
+    paintSelectionRect(clippedRect, { rememberText: false, immediate: true });
   }, [themeEpoch, withSelectionClip, paintSelectionRect]);
   useEffect(() => {
     const maxRows = Math.max(0, Number(transcriptWindow.maxScrollRows) || 0);

package/src/tui/components/PromptInput.jsx

@@ -49,10 +49,6 @@ import {
   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
@@ -100,8 +96,6 @@ export function PromptInput({
   onRestoreQueued,
   onHistoryNavigate,
   onPasteText,
-  onVoiceToggle,
-  voiceIndicatorMode = 'off',
   selectionRef,
   valueRef,
   boxRectRef,
@@ -129,27 +123,8 @@ 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
@@ -171,6 +146,7 @@ export function PromptInput({
   // the parent chain from our box and firing it flushes the new draft in the same
   // tick. Guarded so a structure change in the ink fork degrades to throttled
   // (slower) rendering, never a crash.
+  const flushThrottleRef = useRef({ lastAt: 0, timer: null });
   const flushImmediate = () => {
     let node = boxRef.current;
     for (let i = 0; node && i < 64; i++) {
@@ -182,6 +158,30 @@ export function PromptInput({
     }
   };
 
+  // commitDraft fires on every keystroke; a raw queueMicrotask(flushImmediate)
+  // per commit bypassed ink's maxFps and forced an unthrottled render for each
+  // char (a burst of paste/held-key edits = a render storm). Coalesce to a
+  // frame budget: flush the first keystroke immediately (no caret lag) and
+  // batch the rest to one flush per ~16ms, with a trailing flush so the final
+  // char of a burst always lands.
+  const FLUSH_INTERVAL_MS = 16;
+  const scheduleImmediateFlush = () => {
+    const t = flushThrottleRef.current;
+    const now = Date.now();
+    const elapsed = now - t.lastAt;
+    if (elapsed >= FLUSH_INTERVAL_MS) {
+      if (t.timer !== null) { clearTimeout(t.timer); t.timer = null; }
+      t.lastAt = now;
+      queueMicrotask(flushImmediate);
+    } else if (t.timer === null) {
+      t.timer = setTimeout(() => {
+        t.timer = null;
+        t.lastAt = Date.now();
+        flushImmediate();
+      }, FLUSH_INTERVAL_MS - elapsed);
+    }
+  };
+
   const commitDraft = (next, options = {}) => {
     const sameDraft = draftStateEqual(draftRef.current, next);
     if (!options.keepPreferredColumn) preferredColumnRef.current = null;
@@ -189,7 +189,7 @@ export function PromptInput({
     if (!options.skipHistory) recordUndoSnapshot(draftRef.current, next, options);
     draftRef.current = next;
     setDraft(next);
-    queueMicrotask(flushImmediate);
+    scheduleImmediateFlush();
     if (next.value !== lastReportedValueRef.current) {
       lastReportedValueRef.current = next.value;
       onDraftChange?.(next.value);
@@ -231,12 +231,7 @@ export function PromptInput({
       const d = draftRef.current;
       const w = yogaNode?.getComputedWidth?.() ?? 0;
       const guardColumns = w > IME_LEFT_GUARD_COLUMNS ? IME_LEFT_GUARD_COLUMNS : 0;
-      // 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);
+      const contentWidth = Math.max(1, (w ? w - guardColumns : contentWidthRef.current) || 80);
       contentWidthRef.current = contentWidth;
       const caret = w > 0
         // PromptInput renders a trailing space cell when the cursor is at
@@ -962,21 +957,15 @@ export function PromptInput({
       return;
     }
 
-    // Ctrl+Space voice-record toggle. Two encodings observed across
-    // terminals: a lone NUL byte (legacy Ctrl+Space, many terminals send
-    // 0x00 directly) or the kitty CSI-u form `\x1b[32;5u` (codepoint 32
-    // = space, modifier 5 = 1+4 = ctrl). Consumed here — never typed into
-    // the prompt — and forwarded to the App-level recorder state machine
-    // via onVoiceToggle; a no-op when the prop isn't wired (e.g. embedded
-    // pickers) so this never throws.
-    if (rawInput === '\x00' || /^(?:\x1b)?\[32;5u$/.test(rawInput)) {
-      onVoiceToggle?.();
-      return;
-    }
-
     // Printable input (ignore other control keys). Strip any embedded SGR mouse
     // sequences as a belt-and-suspenders guard (the early return above catches
     // whole-sequence inputs; this removes partials that rode in with real text).
+    // Swallow Ctrl+Space raw encodings (lone NUL, or the kitty CSI-u form
+    // \x1b[32;5u) as a no-op so they never fall through into the prompt as
+    // garbage. No voice behavior — just discarded.
+    if (rawInput === '\x00' || /^(?:\x1b)?\[32;5u$/.test(rawInput)) {
+      return;
+    }
     const printable = rawInput
       .replace(/(?:\x1b)?\[<\d+;\d+;\d+[Mm]/g, '')
       .replace(/[\r\n]/g, '');
@@ -1019,15 +1008,6 @@ 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()}>
@@ -1038,17 +1018,6 @@ 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/ToolExecution.jsx

@@ -254,7 +254,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
     // Keep the aggregate card at a fixed height (header + one detail row) for
     // its whole lifecycle. Pending cards have no result yet, so reserve the
     // detail row up front instead of growing from 1→2 rows when the summary
-    // lands on completion — that late row push is the "줄 튐" jump. The empty
+    // lands on completion — that late row push is the "line-jump" jump. The empty
     // placeholder renders as a blank line under the ⎿ gutter; the final summary
     // simply fills it in place. This matches estimateTranscriptItemRows (always
     // 2 + resultRows), so windowing/scroll stay in lockstep too.
@@ -381,7 +381,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   // (collapsedDetail = ''), so the card rendered as a single header row. But
   // estimateTranscriptItemRows() in App.jsx reserves 2 rows for a collapsed
   // non-aggregate tool (1 only for skill surfaces). That left a 1-row gap that
-  // closed the instant the result landed — the surviving "튐". Reserve the same
+    // closed the instant the result landed — the surviving "line-jump". Reserve the same
   // dim placeholder detail row the aggregate card uses (`Running`) for the whole
   // pending lifecycle so the height stays fixed at header + one detail row and
   // the final summary just fills in place. Skill surfaces collapse to a single