mixdog 1.4.1 → 1.4.2

package/src/tui/app/use-selection-stitch.mjs

@@ -64,7 +64,7 @@ export function useSelectionStitchBuffer({ store, dragRef, scrollTargetRef }) {
       if (!Array.isArray(rows)) return;
       storeStitchRows(stitchBufferRef.current, rows, stitchHarvestScrollRef.current);
     }, 0);
-  }, [store]);
+  }, [store, dragRef, scrollTargetRef]);
 
   // Synchronous sibling: snapshot the rows CURRENTLY under the selection
   // immediately, keyed by the given (pre-scroll) offset. Called right before
@@ -80,7 +80,7 @@ export function useSelectionStitchBuffer({ store, dragRef, scrollTargetRef }) {
       if (!Array.isArray(rows)) return;
       storeStitchRows(stitchBufferRef.current, rows, Number(scroll) || 0);
     },
-    [store]
+    [store, dragRef]
   );
 
   // Map the CURRENT rect + current scrollTarget onto the content-key range and
@@ -122,7 +122,7 @@ export function useSelectionStitchBuffer({ store, dragRef, scrollTargetRef }) {
     }
     const text = logical.map((l) => l.replace(/\s+$/u, '')).join('\n');
     return text.trim() ? { text, complete } : empty;
-  }, []);
+  }, [dragRef, scrollTargetRef]);
 
   return { clearStitchBuffer, harvestStitchRowsSoon, harvestStitchRowsNow, getStitchedSelectionText };
 }

package/src/tui/app/use-slash-palette.mjs

@@ -0,0 +1,62 @@
+/*
+ * app/use-slash-palette.mjs — the slash / `$skill` palette above the prompt.
+ *
+ * useSlashPaletteState owns the selection index, the dismissed-draft marker
+ * and the live open/count ref the mouse handler reads; it is declared early
+ * because the mouse and draft hooks need the setters. useSlashPalette derives
+ * the palette for this render from the prompt and the surfaces that suppress
+ * it, publishes it to that ref, and keeps the index inside the list.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { deriveSlashPalette } from './slash-palette.mjs';
+import { skillMentionQuery, useSkillMentionSkills } from './skill-mention-palette.mjs';
+
+export function useSlashPaletteState() {
+  const [slashIndex, setSlashIndex] = useState(0);
+  const [slashDismissedFor, setSlashDismissedFor] = useState('');
+  const slashPaletteRef = useRef({ open: false, count: 0 });
+  return { slashIndex, setSlashIndex, slashDismissedFor, setSlashDismissedFor, slashPaletteRef };
+}
+
+export function useSlashPalette({
+  store,
+  slashPaletteRef,
+  setSlashIndex,
+  slashDismissedFor,
+  promptDraft,
+  promptCaret,
+  providerPrompt,
+  settingsPrompt,
+  toolApproval,
+  contextPanel,
+  usagePanel,
+  picker,
+  exiting,
+  commandBusy,
+}) {
+  const mentionSkills = useSkillMentionSkills(store, skillMentionQuery(promptDraft, promptCaret) !== null);
+  const palette = deriveSlashPalette({
+    providerPrompt,
+    settingsPrompt,
+    toolApproval,
+    contextPanel,
+    usagePanel,
+    picker,
+    exiting,
+    commandBusy,
+    promptDraft,
+    slashDismissedFor,
+    skills: mentionSkills,
+    promptCaret,
+  });
+  const { activeSlashQuery, slashCommands, slashPaletteOpen } = palette;
+  slashPaletteRef.current = { open: slashPaletteOpen, count: slashCommands.length };
+
+  // A query change re-clamps even when the list length stays the same.
+  // biome-ignore lint/correctness/useExhaustiveDependencies(activeSlashQuery): query-change re-clamp trigger
+  useEffect(() => {
+    setSlashIndex((index) => Math.min(index, Math.max(0, slashCommands.length - 1)));
+  }, [slashCommands.length, activeSlashQuery, setSlashIndex]);
+
+  return palette;
+}

package/src/tui/app/use-terminal-chrome.mjs

@@ -47,7 +47,7 @@ export function useTerminalChrome({ stdout, isRawModeSupported, setResizeState }
       if (trailing) clearTimeout(trailing);
       stdout.off('resize', onResize);
     };
-  }, [stdout]);
+  }, [stdout, setResizeState]);
 
   // Enable extended keyboard reporting (kitty + xterm modifyOtherKeys)
   // SYNCHRONOUSLY, ONCE, with NO query/round-trip. ink
@@ -61,7 +61,7 @@ export function useTerminalChrome({ stdout, isRawModeSupported, setResizeState }
   // \x1b[27;5;13~ (or kitty \x1b[13;5u) instead of a bare \r — fixing the old
   // "first Ctrl+Enter submits, second works" race. Teardown lives in index.jsx's
   // restoreTerminal(). The empty dep array makes this run exactly once on mount.
-  // eslint-disable-next-line react-hooks/exhaustive-deps
+  // biome-ignore lint/correctness/useExhaustiveDependencies: one-shot mount enable; teardown is owned by restoreTerminal()
   useEffect(() => {
     if (!isRawModeSupported || !stdout?.write) return;
     if (!supportsExtendedKeys()) return;

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

@@ -105,38 +105,53 @@ export function useTranscriptActivity({ state }) {
   // StatusLine only reads a small stats subset; engine clones the full stats
   // object on many updates. Memoize by field value so identical usage keeps
   // the same object reference and React.memo / effect deps stay quiet.
-  const statuslineStats = useMemo(() => {
-    const s = state.stats || {};
-    return {
-      currentContextSource: s.currentContextSource ?? null,
-      currentEstimatedContextTokens: s.currentEstimatedContextTokens ?? 0,
-      currentContextTokens: s.currentContextTokens ?? null,
-      contextTokens: s.contextTokens ?? 0,
-      latestPromptTokens: s.latestPromptTokens ?? 0,
-      latestInputTokens: s.latestInputTokens ?? 0,
-      latestCachedTokens: s.latestCachedTokens ?? 0,
-      latestCacheWriteTokens: s.latestCacheWriteTokens ?? 0,
-      inputTokens: s.inputTokens ?? 0,
-      cachedTokens: s.cachedTokens ?? 0,
-      cacheWriteTokens: s.cacheWriteTokens ?? 0,
-      promptTokens: s.promptTokens ?? 0,
-      turns: s.turns ?? 0,
-    };
-  }, [
-    state.stats?.currentContextSource,
-    state.stats?.currentEstimatedContextTokens,
-    state.stats?.currentContextTokens,
-    state.stats?.contextTokens,
-    state.stats?.latestPromptTokens,
-    state.stats?.latestInputTokens,
-    state.stats?.latestCachedTokens,
-    state.stats?.latestCacheWriteTokens,
-    state.stats?.inputTokens,
-    state.stats?.cachedTokens,
-    state.stats?.cacheWriteTokens,
-    state.stats?.promptTokens,
-    state.stats?.turns,
-  ]);
+  const {
+    currentContextSource,
+    currentEstimatedContextTokens,
+    currentContextTokens,
+    contextTokens,
+    latestPromptTokens,
+    latestInputTokens,
+    latestCachedTokens,
+    latestCacheWriteTokens,
+    inputTokens,
+    cachedTokens,
+    cacheWriteTokens,
+    promptTokens,
+    turns,
+  } = state.stats || {};
+  const statuslineStats = useMemo(
+    () => ({
+      currentContextSource: currentContextSource ?? null,
+      currentEstimatedContextTokens: currentEstimatedContextTokens ?? 0,
+      currentContextTokens: currentContextTokens ?? null,
+      contextTokens: contextTokens ?? 0,
+      latestPromptTokens: latestPromptTokens ?? 0,
+      latestInputTokens: latestInputTokens ?? 0,
+      latestCachedTokens: latestCachedTokens ?? 0,
+      latestCacheWriteTokens: latestCacheWriteTokens ?? 0,
+      inputTokens: inputTokens ?? 0,
+      cachedTokens: cachedTokens ?? 0,
+      cacheWriteTokens: cacheWriteTokens ?? 0,
+      promptTokens: promptTokens ?? 0,
+      turns: turns ?? 0,
+    }),
+    [
+      currentContextSource,
+      currentEstimatedContextTokens,
+      currentContextTokens,
+      contextTokens,
+      latestPromptTokens,
+      latestInputTokens,
+      latestCachedTokens,
+      latestCacheWriteTokens,
+      inputTokens,
+      cachedTokens,
+      cacheWriteTokens,
+      promptTokens,
+      turns,
+    ]
+  );
 
   return { agentRevision, activeTools, statuslineStats };
 }

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

@@ -44,11 +44,11 @@ export function useTranscriptFollow({
       setScrollOffset(Math.max(0, Math.round(scrollPositionRef.current)));
     }, 16);
     scrollAnimationRef.current.unref?.();
-  }, [stopSmoothScroll]);
+  }, [scrollPositionRef, scrollTargetRef, followingRef, setScrollOffset, stopSmoothScroll]);
 
   const cancelTranscriptFollow = useCallback(() => {
     followingRef.current = false;
-  }, []);
+  }, [followingRef]);
 
   const resetTranscriptScroll = useCallback(() => {
     stopSmoothScroll();
@@ -65,7 +65,15 @@ export function useTranscriptFollow({
     // and every new row piled up below the fold.
     followingRef.current = true;
     setScrollOffset(0);
-  }, [stopSmoothScroll]);
+  }, [
+    scrollPositionRef,
+    scrollTargetRef,
+    followingRef,
+    transcriptAnchorRef,
+    transcriptAnchorDirtyRef,
+    setScrollOffset,
+    stopSmoothScroll,
+  ]);
 
   const armTranscriptFollow = useCallback(() => {
     // Do not mutate scrollOffset here. During prompt submit the transcript rows
@@ -78,7 +86,7 @@ export function useTranscriptFollow({
     pendingReadbackRowsRef.current = 0;
     followingRef.current = true;
     stopSmoothScroll();
-  }, [stopSmoothScroll]);
+  }, [followingRef, transcriptAnchorRef, transcriptAnchorDirtyRef, stopSmoothScroll]);
 
   return {
     pendingReadbackRowsRef,

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

@@ -141,7 +141,7 @@ export function useTranscriptScroll({
     if (!anchor) return;
     transcriptAnchorRef.current = anchor;
     transcriptAnchorDirtyRef.current = false;
-  }, []);
+  }, [transcriptGeomRef, scrollTargetRef, transcriptAnchorRef, transcriptAnchorDirtyRef]);
 
   // A manual scroll moves the reading position. Capture the new anchor
   // SYNCHRONOUSLY from the latest published geometry so the very next render
@@ -149,20 +149,23 @@ export function useTranscriptScroll({
   // streaming growth could lurch the view. Only at the true bottom drop the
   // anchor so the bottom-follow path owns the viewport again: a positive
   // wheel offset is an explicit reading position, even inside the old slack.
-  const captureReadingAnchor = useCallback((target) => {
-    if (target === 0) {
-      transcriptAnchorRef.current = null;
-      transcriptAnchorDirtyRef.current = false;
-      return;
-    }
-    const anchor = readingAnchorAt(transcriptGeomRef.current || {}, target);
-    if (anchor) {
-      transcriptAnchorRef.current = anchor;
-      transcriptAnchorDirtyRef.current = false;
-    } else {
-      transcriptAnchorDirtyRef.current = true;
-    }
-  }, []);
+  const captureReadingAnchor = useCallback(
+    (target) => {
+      if (target === 0) {
+        transcriptAnchorRef.current = null;
+        transcriptAnchorDirtyRef.current = false;
+        return;
+      }
+      const anchor = readingAnchorAt(transcriptGeomRef.current || {}, target);
+      if (anchor) {
+        transcriptAnchorRef.current = anchor;
+        transcriptAnchorDirtyRef.current = false;
+      } else {
+        transcriptAnchorDirtyRef.current = true;
+      }
+    },
+    [transcriptGeomRef, transcriptAnchorRef, transcriptAnchorDirtyRef]
+  );
 
   // Scrolling past the oldest/newest loaded edge pages transcript history
   // instead of moving the target. Returns true when the edge owned the
@@ -190,7 +193,15 @@ export function useTranscriptScroll({
       }
       return true;
     },
-    [store, captureRestoreAnchor, stopSmoothScroll, cancelTranscriptFollow]
+    [
+      store,
+      scrollTargetRef,
+      scrollPositionRef,
+      setScrollOffset,
+      captureRestoreAnchor,
+      stopSmoothScroll,
+      cancelTranscriptFollow,
+    ]
   );
 
   // Keep a live selection on its content after the viewport moved. An active
@@ -229,7 +240,14 @@ export function useTranscriptScroll({
       // (Ctrl+C after scrolling then copied just that fragment).
       paintSelectionRect(clippedRect, { rememberText: false });
     },
-    [buildSpanRect, selectionPointAtCurrentScroll, withSelectionClip, cancelPendingSelectionPaint, paintSelectionRect]
+    [
+      dragRef,
+      buildSpanRect,
+      selectionPointAtCurrentScroll,
+      withSelectionClip,
+      cancelPendingSelectionPaint,
+      paintSelectionRect,
+    ]
   );
 
   const scrollTranscriptRows = useCallback(
@@ -294,6 +312,17 @@ export function useTranscriptScroll({
       setScrollOffset(Math.round(target));
     },
     [
+      maxScrollRowsRef,
+      transcriptGeomRef,
+      scrollTargetRef,
+      scrollPositionRef,
+      pendingReadbackRowsRef,
+      dragRef,
+      transcriptAnchorRef,
+      transcriptAnchorDirtyRef,
+      followingRef,
+      selectionLayoutRef,
+      setScrollOffset,
       pageTranscriptHistory,
       captureReadingAnchor,
       rebuildSelectionAfterScroll,

package/src/tui/app/use-transcript-swap-reset.mjs

@@ -0,0 +1,27 @@
+/*
+ * app/use-transcript-swap-reset.mjs — returns the viewport to the live tail
+ * when the transcript items are bulk-swapped.
+ *
+ * Item-count changes never infer follow permission from scrollTarget=0. A
+ * first read-back input can be waiting one frame for committed row geometry;
+ * only prompt submit, session reset, or an explicit return to bottom arms
+ * follow. Pure streaming height growth is handled in the row-delta effect.
+ */
+import { useLayoutEffect } from 'react';
+import { transcriptSwapReturnsToTail } from './transcript-window.mjs';
+
+export function useTranscriptSwapReset({ items, lastItemsCountRef, lastFirstItemIdRef, resetTranscriptScroll }) {
+  useLayoutEffect(() => {
+    const count = items.length;
+    const previousCount = lastItemsCountRef.current;
+    lastItemsCountRef.current = count;
+    const firstId = count > 0 ? (items[0]?.id ?? null) : null;
+    const previousFirstId = lastFirstItemIdRef.current;
+    lastFirstItemIdRef.current = firstId;
+    // A bulk swap (compaction included) is an explicit return to the tail: the
+    // rows the reader was anchored to no longer exist.
+    if (transcriptSwapReturnsToTail({ count, previousCount, firstId, previousFirstId })) {
+      resetTranscriptScroll();
+    }
+  }, [items, lastItemsCountRef, lastFirstItemIdRef, resetTranscriptScroll]);
+}

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

@@ -81,7 +81,12 @@ export function useTranscriptGeometry(state, props) {
   // settled-prefix row-index instead of re-walking all N items. Any structural
   // change misses the cache and falls back to a full rebuild, so the prefix
   // table is byte-identical to a full rebuild for the settled prefix. All those
-  // invalidators are folded into the memo deps.
+  // invalidators are folded into the memo deps: revision + tailSig stand in
+  // for the items/tail identities, and measuredRowsVersion folds in measured
+  // corrections.
+  // biome-ignore lint/correctness/useExhaustiveDependencies(transcriptItems): keyed by revision + tailSig
+  // biome-ignore lint/correctness/useExhaustiveDependencies(streamingTailItem): keyed by tailSig
+  // biome-ignore lint/correctness/useExhaustiveDependencies(tailSig): tail id + height recompute key
   const transcriptRowIndex = useMemo(
     () =>
       buildTranscriptRowIndexIncremental(transcriptItems, {
@@ -92,9 +97,8 @@ export function useTranscriptGeometry(state, props) {
         cacheRef: state.incrementalRowIndexCacheRef,
         prefixRevision: revision,
         streamingTailItem,
-        // eslint-disable-next-line react-hooks/exhaustive-deps -- revision/tail height capture structural geometry; measuredRowsVersion folds in measured corrections
       }),
-    [revision, tailSig, frameColumns, toolOutputExpanded, measuredRowsVersion]
+    [revision, tailSig, frameColumns, toolOutputExpanded, measuredRowsVersion, state.incrementalRowIndexCacheRef]
   );
   const renderScrollOffset = resolveRenderScrollOffset({
     scrollOffset,
@@ -109,6 +113,10 @@ export function useTranscriptGeometry(state, props) {
     geomRef: transcriptGeomRef,
     prevViewportRef: state.prevViewportGeomRef,
   });
+  // transcriptStructureSig stands in for the items identity (it also encodes
+  // frameColumns and toolOutputExpanded); scroll/viewport capture the rest.
+  // biome-ignore lint/correctness/useExhaustiveDependencies(transcriptItems): keyed by transcriptStructureSig
+  // biome-ignore lint/correctness/useExhaustiveDependencies(transcriptStructureSig): items recompute key
   const transcriptWindow = useMemo(
     () =>
       transcriptRenderWindow(transcriptItems, {
@@ -117,9 +125,15 @@ export function useTranscriptGeometry(state, props) {
         columns: frameColumns,
         toolOutputExpanded,
         rowIndex: transcriptRowIndex,
-        // eslint-disable-next-line react-hooks/exhaustive-deps -- intentional: sig+scroll/viewport capture the relevant changes
       }),
-    [transcriptStructureSig, renderScrollOffset, transcriptContentHeight, transcriptRowIndex]
+    [
+      transcriptStructureSig,
+      renderScrollOffset,
+      transcriptContentHeight,
+      transcriptRowIndex,
+      frameColumns,
+      toolOutputExpanded,
+    ]
   );
   publishMaxScrollRows(state, transcriptWindow, { maxScrollRowsRef, frameColumns, toolOutputExpanded });
   // Publish this frame's geometry so a manual scroll can capture the reading

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

@@ -65,6 +65,10 @@ export function useTranscriptInstanceState({ sessionKey, scrollOffset, setScroll
     followingRef.current = true;
     selectionLayoutRef.current = null;
   }
+  // Runs on a session switch only: normalizedSessionKey is the trigger, and
+  // scrollOffset is read (not tracked) so scrolling never re-runs the reset.
+  // biome-ignore lint/correctness/useExhaustiveDependencies(normalizedSessionKey): session-switch trigger
+  // biome-ignore lint/correctness/useExhaustiveDependencies(scrollOffset): read at switch time only
   useLayoutEffect(() => {
     if (scrollOffset !== 0) setScrollOffset(0);
   }, [normalizedSessionKey, setScrollOffset]);

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

@@ -40,12 +40,16 @@ export function useSelectionLayoutShift({
     // with only the still-visible fragment (partial Ctrl+C after scrolling).
     paintSelectionRect(clippedRect, { rememberText: false });
   }, [
+    transcriptViewportRef,
+    selectionLayoutRef,
+    dragRef,
     transcriptContentHeight,
     transcriptWindow.totalRows,
     transcriptWindow.effectiveScrollOffset,
     withSelectionClip,
     paintSelectionRect,
   ]);
+  // biome-ignore lint/correctness/useExhaustiveDependencies(themeEpoch): theme-change repaint trigger
   useEffect(() => {
     if (!dragRef.current.rect) return;
     const clippedRect = withSelectionClip(dragRef.current.rect);
@@ -53,5 +57,5 @@ export function useSelectionLayoutShift({
     // 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 });
-  }, [themeEpoch, withSelectionClip, paintSelectionRect]);
+  }, [themeEpoch, dragRef, withSelectionClip, paintSelectionRect]);
 }

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

@@ -13,7 +13,7 @@
  *   use-transcript-window/visible-items.mjs   — on-screen slice, overlay hint placement
  *   use-transcript-window/selection-shift.mjs — selection rect follows geometry/theme
  */
-import { useCallback, useEffect, useLayoutEffect } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useMemo } from 'react';
 import { harvestMeasuredRows, measureRefFor } from './transcript-measure.mjs';
 import {
   clampScrollToOverflow,
@@ -66,7 +66,10 @@ export function useTranscriptWindow({
     selectionLayoutRef,
   };
   const state = useTranscriptInstanceState({ sessionKey, scrollOffset, setScrollOffset, refs });
-  const transcriptMeasureRef = useCallback((item) => measureRefFor(state.measureStateRef.current, item), []);
+  const transcriptMeasureRef = useCallback(
+    (item) => measureRefFor(state.measureStateRef.current, item),
+    [state.measureStateRef]
+  );
   const { revision, streamingTailItem, transcriptItems, transcriptRowIndex, transcriptWindow } = useTranscriptGeometry(
     state,
     {
@@ -102,13 +105,12 @@ export function useTranscriptWindow({
     transcriptGuardRows,
     themeEpoch,
   };
-  const scrollRefs = {
-    transcriptAnchorRef,
-    transcriptAnchorDirtyRef,
-    scrollTargetRef,
-    scrollPositionRef,
-    followingRef,
-  };
+  // Memoized over the App-owned refs (stable identities), so the effects below
+  // can depend on the bundle without re-running.
+  const scrollRefs = useMemo(
+    () => ({ transcriptAnchorRef, transcriptAnchorDirtyRef, scrollTargetRef, scrollPositionRef, followingRef }),
+    [transcriptAnchorRef, transcriptAnchorDirtyRef, scrollTargetRef, scrollPositionRef, followingRef]
+  );
   // ── Measured height harvest (every commit, no deps) ─────────────────────
   useLayoutEffect(() => {
     harvestMeasuredRows(state.measureStateRef.current, {
@@ -120,6 +122,10 @@ export function useTranscriptWindow({
     });
   });
   // ── Bottom-follow / anchor post-commit sync ─────────────────────────────
+  // transcriptItems is read alongside transcriptRowIndex, which is derived
+  // from it; the sync keys on the row index so a same-geometry items swap
+  // does not re-run it.
+  // biome-ignore lint/correctness/useExhaustiveDependencies(transcriptItems): keyed on the derived row index
   useLayoutEffect(() => {
     const totalRows = Math.max(0, Number(transcriptWindow.totalRows) || 0);
     const previousTotalRows = Math.max(0, Number(state.transcriptTotalRowsRef.current) || 0);
@@ -144,10 +150,14 @@ export function useTranscriptWindow({
     transcriptContentHeight,
     scrollOffset,
     stopSmoothScroll,
+    scrollRefs,
+    state.transcriptTotalRowsRef,
+    dragRef,
+    setScrollOffset,
   ]);
   useLayoutEffect(() => {
     resetScrollWhenUnanchored(scrollRefs, { scrollOffset, setScrollOffset, stopSmoothScroll });
-  }, [scrollOffset, stopSmoothScroll]);
+  }, [scrollRefs, scrollOffset, setScrollOffset, stopSmoothScroll]);
   // ── Selection layout shift ──────────────────────────────────────────────
   useSelectionLayoutShift({
     transcriptWindow,
@@ -166,7 +176,7 @@ export function useTranscriptWindow({
       setScrollOffset,
       stopSmoothScroll,
     });
-  }, [transcriptWindow.maxScrollRows, scrollOffset, stopSmoothScroll]);
+  }, [scrollRefs, transcriptWindow.maxScrollRows, scrollOffset, setScrollOffset, stopSmoothScroll]);
 
   return {
     transcriptWindow,

package/src/tui/app/use-tui-ready.mjs

@@ -0,0 +1,18 @@
+/*
+ * app/use-tui-ready.mjs — post-mount input gate.
+ *
+ * tuiReady stays false across the first render + commit. Let one event-loop
+ * poll pass so Ink processes (and discards, because PromptInput is still
+ * disabled) any keystrokes the OS buffered during terminal setup / initial
+ * mount. After the tick, enable the input — new keystrokes land normally.
+ */
+import { useEffect, useState } from 'react';
+
+export function useTuiReady() {
+  const [tuiReady, setTuiReady] = useState(false);
+  useEffect(() => {
+    const timer = setTimeout(() => setTuiReady(true), 0);
+    return () => clearTimeout(timer);
+  }, []);
+  return tuiReady;
+}

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

@@ -26,6 +26,11 @@ export function useWelcomePromptHint({ store, state, toastErrorSignature }) {
     setWelcomePromptHintDismissed(true);
   }, []);
 
+  // The probe re-runs when the workflow id changes; the workflow snapshot it
+  // hands to the summary probe is read, not tracked, so an identity-only
+  // workflow refresh does not re-probe.
+  // biome-ignore lint/correctness/useExhaustiveDependencies(state.workflow): keyed by workflow id
+  // biome-ignore lint/correctness/useExhaustiveDependencies(state.workflow?.id): workflow id re-probe key
   useEffect(() => {
     let alive = true;
     const refreshConditionalWelcomeHint = async () => {

package/src/tui/app/use-workflow-tab-cycle.mjs

@@ -20,10 +20,12 @@ export function useWorkflowTabCycle({
   // async switch and pushes a toast, producing a rapid bottom-layout repaint
   // storm that can visually tear the prompt box in Windows Terminal.
   const workflowTabCycleRef = useRef({ pending: false, lastAt: 0 });
+  // The cycle reads only these two state fields.
+  const { commandBusy, workflow } = state;
   return useCallback(() => {
     if (slashPaletteOpen || toolApproval || picker || settingsPrompt || providerPrompt || contextPanel || usagePanel)
       return true;
-    return cycleWorkflow({ store, state, cycleGuard: workflowTabCycleRef.current });
+    return cycleWorkflow({ store, state: { commandBusy, workflow }, cycleGuard: workflowTabCycleRef.current });
   }, [
     slashPaletteOpen,
     toolApproval,
@@ -32,8 +34,8 @@ export function useWorkflowTabCycle({
     providerPrompt,
     contextPanel,
     usagePanel,
-    state.commandBusy,
-    state.workflow,
+    commandBusy,
+    workflow,
     store,
   ]);
 }