mixdog 0.9.2 → 0.9.4

package/src/tui/engine.mjs

@@ -4,76 +4,81 @@
  * 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';
 import { resetAllStreamingMarkdownStablePrefixes } from './markdown/streaming-markdown.mjs';
-
-const BOOT_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ''));
-const BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance.now());
-
-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 { 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 {
+  parseBackgroundTaskEnvelope,
+  parseSyntheticAgentMessage,
+  toolResultStatus,
+  isErrorToolStatus,
+} from './engine/agent-envelope.mjs';
+import {
+  queuePriorityValue,
+  defaultQueuePriority,
+  isQueuedEntryEditable,
+  isQueuedEntryVisible,
+  isSlashQueuedEntry,
+  notificationDisplayText,
+  sessionActivityTimestamp,
+  promptDisplayText,
+  mergePromptContents,
+  mergePastedImages,
+  mergePastedTexts,
+  callCommitCallbacks,
+} from './engine/queue-helpers.mjs';
+import {
+  resolveTuiRuntimeNotificationDelivery,
+} from './engine/notification-plan.mjs';
+import { yieldToRenderer } from './engine/render-timing.mjs';
+import {
+  aggregateRawResult,
+  aggregateBucketForCategory,
+  aggregateSummaries,
+  assignAggregateSummaryOrder,
+} from './engine/tool-result-status.mjs';
+import { createToolApproval } from './engine/tool-approval.mjs';
+import { createToolCardResults } from './engine/tool-card-results.mjs';
+import { createAgentJobFeed } from './engine/agent-job-feed.mjs';
 
 // Source tests resolve from src/tui/engine.mjs; the built bundle resolves from
 // src/tui/dist/index.mjs.
@@ -89,836 +94,13 @@ 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;
-// Absolute cap for a collapsed tool detail line (the second row under the ⎿
-// gutter). Terminal-width independent so a wide terminal never lets a long line
-// stretch the row; lockstep with ToolExecution RESULT_LINE_HARD_MAX (80).
-const TOOL_DETAIL_LINE_MAX = 80;
-
-function compactToolResultObjectFallback(obj) {
-  if (obj?.type === 'tool_result') return '';
-  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 > TOOL_DETAIL_LINE_MAX ? `${line.slice(0, TOOL_DETAIL_LINE_MAX - 3)}…` : 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 agent = attrs.agent || 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: agent || 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 || '',
-    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 || 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 : {};
-}
-
-// Ink renders through a maxFps throttle (120fps in index.jsx, ≈8.3ms). A plain
-// setImmediate only yields to the event loop; if Ink already painted within the
-// current throttle window, the next paint may still be queued and our following
-// transcript mutation can coalesce into the same visible frame. Wait just past
-// one render window when we intentionally split transcript commits for visual
-// stability (preamble frame → tool-card frame).
-const RENDER_THROTTLE_FLUSH_MS = 12;
-const yieldToRenderer = () => new Promise((resolve) => {
-  setTimeout(resolve, RENDER_THROTTLE_FLUSH_MS);
-});
-
-function parseAgentJob(text) {
-  const value = String(text || '');
-  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 agentMatch = /^agent:\s*(.+)$/m.exec(value);
-  const presetMatch = /^preset:\s*(.+)$/m.exec(value);
-  const modelMatch = /^model:\s*([^/\s]+)\/(.+)$/m.exec(value);
-  const effortMatch = /^effort:\s*(.+)$/m.exec(value);
-  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(),
-    agent: (agentMatch?.[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 {}
-  }
-}
-
-function notificationQueueKey(event, text, parsed) {
-  const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
-  const synthetic = parseSyntheticAgentMessage(text);
-  if (synthetic?.name === 'agent' && String(synthetic.args?.type || '').toLowerCase() === 'result') {
-    const taskId = String(synthetic.args?.task_id || '').trim();
-    const executionId = String(meta.execution_id || '').trim();
-    const tag = String(synthetic.args?.tag || '').trim();
-    const resultId = taskId
-      ? `task:${taskId}`
-      : executionId
-        ? `exec:${executionId}`
-        : tag
-          ? `tag:${tag}:${shortTextFingerprint(synthetic.result || text)}`
-          : '';
-    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 '';
-  const type = String(meta.type || '').trim();
-  const status = String(meta.status || parsed?.status || '').trim();
-  const fallbackKind = String(text || '').split('\n', 1)[0]?.trim() || 'notification';
-  // Distinguish a body-carrying completion from a header-only preview that
-  // shares the same id/type/status. An early agent preview can arrive before
-  // the session is persisted (no result body); the canonical notification that
-  // follows DOES carry the body. Without this dimension the bodyless preview
-  // would claim the dedupe key and suppress the real result. A blank-line gap
-  // separates the task header block from the result body in the envelope.
-  const hasBody = /\n\s*\n[\s\S]*\S/.test(String(text || '')) ? 'b1' : 'b0';
-  return [id, type || fallbackKind, status, hasBody].filter(Boolean).join(':');
-}
-
-/** Pure delivery plan for runtime.onNotification execution envelopes (tests + handler). */
-export function resolveTuiRuntimeNotificationDelivery(event, text) {
-  const trimmed = String(text ?? '').trim();
-  if (!trimmed) return { action: 'ignore' };
-  const parsed = parseAgentJob(trimmed);
-  const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
-  if (!isExecutionNotification(event, trimmed, parsed)) {
-    return { action: 'enqueue', displayText: trimmed, modelContent: trimmed };
-  }
-  if (isStatusOnlyAgentCompletionNotification(trimmed)) {
-    return { action: 'status-only', displayText: trimmed, modelContent: '' };
-  }
-  const modelContent = modelVisibleToolCompletionMessage(trimmed, meta);
-  return {
-    action: 'execution-ui',
-    displayText: trimmed,
-    modelContent,
-  };
-}
-
-function isExecutionNotification(event, text, parsed) {
-  const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
-  if (meta.execution_id || meta.execution_surface) return true;
-  if (parseAgentResultEnvelope(text)) return true;
-  if (parseBackgroundTaskEnvelope(text)) return true;
-  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.agent) next.agent = parsed.agent;
-  if (parsed.preset) next.preset = parsed.preset;
-  if (parsed.provider) next.provider = parsed.provider;
-  if (parsed.model) next.model = parsed.model;
-  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 { parseBackgroundTaskEnvelope };
+// Re-export the pure notification delivery plan (moved to ./engine/notification-plan.mjs)
+// so importers/tests keep resolving resolveTuiRuntimeNotificationDelivery from engine.mjs.
+export { resolveTuiRuntimeNotificationDelivery };
 
 export async function createEngineSession({
   provider: providerName,
@@ -943,7 +125,7 @@ export async function createEngineSession({
   bootProfile('engine:create:runtime-ready', { ms: (performance.now() - startedAt).toFixed(1) });
   const cwd = runtime.cwd || process.cwd();
   const stateStartedAt = performance.now();
-  const autoClearState = () => runtime.getAutoClear?.() || runtime.autoClear || { enabled: true, idleMs: 60 * 60 * 1000 };
+  const autoClearState = () => runtime.getAutoClear?.() || runtime.autoClear || { enabled: true, idleMs: 60 * 60 * 1000, custom: false, providerDefault: 60 * 60 * 1000, provider: null };
   const AGENT_STATUS_CACHE_MS = 250;
   let agentStatusCache = null;
   let agentStatusCacheAt = 0;
@@ -1009,6 +191,7 @@ export async function createEngineSession({
   let state = {
     items: [],
     toasts: [],
+    progressHint: null,
     busy: false,
     commandBusy: false,
     commandStatus: null,
@@ -1018,6 +201,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,
@@ -1131,10 +322,85 @@ 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();
@@ -1142,7 +408,16 @@ export async function createEngineSession({
     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);
@@ -1198,80 +473,38 @@ export async function createEngineSession({
     pushItem({ kind: 'notice', id, text: value, tone });
     return id;
   };
-  const toolApprovalQueue = [];
-  let activeToolApproval = null;
-  function normalizeToolApprovalRequest(input = {}, id = nextId()) {
-    const now = Date.now();
-    const timeoutMs = TOOL_APPROVAL_TIMEOUT_MS;
-    return {
-      id,
-      name: String(input?.name || input?.tool_name || 'tool'),
-      args: input?.args ?? input?.tool_input ?? null,
-      cwd: input?.cwd || null,
-      sessionId: input?.sessionId || input?.session_id || null,
-      toolCallId: input?.toolCallId || input?.tool_use_id || null,
-      reason: String(input?.reason || input?.message || 'approval requested by hook').trim(),
-      requestedAt: now,
-      timeoutMs,
-      expiresAt: now + timeoutMs,
-    };
-  }
-  function presentNextToolApproval() {
-    if (activeToolApproval || disposed) return;
-    const entry = toolApprovalQueue.shift();
-    if (!entry) {
-      if (state.toolApproval) set({ toolApproval: null });
-      return;
-    }
-    activeToolApproval = entry;
-    entry.timer = setTimeout(() => {
-      finishToolApproval(entry.id, false, 'approval timed out');
-    }, entry.request.timeoutMs);
-    entry.timer.unref?.();
-    set({ toolApproval: entry.request });
-  }
-  function finishToolApproval(id, approved, reason = '') {
-    const targetId = String(id || '');
-    if (activeToolApproval && activeToolApproval.id === targetId) {
-      const entry = activeToolApproval;
-      activeToolApproval = null;
-      if (entry.timer) clearTimeout(entry.timer);
-      set({ toolApproval: null });
-      try { entry.resolve({ approved: approved === true, reason: String(reason || '') }); } catch {}
-      presentNextToolApproval();
-      return true;
-    }
-    const index = toolApprovalQueue.findIndex((entry) => entry.id === targetId);
-    if (index >= 0) {
-      const [entry] = toolApprovalQueue.splice(index, 1);
-      if (entry?.timer) clearTimeout(entry.timer);
-      try { entry.resolve({ approved: approved === true, reason: String(reason || '') }); } catch {}
-      return true;
-    }
-    return false;
-  }
-  function denyAllToolApprovals(reason = 'approval cancelled') {
-    if (activeToolApproval) {
-      const entry = activeToolApproval;
-      activeToolApproval = null;
-      if (entry.timer) clearTimeout(entry.timer);
-      try { entry.resolve({ approved: false, reason }); } catch {}
-    }
-    while (toolApprovalQueue.length > 0) {
-      const entry = toolApprovalQueue.shift();
-      if (entry?.timer) clearTimeout(entry.timer);
-      try { entry.resolve({ approved: false, reason }); } catch {}
-    }
-    if (state.toolApproval) set({ toolApproval: null });
-  }
-  function requestToolApproval(input = {}) {
-    if (disposed) return Promise.resolve({ approved: false, reason: 'runtime disposed' });
-    return new Promise((resolve) => {
-      const id = nextId();
-      toolApprovalQueue.push({ id, request: normalizeToolApprovalRequest(input, id), resolve, timer: null });
-      presentNextToolApproval();
-    });
-  }
+  // Remove a transcript notice previously created via pushNotice(...,
+  // {transcript:true}). Used for transient-but-persistent notices (e.g. the
+  // manual OAuth URL) that must disappear once their flow concludes.
+  const removeNotice = (id) => {
+    if (id == null) return false;
+    const items = state.items.filter((it) => !(it?.kind === 'notice' && it?.id === id));
+    if (items.length === state.items.length) return false;
+    set({ items: replaceItems(items) });
+    return true;
+  };
+  // 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 {
+    presentNextToolApproval,
+    finishToolApproval,
+    denyAllToolApprovals,
+    requestToolApproval,
+  } = createToolApproval({
+    getState: () => state,
+    set,
+    nextId,
+    getDisposed: () => disposed,
+    timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
+  });
   const patchItem = (id, patch) => {
     let index = itemIndexById.get(id);
     if (!Number.isInteger(index) || state.items[index]?.id !== id) {
@@ -1319,396 +552,51 @@ export async function createEngineSession({
   let autoClearRunning = false;
   const pendingNotificationKeys = new Set();
   const displayedExecutionNotificationKeys = new Set();
-  let executionResumeKickDeferred = false;
-
-  function kickExecutionPendingResume() {
-    if (disposed) return;
-    if (state.busy) {
-      executionResumeKickDeferred = true;
-      return;
-    }
-    if (pending.some((entry) => entry.mode === 'pending-resume')) {
-      executionResumeKickDeferred = true;
-      return;
-    }
-    executionResumeKickDeferred = false;
-    pending.push(makeQueueEntry('', { mode: 'pending-resume', priority: 'next' }));
-    void drain();
-  }
-
-  function flushDeferredExecutionPendingResumeKick() {
-    if (!executionResumeKickDeferred || disposed || state.busy) return;
-    kickExecutionPendingResume();
-  }
-
-  function scheduleExecutionPendingResumeKick() {
-    // notifyFnForSession enqueues the model-visible body after onNotification
-    // returns; defer the kick so askSession pre-drain sees session pending.
-    queueMicrotask(() => kickExecutionPendingResume());
-  }
-
-  function updateAgentJobCard(itemId, text, isError = false) {
-    const parsed = parseAgentJob(text);
-    const current = state.items.find((it) => it.id === itemId);
-    const rawDisplayText = agentJobResultText(text, parsed) || String(text ?? '').trim();
-    const displayText = isError ? toolErrorDisplay(rawDisplayText, 'agent') : rawDisplayText;
-    patchItem(itemId, {
-      result: displayText,
-      text: displayText,
-      isError,
-      errorCount: isError ? 1 : 0,
-      ...(parsed ? { args: agentArgsWithResultMetadata(current?.args, parsed) } : {}),
-    });
-  }
-
-  if (typeof runtime.onNotification === 'function') {
-    unsubscribeRuntimeNotifications = runtime.onNotification((event) => {
+  const {
+    kickExecutionPendingResume,
+    flushDeferredExecutionPendingResumeKick,
+    scheduleExecutionPendingResumeKick,
+    updateAgentJobCard,
+    subscribeRuntimeNotifications,
+  } = createAgentJobFeed({
+    runtime,
+    getState: () => state,
+    set,
+    nextId,
+    getDisposed: () => disposed,
+    patchItem,
+    enqueue: (...args) => enqueue(...args),
+    drain: (...args) => drain(...args),
+    pushUserOrSyntheticItem,
+    makeQueueEntry: (...args) => makeQueueEntry(...args),
+    getPending: () => pending,
+    agentStatusState,
+    displayedExecutionNotificationKeys,
+  });
+  unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
+
+  // Remote seat superseded by another session: runtime already stopped its
+  // worker; sync the indicator and tell the user. Non-user-initiated, so a
+  // toast (not transcript) is right.
+  let unsubscribeRemoteState = null;
+  if (typeof runtime.onRemoteStateChange === 'function') {
+    unsubscribeRemoteState = runtime.onRemoteStateChange(({ enabled, reason }) => {
       if (disposed) return;
-      const text = String(event?.content ?? event?.text ?? event ?? '').trim();
-      if (!text) return;
-      const parsed = parseAgentJob(text);
-      const notificationKey = notificationQueueKey(event, text, parsed);
-      const delivery = resolveTuiRuntimeNotificationDelivery(event, text);
-      if (delivery.action === 'ignore') return;
-      if (delivery.action === 'status-only') {
-        if (parsed?.taskId) set(agentStatusState({ force: true }));
-        return true;
-      }
-      if (delivery.action === 'execution-ui') {
-        const firstDelivery = !notificationKey || !displayedExecutionNotificationKeys.has(notificationKey);
-        if (firstDelivery) {
-          if (notificationKey) displayedExecutionNotificationKeys.add(notificationKey);
-          pushUserOrSyntheticItem(delivery.displayText, nextId());
-        }
-        if (parsed?.taskId) set(agentStatusState({ force: true }));
-        if (String(delivery.modelContent || '').trim()) {
-          scheduleExecutionPendingResumeKick();
-        }
-        return true;
-      }
-      if (parsed?.taskId) {
-        set(agentStatusState({ force: true }));
+      set({ remoteEnabled: enabled === true });
+      if (reason === 'superseded') {
+        pushNotice('Remote mode OFF — another session took over remote.', 'warn');
       }
-      const modelContent = String(delivery.modelContent ?? delivery.displayText ?? text).trim();
-      if (!modelContent) return true;
-      enqueue(modelContent, {
-        mode: 'task-notification',
-        priority: 'next',
-        key: notificationKey || undefined,
-        displayText: delivery.displayText || text,
-      });
-      return true;
     });
   }
 
-  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 ?? '';
-    if (group.errors > 0) {
-      const succeeded = Math.max(0, completed - group.errors);
-      const reasons = group.results
-        .filter((result) => result?.isError)
-        .map((result) => firstErrorLine(result?.text))
-        .filter(Boolean);
-      const uniqueReasons = [...new Set(reasons)].slice(0, 2);
-      const base = succeeded > 0
-        ? `${succeeded} Ok · ${group.errors} Failed`
-        : `${group.errors} Failed`;
-      return [
-        `${base}${uniqueReasons[0] ? ` · ${uniqueReasons[0]}` : ''}`,
-        ...uniqueReasons.slice(1),
-      ].join('\n');
-    }
-    for (const result of group.results || []) {
-      const line = String(result?.text || '').trim();
-      if (line) return result.text;
-    }
-    return '';
-  }
-
-  function firstErrorLine(text) {
-    const clean = toolErrorDisplay(text, 'tool');
-    if (clean) return clean;
-    for (const line of String(text || '').split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      if (/^(Error|\[?error|FAIL\b)/i.test(trimmed)) return trimmed;
-    }
-    return String(text || '').split('\n').map((line) => line.trim()).find(Boolean) || '';
-  }
-
-  function aggregateRawResult(calls) {
-    const chunks = [];
-    for (const rec of calls || []) {
-      if (rec?.resolved !== true) continue;
-      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}`);
-    }
-    return chunks.join('\n\n');
-  }
-
-  function aggregateBucketForCategory(category) {
-    // 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) {
-    return [...(aggregate?.calls?.values?.() || [])]
-      .filter((r) => r.summary)
-      .sort((a, b) => Number(a.summarySeq ?? 0) - Number(b.summarySeq ?? 0))
-      .map((r) => r.summary);
-  }
-
-  function assignAggregateSummaryOrder(aggregate, callRec) {
-    if (!aggregate || !callRec?.summary || callRec.summarySeq != null) return;
-    const next = Math.max(0, Number(aggregate.nextSummarySeq || 0));
-    callRec.summarySeq = next;
-    aggregate.nextSummarySeq = next + 1;
-  }
-
-  function patchToolCardResult(card, message, toolGroups, done) {
-    if (!card || card.done) return false;
-    const callId = toolResultCallId(message) || card.callId;
-    if (callId && done.has(callId)) return false;
-    // 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.
-    // ensureVisible flushes this card AND every earlier-created still-deferred
-    // card in order, so transcript order always matches call order.
-    (card.aggregate?.ensureVisible || card.ensureVisible)?.();
-    const rawText = toolResultText(message?.content);
-    const isError = message?.isError === true || message?.toolKind === 'error' || /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText));
-    const text = isError ? toolErrorDisplay(rawText, card?.name || 'tool') : rawText;
-
-    // Aggregate card handling — collect semantic summaries per call
-    const aggregate = card.aggregate;
-    if (aggregate && card.itemId === aggregate.itemId) {
-      const callRec = callId ? aggregate.calls.get(callId) : null;
-      if (!callRec) return false;
-      if (callRec.resolved) {
-        card.done = true;
-        if (callId) done.add(callId);
-        return false;
-      }
-      callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
-      assignAggregateSummaryOrder(aggregate, callRec);
-      callRec.isError = isError;
-      callRec.resultText = text;
-      callRec.resolved = true;
-      const allCalls = [...aggregate.calls.values()];
-      const completed = allCalls.filter((r) => r.resolved).length;
-      const errors = allCalls.filter((r) => r.isError).length;
-      // Collapsed detail is status-only (no per-result summary). Failures keep a
-      // bare 'N Failed' status so an error stays visible while collapsed.
-      const succeeded = completed - errors;
-      const detailText = errors > 0
-        ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
-        : '';
-      const currentItem = state.items.find((it) => it.id === card.itemId);
-      const earlyCompleted = allCalls.filter((r) => r.resolved || r.completedEarly).length;
-      const visualCompleted = Math.max(completed, earlyCompleted, Math.min(allCalls.length, Number(currentItem?.completedCount || 0)));
-      const rawResult = aggregateRawResult(allCalls);
-      // Collapsed aggregate detail carries no per-result summary — the card body
-      // shows only a status word ('Finished') or, on failure, 'N Failed'. The
-      // numbered+labelled raw (rawResult) is preserved for ctrl+o expansion.
-      const displayDetail = detailText;
-      patchItem(card.itemId, {
-        result: displayDetail,
-        text: displayDetail,
-        rawResult: rawResult || null,
-        isError: errors > 0,
-        errorCount: errors,
-        count: allCalls.length,
-        completedCount: visualCompleted,
-        completedAt: Number(currentItem?.completedAt) || Date.now(),
-      });
-      card.done = true;
-      if (callId) done.add(callId);
-      return true;
-    }
-
-    // Non-aggregate (legacy agent-job cards, etc.)
-    const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, results: [] };
-    group.completed = Math.min(group.count, group.completed + 1);
-    group.errors += isError ? 1 : 0;
-    group.results.push({ text, isError });
-    toolGroups.set(card.itemId, group);
-    const resultText = groupedToolResultText(group);
-    const displayResult = toolGroupedDisplayFallback(resultText, text, rawText);
-    const patch = {
-      result: displayResult,
-      text: displayResult,
-      isError: group.errors > 0,
-      errorCount: group.errors,
-      count: group.count,
-      completedCount: group.completed,
-      completedAt: Date.now(),
-    };
-    if (group.count <= 1) {
-      const body = String(text || rawText || '').trim();
-      if (body) patch.rawResult = text || rawText;
-      const parsedAgent = parseAgentJob(rawText);
-      if (parsedAgent) {
-        patch.args = agentArgsWithResultMetadata(state.items.find((it) => it.id === card.itemId)?.args, parsedAgent);
-        set(agentStatusState({ force: true }));
-      }
-    }
-    patchItem(card.itemId, patch);
-    if (group.count <= 1) updateAgentJobCard(card.itemId, rawText, isError);
-    card.done = true;
-    if (callId) done.add(callId);
-    return true;
-  }
-
-  const flushToolResults = (messages, toolCards, cardByCallId, toolGroups, done, { finalize = false, cancelled = false } = {}) => {
-    const results = [];
-    for (const m of messages || []) {
-      if (!m || m.role !== 'tool') continue;
-      const callId = toolResultCallId(m);
-      results.push({ message: m, callId, used: false });
-      if (!callId || done.has(callId)) continue;
-      const card = cardByCallId.get(callId);
-      if (patchToolCardResult(card, m, toolGroups, done)) {
-        results[results.length - 1].used = true;
-      }
-    }
-
-    const openCards = (toolCards || []).filter((card) => !card.done);
-    if (openCards.length === 0) return;
-
-    const unusedResults = results.filter((result) => !result.used);
-    const fallbackResults = unusedResults.slice(-openCards.length);
-    for (let i = 0; i < fallbackResults.length; i++) {
-      const card = openCards[i];
-      const result = fallbackResults[i];
-      if (!card || !result || card.done) continue;
-      if (patchToolCardResult(card, result.message, toolGroups, done)) {
-        if (result.callId) done.add(result.callId);
-        result.used = true;
-      }
-    }
-
-    if (!finalize) return;
-    for (const card of toolCards || []) {
-      if (card.done) continue;
-      // Finalize must surface any still-deferred card before patching its result
-      // so the completed/cancelled card is never silently dropped.
-      (card.aggregate?.ensureVisible || card.ensureVisible)?.();
-      // Aggregate finalize — mark any remaining calls as done
-      const aggregate = card.aggregate;
-      if (aggregate && card.itemId === aggregate.itemId) {
-        const allCalls = [...aggregate.calls.values()];
-        // Never let a call that truly never resolved be presented as a real
-        // completion. Stamp it resolved with an empty, non-error result so
-        // completedCount reflects an honest (if degenerate) accounting instead
-        // of manufacturing success out of a call that never came back.
-        for (const rec of allCalls) {
-          if (rec.resolved) continue;
-          rec.resolved = true;
-          rec.isError = false;
-          rec.resultText = rec.resultText || '';
-        }
-        const completed = allCalls.filter((r) => r.resolved).length;
-        const totalCompleted = completed;
-        const errors = allCalls.filter((r) => r.isError).length;
-        const succeeded = completed - errors;
-        const rawResult = aggregateRawResult(allCalls);
-        // Collapsed detail is status-only: no per-result summary. Failures keep a
-        // bare 'N Failed' status. The numbered+labelled raw is kept for ctrl+o.
-        let displayDetail = errors > 0
-          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
-          : '';
-        if (cancelled) {
-          // Cancelled aggregates MUST keep the [status: cancelled] marker on the
-          // result so terminalStatus parsing resolves to 'cancelled'. Only normal
-          // completions drop the summary; cancelled ones prepend the marker.
-          const currentItem = state.items.find((it) => it.id === card.itemId);
-          displayDetail = withCancelledResultMarker(displayDetail, currentItem);
-        }
-        patchItem(card.itemId, {
-          result: displayDetail,
-          text: displayDetail,
-          rawResult: rawResult || null,
-          isError: errors > 0,
-          errorCount: errors,
-          count: allCalls.length,
-          completedCount: totalCompleted,
-          completedAt: Date.now(),
-        });
-        for (const sibling of toolCards || []) {
-          if (sibling.itemId !== card.itemId) continue;
-          sibling.done = true;
-          if (sibling.callId) done.add(sibling.callId);
-        }
-        continue;
-      }
-      // Non-aggregate finalize
-      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);
-      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);
-    }
-  };
+  const { patchToolCardResult, flushToolResults } = createToolCardResults({
+    getState: () => state,
+    set,
+    patchItem,
+    markToolCallDone,
+    updateAgentJobCard,
+    agentStatusState,
+  });
 
   async function runTurn(userText, options = {}) {
     const turnIndex = state.stats.turns || 0;
@@ -1721,6 +609,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,
@@ -1749,7 +638,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(); // per-bucket reusable card for the current consecutive tool block; cleared on block seal
+    let tailAggregate = null; // most recently touched aggregate card; only the tail may absorb the next same-bucket call
 
     // ── Deferred tool-card push (scroll/text sync) ────────────────────────────
     // A tool card used to enter the transcript the instant onToolCall fired,
@@ -1849,6 +738,7 @@ export async function createEngineSession({
         activePromptRestore.committed = true;
         activePromptRestore.requeueEntries = [];
         activePromptRestore.pastedImages = null;
+        activePromptRestore.pastedTexts = null;
       }
     };
 
@@ -1884,11 +774,11 @@ export async function createEngineSession({
         const completed = allCalls.filter((r) => r.resolved).length;
         const succeeded = completed - errors;
         const rawResult = aggregateRawResult(allCalls);
-        // Status-only collapsed detail (see patchToolCardResult): no per-result
-        // summary; failures keep 'N Failed'. Raw preserved for ctrl+o expansion.
+        // 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,
@@ -1907,28 +797,25 @@ export async function createEngineSession({
       aggregateCards.length = 0;
       // 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();
+      // end boundary).
+      tailAggregate = null;
     };
 
     const rememberActiveAggregate = (aggregate) => {
       if (!aggregate) return;
       if (!aggregateCards.includes(aggregate)) aggregateCards.push(aggregate);
-      aggregateByBucket.set(aggregate.bucket, aggregate);
+      tailAggregate = aggregate;
     };
 
     const ensureAggregateCard = (bucket) => {
-      // 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);
+      // Only the TAIL aggregate (most recent card) may absorb the next call,
+      // and only when the bucket matches. Any different-bucket aggregate or
+      // standalone card in between breaks the run, so Search, Memory, Search
+      // renders as three cards in call order — a new call never merges into
+      // an earlier card above the current tail (which read as out-of-order
+      // count changes in the transcript). clearAggregateContinuation seals
+      // the block at assistant-text/turn boundaries.
+      const cached = tailAggregate && tailAggregate.bucket === bucket ? tailAggregate : null;
       if (cached) {
         rememberActiveAggregate(cached);
         return cached;
@@ -2046,6 +933,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) {
@@ -2090,24 +988,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);
       }
     };
 
@@ -2122,6 +1047,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);
@@ -2194,7 +1121,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);
           }
         },
@@ -2208,6 +1139,7 @@ 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' } });
           }
@@ -2230,9 +1162,20 @@ export async function createEngineSession({
             // 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);
+            // Agent/bridge calls always get their own standalone card so
+            // ToolExecution's isAgentTool/agentActionTitle path renders a
+            // "Spawn <Agent> (model, tag)" header instead of being folded
+            // into the "Called N agent(s)" category-aggregate card.
+            const bucket = category === 'Agent' ? null : aggregateBucketForCategory(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) {
               const itemId = nextId();
@@ -2264,6 +1207,10 @@ export async function createEngineSession({
                 cardByCallId.set(callId, card);
               }
               toolCards.push(card);
+              // A standalone card (Agent) breaks the consecutive run too: a
+              // later same-bucket call must open a fresh card BELOW it, not
+              // merge into an aggregate above it.
+              tailAggregate = null;
               continue;
             }
 
@@ -2321,6 +1268,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(),
@@ -2335,6 +1287,7 @@ export async function createEngineSession({
             compactingActive = true;
             const thinkingLastEndedAt = closeThinkingSegment();
             _pendingThinkFlush = false;
+            _publishedThinkingActive = false; // compacting cleared the thinking flag
             set({
               thinking: null,
               spinner: {
@@ -2362,7 +1315,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
@@ -2391,7 +1348,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;
@@ -2477,7 +1435,15 @@ export async function createEngineSession({
       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();
@@ -2510,6 +1476,8 @@ export async function createEngineSession({
       });
       flushDeferredExecutionPendingResumeKick();
     }
+    clearActiveToolSummary();
+    _publishedThinkingActive = false; // turn teardown cleared state.thinking
     return cancelled ? 'cancelled' : 'done';
   }
 
@@ -2526,6 +1494,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,
@@ -2539,6 +1508,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 });
   }
@@ -2617,9 +1587,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,
@@ -2747,7 +1719,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 = () => {
@@ -2762,6 +1734,8 @@ export async function createEngineSession({
     state.spinner = null;
     state.lastTurn = null;
     state.busy = false;
+    pendingNotificationKeys.clear();
+    displayedExecutionNotificationKeys.clear();
   };
   const resetTuiForPendingSessionReset = () => {
     pendingSessionReset = true;
@@ -2929,8 +1903,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 });
@@ -2944,8 +1925,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 });
@@ -3278,6 +2265,7 @@ export async function createEngineSession({
       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]`
@@ -3285,6 +2273,9 @@ export async function createEngineSession({
       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()
         : [];
@@ -3306,7 +2297,7 @@ export async function createEngineSession({
         restoreState.restorable = false;
         restoreState.requeueEntries = [];
       }
-      return { aborted, restoreText, pastedImages: restorePastedImages, discardPastedImages };
+      return { aborted, restoreText, pastedImages: restorePastedImages, discardPastedImages, pastedTexts: restorePastedTexts, discardPastedTexts };
     },
     resolveToolApproval: (id, decision = {}) => {
       const approved = decision === true || decision?.approved === true;
@@ -3368,8 +2359,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 });
@@ -3397,6 +2394,16 @@ export async function createEngineSession({
       set({ remoteEnabled: next });
       return next;
     },
+    // Force-claim remote for this session (single-holder, last-wins). Always
+    // turns remote ON here and steals the bridge seat; the previous holder is
+    // superseded and flips itself OFF via onRemoteStateChange. Used by the
+    // `/remote` slash command — repeated /remote just re-claims (idempotent).
+    claimRemote: () => {
+      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
@@ -3479,6 +2486,15 @@ export async function createEngineSession({
         'info');
       return true;
     },
+    loginOpenCodeGoUsage: async () => {
+      if (state.commandBusy) throw new Error('command busy');
+      set({ commandBusy: true });
+      try {
+        return await runtime.loginOpenCodeGoUsage();
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     saveOpenAIUsageSessionKey: (secret) => {
       runtime.saveOpenAIUsageSessionKey(secret);
       pushNotice('OpenAI usage auth saved', 'info');
@@ -3603,6 +2619,8 @@ export async function createEngineSession({
       }
     },
     pushNotice,
+    removeNotice,
+    setProgressHint,
     clear: async () => {
       if (state.commandBusy) return false;
       set({ commandBusy: true });
@@ -3739,6 +2757,8 @@ export async function createEngineSession({
       try { clearInterval(runtimePulseTimer); } catch {}
       try { unsubscribeRuntimeNotifications?.(); } catch {}
       unsubscribeRuntimeNotifications = null;
+      try { unsubscribeRemoteState?.(); } catch {}
+      unsubscribeRemoteState = null;
       denyAllToolApprovals('runtime closing');
       await runtime.close(reason, options);
       listeners.clear();