mixdog 0.9.17 → 0.9.18

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

@@ -19,6 +19,7 @@ import {
   buildTranscriptRowIndexIncremental,
   transcriptStructureSignature,
   estimateTranscriptItemRowsCached,
+  setStreamingBottomPinned,
   transcriptRenderWindow,
   resolveAnchorScrollOffset,
   upperBound,
@@ -148,6 +149,14 @@ export function useTranscriptWindow({
     ),
     [items, streamingTailItem, prefixLen, frameColumns, toolOutputExpanded],
   );
+  const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
+  const transcriptPinnedForStreaming = followingRef.current
+    || scrolledUpRowsForPin <= transcriptBottomSlackRows;
+  // 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 tailSig = streamingTailItem
     ? `a${streamingTailItem.id}:${estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)}`
     : '_';
@@ -155,9 +164,6 @@ export function useTranscriptWindow({
   const transcriptStreamingActive = (items || []).some(
     (item) => item?.kind === 'assistant' && item?.streaming,
   );
-  const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
-  const transcriptPinnedForStreaming = followingRef.current
-    || scrolledUpRowsForPin <= transcriptBottomSlackRows;
   const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > transcriptBottomSlackRows;
   const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
   const hasStreamingReadingAnchor = !!transcriptAnchorRef.current

package/src/tui/dist/index.mjs

@@ -11100,6 +11100,10 @@ function measuredTranscriptRows(item, columns, toolOutputExpanded) {
   return entry.rows;
 }
 var STREAMING_ROW_QUANTUM = 1;
+var streamingBottomPinned = false;
+function setStreamingBottomPinned(pinned) {
+  streamingBottomPinned = !!pinned;
+}
 function assistantTextForStreamingRowEstimate(text) {
   return streamingLayoutText(text);
 }
@@ -11116,6 +11120,9 @@ function estimateTranscriptItemRowsCached(item, columns, toolOutputExpanded) {
     const toolExpanded2 = toolOutputExpanded ? 1 : 0;
     const idEntry = streamingMeasuredRowsById.get(item.id);
     if (idEntry && idEntry.rows > 0 && idEntry.columns === columns && idEntry.toolExpanded === toolExpanded2) {
+      if (streamingBottomPinned) {
+        return Math.max(idEntry.rows, streamingEstimateRows(item, columns, toolOutputExpanded));
+      }
       return idEntry.rows;
     }
     if (idEntry) streamingMeasuredRowsById.delete(item.id);
@@ -12081,13 +12088,14 @@ function useTranscriptWindow({
     ),
     [items, streamingTailItem, prefixLen, frameColumns, toolOutputExpanded]
   );
+  const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
+  const transcriptPinnedForStreaming = followingRef.current || scrolledUpRowsForPin <= transcriptBottomSlackRows;
+  setStreamingBottomPinned(transcriptPinnedForStreaming);
   const tailSig = streamingTailItem ? `a${streamingTailItem.id}:${estimateTranscriptItemRowsCached(streamingTailItem, frameColumns, toolOutputExpanded)}` : "_";
   const transcriptStructureSig = `${prefixSig}#${tailSig}`;
   const transcriptStreamingActive = (items || []).some(
     (item) => item?.kind === "assistant" && item?.streaming
   );
-  const scrolledUpRowsForPin = Math.max(0, Number(scrollTargetRef.current) || 0);
-  const transcriptPinnedForStreaming = followingRef.current || scrolledUpRowsForPin <= transcriptBottomSlackRows;
   const scrolledUpForStreamingMeasure = scrolledUpRowsForPin > transcriptBottomSlackRows;
   const prevEstimateGeometry = transcriptGeomRef.current?.suppressMeasuredRowHeights === true;
   const hasStreamingReadingAnchor = !!transcriptAnchorRef.current || transcriptAnchorDirtyRef.current;
@@ -23054,13 +23062,20 @@ async function createEngineSession({
         seq: deferredSeqCounter++,
         pushed: false,
         timer: null,
-        push: () => {
+        // Mark the card visible and return its spec WITHOUT emitting, so a
+        // batched turn-close flush can commit many specs in one set().
+        materialize: () => {
           card.pushed = true;
-          if (!card.spec) return;
+          if (!card.spec) return null;
           card.spec.deferredDisplayReady = true;
+          return card.spec;
+        },
+        push: () => {
+          const spec = entry.materialize();
+          if (!spec) return;
           pushingFromDeferredEntry = true;
           try {
-            pushItem(card.spec);
+            pushItem(spec);
           } finally {
             pushingFromDeferredEntry = false;
           }
@@ -23081,13 +23096,18 @@ async function createEngineSession({
         seq: deferredSeqCounter++,
         pushed: false,
         timer: null,
-        push: () => {
+        materialize: () => {
           aggregate.pushed = true;
-          if (!aggregate.pendingSpec) return;
+          if (!aggregate.pendingSpec) return null;
           aggregate.pendingSpec.deferredDisplayReady = true;
+          return aggregate.pendingSpec;
+        },
+        push: () => {
+          const spec = entry.materialize();
+          if (!spec) return;
           pushingFromDeferredEntry = true;
           try {
-            pushItem(aggregate.pendingSpec);
+            pushItem(spec);
           } finally {
             pushingFromDeferredEntry = false;
           }
@@ -23111,6 +23131,35 @@ async function createEngineSession({
         }
       }
     };
+    const collectDeferredUpTo = (entry) => {
+      const specs = [];
+      if (!entry) return specs;
+      for (const e of deferredEntries) {
+        if (e.seq > entry.seq) break;
+        if (e.pushed) continue;
+        e.pushed = true;
+        if (e.timer) {
+          clearTimeout(e.timer);
+          e.timer = null;
+        }
+        const spec = e.materialize?.();
+        if (spec) specs.push(spec);
+      }
+      return specs;
+    };
+    const appendItemsBatch = (newItems, extra = {}) => {
+      if (!newItems || !newItems.length) {
+        set(extra);
+        return;
+      }
+      const base = state.items.length;
+      const items = [...state.items, ...newItems];
+      for (let i = 0; i < newItems.length; i++) {
+        const it = newItems[i];
+        if (it?.id != null) itemIndexById.set(it.id, base + i);
+      }
+      set({ items, ...extra });
+    };
     const markPromptCommitted = () => {
       if (activePromptRestore) {
         if (!promptCommittedCallbackCalled && typeof activePromptRestore.onCommitted === "function") {
@@ -23613,13 +23662,14 @@ async function createEngineSession({
       denyAllToolApprovals(cancelled ? "turn cancelled" : "turn finished");
       clearWatchdog();
       const isStaleUnwind = leadTurnEpoch !== turnEpoch;
+      let closingItems = [];
       if (deferredEntries.length) {
         const last = deferredEntries[deferredEntries.length - 1];
-        if (last) flushDeferredUpTo(last);
+        closingItems = collectDeferredUpTo(last);
         clearDeferredTimers();
       }
       flushDeferredBeforeImmediatePush = null;
-      const producedTranscriptItem = state.items.length > itemsAtTurnStart;
+      const producedTranscriptItem = state.items.length + closingItems.length > itemsAtTurnStart;
       const reclaimed = cancelled && activePromptRestore?.reclaimed === true;
       if (!isStaleUnwind) activePromptRestore = null;
       closeThinkingSegment();
@@ -23633,15 +23683,16 @@ async function createEngineSession({
       const assistantOutput = (currentAssistantText || assistantText || "").trim();
       const isNoOpTurn = turnFinishedNormally && !cancelled && toolCards.length === 0 && !resultContent && !assistantOutput && !producedTranscriptItem;
       if (isStaleUnwind) {
+        if (closingItems.length) appendItemsBatch(closingItems);
         tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} \u2014 force-released; skipping shared-state writes`);
       } else {
         if (!isNoOpTurn) {
           state.stats.turns = (state.stats.turns || 0) + 1;
         }
         if (!reclaimed && !isNoOpTurn) {
-          pushItem({ kind: "turndone", id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
+          closingItems.push({ kind: "turndone", id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
         }
-        set({
+        appendItemsBatch(closingItems, {
           busy: false,
           spinner: null,
           thinking: null,

package/src/tui/engine.mjs

@@ -775,12 +775,19 @@ export async function createEngineSession({
         seq: deferredSeqCounter++,
         pushed: false,
         timer: null,
-        push: () => {
+        // Mark the card visible and return its spec WITHOUT emitting, so a
+        // batched turn-close flush can commit many specs in one set().
+        materialize: () => {
           card.pushed = true;
-          if (!card.spec) return;
+          if (!card.spec) return null;
           card.spec.deferredDisplayReady = true;
+          return card.spec;
+        },
+        push: () => {
+          const spec = entry.materialize();
+          if (!spec) return;
           pushingFromDeferredEntry = true;
-          try { pushItem(card.spec); } finally { pushingFromDeferredEntry = false; }
+          try { pushItem(spec); } finally { pushingFromDeferredEntry = false; }
         },
       };
       card.deferred = entry;
@@ -798,12 +805,17 @@ export async function createEngineSession({
         seq: deferredSeqCounter++,
         pushed: false,
         timer: null,
-        push: () => {
+        materialize: () => {
           aggregate.pushed = true;
-          if (!aggregate.pendingSpec) return;
+          if (!aggregate.pendingSpec) return null;
           aggregate.pendingSpec.deferredDisplayReady = true;
+          return aggregate.pendingSpec;
+        },
+        push: () => {
+          const spec = entry.materialize();
+          if (!spec) return;
           pushingFromDeferredEntry = true;
-          try { pushItem(aggregate.pendingSpec); } finally { pushingFromDeferredEntry = false; }
+          try { pushItem(spec); } finally { pushingFromDeferredEntry = false; }
         },
       };
       aggregate.deferred = entry;
@@ -821,6 +833,35 @@ export async function createEngineSession({
         if (e.timer) { clearTimeout(e.timer); e.timer = null; }
       }
     };
+    // Collect (mark pushed + cancel timers) every still-deferred entry up to
+    // `entry` in creation order, returning their specs WITHOUT emitting — the
+    // caller commits them (optionally alongside a trailing turndone item) in a
+    // single set() so turn-close writes land as ONE visible commit.
+    const collectDeferredUpTo = (entry) => {
+      const specs = [];
+      if (!entry) return specs;
+      for (const e of deferredEntries) {
+        if (e.seq > entry.seq) break;
+        if (e.pushed) continue;
+        e.pushed = true;
+        if (e.timer) { clearTimeout(e.timer); e.timer = null; }
+        const spec = e.materialize?.();
+        if (spec) specs.push(spec);
+      }
+      return specs;
+    };
+    // Append pre-built items (deferred cards + turndone) in ONE set(). None are
+    // 'user' kind, so no promptHistory rebuild is needed.
+    const appendItemsBatch = (newItems, extra = {}) => {
+      if (!newItems || !newItems.length) { set(extra); return; }
+      const base = state.items.length;
+      const items = [...state.items, ...newItems];
+      for (let i = 0; i < newItems.length; i++) {
+        const it = newItems[i];
+        if (it?.id != null) itemIndexById.set(it.id, base + i);
+      }
+      set({ items, ...extra });
+    };
 
     const markPromptCommitted = () => {
       if (activePromptRestore) {
@@ -1542,13 +1583,18 @@ export async function createEngineSession({
       // pending push timers so nothing fires (or leaks) after the turn ends. The
       // finalize path above already patches results onto visible cards; this just
       // guarantees every registered card is materialized before the turn closes.
+      // Collect (don't emit) the still-deferred cards so the turn-close flush and
+      // the turndone item append in ONE set() below instead of one render bounce
+      // per row. Order/ids are preserved (creation order, then turndone last).
+      let closingItems = [];
       if (deferredEntries.length) {
         const last = deferredEntries[deferredEntries.length - 1];
-        if (last) flushDeferredUpTo(last);
+        closingItems = collectDeferredUpTo(last);
         clearDeferredTimers();
       }
       flushDeferredBeforeImmediatePush = null;
-      const producedTranscriptItem = state.items.length > itemsAtTurnStart;
+      const producedTranscriptItem =
+        state.items.length + closingItems.length > itemsAtTurnStart;
       const reclaimed = cancelled && activePromptRestore?.reclaimed === true;
       if (!isStaleUnwind) activePromptRestore = null;
       closeThinkingSegment();
@@ -1574,6 +1620,9 @@ export async function createEngineSession({
         && !assistantOutput
         && !producedTranscriptItem;
       if (isStaleUnwind) {
+        // Preserve prior behavior: a stale unwind still materializes its own
+        // deferred cards (turn-local teardown) but writes no other shared state.
+        if (closingItems.length) appendItemsBatch(closingItems);
         tuiDebug(`runTurn STALE UNWIND turn=${turnIndex} — force-released; skipping shared-state writes`);
       } else {
       if (!isNoOpTurn) {
@@ -1584,9 +1633,10 @@ export async function createEngineSession({
       // in scrollback. (Previously TurnDone rendered only in the
       // bottom-fixed live-status slot and vanished on the next turn.)
       if (!reclaimed && !isNoOpTurn) {
-        pushItem({ kind: 'turndone', id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
+        closingItems.push({ kind: 'turndone', id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
       }
-      set({
+      // Deferred cards + turndone + status all land in ONE set() (one commit).
+      appendItemsBatch(closingItems, {
         busy: false,
         spinner: null,
         thinking: null,