mixdog 0.9.64 → 0.9.66

package/src/tui/engine/frame-batched-store.mjs

@@ -12,6 +12,8 @@ export function createFrameBatchedStorePublisher({
   setTimer = setTimeout,
   clearTimer = clearTimeout,
   enqueueMicrotask = queueMicrotask,
+  scheduleFrame = (callback, delay) => setTimer(callback, delay),
+  cancelFrame = (handle) => clearTimer(handle),
 }) {
   let timer = null;
   let emitPending = false;
@@ -20,7 +22,7 @@ export function createFrameBatchedStorePublisher({
 
   const flush = () => {
     if (timer !== null) {
-      clearTimer(timer);
+      cancelFrame(timer);
       timer = null;
     }
     immediatePending = false;
@@ -43,7 +45,7 @@ export function createFrameBatchedStorePublisher({
   const emit = () => {
     emitPending = true;
     if (timer !== null || isDisposed()) return;
-    timer = setTimer(flush, frameMs);
+    timer = scheduleFrame(flush, frameMs);
     timer?.unref?.();
   };
 
@@ -64,7 +66,7 @@ export function createFrameBatchedStorePublisher({
     // Disposal is itself an immediate boundary: publish the final pending
     // snapshot once, while subscribers are still present, then disarm.
     if (emitPending && !isDisposed()) flush();
-    else if (timer !== null) clearTimer(timer);
+    else if (timer !== null) cancelFrame(timer);
     timer = null;
     emitPending = false;
     structureChangePending = false;

package/src/tui/engine/live-share.mjs

@@ -62,6 +62,7 @@ export function createLiveShare({
   getPublishedState,
   listeners,
   onRemoteSubmit,
+  onRemoteAbort,
   onOwnerClosed,
   viewerApply,
 }) {
@@ -73,6 +74,7 @@ export function createLiveShare({
   let lastItems = null;
   let lastTail = null;
   let lastSpinner = null;
+  let lastLiveSig = '';
 
   const broadcast = (frame) => {
     if (sockets.size === 0) return;
@@ -82,12 +84,49 @@ export function createLiveShare({
     }
   };
 
+  // Live-state mirror (attach parity): the transcript alone left an attached
+  // viewer blind to the owner's activity — busy/stop state, the queued
+  // follow-up list, the Explore/Search summary, agent workers/jobs, and the
+  // context gauge stats all live in owner process state. Mirror a compact
+  // subset so viewer surfaces render them natively. queued entries are
+  // projected to display fields only (content parts may carry images).
+  const LIVE_STATS_KEYS = [
+    'currentContextSource', 'currentContextTokens', 'currentEstimatedContextTokens',
+    'currentContextUpdatedAt', 'costUsd', 'turns', 'inputTokens', 'outputTokens',
+    'latestInputTokens', 'latestPromptTokens', 'contextTokens',
+  ];
+  const liveStateOf = (st) => {
+    const stats = st.stats && typeof st.stats === 'object' ? st.stats : {};
+    const statsSubset = {};
+    for (const key of LIVE_STATS_KEYS) {
+      if (stats[key] !== undefined) statsSubset[key] = stats[key];
+    }
+    return {
+      busy: st.busy === true,
+      commandBusy: st.commandBusy === true,
+      queued: (Array.isArray(st.queued) ? st.queued : []).map((entry) => ({
+        id: entry?.id,
+        text: String(entry?.displayText ?? entry?.text ?? entry?.message ?? '').slice(0, 2000),
+        ...(entry?.enqueuedAt ? { enqueuedAt: entry.enqueuedAt } : {}),
+      })),
+      activeToolSummary: st.activeToolSummary || null,
+      agentWorkers: Array.isArray(st.agentWorkers) ? st.agentWorkers : [],
+      agentJobs: Array.isArray(st.agentJobs) ? st.agentJobs : [],
+      ownerClientHostPid: Number(st.clientHostPid) || process.pid,
+      displayContextWindow: Number(st.displayContextWindow) || 0,
+      compactBoundaryTokens: Number(st.compactBoundaryTokens) || 0,
+      autoCompactTokenLimit: Number(st.autoCompactTokenLimit) || 0,
+      stats: statsSubset,
+    };
+  };
+
   const fullFrame = (st) => ({
     t: 'full',
     sessionId: serverId,
     items: Array.isArray(st.items) ? st.items : [],
     tail: st.streamingTail || null,
     spinner: st.spinner || null,
+    live: liveStateOf(st),
   });
 
   // Runs on every frame-batched publish. With no viewers it only re-baselines
@@ -98,6 +137,7 @@ export function createLiveShare({
       lastItems = st.items;
       lastTail = st.streamingTail;
       lastSpinner = st.spinner;
+      lastLiveSig = '';
       return;
     }
     const frame = { t: 'delta' };
@@ -155,6 +195,13 @@ export function createLiveShare({
       lastSpinner = st.spinner;
       dirty = true;
     }
+    const live = liveStateOf(st);
+    const liveSig = JSON.stringify(live);
+    if (liveSig !== lastLiveSig) {
+      frame.live = live;
+      lastLiveSig = liveSig;
+      dirty = true;
+    }
     if (dirty) broadcast(frame);
   };
   listeners.add(onPublish);
@@ -190,6 +237,10 @@ export function createLiveShare({
       attachLineReader(socket, (frame) => {
         if (frame.t === 'submit' && typeof frame.text === 'string' && frame.text.trim()) {
           onRemoteSubmit(frame.text);
+        } else if (frame.t === 'abort') {
+          // Viewer stop button: interrupt the owner's active turn here — the
+          // viewer process has no turn of its own to cancel.
+          onRemoteAbort?.();
         } else if (frame.t === 'sync') {
           try { socket.write(frameLine(fullFrame(getPublishedState()))); } catch { /* close handles */ }
         }
@@ -199,6 +250,7 @@ export function createLiveShare({
         lastItems = st.items;
         lastTail = st.streamingTail;
         lastSpinner = st.spinner;
+        lastLiveSig = JSON.stringify(liveStateOf(st));
         socket.write(frameLine(fullFrame(st)));
       } catch {
         try { socket.destroy(); } catch { /* already gone */ }
@@ -275,11 +327,48 @@ export function createLiveShare({
     else viewerApply.appendItems([item]);
   };
 
+  // Mirror the owner's live-state subset into the viewer store. Context stats
+  // merge over the local stats object so unmirrored accumulator fields keep
+  // their last local values instead of vanishing.
+  const applyLiveState = (live) => {
+    if (!live || typeof live !== 'object') return;
+    const patch = {
+      busy: live.busy === true,
+      commandBusy: live.commandBusy === true,
+      queued: Array.isArray(live.queued) ? live.queued : [],
+      activeToolSummary: live.activeToolSummary || null,
+      agentWorkers: Array.isArray(live.agentWorkers) ? live.agentWorkers : [],
+      agentJobs: Array.isArray(live.agentJobs) ? live.agentJobs : [],
+      ownerClientHostPid: Number(live.ownerClientHostPid) || 0,
+    };
+    for (const key of ['displayContextWindow', 'compactBoundaryTokens', 'autoCompactTokenLimit']) {
+      if (Number(live[key]) > 0) patch[key] = Number(live[key]);
+    }
+    if (live.stats && typeof live.stats === 'object' && Object.keys(live.stats).length > 0) {
+      const current = viewerApply.getState().stats;
+      patch.stats = { ...(current && typeof current === 'object' ? current : {}), ...live.stats };
+    }
+    viewerApply.set(patch);
+  };
+
+  // Owner gone (clean close, crash, or pipe drop): the mirrored activity is
+  // no longer authoritative — clear it so the viewer never shows a frozen
+  // spinner/queue while the promotion path takes over.
+  const clearMirroredLiveState = () => {
+    try {
+      viewerApply?.set?.({
+        busy: false, commandBusy: false, spinner: null, queued: [],
+        activeToolSummary: null, agentWorkers: [], agentJobs: [], ownerClientHostPid: 0,
+      });
+    } catch { /* viewer store already disposed */ }
+  };
+
   const applyViewerFrame = (frame, socket) => {
     if (frame.t === 'full') {
       viewerApply.replaceItems(Array.isArray(frame.items) ? frame.items : []);
       if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail);
       viewerApply.set({ spinner: frame.spinner || null });
+      applyLiveState(frame.live);
       return;
     }
     if (frame.t !== 'delta') return;
@@ -307,6 +396,7 @@ export function createLiveShare({
       else viewerApply.clearStreamingTail();
     }
     if ('spinner' in frame) viewerApply.set({ spinner: frame.spinner || null });
+    if ('live' in frame) applyLiveState(frame.live);
   };
 
   const stopClient = () => {
@@ -335,6 +425,7 @@ export function createLiveShare({
       const wasUp = clientUp && client === socket;
       if (client === socket) { client = null; clientId = ''; clientUp = false; }
       try { socket.destroy(); } catch { /* already gone */ }
+      if (wasUp) clearMirroredLiveState();
       // A live link that dropped means the owner ended or crashed: nudge the
       // promotion path instead of waiting for the next store-mtime change.
       if (wasUp) onOwnerClosed?.(id, ownerClosed);
@@ -381,6 +472,15 @@ export function createLiveShare({
         return false;
       }
     },
+    sendAbort() {
+      if (!clientUp || !client) return false;
+      try {
+        client.write(frameLine({ t: 'abort' }));
+        return true;
+      } catch {
+        return false;
+      }
+    },
     dispose() {
       listeners.delete(onPublish);
       stopServer();

package/src/tui/engine/render-timing.mjs

@@ -20,11 +20,38 @@
 const RENDER_ACK_FALLBACK_MS = 32;
 const RENDER_ACK_HANG_GUARD_MS = 250;
 const RENDER_SETTLE_IDLE_MS = 64;
+export const TUI_RENDER_FPS = 60;
+// Ink uses Math.ceil(1000 / maxFps); share that exact cadence with the store.
+export const TUI_FRAME_MS = Math.ceil(1000 / TUI_RENDER_FPS);
 
 // Back-compat alias: previously the fixed wait duration, now the fallback only.
 
 let pendingRenderAcks = [];
 let renderAckSeq = 0;
+let lastRenderFrameAt = 0;
+
+export const renderFrameDelay = (
+  lastFrameAt,
+  currentTime,
+  frameMs = TUI_FRAME_MS,
+) => {
+  if (!(lastFrameAt > 0)) return frameMs;
+  return Math.max(0, frameMs - Math.max(0, currentTime - lastFrameAt));
+};
+
+export const scheduleRenderAlignedStoreFlush = (
+  callback,
+  frameMs = TUI_FRAME_MS,
+) => {
+  const timer = setTimeout(
+    callback,
+    renderFrameDelay(lastRenderFrameAt, performance.now(), frameMs),
+  );
+  timer.unref?.();
+  return timer;
+};
+
+export const cancelRenderAlignedStoreFlush = (timer) => clearTimeout(timer);
 
 /**
  * Called by the Ink onRender hook once per painted frame. The sequence is
@@ -38,6 +65,7 @@ export const scheduleRenderFrameAck = () => {
 };
 
 const notifyRenderFrame = (seq = ++renderAckSeq) => {
+  lastRenderFrameAt = performance.now();
   if (pendingRenderAcks.length === 0) return;
   const acks = pendingRenderAcks;
   pendingRenderAcks = [];

package/src/tui/engine/session-api-ext.mjs

@@ -515,6 +515,9 @@ export function createEngineApiB(bag) {
     getUsageDashboard: async (options = {}) => {
       return await runtime.getUsageDashboard?.(options);
     },
+    getTurnReviewDiff: async () => {
+      return (await runtime.getTurnReviewDiff?.()) ?? { supported: false, files: [], patch: '' };
+    },
     getOnboardingStatus: () => {
       return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
     },
@@ -742,6 +745,13 @@ export function createEngineApiB(bag) {
     listSessions: (options) => {
       return runtime.listSessions(options);
     },
+    // Desktop sidebar watcher hook: EngineHost fs.watches this directory so
+    // heartbeat sidecar create/delete pushes instant working/dot updates.
+    // Without it the watcher silently no-ops and the sidebar falls back to
+    // the 60s safety poll (user: spinner kept spinning after the turn ended).
+    sessionStoreDir: () => {
+      try { return runtime.sessionStoreDir?.() || null; } catch { return null; }
+    },
     deleteSession: async (id) => {
       if (getState().commandBusy) return false;
       const deletingCurrent = String(runtime.session?.id || getState().sessionId || '') === String(id || '');

package/src/tui/engine/tui-steering-persist.mjs

@@ -8,6 +8,11 @@ import { promptContentText } from './queue-helpers.mjs';
 
 const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
 const PENDING_MESSAGES_MODE = 0o600;
+// Restore window for persisted busy-input steering rows. Rows older than this
+// are leftovers of a session that ended long ago — restoring them into a fresh
+// TUI boot reads as a surprise self-injection (user report), so they are
+// discarded at drain time instead.
+const STALE_STEERING_RESTORE_TTL_MS = 30 * 60 * 1000;
 
 // Serialize this UI process's own steering writes so append→drop→drain keep
 // their issue order even though each now waits on the lock asynchronously.
@@ -44,7 +49,9 @@ function normalizeTuiSteeringQueueEntry(entry) {
   if (typeof entry.text === 'string' && entry.text.trim()) {
     const text = entry.text.trim();
     const id = typeof entry.id === 'string' && entry.id.trim() ? entry.id.trim() : null;
-    return id ? { id, text } : text;
+    if (!id) return text;
+    const at = Number(entry.at);
+    return Number.isFinite(at) && at > 0 ? { id, text, at } : { id, text };
   }
   return null;
 }
@@ -116,7 +123,7 @@ export function appendTuiSteeringPersist(leadSessionId, entry) {
   const key = tuiSteeringSessionKey(leadSessionId);
   if (!key) return Promise.resolve();
   if (!entry.steeringPersistId) entry.steeringPersistId = newSteeringPersistId();
-  const record = { id: entry.steeringPersistId, text };
+  const record = { id: entry.steeringPersistId, text, at: Date.now() };
   return _serialize(async () => {
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
@@ -187,12 +194,23 @@ export function drainTuiSteeringPersist(leadSessionId) {
   if (!key) return Promise.resolve([]);
   return _serialize(async () => {
     let drained = [];
+    let droppedStale = 0;
     try {
       await updateJsonAtomic(pendingMessagesPath(), (raw) => {
         const next = normalizePendingStore(raw);
         const q = Array.isArray(next.sessions[key]) ? next.sessions[key] : [];
-        drained = q.map(drainedRowToRestore).filter(Boolean);
-        if (drained.length === 0) return undefined;
+        // Per-row timestamps age precisely; legacy rows without one age from
+        // the session key's last touch time.
+        const now = Date.now();
+        const touchedAt = Number(next.sessionTouchedAt?.[key]) || 0;
+        const fresh = q.filter((row) => {
+          const at = Number(row?.at) || touchedAt;
+          const stale = at > 0 && (now - at) > STALE_STEERING_RESTORE_TTL_MS;
+          if (stale) droppedStale += 1;
+          return !stale;
+        });
+        drained = fresh.map(drainedRowToRestore).filter(Boolean);
+        if (drained.length === 0 && droppedStale === 0) return undefined;
         delete next.sessions[key];
         if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
         next.updatedAt = Date.now();
@@ -201,6 +219,9 @@ export function drainTuiSteeringPersist(leadSessionId) {
     } catch (err) {
       try { process.stderr.write(`[tui] steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}\n`); } catch {}
     }
+    if (droppedStale > 0) {
+      try { process.stderr.write(`[tui] dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}\n`); } catch {}
+    }
     return drained;
   });
 }

package/src/tui/engine.mjs

@@ -77,7 +77,12 @@ import {
 import {
   resolveTuiRuntimeNotificationDelivery,
 } from './engine/notification-plan.mjs';
-import { yieldToRenderer } from './engine/render-timing.mjs';
+import {
+  TUI_FRAME_MS,
+  cancelRenderAlignedStoreFlush,
+  scheduleRenderAlignedStoreFlush,
+  yieldToRenderer,
+} from './engine/render-timing.mjs';
 import {
   aggregateRawResult,
   aggregateBucketForCategory,
@@ -273,6 +278,9 @@ export async function createEngineSession({
     },
     listeners,
     isDisposed: () => flags.disposed,
+    frameMs: TUI_FRAME_MS,
+    scheduleFrame: scheduleRenderAlignedStoreFlush,
+    cancelFrame: cancelRenderAlignedStoreFlush,
   });
   const emit = publisher.emit;
   const flushEmit = publisher.flush;
@@ -695,6 +703,13 @@ export async function createEngineSession({
   lifecycle.runtimePulseTimer = setInterval(() => {
     if (flags.disposed) return;
     if (flags.pendingSessionReset) return;
+    // Attached viewer with a live pipe: the owner's frames are authoritative
+    // for stats/agent/tool state. Recomputing them locally here would stomp
+    // the mirror with this process's empty registries every 2s.
+    if (bag.liveShareMirroring?.()) {
+      set({ ...routeState() });
+      return;
+    }
     syncContextStats({ allowEstimated: true });
     set({
       ...routeState(),
@@ -822,6 +837,11 @@ export async function createEngineSession({
       bag.enqueue(text);
       void bag.drain();
     },
+    onRemoteAbort: () => {
+      // Forwarded viewer stop: interrupt OUR active turn (we are the owner).
+      if (flags.disposed || state.sessionRemoteAttached) return;
+      try { api.abort?.(); } catch { /* abort is best-effort */ }
+    },
     onOwnerClosed: (id) => {
       // Owner left (clean close or crash): promote via the normal quiet
       // re-resume once its final save/presence-clear has landed.
@@ -849,6 +869,9 @@ export async function createEngineSession({
   // resume() calls this right after installing the restored items so the
   // owner's full frame lands at the entry boundary instead of seconds later.
   bag.ensureLiveShare = () => { try { liveShare.ensure(); } catch { /* share tick retries */ } };
+  // Pulse guard: while this surface is an attached viewer with a live pipe,
+  // owner frames own stats/agent/tool state (see runtimePulseTimer above).
+  bag.liveShareMirroring = () => state.sessionRemoteAttached && liveShare.viewerConnected();
   // Live viewer submits ride the owner's pipe (instant user bubble + shared
   // streaming); the durable spool path below remains the fallback.
   if (typeof api.submit === 'function') {
@@ -861,6 +884,18 @@ export async function createEngineSession({
       return baseSubmit(prompt, options);
     };
   }
+  // Viewer stop button: the local engine has no in-flight turn to cancel —
+  // forward the interrupt to the owner over the pipe. Falls back to the local
+  // abort (no-op safe) when the pipe is down.
+  if (typeof api.abort === 'function') {
+    const baseAbort = api.abort;
+    api.abort = (...args) => {
+      if (state.sessionRemoteAttached && liveShare.viewerConnected() && liveShare.sendAbort()) {
+        return true;
+      }
+      return baseAbort(...args);
+    };
+  }
   // Attach-time pipe fast-path: session entry (resume) reconciles the live
   // pipe IMMEDIATELY instead of waiting for the 3s share tick. The attach
   // render comes from the last disk save WITHOUT the in-flight turn, so that

package/src/tui/index.jsx

@@ -14,7 +14,7 @@ import { format } from 'node:util';
 import { App } from './App.jsx';
 import { cancelPendingMouseTrackingRestores } from './app/use-mouse-input.mjs';
 import { createEngineSession } from './engine.mjs';
-import { scheduleRenderFrameAck } from './engine/render-timing.mjs';
+import { scheduleRenderFrameAck, TUI_RENDER_FPS } from './engine/render-timing.mjs';
 import { installProcessSignalCleanup } from '../runtime/shared/process-shutdown.mjs';
 import { finishProcessLifecycle } from '../runtime/shared/process-lifecycle.mjs';
 import { rgbSgr } from '../ui/ansi.mjs';
@@ -481,6 +481,12 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
 
   process.on('exit', restoreTerminal);
 
+  // Engine startup is independent from palette selection. Start it now and
+  // overlap its runtime import/config work with the theme read, while still
+  // awaiting the theme before the first React frame.
+  const storeOutcomePromise = createEngineSession({ provider, model, toolMode, remote })
+    .then((store) => ({ store, error: null }), (error) => ({ store: null, error }));
+
   // Apply the persisted UI theme (ui.theme in mixdog-config.json) before the
   // first React frame so the whole tree paints in the chosen palette. Unknown
   // or missing values leave the default Mixdog dark palette in place; a failed
@@ -496,7 +502,9 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
 
   let store;
   try {
-    store = await createEngineSession({ provider, model, toolMode, remote });
+    const outcome = await storeOutcomePromise;
+    if (outcome.error) throw outcome.error;
+    store = outcome.store;
     bootProfile('store:ready', { ms: (performance.now() - startedAt).toFixed(1) });
   } catch (error) {
     splash.stop();
@@ -590,7 +598,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     // its clear-frame → write → relative re-render dance, which scrolls the
     // alt screen one line per stray console line (the streaming newline
     // bounce). See installTuiConsoleGuard.
-    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: 60, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
+    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: TUI_RENDER_FPS, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
     bootProfile('render:mounted', { ms: (performance.now() - startedAt).toFixed(1) });
     const { waitUntilExit } = instance;
     // [mixdog fork] Hand the ink renderer's drag-selection setter to the store so

package/src/tui/markdown/measure-rendered-rows.mjs

@@ -85,15 +85,19 @@ function measureStreamingPartsUncached(parts, columns) {
   }
   let rows = 0;
   let childCount = 0;
-  if (parts.stablePrefix) {
-    rows += measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
+  const stableChunks = parts.stableChunks?.length
+    ? parts.stableChunks
+    : parts.stablePrefix ? [parts.stablePrefix] : [];
+  for (const chunk of stableChunks) {
+    if (childCount > 0) rows += 1;
+    rows += measureMarkdownRenderedRows(chunk, columns, { trimPartialFences: false });
     childCount += 1;
   }
   if (parts.unstableSuffix) {
+    if (childCount > 0) rows += 1;
     rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
     childCount += 1;
   }
-  if (childCount === 2) rows += 1;
   return childCount === 0 ? 1 : Math.max(1, rows);
 }
 
@@ -166,30 +170,38 @@ export function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
   let rows = 0;
   let childCount = 0;
   let stableRows = 0;
-  if (parts.stablePrefix) {
-    // The renderer mounts stablePrefix and unstableSuffix as separate Markdown
-    // children. An unchanged stable child is therefore safe to reuse exactly;
-    // only the independently-rendered live suffix needs measuring on append.
-    stableRows = cached
-      && cached.mode === 'markdown'
-      && cached.columns === columns
-      && cached.stablePrefix === parts.stablePrefix
-      ? cached.stableRows
-      : measureMarkdownRenderedRows(parts.stablePrefix, columns, { trimPartialFences: false });
-    rows += stableRows;
-    childCount += 1;
+  const stableChunks = parts.stableChunks?.length
+    ? parts.stableChunks
+    : parts.stablePrefix ? [parts.stablePrefix] : [];
+  const reusableChunks = cached
+    && cached.mode === 'markdown'
+    && cached.columns === columns
+    && Array.isArray(cached.stableChunks)
+    && cached.stableChunks.length <= stableChunks.length
+    && cached.stableChunks.every((chunk, index) => chunk === stableChunks[index]);
+  let measuredStableChunks = 0;
+  if (reusableChunks) {
+    stableRows = cached.stableRows;
+    measuredStableChunks = cached.stableChunks.length;
+  }
+  for (let index = measuredStableChunks; index < stableChunks.length; index += 1) {
+    if (index > 0) stableRows += 1;
+    stableRows += measureMarkdownRenderedRows(stableChunks[index], columns, { trimPartialFences: false });
   }
+  rows += stableRows;
+  childCount = stableChunks.length;
   if (parts.unstableSuffix) {
+    if (childCount > 0) rows += 1;
     rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
     childCount += 1;
   }
-  if (childCount === 2) rows += 1;
   const measuredRows = childCount === 0 ? 1 : Math.max(1, rows);
   cacheStreamingRows(key, {
     text: value,
     columns,
     mode: 'markdown',
     stablePrefix: parts.stablePrefix,
+    stableChunks: stableChunks.slice(),
     stableRows,
     rows: measuredRows,
   });

package/src/tui/markdown/render-ansi.mjs

@@ -16,9 +16,14 @@
 import { marked } from 'marked';
 import { formatToken } from './format-token.mjs';
 import { trimPartialClosingFences, findOpenFenceStart } from './stream-fence.mjs';
+import { getThemeVersion } from '../theme.mjs';
 
 const TOKEN_CACHE_MAX = 500;
 const tokenCache = new Map();
+const renderedSegmentCache = [];
+const RENDERED_SEGMENT_CACHE_MAX = 12;
+const RENDERED_SEGMENT_CACHE_MAX_CHARS = 256 * 1024;
+let renderedSegmentCacheChars = 0;
 const MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
 
 let _configured = false;
@@ -99,8 +104,24 @@ function lexMarkdown(content, { trimPartialFences = false } = {}) {
  * Blank-edge-only ansi segments are dropped (mirrors the component's pushAnsi).
  */
 export function renderTokenAnsiSegments(content, opts = {}) {
-  const tokens = lexMarkdown(content, opts);
+  const text = String(content ?? '');
   const width = Number(opts.width) || 0;
+  const trimPartialFences = opts.trimPartialFences === true;
+  const themeVersion = getThemeVersion();
+  for (let index = renderedSegmentCache.length - 1; index >= 0; index -= 1) {
+    const entry = renderedSegmentCache[index];
+    if (
+      entry.text === text
+      && entry.width === width
+      && entry.trimPartialFences === trimPartialFences
+      && entry.themeVersion === themeVersion
+    ) {
+      renderedSegmentCache.splice(index, 1);
+      renderedSegmentCache.push(entry);
+      return entry.segments;
+    }
+  }
+  const tokens = lexMarkdown(text, opts);
   const segments = [];
   for (const token of tokens) {
     if (token.type === 'table') {
@@ -113,5 +134,17 @@ export function renderTokenAnsiSegments(content, opts = {}) {
       segments.push({ type: 'ansi', ansi, token });
     }
   }
+  if (text.length <= RENDERED_SEGMENT_CACHE_MAX_CHARS) {
+    const entry = { text, width, trimPartialFences, themeVersion, segments };
+    renderedSegmentCache.push(entry);
+    renderedSegmentCacheChars += text.length;
+    while (
+      renderedSegmentCache.length > RENDERED_SEGMENT_CACHE_MAX
+      || renderedSegmentCacheChars > RENDERED_SEGMENT_CACHE_MAX_CHARS
+    ) {
+      const removed = renderedSegmentCache.shift();
+      renderedSegmentCacheChars -= removed?.text.length || 0;
+    }
+  }
   return segments;
 }