mixdog 0.9.95 → 0.9.97

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

@@ -69,6 +69,22 @@ export const SELECTION_PAINT_INTERVAL_MS = positiveIntEnv('MIXDOG_TUI_SELECTION_
 export const SCROLL_COALESCE_MS = positiveIntEnv('MIXDOG_TUI_SCROLL_COALESCE_MS', 16);
 export const PROMPT_HISTORY_LIMIT = 50;
 
+// Accumulate same-direction wheel/edge-drag deltas, but never retain movement
+// from the opposite direction. Without this reset a quick wheel reversal could
+// apply an older queued delta one frame later and visibly roll the transcript
+// back against the user's latest gesture. Returns true when the direction
+// changed so the caller can cancel its old coalescing timer and flush now.
+export function accumulateDirectionalScrollDelta(state, deltaRows) {
+  const delta = Number(deltaRows) || 0;
+  if (!delta) return false;
+  const direction = Math.sign(delta);
+  const reversed = Boolean(state.direction && state.direction !== direction);
+  if (reversed) state.pendingRows = 0;
+  state.direction = direction;
+  state.pendingRows += delta;
+  return reversed;
+}
+
 // Parse a boolean env var that DEFAULTS ON. Any of 0/false/off/no (case-
 // insensitive, trimmed) disables it; everything else (including unset) leaves it
 // on. Used as the kill switch for the app-level measured-height feature below.
@@ -647,6 +663,28 @@ export function transcriptRowAt(values, index) {
     : (Number(values[index]) || 0);
 }
 
+/** True when a transcript items swap destroyed the reader's position and the
+ *  viewport must return to the live tail with follow re-armed.
+ *
+ *  A bulk swap (session load/clear, mid-turn COMPACTION) drops the history the
+ *  reader was anchored to. Compaction pushes its status row in the SAME commit
+ *  that trims the head, so the item count can stay level or even grow: a
+ *  count-drop test alone left auto-scroll released with an anchor lock on a
+ *  deleted row, and every new row piled up below the fold for the rest of the
+ *  session (user: 컴팩션된 이후로 자동 스크롤이 풀린다). Live appends never
+ *  touch index 0, so a changed HEAD id is the bulk-swap signal. */
+export function transcriptSwapReturnsToTail({
+  count = 0,
+  previousCount = 0,
+  firstId = null,
+  previousFirstId = null,
+} = {}) {
+  if (previousCount === 0) return true;
+  if (count < previousCount) return true;
+  if (count === 0) return false;
+  return firstId != null && previousFirstId != null && firstId !== previousFirstId;
+}
+
 function appendTranscriptRow(prefix, tailValue) {
   return Object.freeze({
     length: prefix.length + 1,

package/src/tui/app/use-prompt-draft-flow.mjs

@@ -146,13 +146,11 @@ export function usePromptDraftFlow({
   }, [slashCommands, slashIndex]);
 
   const cancelSlashPalette = useCallback((value = '') => {
-    // Esc clears the slash draft, so the dismissal marker must not survive.
-    // If it stays as "/" then typing "/" again is treated as the same
-    // dismissed query and the palette never re-opens.
-    setSlashDismissedFor('');
-    setPromptDraft('');
-    setPromptDraftOverride({ id: Date.now(), value: '' });
-  }, []);
+    // Claude Code's autocomplete:dismiss closes suggestions without changing
+    // the draft. Remember this exact value so the palette does not immediately
+    // reopen; the next edit clears the marker in onPromptDraftChange.
+    setSlashDismissedFor(String(value ?? ''));
+  }, [setSlashDismissedFor]);
 
   return {
     onPromptDraftChange,

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

@@ -9,7 +9,7 @@
  * byte-identical to the original inline hooks. Import-level helpers (paste
  * attachments) are imported directly here.
  */
-import { useCallback } from 'react';
+import { useCallback, useEffect, useRef } from 'react';
 import {
   readClipboardImageAttachment,
   readClipboardText,
@@ -20,6 +20,8 @@ import {
   shouldFoldPastedText,
 } from '../paste-attachments.mjs';
 import { promptHistoryKey } from '../prompt-history-store.mjs';
+import { promptInterruptRestoreText } from '../components/prompt-input/interrupt-policy.mjs';
+import { PROMPT_ESCAPE_CLEAR_WINDOW_MS } from '../components/prompt-input/escape-policy.mjs';
 
 export function usePromptHandlers({
   store,
@@ -44,6 +46,7 @@ export function usePromptHandlers({
   recentPromptHistory,
   resetPromptHistoryNav,
   restoreQueuedToPrompt,
+  openMessageSelector,
   usagePanel,
   closeUsagePanel,
   contextPanel,
@@ -55,6 +58,8 @@ export function usePromptHandlers({
   clearPastedTextsSnapshot,
   registerPastedText,
 }) {
+  const interruptGenerationRef = useRef(0);
+  const pendingInterruptRestoreRef = useRef(null);
   const handlePromptPaste = useCallback((text, meta = {}) => {
     const source = String(meta?.source || 'paste');
     const value = String(text ?? '');
@@ -197,41 +202,101 @@ export function usePromptHandlers({
 
   // ESC / Up handling (prompt input):
   // - prompt-local overlays such as the slash palette close first.
-  // - queued editable messages pop back into the prompt before clear/interrupt.
-  // - non-empty prompt text is cleared by PromptInput and must never interrupt
-  //   the active turn on the same Esc press.
-  // - empty prompt + active turn interrupts the active turn.
+  // - active work is cancelled before queue/draft handling.
+  // - idle non-empty text uses Claude Code's "Esc again to clear" guard.
+  // - idle empty input restores queued editable messages, and a double press
+  //   opens the message selector (jump back to a previous prompt).
   const handlePromptEscape = useCallback((text = '', meta = {}) => {
     if (usagePanel) { closeUsagePanel(); return true; }
     if (contextPanel) { setContextPanel(null); return true; }
 
+    if (meta.phase === 'clear-arm') {
+      showPromptHint('Esc again to clear', 'plain', PROMPT_ESCAPE_CLEAR_WINDOW_MS);
+      return true;
+    }
+    if (meta.phase === 'select-arm') {
+      showPromptHint('Esc again to pick a message', 'plain', PROMPT_ESCAPE_CLEAR_WINDOW_MS);
+      return true;
+    }
+    if (meta.phase === 'select') {
+      clearPromptHint();
+      // Queue first (Claude Code order): a stale queue projection must not let
+      // the selector shadow an editable follow-up that is still waiting.
+      if (restoreQueuedToPrompt({ restoreDraft: true, showHint: false, currentText: text })) return true;
+      return openMessageSelector?.() === true;
+    }
     if (meta.phase === 'clear') {
+      try {
+        const remembered = store.rememberPromptHistory?.(text);
+        if (remembered?.catch) void remembered.catch(() => {});
+      } catch { /* best-effort history parity */ }
       clearPastedImagesSnapshot();
+      clearPastedTextsSnapshot();
       clearPromptHint();
       return false;
     }
     if (meta.phase === 'empty') {
       return restoreQueuedToPrompt({ restoreDraft: true, showHint: false, currentText: text });
     }
-    // Idle + empty + nothing to restore: nothing (double-press from empty
-    // opens message selector, but we don't have that feature yet).
+    // Idle + empty + no transcript to jump back into: nothing to do.
     return false;
-  }, [contextPanel, usagePanel, closeUsagePanel, restoreQueuedToPrompt, clearPromptHint, clearPastedImagesSnapshot, store]);
+  }, [contextPanel, usagePanel, closeUsagePanel, restoreQueuedToPrompt, openMessageSelector, showPromptHint, clearPromptHint, clearPastedImagesSnapshot, clearPastedTextsSnapshot, store]);
 
-  const handlePromptInterrupt = useCallback((currentText = '') => {
-    const result = store.abort?.();
-    if (result?.aborted === false) return undefined;
-    if (result?.pastedImages) installPastedImages(result.pastedImages, { merge: true });
-    if (result?.discardPastedImages) clearPastedImagesSnapshot(result.discardPastedImages);
-    if (result?.pastedTexts) installPastedTexts(result.pastedTexts, { merge: true });
-    if (result?.discardPastedTexts) clearPastedTextsSnapshot(result.discardPastedTexts);
-    const restoreText = String(result?.restoreText || '').trim();
-    if (!restoreText) return undefined;
-    const existingText = String(currentText || '').trim();
-    const nextText = [restoreText, existingText].filter(Boolean).join('\n');
+  const commitAsyncInterruptRestore = useCallback((pending) => {
+    if (!pending || pending.generation !== interruptGenerationRef.current) return true;
+    if (store.getState?.().busy) return false;
+    const restoreText = promptInterruptRestoreText(pending.result, promptValueRef.current);
+    if (!restoreText) return true;
+    if (pending.result?.pastedImages) installPastedImages(pending.result.pastedImages, { merge: true });
+    if (pending.result?.pastedTexts) installPastedTexts(pending.result.pastedTexts, { merge: true });
     clearPromptHint();
-    return nextText;
-  }, [store, clearPromptHint, installPastedImages, clearPastedImagesSnapshot]);
+    syncPromptLayoutRows(restoreText);
+    setPromptDraftOverride({ id: Date.now(), value: restoreText });
+    return true;
+  }, [store, promptValueRef, installPastedImages, installPastedTexts, clearPromptHint, syncPromptLayoutRows, setPromptDraftOverride]);
+
+  useEffect(() => {
+    const pending = pendingInterruptRestoreRef.current;
+    if (!pending) return;
+    if (commitAsyncInterruptRestore(pending)) pendingInterruptRestoreRef.current = null;
+  }, [state.busy, commitAsyncInterruptRestore]);
+
+  const handlePromptInterrupt = useCallback((currentText = '') => {
+    const generation = ++interruptGenerationRef.current;
+    pendingInterruptRestoreRef.current = null;
+    const applyResult = (result, draftText, asyncResult = false) => {
+      if (generation !== interruptGenerationRef.current || result?.aborted === false) return undefined;
+      if (result?.discardPastedImages) clearPastedImagesSnapshot(result.discardPastedImages);
+      if (result?.discardPastedTexts) clearPastedTextsSnapshot(result.discardPastedTexts);
+      if (asyncResult) {
+        const pending = { generation, result };
+        if (!commitAsyncInterruptRestore(pending)) pendingInterruptRestoreRef.current = pending;
+        return undefined;
+      }
+      const restoreText = promptInterruptRestoreText(result, draftText);
+      if (!restoreText) return undefined;
+      if (result?.pastedImages) installPastedImages(result.pastedImages, { merge: true });
+      if (result?.pastedTexts) installPastedTexts(result.pastedTexts, { merge: true });
+      clearPromptHint();
+      return restoreText;
+    };
+
+    let result;
+    try {
+      const options = { restorePrompt: String(currentText ?? '') === '' };
+      result = typeof store.abortAsync === 'function' ? store.abortAsync(options) : store.abort?.(options);
+    } catch (error) {
+      store.pushNotice?.(`interrupt failed: ${error?.message || error}`, 'error');
+      return undefined;
+    }
+    if (result && typeof result.then === 'function') {
+      void Promise.resolve(result)
+        .then((resolved) => applyResult(resolved, promptValueRef.current, true))
+        .catch((error) => store.pushNotice?.(`interrupt failed: ${error?.message || error}`, 'error'));
+      return undefined;
+    }
+    return applyResult(result, currentText, false);
+  }, [store, commitAsyncInterruptRestore, clearPromptHint, installPastedImages, installPastedTexts, clearPastedImagesSnapshot, clearPastedTextsSnapshot]);
 
   return {
     handlePromptPaste,

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

@@ -12,17 +12,18 @@ export function usePromptHint() {
   const promptHintTimerRef = useRef(null);
   const promptHintActiveRef = useRef(false);
 
-  const showPromptHint = useCallback((text, tone = 'info') => {
+  const showPromptHint = useCallback((text, tone = 'info', dismissMs = PROMPT_HINT_DISMISS_MS) => {
     if (promptHintTimerRef.current) clearTimeout(promptHintTimerRef.current);
     promptHintActiveRef.current = true;
     setPromptHint(String(text || ''));
     setPromptHintTone(tone);
+    const timeoutMs = Number(dismissMs) > 0 ? Number(dismissMs) : PROMPT_HINT_DISMISS_MS;
     promptHintTimerRef.current = setTimeout(() => {
       promptHintTimerRef.current = null;
       promptHintActiveRef.current = false;
       setPromptHint('');
       setPromptHintTone('info');
-    }, PROMPT_HINT_DISMISS_MS);
+    }, timeoutMs);
   }, []);
 
   // Same band and timer; only the resting tone differs for copy feedback.

package/src/tui/app/use-prompt-queue-history.mjs

@@ -5,6 +5,7 @@
 import { useCallback, useMemo } from 'react';
 import { PROMPT_HISTORY_LIMIT } from './transcript-window.mjs';
 import { promptHistoryKey } from './app-format.mjs';
+import { mergeQueuedRestoreText } from '../components/prompt-input/restore-policy.mjs';
 
 export function usePromptQueueHistory({
   store,
@@ -60,8 +61,12 @@ export function usePromptQueueHistory({
       if (restoreDraft) {
         if (restored.pastedImages) installPastedImages(restored.pastedImages, { merge: true });
         if (restored.pastedTexts) installPastedTexts(restored.pastedTexts, { merge: true });
-        syncPromptLayoutRows(restored.text);
-        setPromptDraftOverride({ id: Date.now(), value: restored.text });
+        const restoredText = mergeQueuedRestoreText(
+          restored.text,
+          promptValueRef.current ?? currentText,
+        );
+        syncPromptLayoutRows(restoredText);
+        setPromptDraftOverride({ id: Date.now(), value: restoredText });
       }
       if (showHint) {
         showPromptHint(`restored ${restored.count} queued message${restored.count === 1 ? '' : 's'}`, 'info');
@@ -70,7 +75,9 @@ export function usePromptQueueHistory({
       }
       return true;
     };
-    const restored = store.restoreQueued?.(currentText);
+    // Ask the session service for the queued portion only. The live draft remains
+    // renderer-owned and is merged in apply(), after a daemon promise settles.
+    const restored = store.restoreQueued?.('');
     // A daemon-backed store answers this as an ASYNC remote call, so the
     // payload (and with it the queued text) only exists a tick later. Reading
     // `.count`/`.text` off the promise dropped the popped entries on the floor —

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

@@ -13,13 +13,14 @@ import { theme } from '../theme.mjs';
 import {
   SELECTION_PAINT_INTERVAL_MS,
   SCROLL_COALESCE_MS,
+  accumulateDirectionalScrollDelta,
   selectionRectsEqual,
   shiftSelectionRectY,
   comparePoints,
   upperBound,
   transcriptRowAt,
 } from './transcript-window.mjs';
-import { yieldToRenderer } from '../engine/render-timing.mjs';
+import { yieldToRenderer } from '../session/render-timing.mjs';
 
 export function useTranscriptScroll({
   store,
@@ -45,7 +46,7 @@ export function useTranscriptScroll({
   const selectionPaintRef = useRef({ t: 0, rect: null, pending: null, timer: null });
   // Coalescer for edge-drag auto-scroll + wheel scroll deltas (see
   // SCROLL_COALESCE_MS). Both call sites accumulate into pendingRows.
-  const scrollCoalesceRef = useRef({ pendingRows: 0, timer: null });
+  const scrollCoalesceRef = useRef({ pendingRows: 0, direction: 0, timer: null });
   const selectionTextCaptureRef = useRef(0);
   // Stitch buffer: accumulates harvested transcript selection rows across scroll
   // positions so Ctrl+C copies the FULL drag even after it auto-scrolled past the
@@ -446,6 +447,7 @@ export function useTranscriptScroll({
     if (coalesceState.timer) clearTimeout(coalesceState.timer);
     coalesceState.timer = null;
     coalesceState.pendingRows = 0;
+    coalesceState.direction = 0;
   }, []);
 
   const scrollTranscriptRows = useCallback((deltaRows, options = {}) => {
@@ -653,13 +655,18 @@ export function useTranscriptScroll({
   // calling scrollTranscriptRows directly.
   const queueScrollCoalesced = useCallback((deltaRows) => {
     const state = scrollCoalesceRef.current;
-    state.pendingRows += deltaRows;
+    const reversed = accumulateDirectionalScrollDelta(state, deltaRows);
+    if (reversed && state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
     if (state.timer) return;
     const rows = state.pendingRows;
     state.pendingRows = 0;
     scrollTranscriptRows(rows);
     state.timer = setTimeout(() => {
       state.timer = null;
+      state.direction = 0;
       if (state.pendingRows !== 0) {
         const remaining = state.pendingRows;
         state.pendingRows = 0;

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

@@ -207,8 +207,6 @@ export function useTranscriptWindow({
   const streamingTailItem = streamingTail?.kind === 'assistant' && streamingTail.streaming
     ? streamingTail
     : null;
-  const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
-  const transcriptPinnedForStreaming = followingRef.current || scrolledUpRowsForPin === 0;
   const tailRows = streamingTailItem
     ? estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)
     : 0;
@@ -226,17 +224,12 @@ export function useTranscriptWindow({
     revision,
     streamingTailItem,
   );
-  const transcriptStreamingActive = !!streamingTailItem;
-  const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > 0;
-  const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
-  const hasStreamingReadingAnchor = !!transcriptAnchorRef.current
-    || transcriptAnchorDirtyRef.current;
-  const bottomPinnedForMeasure = transcriptPinnedForStreaming;
-  const suppressMeasuredRowHeights = bottomPinnedForMeasure
-    || (transcriptStreamingActive && (
-      (scrolledUpForStreamingMeasure && hasStreamingReadingAnchor)
-      || (scrolledUpForStreamingMeasure && prevEstimateGeometry && !transcriptPinnedForStreaming)
-    ));
+  // The live assistant already has one deterministic geometry authority in
+  // estimateTranscriptItemRowsCached. Settled rows always keep their measured
+  // geometry, whether following, reading, or resizing around a popup/picker.
+  // Switching the entire prefix back to estimates on the first upward wheel
+  // changed the row table during that gesture and caused rollback/jitter.
+  const suppressMeasuredRowHeights = false;
   // Incremental builder: on a streaming flush where only the trailing assistant
   // item's text grew, it recomputes just the tail row and appends to a cached
   // settled-prefix row-index (O(1) prefix) instead of re-walking all N items.
@@ -680,9 +673,14 @@ export function useTranscriptWindow({
     // off-screen. Ref: render-node-to-output's
     // `atBottom = sticky || (grew && scrollTop >= prevMaxScroll)`, which
     // likewise flips a user-broken sticky flag back on when the position says
-    // bottom. Growth-gated (rowDelta > 0) for the same reason the ref gates on
-    // `grew`: a shrink can put the offset at 0 as an artifact.
-    if (!followingRef.current && rowDelta > 0 && currentTarget === 0) {
+    // bottom. Gated on `rowDelta >= 0` in exact parity with the reference's
+    // `grew = scrollHeight >= prevScrollHeight`: only a SHRINK is excluded
+    // (it can put the offset at 0 as an artifact). Demanding real growth was
+    // stricter than the reference and left the equal-height commits (a text
+    // replaced in place, a spinner/mode swap) falling through to the anchor
+    // capture below — which then locked the viewport at the tail with follow
+    // off, and every later row piled up below the fold.
+    if (!followingRef.current && rowDelta >= 0 && currentTarget === 0) {
       followingRef.current = true;
     }
     // Follow ownership is explicit. target=0 can also mean the first manual
@@ -774,7 +772,31 @@ export function useTranscriptWindow({
       maxRows,
     });
     if (desired == null) {
-      // Anchor item gone (rare: removal/compaction). Re-capture next frame.
+      // Anchor item gone (removal/compaction). On GROWTH this is a transient
+      // identity gap — re-capture next frame. On a SHRINK the anchored rows
+      // were deleted: the reading position no longer exists, and leaving the
+      // lock in place pinned the target above zero forever, so the positional
+      // follow restore above (which needs target === 0) could never fire and
+      // auto-scroll stayed released for the rest of the session
+      // (user: 컴팩션된 이후로 자동 스크롤이 풀린다).
+      // A compaction commit can also NET-GROW the frame it lands in (it pushes
+      // its status row and keeps the streaming tail growing while it trims the
+      // head), so the row delta alone missed exactly the case it was written
+      // for. A bottom-relative target that no longer fits the transcript
+      // (currentTarget > maxRows) is the same deletion signal without the sign
+      // assumption: a transient identity gap during growth still fits, and the
+      // clamp effect below would otherwise silently park the target with follow
+      // left off.
+      if (rowDelta < 0 || currentTarget > maxRows) {
+        stopSmoothScroll();
+        transcriptAnchorRef.current = null;
+        transcriptAnchorDirtyRef.current = false;
+        scrollTargetRef.current = 0;
+        scrollPositionRef.current = 0;
+        followingRef.current = true;
+        if (currentOffset !== 0) setScrollOffset(0);
+        return;
+      }
       transcriptAnchorDirtyRef.current = true;
       return;
     }
@@ -837,6 +859,17 @@ export function useTranscriptWindow({
   }, [themeEpoch, withSelectionClip, paintSelectionRect]);
   useEffect(() => {
     const maxRows = Math.max(0, Number(transcriptWindow.maxScrollRows) || 0);
+    // Opencode parity (createAutoScroll: `if (!canScroll(el)) userScrolled =
+    // false`, applied both on scroll and on the content resize; our desktop
+    // hook mirrors it in handleScroll/handleAutoScroll): a transcript that no
+    // longer OVERFLOWS holds no reading position, so a compaction or clear
+    // that shrinks it inside the viewport re-arms follow instead of leaving
+    // auto-scroll released with nothing left to scroll.
+    if (maxRows === 0 && !followingRef.current) {
+      transcriptAnchorRef.current = null;
+      transcriptAnchorDirtyRef.current = false;
+      followingRef.current = true;
+    }
     if (scrollTargetRef.current <= maxRows && scrollPositionRef.current <= maxRows && scrollOffset <= maxRows) return;
     stopSmoothScroll();
     const next = Math.max(0, Math.min(maxRows, scrollTargetRef.current));