mixdog 0.9.0 → 0.9.2

package/src/tui/engine.mjs

@@ -10,7 +10,6 @@ import { SPINNER_VERBS } from './spinner-verbs.mjs';
 import {
   aggregateToolCategoryEntry,
   classifyToolCategory,
-  formatAggregateDetail,
   summarizeToolResult,
 } from '../runtime/shared/tool-surface.mjs';
 import { isBackgroundErrorOnlyBody, presentErrorText } from '../runtime/shared/err-text.mjs';
@@ -19,6 +18,7 @@ import {
   modelVisibleToolCompletionMessage,
 } from '../runtime/shared/tool-execution-contract.mjs';
 import { listThemes, getThemeSetting, setThemeSetting } from './theme.mjs';
+import { resetAllStreamingMarkdownStablePrefixes } from './markdown/streaming-markdown.mjs';
 
 const BOOT_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ''));
 const BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance.now());
@@ -289,6 +289,10 @@ function toolResultText(content) {
 
 const TOOL_RESULT_PART_MAX_DEPTH = 12;
 const TOOL_RESULT_JSON_FALLBACK_MAX = 480;
+// Absolute cap for a collapsed tool detail line (the second row under the ⎿
+// gutter). Terminal-width independent so a wide terminal never lets a long line
+// stretch the row; lockstep with ToolExecution RESULT_LINE_HARD_MAX (80).
+const TOOL_DETAIL_LINE_MAX = 80;
 
 function compactToolResultObjectFallback(obj) {
   if (obj?.type === 'tool_result') return '';
@@ -357,7 +361,7 @@ function toolAggregateDetailFallback(detailText, rawResult) {
   if (!raw) return detailText;
   const line = raw.split('\n').map((l) => l.trim()).find(Boolean) || '';
   if (!line) return detailText;
-  return line.length > 160 ? `${line.slice(0, 157)}…` : line;
+  return line.length > TOOL_DETAIL_LINE_MAX ? `${line.slice(0, TOOL_DETAIL_LINE_MAX - 3)}…` : line;
 }
 
 function toolGroupedDisplayFallback(resultText, text, rawText) {
@@ -456,7 +460,7 @@ function parseAgentResultEnvelope(text, fallback = {}) {
     attrs[match[1].toLowerCase()] = String(match[2] || '').replace(/^["']|["']$/g, '');
   }
   const providerModel = /\s([a-zA-Z0-9_.-]+)\/([^\s]+)\s*$/i.exec(head);
-  const role = attrs.agent || attrs.role || fallback.role || fallback.agent || '';
+  const agent = attrs.agent || fallback.agent || '';
   return {
     name: 'agent',
     label: String(fallback.status || attrs.status || 'completed').toLowerCase(),
@@ -465,8 +469,7 @@ function parseAgentResultEnvelope(text, fallback = {}) {
       status: fallback.status || attrs.status || 'completed',
       task_id: fallback.taskId || attrs.task_id || attrs.taskid || undefined,
       tag: fallback.tag || attrs.tag || undefined,
-      agent: role || undefined,
-      role: role || undefined,
+      agent: agent || undefined,
       provider: fallback.provider || attrs.provider || providerModel?.[1] || undefined,
       model: fallback.model || attrs.model || providerModel?.[2] || undefined,
       preset: fallback.preset || attrs.preset || undefined,
@@ -502,7 +505,6 @@ export function parseBackgroundTaskEnvelope(text) {
     status,
     taskId,
     tag: fields.tag || fields.label || '',
-    role: fields.role || fields.agent || '',
     agent: fields.agent || '',
     provider: fields.provider || '',
     model: fields.model || '',
@@ -524,8 +526,7 @@ export function parseBackgroundTaskEnvelope(text) {
       operation: fields.operation || undefined,
       label: fields.label || undefined,
       tag: fields.tag || undefined,
-      agent: fields.agent || fields.role || undefined,
-      role: fields.role || fields.agent || undefined,
+      agent: fields.agent || undefined,
       provider: fields.provider || undefined,
       model: fields.model || undefined,
       preset: fields.preset || undefined,
@@ -657,7 +658,16 @@ function parseToolArgs(args) {
   return typeof args === 'object' ? args : {};
 }
 
-const yieldToRenderer = () => new Promise((resolve) => setImmediate(resolve));
+// Ink renders through a maxFps throttle (120fps in index.jsx, ≈8.3ms). A plain
+// setImmediate only yields to the event loop; if Ink already painted within the
+// current throttle window, the next paint may still be queued and our following
+// transcript mutation can coalesce into the same visible frame. Wait just past
+// one render window when we intentionally split transcript commits for visual
+// stability (preamble frame → tool-card frame).
+const RENDER_THROTTLE_FLUSH_MS = 12;
+const yieldToRenderer = () => new Promise((resolve) => {
+  setTimeout(resolve, RENDER_THROTTLE_FLUSH_MS);
+});
 
 function parseAgentJob(text) {
   const value = String(text || '');
@@ -666,7 +676,7 @@ function parseAgentJob(text) {
   const statusMatch = /^status:\s*([^\s(]+)/m.exec(value);
   const typeMatch = /^type:\s*(.+)$/m.exec(value);
   const targetMatch = /^target:\s*(.+)$/m.exec(value);
-  const roleMatch = /^(?:agent|role):\s*(.+)$/m.exec(value);
+  const agentMatch = /^agent:\s*(.+)$/m.exec(value);
   const presetMatch = /^preset:\s*(.+)$/m.exec(value);
   const modelMatch = /^model:\s*([^/\s]+)\/(.+)$/m.exec(value);
   const effortMatch = /^effort:\s*(.+)$/m.exec(value);
@@ -676,7 +686,7 @@ function parseAgentJob(text) {
     status: (statusMatch?.[1] || '').toLowerCase(),
     type: (typeMatch?.[1] || '').trim(),
     target: (targetMatch?.[1] || '').trim(),
-    role: (roleMatch?.[1] || '').trim(),
+    agent: (agentMatch?.[1] || '').trim(),
     preset: (presetMatch?.[1] || '').trim(),
     provider: (modelMatch?.[1] || '').trim(),
     model: (modelMatch?.[2] || '').trim(),
@@ -837,8 +847,8 @@ function notificationQueueKey(event, text, parsed) {
         : tag
           ? `tag:${tag}:${shortTextFingerprint(synthetic.result || text)}`
           : '';
-    const role = String(synthetic.args?.agent || synthetic.args?.role || '').trim();
-    if (resultId || role) return ['agent-result', resultId, role].filter(Boolean).join(':');
+    const agent = String(synthetic.args?.agent || '').trim();
+    if (resultId || agent) return ['agent-result', resultId, agent].filter(Boolean).join(':');
   }
   const id = String(meta.execution_id || parsed?.taskId || '').trim();
   if (!id) return '';
@@ -897,7 +907,7 @@ function agentArgsWithResultMetadata(args, parsed) {
   }
   if (parsed.status) next.status = parsed.status;
   if (parsed.taskId) next.task_id = parsed.taskId;
-  if (parsed.role) next.role = parsed.role;
+  if (parsed.agent) next.agent = parsed.agent;
   if (parsed.preset) next.preset = parsed.preset;
   if (parsed.provider) next.provider = parsed.provider;
   if (parsed.model) next.model = parsed.model;
@@ -914,9 +924,10 @@ export async function createEngineSession({
   provider: providerName,
   model,
   toolMode = 'full',
+  remote = false,
 } = {}) {
   const startedAt = performance.now();
-  bootProfile('engine:create:start', { provider: providerName, model, toolMode });
+  bootProfile('engine:create:start', { provider: providerName, model, toolMode, remote });
   // Silence provider/session diagnostics so they cannot tear through the
   // alternate-screen React/ink render.
   process.env.MIXDOG_QUIET_PROVIDER_LOG = '1';
@@ -928,7 +939,7 @@ export async function createEngineSession({
   const importStartedAt = performance.now();
   const { createMixdogSessionRuntime } = await import(SESSION_RUNTIME_MODULE);
   bootProfile('session-runtime:imported', { ms: (performance.now() - importStartedAt).toFixed(1) });
-  const runtime = await createMixdogSessionRuntime({ provider: providerName, model, toolMode });
+  const runtime = await createMixdogSessionRuntime({ provider: providerName, model, toolMode, remote });
   bootProfile('engine:create:runtime-ready', { ms: (performance.now() - startedAt).toFixed(1) });
   const cwd = runtime.cwd || process.cwd();
   const stateStartedAt = performance.now();
@@ -965,6 +976,7 @@ export async function createEngineSession({
     searchRoute: runtime.getSearchRoute?.() || runtime.searchRoute || null,
     autoClear: autoClearState(),
     workflow: runtime.workflow || null,
+    remoteEnabled: runtime.isRemoteEnabled?.() === true,
   });
 
   const routeState = () => ({
@@ -1121,7 +1133,12 @@ export async function createEngineSession({
     }
     return nextItems;
   };
+  let flushDeferredBeforeImmediatePush = null;
+  let pushingFromDeferredEntry = false;
   const pushItem = (item) => {
+    if (!pushingFromDeferredEntry && flushDeferredBeforeImmediatePush) {
+      flushDeferredBeforeImmediatePush();
+    }
     const index = state.items.length;
     const items = [...state.items, item];
     if (item?.id != null) itemIndexById.set(item.id, index);
@@ -1384,6 +1401,51 @@ export async function createEngineSession({
     });
   }
 
+  const CANCELLED_RESULT_STATUS_LINE = '[status: cancelled]';
+
+  function normalizedResultStatusToken(value) {
+    const raw = String(value || '').trim().toLowerCase();
+    if (!raw) return '';
+    if (/^(running|pending|queued|in_progress|in-progress)$/.test(raw)) return 'running';
+    if (/^(completed|complete|done|success|succeeded|ok)$/.test(raw)) return 'completed';
+    if (/^(failed|fail|error|errored|timeout|timed_out|killed)$/.test(raw)) return 'failed';
+    if (/^(cancelled|canceled|cancel)$/.test(raw)) return 'cancelled';
+    return '';
+  }
+
+  function resultTextTerminalStatus(text) {
+    const body = String(text || '');
+    const tagged = body.match(/<status[^>]*>([\s\S]*?)<\/status>/i)?.[1]?.trim();
+    if (tagged) return normalizedResultStatusToken(tagged);
+    const bracketed = body.match(/^\[status:\s*([^\]]*)\]/mi)?.[1]?.trim();
+    if (bracketed) return normalizedResultStatusToken(bracketed);
+    const inline = body.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
+    return normalizedResultStatusToken(inline);
+  }
+
+  function itemHasKnownTerminalStatus(item, texts = []) {
+    const settled = (token) => token === 'completed' || token === 'failed' || token === 'cancelled';
+    if (settled(normalizedResultStatusToken(item?.args?.status))) return true;
+    for (const text of texts) {
+      if (settled(resultTextTerminalStatus(text))) return true;
+    }
+    return false;
+  }
+
+  function withCancelledResultMarker(text, item) {
+    const body = String(text || '');
+    // Do NOT inspect item.rawResult here: aggregate rawResult is child tool
+    // output (`1. grep\n<result>…`) that can incidentally contain a `status:`
+    // line, which would false-positive as an already-terminal status and skip
+    // the cancelled marker. Only result/text/body are engine-controlled
+    // collapsed detail (empty / status word / an existing marker), so they are
+    // the trustworthy terminal-status sources.
+    const sources = [item?.result, item?.text, body];
+    if (itemHasKnownTerminalStatus(item, sources)) return body;
+    if (!body.trim()) return `${CANCELLED_RESULT_STATUS_LINE}\n`;
+    return `${CANCELLED_RESULT_STATUS_LINE}\n${body}`;
+  }
+
   function groupedToolResultText(group) {
     const completed = Math.min(group.count, group.completed);
     if (group.count <= 1) return group.results.at(-1)?.text ?? '';
@@ -1424,7 +1486,7 @@ export async function createEngineSession({
     const chunks = [];
     for (const rec of calls || []) {
       if (rec?.resolved !== true) continue;
-      const text = String(rec?.resultText || '').replace(/\s+$/, '');
+      let text = String(rec?.resultText || '').replace(/\s+$/, '');
       if (!text.trim()) continue;
       const label = String(rec?.name || rec?.category || 'tool').trim() || 'tool';
       chunks.push(`${chunks.length + 1}. ${label}\n${text}`);
@@ -1432,37 +1494,15 @@ export async function createEngineSession({
     return chunks.join('\n\n');
   }
 
-  function aggregateDisplayDetail(summaries, allCalls) {
-    const fromSummaries = formatAggregateDetail(summaries);
-    if (String(fromSummaries || '').trim()) return fromSummaries;
-    let line = '';
-    for (const rec of allCalls || []) {
-      const text = String(rec?.resultText || '').replace(/\s+$/, '');
-      line = text.split('\n').map((l) => l.trim()).find(Boolean) || '';
-      if (line) break;
-    }
-    if (!line) return '';
-    return line.length > 160 ? `${line.slice(0, 157)}…` : line;
-  }
-
   function aggregateBucketForCategory(category) {
-    switch (category) {
-      case 'Read':
-      case 'Search':
-        return 'local-discovery';
-      case 'Web Research':
-        return 'web-research';
-      case 'Memory':
-        return 'memory';
-      case 'Explore':
-        return 'explore';
-      case 'Patch':
-        return 'patch';
-      default:
-        // Shell/Agent/Channel/Setup/Other stay as their own cards so risky or
-        // semantically distinct actions do not disappear inside a discovery log.
-        return null;
-    }
+    // Merge consecutive tool calls of the SAME category into one aggregate card;
+    // a different category opens a fresh card (no cross-category merge). The
+    // bucket key is the category itself, so a run of Search calls collapses into
+    // one Search card while an adjacent Read/Patch stays separate. Falls back to
+    // 'default' when a call has no resolved category. Hook/approval denials keep
+    // their dedicated ToolHookDenialCard path in App.jsx.
+    const key = String(category || '').trim();
+    return key ? `category:${key}` : 'default';
   }
 
   function aggregateSummaries(aggregate) {
@@ -1511,22 +1551,20 @@ export async function createEngineSession({
       const allCalls = [...aggregate.calls.values()];
       const completed = allCalls.filter((r) => r.resolved).length;
       const errors = allCalls.filter((r) => r.isError).length;
-      const summaries = aggregateSummaries(aggregate);
-      let detailText;
-      if (errors > 0 && summaries.length === 0) {
-        const succeeded = completed - errors;
-        detailText = succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`;
-      } else {
-        detailText = aggregateDisplayDetail(summaries, allCalls);
-        if (errors > 0) {
-          detailText = detailText ? `${detailText} · ${errors} Failed` : `${errors} Failed`;
-        }
-      }
+      // Collapsed detail is status-only (no per-result summary). Failures keep a
+      // bare 'N Failed' status so an error stays visible while collapsed.
+      const succeeded = completed - errors;
+      const detailText = errors > 0
+        ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+        : '';
       const currentItem = state.items.find((it) => it.id === card.itemId);
       const earlyCompleted = allCalls.filter((r) => r.resolved || r.completedEarly).length;
       const visualCompleted = Math.max(completed, earlyCompleted, Math.min(allCalls.length, Number(currentItem?.completedCount || 0)));
       const rawResult = aggregateRawResult(allCalls);
-      const displayDetail = toolAggregateDetailFallback(detailText, rawResult);
+      // Collapsed aggregate detail carries no per-result summary — the card body
+      // shows only a status word ('Finished') or, on failure, 'N Failed'. The
+      // numbered+labelled raw (rawResult) is preserved for ctrl+o expansion.
+      const displayDetail = detailText;
       patchItem(card.itemId, {
         result: displayDetail,
         text: displayDetail,
@@ -1575,7 +1613,7 @@ export async function createEngineSession({
     return true;
   }
 
-  const flushToolResults = (messages, toolCards, cardByCallId, toolGroups, done, { finalize = false } = {}) => {
+  const flushToolResults = (messages, toolCards, cardByCallId, toolGroups, done, { finalize = false, cancelled = false } = {}) => {
     const results = [];
     for (const m of messages || []) {
       if (!m || m.role !== 'tool') continue;
@@ -1613,14 +1651,33 @@ export async function createEngineSession({
       const aggregate = card.aggregate;
       if (aggregate && card.itemId === aggregate.itemId) {
         const allCalls = [...aggregate.calls.values()];
+        // Never let a call that truly never resolved be presented as a real
+        // completion. Stamp it resolved with an empty, non-error result so
+        // completedCount reflects an honest (if degenerate) accounting instead
+        // of manufacturing success out of a call that never came back.
+        for (const rec of allCalls) {
+          if (rec.resolved) continue;
+          rec.resolved = true;
+          rec.isError = false;
+          rec.resultText = rec.resultText || '';
+        }
         const completed = allCalls.filter((r) => r.resolved).length;
-        const remaining = allCalls.length - completed;
-        const totalCompleted = remaining > 0 ? completed + remaining : completed;
+        const totalCompleted = completed;
         const errors = allCalls.filter((r) => r.isError).length;
-        const summaries = aggregateSummaries(aggregate);
-        const detailText = aggregateDisplayDetail(summaries, allCalls);
+        const succeeded = completed - errors;
         const rawResult = aggregateRawResult(allCalls);
-        const displayDetail = toolAggregateDetailFallback(detailText, rawResult);
+        // Collapsed detail is status-only: no per-result summary. Failures keep a
+        // bare 'N Failed' status. The numbered+labelled raw is kept for ctrl+o.
+        let displayDetail = errors > 0
+          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+          : '';
+        if (cancelled) {
+          // Cancelled aggregates MUST keep the [status: cancelled] marker on the
+          // result so terminalStatus parsing resolves to 'cancelled'. Only normal
+          // completions drop the summary; cancelled ones prepend the marker.
+          const currentItem = state.items.find((it) => it.id === card.itemId);
+          displayDetail = withCancelledResultMarker(displayDetail, currentItem);
+        }
         patchItem(card.itemId, {
           result: displayDetail,
           text: displayDetail,
@@ -1642,7 +1699,11 @@ export async function createEngineSession({
       const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, results: [] };
       group.completed = Math.min(group.count, group.completed + 1);
       toolGroups.set(card.itemId, group);
-      const resultText = groupedToolResultText(group);
+      let resultText = groupedToolResultText(group);
+      if (cancelled) {
+        const currentItem = state.items.find((it) => it.id === card.itemId);
+        resultText = withCancelledResultMarker(resultText, currentItem);
+      }
       patchItem(card.itemId, { result: resultText, text: resultText, isError: group.errors > 0, errorCount: group.errors, count: group.count, completedCount: group.completed, completedAt: Date.now() });
       card.done = true;
       if (card.callId) done.add(card.callId);
@@ -1688,8 +1749,7 @@ export async function createEngineSession({
     // cards (send() still in flight). Hold those by callId until the batch lands.
     const earlyResultBuffer = new Map();
     const aggregateCards = []; // active aggregate cards in the current consecutive tool block
-    const aggregateByBucket = new Map(); // tail-continuation cache; append only while still the last visible item
-    let openAggregateCard = null;
+    const aggregateByBucket = new Map(); // per-bucket reusable card for the current consecutive tool block; cleared on block seal
 
     // ── Deferred tool-card push (scroll/text sync) ────────────────────────────
     // A tool card used to enter the transcript the instant onToolCall fired,
@@ -1722,12 +1782,23 @@ export async function createEngineSession({
         try { e.push(); } catch {}
       }
     };
+    flushDeferredBeforeImmediatePush = () => {
+      if (!deferredEntries.length) return;
+      const last = deferredEntries[deferredEntries.length - 1];
+      if (last) flushDeferredUpTo(last);
+    };
     const registerDeferredCard = (card) => {
       const entry = {
         seq: deferredSeqCounter++,
         pushed: false,
         timer: null,
-        push: () => { card.pushed = true; if (card.spec) { card.spec.deferredDisplayReady = true; pushItem(card.spec); } },
+        push: () => {
+          card.pushed = true;
+          if (!card.spec) return;
+          card.spec.deferredDisplayReady = true;
+          pushingFromDeferredEntry = true;
+          try { pushItem(card.spec); } finally { pushingFromDeferredEntry = false; }
+        },
       };
       card.deferred = entry;
       card.ensureVisible = () => flushDeferredUpTo(entry);
@@ -1744,7 +1815,13 @@ export async function createEngineSession({
         seq: deferredSeqCounter++,
         pushed: false,
         timer: null,
-        push: () => { aggregate.pushed = true; if (aggregate.pendingSpec) { aggregate.pendingSpec.deferredDisplayReady = true; pushItem(aggregate.pendingSpec); } },
+        push: () => {
+          aggregate.pushed = true;
+          if (!aggregate.pendingSpec) return;
+          aggregate.pendingSpec.deferredDisplayReady = true;
+          pushingFromDeferredEntry = true;
+          try { pushItem(aggregate.pendingSpec); } finally { pushingFromDeferredEntry = false; }
+        },
       };
       aggregate.deferred = entry;
       aggregate.ensureVisible = () => flushDeferredUpTo(entry);
@@ -1804,10 +1881,14 @@ export async function createEngineSession({
         if (allCalls.length === 0) continue;
         aggregate.ensureVisible?.();
         const errors = allCalls.filter((r) => r.isError).length;
-        const summaries = aggregateSummaries(aggregate);
-        const detailText = aggregateDisplayDetail(summaries, allCalls);
+        const completed = allCalls.filter((r) => r.resolved).length;
+        const succeeded = completed - errors;
         const rawResult = aggregateRawResult(allCalls);
-        const displayDetail = toolAggregateDetailFallback(detailText, rawResult);
+        // Status-only collapsed detail (see patchToolCardResult): no per-result
+        // summary; failures keep 'N Failed'. Raw preserved for ctrl+o expansion.
+        const displayDetail = errors > 0
+          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+          : '';
         patchItem(aggregate.itemId, {
           result: displayDetail,
           text: displayDetail,
@@ -1824,13 +1905,11 @@ export async function createEngineSession({
       completeAggregateVisual();
       finalizeToolHeaders();
       aggregateCards.length = 0;
-      openAggregateCard = null;
-    };
-
-    const isAggregateTail = (aggregate) => {
-      if (!aggregate?.itemId) return false;
-      const last = state.items[state.items.length - 1];
-      return last?.kind === 'tool' && last.aggregate === true && last.id === aggregate.itemId;
+      // Seal the block: same-bucket calls after this point must open a fresh
+      // card, never continue one from before the seal (assistant text/turn
+      // end boundary). Cross-block behavior is unchanged by the in-block
+      // reuse relaxation below.
+      aggregateByBucket.clear();
     };
 
     const rememberActiveAggregate = (aggregate) => {
@@ -1840,24 +1919,19 @@ export async function createEngineSession({
     };
 
     const ensureAggregateCard = (bucket) => {
-      // Reuse the open aggregate when it is either still the transcript tail OR
-      // has not been pushed yet. The not-yet-pushed case matters for parallel
-      // tool batches: every call in one onToolCall batch is collected first and
-      // the card is pushed once afterward (syncAggregateHeader), so the 2nd+
-      // same-bucket call in the SAME batch must merge even though the card is
-      // not yet visible in state.items (isAggregateTail would be false).
-      if (openAggregateCard?.bucket === bucket
-          && (!openAggregateCard.pushed || isAggregateTail(openAggregateCard))) return openAggregateCard;
-      // If the previous aggregate was finalized/closed but is still the tail of
-      // the transcript (or was never pushed), continue that exact card instead
-      // of pushing a duplicate directly below it. Never reach past a visible
-      // assistant/tool/status item: that would make an older card's count change
-      // "in the middle" of history.
-      const tailAggregate = aggregateByBucket.get(bucket);
-      if (tailAggregate && (!tailAggregate.pushed || isAggregateTail(tailAggregate))) {
-        openAggregateCard = tailAggregate;
-        rememberActiveAggregate(tailAggregate);
-        return tailAggregate;
+      // Reuse any same-bucket aggregate created earlier in the SAME consecutive
+      // tool block, even when a different-category card was interleaved after
+      // it (Read, Search, Read → the two Reads merge into one card; the Search
+      // stays separate). The block is only sealed — forcing a fresh card per
+      // bucket — by clearAggregateContinuation (assistant text lands or the
+      // turn ends), which clears aggregateByBucket. Reusing a pushed, non-tail
+      // card is safe: the aggregate card body is a fixed header+1-detail-row
+      // height, so patching its count/completedCount later never reflows the
+      // cards that were pushed after it.
+      const cached = aggregateByBucket.get(bucket);
+      if (cached) {
+        rememberActiveAggregate(cached);
+        return cached;
       }
       const itemId = nextId();
       const aggregate = {
@@ -1874,7 +1948,6 @@ export async function createEngineSession({
       // pendingSpec current until the timer/result flushes it in call order.
       registerDeferredAggregate(aggregate);
       rememberActiveAggregate(aggregate);
-      openAggregateCard = aggregate;
       return aggregate;
     };
 
@@ -2065,19 +2138,13 @@ export async function createEngineSession({
         const allCalls = [...aggregate.calls.values()];
         const completedCount = allCalls.filter((r) => r.resolved || r.completedEarly).length;
         const errors = allCalls.filter((r) => r.isError).length;
-        const summaries = aggregateSummaries(aggregate);
-        let detailText;
-        if (errors > 0 && summaries.length === 0) {
-          const succeeded = completedCount - errors;
-          detailText = succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`;
-        } else {
-          detailText = aggregateDisplayDetail(summaries, allCalls);
-          if (errors > 0) {
-            detailText = detailText ? `${detailText} · ${errors} Failed` : `${errors} Failed`;
-          }
-        }
+        const succeeded = completedCount - errors;
         const rawResult = aggregateRawResult(allCalls);
-        const displayDetail = toolAggregateDetailFallback(detailText, rawResult);
+        // Status-only collapsed detail (no per-result summary); failures keep
+        // 'N Failed'. Raw preserved for ctrl+o expansion.
+        const displayDetail = errors > 0
+          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+          : '';
         const currentItem = state.items.find((it) => it.id === card.itemId);
         const visualCompleted = Math.max(
           completedCount,
@@ -2146,21 +2213,28 @@ export async function createEngineSession({
           }
           const batchCalls = (calls || []).filter(Boolean);
           if (batchCalls.length === 0) return;
-          commitAssistantSegment({ sealToolBlock: true });
+          const committedAssistantSegment = commitAssistantSegment({ sealToolBlock: true });
+          if (committedAssistantSegment) {
+            // Let the pre-tool assistant preamble paint as its own frame before
+            // the tool card reserves/pushes rows. When both enter the transcript
+            // in the same render, the bottom-pinned viewport can appear to jump
+            // upward by the combined height ("preamble + tool card" at once).
+            await yieldToRenderer();
+          }
 
           const touchedAggregates = new Set();
           for (let i = 0; i < batchCalls.length; i++) {
             const c = batchCalls[i];
             const name = toolCallName(c);
             const args = toolCallArgs(c);
+            // Category drives the aggregate bucket so only same-category calls
+            // merge into one card; classify first, then bucket by it.
             const category = classifyToolCategory(name, args);
             const bucket = aggregateBucketForCategory(category);
-            const categoryEntry = aggregateToolCategoryEntry(name, args, category);
             const callId = toolCallId(c);
             const callKey = callId || `__tool_${toolCards.length}_${i}`;
 
             if (!bucket) {
-              openAggregateCard = null;
               const itemId = nextId();
               // Defer the visible push: hold the spec and only enter the
               // transcript when the real header/detail will paint (delay
@@ -2193,6 +2267,7 @@ export async function createEngineSession({
               continue;
             }
 
+            const categoryEntry = aggregateToolCategoryEntry(name, args, category);
             const aggregateCard = ensureAggregateCard(bucket);
             if (!aggregateCard.categories.has(categoryEntry.key)) aggregateCard.categoryOrder.push(categoryEntry.key);
             const prevCategory = aggregateCard.categories.get(categoryEntry.key);
@@ -2212,6 +2287,17 @@ export async function createEngineSession({
           for (const aggregateCard of touchedAggregates) {
             syncAggregateHeader(aggregateCard);
           }
+          if (committedAssistantSegment) {
+            // A pre-tool assistant preamble has already had one render frame to
+            // settle. Do not let the first grouped tool card sit off-screen until
+            // the normal 1s deferred timer: when it later inserts its real 3 rows,
+            // the already-wrapped preamble visibly jumps. Surface the first card
+            // now via the existing deferredDisplayReady path, so the post-
+            // preamble frame contains the intended Running tool card immediately
+            // (no blank placeholder, no delayed row insertion).
+            const firstTouchedAggregate = [...touchedAggregates][0] || null;
+            firstTouchedAggregate?.ensureVisible?.();
+          }
           for (const [bufferedCallId, bufferedMessage] of earlyResultBuffer) {
             if (!cardByCallId.has(bufferedCallId)) continue;
             deliverToolResultMessage(bufferedMessage);
@@ -2367,7 +2453,7 @@ export async function createEngineSession({
         // shows "cancelled", but in-flight tool cards remain in a perpetual
         // pending/blinking state because the normal finalize path (line 992)
         // was skipped when the error interrupted the try block.
-        flushToolResults([], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true });
+        flushToolResults([], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true, cancelled: true });
         finalizeToolHeaders();
       } else {
         finalizeToolHeaders();
@@ -2384,6 +2470,7 @@ export async function createEngineSession({
         if (last) flushDeferredUpTo(last);
         clearDeferredTimers();
       }
+      flushDeferredBeforeImmediatePush = null;
       const producedTranscriptItem = state.items.length > itemsAtTurnStart;
       const reclaimed = cancelled && activePromptRestore?.reclaimed === true;
       activePromptRestore = null;
@@ -2481,6 +2568,7 @@ export async function createEngineSession({
     if (pending.length === 0) return [];
     const max = queuePriorityValue(maxPriority);
     const predicate = typeof options.predicate === 'function' ? options.predicate : () => true;
+    const limit = Math.max(1, Number(options.limit) || Infinity);
     let bestPriority = Infinity;
     let targetMode = null;
     for (const entry of pending) {
@@ -2499,6 +2587,7 @@ export async function createEngineSession({
       if (predicate(entry) && (entry.mode || 'prompt') === targetMode && queuePriorityValue(entry.priority) === bestPriority) {
         batch.push(entry);
         pending.splice(i, 1);
+        if (batch.length >= limit) break;
       } else {
         i += 1;
       }
@@ -2509,13 +2598,16 @@ export async function createEngineSession({
 
   async function drain() {
     if (draining) return;
+    if (autoClearRunning) return;
     draining = true;
+    let firstBatch = true;
     try {
       while (pending.length > 0) {
         // Drain one priority/mode bucket at a time (unified command queue):
         // unified command queue semantics: prompt steering stays editable and
         // task notifications stay non-editable but model-visible.
-        const batch = dequeueQueueBatch('later');
+        const batch = dequeueQueueBatch('later', { limit: firstBatch ? 1 : Infinity });
+        firstBatch = false;
         if (batch.length === 0) break;
         const ids = new Set(batch.map((e) => e.id));
         const merged = mergePromptContents(batch);
@@ -2559,9 +2651,12 @@ export async function createEngineSession({
 
   function drainPendingSteering() {
     // Mid-turn steering drain:
-    // getCommandsByMaxPriority('next') and exclude slash commands. Slash
-    // commands must run through the normal command processor after the turn,
-    // not be sent to the model as plain text.
+    // Injects queued user prompts (steering) plus non-editable internal entries
+    // into the CURRENT provider pre-send window so the user can redirect a turn
+    // that is already running. Slash commands are still excluded: they must run
+    // through the normal command processor after the turn, not be sent as plain
+    // text. Consumed entries are spliced out of `pending` here, so the post-turn
+    // drain() loop will not re-execute them.
     const batch = dequeueQueueBatch('next', { predicate: (entry) => !isSlashQueuedEntry(entry) });
     if (batch.length === 0) return [];
     const out = batch
@@ -2592,7 +2687,14 @@ export async function createEngineSession({
     const startedAt = Date.now();
     set({ commandStatus: { active: true, verb: 'Auto-clearing idle conversation', startedAt, mode: 'auto-clear' } });
     try {
-      await runtime.clear({ compactType: cfg.compactType || null, requireCompactSuccess: !!cfg.compactType });
+      // Give Ink one event-loop turn to paint the auto-clear status before the
+      // clear/compact path starts doing synchronous session/transcript work.
+      // Without this, long idle clears can look like a frozen prompt followed by
+      // an already-complete status row.
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      const compaction = runtime.getCompactionSettings();
+      const compactType = compaction.compactType || compaction.type;
+      await runtime.clear({ compactType, requireCompactSuccess: !!compactType });
       resetStats();
       clearUiActivityBeforeContextSync();
       syncContextStats({ allowEstimated: true });
@@ -2627,6 +2729,7 @@ export async function createEngineSession({
       lastUserActivityAt = Date.now();
       autoClearRunning = false;
       set({ commandStatus: null });
+      void drain();
     }
   }
 
@@ -2739,6 +2842,10 @@ export async function createEngineSession({
         enqueue(text, queueOptions);
         return true;
       }
+      if (autoClearRunning) {
+        enqueue(text, queueOptions);
+        return true;
+      }
       void autoClearBeforeSubmit().then(() => enqueue(text, queueOptions));
       return true;
     },
@@ -2747,8 +2854,10 @@ export async function createEngineSession({
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       try {
-        await runtime.setRoute({ model: m }, { applyToCurrentSession: true });
-        syncContextStats({ allowEstimated: true });
+        // Model changes apply to the NEXT session only (default setRoute
+        // behavior) — never rewrite the live session's provider/model, which
+        // would force a full prompt-cache rewrite mid-conversation.
+        await runtime.setRoute({ model: m });
         set({ ...routeState(), stats: { ...state.stats } });
         return true;
       } finally {
@@ -2802,6 +2911,11 @@ export async function createEngineSession({
       set({ autoClear: next });
       return next;
     },
+    getUpdateSettings: () => runtime.getUpdateSettings?.() || null,
+    setAutoUpdate: (enabled) => runtime.setAutoUpdate?.(enabled),
+    checkForUpdate: (input = {}) => runtime.checkForUpdate?.(input),
+    runUpdateNow: () => runtime.runUpdateNow?.(),
+    getUpdateStatus: () => runtime.getUpdateStatus?.() || { phase: 'idle' },
     getProfile: () => runtime.getProfile?.() || { title: '', language: 'system', languages: [] },
     setProfile: (input = {}) => {
       const next = runtime.setProfile?.(input) || runtime.getProfile?.() || null;
@@ -3157,8 +3271,20 @@ export async function createEngineSession({
       if (!state.busy) return false;
       denyAllToolApprovals('interrupted by user');
       const restoreState = activePromptRestore;
-      const restoreText = restoreState?.restorable ? restoreState.text : '';
-      const restorePastedImages = restoreState?.restorable && restoreState?.pastedImages ? restoreState.pastedImages : null;
+      // A queued steering prompt means the user already redirected the turn:
+      // interrupting should just cancel the running turn and let the steering
+      // prompt run next, NOT resurrect the in-flight prompt back into the draft.
+      const hasPendingSteering = pending.some((entry) => isQueuedEntryEditable(entry));
+      const canRestore = restoreState?.restorable && !hasPendingSteering;
+      const restoreText = canRestore ? restoreState.text : '';
+      const restorePastedImages = canRestore && restoreState?.pastedImages ? restoreState.pastedImages : null;
+      // When steering suppresses the restore, the interrupted prompt's pasted
+      // images never get committed (onCommitted won't fire) nor re-installed into
+      // the draft, so hand them back for cleanup to avoid a stale `[Image #id]`
+      // lingering in the paste snapshot.
+      const discardPastedImages = restoreState?.restorable && hasPendingSteering && restoreState?.pastedImages
+        ? restoreState.pastedImages
+        : null;
       const requeueEntries = restoreState && !restoreState.committed && Array.isArray(restoreState.requeueEntries)
         ? restoreState.requeueEntries.slice()
         : [];
@@ -3180,7 +3306,7 @@ export async function createEngineSession({
         restoreState.restorable = false;
         restoreState.requeueEntries = [];
       }
-      return { aborted, restoreText, pastedImages: restorePastedImages };
+      return { aborted, restoreText, pastedImages: restorePastedImages, discardPastedImages };
     },
     resolveToolApproval: (id, decision = {}) => {
       const approved = decision === true || decision?.approved === true;
@@ -3260,6 +3386,18 @@ export async function createEngineSession({
         set({ commandBusy: false });
       }
     },
+    // Toggle Discord remote mode for this session. Flips the runtime's
+    // remoteEnabled flag (booting/stopping the channel worker) and returns the
+    // NEW enabled state so the caller can render an ON/OFF notice.
+    toggleRemote: () => {
+      const enabled = runtime.isRemoteEnabled?.() === true;
+      if (enabled) runtime.stopRemote?.();
+      else runtime.startRemote?.();
+      const next = runtime.isRemoteEnabled?.() === true;
+      set({ remoteEnabled: next });
+      return next;
+    },
+    isRemoteEnabled: () => runtime.isRemoteEnabled?.() === true,
     // Theme is a TUI-local concern (no runtime round-trip). listThemes returns
     // picker metadata; getTheme reports the active id; setTheme applies the
     // palette in-place + persists ui.theme and bumps a themeEpoch so the React
@@ -3274,6 +3412,9 @@ export async function createEngineSession({
     setAgentRoute: async (agentId, opts) => {
       return await runtime.setAgentRoute?.(agentId, opts);
     },
+    setDefaultProvider: async (provider) => {
+      return await runtime.setDefaultProvider?.(provider);
+    },
     listProviders: () => {
       return runtime.listProviders();
     },
@@ -3286,6 +3427,10 @@ export async function createEngineSession({
     getOnboardingStatus: () => {
       return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
     },
+    skipOnboarding: () => {
+      // Completed-marking only; no route/agent/provider writes.
+      return runtime.skipOnboarding?.() || null;
+    },
     completeOnboarding: async (payload = {}) => {
       if (state.commandBusy) return null;
       set({ commandBusy: true });
@@ -3363,6 +3508,8 @@ export async function createEngineSession({
     getChannelSetup: () => {
       return runtime.getChannelSetup();
     },
+    getChannelWorkerStatus: () => runtime.getChannelWorkerStatus?.(),
+    setBackend: (name) => runtime.setBackend?.(name),
     saveDiscordToken: (token) => {
       const result = runtime.saveDiscordToken(token);
       pushNotice('discord token saved', 'info');
@@ -3373,6 +3520,16 @@ export async function createEngineSession({
       pushNotice('discord token forgotten', 'info');
       return result;
     },
+    saveTelegramToken: (token) => {
+      const result = runtime.saveTelegramToken?.(token);
+      pushNotice('telegram token saved', 'info');
+      return result;
+    },
+    forgetTelegramToken: () => {
+      const result = runtime.forgetTelegramToken?.();
+      pushNotice('telegram token forgotten', 'info');
+      return result;
+    },
     saveWebhookAuthtoken: (token) => {
       const result = runtime.saveWebhookAuthtoken(token);
       pushNotice('webhook/ngrok authtoken saved', 'info');
@@ -3433,7 +3590,9 @@ export async function createEngineSession({
       set({ commandBusy: true });
       try {
         const routeOpts = opts && typeof opts === 'object' ? opts : {};
-        const applyToCurrentSession = routeOpts.applyToCurrentSession === false ? false : true;
+        // Default: apply to the NEXT session only. Only an explicit
+        // `applyToCurrentSession: true` rewrites the live session in place.
+        const applyToCurrentSession = routeOpts.applyToCurrentSession === true;
         const { applyToCurrentSession: _drop, ...nextRoute } = routeOpts;
         await runtime.setRoute(nextRoute, { applyToCurrentSession });
         if (applyToCurrentSession) syncContextStats({ allowEstimated: true });
@@ -3448,6 +3607,7 @@ export async function createEngineSession({
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       clearToastTimers();
+      resetAllStreamingMarkdownStablePrefixes();
       const rollbackSnapshot = snapshotTuiBeforeSessionReset();
       resetTuiForPendingSessionReset();
       set({
@@ -3483,6 +3643,7 @@ export async function createEngineSession({
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       clearToastTimers();
+      resetAllStreamingMarkdownStablePrefixes();
       const rollbackSnapshot = snapshotTuiBeforeSessionReset();
       resetTuiForPendingSessionReset();
       set({