mixdog 0.9.18 → 0.9.19

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