mixdog 0.9.1 → 0.9.3

package/src/tui/engine.mjs

@@ -4,76 +4,75 @@
  * Runs mixdog's session manager outside React and exposes a tiny subscribable
  * store. The React/ink layer consumes it via useSyncExternalStore
  * (see hooks/useEngine.mjs).
+ *
+ * Pure/stateless helpers live in ./engine/* (boot-profile, session-stats,
+ * labels, notice-text, tool-result-text, tool-call-fields, agent-envelope,
+ * queue-helpers) and are re-exported here so the public surface is unchanged.
+ * This file keeps the stateful createEngineSession store + notification plan.
  */
 import { performance } from 'node:perf_hooks';
-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';
 import {
   isModelVisibleToolCompletionWrapper,
   modelVisibleToolCompletionMessage,
 } from '../runtime/shared/tool-execution-contract.mjs';
+import { presentErrorText } from '../runtime/shared/err-text.mjs';
 import { listThemes, getThemeSetting, setThemeSetting } from './theme.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());
-
-function bootProfile(event, fields = {}) {
-  if (!BOOT_PROFILE_ENABLED) return;
-  const elapsedMs = performance.now() - BOOT_PROFILE_START;
-  const parts = [`[mixdog-boot] +${elapsedMs.toFixed(1)}ms`, `tui:${event}`];
-  for (const [key, value] of Object.entries(fields || {})) {
-    if (value === undefined || value === null || value === '') continue;
-    parts.push(`${key}=${String(value).replace(/\s+/g, '_')}`);
-  }
-  try { process.stderr.write(`${parts.join(' ')}\n`); } catch {}
-}
-
-// Session-usage accumulator - inlined (not imported from ui/statusline.mjs) so
-// engine.mjs has no static dependency on the vendored statusline closure.
-function createSessionStats() {
-  return {
-    inputTokens: 0,
-    outputTokens: 0,
-    cachedTokens: 0,
-    cacheWriteTokens: 0,
-    promptTokens: 0,
-    latestInputTokens: 0,
-    latestOutputTokens: 0,
-    latestCachedTokens: 0,
-    latestCacheWriteTokens: 0,
-    latestPromptTokens: 0,
-    currentContextTokens: 0,
-    costUsd: 0,
-    turns: 0,
-  };
-}
-function num(v) { const n = Number(v); return Number.isFinite(n) ? n : 0; }
-function applyUsageDelta(stats, delta = {}) {
-  if (!stats || !delta) return stats;
-  const inputTokens = num(delta.deltaInput);
-  const outputTokens = num(delta.deltaOutput);
-  const cachedTokens = num(delta.deltaCachedRead);
-  const cacheWriteTokens = num(delta.deltaCacheWrite);
-  const promptTokens = num(delta.deltaPrompt);
-  stats.inputTokens += inputTokens;
-  stats.outputTokens += outputTokens;
-  stats.cachedTokens += cachedTokens;
-  stats.cacheWriteTokens += cacheWriteTokens;
-  stats.promptTokens += promptTokens;
-  stats.latestInputTokens = inputTokens;
-  stats.latestOutputTokens = outputTokens;
-  stats.latestCachedTokens = cachedTokens;
-  stats.latestCacheWriteTokens = cacheWriteTokens;
-  stats.latestPromptTokens = promptTokens;
-  stats.costUsd += num(delta.costUsd);
-  return stats;
-}
+import { resetAllStreamingMarkdownStablePrefixes } from './markdown/streaming-markdown.mjs';
+import { bootProfile } from './engine/boot-profile.mjs';
+import { createSessionStats, applyUsageDelta } from './engine/session-stats.mjs';
+import {
+  pickVerb,
+  pickDoneVerb,
+  formatElapsedSeconds,
+  compactEventLabel,
+  compactEventDetail,
+  projectNameFromPath,
+} from './engine/labels.mjs';
+import { polishNoticeText } from './engine/notice-text.mjs';
+import {
+  toolResultText,
+  toolAggregateDetailFallback,
+  toolGroupedDisplayFallback,
+  toolErrorDisplay,
+} from './engine/tool-result-text.mjs';
+import {
+  toolCallId,
+  toolResultCallId,
+  toolCallName,
+  toolCallArgs,
+} from './engine/tool-call-fields.mjs';
+import {
+  parseAgentJob,
+  parseAgentResultEnvelope,
+  parseBackgroundTaskEnvelope,
+  parseSyntheticAgentMessage,
+  isStatusOnlyAgentCompletionNotification,
+  agentJobResultText,
+  agentArgsWithResultMetadata,
+  toolResultStatus,
+  isErrorToolStatus,
+} from './engine/agent-envelope.mjs';
+import {
+  queuePriorityValue,
+  defaultQueuePriority,
+  isQueuedEntryEditable,
+  isQueuedEntryVisible,
+  isSlashQueuedEntry,
+  shortTextFingerprint,
+  notificationDisplayText,
+  sessionActivityTimestamp,
+  promptDisplayText,
+  mergePromptContents,
+  mergePastedImages,
+  mergePastedTexts,
+  callCommitCallbacks,
+} from './engine/queue-helpers.mjs';
 
 // Source tests resolve from src/tui/engine.mjs; the built bundle resolves from
 // src/tui/dist/index.mjs.
@@ -89,739 +88,21 @@ const TOOL_APPROVAL_TIMEOUT_MS = (() => {
 let _idSeq = 0;
 const nextId = () => `it_${++_idSeq}`;
 
-function pickVerb(turn) {
-  return SPINNER_VERBS[(turn * 7 + 3) % SPINNER_VERBS.length];
-}
-
-const TURN_DONE_VERBS = [
-  'Thought',
-  'Reasoned',
-  'Mapped',
-  'Checked',
-  'Solved',
-  'Composed',
-  'Synthesized',
-  'Wrapped',
-];
-
-function pickDoneVerb(turn) {
-  return TURN_DONE_VERBS[(turn * 5 + 2) % TURN_DONE_VERBS.length];
-}
-
-function formatElapsedSeconds(ms) {
-  const value = Math.max(0, Number(ms) || 0);
-  if (value <= 0) return '0s';
-  return `${Math.max(1, Math.ceil(value / 1000))}s`;
-}
-
-function compactEventLabel(event = {}) {
-  const status = String(event.status || '').toLowerCase();
-  const reactive = String(event.trigger || '').toLowerCase() === 'reactive';
-  if (status === 'failed') return reactive ? 'Compact failed (overflow retry)' : 'Compact failed';
-  if (status === 'skipped') return 'Compact skipped';
-  if (status === 'no_change') return 'Compact checked';
-  return reactive ? 'Compact complete (overflow recovery)' : 'Compact complete';
-}
-
-function compactEventDetail(event = {}) {
-  // Keep the elapsed time as the lead detail, but no longer discard the rest of
-  // the compact metadata. Surface type/trigger and the boundary/pressure so the
-  // statusdone marker reflects what actually fired.
-  const parts = [];
-  const elapsed = formatElapsedSeconds(Number(event.durationMs ?? event.elapsedMs ?? 0));
-  if (elapsed) parts.push(elapsed);
-  const type = String(event.compactType || event.type || '').trim();
-  if (type && type !== 'semantic') parts.push(type);
-  const trigger = String(event.trigger || '').toLowerCase();
-  if (trigger === 'reactive') parts.push('reactive');
-  else if (trigger === 'manual') parts.push('manual');
-  const before = Number(event.beforeTokens ?? event.pressureTokens ?? 0);
-  const after = Number(event.afterTokens ?? 0);
-  const fmtTok = (n) => {
-    const v = Number(n) || 0;
-    if (v >= 1000) return `${(v / 1000).toFixed(v >= 10_000 ? 0 : 1)}k`;
-    return `${Math.round(v)}`;
-  };
-  if (before > 0 && after > 0 && after !== before) parts.push(`${fmtTok(before)}→${fmtTok(after)}`);
-  return parts.join(' · ');
-}
-
-function projectNameFromPath(value) {
-  const text = String(value || '').replace(/[\\/]+$/, '');
-  return text.split(/[\\/]/).pop() || text || '(current)';
-}
-
-const FAILED_NOTICE_ACTIONS = new Map([
-  ['api key save', 'save API key'],
-  ['auth-forget', 'forget auth'],
-  ['auto-clear', 'update auto-clear'],
-  ['autoclear', 'update auto-clear'],
-  ['agent', 'run agent command'],
-  ['channels', 'load channels'],
-  ['channels update', 'update channels'],
-  ['clear', 'clear chat'],
-  ['compact', 'compact context'],
-  ['copy', 'copy'],
-  ['core memory', 'load core memory'],
-  ['cwd', 'update working directory'],
-  ['effort switch', 'switch effort'],
-  ['fast', 'update fast mode'],
-  ['hook rule update', 'update hook rule'],
-  ['hook toggle', 'toggle hook'],
-  ['hook update', 'update hook'],
-  ['hooks status', 'load hooks'],
-  ['local provider update', 'update local provider'],
-  ['mcp add', 'add MCP server'],
-  ['mcp reconnect', 'reconnect MCP server'],
-  ['mcp status', 'load MCP status'],
-  ['mcp toggle', 'toggle MCP server'],
-  ['memory', 'run memory command'],
-  ['memory status', 'load memory status'],
-  ['model save', 'save model'],
-  ['model switch', 'switch model'],
-  ['oauth code', 'finish OAuth login'],
-  ['oauth login', 'start OAuth login'],
-  ['output style switch', 'switch output style'],
-  ['OpenAI usage auth save', 'save OpenAI usage auth'],
-  ['OpenCode Go usage auth save', 'save OpenCode Go usage auth'],
-  ['plugin add', 'add plugin'],
-  ['plugin MCP enable', 'enable plugin MCP'],
-  ['plugin uninstall', 'uninstall plugin'],
-  ['plugin update', 'update plugin'],
-  ['plugins status', 'load plugins'],
-  ['providers', 'load providers'],
-  ['recall', 'run recall'],
-  ['resume', 'resume chat'],
-  ['schedule toggle', 'toggle schedule'],
-  ['setup save', 'save setup'],
-  ['settings update', 'update settings'],
-  ['skill add', 'add skill'],
-  ['skills status', 'load skills'],
-  ['tools status', 'load tool status'],
-  ['usage', 'load usage'],
-  ['webhook toggle', 'toggle webhook'],
-  ['workflow switch', 'switch workflow'],
-]);
-
-function polishNoticeAction(action) {
-  const value = String(action || '').trim();
-  if (!value) return 'finish';
-  const key = value.toLowerCase();
-  for (const [candidate, replacement] of FAILED_NOTICE_ACTIONS.entries()) {
-    if (candidate.toLowerCase() === key) return replacement;
-  }
-  const suffixes = [
-    [' save', 'save'],
-    [' switch', 'switch'],
-    [' update', 'update'],
-    [' toggle', 'toggle'],
-    [' reconnect', 'reconnect'],
-    [' enable', 'enable'],
-    [' uninstall', 'uninstall'],
-    [' add', 'add'],
-  ];
-  for (const [suffix, verb] of suffixes) {
-    if (!key.endsWith(suffix)) continue;
-    const subject = value.slice(0, -suffix.length).trim();
-    return subject ? `${verb} ${subject}` : verb;
-  }
-  return value;
-}
-
-function sentenceStart(text) {
-  const value = String(text || '').trim();
-  return value ? `${value[0].toUpperCase()}${value.slice(1)}` : value;
-}
-
-function polishNoticeText(text) {
-  let value = String(text ?? '').trim().replace(/^✓\s*/, '');
-  if (!value) return '';
-  const error = /^error\s*:\s*(.+)$/i.exec(value);
-  if (error?.[1]) value = error[1].trim();
-  const couldNot = /^could not\s+(.+?)(?::\s*(.+))?$/i.exec(value);
-  if (couldNot) {
-    return couldNot[2]
-      ? `Couldn’t ${couldNot[1]}: ${couldNot[2]}`
-      : `Couldn’t ${couldNot[1]}.`;
-  }
-  const failed = /^(.+?)\s+failed(?::\s*(.+))?$/i.exec(value);
-  if (failed) {
-    const action = polishNoticeAction(failed[1]);
-    return failed[2] ? `Couldn’t ${action}: ${failed[2]}` : `Couldn’t ${action}.`;
-  }
-  const busy = /^(.+?)\s+already in progress\.?$/i.exec(value);
-  if (busy) return `${sentenceStart(polishNoticeAction(busy[1]))} is already running.`;
-  const required = /^(.+?)\s+is required(?:\s+for\s+(.+))?\.?$/i.exec(value);
-  if (required) {
-    const subject = required[1].trim();
-    const target = required[2]?.trim();
-    return `${subject}${target ? ` required for ${target}` : ' required'}.`;
-  }
-  return value;
-}
-
-function toolResultText(content) {
-  if (content == null) return '';
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content.map((c) => toolResultPartText(c)).filter((t) => t !== '').join('\n');
-  }
-  if (typeof content === 'object') {
-    if (Array.isArray(content.content)) {
-      const nested = content.content.map((c) => toolResultPartText(c)).filter((t) => t !== '').join('\n');
-      if (nested) return nested;
-    } else if (content.content != null && typeof content.content === 'object') {
-      const nested = toolResultPartText(content.content);
-      if (nested) return nested;
-    }
-    if (Array.isArray(content.parts)) {
-      const nested = content.parts.map((c) => toolResultPartText(c)).filter((t) => t !== '').join('\n');
-      if (nested) return nested;
-    }
-    const fromPart = toolResultPartText(content);
-    if (fromPart) return fromPart;
-    if (content?.type === 'tool_result') return '';
-    if (typeof content.text === 'string') return content.text;
-    if (typeof content.content === 'string') return content.content;
-  }
-  try { return JSON.stringify(content); } catch { return String(content); }
-}
-
-const TOOL_RESULT_PART_MAX_DEPTH = 12;
-const TOOL_RESULT_JSON_FALLBACK_MAX = 480;
-
-function compactToolResultObjectFallback(obj) {
-  if (obj?.type === 'tool_result') return '';
-  try {
-    const json = JSON.stringify(obj);
-    if (!json || json === '{}') return '';
-    if (json.length <= TOOL_RESULT_JSON_FALLBACK_MAX) return json;
-    return `${json.slice(0, TOOL_RESULT_JSON_FALLBACK_MAX - 1)}…`;
-  } catch {
-    return String(obj);
-  }
-}
-
-function toolResultPartText(part, depth = 0) {
-  if (part == null) return '';
-  if (depth > TOOL_RESULT_PART_MAX_DEPTH) return '';
-  if (typeof part === 'string') return part;
-  if (part?.type === 'image' || part?.type === 'input_image') {
-    return `[image: ${part.mimeType || part.mediaType || part.source?.media_type || 'image'}]`;
-  }
-  if (part?.type === 'tool_result') {
-    const inner = part.content;
-    if (typeof inner === 'string') return inner;
-    if (Array.isArray(inner)) {
-      return inner.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
-    }
-    if (inner != null && typeof inner === 'object') {
-      return toolResultPartText(inner, depth + 1);
-    }
-    return '';
-  }
-  if (part?.type === 'text' || part?.type === 'output_text' || part?.type === 'input_text') {
-    return part.text ?? '';
-  }
-  if (Array.isArray(part)) {
-    return part.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
-  }
-  if (typeof part === 'object') {
-    if (Array.isArray(part.content)) {
-      const nested = part.content.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
-      if (nested) return nested;
-    }
-    if (part.content != null && typeof part.content === 'object') {
-      const nested = toolResultPartText(part.content, depth + 1);
-      if (nested) return nested;
-    }
-    if (Array.isArray(part.parts)) {
-      const nested = part.parts.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
-      if (nested) return nested;
-    }
-    if (typeof part.text === 'string' && part.text) return part.text;
-    if (typeof part.output === 'string' && part.output) return part.output;
-    if (typeof part.message === 'string' && part.message) return part.message;
-    if (typeof part.content === 'string') return part.content;
-    if (part.source?.type === 'base64' && part.source?.data) {
-      return `[image: ${part.source.media_type || part.source.mediaType || 'base64'}]`;
-    }
-    return compactToolResultObjectFallback(part);
-  }
-  return '';
-}
-
-function toolAggregateDetailFallback(detailText, rawResult) {
-  if (String(detailText || '').trim()) return detailText;
-  const raw = String(rawResult || '').replace(/\s+$/, '').trim();
-  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;
-}
-
-function toolGroupedDisplayFallback(resultText, text, rawText) {
-  if (String(resultText || '').trim()) return resultText;
-  const body = String(text || rawText || '').trim();
-  if (body) return text || rawText;
-  return resultText;
-}
-
-function toolErrorDisplay(value, surface = 'tool') {
-  const text = presentErrorText(value, { surface });
-  if (/^(?:Search failed|Fetch failed|No first response|The .+ went stale|(?:Web search agent|Agent|Tool) (?:stopped|was cancelled))/i.test(text)) {
-    return text;
-  }
-  return /^error\s*:/i.test(text) ? text : `Error: ${text}`;
-}
-
-function toolCallId(call) {
-  return call?.id ?? call?.toolCallId ?? call?.tool_call_id ?? call?.call_id;
-}
-
-function toolResultCallId(message) {
-  return message?.toolCallId
-    ?? message?.tool_call_id
-    ?? message?.tool_use_id
-    ?? message?.call_id
-    ?? message?.id;
-}
-
-function toolCallName(call) {
-  return call?.name ?? call?.function?.name ?? call?.toolName ?? call?.tool_name ?? 'tool';
-}
-
-function toolCallArgs(call) {
-  return call?.arguments ?? call?.args ?? call?.input ?? call?.function?.arguments;
-}
-
-function textBetweenTag(text, tag) {
-  const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'i');
-  const match = re.exec(String(text ?? ''));
-  return match ? match[1].trim() : '';
-}
-
-function stripSyntheticAgentTags(text) {
-  const value = String(text ?? '').trim();
-  const finalAnswer = textBetweenTag(value, 'final-answer');
-  if (finalAnswer) return finalAnswer;
-  const taskResult = textBetweenTag(value, 'result');
-  if (taskResult) return taskResult;
-  return value
-    .replace(/^agent result[^\n]*(?:\n|$)/i, '')
-    .replace(/<\/?(?:final-answer|task-notification|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>/gi, '')
-    .trim();
-}
-
-function splitBridgeEnvelope(text) {
-  const value = String(text ?? '').trim();
-  if (!value) return { head: '', body: '' };
-  const match = /\n\s*\n/.exec(value);
-  if (!match) return { head: value, body: '' };
-  return {
-    head: value.slice(0, match.index).trim(),
-    body: value.slice(match.index + match[0].length).trim(),
-  };
-}
-
-function agentJobStatusText(parsed) {
-  if (!parsed) return '';
-  const parts = [];
-  if (parsed.status) parts.push(`status: ${parsed.status}`);
-  if (parsed.taskId) parts.push(`task_id: ${parsed.taskId}`);
-  return parts.join(' · ');
-}
-
-function agentJobResultText(text, parsed = parseAgentJob(text)) {
-  const value = String(text ?? '').trim();
-  if (!value) return '';
-  if (parsed?.taskId) {
-    const { body } = splitBridgeEnvelope(value);
-    const cleanBody = stripSyntheticAgentTags(body);
-    if (cleanBody) return cleanBody;
-    return agentJobStatusText(parsed);
-  }
-  return stripSyntheticAgentTags(value) || value;
-}
-
-function parseAgentResultEnvelope(text, fallback = {}) {
-  const value = String(text ?? '').trim();
-  if (!/^agent result\b/i.test(value)) return null;
-  const [head = '', ...restLines] = value.split('\n');
-  const body = stripSyntheticAgentTags(restLines.join('\n'));
-  const attrs = {};
-  const attrRe = /([a-zA-Z][\w-]*)=("[^"]*"|'[^']*'|\S+)/g;
-  let match;
-  while ((match = attrRe.exec(head))) {
-    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 || '';
-  return {
-    name: 'agent',
-    label: String(fallback.status || attrs.status || 'completed').toLowerCase(),
-    args: {
-      type: 'result',
-      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,
-      provider: fallback.provider || attrs.provider || providerModel?.[1] || undefined,
-      model: fallback.model || attrs.model || providerModel?.[2] || undefined,
-      preset: fallback.preset || attrs.preset || undefined,
-      effort: fallback.effort || attrs.effort || undefined,
-      fast: fallback.fast ?? attrs.fast,
-    },
-    result: body || agentJobStatusText({ status: fallback.status || attrs.status || 'completed', taskId: fallback.taskId || attrs.task_id || attrs.taskid || '' }),
-    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(fallback.status || attrs.status || ''),
-  };
-}
-
+// Re-export the shared tool-result/notification helpers so importers (and tests)
+// keep resolving them from engine.mjs unchanged.
 export { toolResultText, toolAggregateDetailFallback, toolGroupedDisplayFallback };
-
-export function parseBackgroundTaskEnvelope(text) {
-  const value = String(text ?? '').trim();
-  if (!/^background task\b/i.test(value)) return null;
-  const allLines = value.split('\n');
-  const rest = allLines.slice(1);
-  const blank = rest.findIndex((line) => !line.trim());
-  const headLines = blank >= 0 ? rest.slice(0, blank) : rest;
-  const body = blank >= 0 ? rest.slice(blank + 1).join('\n').trim() : '';
-  const fields = {};
-  for (const line of headLines) {
-    const match = /^([a-zA-Z][\w-]*):\s*(.*)$/.exec(line.trim());
-    if (match) fields[match[1].toLowerCase()] = match[2].trim();
-  }
-  const surface = String(fields.surface || fields.operation || 'task').toLowerCase();
-  const name = surface === 'explore' || surface === 'search' || surface === 'shell' || surface === 'agent' ? surface : 'task';
-  const status = String(fields.status || '').toLowerCase();
-  const taskId = fields.task_id || fields.taskid || '';
-  const errorText = fields.error || '';
-  const agentResult = parseAgentResultEnvelope(body, {
-    status,
-    taskId,
-    tag: fields.tag || fields.label || '',
-    role: fields.role || fields.agent || '',
-    agent: fields.agent || '',
-    provider: fields.provider || '',
-    model: fields.model || '',
-    preset: fields.preset || '',
-    effort: fields.effort || '',
-    fast: fields.fast,
-  });
-  if (agentResult) return { ...agentResult, rawResult: value };
-  const errorOnlyBody = isBackgroundErrorOnlyBody(body, errorText);
-  const resultBody = body && !errorOnlyBody ? body : '';
-  return {
-    name,
-    label: status || 'notification',
-    args: {
-      type: body ? 'result' : (fields.operation || 'status'),
-      status,
-      task_id: taskId || undefined,
-      surface,
-      operation: fields.operation || undefined,
-      label: fields.label || undefined,
-      tag: fields.tag || undefined,
-      agent: fields.agent || fields.role || undefined,
-      role: fields.role || fields.agent || undefined,
-      provider: fields.provider || undefined,
-      model: fields.model || undefined,
-      preset: fields.preset || undefined,
-      effort: fields.effort || undefined,
-      fast: fields.fast || undefined,
-      error: errorText || undefined,
-      startedAt: fields.started || fields.startedat || undefined,
-      finishedAt: fields.finished || fields.finishedat || undefined,
-    },
-    result: resultBody || (!errorText ? [status ? `status: ${status}` : '', taskId ? `task_id: ${taskId}` : ''].filter(Boolean).join(' · ') : ''),
-    rawResult: value,
-    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(status) || /^error:/i.test(body) || Boolean(errorText),
-  };
-}
-
-function isStatusOnlyAgentCompletionNotification(text) {
-  const background = parseBackgroundTaskEnvelope(text);
-  if (background?.name === 'agent' && /^(completed|cancelled|canceled)$/i.test(background.label || '')) {
-    return !(hasAgentResponseResultText(background.result) || hasAgentResponseResultText(text));
-  }
-  const parsed = parseAgentJob(text);
-  const result = agentJobResultText(text, parsed);
-  if (!parsed?.taskId || !/^(completed|cancelled|canceled)$/i.test(parsed.status || '')) return false;
-  return !(hasAgentResponseResultText(result) || hasAgentResponseResultText(text));
-}
-
-function hasAgentResponseResultText(text) {
-  const value = String(text || '').trim();
-  if (!value) return false;
-  if (/^status:\s*(?:running|pending|queued|completed|failed|cancelled|canceled)(?:\s*·\s*task_id:\s*\S+)?$/i.test(value)) return false;
-  if (/^(?:background task\b|agent task:|task_id:)/i.test(value) && !/\n\s*\n[\s\S]*\S/.test(value)) return false;
-  return true;
-}
-
-function bracketField(text, name) {
-  const re = new RegExp(`^\\[${name}:\\s*([^\\]]*)\\]`, 'mi');
-  return re.exec(String(text ?? ''))?.[1]?.trim() || '';
-}
-
-function toolResultStatus(text) {
-  const value = String(text ?? '');
-  const tagged = textBetweenTag(value, 'status');
-  if (tagged) return tagged.trim();
-  const bracketed = bracketField(value, 'status');
-  if (bracketed) return bracketed.trim();
-  const inline = /^(?:status|state):\s*([^\s·,;]+)/mi.exec(value);
-  return inline ? inline[1].trim() : '';
-}
-
-function isErrorToolStatus(status) {
-  return /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(String(status || '').trim());
-}
-
-function parseSyntheticAgentMessage(text) {
-  const value = String(text ?? '').trim();
-  if (!value) return null;
-  const finalAnswer = textBetweenTag(value, 'final-answer');
-  if (finalAnswer) {
-    return {
-      name: 'agent',
-      label: 'final',
-      args: { type: 'read', description: 'agent result' },
-      result: finalAnswer,
-    };
-  }
-  const agentResult = parseAgentResultEnvelope(value);
-  if (agentResult) return agentResult;
-  const backgroundTask = parseBackgroundTaskEnvelope(value);
-  if (backgroundTask) return backgroundTask;
-  const shellTaskId = bracketField(value, 'task_id');
-  if (shellTaskId) {
-    const status = bracketField(value, 'status') || 'done';
-    const exit = bracketField(value, 'exit');
-    const command = bracketField(value, 'command');
-    return {
-      name: 'shell',
-      label: status,
-      args: { type: 'result', task_id: shellTaskId, command },
-      result: value,
-      isError: /^(failed|error|timeout|cancelled|killed)$/i.test(status) || (exit && exit !== '0' && exit !== 'n/a'),
-    };
-  }
-  const agentJob = parseAgentJob(value);
-  if (agentJob?.taskId) {
-    const label = agentJob.status || 'notification';
-    const result = agentJobResultText(value, agentJob);
-    return {
-      name: 'agent',
-      label,
-      args: agentArgsWithResultMetadata({ type: agentJob.type || 'notification', description: 'agent notification' }, agentJob),
-      result: result || agentJobStatusText(agentJob) || 'agent notification',
-      isError: /^(failed|error|timeout|cancelled|killed)$/i.test(label),
-    };
-  }
-  if (/<task-notification\b/i.test(value)) {
-    const status = textBetweenTag(value, 'status') || 'completed';
-    const summary = textBetweenTag(value, 'summary') || `Agent ${status}`;
-    const taskId = textBetweenTag(value, 'task-id');
-    const result = stripSyntheticAgentTags(value);
-    return {
-      name: 'agent',
-      label: status,
-      taskId,
-      summary,
-      result: result || summary,
-    };
-  }
-  return null;
-}
-
-function normalizeToolName(name) {
-  return String(name || 'tool')
-    .replace(/^mcp__.*__/, '')
-    .replace(/^functions\./, '')
-    .replace(/-/g, '_')
-    .toLowerCase();
-}
-
-function parseToolArgs(args) {
-  if (!args) return {};
-  if (typeof args === 'string') {
-    try {
-      const parsed = JSON.parse(args);
-      return parsed && typeof parsed === 'object' ? parsed : {};
-    } catch {
-      return {};
-    }
-  }
-  return typeof args === 'object' ? args : {};
-}
-
-const yieldToRenderer = () => new Promise((resolve) => setImmediate(resolve));
-
-function parseAgentJob(text) {
-  const value = String(text || '');
-  const idMatch = /^agent task:\s*([^\s]+)/m.exec(value) || /^task_id:\s*([^\s]+)/m.exec(value);
-  if (!idMatch) return null;
-  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 presetMatch = /^preset:\s*(.+)$/m.exec(value);
-  const modelMatch = /^model:\s*([^/\s]+)\/(.+)$/m.exec(value);
-  const effortMatch = /^effort:\s*(.+)$/m.exec(value);
-  const fastMatch = /^fast:\s*(on|off|true|false)$/m.exec(value);
-  return {
-    taskId: idMatch[1],
-    status: (statusMatch?.[1] || '').toLowerCase(),
-    type: (typeMatch?.[1] || '').trim(),
-    target: (targetMatch?.[1] || '').trim(),
-    role: (roleMatch?.[1] || '').trim(),
-    preset: (presetMatch?.[1] || '').trim(),
-    provider: (modelMatch?.[1] || '').trim(),
-    model: (modelMatch?.[2] || '').trim(),
-    effort: (effortMatch?.[1] || '').trim(),
-    fast: fastMatch ? /^(on|true)$/i.test(fastMatch[1]) : undefined,
-  };
-}
-
-const QUEUE_PRIORITY = { now: 0, next: 1, later: 2 };
-
-function queuePriorityValue(value) {
-  return QUEUE_PRIORITY[String(value || 'next')] ?? QUEUE_PRIORITY.next;
-}
-
-function defaultQueuePriority(mode) {
-  // Queue priority defaults:
-  // - user/bashed prompt input defaults to `next`, so it can be attached at the
-  //   next model-send boundary while a turn is active.
-  // - task notifications default to `later`, unless the caller explicitly marks
-  //   them urgent (e.g. interactive shell stall/completion).
-  return mode === 'task-notification' ? 'later' : 'next';
-}
-
-function isQueuedEntryEditable(entry) {
-  const mode = entry?.mode || 'prompt';
-  return mode !== 'task-notification' && mode !== 'pending-resume';
-}
-
-function isQueuedEntryVisible(entry) {
-  // state.queued drives the user-command wait list above the prompt. Background
-  // task completions stay in the internal pending queue, but should never look
-  // like commands typed by the user while they wait to be drained.
-  const mode = entry?.mode || 'prompt';
-  if (mode === 'pending-resume') return false;
-  return isQueuedEntryEditable(entry);
-}
-
-function isSlashQueuedEntry(entry) {
-  if (entry?.skipSlashCommands) return false;
-  const text = promptContentText(entry?.content ?? entry?.text ?? '');
-  return text.trim().startsWith('/');
-}
-
-function firstQueueLine(text) {
-  return String(text || '').split('\n').map((line) => line.trim()).find(Boolean) || '';
-}
-
-function shortTextFingerprint(text) {
-  const value = String(text || '').trim();
-  let hash = 2166136261;
-  for (let i = 0; i < value.length; i += 1) {
-    hash ^= value.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-
-function notificationDisplayText(text) {
-  const parsed = parseAgentJob(text);
-  const result = agentJobResultText(text, parsed);
-  const synthetic = parseSyntheticAgentMessage(text);
-  return firstQueueLine(synthetic?.result || result || text) || 'agent notification';
-}
-
-function promptContentText(content) {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (typeof part === 'string') return part;
-      if (part?.type === 'text') return part.text || '';
-      if (part?.type === 'image') return '[Image]';
-      return part?.text || '';
-    }).filter(Boolean).join('\n');
-  }
-  return String(content ?? '');
-}
-
-function timestampMs(value) {
-  if (value == null || value === '') return 0;
-  const n = Number(value);
-  if (Number.isFinite(n) && n > 0) return n;
-  const parsed = Date.parse(String(value));
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
-}
-
-function hasModelVisibleConversation(session) {
-  const messages = Array.isArray(session?.messages) ? session.messages : [];
-  return messages.some((message) => {
-    const role = message?.role;
-    if (role !== 'user' && role !== 'assistant' && role !== 'tool') return false;
-    const text = promptContentText(message.content).trim();
-    if (role === 'user' && text.startsWith('<system-reminder>')) return false;
-    if (role === 'assistant' && text === '.' && !Array.isArray(message.toolCalls)) return false;
-    return !!text || role === 'assistant' || role === 'tool';
-  });
-}
-
-function sessionActivityTimestamp(session, fallback = 0) {
-  if (!hasModelVisibleConversation(session)) return 0;
-  return timestampMs(session?.lastUsedAt)
-    || timestampMs(session?.updatedAt)
-    || timestampMs(fallback);
-}
-
-function promptDisplayText(content, options = {}) {
-  if (typeof options.displayText === 'string') return options.displayText;
-  return promptContentText(content);
-}
-
-function mergePromptContents(entries) {
-  const batch = Array.isArray(entries) ? entries : [];
-  if (batch.every((entry) => typeof entry?.content === 'string')) {
-    return batch.map((entry) => entry.content).filter((text) => String(text || '').trim()).join('\n');
-  }
-  const parts = [];
-  for (const entry of batch) {
-    const content = entry?.content;
-    if (typeof content === 'string') {
-      if (content.trim()) parts.push({ type: 'text', text: content });
-    } else if (Array.isArray(content)) {
-      parts.push(...content);
-    }
-    parts.push({ type: 'text', text: '\n' });
-  }
-  while (parts.length && parts[parts.length - 1]?.type === 'text' && parts[parts.length - 1]?.text === '\n') parts.pop();
-  return parts.length === 1 && parts[0]?.type === 'text' ? parts[0].text : parts;
-}
-
-function mergePastedImages(entries) {
-  const out = {};
-  for (const entry of entries || []) {
-    const images = entry?.pastedImages;
-    if (!images || typeof images !== 'object') continue;
-    for (const [id, image] of Object.entries(images)) {
-      if (image) out[id] = image;
-    }
-  }
-  return Object.keys(out).length > 0 ? out : null;
-}
-
-function callCommitCallbacks(entries) {
-  for (const entry of entries || []) {
-    try { entry?.onCommitted?.(); } catch {}
-  }
-}
+export { parseBackgroundTaskEnvelope };
+
+// 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 notificationQueueKey(event, text, parsed) {
   const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
@@ -837,8 +118,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 '';
@@ -883,40 +164,14 @@ function isExecutionNotification(event, text, parsed) {
   return Boolean(parsed?.taskId && /^(?:agent task:|task_id:)/mi.test(String(text || '')));
 }
 
-function agentArgsWithResultMetadata(args, parsed) {
-  if (!parsed) return args;
-  const next = { ...(args && typeof args === 'object' ? args : {}) };
-  const requestedAction = String(next.type || next.action || next.mode || '').trim().toLowerCase();
-  if (parsed.type) {
-    // Job status envelopes report the original job type (usually "spawn").
-    // Preserve the user's current agent tool action ("status", "read", …) so
-    // manual checks render as "Reviewer status" instead of another
-    // "Spawning Reviewer" card. Keep the job type as metadata for detail.
-    if (!requestedAction || /^(notification|result|completion)$/i.test(requestedAction)) next.type = parsed.type;
-    else next.jobType = parsed.type;
-  }
-  if (parsed.status) next.status = parsed.status;
-  if (parsed.taskId) next.task_id = parsed.taskId;
-  if (parsed.role) next.role = parsed.role;
-  if (parsed.preset) next.preset = parsed.preset;
-  if (parsed.provider) next.provider = parsed.provider;
-  if (parsed.model) next.model = parsed.model;
-  if (parsed.effort) next.effort = parsed.effort;
-  if (parsed.fast !== undefined) next.fast = parsed.fast;
-  if (!next.tag && parsed.target) {
-    const target = parsed.target.split(/\s+/)[0];
-    if (target && !target.startsWith('sess_')) next.tag = target;
-  }
-  return next;
-}
-
 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 +183,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 +220,7 @@ export async function createEngineSession({
     searchRoute: runtime.getSearchRoute?.() || runtime.searchRoute || null,
     autoClear: autoClearState(),
     workflow: runtime.workflow || null,
+    remoteEnabled: runtime.isRemoteEnabled?.() === true,
   });
 
   const routeState = () => ({
@@ -997,6 +253,7 @@ export async function createEngineSession({
   let state = {
     items: [],
     toasts: [],
+    progressHint: null,
     busy: false,
     commandBusy: false,
     commandStatus: null,
@@ -1006,6 +263,14 @@ export async function createEngineSession({
     toolApproval: null,
     lastTurn: null,
     stats: createSessionStats(),
+    // Incremental derivations published by the engine so App does not scan all
+    // transcript items on every change:
+    //  - activeToolSummary: running Explore/Search active counts + earliest
+    //    startedAt for the prompt-line status (replaces App.jsx O(n) items scan).
+    //  - promptHistoryList: newest-first deduped user-prompt history, rebuilt
+    //    only when a user item is appended (replaces the per-change rescan).
+    activeToolSummary: null,
+    promptHistoryList: [],
     ...baseRouteState(),
     displayContextWindow: 0,
     compactBoundaryTokens: 0,
@@ -1119,13 +384,102 @@ export async function createEngineSession({
       const id = nextItems[i]?.id;
       if (id != null) itemIndexById.set(id, i);
     }
+    // Bulk item swap (session load / clear / compact). Derive the prompt-history
+    // list from the NEW items and stage it onto state here so App never rescans;
+    // the callers that invoke replaceItems always follow with a set({items:...,
+    // ...}) that carries fresh references, so this pre-stage does not defeat any
+    // emit (the accompanying set() diffs the full patch). A bulk swap also
+    // discards the old transcript, so drop any tracked active tool calls.
+    activeToolCalls.clear();
+    state = { ...state, items: nextItems, promptHistoryList: recomputePromptHistory(nextItems), activeToolSummary: null };
     return nextItems;
   };
+  let flushDeferredBeforeImmediatePush = null;
+  let pushingFromDeferredEntry = false;
+  // --- Prompt-history list (newest-first, deduped) maintained incrementally ---
+  // App previously rebuilt this from state.items on EVERY transcript change
+  // (App.jsx recentPromptHistory useMemo). It only changes when a user item is
+  // appended, so rebuild it there and on bulk item swaps, publishing to
+  // state.promptHistoryList.
+  const PROMPT_HISTORY_LIMIT = 50;
+  const promptHistoryKey = (value) => String(value || '').trim().replace(/\s+/g, ' ');
+  const recomputePromptHistory = (sourceItems = null) => {
+    // Pure: derive the newest-first deduped user-prompt history from the given
+    // items (defaults to state.items) and RETURN it. Callers decide whether to
+    // publish via set() so the immutable-emit contract is preserved.
+    const items = Array.isArray(sourceItems) ? sourceItems : (Array.isArray(state.items) ? state.items : []);
+    const seen = new Set();
+    const history = [];
+    for (let i = items.length - 1; i >= 0 && history.length < PROMPT_HISTORY_LIMIT; i -= 1) {
+      const item = items[i];
+      if (item?.kind !== 'user') continue;
+      const text = String(item.text || '').trim();
+      const key = promptHistoryKey(text);
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      history.push(text);
+    }
+    return history;
+  };
+  // --- Active-tool summary (Explore/Search) maintained incrementally ---
+  // App previously scanned every transcript item on every change to derive the
+  // prompt-line "Exploring N / Searching N" status. Instead the tool lifecycle
+  // below tracks per-callId category + started-at in activeToolCalls and derives
+  // the small summary from it, publishing state.activeToolSummary only when the
+  // aggregate (counts + earliest start) actually changes.
+  const activeToolCalls = new Map(); // callKey -> { category, count, startedAt }
+  const recomputeActiveToolSummary = () => {
+    let exploreCount = 0, exploreStart = 0, searchCount = 0, searchStart = 0;
+    for (const rec of activeToolCalls.values()) {
+      if (!rec) continue;
+      const c = Math.max(1, Number(rec.count || 1));
+      const started = Number(rec.startedAt || 0);
+      if (rec.category === 'Explore') {
+        exploreCount += c;
+        if (started > 0 && (exploreStart === 0 || started < exploreStart)) exploreStart = started;
+      } else if (rec.category === 'Search') {
+        searchCount += c;
+        if (started > 0 && (searchStart === 0 || started < searchStart)) searchStart = started;
+      }
+    }
+    const next = (exploreCount || searchCount)
+      ? `${exploreCount}:${exploreStart}:${searchCount}:${searchStart}`
+      : '';
+    const prev = state.activeToolSummary || '';
+    if (next !== prev) set({ activeToolSummary: next || null });
+  };
+  const markToolCallActive = (callKey, category, count, startedAt) => {
+    if (!callKey || (category !== 'Explore' && category !== 'Search')) return;
+    activeToolCalls.set(callKey, { category, count: Math.max(1, Number(count || 1)), startedAt: Number(startedAt || Date.now()) });
+    recomputeActiveToolSummary();
+  };
+  const markToolCallDone = (callKey) => {
+    if (!callKey || !activeToolCalls.has(callKey)) return;
+    activeToolCalls.delete(callKey);
+    recomputeActiveToolSummary();
+  };
+  const clearActiveToolSummary = () => {
+    if (activeToolCalls.size === 0 && !state.activeToolSummary) return;
+    activeToolCalls.clear();
+    if (state.activeToolSummary) set({ activeToolSummary: null });
+  };
   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);
-    set({ items });
+    if (item?.kind === 'user') {
+      // Rebuild the derived history against the NEW list (not yet in state) and
+      // publish items + the fresh list in ONE set(). Do NOT pre-assign to state
+      // first — set() diffs against the current state, so a pre-assign would make
+      // the references identical and skip emit().
+      const promptHistoryList = recomputePromptHistory(items);
+      set({ items, promptHistoryList });
+    } else {
+      set({ items });
+    }
   };
   const upsertSyntheticToolItem = (text, id = nextId(), parsed = null) => {
     const synthetic = parseSyntheticAgentMessage(text);
@@ -1181,6 +535,16 @@ export async function createEngineSession({
     pushItem({ kind: 'notice', id, text: value, tone });
     return id;
   };
+  // Sticky (non-TTL) input-hint-line progress state, for long-running
+  // installs (e.g. voice runtime download) that would otherwise spam the
+  // 3s toast queue. Distinct from pushToast/pushNotice: it persists across
+  // renders until explicitly cleared (setProgressHint('', ...) or a falsy
+  // text), and App.jsx's inputHint falls back to it only when no promptHint
+  // and no live toast currently cover the same line.
+  const setProgressHint = (text, tone = 'info') => {
+    const value = String(text ?? '').trim();
+    set({ progressHint: value ? { text: value, tone } : null });
+  };
   const toolApprovalQueue = [];
   let activeToolApproval = null;
   function normalizeToolApprovalRequest(input = {}, id = nextId()) {
@@ -1384,6 +748,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 +833,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 +841,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) {
@@ -1483,6 +870,9 @@ export async function createEngineSession({
     if (!card || card.done) return false;
     const callId = toolResultCallId(message) || card.callId;
     if (callId && done.has(callId)) return false;
+    // Any resolving call clears its active-summary entry (keyed by the same
+    // callKey used at markToolCallActive; card.callId holds it for both branches).
+    markToolCallDone(card.callId);
     // A result for this card arrived (possibly before its deferred push delay
     // elapsed) — surface the card now so the patch below has a live item and the
     // fast tool paints a completed card directly, no pending placeholder stage.
@@ -1511,22 +901,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 carries the merged per-call count summary
+      // ("512 lines, 6 matches, 3 files") so the finished card answers "how
+      // much" without ctrl+o. Failures keep a bare 'N Ok · 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`)
+        : formatAggregateDetail(aggregateSummaries(aggregate));
       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);
+      // The numbered+labelled raw (rawResult) is preserved for ctrl+o expansion.
+      const displayDetail = detailText;
       patchItem(card.itemId, {
         result: displayDetail,
         text: displayDetail,
@@ -1575,7 +963,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 +1001,38 @@ 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 so completedCount reflects an honest
+        // (if degenerate) accounting instead of manufacturing success out of
+        // a call that never came back. A record already marked completedEarly
+        // (via __earlyNotify) already carries a real isError/resultText/summary
+        // from its actual result — preserve those; only blank-fill for calls
+        // truly never heard from (no completedEarly, no resolved).
+        for (const rec of allCalls) {
+          if (rec.resolved) continue;
+          rec.resolved = true;
+          if (!rec.completedEarly) {
+            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 carries the merged per-call count summary; failures
+        // keep a bare 'N Ok · N Failed' status. Raw is kept for ctrl+o.
+        let displayDetail = errors > 0
+          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+          : formatAggregateDetail(aggregateSummaries(aggregate));
+        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 +1054,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);
@@ -1660,6 +1076,7 @@ export async function createEngineSession({
     activePromptRestore = {
       text: String(displayText || '').trim(),
       pastedImages: options.pastedImages && typeof options.pastedImages === 'object' ? options.pastedImages : null,
+      pastedTexts: options.pastedTexts && typeof options.pastedTexts === 'object' ? options.pastedTexts : null,
       onCommitted: typeof options.onCommitted === 'function' ? options.onCommitted : null,
       restorable: options.restorable !== false,
       submittedIds,
@@ -1688,8 +1105,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 +1138,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 +1171,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);
@@ -1772,6 +1205,7 @@ export async function createEngineSession({
         activePromptRestore.committed = true;
         activePromptRestore.requeueEntries = [];
         activePromptRestore.pastedImages = null;
+        activePromptRestore.pastedTexts = null;
       }
     };
 
@@ -1804,10 +1238,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);
+        // Merged count summary (see patchToolCardResult); failures keep
+        // 'N Ok · N Failed'. Raw preserved for ctrl+o expansion.
+        const displayDetail = errors > 0
+          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
+          : formatAggregateDetail(aggregateSummaries(aggregate));
         patchItem(aggregate.itemId, {
           result: displayDetail,
           text: displayDetail,
@@ -1824,13 +1262,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 +1276,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 +1305,6 @@ export async function createEngineSession({
       // pendingSpec current until the timer/result flushes it in call order.
       registerDeferredAggregate(aggregate);
       rememberActiveAggregate(aggregate);
-      openAggregateCard = aggregate;
       return aggregate;
     };
 
@@ -1973,6 +1403,17 @@ export async function createEngineSession({
     let _pendingThinkFlush = false;  // true when a thinking update is queued
     let _pendingThinkingLastEndedAt = 0;
     let compactingActive = false;
+    // Engine-local streaming scalars. Neither responseLength nor thinkingText is
+    // rendered per-token by any consumer: App reads state.thinking only as a
+    // boolean (App.jsx `!!(state.thinking || liveSpinner?.thinking)`) and the
+    // Spinner takes outputTokens, not responseLength. So we keep these growing
+    // values in engine-local vars and publish to the store only on a visible
+    // transition (thinking on↔off), a completed visible text line, tool/usage
+    // updates, or finalization — not on every 8ms streaming flush.
+    let _publishedThinkingActive = false; // last thinking boolean pushed to store
+    // responseLength is only consumed at finalize as an outputTokens fallback
+    // (Math.round(responseLength/4)); we refresh state.spinner.responseLength on
+    // visible-line flush and finalize so that fallback stays valid.
 
     const flushStreamBatch = () => {
       if (_batchTimer !== null) {
@@ -2017,24 +1458,51 @@ export async function createEngineSession({
             }
           }
         }
+        // Only touch the spinner when there is a real reason: a visible-line
+        // change (patch.items set above), a thinking→responding transition, or a
+        // pending thinking end timestamp. Refresh responseLength here so the
+        // finalize outputTokens fallback stays valid without a per-token push.
         const responseLengthVal = assistantText.length + thinkingText.length;
-        if (state.spinner) {
+        const visibleLineChanged = patch.items !== undefined;
+        const thinkingTransition = _publishedThinkingActive === true; // was thinking, now responding
+        if (state.spinner && (visibleLineChanged || thinkingTransition || _pendingThinkingLastEndedAt)) {
           patch.spinner = { ...state.spinner, responseLength: responseLengthVal, thinking: false, thinkingLastEndedAt: _pendingThinkingLastEndedAt || state.spinner.thinkingLastEndedAt, mode: compactingActive ? 'compacting' : 'responding' };
+          _publishedThinkingActive = false;
         }
         if (Object.keys(patch).length > 0) set(patch);
         _pendingThinkingLastEndedAt = 0;
       }
       if (_pendingThinkFlush) {
         _pendingThinkFlush = false;
-        const responseLengthVal = assistantText.length + thinkingText.length;
-        const thinkingElapsedMs = accumulatedThinkingMs + (thinkingSegmentStartedAt ? Math.max(0, Date.now() - thinkingSegmentStartedAt) : 0);
-        const patch = { thinking: compactingActive ? null : thinkingText };
-        if (state.spinner) {
-          patch.spinner = compactingActive
-            ? { ...state.spinner, responseLength: responseLengthVal, thinking: false, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingElapsedMs, thinkingLastEndedAt: state.spinner.thinkingLastEndedAt || 0, mode: 'compacting' }
-            : { ...state.spinner, responseLength: responseLengthVal, thinking: true, thinkingStartedAt, thinkingSegmentStartedAt, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingElapsedMs, thinkingLastEndedAt: 0, mode: 'thinking' };
+        // App only consumes state.thinking as a boolean and the Spinner only
+        // reads the thinking flag + timing anchors — none of them render the
+        // growing thinkingText. So publish the thinking boolean only on the
+        // OFF→ON transition (or when compacting toggles the flag), not on every
+        // 8ms reasoning chunk. The full thinkingText stays engine-local and is
+        // emitted at finalize via the normal spinner/thinking teardown.
+        const nextThinkingActive = !compactingActive;
+        // Skip the push when the published thinking boolean is unchanged: neither
+        // the growing thinkingText nor responseLength is rendered per-token, and
+        // the Spinner derives its live elapsed from the (already-published)
+        // thinkingSegmentStartedAt anchor. Applies to both thinking and
+        // compacting steady state.
+        if (nextThinkingActive === _publishedThinkingActive) {
+          // no-op: boolean unchanged
+        } else {
+          const responseLengthVal = assistantText.length + thinkingText.length;
+          const thinkingElapsedMs = accumulatedThinkingMs + (thinkingSegmentStartedAt ? Math.max(0, Date.now() - thinkingSegmentStartedAt) : 0);
+          // state.thinking stays a truthy sentinel while active; consumers read it
+          // as a boolean. Keep the value stable (thinkingText) so a late consumer
+          // still sees real text, but only push on transition.
+          const patch = { thinking: compactingActive ? null : thinkingText };
+          if (state.spinner) {
+            patch.spinner = compactingActive
+              ? { ...state.spinner, responseLength: responseLengthVal, thinking: false, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingElapsedMs, thinkingLastEndedAt: state.spinner.thinkingLastEndedAt || 0, mode: 'compacting' }
+              : { ...state.spinner, responseLength: responseLengthVal, thinking: true, thinkingStartedAt, thinkingSegmentStartedAt, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingElapsedMs, thinkingLastEndedAt: 0, mode: 'thinking' };
+          }
+          set(patch);
+          _publishedThinkingActive = nextThinkingActive;
         }
-        set(patch);
       }
     };
 
@@ -2049,6 +1517,8 @@ export async function createEngineSession({
     const markToolCardCompletedState = (callId, message) => {
       const card = cardByCallId.get(callId);
       if (!card) return;
+      // Early completion also clears the active-summary entry.
+      markToolCallDone(card.callId);
       const aggregate = card.aggregate;
       if (aggregate && card.itemId === aggregate.itemId) {
         const callRec = aggregate.calls.get(callId);
@@ -2065,19 +1535,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,
@@ -2127,7 +1591,11 @@ export async function createEngineSession({
           assistantText = '';
           const value = String(text || '').trim();
           if (value) {
-            finalizeToolHeaders();
+            // Any non-tool transcript item is a block boundary: seal the
+            // aggregate continuation (not just finalize headers) so a later
+            // same-category tool call opens a fresh card instead of reusing
+            // one whose count would then change ABOVE this steered user item.
+            clearAggregateContinuation();
             pushUserOrSyntheticItem(value);
           }
         },
@@ -2141,26 +1609,41 @@ export async function createEngineSession({
           if (thinkingText && state.thinking) {
             const thinkingLastEndedAt = closeThinkingSegment();
             set({ thinking: null, spinner: state.spinner ? { ...state.spinner, thinking: false, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingLastEndedAt, mode: 'tool-use' } : state.spinner });
+            _publishedThinkingActive = false;
           } else if (state.spinner) {
             set({ spinner: { ...state.spinner, mode: 'tool-use' } });
           }
           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}`;
+            // The old App scan counted multi-pattern calls via
+            // aggregateToolCategoryEntry(...).count, not a flat 1. Derive the same
+            // count here so the incremental Explore/Search summary matches.
+            const activeCount = Number(aggregateToolCategoryEntry(name, args, category)?.count || 1);
+            // Track Explore/Search calls as active for the incremental prompt-
+            // line summary; cleared when their result lands or the turn ends.
+            markToolCallActive(callKey, category, activeCount, Date.now());
 
             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 +1676,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 +1696,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);
@@ -2235,6 +1730,11 @@ export async function createEngineSession({
         },
         onCompactEvent: (event) => {
           flushStreamBatch();
+          // Non-tool transcript item — same block-boundary rule as the
+          // steered user item above: seal any live aggregate first so a
+          // later same-category tool call doesn't reuse a card whose count
+          // would then change above this statusdone item.
+          clearAggregateContinuation();
           pushItem({
             kind: 'statusdone',
             id: nextId(),
@@ -2249,6 +1749,7 @@ export async function createEngineSession({
             compactingActive = true;
             const thinkingLastEndedAt = closeThinkingSegment();
             _pendingThinkFlush = false;
+            _publishedThinkingActive = false; // compacting cleared the thinking flag
             set({
               thinking: null,
               spinner: {
@@ -2276,7 +1777,11 @@ export async function createEngineSession({
           if (!textChunk) return;
           markPromptCommitted();
           const thinkingLastEndedAt = closeThinkingSegment();
-          if (state.thinking) set({ thinking: null }); // collapse thinking panel immediately, no batch delay
+          // Drop any queued think-flush too: it would otherwise re-publish
+          // spinner.thinking:true from flushStreamBatch and resurrect the
+          // indicator after we cleared it here.
+          _pendingThinkFlush = false;
+          if (state.thinking) { set({ thinking: null }); _publishedThinkingActive = false; } // collapse thinking panel immediately, no batch delay
           assistantText += textChunk;
           currentAssistantText += textChunk;
           // Accumulate text and schedule a batched flush (≤1 render per
@@ -2305,7 +1810,8 @@ export async function createEngineSession({
           if (currentAssistantText.trim()) return;
           markPromptCommitted();
           closeThinkingSegment();
-          if (state.thinking) set({ thinking: null });
+          _pendingThinkFlush = false; // see onTextDelta: prevent a stale think flush resurrecting the indicator
+          if (state.thinking) { set({ thinking: null }); _publishedThinkingActive = false; }
           assistantText += full;
           currentAssistantText += full;
           _pendingTextFlush = true;
@@ -2367,7 +1873,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,13 +1890,22 @@ 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;
       closeThinkingSegment();
       const elapsedMs = Date.now() - startedAt;
       const thinkingElapsedMs = thinkingStartedAt ? accumulatedThinkingMs : 0;
-      const finalOutputTokens = Math.max(0, Number(state.spinner?.outputTokens || 0), Math.round(Number(state.spinner?.responseLength || 0) / 4));
+      // responseLength is engine-local now (not pushed per-token), so compute the
+      // fallback from the live accumulator instead of the possibly-stale
+      // state.spinner.responseLength. Final-only / non-streaming turns never
+      // accumulate `assistantText` (only currentAssistantText is set at the
+      // finalize reconcile above), so take the larger of the two text sources so
+      // a no-usage turn still estimates tokens from the final content.
+      const finalAssistantLen = Math.max(assistantText.length, currentAssistantText.length);
+      const finalResponseLength = finalAssistantLen + thinkingText.length;
+      const finalOutputTokens = Math.max(0, Number(state.spinner?.outputTokens || 0), Math.round(finalResponseLength / 4));
       const turnStatus = cancelled ? 'cancelled' : 'done';
       const resultContent = askResult?.content != null ? String(askResult.content).trim() : '';
       const assistantOutput = (currentAssistantText || assistantText || '').trim();
@@ -2423,6 +1938,8 @@ export async function createEngineSession({
       });
       flushDeferredExecutionPendingResumeKick();
     }
+    clearActiveToolSummary();
+    _publishedThinkingActive = false; // turn teardown cleared state.thinking
     return cancelled ? 'cancelled' : 'done';
   }
 
@@ -2439,6 +1956,7 @@ export async function createEngineSession({
       text: displayText,
       content: text,
       pastedImages: options.pastedImages && typeof options.pastedImages === 'object' ? options.pastedImages : null,
+      pastedTexts: options.pastedTexts && typeof options.pastedTexts === 'object' ? options.pastedTexts : null,
       onCommitted: typeof options.onCommitted === 'function' ? options.onCommitted : null,
       mode,
       priority,
@@ -2452,6 +1970,7 @@ export async function createEngineSession({
     const ids = new Set(entries.map((entry) => entry.id));
     const keys = entries.map((entry) => entry.key).filter(Boolean);
     for (const key of keys) pendingNotificationKeys.delete(key);
+    for (const key of keys) displayedExecutionNotificationKeys.delete(key);
     const queued = state.queued.filter((q) => !ids.has(q.id));
     if (queued.length !== state.queued.length) set({ queued });
   }
@@ -2481,6 +2000,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 +2019,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 +2030,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);
@@ -2525,9 +2049,11 @@ export async function createEngineSession({
         }
         const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
         const batchPastedImages = mergePastedImages(batch);
+        const batchPastedTexts = mergePastedTexts(batch);
         const turnStatus = await runTurn(merged, {
           displayText: batch.map((entry) => entry.text).filter((text) => String(text || '').trim()).join('\n'),
           pastedImages: batchPastedImages,
+          pastedTexts: batchPastedTexts,
           onCommitted: () => callCommitCallbacks(batch),
           submittedIds: [...ids],
           restorable: nonEditable.length === 0,
@@ -2559,9 +2085,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 +2121,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 +2163,7 @@ export async function createEngineSession({
       lastUserActivityAt = Date.now();
       autoClearRunning = false;
       set({ commandStatus: null });
+      void drain();
     }
   }
 
@@ -2644,7 +2181,7 @@ export async function createEngineSession({
     removeQueuedEntries(queued);
     const queuedText = queued.map((item) => item.text).filter((text) => String(text || '').trim()).join('\n');
     const combinedText = [queuedText, String(currentText || '')].filter((text) => text.trim()).join('\n');
-    return { count: queued.length, text: combinedText, pastedImages: mergePastedImages(queued) };
+    return { count: queued.length, text: combinedText, pastedImages: mergePastedImages(queued), pastedTexts: mergePastedTexts(queued) };
   }
 
   const resetStats = () => {
@@ -2659,6 +2196,8 @@ export async function createEngineSession({
     state.spinner = null;
     state.lastTurn = null;
     state.busy = false;
+    pendingNotificationKeys.clear();
+    displayedExecutionNotificationKeys.clear();
   };
   const resetTuiForPendingSessionReset = () => {
     pendingSessionReset = true;
@@ -2739,6 +2278,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 +2290,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 +2347,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;
@@ -2815,8 +2365,15 @@ export async function createEngineSession({
       set({ commandBusy: true });
       try {
         const next = runtime.setCompactionSettings?.(input) || {};
-        syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...state.stats } });
+        // Context-stats recompute (transcript scan + per-message JSON
+        // stringify) is the secondary hitch source on this toggle; defer it
+        // off the key-handler tick so Ink repaints the setting change first.
+        // Stats become eventually consistent on the next tick/repaint.
+        setTimeout(() => {
+          syncContextStats({ allowEstimated: true });
+          set({ stats: { ...state.stats } });
+        }, 0);
         return next;
       } finally {
         set({ commandBusy: false });
@@ -2830,8 +2387,14 @@ export async function createEngineSession({
       set({ commandBusy: true });
       try {
         const next = await runtime.setMemoryEnabled?.(enabled);
-        syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...state.stats } });
+        // Deferred for the same reason as setCompactionSettings above: keep
+        // the recompute off the key-handler tick so the toggle repaints
+        // immediately; stats catch up right after.
+        setTimeout(() => {
+          syncContextStats({ allowEstimated: true });
+          set({ stats: { ...state.stats } });
+        }, 0);
         return next;
       } finally {
         set({ commandBusy: false });
@@ -3157,8 +2720,24 @@ 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;
+      const restorePastedTexts = canRestore && restoreState?.pastedTexts ? restoreState.pastedTexts : 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 discardPastedTexts = restoreState?.restorable && hasPendingSteering && restoreState?.pastedTexts
+        ? restoreState.pastedTexts
+        : null;
       const requeueEntries = restoreState && !restoreState.committed && Array.isArray(restoreState.requeueEntries)
         ? restoreState.requeueEntries.slice()
         : [];
@@ -3180,7 +2759,7 @@ export async function createEngineSession({
         restoreState.restorable = false;
         restoreState.requeueEntries = [];
       }
-      return { aborted, restoreText, pastedImages: restorePastedImages };
+      return { aborted, restoreText, pastedImages: restorePastedImages, discardPastedImages, pastedTexts: restorePastedTexts, discardPastedTexts };
     },
     resolveToolApproval: (id, decision = {}) => {
       const approved = decision === true || decision?.approved === true;
@@ -3242,8 +2821,14 @@ export async function createEngineSession({
       set({ commandBusy: true });
       try {
         const result = await runtime.setOutputStyle?.(styleId);
-        resetStatsAndSyncContext();
+        resetStats();
         set({ ...routeState(), stats: { ...state.stats } });
+        // Defer the context recompute (transcript scan) off this tick so
+        // the style change repaints immediately; stats settle right after.
+        setTimeout(() => {
+          syncContextStats({ allowEstimated: true });
+          set({ stats: { ...state.stats } });
+        }, 0);
         return result;
       } finally {
         set({ commandBusy: false });
@@ -3260,6 +2845,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 +2871,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 +2886,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 +2967,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 +2979,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 +3049,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 });
@@ -3444,10 +3062,12 @@ export async function createEngineSession({
       }
     },
     pushNotice,
+    setProgressHint,
     clear: async () => {
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       clearToastTimers();
+      resetAllStreamingMarkdownStablePrefixes();
       const rollbackSnapshot = snapshotTuiBeforeSessionReset();
       resetTuiForPendingSessionReset();
       set({
@@ -3483,6 +3103,7 @@ export async function createEngineSession({
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       clearToastTimers();
+      resetAllStreamingMarkdownStablePrefixes();
       const rollbackSnapshot = snapshotTuiBeforeSessionReset();
       resetTuiForPendingSessionReset();
       set({