mixdog 0.9.65 → 0.9.67

package/src/tui/dist/index.mjs

@@ -1246,7 +1246,6 @@ __export(config_exports, {
   getOpenAIUsageSessionKey: () => getOpenAIUsageSessionKey,
   getOpenCodeGoAuthCookie: () => getOpenCodeGoAuthCookie,
   getTelegramToken: () => getTelegramToken,
-  getWebhookAuthtoken: () => getWebhookAuthtoken,
   hasStoredSecret: () => hasStoredSecret,
   invalidateConfigReadCache: () => invalidateConfigReadCache,
   invalidateSecretReadCache: () => invalidateSecretReadCache,
@@ -1563,9 +1562,6 @@ function getDiscordToken() {
 function getTelegramToken() {
   return _readSecret(SECRET_ACCOUNTS.telegramToken);
 }
-function getWebhookAuthtoken() {
-  return _readSecret(SECRET_ACCOUNTS.webhookAuth);
-}
 function getOpenAIUsageSessionKey() {
   return process.env.OPENAI_USAGE_SESSION_KEY || process.env.OPENAI_DASHBOARD_SESSION_KEY || process.env.OPENAI_SESSION_KEY || process.env.MIXDOG_OPENAI_USAGE_SESSION_KEY || _readSecret(SECRET_ACCOUNTS.openaiUsageSessionKey);
 }
@@ -1631,7 +1627,6 @@ var init_config = __esm({
     SECRET_ACCOUNTS = Object.freeze({
       discordToken: "discord.token",
       telegramToken: "telegram.token",
-      webhookAuth: "webhook.authtoken",
       agentApiKey: (provider) => `agent.${provider}.apiKey`,
       openaiUsageSessionKey: "agent.openai.usageSessionKey",
       opencodeGoAuthCookie: "agent.opencode-go.authCookie"
@@ -2588,7 +2583,7 @@ import { render } from "../../../vendor/ink/build/index.js";
 import { closeSync as closeSync3, constants as fsConstants, createWriteStream as createWriteStream2, mkdirSync as mkdirSync9, openSync as openSync3, readSync } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname12, join as join15 } from "node:path";
-import { performance as performance3 } from "node:perf_hooks";
+import { performance as performance4 } from "node:perf_hooks";
 import { format } from "node:util";
 
 // src/tui/App.jsx
@@ -5844,7 +5839,7 @@ var SPINNER_VERBS = [
 ];
 var SPINNER_FRAMES = ["\u25C7", "\u25C6", "\u25C8", "\u25C6", "\u25C7"];
 
-// src/tui/time-format.mjs
+// src/runtime/shared/time-format.mjs
 function formatDuration(ms, options = {}) {
   if (!Number.isFinite(Number(ms))) return "";
   const value = Math.max(0, Number(ms) || 0);
@@ -7274,6 +7269,7 @@ function PromptInput({
   if (valueRef) valueRef.current = draftRef.current.value;
   const { isRawModeSupported } = useStdin();
   const boxRef = useRef4(null);
+  const inkRootRef = useRef4(null);
   const cursorEnabledRef = useRef4(false);
   const contentWidthRef = useRef4(80);
   const preferredColumnRef = useRef4(null);
@@ -7288,9 +7284,15 @@ function PromptInput({
   }
   const flushThrottleRef = useRef4({ lastAt: 0, timer: null });
   const flushImmediate = () => {
+    const cachedRoot = inkRootRef.current;
+    if (typeof cachedRoot?.onImmediateRender === "function") {
+      cachedRoot.onImmediateRender();
+      return;
+    }
     let node = boxRef.current;
     for (let i = 0; node && i < 64; i++) {
       if (node.nodeName === "ink-root") {
+        inkRootRef.current = node;
         if (typeof node.onImmediateRender === "function") node.onImmediateRender();
         return;
       }
@@ -11289,18 +11291,22 @@ function trimPartialClosingFences(tokens) {
 }
 var OPEN_FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 var CLOSE_FENCE_RE = /^ {0,3}([`~]+)[ \t]*$/;
+var OPEN_FENCE_SCAN_LRU_MAX = 32;
+var openFenceScanByStreamKey = /* @__PURE__ */ new Map();
 function isClosingFence(line, char, openLen) {
   const m = CLOSE_FENCE_RE.exec(line);
   if (!m) return false;
   const run = m[1];
   return run.startsWith(char.repeat(openLen));
 }
-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);
@@ -11316,13 +11322,42 @@ function findOpenFenceStart(text) {
     }
     start = i + 1;
   }
-  if (!open || open.indent !== 0) return null;
-  return { index: open.index, lang: open.lang };
+  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 === void 0) break;
+    openFenceScanByStreamKey.delete(oldest);
+  }
+}
+function resetOpenFenceScan(streamKey) {
+  if (streamKey == null || streamKey === "") return;
+  openFenceScanByStreamKey.delete(String(streamKey));
+}
+function resetAllOpenFenceScans() {
+  openFenceScanByStreamKey.clear();
+}
+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);
+  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;
 }
 
 // src/tui/markdown/render-ansi.mjs
 var TOKEN_CACHE_MAX = 500;
 var tokenCache = /* @__PURE__ */ new Map();
+var renderedSegmentCache = [];
+var RENDERED_SEGMENT_CACHE_MAX = 12;
+var RENDERED_SEGMENT_CACHE_MAX_CHARS = 256 * 1024;
+var renderedSegmentCacheChars = 0;
 var MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
 var _configured = false;
 function configureMarked() {
@@ -11384,8 +11419,19 @@ function lexMarkdown(content, { trimPartialFences = false } = {}) {
   return tokens;
 }
 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") {
@@ -11398,55 +11444,104 @@ 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;
 }
 
 // src/tui/markdown/streaming-markdown.mjs
 import { marked as marked2 } from "marked";
 var stablePrefixByStreamKey = /* @__PURE__ */ new Map();
+var markdownSyntaxByStreamKey = /* @__PURE__ */ new Map();
+var plainWindowSyntaxByStreamKey = /* @__PURE__ */ new Map();
 var resolvedPartsByStreamKey = /* @__PURE__ */ new Map();
 var STABLE_PREFIX_LRU_MAX = 32;
 function streamingLayoutText(text) {
   return String(text ?? "").replace(/^\n+|\n+$/g, "");
 }
-function windowPlainStreamingText(text, columns, maxRows) {
+function windowPlainStreamingText(text, columns, maxRows, streamKey = null) {
   const value = streamingLayoutText(text);
   const rowBudget = Math.max(0, Math.floor(Number(maxRows) || 0));
-  if (!value || rowBudget <= 0 || hasMarkdownSyntax(value)) return value;
-  const lines = value.split("\n");
+  const key = streamKey == null || streamKey === "" ? null : String(streamKey);
+  if (!value || rowBudget <= 0 || cachedStreamingHasMarkdownSyntax(
+    plainWindowSyntaxByStreamKey,
+    value,
+    key
+  )) return value;
   const width = Math.max(1, Math.floor(Number(columns) || 80));
   let rows = 0;
-  let start = lines.length;
-  while (start > 0) {
-    const line = lines[start - 1];
+  let end = value.length;
+  let start = end;
+  while (end >= 0) {
+    const newline = value.lastIndexOf("\n", end - 1);
+    const lineStart2 = newline + 1;
+    const line = value.slice(lineStart2, end);
     const lineRows = Math.max(1, Math.ceil(displayWidth(line) / width));
     if (rows > 0 && rows + lineRows > rowBudget) break;
     rows += lineRows;
-    start -= 1;
-    if (rows >= rowBudget) break;
+    start = lineStart2;
+    if (rows >= rowBudget || newline < 0) break;
+    end = newline;
   }
-  return start > 0 ? lines.slice(start).join("\n") : value;
+  return start > 0 ? value.slice(start) : value;
 }
 function isWhitespaceOnlyText(text) {
   return !String(text ?? "").trim();
 }
-function touchStablePrefixKey(key, value) {
+function touchLruKey(cache, key, value) {
   if (!key) return;
-  if (stablePrefixByStreamKey.has(key)) stablePrefixByStreamKey.delete(key);
-  stablePrefixByStreamKey.set(key, value);
-  while (stablePrefixByStreamKey.size > STABLE_PREFIX_LRU_MAX) {
-    const oldest = stablePrefixByStreamKey.keys().next().value;
+  if (cache.has(key)) cache.delete(key);
+  cache.set(key, value);
+  while (cache.size > STABLE_PREFIX_LRU_MAX) {
+    const oldest = cache.keys().next().value;
     if (oldest === void 0) break;
-    stablePrefixByStreamKey.delete(oldest);
+    cache.delete(oldest);
   }
 }
+function touchStablePrefixKey(key, value) {
+  touchLruKey(stablePrefixByStreamKey, key, value);
+}
 function getStablePrefixKey(key) {
-  if (!key || !stablePrefixByStreamKey.has(key)) return "";
+  if (!key || !stablePrefixByStreamKey.has(key)) return { text: "", chunks: [] };
   const value = stablePrefixByStreamKey.get(key);
-  stablePrefixByStreamKey.delete(key);
-  stablePrefixByStreamKey.set(key, value);
+  touchStablePrefixKey(key, value);
+  return value;
+}
+function stableStateForText(text, previous) {
+  if (!text) return { text: "", chunks: [] };
+  if (text.startsWith(previous.text)) {
+    const appended = text.substring(previous.text.length);
+    return appended ? { text, chunks: [...previous.chunks, appended] } : previous;
+  }
+  return { text, chunks: [text] };
+}
+function cachedStreamingHasMarkdownSyntax(cache, text, key) {
+  if (!key) return hasMarkdownSyntax(text);
+  const previous = cache.get(key);
+  let value;
+  if (previous && text.startsWith(previous.text)) {
+    if (previous.value) {
+      value = true;
+    } else {
+      const lineStart2 = previous.text.lastIndexOf("\n") + 1;
+      value = hasMarkdownSyntax(text.substring(Math.max(0, lineStart2 - 1)));
+    }
+  } else {
+    value = hasMarkdownSyntax(text);
+  }
+  touchLruKey(cache, key, { text, value });
   return value;
 }
+function streamingHasMarkdownSyntax(text, key) {
+  return cachedStreamingHasMarkdownSyntax(markdownSyntaxByStreamKey, text, key);
+}
 function getResolvedPartsKey(key, text) {
   if (!key) return null;
   const entry = resolvedPartsByStreamKey.get(key);
@@ -11518,11 +11613,17 @@ function resetStreamingMarkdownStablePrefix(streamKey) {
   if (streamKey == null || streamKey === "") return;
   const key = String(streamKey);
   stablePrefixByStreamKey.delete(key);
+  markdownSyntaxByStreamKey.delete(key);
+  plainWindowSyntaxByStreamKey.delete(key);
   resolvedPartsByStreamKey.delete(key);
+  resetOpenFenceScan(key);
 }
 function resetAllStreamingMarkdownStablePrefixes() {
   stablePrefixByStreamKey.clear();
+  markdownSyntaxByStreamKey.clear();
+  plainWindowSyntaxByStreamKey.clear();
   resolvedPartsByStreamKey.clear();
+  resetAllOpenFenceScans();
 }
 function resolveStreamingMarkdownParts(text, streamKey) {
   const t = streamingLayoutText(text);
@@ -11534,34 +11635,39 @@ function resolveStreamingMarkdownParts(text, streamKey) {
     return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: "",
+      stableChunks: [],
       unstableSuffix: "",
       unstableForRender: ""
     });
   }
-  if (!hasMarkdownSyntax(t)) {
+  if (!streamingHasMarkdownSyntax(t, key)) {
     if (key) stablePrefixByStreamKey.delete(key);
     return cacheResolvedPartsKey(key, t, {
       plain: true,
       stablePrefix: "",
+      stableChunks: [],
       unstableSuffix: t,
       unstableForRender: t
     });
   }
-  let stablePrefix = key ? getStablePrefixKey(key) : "";
-  if (!t.startsWith(stablePrefix)) {
-    stablePrefix = "";
+  let stableState = key ? getStablePrefixKey(key) : { text: "", chunks: [] };
+  if (!t.startsWith(stableState.text)) {
+    stableState = { text: "", chunks: [] };
   }
-  const open = findOpenFenceStart(t);
+  let stablePrefix = stableState.text;
+  const open = findOpenFenceStart(t, key);
   if (open) {
     let openPrefix = t.substring(0, open.index);
     if (isWhitespaceOnlyText(openPrefix)) openPrefix = "";
-    if (key && openPrefix) touchStablePrefixKey(key, openPrefix);
+    stableState = stableStateForText(openPrefix, stableState);
+    if (key && openPrefix) touchStablePrefixKey(key, stableState);
     else if (key) stablePrefixByStreamKey.delete(key);
     const unstableSuffix2 = t.substring(openPrefix.length);
     return cacheResolvedPartsKey(key, t, {
       plain: false,
       openFence: true,
       stablePrefix: openPrefix,
+      stableChunks: stableState.chunks,
       unstableSuffix: unstableSuffix2,
       unstableForRender: unstableSuffix2
     });
@@ -11584,18 +11690,24 @@ function resolveStreamingMarkdownParts(text, streamKey) {
     if (advance > 0) {
       stablePrefix = t.substring(0, boundary + advance);
       if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = "";
-      if (key && stablePrefix) touchStablePrefixKey(key, stablePrefix);
+      stableState = stableStateForText(stablePrefix, stableState);
+      if (key && stablePrefix) touchStablePrefixKey(key, stableState);
       else if (key && !stablePrefix) stablePrefixByStreamKey.delete(key);
     }
   } catch {
     stablePrefix = "";
+    stableState = { text: "", chunks: [] };
     if (key) stablePrefixByStreamKey.delete(key);
   }
-  if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = "";
+  if (isWhitespaceOnlyText(stablePrefix)) {
+    stablePrefix = "";
+    stableState = { text: "", chunks: [] };
+  }
   const unstableSuffix = t.substring(stablePrefix.length);
   return cacheResolvedPartsKey(key, t, {
     plain: false,
     stablePrefix,
+    stableChunks: stableState.chunks,
     unstableSuffix,
     unstableForRender: balanceStreamingMarkdown(unstableSuffix)
   });
@@ -11721,22 +11833,31 @@ function measureStreamingMarkdownRenderedRows(text, columns, streamKey) {
   let rows = 0;
   let childCount = 0;
   let stableRows = 0;
-  if (parts.stablePrefix) {
-    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
   });
@@ -12818,6 +12939,9 @@ function cacheStreamingTailEstimate(id, entry) {
 function hasStreamingRowStateToPrune() {
   return streamingMeasuredRowsById.size > 0 || streamingEstimateHighWaterById.size > 0 || streamingTailEstimateById.size > 0;
 }
+function transcriptHarvestInputsEqual(left, right) {
+  return !!left && !!right && left.revision === right.revision && left.settledItems === right.settledItems && left.streamingTailItem === right.streamingTailItem && left.startIndex === right.startIndex && left.endIndex === right.endIndex && left.frameColumns === right.frameColumns && left.toolOutputExpanded === right.toolOutputExpanded && left.transcriptContentHeight === right.transcriptContentHeight && left.floatingPanelRows === right.floatingPanelRows && left.overlayHintRequested === right.overlayHintRequested && left.transcriptGuardRows === right.transcriptGuardRows && left.themeEpoch === right.themeEpoch;
+}
 function pruneStreamingMeasuredRowsById(liveIds) {
   if (!liveIds) return;
   if (streamingMeasuredRowsById.size > 0) {
@@ -13632,13 +13756,30 @@ import { useCallback as useCallback3, useEffect as useEffect8, useRef as useRef8
 // src/tui/engine/render-timing.mjs
 var RENDER_ACK_HANG_GUARD_MS = 250;
 var RENDER_SETTLE_IDLE_MS = 64;
+var TUI_RENDER_FPS = 60;
+var TUI_FRAME_MS = Math.ceil(1e3 / TUI_RENDER_FPS);
 var pendingRenderAcks = [];
 var renderAckSeq = 0;
+var lastRenderFrameAt = 0;
+var renderFrameDelay = (lastFrameAt, currentTime, frameMs = TUI_FRAME_MS) => {
+  if (!(lastFrameAt > 0)) return frameMs;
+  return Math.max(0, frameMs - Math.max(0, currentTime - lastFrameAt));
+};
+var scheduleRenderAlignedStoreFlush = (callback, frameMs = TUI_FRAME_MS) => {
+  const timer2 = setTimeout(
+    callback,
+    renderFrameDelay(lastRenderFrameAt, performance.now(), frameMs)
+  );
+  timer2.unref?.();
+  return timer2;
+};
+var cancelRenderAlignedStoreFlush = (timer2) => clearTimeout(timer2);
 var scheduleRenderFrameAck = () => {
   const seq = ++renderAckSeq;
   setImmediate(() => notifyRenderFrame(seq));
 };
 var notifyRenderFrame = (seq = ++renderAckSeq) => {
+  lastRenderFrameAt = performance.now();
   if (pendingRenderAcks.length === 0) return;
   const acks = pendingRenderAcks;
   pendingRenderAcks = [];
@@ -14285,6 +14426,11 @@ function useTranscriptWindow({
   const prevViewportGeomRef = useRef9({ contentHeight: 0, floatingPanelRows: 0 });
   const transcriptItemElsRef = useRef9(/* @__PURE__ */ new Map());
   const transcriptMeasureRefCache = useRef9(/* @__PURE__ */ new Map());
+  const harvestGateRef = useRef9({
+    inputs: null,
+    skippedForDrag: false,
+    forceNext: false
+  });
   const transcriptMeasureItemsRef = useRef9(/* @__PURE__ */ new Map());
   const transcriptMeasureRef = useCallback4((item) => {
     if (!TRANSCRIPT_MEASURED_ROWS || !item || item.id == null) return void 0;
@@ -14516,11 +14662,33 @@ function useTranscriptWindow({
   const transcriptTailPinned = Math.max(0, Number(transcriptWindow.effectiveScrollOffset) || 0) === 0;
   const overlayHintOnLastItem = overlayHintRequested && floatingPanelRows <= 0 && transcriptWindow.bottomSpacerRows === 0 && transcriptTailPinned && overlayHintAttachItemIndex >= 0;
   const overlayHintFallbackRow = overlayHintRequested && floatingPanelRows <= 0 && transcriptGuardRows > 0 && !overlayHintOnLastItem;
+  const harvestInputs = {
+    revision,
+    settledItems,
+    streamingTailItem,
+    startIndex: transcriptWindow.startIndex,
+    endIndex: transcriptWindow.endIndex,
+    frameColumns,
+    toolOutputExpanded,
+    transcriptContentHeight,
+    floatingPanelRows,
+    overlayHintRequested,
+    transcriptGuardRows,
+    themeEpoch
+  };
   useLayoutEffect3(() => {
     if (!TRANSCRIPT_MEASURED_ROWS) return;
-    if (dragRef.current.active) return;
+    const gate = harvestGateRef.current;
+    if (dragRef.current.active) {
+      gate.skippedForDrag = true;
+      return;
+    }
+    if (!gate.skippedForDrag && !gate.forceNext && transcriptHarvestInputsEqual(gate.inputs, harvestInputs)) return;
     const els = transcriptItemElsRef.current;
     if (!els || els.size === 0) return;
+    gate.inputs = harvestInputs;
+    gate.skippedForDrag = false;
+    gate.forceNext = false;
     const liveItems = transcriptMeasureItemsRef.current;
     const toolExpandedFlag = toolOutputExpanded ? 1 : 0;
     let changed = false;
@@ -14595,6 +14763,7 @@ function useTranscriptWindow({
           }, 0);
           if (typeof streak.timer?.unref === "function") streak.timer.unref();
         }
+        gate.forceNext = true;
         setMeasuredRowsVersion((v) => (v + 1) % 1e6);
       }
     }
@@ -17227,46 +17396,26 @@ function createChannelPickers({
     }
     if (focus === "webhook-endpoint") {
       const returnTo = typeof options.returnTo === "function" ? options.returnTo : () => setPicker(null);
-      const domain = setup.webhook?.ngrokDomain || setup.webhook?.domain || "";
+      const publicUrl = setup.webhook?.publicUrl || "";
       const items2 = [
         {
-          value: "endpoint-domain",
-          label: "ngrok domain",
-          description: domain ? domain : "Not set \xB7 Enter ngrok domain",
-          _action: "endpoint-domain"
-        },
-        {
-          value: "endpoint-authtoken",
-          label: "authtoken",
-          description: setup.webhook?.authenticated === true ? "Set" : "Not set \xB7 Enter authtoken",
-          _action: "endpoint-authtoken"
+          value: "endpoint-url",
+          label: "Public URL",
+          description: publicUrl ? `${publicUrl}/webhook/<name>` : "Assigned when the channel worker connects to the relay",
+          _action: "endpoint-url"
         }
       ];
       setPicker({
         title: "Webhook endpoint",
-        description: "ngrok domain and authtoken. Toggle individual webhooks in /webhooks.",
+        description: "Served through the Mixdog relay \u2014 no tunnel setup needed. Toggle individual webhooks in /webhooks.",
         help: "\u2191/\u2193 Select \xB7 Enter Edit \xB7 Esc Back",
         indexMode: "always",
         labelWidth: 18,
         items: items2,
         onSelect: (_value, item) => {
           try {
-            if (item._action === "endpoint-domain") {
-              openChannelPrompt({
-                kind: "webhook-domain",
-                label: "ngrok domain",
-                hint: "Paste the reserved ngrok domain (e.g. my-app.ngrok-free.app).",
-                afterSave: () => void openChannelSetupPicker("webhook-endpoint", options)
-              });
-              return;
-            }
-            if (item._action === "endpoint-authtoken") {
-              openChannelPrompt({
-                kind: "webhook-token",
-                label: "Webhook/ngrok authtoken",
-                hint: "Paste the webhook/ngrok authtoken. It is stored in the OS keychain.",
-                afterSave: () => void openChannelSetupPicker("webhook-endpoint", options)
-              });
+            if (item._action === "endpoint-url") {
+              store.pushNotice(publicUrl ? `Webhook base: ${publicUrl}/webhook/<name>` : "URL not assigned yet \u2014 start channels once and reopen.", "info");
             }
           } catch (e) {
             store.pushNotice(`webhook endpoint failed: ${e?.message || e}`, "error");
@@ -17401,20 +17550,10 @@ function createChannelPickers({
       {
         value: "webhook-endpoint",
         label: "Webhook endpoint",
-        meta: (() => {
-          const hasDomain = Boolean(setup.webhook?.ngrokDomain || setup.webhook?.domain);
-          const hasAuth = setup.webhook?.authenticated === true;
-          return hasDomain && hasAuth ? "On" : "Off";
-        })(),
-        description: (() => {
-          const hasDomain = Boolean(setup.webhook?.ngrokDomain || setup.webhook?.domain);
-          const hasAuth = setup.webhook?.authenticated === true;
-          const needs = [
-            ...hasDomain ? [] : ["domain"],
-            ...hasAuth ? [] : ["authtoken"]
-          ];
-          return needs.length ? `Needs ${needs.join(" + ")}` : "ngrok domain and authtoken set";
-        })(),
+        // Relay tunnel: public exposure is automatic, so the endpoint is
+        // "On" whenever the webhook server itself is enabled.
+        meta: setup.webhook?.enabled === false ? "Off" : "On",
+        description: setup.webhook?.publicUrl ? setup.webhook.publicUrl : "Mixdog relay tunnel \u2014 URL assigned on first run",
         _action: "webhook-endpoint"
       }
     ];
@@ -20156,13 +20295,29 @@ function Markdown({ children, themeEpoch = 0, trimPartialFences = false, columns
   }, [children, themeEpoch, trimPartialFences, columns]);
   return /* @__PURE__ */ jsx13(Box11, { flexDirection: "column", gap: 1, children: elements });
 }
+var StableMarkdownChunk = React13.memo(function StableMarkdownChunk2({
+  text,
+  themeEpoch,
+  columns
+}) {
+  return /* @__PURE__ */ jsx13(Markdown, { themeEpoch, columns, children: text });
+});
 function StreamingMarkdown({ children, themeEpoch = 0, columns, streamKey }) {
   const parts = resolveStreamingMarkdownParts(children, streamKey);
   if (parts.plain) {
     return /* @__PURE__ */ jsx13(Text13, { color: theme.text, wrap: "wrap", children: parts.unstableForRender });
   }
+  const stableChunks = parts.stableChunks?.length ? parts.stableChunks : parts.stablePrefix ? [parts.stablePrefix] : [];
   return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", gap: 1, children: [
-    parts.stablePrefix ? /* @__PURE__ */ jsx13(Markdown, { themeEpoch, columns, children: parts.stablePrefix }) : null,
+    stableChunks.map((text, index) => /* @__PURE__ */ jsx13(
+      StableMarkdownChunk,
+      {
+        text,
+        themeEpoch,
+        columns
+      },
+      `stable-${index}`
+    )),
     parts.unstableSuffix ? /* @__PURE__ */ jsx13(Markdown, { themeEpoch, columns, trimPartialFences: true, children: parts.unstableForRender }) : null
   ] });
 }
@@ -20181,7 +20336,7 @@ var AssistantMessage = React14.memo(function AssistantMessage2({
     if (!streaming && assistantId) resetStreamingMarkdownStablePrefix(assistantId);
   }, [streaming, assistantId]);
   const bodyWidth = assistantBodyWidth(columns);
-  const renderText = streaming && streamingWindowRows > 0 ? windowPlainStreamingText(text, bodyWidth, streamingWindowRows) : text;
+  const renderText = streaming && streamingWindowRows > 0 ? windowPlainStreamingText(text, bodyWidth, streamingWindowRows, assistantId) : text;
   return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "row", marginTop: 1, children: [
     /* @__PURE__ */ jsx14(Box12, { flexShrink: 0, minWidth: 2, children: /* @__PURE__ */ jsx14(Text14, { color: theme.text, children: TURN_MARKER }) }),
     /* @__PURE__ */ jsx14(Box12, { flexDirection: "column", flexShrink: 0, width: bodyWidth, children: streaming ? /* @__PURE__ */ jsx14(StreamingMarkdown, { themeEpoch, columns: bodyWidth, streamKey: assistantId, children: renderText }) : /* @__PURE__ */ jsx14(Markdown, { themeEpoch, columns: bodyWidth, children: text }) })
@@ -20210,7 +20365,7 @@ import React16 from "react";
 import { Box as Box14, Text as Text16 } from "../../../vendor/ink/build/index.js";
 import stringWidth9 from "string-width";
 
-// src/tui/components/tool-execution/text-format.mjs
+// src/runtime/shared/tool-card-model.mjs
 import stripAnsi6 from "strip-ansi";
 
 // src/runtime/shared/tool-status.mjs
@@ -20234,7 +20389,7 @@ function toolResultTerminalStatus(text) {
   return normalizeToolTerminalStatus(inline);
 }
 
-// src/tui/components/tool-execution/text-format.mjs
+// src/runtime/shared/tool-card-model.mjs
 var MIN_RESULT_LINE_CHARS = 24;
 var RESULT_LINE_HARD_MAX = 80;
 var SUMMARY_MAX_CHARS = 48;
@@ -20258,47 +20413,9 @@ function normalizeCountMap(value = {}) {
   }
   return out;
 }
-function deltaColor(token) {
-  return String(token || "").startsWith("+") ? theme.success : theme.error;
-}
-function deltaTextParts(text) {
-  const value = String(text ?? "");
-  const parts = [];
-  const re = /(^|[\s([,{·])([+-]\s*\d+)(?=\s+Lines?\b)/gi;
-  let last = 0;
-  let match;
-  while (match = re.exec(value)) {
-    const prefix = match[1] || "";
-    const token = (match[2] || "").replace(/\s+/g, "");
-    const tokenStart = match.index + prefix.length;
-    if (match.index > last) parts.push({ text: value.slice(last, match.index) });
-    if (prefix) parts.push({ text: prefix });
-    if (token) parts.push({ text: token, color: deltaColor(token) });
-    last = tokenStart + (match[2] || "").length;
-  }
-  if (last < value.length) parts.push({ text: value.slice(last) });
-  return parts;
-}
 function plural(count, singular, pluralText = `${singular}s`) {
   return count === 1 ? singular : pluralText;
 }
-function fitResultLine(line, columns) {
-  const max = Math.min(RESULT_LINE_HARD_MAX, Math.max(MIN_RESULT_LINE_CHARS, Number(columns || 80) - 7));
-  const text = safeInlineText(line);
-  return displayWidth(text) > max ? truncateToWidth(text, max) : text;
-}
-function truncateToWidth(text, maxWidth) {
-  const str = safeInlineText(text);
-  if (maxWidth < 1) return "";
-  if (displayWidth(str) <= maxWidth) return str;
-  const chars = Array.from(str);
-  let out = "";
-  for (const ch of chars) {
-    if (displayWidth(out + ch + "\u2026") > maxWidth) break;
-    out += ch;
-  }
-  return `${out}\u2026`;
-}
 function shellResultStatus(value) {
   const match = String(value || "").match(/(?:^|\b)status:\s*(running|pending|queued|completed|failed|cancelled|canceled)\b/im);
   return match ? String(match[1] || "").toLowerCase() : "";
@@ -20334,8 +20451,6 @@ function shellResultElapsed(value) {
   const elapsedMs = Number(match[1]);
   return Number.isFinite(elapsedMs) && elapsedMs >= 1e3 ? formatElapsed(elapsedMs) : "";
 }
-
-// src/tui/components/tool-execution/surface-detail.mjs
 function isShellTool(normalizedName, label = "") {
   const n = String(normalizedName || "").toLowerCase();
   const l = String(label || "").toLowerCase();
@@ -20667,6 +20782,248 @@ function clampFailureCount(errorCount, groupCount, isError) {
   if (Number.isFinite(explicit)) return Math.max(0, Math.min(groupCount, Math.floor(explicit)));
   return isError ? groupCount : 0;
 }
+function clipPlain(text, maxChars) {
+  const value = safeInlineText(text);
+  const max = Math.max(1, Number(maxChars) || 1);
+  if (value.length <= max) return value;
+  return `${value.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+function deriveToolCardModel(input = {}, options = {}) {
+  const {
+    name = "",
+    args = {},
+    result = null,
+    rawResult = null,
+    isError = false,
+    errorCount,
+    callErrorCount,
+    exitErrorCount,
+    count = 1,
+    completedCount,
+    startedAt = 0,
+    completedAt = 0,
+    aggregate = false,
+    categories = {},
+    doneCategories = null,
+    headerFinalized = true
+  } = input;
+  const nowMs = Number(input.nowMs || Date.now());
+  const truncate2 = typeof options.truncate === "function" ? options.truncate : clipPlain;
+  const maxResultChars = Math.max(
+    MIN_RESULT_LINE_CHARS,
+    Math.min(RESULT_LINE_HARD_MAX, Number(options.maxResultChars ?? RESULT_LINE_HARD_MAX))
+  );
+  const groupCount = Math.max(1, Number(count || 1));
+  const doneCount = Math.max(0, Math.min(groupCount, Number(completedCount ?? (result == null ? 0 : groupCount))));
+  const rt = result == null ? null : String(result).replace(/\s+$/, "");
+  const rawRt = rawResult == null ? null : String(rawResult).replace(/\s+$/, "");
+  const pending = doneCount < groupCount;
+  const headerPending = pending || headerFinalized === false;
+  const hasResult = result != null && Boolean(String(rt || "").trim());
+  const hasRawResult = rawResult != null && Boolean(String(rawRt || "").trim());
+  const startedAtMs = Number(startedAt || 0);
+  const completedAtMs = Number(completedAt || 0);
+  const elapsedMs = startedAtMs ? Math.max(0, (pending ? nowMs : completedAtMs || nowMs) - startedAtMs) : 0;
+  const elapsed = elapsedMs >= 1e3 ? formatElapsed(elapsedMs) : "";
+  const failedCount = clampFailureCount(errorCount, groupCount, isError);
+  const callFailedCount = clampFailureCount(callErrorCount, groupCount, false);
+  const exitFailedCount = clampFailureCount(exitErrorCount, groupCount, false);
+  if (aggregate) {
+    const displayCategories = normalizeCountMap(categories || {});
+    const normalizedDone = doneCategories ? normalizeCountMap(doneCategories) : displayCategories;
+    const hasDoneCounts = Object.values(normalizedDone || {}).some(
+      (v) => (v && typeof v === "object" ? Number(v.count || 0) : Number(v || 0)) > 0
+    );
+    const displayDone = hasDoneCounts ? normalizedDone : displayCategories;
+    const headerOrder = Array.isArray(args?.categoryOrder) ? args.categoryOrder : null;
+    const labelText2 = safeInlineText(formatAggregateHeader(
+      (headerPending ? displayCategories : displayDone) || {},
+      { pending: headerPending, order: headerOrder }
+    ));
+    const detailText = hasResult ? safeInlineText(rt) : "";
+    const terminalStatus2 = pending ? "running" : resultTerminalStatus(rt) || (isError || failedCount > 0 ? "failed" : "completed");
+    return {
+      aggregate: true,
+      pending,
+      headerPending,
+      groupCount,
+      doneCount,
+      elapsed,
+      failedCount,
+      callFailedCount,
+      exitFailedCount,
+      terminalStatus: terminalStatus2,
+      labelText: labelText2,
+      summaryText: "",
+      headerFailureText: "",
+      detailLine: detailText || (pending ? "Running" : "Finished"),
+      detailIsPlaceholder: !detailText,
+      hasResult,
+      hasRawResult,
+      displayedResultBodyText: rt || "",
+      firstResultLine: detailText,
+      totalLines: detailText ? 1 : 0,
+      resultSummary: detailText || null,
+      toolArgPath: "",
+      normalizedName: "",
+      label: "",
+      parsedArgs: args,
+      isShellSurface: false,
+      isSkillSurface: false,
+      isAgentSurfaceCard: false,
+      isAgentResponse: false,
+      isBackgroundResponse: false,
+      isBackgroundMetadataResult: false,
+      backgroundMeta: null
+    };
+  }
+  const { label, summary, normalizedName, args: parsedArgs } = formatToolSurface(name, args);
+  const isShellSurface = isShellTool(normalizedName, label);
+  const isSkillSurface = SKILL_SURFACE_NAMES2.has(String(normalizedName || "").toLowerCase());
+  const backgroundMeta = !pending && isBackgroundTaskTool(normalizedName) ? resolveBackgroundTaskMeta(parsedArgs, rt || "") : null;
+  const backgroundError = backgroundMeta?.error || parsedArgs?.error || "";
+  const errorOnlyResult = Boolean(rt) && isBackgroundErrorOnlyBody(rt, backgroundError);
+  const backgroundResultText = backgroundMeta?.hasResponse ? backgroundMeta.body : "";
+  const displayedResultText = backgroundResultText || (errorOnlyResult ? "" : rt || "");
+  const hasDisplayResult = Boolean(String(displayedResultText || "").trim());
+  const displayedResultBodyText = stripLeadingStatusMarkerFromText(displayedResultText);
+  const hasDisplayBody = Boolean(String(displayedResultBodyText || "").trim());
+  const lines = displayedResultBodyText ? displayedResultBodyText.split("\n") : [];
+  const totalLines = lines.length;
+  const resultSummary = !pending && hasDisplayBody ? summarizeToolResult(name, args, displayedResultBodyText, isError) : null;
+  const firstResultLine = hasDisplayResult ? String(lines[0] ?? "") : "";
+  const shellStatus = isShellSurface ? shellDisplayStatus({ pending, failedCount, exitFailedCount, isError, result: displayedResultText }) : "";
+  const shellElapsed = isShellSurface ? shellResultElapsed(displayedResultText) || elapsed : "";
+  const backgroundElapsed = backgroundMeta ? backgroundTaskElapsed(backgroundMeta, elapsed) : isBackgroundTaskTool(normalizedName) ? backgroundTaskElapsed(parsedArgs, elapsed) : "";
+  const toolArgPath = parsedArgs?.path ?? parsedArgs?.file_path ?? parsedArgs?.file ?? "";
+  const imageDetail = normalizedName === "view_image" && toolArgPath && !isError ? String(toolArgPath) : "";
+  const isBackgroundResult = !pending && isBackgroundTaskTool(normalizedName) && Boolean(backgroundMeta);
+  const isBackgroundResponse = isBackgroundResult && (backgroundMeta?.hasResponse || isBackgroundTaskResponseArgs(normalizedName, parsedArgs));
+  const isBackgroundMetadataResult = isBackgroundResult && !isBackgroundResponse && Boolean(backgroundMeta);
+  const backgroundMetadataFailureLabel = isBackgroundMetadataResult ? backgroundTaskFailureDetail(backgroundMeta, parsedArgs) : "";
+  const backgroundMetadataHeaderFailure = Boolean(backgroundMetadataFailureLabel) && !hasDisplayResult ? backgroundMetadataFailureLabel : "";
+  const agentHeaderFailure = !pending && isAgentTool(normalizedName) && isError && parsedArgs?.error && !hasDisplayResult ? backgroundTaskFailureStatusLabel(parsedArgs?.status, parsedArgs?.error, { surface: "agent" }) : "";
+  const headerFailureText = backgroundMetadataHeaderFailure || agentHeaderFailure || "";
+  const agentCompletionDetail = !pending && isAgentTool(normalizedName) && !agentHeaderFailure ? agentTerminalDetail(parsedArgs?.status, isError, elapsed, parsedArgs?.error) : "";
+  const agentDetail = !pending && isAgentTool(normalizedName) && !hasDisplayResult ? agentCompletionDetail : "";
+  const genericDetail = !pending && !isShellSurface && !agentDetail && !imageDetail && !resultSummary ? genericCompletedDetail({ normalizedName, label, hasResult, firstResultLine, isError }) : "";
+  const terminalStatus = pending ? "running" : shellStatus || normalizeTerminalStatus(backgroundMeta?.status) || normalizeTerminalStatus(parsedArgs?.status) || resultTerminalStatus(displayedResultText) || (isError || failedCount > 0 ? "failed" : "completed");
+  const backgroundMetadataDetail = isBackgroundMetadataResult && !backgroundMetadataHeaderFailure ? backgroundTaskDetail(backgroundMeta, backgroundElapsed, parsedArgs) : "";
+  const backgroundResponseDetail = isBackgroundResponse && resultSummary ? prefixElapsed(resultSummary, backgroundElapsed) : resultSummary;
+  const syncElapsedDetail = !isBackgroundResponse && shouldPrefixSyncElapsed(normalizedName, label) ? prefixElapsed(backgroundResponseDetail, elapsed) : backgroundResponseDetail;
+  const nonShellDetail = backgroundMetadataDetail || (/^(Cancelled|Failed|Finished)$/i.test(resultSummary || "") && agentCompletionDetail ? agentCompletionDetail : syncElapsedDetail) || agentDetail || imageDetail || genericDetail;
+  const pendingDetailPlaceholder = pending && !isSkillSurface ? elapsed ? `Running \xB7 ${elapsed}` : "Running" : "";
+  const shellCollapsedSummary = isShellSurface && !pending && hasDisplayResult ? resultSummary || truncate2(firstResultLine, Math.min(120, maxResultChars)) : resultSummary;
+  const collapsedDetail = pending ? pendingDetailPlaceholder : isShellSurface ? prefixElapsed(mergeTerminalDetail(shellStatus, shellCollapsedSummary), shellElapsed) : mergeTerminalDetail(terminalStatus, nonShellDetail);
+  const isAgentResult = !isBackgroundResult && !pending && isAgentTool(normalizedName) && hasDisplayResult;
+  const isAgentResponse = isAgentResult && hasAgentResponseResult(rt);
+  const isAgentSurfaceCard = isAgentTool(normalizedName);
+  const agentSurfaceBriefRaw = isAgentSurfaceCard ? summarizeAgentSurfaceBrief(name, parsedArgs, displayedResultText || "", { isError, isResponse: isAgentResponse }) : "";
+  const agentSurfaceBrief = agentSurfaceBriefRaw ? truncate2(agentSurfaceBriefRaw, Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars)) : "";
+  let detailLine = collapsedDetail;
+  if (isSkillSurface) {
+    detailLine = isError && collapsedDetail ? collapsedDetail : "";
+  } else if (isBackgroundMetadataResult && backgroundMetadataHeaderFailure) {
+    detailLine = "";
+  } else if (isAgentSurfaceCard) {
+    const agentDetailFallback = collapsedDetail || (pending ? pendingDetailPlaceholder || "Running" : "Finished");
+    const agentDetailLine = agentSurfaceBrief || truncate2(String(agentDetailFallback), Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars));
+    const agentFailureText = /\b(Cancelled|Canceled|Failed)\b/i.test(agentSurfaceBrief || collapsedDetail || "");
+    const keepAgentDetail = (isError || agentFailureText) && !(agentHeaderFailure && !agentSurfaceBrief);
+    detailLine = keepAgentDetail ? agentDetailLine : "";
+  }
+  let labelText;
+  if (isAgentResponse) labelText = agentResponseTitle(parsedArgs, groupCount);
+  else if (isBackgroundResponse) labelText = backgroundTaskResultTitle(normalizedName, backgroundMeta || parsedArgs);
+  else if (isBackgroundMetadataResult) labelText = backgroundTaskActionTitle(normalizedName, backgroundMeta);
+  else if (isShellSurface) labelText = shellHeader(shellStatus, groupCount);
+  else labelText = (isAgentTool(normalizedName) ? agentActionTitle(parsedArgs) : "") || formatToolActionHeader(name, args, { pending: headerPending, count: groupCount });
+  labelText = safeInlineText(labelText);
+  const toolSearchSummary = !pending && normalizedName === "load_tool" && hasResult ? toolSearchLoadedSummary(displayedResultText) : "";
+  const rawSummaryText = safeInlineText(isAgentResponse || isBackgroundResponse ? "" : toolSearchSummary || (isAgentTool(normalizedName) ? agentActionSummary(parsedArgs, summary) : summary));
+  const summaryIsHeaderCount = rawSummaryText && /^\d+\s+\S+$/.test(rawSummaryText) && labelText.endsWith(rawSummaryText);
+  const summaryText = summaryIsHeaderCount ? "" : rawSummaryText;
+  return {
+    aggregate: false,
+    pending,
+    headerPending,
+    groupCount,
+    doneCount,
+    elapsed,
+    failedCount,
+    callFailedCount,
+    exitFailedCount,
+    terminalStatus,
+    labelText,
+    summaryText,
+    headerFailureText,
+    detailLine,
+    detailIsPlaceholder: Boolean(pendingDetailPlaceholder) && detailLine === pendingDetailPlaceholder,
+    hasResult,
+    hasRawResult,
+    hasDisplayResult,
+    hasDisplayBody,
+    displayedResultBodyText,
+    firstResultLine,
+    totalLines,
+    resultSummary,
+    shellCollapsedSummary,
+    agentSurfaceBrief,
+    toolArgPath: String(toolArgPath || ""),
+    normalizedName,
+    label,
+    parsedArgs,
+    isShellSurface,
+    isSkillSurface,
+    isAgentSurfaceCard,
+    isAgentResponse,
+    isBackgroundResponse,
+    isBackgroundMetadataResult,
+    backgroundMeta
+  };
+}
+
+// src/tui/components/tool-execution/text-format.mjs
+function deltaColor(token) {
+  return String(token || "").startsWith("+") ? theme.success : theme.error;
+}
+function deltaTextParts(text) {
+  const value = String(text ?? "");
+  const parts = [];
+  const re = /(^|[\s([,{·])([+-]\s*\d+)(?=\s+Lines?\b)/gi;
+  let last = 0;
+  let match;
+  while (match = re.exec(value)) {
+    const prefix = match[1] || "";
+    const token = (match[2] || "").replace(/\s+/g, "");
+    const tokenStart = match.index + prefix.length;
+    if (match.index > last) parts.push({ text: value.slice(last, match.index) });
+    if (prefix) parts.push({ text: prefix });
+    if (token) parts.push({ text: token, color: deltaColor(token) });
+    last = tokenStart + (match[2] || "").length;
+  }
+  if (last < value.length) parts.push({ text: value.slice(last) });
+  return parts;
+}
+function fitResultLine(line, columns) {
+  const max = Math.min(RESULT_LINE_HARD_MAX, Math.max(MIN_RESULT_LINE_CHARS, Number(columns || 80) - 7));
+  const text = safeInlineText(line);
+  return displayWidth(text) > max ? truncateToWidth(text, max) : text;
+}
+function truncateToWidth(text, maxWidth) {
+  const str = safeInlineText(text);
+  if (maxWidth < 1) return "";
+  if (displayWidth(str) <= maxWidth) return str;
+  const chars = Array.from(str);
+  let out = "";
+  for (const ch of chars) {
+    if (displayWidth(out + ch + "\u2026") > maxWidth) break;
+    out += ch;
+  }
+  return `${out}\u2026`;
+}
+
+// src/tui/components/tool-execution/surface-detail.mjs
 function toolStatusColor({ pending, groupCount, callFailedCount = 0, exitFailedCount = 0, terminalStatus = "" }) {
   if (pending) return theme.text;
   const status = normalizeTerminalStatus(terminalStatus);
@@ -20705,9 +21062,6 @@ import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
 var TOOL_BLINK_MS = 500;
 var TOOL_PENDING_SHOW_DELAY_MS = 1e3;
 var TOOL_ANIM_TICK_MS = TOOL_BLINK_MS;
-function statusCopy(name, label, count, doneCount, pending, isError, args = {}) {
-  return formatToolActionHeader(name, args, { pending, count });
-}
 function ToolExecution({ name, args, result, rawResult, isError, errorCount, callErrorCount, exitErrorCount, expanded, columns = 80, attached = false, count = 1, completedCount = 0, startedAt = 0, completedAt = 0, aggregate = false, categories = {}, doneCategories = null, headerFinalized = true, deferredDisplayReady = false, agentResponseAggregate = false }) {
   const rowWidth = Math.max(1, Number(columns || 80));
   const groupCount = Math.max(1, Number(count || 1));
@@ -20794,87 +21148,60 @@ function ToolExecution({ name, args, result, rawResult, isError, errorCount, cal
       )
     ] });
   }
-  const { label, summary, normalizedName, args: parsedArgs } = formatToolSurface(name, args);
-  const isShellSurface = isShellTool(normalizedName, label);
-  const isSkillSurface = SKILL_SURFACE_NAMES2.has(String(normalizedName || "").toLowerCase());
-  const backgroundMeta = !pending && isBackgroundTaskTool(normalizedName) ? resolveBackgroundTaskMeta(parsedArgs, rt || "") : null;
-  const backgroundError = backgroundMeta?.error || parsedArgs?.error || "";
-  const errorOnlyResult = Boolean(rt) && isBackgroundErrorOnlyBody(rt, backgroundError);
-  const backgroundResultText = backgroundMeta?.hasResponse ? backgroundMeta.body : "";
-  const displayedResultText = backgroundResultText || (errorOnlyResult ? "" : rt || "");
-  const hasDisplayResult = Boolean(String(displayedResultText || "").trim());
-  const displayedResultBodyText = stripLeadingStatusMarkerFromText(displayedResultText);
-  const hasDisplayBody = Boolean(String(displayedResultBodyText || "").trim());
-  const lines = displayedResultBodyText ? displayedResultBodyText.split("\n") : [];
-  const totalLines = lines.length;
-  const resultSummary = !pending && hasDisplayBody ? summarizeToolResult(name, args, displayedResultBodyText, isError) : null;
   const maxResultChars = Math.min(RESULT_LINE_HARD_MAX, Math.max(MIN_RESULT_LINE_CHARS, Number(columns || 80) - 7));
+  const model = deriveToolCardModel({
+    name,
+    args,
+    result,
+    rawResult,
+    isError,
+    errorCount,
+    callErrorCount,
+    exitErrorCount,
+    count: displayGroupCount,
+    completedCount: doneCount,
+    startedAt,
+    completedAt,
+    headerFinalized,
+    nowMs
+  }, { truncate: truncateToWidth, maxResultChars });
+  const {
+    labelText,
+    summaryText,
+    headerFailureText: headerFailureStatus,
+    detailLine: collapsedDetailLine,
+    detailIsPlaceholder,
+    terminalStatus,
+    normalizedName,
+    isShellSurface,
+    isAgentSurfaceCard,
+    isAgentResponse,
+    isBackgroundMetadataResult,
+    hasDisplayResult,
+    hasDisplayBody,
+    displayedResultBodyText,
+    firstResultLine,
+    totalLines,
+    resultSummary,
+    shellCollapsedSummary,
+    toolArgPath
+  } = model;
+  const lines = displayedResultBodyText ? displayedResultBodyText.split("\n") : [];
   const resultColor = theme.text;
-  const firstResultLine = hasDisplayResult ? String(lines[0] ?? "") : "";
   const firstResultLineClipped = hasDisplayBody && stringWidth9(firstResultLine) > maxResultChars;
   const hasHiddenDetail = !pending && hasDisplayBody && (totalLines > 1 || firstResultLineClipped || Boolean(resultSummary));
-  const shellStatus = isShellSurface ? shellDisplayStatus({ pending, failedCount, exitFailedCount, isError, result: displayedResultText }) : "";
-  const shellElapsed = isShellSurface ? shellResultElapsed(displayedResultText) || elapsed : "";
-  const backgroundElapsed = backgroundMeta ? backgroundTaskElapsed(backgroundMeta, elapsed) : isBackgroundTaskTool(normalizedName) ? backgroundTaskElapsed(parsedArgs, elapsed) : "";
-  const toolArgPath = parsedArgs?.path ?? parsedArgs?.file_path ?? parsedArgs?.file ?? "";
-  const imageDetail = normalizedName === "view_image" && toolArgPath && !isError ? String(toolArgPath) : "";
-  const isBackgroundResult = !pending && isBackgroundTaskTool(normalizedName) && Boolean(backgroundMeta);
-  const isBackgroundResponse = isBackgroundResult && (backgroundMeta?.hasResponse || isBackgroundTaskResponseArgs(normalizedName, parsedArgs));
-  const isBackgroundMetadataResult = isBackgroundResult && !isBackgroundResponse && Boolean(backgroundMeta);
-  const backgroundMetadataFailureLabel = isBackgroundMetadataResult ? backgroundTaskFailureDetail(backgroundMeta, parsedArgs) : "";
-  const backgroundMetadataHeaderFailure = Boolean(backgroundMetadataFailureLabel) && !hasDisplayResult ? backgroundMetadataFailureLabel : "";
-  const agentHeaderFailure = !pending && isAgentTool(normalizedName) && isError && parsedArgs?.error && !hasDisplayResult ? backgroundTaskFailureStatusLabel(parsedArgs?.status, parsedArgs?.error, { surface: "agent" }) : "";
-  const headerFailureStatus = backgroundMetadataHeaderFailure || agentHeaderFailure || "";
-  const agentCompletionDetail = !pending && isAgentTool(normalizedName) && !agentHeaderFailure ? agentTerminalDetail(parsedArgs?.status, isError, elapsed, parsedArgs?.error) : "";
-  const agentDetail = !pending && isAgentTool(normalizedName) && !hasDisplayResult ? agentCompletionDetail : "";
-  const genericDetail = !pending && !isShellSurface && !agentDetail && !imageDetail && !resultSummary ? genericCompletedDetail({ normalizedName, label, hasResult, firstResultLine, isError }) : "";
-  const terminalStatus = pending ? "running" : shellStatus || normalizeTerminalStatus(backgroundMeta?.status) || normalizeTerminalStatus(parsedArgs?.status) || resultTerminalStatus(displayedResultText) || (isError || failedCount > 0 ? "failed" : "completed");
-  const backgroundMetadataDetail = isBackgroundMetadataResult && !backgroundMetadataHeaderFailure ? backgroundTaskDetail(backgroundMeta, backgroundElapsed, parsedArgs) : "";
-  const backgroundResponseDetail = isBackgroundResponse && resultSummary ? prefixElapsed(resultSummary, backgroundElapsed) : resultSummary;
-  const syncElapsedDetail = !isBackgroundResponse && shouldPrefixSyncElapsed(normalizedName, label) ? prefixElapsed(backgroundResponseDetail, elapsed) : backgroundResponseDetail;
-  const nonShellDetail = backgroundMetadataDetail || (/^(Cancelled|Failed|Finished)$/i.test(resultSummary || "") && agentCompletionDetail ? agentCompletionDetail : syncElapsedDetail) || agentDetail || imageDetail || genericDetail;
-  const pendingDetailPlaceholder = pending && !isSkillSurface ? elapsed ? `Running \xB7 ${elapsed}` : "Running" : "";
-  const shellCollapsedSummary = isShellSurface && !pending && hasDisplayResult ? resultSummary || truncateToWidth(firstResultLine, Math.min(120, maxResultChars)) : resultSummary;
-  const collapsedDetail = pending ? pendingDetailPlaceholder : isShellSurface ? prefixElapsed(mergeTerminalDetail(shellStatus, shellCollapsedSummary), shellElapsed) : mergeTerminalDetail(terminalStatus, nonShellDetail);
   const backgroundMetadataExpandable = isBackgroundMetadataResult && hasRawResult && !pending;
   const showRawResult = expanded && (hasDisplayBody || hasRawResult) && (!isBackgroundMetadataResult || hasRawResult);
-  const detailLines = showRawResult ? agentResponseAggregate && hasRawResult ? stripLeadingStatusMarkerLines(rawRt.split("\n")) : hasDisplayBody ? lines : rawRt ? stripLeadingStatusMarkerLines(rawRt.split("\n")) : [] : collapsedDetail ? [collapsedDetail] : [];
-  const isPendingPlaceholderDetail = !showRawResult && Boolean(pendingDetailPlaceholder);
+  const detailLines = showRawResult ? agentResponseAggregate && hasRawResult ? stripLeadingStatusMarkerLines(rawRt.split("\n")) : hasDisplayBody ? lines : rawRt ? stripLeadingStatusMarkerLines(rawRt.split("\n")) : [] : collapsedDetailLine ? [collapsedDetailLine] : [];
+  const isPendingPlaceholderDetail = !showRawResult && detailIsPlaceholder;
   const detailColor = isPendingPlaceholderDetail ? theme.subtle : theme.text;
-  const isAgentResult = !isBackgroundResult && !pending && isAgentTool(normalizedName) && hasDisplayResult;
-  const isAgentResponse = isAgentResult && hasAgentResponseResult(rt);
-  const isAgentSurfaceCard = isAgentTool(normalizedName);
-  const agentSurfaceBriefRaw = isAgentSurfaceCard && !showRawResult ? summarizeAgentSurfaceBrief(name, parsedArgs, displayedResultText || "", { isError, isResponse: isAgentResponse }) : "";
-  const agentSurfaceBrief = agentSurfaceBriefRaw ? truncateToWidth(agentSurfaceBriefRaw, Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars)) : "";
-  let visibleDetailLines = detailLines;
-  if (isSkillSurface && !showRawResult) {
-    visibleDetailLines = isError && collapsedDetail ? [collapsedDetail] : [];
-  } else if (isBackgroundMetadataResult && backgroundMetadataHeaderFailure && !showRawResult) {
-    visibleDetailLines = [];
-  } else if (isAgentSurfaceCard && !showRawResult) {
-    const agentDetailFallback = collapsedDetail || (pending ? pendingDetailPlaceholder || "Running" : "Finished");
-    const agentDetailLine = agentSurfaceBrief || truncateToWidth(String(agentDetailFallback), Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars));
-    const agentFailureText = /\b(Cancelled|Canceled|Failed)\b/i.test(agentSurfaceBrief || collapsedDetail || "");
-    const keepAgentDetail = (isError || agentFailureText) && !(agentHeaderFailure && !agentSurfaceBrief);
-    visibleDetailLines = keepAgentDetail ? [agentDetailLine] : [];
-  }
+  const visibleDetailLines = detailLines;
   const finalStatusColor = toolStatusColor({ pending, groupCount, callFailedCount, exitFailedCount, terminalStatus });
   const dotColor = finalStatusColor;
   const markerGlyph = isAgentResponse ? AGENT_RESPONSE_MARKER : isAgentSurfaceCard ? AGENT_CALL_MARKER : TURN_MARKER;
   const isDirectionalMarker = isAgentResponse || isAgentSurfaceCard;
   const markerText = isDirectionalMarker ? `${markerGlyph} ` : markerGlyph;
   const dotText = pending && !blinkOn ? " " : markerText;
-  let labelText;
-  if (isAgentResponse) labelText = agentResponseTitle(parsedArgs, displayGroupCount);
-  else if (isBackgroundResponse) labelText = backgroundTaskResultTitle(normalizedName, backgroundMeta || parsedArgs);
-  else if (isBackgroundMetadataResult) labelText = backgroundTaskActionTitle(normalizedName, backgroundMeta);
-  else if (isShellSurface) labelText = shellHeader(shellStatus, displayGroupCount);
-  else labelText = (isAgentTool(normalizedName) ? agentActionTitle(parsedArgs) : "") || statusCopy(name, label, displayGroupCount, doneCount, headerPending, isError, parsedArgs);
-  labelText = safeInlineText(labelText);
-  const toolSearchSummary = !pending && normalizedName === "load_tool" && hasResult ? toolSearchLoadedSummary(displayedResultText) : "";
-  const rawSummaryText = safeInlineText(isAgentResponse || isBackgroundResponse ? "" : toolSearchSummary || (isAgentTool(normalizedName) ? agentActionSummary(parsedArgs, summary) : summary));
-  const summaryIsHeaderCount = rawSummaryText && /^\d+\s+\S+$/.test(rawSummaryText) && labelText.endsWith(rawSummaryText);
-  const summaryText = summaryIsHeaderCount ? "" : rawSummaryText;
   const agentHasExpandableBody = isAgentSurfaceCard && !pending && hasResult && (isAgentResponse || totalLines > 1 || firstResultLineClipped);
   const shellHasExpandableBody = isShellSurface && !pending && hasDisplayResult && hasDisplayBody && (totalLines > 1 || firstResultLineClipped || Boolean(shellCollapsedSummary && shellCollapsedSummary !== firstResultLine));
   const showHeaderExpandHint = (isShellSurface ? shellHasExpandableBody : isAgentSurfaceCard ? agentHasExpandableBody : hasHiddenDetail || backgroundMetadataExpandable) && normalizedName !== "load_tool";
@@ -22491,19 +22818,6 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
           resumeAfterChannelPrompt(channelPrompt);
           return true;
         }
-        if (channelPrompt.kind === "webhook-token") {
-          if (!commandText) return false;
-          store.saveWebhookAuthtoken(commandText);
-          resumeAfterChannelPrompt(channelPrompt);
-          return true;
-        }
-        if (channelPrompt.kind === "webhook-domain") {
-          if (!commandText) return false;
-          Promise.resolve(store.setWebhookConfig?.({ ngrokDomain: commandText })).then(() => resumeAfterChannelPrompt(channelPrompt)).catch((e) => {
-            store.pushNotice(`webhook config update failed: ${e?.message || e}`, "error");
-          });
-          return true;
-        }
         const parts = commandText.split("|").map((part) => part.trim());
         if (channelPrompt.kind === "channel-add") {
           const isPipe = parts.length > 1;
@@ -23633,7 +23947,7 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
 }
 
 // src/tui/engine.mjs
-import { performance as performance2 } from "node:perf_hooks";
+import { performance as performance3 } from "node:perf_hooks";
 import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync11, readdirSync as readdirSync5, rmSync as rmSync4, statSync as statSync7, watch as watch2, writeFileSync as writeFileSync8 } from "node:fs";
 import { basename as basename7, dirname as dirname11, join as join14 } from "node:path";
 
@@ -23786,6 +24100,12 @@ var SYNTHETIC_SESSION_TEXT_PATTERNS = Object.freeze([
   /^\[mixdog-runtime\]/i,
   /^\[(?:truncated|request interrupted by user)\]$/i,
   /^a previous model worked on this task and produced the compacted handoff summary below\b/i,
+  // Compact/auto-clear re-seed handoff variants: these lead the FIRST user
+  // message of every post-compaction session, so titling from them painted
+  // "Re-attached after compaction…" rows in Recent (user report). Skipping
+  // them titles the session from its first REAL user message instead.
+  /^re-attached after compaction\b/i,
+  /^reference files:\s/i,
   /^the async (?:agent|shell) task\b/i
 ]);
 var LATE_TOOL_ANNOUNCEMENT_SENTINEL = "connected after this session started";
@@ -23916,12 +24236,12 @@ function sessionPath(id) {
 }
 
 // src/tui/engine/boot-profile.mjs
-import { performance } from "node:perf_hooks";
+import { performance as performance2 } from "node:perf_hooks";
 var BOOT_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ""));
-var BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance.now());
+var BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance2.now());
 function bootProfile(event, fields = {}) {
   if (!BOOT_PROFILE_ENABLED) return;
-  const elapsedMs = performance.now() - BOOT_PROFILE_START;
+  const elapsedMs = performance2.now() - BOOT_PROFILE_START;
   const parts = [`[mixdog-boot] +${elapsedMs.toFixed(1)}ms`, `tui:${event}`];
   for (const [key, value] of Object.entries(fields || {})) {
     if (value === void 0 || value === null || value === "") continue;
@@ -25611,6 +25931,7 @@ import { randomBytes as randomBytes3 } from "crypto";
 import { join as join10 } from "path";
 var PENDING_MESSAGES_FILE = "session-pending-messages.json";
 var PENDING_MESSAGES_MODE = 384;
+var STALE_STEERING_RESTORE_TTL_MS = 30 * 60 * 1e3;
 var _persistChain = Promise.resolve();
 function _serialize(task) {
   const run = _persistChain.then(task, task);
@@ -25637,7 +25958,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;
 }
@@ -25689,7 +26012,7 @@ 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) => {
@@ -25761,12 +26084,21 @@ 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 void 0;
+        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 void 0;
         delete next.sessions[key];
         if (next.sessionTouchedAt) delete next.sessionTouchedAt[key];
         next.updatedAt = Date.now();
@@ -25775,6 +26107,13 @@ function drainTuiSteeringPersist(leadSessionId) {
     } catch (err) {
       try {
         process.stderr.write(`[tui] steering-queue drain failed sessionId=${leadSessionId}: ${err?.message || err}
+`);
+      } catch {
+      }
+    }
+    if (droppedStale > 0) {
+      try {
+        process.stderr.write(`[tui] dropped ${droppedStale} stale steering row(s) sessionId=${leadSessionId}
 `);
       } catch {
       }
@@ -28166,16 +28505,6 @@ 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");
@@ -28276,6 +28605,17 @@ 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 || "");
@@ -28581,7 +28921,6 @@ async function buildDoctorReport(runtime = {}, getState = () => ({})) {
     const tokens = [];
     if (setup.discord?.authenticated) tokens.push("discord");
     if (setup.telegram?.authenticated) tokens.push("telegram");
-    if (setup.webhook?.authenticated) tokens.push("webhook");
     const running = worker.running === true;
     const detail = `enabled \xB7 worker ${running ? "running" : "stopped"} \xB7 tokens: ${tokens.length ? tokens.join(", ") : "none"}`;
     row(running ? "ok" : "warn", detail);
@@ -29247,7 +29586,9 @@ function createFrameBatchedStorePublisher({
   frameMs = 16,
   setTimer = setTimeout,
   clearTimer = clearTimeout,
-  enqueueMicrotask = queueMicrotask
+  enqueueMicrotask = queueMicrotask,
+  scheduleFrame = (callback, delay2) => setTimer(callback, delay2),
+  cancelFrame = (handle) => clearTimer(handle)
 }) {
   let timer2 = null;
   let emitPending = false;
@@ -29255,7 +29596,7 @@ function createFrameBatchedStorePublisher({
   let immediatePending = false;
   const flush = () => {
     if (timer2 !== null) {
-      clearTimer(timer2);
+      cancelFrame(timer2);
       timer2 = null;
     }
     immediatePending = false;
@@ -29277,7 +29618,7 @@ function createFrameBatchedStorePublisher({
   const emit = () => {
     emitPending = true;
     if (timer2 !== null || isDisposed()) return;
-    timer2 = setTimer(flush, frameMs);
+    timer2 = scheduleFrame(flush, frameMs);
     timer2?.unref?.();
   };
   const markStructureChange = () => {
@@ -29291,7 +29632,7 @@ function createFrameBatchedStorePublisher({
   };
   const dispose = () => {
     if (emitPending && !isDisposed()) flush();
-    else if (timer2 !== null) clearTimer(timer2);
+    else if (timer2 !== null) cancelFrame(timer2);
     timer2 = null;
     emitPending = false;
     structureChangePending = false;
@@ -29707,6 +30048,7 @@ function createLiveShare({
   const stopClient = () => {
     const closing = client;
     const closingId = clientId;
+    const wasUp = clientUp;
     client = null;
     clientId = "";
     clientUp = false;
@@ -29718,6 +30060,7 @@ function createLiveShare({
       } catch {
       }
     }
+    if (wasUp) clearMirroredLiveState();
   };
   const startClient = (id) => {
     let socket;
@@ -30313,16 +30656,16 @@ async function createEngineSession({
   cwd,
   desktopSession
 } = {}) {
-  const startedAt = performance2.now();
+  const startedAt = performance3.now();
   bootProfile("engine:create:start", { provider: providerName, model, toolMode, remote });
   process.env.MIXDOG_QUIET_PROVIDER_LOG = "1";
   process.env.MIXDOG_QUIET_SESSION_LOG = "1";
   process.env.MIXDOG_QUIET_MCP_LOG = "1";
   process.env.MIXDOG_QUIET_MEMORY_LOG = "1";
   process.env.MIXDOG_PATCH_NATIVE_PREWARM ??= "0";
-  const importStartedAt = performance2.now();
+  const importStartedAt = performance3.now();
   const { createMixdogSessionRuntime } = await import(SESSION_RUNTIME_MODULE);
-  bootProfile("session-runtime:imported", { ms: (performance2.now() - importStartedAt).toFixed(1) });
+  bootProfile("session-runtime:imported", { ms: (performance3.now() - importStartedAt).toFixed(1) });
   const runtime = await createMixdogSessionRuntime({
     provider: providerName,
     model,
@@ -30331,9 +30674,9 @@ async function createEngineSession({
     ...cwd ? { cwd } : {},
     ...desktopSession ? { desktopSession } : {}
   });
-  bootProfile("engine:create:runtime-ready", { ms: (performance2.now() - startedAt).toFixed(1) });
+  bootProfile("engine:create:runtime-ready", { ms: (performance3.now() - startedAt).toFixed(1) });
   const runtimeCwd = runtime.cwd || process.cwd();
-  const stateStartedAt = performance2.now();
+  const stateStartedAt = performance3.now();
   const flags = {
     disposed: false,
     draining: false,
@@ -30409,11 +30752,11 @@ async function createEngineSession({
     cwd: runtimeCwd,
     themeEpoch: 0
   };
-  bootProfile("engine:route-state-ready", { ms: (performance2.now() - stateStartedAt).toFixed(1) });
-  bootProfile("engine:state-ready", { ms: (performance2.now() - stateStartedAt).toFixed(1) });
-  const contextStartedAt = performance2.now();
+  bootProfile("engine:route-state-ready", { ms: (performance3.now() - stateStartedAt).toFixed(1) });
+  bootProfile("engine:state-ready", { ms: (performance3.now() - stateStartedAt).toFixed(1) });
+  const contextStartedAt = performance3.now();
   syncContextStats({ allowEstimated: true });
-  bootProfile("engine:context-ready", { ms: (performance2.now() - contextStartedAt).toFixed(1) });
+  bootProfile("engine:context-ready", { ms: (performance3.now() - contextStartedAt).toFixed(1) });
   const listeners = /* @__PURE__ */ new Set();
   let publishedState = process.env.NODE_ENV === "production" ? state : Object.freeze(state);
   state = { ...state, stats: { ...state.stats } };
@@ -30424,7 +30767,10 @@ async function createEngineSession({
       state = { ...next, stats: { ...next.stats } };
     },
     listeners,
-    isDisposed: () => flags.disposed
+    isDisposed: () => flags.disposed,
+    frameMs: TUI_FRAME_MS,
+    scheduleFrame: scheduleRenderAlignedStoreFlush,
+    cancelFrame: cancelRenderAlignedStoreFlush
   });
   const emit = publisher.emit;
   const flushEmit = publisher.flush;
@@ -31100,7 +31446,7 @@ var XTSHIFTESCAPE_ON = process.env.WT_SESSION ? "" : "\x1B[>1s";
 var MOUSE_TRACKING_ON2 = `\x1B[?1000h\x1B[?1002h\x1B[?1006h\x1B[?1007l${XTSHIFTESCAPE_ON}`;
 var ALT_SCROLL_RESTORE = "\x1B[?1007h";
 var BOOT_PROFILE_ENABLED2 = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ""));
-var BOOT_PROFILE_START2 = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance3.now());
+var BOOT_PROFILE_START2 = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance4.now());
 var EXIT_WAIT_TIMEOUT_MS = positiveIntEnv2("MIXDOG_TUI_EXIT_WAIT_MS", 2500);
 var EXIT_HARD_DELAY_MS = positiveIntEnv2("MIXDOG_TUI_HARD_EXIT_DELAY_MS", 500);
 var EXIT_HARD_ENABLED = !/^(0|false|no|off)$/i.test(String(process.env.MIXDOG_TUI_HARD_EXIT || "1"));
@@ -31116,9 +31462,9 @@ function positiveIntEnv2(name, fallback) {
 function installTuiLoopProbe() {
   if (!LOOP_PROBE_ENABLED) return () => {
   };
-  let last = performance3.now();
+  let last = performance4.now();
   const timer2 = setInterval(() => {
-    const now = performance3.now();
+    const now = performance4.now();
     const drift = now - last - LOOP_PROBE_INTERVAL_MS;
     last = now;
     if (drift > LOOP_PROBE_DRIFT_THRESHOLD_MS) {
@@ -31143,7 +31489,7 @@ var PERF_STALL_THRESHOLD_MS = positiveIntEnv2("MIXDOG_TUI_PERF_STALL_MS", 80);
 var PERF_RENDER_GAP_MS = positiveIntEnv2("MIXDOG_TUI_PERF_RENDER_GAP_MS", 120);
 function perfLog(event, fields = {}) {
   if (!PERF_ENABLED) return;
-  const elapsedMs = performance3.now() - BOOT_PROFILE_START2;
+  const elapsedMs = performance4.now() - BOOT_PROFILE_START2;
   const parts = [`[mixdog-perf] +${elapsedMs.toFixed(1)}ms`, event];
   for (const [key, value] of Object.entries(fields || {})) {
     if (value === void 0 || value === null || value === "") continue;
@@ -31158,7 +31504,7 @@ function perfLog(event, fields = {}) {
 function installTuiPerfProbe() {
   if (!PERF_ENABLED) return () => {
   };
-  let last = performance3.now();
+  let last = performance4.now();
   let lastCpu = process.cpuUsage();
   perfLog("probe:start", {
     intervalMs: PERF_STALL_INTERVAL_MS,
@@ -31166,7 +31512,7 @@ function installTuiPerfProbe() {
     renderGapMs: PERF_RENDER_GAP_MS
   });
   const timer2 = setInterval(() => {
-    const now = performance3.now();
+    const now = performance4.now();
     const elapsed = now - last;
     const lagMs = elapsed - PERF_STALL_INTERVAL_MS;
     const cpu = process.cpuUsage(lastCpu);
@@ -31204,7 +31550,7 @@ function makeRenderProfiler() {
   let lastFrameAt = 0;
   return ({ renderTime } = {}) => {
     ackRenderedFrame();
-    const now = performance3.now();
+    const now = performance4.now();
     const ms = Number(renderTime) || 0;
     const gap = lastFrameAt ? now - lastFrameAt : 0;
     lastFrameAt = now;
@@ -31238,7 +31584,7 @@ function makeRenderProfiler() {
 }
 function bootProfile2(event, fields = {}) {
   if (!BOOT_PROFILE_ENABLED2) return;
-  const elapsedMs = performance3.now() - BOOT_PROFILE_START2;
+  const elapsedMs = performance4.now() - BOOT_PROFILE_START2;
   const parts = [`[mixdog-boot] +${elapsedMs.toFixed(1)}ms`, `tui:${event}`];
   for (const [key, value] of Object.entries(fields || {})) {
     if (value === void 0 || value === null || value === "") continue;
@@ -31456,7 +31802,7 @@ function installTuiConsoleGuard() {
   };
 }
 async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {}) {
-  const startedAt = performance3.now();
+  const startedAt = performance4.now();
   bootProfile2("run:start", { provider, model, toolMode, remote });
   if (!process.stdin.isTTY) {
     process.stderr.write(
@@ -31487,6 +31833,7 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
   process.stdout.write(`${TERMINAL_MODE_RESET_HIDDEN_CURSOR}\x1B[?1049h${TERMINAL_MODE_RESET_HIDDEN_CURSOR}\x1B[2J\x1B[H`);
   process.stdout.write("\x1B[5 q");
   process.on("exit", restoreTerminal);
+  const storeOutcomePromise = createEngineSession({ provider, model, toolMode, remote }).then((store2) => ({ store: store2, error: null }), (error) => ({ store: null, error }));
   try {
     await loadThemeSettingFromConfig();
   } catch {
@@ -31496,8 +31843,10 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
   } };
   let store;
   try {
-    store = await createEngineSession({ provider, model, toolMode, remote });
-    bootProfile2("store:ready", { ms: (performance3.now() - startedAt).toFixed(1) });
+    const outcome = await storeOutcomePromise;
+    if (outcome.error) throw outcome.error;
+    store = outcome.store;
+    bootProfile2("store:ready", { ms: (performance4.now() - startedAt).toFixed(1) });
   } catch (error) {
     splash.stop();
     stopPerfProbe();
@@ -31562,8 +31911,8 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
   registerStdioDeath(process.stderr, "error", { requireCode: true });
   registerStdioDeath(process.stderr, "close");
   try {
-    const instance = render(/* @__PURE__ */ jsx21(App, { store, forceOnboarding: forceOnboarding === true }), { exitOnCtrlC: false, maxFps: 60, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
-    bootProfile2("render:mounted", { ms: (performance3.now() - startedAt).toFixed(1) });
+    const instance = render(/* @__PURE__ */ jsx21(App, { store, forceOnboarding: forceOnboarding === true }), { exitOnCtrlC: false, maxFps: TUI_RENDER_FPS, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
+    bootProfile2("render:mounted", { ms: (performance4.now() - startedAt).toFixed(1) });
     const { waitUntilExit } = instance;
     if (mouseTracking && typeof instance.setSelection === "function") {
       store.setRenderSelection = instance.setSelection;