mixdog 0.9.87 → 0.9.89

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

@@ -12,7 +12,6 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr
 import {
   TRANSCRIPT_MEASURED_ROWS,
   transcriptMeasuredRowsCache,
-  streamingMeasuredRowsById,
   pruneStreamingMeasuredRowsById,
   hasStreamingRowStateToPrune,
   transcriptItemVariantKey,
@@ -21,12 +20,8 @@ import {
   transcriptRowAt,
   buildTranscriptRowIndexIncremental,
   estimateTranscriptItemRowsCached,
-  setStreamingBottomPinned,
   transcriptRenderWindow,
   resolveAnchorScrollOffset,
-  streamingTailMountedGrowth,
-  streamingEstimateRows,
-  TRANSCRIPT_WINDOW_OVERSCAN_ROWS,
   upperBound,
   shiftSelectionRectY,
   transcriptHarvestInputsEqual,
@@ -59,6 +54,7 @@ function traceHarvestBreaker(changedKeys) {
 export function useTranscriptWindow({
   items: settledItems,
   structureRevision,
+  sessionKey = '',
   streamingTail,
   themeEpoch,
   frameColumns,
@@ -141,6 +137,46 @@ export function useTranscriptWindow({
   // item by id at call time. The ref(null) path drops the element; the harvest
   // reads getComputedHeight from whatever is mounted, so an unmount simply stops
   // contributing (its last measurement stays cached on the item object).
+  const normalizedSessionKey = String(sessionKey ?? '');
+  const transcriptSessionKeyRef = useRef(normalizedSessionKey);
+  if (transcriptSessionKeyRef.current !== normalizedSessionKey) {
+    // A resumed session replaces the transcript atomically, but this hook
+    // remains mounted. Never let the outgoing session's row index, reading
+    // anchor, measured-element map, or bottom-relative offset participate in
+    // the incoming session's first frame. Reset synchronously during render so
+    // the new transcript paints at its final bottom-pinned position; the layout
+    // effect below only reconciles the App-owned scroll state afterward.
+    transcriptSessionKeyRef.current = normalizedSessionKey;
+    transcriptTotalRowsRef.current = 0;
+    harvestBumpStreakRef.current = { count: 0, timer: null };
+    committedMaxScrollRowsRef.current = 0;
+    incrementalRowIndexCacheRef.current = null;
+    transcriptItemsCacheRef.current = null;
+    prevViewportGeomRef.current = { contentHeight: 0, floatingPanelRows: 0 };
+    transcriptItemElsRef.current.clear();
+    transcriptMeasureRefCache.current.clear();
+    transcriptMeasureItemsRef.current.clear();
+    harvestGateRef.current = {
+      inputs: null,
+      skippedForDrag: false,
+      forceNext: false,
+    };
+    transcriptAnchorRef.current = null;
+    transcriptAnchorDirtyRef.current = false;
+    scrollTargetRef.current = 0;
+    scrollPositionRef.current = 0;
+    maxScrollRowsRef.current = 0;
+    transcriptGeomRef.current = {};
+    followingRef.current = true;
+    selectionLayoutRef.current = null;
+    if (hasStreamingRowStateToPrune()) {
+      pruneStreamingMeasuredRowsById(new Set());
+    }
+  }
+  useLayoutEffect(() => {
+    if (scrollOffset !== 0) setScrollOffset(0);
+  }, [normalizedSessionKey, setScrollOffset]);
+
   const transcriptMeasureRef = useCallback((item) => {
     if (!TRANSCRIPT_MEASURED_ROWS || !item || item.id == null) return undefined;
     if (shouldSuppressFullyFailedToolItem(item)) {
@@ -172,13 +208,7 @@ export function useTranscriptWindow({
     ? streamingTail
     : null;
   const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
-  const transcriptPinnedForStreaming = followingRef.current
-    || scrolledUpRowsForPin === 0;
-  // Publish the pinned state to the streaming-tail estimator BEFORE resolving
-  // tailSig / the row-index memo this render, so max(measuredFloor, liveEstimate)
-  // applies while bottom-pinned (right geometry on first commit, no judder) and
-  // every tail-resolving path reads the same height (no sig/geometry divergence).
-  setStreamingBottomPinned(transcriptPinnedForStreaming);
+  const transcriptPinnedForStreaming = followingRef.current || scrolledUpRowsForPin === 0;
   const tailRows = streamingTailItem
     ? estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)
     : 0;
@@ -381,41 +411,6 @@ 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(
-      streamingTailItem ? [streamingTailItem] : transcriptItems,
-      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(transcriptItems, {
     scrollOffset: renderScrollOffset,
     viewportHeight: transcriptContentHeight,
@@ -447,12 +442,10 @@ export function useTranscriptWindow({
     for (let i = 0; i < mountedSlice.length; i++) {
       const it = mountedSlice[i];
       if (!it || shouldSuppressFullyFailedToolItem(it)) continue;
-      if (it.kind === 'assistant' && it.streaming) {
-        const idPrev = streamingMeasuredRowsById.get(it.id);
-        if (!idPrev || idPrev.columns !== frameColumns || idPrev.toolExpanded !== toolExpandedFlag) {
-          holdCommittedMax = true;
-          break;
-        }
+      if (it.kind === 'assistant') {
+        // Assistant rows are exact-model owned and never wait for a Yoga
+        // commit before their max scroll range becomes authoritative.
+        continue;
       } else {
         const prev = transcriptMeasuredRowsCache.get(it);
         if (!prev
@@ -580,14 +573,9 @@ export function useTranscriptWindow({
         if (transcriptMeasuredRowsCache.delete(item)) { changed = true; changedKeys.push(`${key}=del`); }
         continue;
       }
-      // Streaming assistant rows are now harvested too: their height churns
-      // every flush, but skipping them entirely meant the measured cache
-      // never observed live re-slice growth, so anchor-lock signatures
-      // (transcriptStructureSignature) could not react to it. Since streaming
-      // items are replaced per-token, their WeakMap entry is orphaned every
-      // frame; the id-keyed streamingMeasuredRowsById store (transcript-
-      // window.mjs) is written below to survive that swap. The drag guard
-      // above keeps this from fighting drag scroll.
+      // Active stream geometry is owned exclusively by the deterministic row
+      // model. Harvesting it here would create a second, post-commit geometry
+      // authority and reintroduce estimate→measure correction jitter.
       // Width 0 = Yoga has not laid this node out yet this frame; skip so a
       // transient 0 never poisons the cache (guard on a real positive width).
       if (typeof yoga.getComputedWidth === 'function' && yoga.getComputedWidth() <= 0) continue;
@@ -596,48 +584,14 @@ export function useTranscriptWindow({
         if (transcriptMeasuredRowsCache.delete(item)) { changed = true; changedKeys.push(`${key}=del`); }
         continue;
       }
-      const isStreamingAssistant = item.kind === 'assistant' && !!item.streaming;
+      if (item.kind === 'assistant') {
+        transcriptMeasuredRowsCache.delete(item);
+        continue;
+      }
       const measured = Math.max(1, rawMeasured);
       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) {
-          // 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-
-          // growth: no live-estimate blend), so it is the SOLE path that ever
-          // feeds this item's grown height into transcriptStructureSig /
-          // buildTranscriptRowIndex. Skipping the bump while bottom-pinned
-          // used to be safe because the blended estimate kept the signature
-          // moving on its own each flush; with the blend gone, skipping it
-          // here would freeze totalRows/prefixRows for this item until the
-          // stream settles — invisible growth for anything reading rowIndex
-          // (windowing, maxScrollRows, an anchor captured mid-stream).
-          changed = true;
-          changedKeys.push(`${key}=${measured}s`);
-        } else {
-          idPrev.estimateRows = estimateAtMeasure;
-        }
-      }
       const prev = transcriptMeasuredRowsCache.get(item);
-      if (!isStreamingAssistant && prev
+      if (prev
         && prev.rows === measured
         && prev.columns === frameColumns
         && prev.toolExpanded === toolExpandedFlag
@@ -650,19 +604,12 @@ export function useTranscriptWindow({
         toolExpanded: toolExpandedFlag,
         variantKey,
       });
-      if (!isStreamingAssistant) {
-        // First mount (no prior entry): this frame's row index already used the
-        // ESTIMATE for this item (measuredTranscriptRows returned null). If Yoga
-        // measured exactly what the estimate predicted, the geometry is already
-        // correct — bumping measuredRowsVersion would re-run the row-index/window
-        // memos for a no-op and repaint the card one frame later (the "settle"
-        // jump). Only bump when the measurement actually corrects the estimate.
-        // A CHANGED height (prev existed but differs) always bumps.
-        const estimateRows = prev
-          ? -1
-          : estimateTranscriptItemRowsCached(item, frameColumns, toolOutputExpanded);
-        if (prev || measured !== estimateRows) { changed = true; changedKeys.push(`${key}=${measured}`); }
-      }
+      // First mount (no prior entry): this frame's row index already used the
+      // estimate. Only bump when Yoga actually corrects it.
+      const estimateRows = prev
+        ? -1
+        : estimateTranscriptItemRowsCached(item, frameColumns, toolOutputExpanded);
+      if (prev || measured !== estimateRows) { changed = true; changedKeys.push(`${key}=${measured}`); }
     }
     if (changed) {
       // `changed` only flips true when a height actually differs from the
@@ -723,7 +670,10 @@ export function useTranscriptWindow({
     const currentPosition = Math.max(0, Number(scrollPositionRef.current) || 0);
     const currentOffset = Math.max(0, Number(scrollOffset) || 0);
     const maxRows = Math.max(0, Number(transcriptWindow.maxScrollRows) || 0);
-    const nearBottom = followingRef.current || currentTarget === 0;
+    // Follow ownership is explicit. target=0 can also mean the first manual
+    // read-back gesture is waiting for a newly mounted row measurement; never
+    // infer permission to chase the tail from the numeric offset alone.
+    const nearBottom = followingRef.current;
     const pinnedToBottom = nearBottom;
     // A genuine reading anchor must win over ordinary stream growth, but an
     // explicit follow arm (prompt submit / pinned bottom) must win over stale

package/src/tui/components/Markdown.jsx

@@ -88,14 +88,31 @@ const StableMarkdownChunk = React.memo(function StableMarkdownChunk({
   return <Markdown themeEpoch={themeEpoch} columns={columns}>{text}</Markdown>;
 });
 
-export function StreamingMarkdown({ children, themeEpoch = 0, columns, streamKey }) {
+export function StreamingMarkdown({
+  children,
+  themeEpoch = 0,
+  columns,
+  streamKey,
+  streaming = true,
+}) {
+  if (!streaming) {
+    return (
+      <Box flexDirection="column">
+        <Markdown themeEpoch={themeEpoch} columns={columns} trimPartialFences>{children}</Markdown>
+      </Box>
+    );
+  }
   const parts = resolveStreamingMarkdownParts(children, streamKey);
   if (parts.plain) {
     // Plain streaming text has no markdown tokens to style. Sending a growing
     // multi-line tail through renderTokenAnsiSegments/marked on every delta
     // reparses the whole response and dominates frame time; Ink can wrap the
     // identical visible text directly.
-    return <Text color={theme.text} wrap="wrap">{parts.unstableForRender}</Text>;
+    return (
+      <Box flexDirection="column">
+        <Text color={theme.text} wrap="wrap">{parts.unstableForRender}</Text>
+      </Box>
+    );
   }
   const stableChunks = parts.stableChunks?.length
     ? parts.stableChunks

package/src/tui/components/Message.jsx

@@ -58,9 +58,14 @@ export const AssistantMessage = React.memo(function AssistantMessage({
         <Text color={theme.text}>{TURN_MARKER}</Text>
       </Box>
       <Box flexDirection="column" flexShrink={0} width={bodyWidth}>
-        {streaming
-          ? <StreamingMarkdown themeEpoch={themeEpoch} columns={bodyWidth} streamKey={assistantId}>{renderText}</StreamingMarkdown>
-          : <Markdown themeEpoch={themeEpoch} columns={bodyWidth}>{text}</Markdown>}
+        <StreamingMarkdown
+          themeEpoch={themeEpoch}
+          columns={bodyWidth}
+          streamKey={assistantId}
+          streaming={streaming}
+        >
+          {streaming ? renderText : text}
+        </StreamingMarkdown>
       </Box>
     </Box>
   );

package/src/tui/components/ToolExecution.jsx

@@ -368,17 +368,21 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const trailingColor = expandHintColor;
   let labelOut;
   let summaryOut;
+  // Shell headers stay label-only ("Ran 1 command") on every surface —
+  // opencode parity and the desktop card contract: the raw command line never
+  // rides inline in the header; it stays in the expanded detail body.
+  const headerSummaryText = isShellSurface ? '' : summaryText;
   if (stringWidth(labelText) >= avail) {
     labelOut = truncateToWidth(labelText, avail);
     summaryOut = '';
   } else {
     labelOut = labelText;
-    const summaryBudget = avail - stringWidth(labelText) - (summaryText ? stringWidth(' ()') : 0);
+    const summaryBudget = avail - stringWidth(labelText) - (headerSummaryText ? stringWidth(' ()') : 0);
     // Cap by both the remaining header width and a fixed max so long
     // paths/queries get an ellipsis instead of dominating the line.
     const summaryWidth = Math.max(0, Math.min(summaryBudget, SUMMARY_MAX_CHARS));
-    const truncatedSummary = summaryText && summaryWidth > 0
-      ? truncateToWidth(summaryText, summaryWidth)
+    const truncatedSummary = headerSummaryText && summaryWidth > 0
+      ? truncateToWidth(headerSummaryText, summaryWidth)
       : '';
     summaryOut = truncatedSummary ? ` (${truncatedSummary})` : '';
   }