mixdog 0.9.65 → 0.9.67

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

@@ -402,6 +402,7 @@ export function createLiveShare({
   const stopClient = () => {
     const closing = client;
     const closingId = clientId;
+    const wasUp = clientUp;
     client = null;
     clientId = '';
     clientUp = false;
@@ -410,6 +411,14 @@ export function createLiveShare({
     if (closing) {
       try { closing.destroy(); } catch { /* already gone */ }
     }
+    // Deliberate teardown (session switch / role change / dispose) destroys
+    // the socket AFTER clientUp is already false, so the socket's close
+    // handler sees wasUp=false and never clears the mirror. Clear it here:
+    // otherwise the owner's mirrored busy/spinner/queue leaks into the next
+    // resumed session as a frozen working indicator (user report: finished
+    // session shows a spinner + stop button after switching away from a
+    // busy live-attached session).
+    if (wasUp) clearMirroredLiveState();
   };
 
   const startClient = (id) => {

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

@@ -633,16 +633,6 @@ export function createEngineApiB(bag) {
       pushNotice('telegram token forgotten', 'info');
       return result;
     },
-    saveWebhookAuthtoken: (token) => {
-      const result = runtime.saveWebhookAuthtoken(token);
-      pushNotice('webhook/ngrok authtoken saved', 'info');
-      return result;
-    },
-    forgetWebhookAuthtoken: () => {
-      const result = runtime.forgetWebhookAuthtoken();
-      pushNotice('webhook/ngrok authtoken forgotten', 'info');
-      return result;
-    },
     setChannel: async (entry) => {
       const result = await runtime.setChannel(entry);
       pushNotice('channel saved', 'info');
@@ -745,6 +735,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;

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;
 }

package/src/tui/markdown/stream-fence.mjs

@@ -55,6 +55,8 @@ export function trimPartialClosingFences(tokens) {
  */
 const OPEN_FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 const CLOSE_FENCE_RE = /^ {0,3}([`~]+)[ \t]*$/;
+const OPEN_FENCE_SCAN_LRU_MAX = 32;
+const openFenceScanByStreamKey = new Map();
 
 function isClosingFence(line, char, openLen) {
   const m = CLOSE_FENCE_RE.exec(line);
@@ -66,12 +68,14 @@ function isClosingFence(line, char, openLen) {
   return run.startsWith(char.repeat(openLen));
 }
 
-export function findOpenFenceStart(text) {
-  const value = String(text ?? '');
-  let open = null;
-  let start = 0;
-  for (let i = 0; i <= value.length; i++) {
+function scanOpenFence(value, startAt = 0, initialOpen = null) {
+  let open = initialOpen;
+  let start = startAt;
+  const checkpointIndex = value.lastIndexOf('\n') + 1;
+  let openBeforeCheckpoint = start === checkpointIndex ? open : null;
+  for (let i = startAt; i <= value.length; i++) {
     if (i !== value.length && value[i] !== '\n') continue;
+    if (start === checkpointIndex) openBeforeCheckpoint = open;
     const line = value.slice(start, i);
     if (!open) {
       const m = OPEN_FENCE_RE.exec(line);
@@ -88,7 +92,40 @@ export function findOpenFenceStart(text) {
     }
     start = i + 1;
   }
+  return { open, checkpointIndex, openBeforeCheckpoint };
+}
+
+function touchOpenFenceScan(key, entry) {
+  if (openFenceScanByStreamKey.has(key)) openFenceScanByStreamKey.delete(key);
+  openFenceScanByStreamKey.set(key, entry);
+  while (openFenceScanByStreamKey.size > OPEN_FENCE_SCAN_LRU_MAX) {
+    const oldest = openFenceScanByStreamKey.keys().next().value;
+    if (oldest === undefined) break;
+    openFenceScanByStreamKey.delete(oldest);
+  }
+}
+
+export function resetOpenFenceScan(streamKey) {
+  if (streamKey == null || streamKey === '') return;
+  openFenceScanByStreamKey.delete(String(streamKey));
+}
+
+export function resetAllOpenFenceScans() {
+  openFenceScanByStreamKey.clear();
+}
+
+export function findOpenFenceStart(text, streamKey = null) {
+  const value = String(text ?? '');
+  const key = streamKey == null || streamKey === '' ? null : String(streamKey);
+  const cached = key ? openFenceScanByStreamKey.get(key) : null;
+  if (cached?.text === value) return cached.result;
+  const scanned = cached && value.startsWith(cached.text)
+    ? scanOpenFence(value, cached.checkpointIndex, cached.openBeforeCheckpoint)
+    : scanOpenFence(value);
   // Only fast-path unambiguously top-level (column-0) fences.
-  if (!open || open.indent !== 0) return null;
-  return { index: open.index, lang: open.lang };
+  const result = !scanned.open || scanned.open.indent !== 0
+    ? null
+    : { index: scanned.open.index, lang: scanned.open.lang };
+  if (key) touchOpenFenceScan(key, { text: value, ...scanned, result });
+  return result;
 }