mixdog 0.9.87 → 0.9.89

package/src/standalone/channel-daemon.mjs

@@ -15,6 +15,14 @@
 process.env.MIXDOG_CHANNEL_DAEMON = '1';
 process.env.MIXDOG_WORKER_MODE = process.env.MIXDOG_WORKER_MODE || '1';
 
+// V8 compile cache: the daemon is a standalone child entry (not via cli.mjs);
+// caching compiled bytecode across restarts removes the channels+memory
+// runtime parse cost from every daemon boot. Best-effort.
+try {
+  const { enableCompileCache } = await import('node:module');
+  enableCompileCache?.();
+} catch { /* launch-speed optimization only */ }
+
 import os from 'node:os';
 import path from 'node:path';
 import { mkdirSync, appendFileSync } from 'node:fs';

package/src/standalone/explore-tool.mjs

@@ -18,7 +18,7 @@ export const EXPLORE_TOOL = {
   name: 'explore',
   title: 'Explore',
   annotations: { title: 'Explore', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-  description: 'Locator for broad/uncertain targets with no known path, repo or machine-wide (dot dirs included). Array = independent targets: query[] fans out facets (max 8), never rephrasings. Every returned path:line freezes the LOCATION only; read/code_graph detail inspection is valid when content was not returned; never re-locate it — search only unresolved facets.',
+  description: 'Locator for broad/uncertain targets with no known path, repo or machine-wide (dot dirs included). Array = independent targets: query[] fans out facets (max 8), never rephrasings.',
   inputSchema: {
     type: 'object',
     properties: {

package/src/standalone/memory-runtime-proxy.mjs

@@ -446,13 +446,10 @@ export function createStandaloneMemoryRuntime({
           MIXDOG_OWNER_LEAD_PID: String(process.pid),
           MIXDOG_MEMORY_SECONDARY: '0',
           MIXDOG_PG_ATTACH_ONLY: '0',
-          // seeds.mjs defaults MIXDOG_EMBED_WARMUP to '0' for the HOST process
-          // (TUI boot must not pay the ONNX session-create cost). The daemon is
-          // the long-lived embed owner, so warmup is force-enabled here like the
-          // secondary/attach flags above — otherwise the daemon boots cold and
-          // every recall runs lexical-only until the first fallback flush
-          // lazily loads the model (observed 1.5h '(no results)' windows).
-          MIXDOG_EMBED_WARMUP: '1',
+          // The daemon owns the model, but ownership does not imply eager
+          // residency. A recall starts warmup on demand and immediately uses
+          // lexical search while it loads, keeping desktop/TUI boot lightweight.
+          MIXDOG_EMBED_WARMUP: process.env.MIXDOG_EMBED_WARMUP ?? '0',
           MIXDOG_MEMORY_DISABLE_CYCLES: process.env.MIXDOG_MEMORY_DISABLE_CYCLES ?? '0',
           MIXDOG_MEMORY_DISABLE_LLM_WORKER: process.env.MIXDOG_MEMORY_DISABLE_LLM_WORKER ?? '0',
           MIXDOG_QUIET_SESSION_LOG: process.env.MIXDOG_QUIET_SESSION_LOG ?? '1',

package/src/standalone/projects.mjs

@@ -12,7 +12,9 @@ import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSyn
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 
 const MIXDOG_HOME = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
-const PROJECTS_FILE = join(MIXDOG_HOME, 'projects.json');
+const PROJECTS_FILE = process.env.MIXDOG_PROJECTS_FILE
+  ? resolve(process.env.MIXDOG_PROJECTS_FILE)
+  : join(MIXDOG_HOME, 'projects.json');
 
 /** Resolve a raw path to an absolute path against the user's cwd. */
 function toAbsolute(rawPath) {
@@ -76,6 +78,7 @@ function writeStore(store) {
  */
 function ensureProjectIdMarker(absPath, name) {
   try {
+    if (process.env.MIXDOG_DISABLE_PROJECT_MARKERS === '1') return;
     if (!absPath) return;
     // Only when the project folder actually exists as a directory on disk.
     try {

package/src/standalone/usage-dashboard.mjs

@@ -88,9 +88,25 @@ function normaliseResetCredits(value) {
   const offerRevision = clean(value.offerRevision ?? value.offer_revision);
   if (availableCount === null || !offerRevision) return null;
   const nextExpiresAt = num(value.nextExpiresAt ?? value.next_expires_at, null);
+  const rawAvailableCredits = value.availableCredits ?? value.available_credits;
+  const availableCredits = (Array.isArray(rawAvailableCredits) ? rawAvailableCredits : [])
+    .map((credit) => {
+      if (!credit || typeof credit !== 'object' || Array.isArray(credit)) return null;
+      const expiresAt = num(credit.expiresAt ?? credit.expires_at, null);
+      const grantedAt = num(credit.grantedAt ?? credit.granted_at, null);
+      return {
+        ...(expiresAt && expiresAt > 0 ? { expiresAt } : {}),
+        ...(grantedAt && grantedAt > 0 ? { grantedAt } : {}),
+      };
+    })
+    .filter(Boolean)
+    .sort((left, right) =>
+      (left.expiresAt ?? Number.POSITIVE_INFINITY)
+      - (right.expiresAt ?? Number.POSITIVE_INFINITY));
   return {
     availableCount: Math.max(0, Math.floor(availableCount)),
     offerRevision,
+    availableCredits,
     ...(nextExpiresAt && nextExpiresAt > 0 ? { nextExpiresAt } : {}),
   };
 }
@@ -234,22 +250,28 @@ function rowTone(row) {
 async function oauthSnapshot(providerId, { refresh, getProvider, log }) {
   const cached = readCachedOAuthUsageSnapshot({ provider: providerId, model: '' });
   if (!refresh && cached) return cached;
+  // A rate-limited or failed forced refresh (Anthropic /oauth/usage 429s
+  // aggressively) must not blank a known quota row: fall back to the last
+  // contentful snapshot — a stale meter with its updatedAt beats an empty row.
+  const staleFallback = () => cached
+    || readCachedOAuthUsageSnapshot({ provider: providerId, model: '' }, { allowStale: true });
   if (typeof getProvider === 'function') {
     try {
       const providerObj = getProvider(providerId);
       if (providerObj) {
-        return await fetchOAuthUsageSnapshot(
+        const fresh = await fetchOAuthUsageSnapshot(
           { provider: providerId, model: '' },
           providerObj,
           log,
           { force: refresh === true },
         );
+        return fresh || staleFallback();
       }
     } catch {
-      return null;
+      return staleFallback();
     }
   }
-  return cached;
+  return staleFallback();
 }
 
 async function apiSnapshot(providerId, { refresh } = {}) {

package/src/tui/App.jsx

@@ -764,8 +764,10 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   });
 
 
-  // Item-count changes are the only time we can arm follow before row totals are
-  // recomputed. Pure streaming height growth is handled in the row-delta effect.
+  // 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.
   useLayoutEffect(() => {
     const count = state.items.length;
     const previousCount = lastItemsCountRef.current;
@@ -775,7 +777,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
       return;
     }
     if (count === previousCount || dragRef.current.active) return;
-    if (scrollTargetRef.current === 0 || followingRef.current) followingRef.current = true;
   }, [state.items.length, resetTranscriptScroll]);
 
   // Exit + queued-restore + prompt history: app/use-prompt-queue-history.mjs.
@@ -1139,6 +1140,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     structureRevision: state.transcriptViewItems
       ? state.transcriptViewRevision
       : state.structureRevision,
+    sessionKey: state.sessionId || '',
     // Historical pages are contiguous settled windows. Keep the independently
     // growing live tail hidden until paging forward reaches the live window.
     streamingTail: state.transcriptViewItems ? null : state.streamingTail,

package/src/tui/app/resume-picker.mjs

@@ -31,11 +31,12 @@ export function createResumePicker({
     }
     const items = sessions.map((s) => {
       const preview = String(s.preview || '').replace(/\n/g, ' ').trim();
+      const title = String(s.title || '').replace(/\s+/g, ' ').trim();
       const count = formatSessionMessageCount(s.messageCount);
       return {
         value: s.id,
         label: `${formatSessionUpdatedAt(s.updatedAt)}  ${count}`,
-        description: preview || '(no message)',
+        description: title || preview || '(no message)',
       };
     });
     setPicker({
@@ -45,8 +46,12 @@ export function createResumePicker({
       labelWidth: 21,
       onSelect: (value) => {
         setPicker(null);
+        const selected = sessions.find((session) => session.id === value);
+        const resumedName = String(selected?.title || selected?.preview || value)
+          .replace(/\s+/g, ' ')
+          .trim();
         void store.resume(value)
-          .then(ok => store.pushNotice(ok ? `Resumed ${value}` : 'Couldn’t resume chat.', ok ? 'info' : 'warn'))
+          .then(ok => store.pushNotice(ok ? `Resumed ${resumedName || value}` : 'Couldn’t resume chat.', ok ? 'info' : 'warn'))
           .catch((e) => store.pushNotice(`Couldn’t resume chat: ${e?.message || e}`, 'error'));
       },
       onCancel: () => {

package/src/tui/app/route-pickers.mjs

@@ -157,134 +157,28 @@ export function createRoutePickers({
     closeUsagePanel();
     setPicker({
       title: 'Workflow',
-      description: 'Active workflow and its agents.',
-      help: returnTo ? '↑/↓ Select · Enter Open · Esc Settings' : '↑/↓ Select · Enter Open · Esc Back',
+      description: 'Select active workflow.',
+      help: returnTo ? '↑/↓ Select · Enter Choose · Esc Settings' : '↑/↓ Select · Enter Choose · Esc Back',
       labelWidth: 18,
-      initialIndex: Math.max(0, items.findIndex((item) => item.value === (options.initialWorkflowId || ''))),
       items,
       onSelect: (_value, item) => {
         const workflow = item?._workflow;
         if (!workflow) return;
-        // Depth mirrors the system model: a workflow pack owns the agent set
-        // it delegates to, so Enter opens the pack (activate + its agents)
-        // instead of switching immediately.
-        openWorkflowDetailPicker(workflow.id, { returnTo });
-      },
-      onCancel: () => {
         setPicker(null);
-        if (returnTo) returnTo();
-      },
-    });
-  };
-
-  // Workflow detail: activation row plus the agents this pack delegates to
-  // (route editing inline). Packs without an `agents:` key delegate to all
-  // fixed agents; a configured-but-empty list means Lead works alone.
-  const openWorkflowDetailPicker = (workflowId, options = {}) => {
-    const returnTo = typeof options.returnTo === 'function' ? options.returnTo : null;
-    let workflows = [];
-    try {
-      workflows = store.listWorkflows?.() || [];
-    } catch (e) {
-      store.pushNotice(`could not list workflows: ${e?.message || e}`, 'error');
-      return;
-    }
-    const workflow = workflows.find((item) => item.id === workflowId);
-    if (!workflow) {
-      store.pushNotice(`workflow "${workflowId}" not found`, 'warn');
-      openWorkflowPicker({ returnTo });
-      return;
-    }
-    let agents = [];
-    try {
-      agents = store.listAgents?.() || [];
-    } catch (e) {
-      store.pushNotice(`could not list agents: ${e?.message || e}`, 'error');
-      agents = [];
-    }
-    const packAgents = workflow.agentsConfigured === true
-      ? (workflow.agents || [])
-          .map((id) => agents.find((agent) => agent.id === id) || { id, label: id, route: null, description: '' })
-      : agents.filter((agent) => agent.custom !== true);
-    const routeOverrides = options.routeOverrides && typeof options.routeOverrides === 'object' ? options.routeOverrides : {};
-    const items = [
-      {
-        value: '__activate',
-        label: workflow.active ? 'Active' : 'Activate',
-        marker: workflow.active ? '✓' : '',
-        markerColor: theme.success,
-        description: workflow.active
-          ? 'This workflow is active.'
-          : 'Make this the active workflow.',
-      },
-      ...(packAgents.length
-        ? packAgents.map((agent) => ({
-            value: agent.id,
-            label: agent.label,
-            metaParts: agentModelParts(routeOverrides[agent.id] || agent.route),
-            description: agent.description || agent.definition?.description || '',
-            _agent: agent,
-          }))
-        : [{
-            value: '__lead-only',
-            label: 'Lead only',
-            description: 'This workflow delegates to no agents.',
-          }]),
-    ];
-    setPicker({
-      title: workflow.name,
-      description: workflow.description || 'Workflow activation and agents.',
-      help: '↑/↓ Select · Enter Choose · Esc Back',
-      indexMode: 'always',
-      labelWidth: 18,
-      metaWidth: 33,
-      initialIndex: Math.max(0, items.findIndex((item) => item.value === (options.initialValue || '__activate'))),
-      items,
-      onSelect: (_value, item) => {
-        if (item?.value === '__activate') {
-          if (workflow.active) {
-            store.pushNotice(`${workflow.name} is already the active workflow`, 'info');
-            return;
-          }
-          setPicker(null);
-          void store.setWorkflow?.(workflow.id)
-            .then((result) => {
-              if (!result) {
-                store.pushNotice('Workflow switch is already running.', 'warn');
-                return;
-              }
-              store.pushNotice(workflowSwitchNotice(result), 'info');
-              openWorkflowPicker({ returnTo, initialWorkflowId: workflow.id });
-            })
-            .catch((e) => store.pushNotice(`Couldn’t switch workflow: ${e?.message || e}`, 'error'));
-          return;
-        }
-        const agent = item?._agent;
-        if (!agent) return;
-        void openModelPicker({
-          title: `${agent.label} Model`,
-          providerDescription: 'Choose a provider for this agent.',
-          currentRoute: agent.route || null,
-          returnTo: () => openWorkflowDetailPicker(workflow.id, { returnTo, initialValue: agent.id }),
-          onImmediateSelect: (routeInput) => {
-            openWorkflowDetailPicker(workflow.id, {
-              returnTo,
-              routeOverrides: { [agent.id]: routeInput },
-              initialValue: agent.id,
-            });
-          },
-          onSelectRoute: async (routeInput) => {
-            const result = await store.setAgentRoute?.(agent.id, routeInput);
+        void store.setWorkflow?.(workflow.id)
+          .then((result) => {
             if (!result) {
-              store.pushNotice('Agent model save is already running.', 'warn');
+              store.pushNotice('Workflow switch is already running.', 'warn');
               return;
             }
-            store.pushNotice(`${agent.label} model set to ${agentModelProfile(result)}`, 'info');
-          },
-        });
+            store.pushNotice(workflowSwitchNotice(result), 'info');
+            if (returnTo) returnTo();
+          })
+          .catch((e) => store.pushNotice(`Couldn’t switch workflow: ${e?.message || e}`, 'error'));
       },
       onCancel: () => {
-        openWorkflowPicker({ returnTo, initialWorkflowId: workflow.id });
+        setPicker(null);
+        if (returnTo) returnTo();
       },
     });
   };

package/src/tui/app/slash-dispatch.mjs

@@ -63,12 +63,22 @@ export function createSlashDispatch({
     if (cmd !== 'usage') closeUsagePanel();
     switch (cmd) {
       case 'clear':
-        if (state.busy) {
-          store.pushNotice('wait for the current turn to finish before /clear', 'warn');
+        if (state.busy || state.commandBusy) {
+          store.pushNotice(`wait for the current session command to finish before /${rawName === 'new' ? 'new' : 'clear'}`, 'warn');
           return false;
         }
         if (rawName === 'new') {
-          void store.newSession().then(() => {}).catch((e) => store.pushNotice(`new session failed: ${e?.message || e}`, 'error'));
+          void store.newSession()
+            .then((created) => {
+              if (created === false) {
+                store.pushNotice('new session is already running', 'warn');
+                return;
+              }
+              // Incremental Ink rendering can otherwise retain physical rows
+              // from the taller outgoing transcript on Windows Terminal.
+              store.forceRenderRepaint?.();
+            })
+            .catch((e) => store.pushNotice(`new session failed: ${e?.message || e}`, 'error'));
         } else {
           void store.clear().then(() => {}).catch((e) => store.pushNotice(`clear failed: ${e?.message || e}`, 'error'));
         }

package/src/tui/app/transcript-row-estimate.mjs

@@ -272,7 +272,7 @@ export function estimateTranscriptItemRows(item, columns, toolOutputExpanded, at
       // marginTop={1} (AssistantMessage <Box>) + rendered body height.
       return 1 + (item.streaming
         ? measureStreamingMarkdownRenderedRows(item.text, columns, item.id)
-        : measureMarkdownRenderedRows(item.text, columns));
+        : measureMarkdownRenderedRows(item.text, columns, { trimPartialFences: true }));
     case 'tool': {
       // Consecutive tool cards render attached (marginTop 0) — see
       // TranscriptItem's attached={prevKind === 'tool'}.

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

@@ -354,12 +354,12 @@ export function carryTranscriptMeasuredRowsCache(prevItem, nextItem) {
 export function measuredTranscriptRows(item, columns, toolOutputExpanded) {
   if (!TRANSCRIPT_MEASURED_ROWS || !item) return null;
   if (shouldSuppressFullyFailedToolItemCached(item)) return 0;
-  // Streaming height flows ONLY through estimateTranscriptItemRowsCached's
-  // max(idStore, estimate) path — never straight from the WeakMap here, or
-  // buildTranscriptRowIndex (which calls this first) and the sigPart (which
-  // calls estimateTranscriptItemRowsCached) could resolve different values
-  // for the same streaming item and diverge.
-  if (item.kind === 'assistant' && item.streaming) return null;
+  // Assistant Markdown has an exact deterministic renderer measurement for
+  // both streaming and settled states. Never mix Yoga's mounted-window height
+  // back into that model: a fenced script whose measured height alternated as
+  // the window corrected itself could otherwise trigger up to ten idle
+  // measure→reindex commits with no text change.
+  if (item.kind === 'assistant') return null;
   const entry = transcriptMeasuredRowsCache.get(item);
   if (!entry) return null;
   if (entry.rows <= 0) return null;
@@ -371,17 +371,6 @@ export function measuredTranscriptRows(item, columns, toolOutputExpanded) {
 
 const STREAMING_ROW_QUANTUM = 1;
 
-// Bottom-pinned flag for the streaming-tail row estimate. Set once per hook
-// render (use-transcript-window.mjs) BEFORE any tail resolution so every path
-// that resolves the streaming tail height (tailSig, buildTranscriptRowIndex,
-// incremental tail, transcriptStructureSignature) reads the same value and
-// cannot diverge. Bottom-pinned → fold the live estimate in (geometry right on
-// the first commit); away from bottom → d19cad1e defer-growth.
-let streamingBottomPinned = false;
-export function setStreamingBottomPinned(pinned) {
-  streamingBottomPinned = !!pinned;
-}
-
 function assistantTextForStreamingRowEstimate(text) {
   return streamingLayoutText(text);
 }
@@ -438,49 +427,6 @@ export function streamingEstimateRows(item, columns, toolOutputExpanded) {
   return rows;
 }
 
-// ── Same-frame streaming-tail growth compensation (scrolled-up only) ────────
-// Away from bottom, estimateTranscriptItemRowsCached freezes the trailing
-// streaming item at its last Yoga-confirmed height (defer-growth), so the row
-// index / totalRows this render still counts the OLD height even though the
-// mounted Box lays out at the live-grown height NOW. That one-frame mismatch is
-// the newline judder: the physical content grew but the scroll offset did not,
-// so the visible window shifts up until measuredRowsVersion bumps next frame.
-// Report how many rows the mounted tail has grown beyond the height the row
-// index used so the caller can fold it into the scroll offset for the SAME
-// render. Returns { tailRows, delta }:
-//   tailRows — the height the row index used for the tail (for the in-slice gate)
-//   delta    — live-estimate rows grown beyond that (0 when nothing to correct)
-// Returns null when the tail is not a deferred streaming item (no confirmed
-// measurement yet → the index already used the live estimate, so no mismatch).
-export function streamingTailMountedGrowth(items, columns, toolOutputExpanded) {
-  const list = Array.isArray(items) ? items : [];
-  const tail = list.length > 0 ? list[list.length - 1] : null;
-  if (!tail || tail.kind !== 'assistant' || !tail.streaming) return null;
-  const toolExpanded = toolOutputExpanded ? 1 : 0;
-  const idEntry = streamingMeasuredRowsById.get(tail.id);
-  if (!idEntry || !(idEntry.rows > 0) || idEntry.columns !== columns || idEntry.toolExpanded !== toolExpanded) {
-    return null;
-  }
-  const live = streamingEstimateRows(tail, columns, toolOutputExpanded);
-  // Bottom-pinned already folds the live estimate into the row index, so there
-  // is nothing to compensate (delta 0); the caller also only invokes this while
-  // scrolled up, so this is a belt-and-suspenders guard.
-  if (streamingBottomPinned) return { tailRows: Math.max(idEntry.rows, live), delta: 0 };
-  // Away from bottom the row index used the real Yoga height (idEntry.rows). The
-  // physical mismatch to compensate is real_now − real_measured, but `live` (an
-  // estimate) vs idEntry.rows (measured) also carries the estimator's steady
-  // bias, which would keep delta positive AFTER measuredRowsVersion has already
-  // absorbed the real height — permanent over-compensation. Measure growth in
-  // the SAME (estimate) metric instead: delta = live_now − estimateAtMeasure,
-  // where estimateAtMeasure is the estimate for the exact text that was
-  // measured. The estimator bias cancels, so an unchanged tail gives delta 0
-  // (nothing left for the index to consume) and only genuine text growth since
-  // the last measurement compensates.
-  const baseline = idEntry.estimateRows > 0 ? idEntry.estimateRows : idEntry.rows;
-  const delta = Math.max(0, live - baseline);
-  return { tailRows: idEntry.rows, delta };
-}
-
 // Identity-keyed memo, same contract as transcriptVariantKeyCache: transcript
 // items are replaced (never mutated) when their content changes, so the
 // suppress decision — which re-parses tool args via isFullyFailedToolBatch —
@@ -499,41 +445,14 @@ export function estimateTranscriptItemRowsCached(item, columns, toolOutputExpand
   if (!item) return Math.max(1, Math.ceil(estimateTranscriptItemRows(item, columns, toolOutputExpanded)));
   if (shouldSuppressFullyFailedToolItemCached(item)) return 0;
   if (item.kind === 'assistant' && item.streaming) {
-    const toolExpanded = toolOutputExpanded ? 1 : 0;
-    const idEntry = streamingMeasuredRowsById.get(item.id);
-    if (idEntry && idEntry.rows > 0 && idEntry.columns === columns && idEntry.toolExpanded === toolExpanded) {
-      if (streamingBottomPinned) {
-        // Bottom-pinned: the view follows the tail, so its geometry must be
-        // correct on the FIRST commit. Fold the freshly-grown live estimate in
-        // — max(measuredFloor, liveEstimate) — so totalRows/scrollOffset are
-        // right this frame instead of committing the stale measured floor and
-        // growing a frame later when the harvest bumps measuredRowsVersion
-        // (the judder). The measured floor still guards against an estimate
-        // that undercounts the real wrap. Away from bottom the defer-growth
-        // path below is kept (its anchor-stability / perf intent).
-        return Math.max(idEntry.rows, streamingEstimateRows(item, columns, toolOutputExpanded));
-      }
-      // Defer-growth: while a confirmed (post-commit Yoga) measurement exists
-      // for this streaming id, THIS render keeps that value instead of
-      // folding in the freshly-grown estimate. Combining
-      // max(measuredFloor, liveEstimate) let per-flush row growth reach
-      // totalRows/scrollOffset a full frame BEFORE Yoga confirmed the real
-      // wrap — the estimate could over/undercount vs the real layout, and
-      // the next commit's harvest then corrected it, bouncing an anchored or
-      // bottom-pinned offset by the mismatch. Freezing at the last confirmed
-      // height means growth only reaches the row index on the SAME frame the
-      // harvest (use-transcript-window.mjs) writes the new measured value and
-      // bumps measuredRowsVersion — the "measured frame" consumes it, not the
-      // estimate frame.
-      return idEntry.rows;
-    }
-    if (idEntry) {
+    // One geometry authority for the active stream: the deterministic renderer
+    // model. Never feed a later Yoga measurement back into the row index; that
+    // estimate→measure→correct cycle produced the newline dip/snap. The
+    // high-water estimate is monotonic for this stream id, so code fences and
+    // stable/unstable chunk promotion cannot move the viewport backward.
+    if (streamingMeasuredRowsById.has(item.id)) {
       streamingMeasuredRowsById.delete(item.id);
-      streamingEstimateHighWaterById.delete(item.id);
-      streamingTailEstimateById.delete(item.id);
     }
-    // No confirmed measurement yet for this id (item just started streaming):
-    // nothing to defer against, so the first frame falls back to the estimate.
     return streamingEstimateRows(item, columns, toolOutputExpanded);
   }
   if (item.kind === 'assistant') {
@@ -715,6 +634,11 @@ function appendTranscriptRow(prefix, tailValue) {
     atIndex: (index) => index === prefix.length
       ? tailValue
       : (Number(prefix[index]) || 0),
+    at: (index) => {
+      const resolved = index < 0 ? prefix.length + 1 + index : index;
+      if (resolved < 0 || resolved > prefix.length) return undefined;
+      return resolved === prefix.length ? tailValue : prefix[resolved];
+    },
     slice: (start = 0, end = prefix.length + 1) => {
       const values = [];
       const lo = Math.max(0, start < 0 ? prefix.length + 1 + start : start);

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

@@ -8,7 +8,7 @@
  * its internal timers (animation interval, selection paint throttle, text
  * capture defer, scroll coalescer).
  */
-import { useCallback, useEffect, useRef } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useRef } from 'react';
 import { theme } from '../theme.mjs';
 import {
   SELECTION_PAINT_INTERVAL_MS,
@@ -41,6 +41,7 @@ export function useTranscriptScroll({
   selectionTextRef,
 }) {
   const scrollAnimationRef = useRef(null);
+  const pendingReadbackRowsRef = useRef(0);
   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.
@@ -203,6 +204,7 @@ export function useTranscriptScroll({
   const resetTranscriptScroll = useCallback(() => {
     cancelTranscriptFollow();
     stopSmoothScroll();
+    pendingReadbackRowsRef.current = 0;
     scrollPositionRef.current = 0;
     scrollTargetRef.current = 0;
     transcriptAnchorRef.current = null;
@@ -218,6 +220,7 @@ export function useTranscriptScroll({
     // perform the single bottom-follow when the transcript actually grows.
     transcriptAnchorRef.current = null;
     transcriptAnchorDirtyRef.current = false;
+    pendingReadbackRowsRef.current = 0;
     followingRef.current = true;
     stopSmoothScroll();
   }, [stopSmoothScroll]);
@@ -441,6 +444,12 @@ export function useTranscriptScroll({
 
   const scrollTranscriptRows = useCallback((deltaRows, options = {}) => {
     const maxTarget = Math.max(0, Number(maxScrollRowsRef.current) || 0);
+    const publishedGeometry = transcriptGeomRef.current || {};
+    const geometryMax = Math.max(
+      0,
+      (Number(publishedGeometry.totalRows) || 0)
+        - Math.max(1, Number(publishedGeometry.viewRows) || 1),
+    );
     const historyState = store.getState?.() || {};
     const captureRestoreAnchor = () => {
       const geom = transcriptGeomRef.current || {};
@@ -496,6 +505,20 @@ export function useTranscriptScroll({
     const BOTTOM_SNAP_ROWS = 3;
     if (deltaRows < 0 && target > 0 && target <= BOTTOM_SNAP_ROWS) target = 0;
     const appliedDelta = target - scrollTargetRef.current;
+    const blockedReadbackIntent = deltaRows > 0
+      && appliedDelta === 0
+      && maxTarget === 0
+      && geometryMax > 0;
+    if (blockedReadbackIntent) {
+      // A newly mounted row can hold the committed max at zero for one frame.
+      // Preserve the first upward wheel/keyboard intent instead of letting the
+      // next item/measurement commit infer bottom-follow from target=0 and yank
+      // the viewport back. The layout effect below applies it before paint as
+      // soon as the committed range becomes available.
+      pendingReadbackRowsRef.current += deltaRows;
+    } else if (deltaRows < 0 || appliedDelta !== 0) {
+      pendingReadbackRowsRef.current = 0;
+    }
     // Before the scroll moves selected rows out of view, snapshot the rows
     // currently under the selection into the stitch buffer keyed by the
     // PRE-scroll offset (ref selection.ts captureScrolledRows). Runs for BOTH
@@ -509,7 +532,7 @@ export function useTranscriptScroll({
     }
     // Any manual wheel/keyboard scroll takes precedence over an in-flight
     // transcript follow: drop the glide so the user's intent wins.
-    if (appliedDelta !== 0) cancelTranscriptFollow();
+    if (appliedDelta !== 0 || blockedReadbackIntent) cancelTranscriptFollow();
     scrollTargetRef.current = target;
     // A manual scroll moves the reading position. Capture the new reading anchor
     // SYNCHRONOUSLY from the latest published geometry so the very next render
@@ -593,6 +616,13 @@ export function useTranscriptScroll({
     setScrollOffset(Math.round(target));
   }, [startSmoothScroll, stopSmoothScroll, paintSelectionRect, selectionPointAtCurrentScroll, withSelectionClip, cancelTranscriptFollow, buildSpanRect, harvestStitchRowsNow, cancelPendingSelectionPaint, flushPendingSelectionPaint]);
 
+  useLayoutEffect(() => {
+    const pendingRows = Math.max(0, Number(pendingReadbackRowsRef.current) || 0);
+    if (pendingRows <= 0 || Math.max(0, Number(maxScrollRowsRef.current) || 0) <= 0) return;
+    pendingReadbackRowsRef.current = 0;
+    scrollTranscriptRows(pendingRows);
+  });
+
   // Leading-edge coalescer for edge-drag auto-scroll + wheel deltas: the first
   // delta after an idle period flushes immediately (single wheel ticks/short
   // drags stay responsive), while a flood of deltas within SCROLL_COALESCE_MS