mixdog 0.8.1 → 0.9.1

package/src/tui/engine.mjs

@@ -8,11 +8,17 @@
 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 { presentErrorText } from '../runtime/shared/err-text.mjs';
+import { isBackgroundErrorOnlyBody, presentErrorText } from '../runtime/shared/err-text.mjs';
+import {
+  isModelVisibleToolCompletionWrapper,
+  modelVisibleToolCompletionMessage,
+} from '../runtime/shared/tool-execution-contract.mjs';
+import { listThemes, getThemeSetting, setThemeSetting } from './theme.mjs';
 
 const BOOT_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ''));
 const BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance.now());
@@ -75,6 +81,11 @@ const SESSION_RUNTIME_MODULE = import.meta.url.replace(/\\/g, '/').includes('/tu
   ? '../../mixdog-session-runtime.mjs'
   : '../mixdog-session-runtime.mjs';
 
+const TOOL_APPROVAL_TIMEOUT_MS = (() => {
+  const value = Number(process.env.MIXDOG_TOOL_APPROVAL_TIMEOUT_MS);
+  return Number.isFinite(value) && value > 0 ? Math.max(1000, Math.round(value)) : 120_000;
+})();
+
 let _idSeq = 0;
 const nextId = () => `it_${++_idSeq}`;
 
@@ -97,21 +108,47 @@ function pickDoneVerb(turn) {
   return TURN_DONE_VERBS[(turn * 5 + 2) % TURN_DONE_VERBS.length];
 }
 
-function formatIdleDuration(ms) {
+function formatElapsedSeconds(ms) {
   const value = Math.max(0, Number(ms) || 0);
-  if (value >= 3_600_000 && value % 3_600_000 === 0) return `${value / 3_600_000}h`;
-  if (value >= 60_000) return `${Math.round(value / 60_000)}m`;
-  if (value < 1_000) return '';
-  return `${Math.floor(value / 1000)}s`;
+  if (value <= 0) return '0s';
+  return `${Math.max(1, Math.ceil(value / 1000))}s`;
 }
 
-function formatTokenCount(value) {
-  const n = Number(value || 0);
-  if (!Number.isFinite(n) || n <= 0) return '0';
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}m`;
-  if (n >= 10_000) return `${Math.round(n / 1000)}k`;
-  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
-  return `${Math.round(n)}`;
+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([
@@ -119,7 +156,7 @@ const FAILED_NOTICE_ACTIONS = new Map([
   ['auth-forget', 'forget auth'],
   ['auto-clear', 'update auto-clear'],
   ['autoclear', 'update auto-clear'],
-  ['bridge', 'run bridge command'],
+  ['agent', 'run agent command'],
   ['channels', 'load channels'],
   ['channels update', 'update channels'],
   ['clear', 'clear chat'],
@@ -226,23 +263,110 @@ function polishNoticeText(text) {
 function toolResultText(content) {
   if (content == null) return '';
   if (typeof content === 'string') return content;
-  const parts = Array.isArray(content)
-    ? content
-    : (content && typeof content === 'object' && Array.isArray(content.content) ? content.content : null);
-  if (parts) {
-    return parts.map((c) => {
-      if (typeof c === 'string') return c;
-      if (c?.type === 'image') return `[image: ${c.mimeType || c.mediaType || c.source?.media_type || 'image'}]`;
-      return c?.text ?? '';
-    }).filter(Boolean).join('\n');
-  }
   if (Array.isArray(content)) {
-    return content.map((c) => (typeof c === 'string' ? c : c?.text ?? '')).filter(Boolean).join('\n');
+    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;
   }
-  if (typeof content === 'object' && typeof content.text === 'string') return content.text;
   try { return JSON.stringify(content); } catch { return String(content); }
 }
 
+const TOOL_RESULT_PART_MAX_DEPTH = 12;
+const TOOL_RESULT_JSON_FALLBACK_MAX = 480;
+
+function compactToolResultObjectFallback(obj) {
+  if (obj?.type === 'tool_result') return '';
+  try {
+    const json = JSON.stringify(obj);
+    if (!json || json === '{}') return '';
+    if (json.length <= TOOL_RESULT_JSON_FALLBACK_MAX) return json;
+    return `${json.slice(0, TOOL_RESULT_JSON_FALLBACK_MAX - 1)}…`;
+  } catch {
+    return String(obj);
+  }
+}
+
+function toolResultPartText(part, depth = 0) {
+  if (part == null) return '';
+  if (depth > TOOL_RESULT_PART_MAX_DEPTH) return '';
+  if (typeof part === 'string') return part;
+  if (part?.type === 'image' || part?.type === 'input_image') {
+    return `[image: ${part.mimeType || part.mediaType || part.source?.media_type || 'image'}]`;
+  }
+  if (part?.type === 'tool_result') {
+    const inner = part.content;
+    if (typeof inner === 'string') return inner;
+    if (Array.isArray(inner)) {
+      return inner.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
+    }
+    if (inner != null && typeof inner === 'object') {
+      return toolResultPartText(inner, depth + 1);
+    }
+    return '';
+  }
+  if (part?.type === 'text' || part?.type === 'output_text' || part?.type === 'input_text') {
+    return part.text ?? '';
+  }
+  if (Array.isArray(part)) {
+    return part.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
+  }
+  if (typeof part === 'object') {
+    if (Array.isArray(part.content)) {
+      const nested = part.content.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
+      if (nested) return nested;
+    }
+    if (part.content != null && typeof part.content === 'object') {
+      const nested = toolResultPartText(part.content, depth + 1);
+      if (nested) return nested;
+    }
+    if (Array.isArray(part.parts)) {
+      const nested = part.parts.map((c) => toolResultPartText(c, depth + 1)).filter((t) => t !== '').join('\n');
+      if (nested) return nested;
+    }
+    if (typeof part.text === 'string' && part.text) return part.text;
+    if (typeof part.output === 'string' && part.output) return part.output;
+    if (typeof part.message === 'string' && part.message) return part.message;
+    if (typeof part.content === 'string') return part.content;
+    if (part.source?.type === 'base64' && part.source?.data) {
+      return `[image: ${part.source.media_type || part.source.mediaType || 'base64'}]`;
+    }
+    return compactToolResultObjectFallback(part);
+  }
+  return '';
+}
+
+function toolAggregateDetailFallback(detailText, rawResult) {
+  if (String(detailText || '').trim()) return detailText;
+  const raw = String(rawResult || '').replace(/\s+$/, '').trim();
+  if (!raw) return detailText;
+  const line = raw.split('\n').map((l) => l.trim()).find(Boolean) || '';
+  if (!line) return detailText;
+  return line.length > 160 ? `${line.slice(0, 157)}…` : line;
+}
+
+function toolGroupedDisplayFallback(resultText, text, rawText) {
+  if (String(resultText || '').trim()) return resultText;
+  const body = String(text || rawText || '').trim();
+  if (body) return text || rawText;
+  return resultText;
+}
+
 function toolErrorDisplay(value, surface = 'tool') {
   const text = presentErrorText(value, { surface });
   if (/^(?:Search failed|Fetch failed|No first response|The .+ went stale|(?:Web search agent|Agent|Tool) (?:stopped|was cancelled))/i.test(text)) {
@@ -284,7 +408,7 @@ function stripSyntheticAgentTags(text) {
   const taskResult = textBetweenTag(value, 'result');
   if (taskResult) return taskResult;
   return value
-    .replace(/^bridge result[^\n]*(?:\n|$)/i, '')
+    .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();
 }
@@ -300,7 +424,7 @@ function splitBridgeEnvelope(text) {
   };
 }
 
-function bridgeJobStatusText(parsed) {
+function agentJobStatusText(parsed) {
   if (!parsed) return '';
   const parts = [];
   if (parsed.status) parts.push(`status: ${parsed.status}`);
@@ -308,19 +432,55 @@ function bridgeJobStatusText(parsed) {
   return parts.join(' · ');
 }
 
-function bridgeJobResultText(text, parsed = parseBridgeJob(text)) {
+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 bridgeJobStatusText(parsed);
+    return agentJobStatusText(parsed);
   }
   return stripSyntheticAgentTags(value) || value;
 }
 
-function parseBackgroundTaskEnvelope(text) {
+function parseAgentResultEnvelope(text, fallback = {}) {
+  const value = String(text ?? '').trim();
+  if (!/^agent result\b/i.test(value)) return null;
+  const [head = '', ...restLines] = value.split('\n');
+  const body = stripSyntheticAgentTags(restLines.join('\n'));
+  const attrs = {};
+  const attrRe = /([a-zA-Z][\w-]*)=("[^"]*"|'[^']*'|\S+)/g;
+  let match;
+  while ((match = attrRe.exec(head))) {
+    attrs[match[1].toLowerCase()] = String(match[2] || '').replace(/^["']|["']$/g, '');
+  }
+  const providerModel = /\s([a-zA-Z0-9_.-]+)\/([^\s]+)\s*$/i.exec(head);
+  const role = attrs.agent || attrs.role || fallback.role || fallback.agent || '';
+  return {
+    name: 'agent',
+    label: String(fallback.status || attrs.status || 'completed').toLowerCase(),
+    args: {
+      type: 'result',
+      status: fallback.status || attrs.status || 'completed',
+      task_id: fallback.taskId || attrs.task_id || attrs.taskid || undefined,
+      tag: fallback.tag || attrs.tag || undefined,
+      agent: role || undefined,
+      role: role || undefined,
+      provider: fallback.provider || attrs.provider || providerModel?.[1] || undefined,
+      model: fallback.model || attrs.model || providerModel?.[2] || undefined,
+      preset: fallback.preset || attrs.preset || undefined,
+      effort: fallback.effort || attrs.effort || undefined,
+      fast: fallback.fast ?? attrs.fast,
+    },
+    result: body || agentJobStatusText({ status: fallback.status || attrs.status || 'completed', taskId: fallback.taskId || attrs.task_id || attrs.taskid || '' }),
+    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(fallback.status || attrs.status || ''),
+  };
+}
+
+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');
@@ -334,9 +494,25 @@ function parseBackgroundTaskEnvelope(text) {
     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 : 'task';
+  const name = surface === 'explore' || surface === 'search' || surface === 'shell' || surface === 'agent' ? surface : 'task';
   const status = String(fields.status || '').toLowerCase();
   const taskId = fields.task_id || fields.taskid || '';
+  const errorText = fields.error || '';
+  const agentResult = parseAgentResultEnvelope(body, {
+    status,
+    taskId,
+    tag: fields.tag || fields.label || '',
+    role: fields.role || fields.agent || '',
+    agent: fields.agent || '',
+    provider: fields.provider || '',
+    model: fields.model || '',
+    preset: fields.preset || '',
+    effort: fields.effort || '',
+    fast: fields.fast,
+  });
+  if (agentResult) return { ...agentResult, rawResult: value };
+  const errorOnlyBody = isBackgroundErrorOnlyBody(body, errorText);
+  const resultBody = body && !errorOnlyBody ? body : '';
   return {
     name,
     label: status || 'notification',
@@ -345,30 +521,78 @@ function parseBackgroundTaskEnvelope(text) {
       status,
       task_id: taskId || undefined,
       surface,
+      operation: fields.operation || undefined,
       label: fields.label || undefined,
-    },
-    result: body || [status ? `status: ${status}` : '', taskId ? `task_id: ${taskId}` : ''].filter(Boolean).join(' · ') || 'background task',
-    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(status) || /^error:/i.test(body),
+      tag: fields.tag || undefined,
+      agent: fields.agent || fields.role || undefined,
+      role: fields.role || fields.agent || undefined,
+      provider: fields.provider || undefined,
+      model: fields.model || undefined,
+      preset: fields.preset || undefined,
+      effort: fields.effort || undefined,
+      fast: fields.fast || undefined,
+      error: errorText || undefined,
+      startedAt: fields.started || fields.startedat || undefined,
+      finishedAt: fields.finished || fields.finishedat || undefined,
+    },
+    result: resultBody || (!errorText ? [status ? `status: ${status}` : '', taskId ? `task_id: ${taskId}` : ''].filter(Boolean).join(' · ') : ''),
+    rawResult: value,
+    isError: /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(status) || /^error:/i.test(body) || Boolean(errorText),
   };
 }
 
+function isStatusOnlyAgentCompletionNotification(text) {
+  const background = parseBackgroundTaskEnvelope(text);
+  if (background?.name === 'agent' && /^(completed|cancelled|canceled)$/i.test(background.label || '')) {
+    return !(hasAgentResponseResultText(background.result) || hasAgentResponseResultText(text));
+  }
+  const parsed = parseAgentJob(text);
+  const result = agentJobResultText(text, parsed);
+  if (!parsed?.taskId || !/^(completed|cancelled|canceled)$/i.test(parsed.status || '')) return false;
+  return !(hasAgentResponseResultText(result) || hasAgentResponseResultText(text));
+}
+
+function hasAgentResponseResultText(text) {
+  const value = String(text || '').trim();
+  if (!value) return false;
+  if (/^status:\s*(?:running|pending|queued|completed|failed|cancelled|canceled)(?:\s*·\s*task_id:\s*\S+)?$/i.test(value)) return false;
+  if (/^(?:background task\b|agent task:|task_id:)/i.test(value) && !/\n\s*\n[\s\S]*\S/.test(value)) return false;
+  return true;
+}
+
 function bracketField(text, name) {
   const re = new RegExp(`^\\[${name}:\\s*([^\\]]*)\\]`, 'mi');
   return re.exec(String(text ?? ''))?.[1]?.trim() || '';
 }
 
+function toolResultStatus(text) {
+  const value = String(text ?? '');
+  const tagged = textBetweenTag(value, 'status');
+  if (tagged) return tagged.trim();
+  const bracketed = bracketField(value, 'status');
+  if (bracketed) return bracketed.trim();
+  const inline = /^(?:status|state):\s*([^\s·,;]+)/mi.exec(value);
+  return inline ? inline[1].trim() : '';
+}
+
+function isErrorToolStatus(status) {
+  return /^(failed|error|timeout|cancelled|canceled|killed)$/i.test(String(status || '').trim());
+}
+
 function parseSyntheticAgentMessage(text) {
   const value = String(text ?? '').trim();
   if (!value) return null;
   const finalAnswer = textBetweenTag(value, 'final-answer');
   if (finalAnswer) {
     return {
-      name: 'bridge',
+      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');
@@ -384,15 +608,15 @@ function parseSyntheticAgentMessage(text) {
       isError: /^(failed|error|timeout|cancelled|killed)$/i.test(status) || (exit && exit !== '0' && exit !== 'n/a'),
     };
   }
-  const bridgeJob = parseBridgeJob(value);
-  if (bridgeJob?.taskId) {
-    const label = bridgeJob.status || 'notification';
-    const result = bridgeJobResultText(value, bridgeJob);
+  const agentJob = parseAgentJob(value);
+  if (agentJob?.taskId) {
+    const label = agentJob.status || 'notification';
+    const result = agentJobResultText(value, agentJob);
     return {
-      name: 'bridge',
+      name: 'agent',
       label,
-      args: bridgeArgsWithResultMetadata({ type: bridgeJob.type || 'notification', description: 'agent notification' }, bridgeJob),
-      result: result || bridgeJobStatusText(bridgeJob) || 'agent notification',
+      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),
     };
   }
@@ -402,7 +626,7 @@ function parseSyntheticAgentMessage(text) {
     const taskId = textBetweenTag(value, 'task-id');
     const result = stripSyntheticAgentTags(value);
     return {
-      name: 'bridge',
+      name: 'agent',
       label: status,
       taskId,
       summary,
@@ -435,9 +659,9 @@ function parseToolArgs(args) {
 
 const yieldToRenderer = () => new Promise((resolve) => setImmediate(resolve));
 
-function parseBridgeJob(text) {
+function parseAgentJob(text) {
   const value = String(text || '');
-  const idMatch = /^bridge task:\s*([^\s]+)/m.exec(value) || /^task_id:\s*([^\s]+)/m.exec(value);
+  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);
@@ -468,20 +692,51 @@ function queuePriorityValue(value) {
 }
 
 function defaultQueuePriority(mode) {
-  return mode === 'task-notification' ? 'next' : 'later';
+  // 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) {
-  return (entry?.mode || 'prompt') !== 'task-notification';
+  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 = parseBridgeJob(text);
-  const result = bridgeJobResultText(text, parsed);
+  const parsed = parseAgentJob(text);
+  const result = agentJobResultText(text, parsed);
   const synthetic = parseSyntheticAgentMessage(text);
   return firstQueueLine(synthetic?.result || result || text) || 'agent notification';
 }
@@ -499,6 +754,33 @@ function promptContentText(content) {
   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);
@@ -543,18 +825,76 @@ function callCommitCallbacks(entries) {
 
 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 role = String(synthetic.args?.agent || synthetic.args?.role || '').trim();
+    if (resultId || role) return ['agent-result', resultId, role].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';
-  return [id, type || fallbackKind, status].filter(Boolean).join(':');
+  // 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 bridgeArgsWithResultMetadata(args, parsed) {
+function agentArgsWithResultMetadata(args, parsed) {
   if (!parsed) return args;
   const next = { ...(args && typeof args === 'object' ? args : {}) };
-  if (parsed.type) next.type = parsed.type;
+  const requestedAction = String(next.type || next.action || next.mode || '').trim().toLowerCase();
+  if (parsed.type) {
+    // Job status envelopes report the original job type (usually "spawn").
+    // Preserve the user's current agent tool action ("status", "read", …) so
+    // manual checks render as "Reviewer status" instead of another
+    // "Spawning Reviewer" card. Keep the job type as metadata for detail.
+    if (!requestedAction || /^(notification|result|completion)$/i.test(requestedAction)) next.type = parsed.type;
+    else next.jobType = parsed.type;
+  }
   if (parsed.status) next.status = parsed.status;
   if (parsed.taskId) next.task_id = parsed.taskId;
   if (parsed.role) next.role = parsed.role;
@@ -593,23 +933,22 @@ export async function createEngineSession({
   const cwd = runtime.cwd || process.cwd();
   const stateStartedAt = performance.now();
   const autoClearState = () => runtime.getAutoClear?.() || runtime.autoClear || { enabled: true, idleMs: 60 * 60 * 1000 };
-  const BRIDGE_STATUS_CACHE_MS = 250;
-  let bridgeStatusCache = null;
-  let bridgeStatusCacheAt = 0;
-  const bridgeStatusState = ({ force = false } = {}) => {
+  const AGENT_STATUS_CACHE_MS = 250;
+  let agentStatusCache = null;
+  let agentStatusCacheAt = 0;
+  const agentStatusState = ({ force = false } = {}) => {
     const now = Date.now();
-    if (!force && bridgeStatusCache && now - bridgeStatusCacheAt < BRIDGE_STATUS_CACHE_MS) return bridgeStatusCache;
-    const status = runtime.bridgeStatus?.() || {};
-    bridgeStatusCache = {
-      bridgeMode: runtime.bridgeMode || status.bridgeMode || 'async',
-      bridgeWorkers: Array.isArray(status.bridgeWorkers) ? status.bridgeWorkers : [],
-      bridgeJobs: Array.isArray(status.bridgeJobs) ? status.bridgeJobs : [],
-      bridgeScope: status.bridgeScope || null,
+    if (!force && agentStatusCache && now - agentStatusCacheAt < AGENT_STATUS_CACHE_MS) return agentStatusCache;
+    const status = runtime.agentStatus?.() || {};
+    agentStatusCache = {
+      agentWorkers: Array.isArray(status.agentWorkers) ? status.agentWorkers : [],
+      agentJobs: Array.isArray(status.agentJobs) ? status.agentJobs : [],
+      agentScope: status.agentScope || null,
     };
-    bridgeStatusCacheAt = now;
-    return bridgeStatusCache;
+    agentStatusCacheAt = now;
+    return agentStatusCache;
   };
-  const routeState = () => ({
+  const baseRouteState = () => ({
     sessionId: runtime.id,
     clientHostPid: runtime.clientHostPid || null,
     model: runtime.model,
@@ -623,18 +962,37 @@ export async function createEngineSession({
     effectiveContextWindowPercent: runtime.effectiveContextWindowPercent,
     cwd: runtime.cwd || process.cwd(),
     systemShell: runtime.systemShell || { source: 'auto', command: '', effective: '' },
+    searchRoute: runtime.getSearchRoute?.() || runtime.searchRoute || null,
     autoClear: autoClearState(),
     workflow: runtime.workflow || null,
   });
 
-  const routeStateStartedAt = performance.now();
-  const initialRouteState = routeState();
-  bootProfile('engine:route-state-ready', { ms: (performance.now() - routeStateStartedAt).toFixed(1) });
-  const initialBridgeState = {
-    bridgeMode: runtime.bridgeMode || 'async',
-    bridgeWorkers: [],
-    bridgeJobs: [],
-    bridgeScope: null,
+  const routeState = () => ({
+    ...baseRouteState(),
+    displayContextWindow: state.displayContextWindow || 0,
+    compactBoundaryTokens: state.compactBoundaryTokens || 0,
+    autoCompactTokenLimit: state.autoCompactTokenLimit || 0,
+  });
+
+  function syncContextDisplayFields(ctx = null) {
+    const status = ctx || runtime.contextStatus?.() || null;
+    if (!status) return;
+    const displayWindow = Number(status.contextWindow || 0);
+    const compactBoundary = Number(status.compaction?.boundaryTokens || 0);
+    const autoCompact = Number(
+      status.compaction?.autoCompactTokenLimit
+      || runtime.session?.autoCompactTokenLimit
+      || 0,
+    );
+    if (displayWindow > 0) state.displayContextWindow = displayWindow;
+    if (compactBoundary > 0) state.compactBoundaryTokens = compactBoundary;
+    if (autoCompact > 0) state.autoCompactTokenLimit = autoCompact;
+  }
+
+  const initialAgentState = {
+    agentWorkers: [],
+    agentJobs: [],
+    agentScope: null,
   };
   let state = {
     items: [],
@@ -645,25 +1003,74 @@ export async function createEngineSession({
     spinner: null,
     queued: [],
     thinking: null,
+    toolApproval: null,
     lastTurn: null,
     stats: createSessionStats(),
-    ...initialRouteState,
-    ...initialBridgeState,
+    ...baseRouteState(),
+    displayContextWindow: 0,
+    compactBoundaryTokens: 0,
+    autoCompactTokenLimit: 0,
+    ...initialAgentState,
     toolMode: runtime.toolMode,
     cwd,
+    themeEpoch: 0,
   };
+  bootProfile('engine:route-state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
   bootProfile('engine:state-ready', { ms: (performance.now() - stateStartedAt).toFixed(1) });
+  let pendingSessionReset = false;
   const syncContextStats = ({ allowEstimated = false } = {}) => {
+    if (pendingSessionReset) return null;
     const ctx = runtime.contextStatus?.() || null;
+    if (!ctx) return null;
+    syncContextDisplayFields(ctx);
     const hasProviderUsage = Number(state.stats.latestPromptTokens || state.stats.latestInputTokens || state.stats.inputTokens || 0) > 0;
-    const lastApiTokens = Number(ctx?.lastApiRequestStale ? 0 : (ctx?.lastApiRequestTokens || ctx?.usage?.lastContextTokens || 0));
-    const estimatedTokens = Number(ctx?.currentEstimatedTokens || 0);
-    const used = lastApiTokens;
-    if (!allowEstimated && !hasProviderUsage && ctx?.usedSource !== 'last_api_request') return ctx;
-    if (Number.isFinite(used) && used > 0) state.stats.currentContextTokens = Math.max(0, used);
-    else state.stats.currentContextTokens = 0;
-    state.stats.currentEstimatedContextTokens = Number.isFinite(estimatedTokens) ? Math.max(0, estimatedTokens) : 0;
-    state.stats.currentContextSource = used > 0 ? 'last_api_request' : (estimatedTokens > 0 ? 'estimated' : null);
+    const hasApiContextUsage = Number(ctx?.lastApiRequestTokens ?? ctx?.usage?.lastContextTokens ?? 0) > 0;
+    const hasTurnActivity = state.busy === true
+      || state.spinner != null
+      || state.thinking != null;
+    const isFreshSession = !hasProviderUsage && !hasApiContextUsage && !hasTurnActivity;
+    if (isFreshSession) {
+      state.stats.currentEstimatedContextTokens = 0;
+      state.stats.currentContextTokens = 0;
+      state.stats.currentContextSource = null;
+      state.stats.currentContextUpdatedAt = Date.now();
+      return ctx;
+    }
+    const estimatedTokens = Math.max(0, Number(ctx.currentEstimatedTokens ?? ctx.usedTokens ?? 0));
+    const usedTokens = Math.max(0, Number(ctx.usedTokens ?? estimatedTokens ?? 0));
+    const usedSource = String(ctx.usedSource || '').toLowerCase();
+    const shouldPublishEstimate = allowEstimated && (
+      usedSource === 'estimated'
+      || Number(ctx.currentEstimatedTokens) > 0
+      || usedTokens > 0
+    );
+    if (!allowEstimated && !hasProviderUsage && usedSource !== 'last_api_request') return ctx;
+    if (shouldPublishEstimate) {
+      state.stats.currentEstimatedContextTokens = estimatedTokens;
+      state.stats.currentContextSource = 'estimated';
+      state.stats.currentContextTokens = 0;
+    } else if (allowEstimated && (hasProviderUsage || hasApiContextUsage || hasTurnActivity)) {
+      state.stats.currentEstimatedContextTokens = estimatedTokens;
+      state.stats.currentContextSource = usedSource || (estimatedTokens > 0 ? 'estimated' : null);
+      const publishedSource = String(state.stats.currentContextSource || '').toLowerCase();
+      if (publishedSource === 'last_api_request') {
+        const apiUsed = Math.max(0, Number(ctx.lastApiRequestTokens ?? usedTokens ?? 0));
+        state.stats.currentContextTokens = apiUsed;
+      } else if (publishedSource === 'estimated') {
+        state.stats.currentContextTokens = 0;
+      } else {
+        state.stats.currentContextTokens = usedTokens > 0 ? usedTokens : 0;
+      }
+    } else {
+      state.stats.currentEstimatedContextTokens = 0;
+      if (usedSource === 'last_api_request' && Number(ctx.lastApiRequestTokens ?? usedTokens ?? 0) > 0) {
+        state.stats.currentContextTokens = Math.max(0, Number(ctx.lastApiRequestTokens ?? usedTokens ?? 0));
+        state.stats.currentContextSource = 'last_api_request';
+      } else {
+        state.stats.currentContextTokens = 0;
+        state.stats.currentContextSource = null;
+      }
+    }
     state.stats.currentContextUpdatedAt = Date.now();
     return ctx;
   };
@@ -671,7 +1078,24 @@ export async function createEngineSession({
   syncContextStats({ allowEstimated: true });
   bootProfile('engine:context-ready', { ms: (performance.now() - contextStartedAt).toFixed(1) });
   const listeners = new Set();
-  const emit = () => { for (const l of listeners) l(); };
+  // Coalesce store notifications: a single onToolCall batch / finalize path
+  // fires many set() calls in one synchronous block (aggregate header sync,
+  // spinner, item pushes). Notifying React on every set() painted the
+  // intermediate layouts ("툭툭" header/count jitter). Collapsing the
+  // notifications into one microtask means listeners see only the final state
+  // of the current tick — "draw twice, keep the last one". getState() stays
+  // synchronous and always returns the latest snapshot, so useSyncExternalStore
+  // never tears.
+  let emitScheduled = false;
+  const flushEmit = () => {
+    emitScheduled = false;
+    for (const l of listeners) l();
+  };
+  const emit = () => {
+    if (emitScheduled) return;
+    emitScheduled = true;
+    queueMicrotask(flushEmit);
+  };
   const set = (patch) => {
     if (!patch || typeof patch !== 'object') return false;
     let changed = false;
@@ -703,38 +1127,36 @@ export async function createEngineSession({
     if (item?.id != null) itemIndexById.set(item.id, index);
     set({ items });
   };
-  const removeItemsByIds = (ids) => {
-    const idSet = new Set((ids || []).filter((id) => id != null));
-    if (idSet.size === 0) return false;
-    const items = state.items.filter((item) => !idSet.has(item?.id));
-    if (items.length === state.items.length) return false;
-    set({ items: replaceItems(items) });
-    return true;
-  };
-  const pushUserOrSyntheticItem = (text, id = nextId()) => {
+  const upsertSyntheticToolItem = (text, id = nextId(), parsed = null) => {
     const synthetic = parseSyntheticAgentMessage(text);
-    if (!synthetic) {
-      pushItem({ kind: 'user', id, text });
-      return;
-    }
+    if (!synthetic) return false;
     const label = synthetic.label || 'notification';
+    const args = synthetic.args || {
+      type: label,
+      task_id: synthetic.taskId || parsed?.taskId || undefined,
+      description: synthetic.summary || 'agent notification',
+    };
+    const isError = synthetic.isError ?? /^(failed|error|timeout|killed|cancelled)$/i.test(label);
     pushItem({
       kind: 'tool',
       id,
-      name: synthetic.name || 'bridge',
-      args: synthetic.args || {
-        type: label,
-        task_id: synthetic.taskId || undefined,
-        description: synthetic.summary || 'agent notification',
-      },
+      name: synthetic.name || 'agent',
+      args,
       result: synthetic.result,
-      isError: synthetic.isError ?? /^(failed|error|killed|cancelled)$/i.test(label),
+      rawResult: synthetic.rawResult ?? text,
+      isError,
       expanded: false,
       count: 1,
       completedCount: 1,
       startedAt: Date.now(),
       completedAt: Date.now(),
     });
+    return true;
+  };
+  const pushUserOrSyntheticItem = (text, id = nextId()) => {
+    if (isModelVisibleToolCompletionWrapper(text)) return;
+    if (upsertSyntheticToolItem(text, id)) return;
+    pushItem({ kind: 'user', id, text });
   };
   const pushToast = (text, tone = 'info', ttlMs = 3000) => {
     const id = nextId();
@@ -759,6 +1181,80 @@ 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();
+    });
+  }
   const patchItem = (id, patch) => {
     let index = itemIndexById.get(id);
     if (!Number.isInteger(index) || state.items[index]?.id !== id) {
@@ -782,6 +1278,17 @@ export async function createEngineSession({
   };
   const toastTimers = new Set();
   let disposed = false;
+  const runtimePulseTimer = setInterval(() => {
+    if (disposed) return;
+    if (pendingSessionReset) return;
+    syncContextStats({ allowEstimated: true });
+    set({
+      ...routeState(),
+      stats: { ...state.stats },
+      ...agentStatusState(),
+    });
+  }, 2000);
+  runtimePulseTimer.unref?.();
 
   function clearToastTimers() {
     for (const timer of toastTimers) {
@@ -794,18 +1301,46 @@ export async function createEngineSession({
   let lastUserActivityAt = Date.now();
   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 updateBridgeJobCard(itemId, text, isError = false) {
-    const parsed = parseBridgeJob(text);
+  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 = bridgeJobResultText(text, parsed) || String(text || '').trim();
-    const displayText = isError ? toolErrorDisplay(rawDisplayText, 'bridge') : rawDisplayText;
+    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: bridgeArgsWithResultMetadata(current?.args, parsed) } : {}),
+      ...(parsed ? { args: agentArgsWithResultMetadata(current?.args, parsed) } : {}),
     });
   }
 
@@ -814,23 +1349,38 @@ export async function createEngineSession({
       if (disposed) return;
       const text = String(event?.content ?? event?.text ?? event ?? '').trim();
       if (!text) return;
-      const parsed = parseBridgeJob(text);
+      const parsed = parseAgentJob(text);
       const notificationKey = notificationQueueKey(event, text, parsed);
-      if (parsed?.taskId) {
-        const existing = [...state.items].reverse().find((item) => {
-          if (!item || item.kind !== 'tool' || item.name !== 'bridge') return false;
-          const args = parseToolArgs(item.args);
-          return args.task_id === parsed.taskId;
-        });
-        if (existing) {
-          updateBridgeJobCard(existing.id, text, /^(failed|error|timeout|cancelled|killed)$/i.test(parsed.status));
+      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;
       }
-      enqueue(text, {
+      if (parsed?.taskId) {
+        set(agentStatusState({ force: true }));
+      }
+      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;
     });
   }
 
@@ -852,6 +1402,10 @@ export async function createEngineSession({
         ...uniqueReasons.slice(1),
       ].join('\n');
     }
+    for (const result of group.results || []) {
+      const line = String(result?.text || '').trim();
+      if (line) return result.text;
+    }
     return '';
   }
 
@@ -869,6 +1423,7 @@ export async function createEngineSession({
   function aggregateRawResult(calls) {
     const chunks = [];
     for (const rec of calls || []) {
+      if (rec?.resolved !== true) continue;
       const text = String(rec?.resultText || '').replace(/\s+$/, '');
       if (!text.trim()) continue;
       const label = String(rec?.name || rec?.category || 'tool').trim() || 'tool';
@@ -877,6 +1432,19 @@ export async function createEngineSession({
     return chunks.join('\n\n');
   }
 
+  function aggregateDisplayDetail(summaries, allCalls) {
+    const fromSummaries = formatAggregateDetail(summaries);
+    if (String(fromSummaries || '').trim()) return fromSummaries;
+    let line = '';
+    for (const rec of allCalls || []) {
+      const text = String(rec?.resultText || '').replace(/\s+$/, '');
+      line = text.split('\n').map((l) => l.trim()).find(Boolean) || '';
+      if (line) break;
+    }
+    if (!line) return '';
+    return line.length > 160 ? `${line.slice(0, 157)}…` : line;
+  }
+
   function aggregateBucketForCategory(category) {
     switch (category) {
       case 'Read':
@@ -915,21 +1483,31 @@ export async function createEngineSession({
     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);
+    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) {
-        callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
-        assignAggregateSummaryOrder(aggregate, callRec);
-        callRec.isError = isError;
-        callRec.resultText = text;
-        callRec.resolved = true;
+      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;
@@ -939,36 +1517,42 @@ export async function createEngineSession({
         const succeeded = completed - errors;
         detailText = succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`;
       } else {
-        detailText = formatAggregateDetail(summaries) || '';
+        detailText = aggregateDisplayDetail(summaries, allCalls);
+        if (errors > 0) {
+          detailText = detailText ? `${detailText} · ${errors} Failed` : `${errors} Failed`;
+        }
       }
       const currentItem = state.items.find((it) => it.id === card.itemId);
-      const visualCompleted = Math.max(completed, Math.min(allCalls.length, Number(currentItem?.completedCount || 0)));
+      const earlyCompleted = allCalls.filter((r) => r.resolved || r.completedEarly).length;
+      const visualCompleted = Math.max(completed, earlyCompleted, Math.min(allCalls.length, Number(currentItem?.completedCount || 0)));
       const rawResult = aggregateRawResult(allCalls);
+      const displayDetail = toolAggregateDetailFallback(detailText, rawResult);
       patchItem(card.itemId, {
-        result: detailText,
-        text: detailText,
+        result: displayDetail,
+        text: displayDetail,
         rawResult: rawResult || null,
         isError: errors > 0,
         errorCount: errors,
         count: allCalls.length,
         completedCount: visualCompleted,
-        completedAt: Date.now(),
+        completedAt: Number(currentItem?.completedAt) || Date.now(),
       });
       card.done = true;
       if (callId) done.add(callId);
       return true;
     }
 
-    // Non-aggregate (legacy bridge-job cards, etc.)
+    // 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: resultText,
-      text: resultText,
+      result: displayResult,
+      text: displayResult,
       isError: group.errors > 0,
       errorCount: group.errors,
       count: group.count,
@@ -976,11 +1560,16 @@ export async function createEngineSession({
       completedAt: Date.now(),
     };
     if (group.count <= 1) {
-      const parsedBridge = parseBridgeJob(rawText);
-      if (parsedBridge) patch.args = bridgeArgsWithResultMetadata(state.items.find((it) => it.id === card.itemId)?.args, parsedBridge);
+      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) updateBridgeJobCard(card.itemId, rawText, isError);
+    if (group.count <= 1) updateAgentJobCard(card.itemId, rawText, isError);
     card.done = true;
     if (callId) done.add(callId);
     return true;
@@ -1017,6 +1606,9 @@ export async function createEngineSession({
     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) {
@@ -1026,11 +1618,12 @@ export async function createEngineSession({
         const totalCompleted = remaining > 0 ? completed + remaining : completed;
         const errors = allCalls.filter((r) => r.isError).length;
         const summaries = aggregateSummaries(aggregate);
-        const detailText = formatAggregateDetail(summaries) || '';
+        const detailText = aggregateDisplayDetail(summaries, allCalls);
         const rawResult = aggregateRawResult(allCalls);
+        const displayDetail = toolAggregateDetailFallback(detailText, rawResult);
         patchItem(card.itemId, {
-          result: detailText,
-          text: detailText,
+          result: displayDetail,
+          text: displayDetail,
           rawResult: rawResult || null,
           isError: errors > 0,
           errorCount: errors,
@@ -1084,13 +1677,90 @@ export async function createEngineSession({
     let thinkingSegmentStartedAt = 0;
     let accumulatedThinkingMs = 0;
     let cancelled = false;
+    let askResult = null;
+    let turnFinishedNormally = false;
+    const itemsAtTurnStart = state.items.length;
     const cardByCallId = new Map();
     const toolCards = [];
     const toolGroups = new Map();
     const resultsDone = new Set();
+    // Streaming providers can deliver eager onToolResult before onToolCall registers
+    // cards (send() still in flight). Hold those by callId until the batch lands.
+    const earlyResultBuffer = new Map();
     const aggregateCards = []; // active aggregate cards in the current consecutive tool block
+    const aggregateByBucket = new Map(); // tail-continuation cache; append only while still the last visible item
     let openAggregateCard = null;
-    let autoCompactStatus = null;
+
+    // ── Deferred tool-card push (scroll/text sync) ────────────────────────────
+    // A tool card used to enter the transcript the instant onToolCall fired,
+    // reserving its estimated height (margin+header+detail) while ToolExecution
+    // only painted blank placeholder rows for TOOL_PENDING_SHOW_DELAY_MS. With a
+    // bottom-fixed viewport that shoved the body up BEFORE any glyph appeared, so
+    // the scroll ran ahead of the text. We now hold each card off-screen for the
+    // same delay and push it only when its real header/detail will paint (delay
+    // elapsed) OR a result lands first (fast tool → completed card, no pending
+    // flicker). Either way the pushed spec is stamped `deferredDisplayReady` so
+    // ToolExecution renders the real header + 'Running' detail immediately
+    // instead of the blank pre-delay placeholder — this matters for the
+    // result-forced chain push (flushDeferredUpTo), where earlier-seq sibling
+    // cards are pushed alongside the result-bearing one before their own delay
+    // elapses and would otherwise paint an empty reserved band.
+    // Mirrors components/ToolExecution.jsx TOOL_PENDING_SHOW_DELAY_MS.
+    const TOOL_CARD_PUSH_DELAY_MS = 1000;
+    let deferredSeqCounter = 0;
+    const deferredEntries = []; // creation-order list; each is pushed at most once
+    // Push this entry AND every earlier-created still-deferred entry, in order,
+    // so transcript order always matches call order even when a later card's
+    // result/timer fires before an earlier one's.
+    const flushDeferredUpTo = (entry) => {
+      if (!entry) return;
+      for (const e of deferredEntries) {
+        if (e.seq > entry.seq) break;
+        if (e.pushed) continue;
+        e.pushed = true;
+        if (e.timer) { clearTimeout(e.timer); e.timer = null; }
+        try { e.push(); } catch {}
+      }
+    };
+    const registerDeferredCard = (card) => {
+      const entry = {
+        seq: deferredSeqCounter++,
+        pushed: false,
+        timer: null,
+        push: () => { card.pushed = true; if (card.spec) { card.spec.deferredDisplayReady = true; pushItem(card.spec); } },
+      };
+      card.deferred = entry;
+      card.ensureVisible = () => flushDeferredUpTo(entry);
+      deferredEntries.push(entry);
+      entry.timer = setTimeout(() => {
+        entry.timer = null;
+        if (disposed) return;
+        flushDeferredUpTo(entry);
+      }, TOOL_CARD_PUSH_DELAY_MS);
+      entry.timer.unref?.();
+    };
+    const registerDeferredAggregate = (aggregate) => {
+      const entry = {
+        seq: deferredSeqCounter++,
+        pushed: false,
+        timer: null,
+        push: () => { aggregate.pushed = true; if (aggregate.pendingSpec) { aggregate.pendingSpec.deferredDisplayReady = true; pushItem(aggregate.pendingSpec); } },
+      };
+      aggregate.deferred = entry;
+      aggregate.ensureVisible = () => flushDeferredUpTo(entry);
+      deferredEntries.push(entry);
+      entry.timer = setTimeout(() => {
+        entry.timer = null;
+        if (disposed) return;
+        flushDeferredUpTo(entry);
+      }, TOOL_CARD_PUSH_DELAY_MS);
+      entry.timer.unref?.();
+    };
+    const clearDeferredTimers = () => {
+      for (const e of deferredEntries) {
+        if (e.timer) { clearTimeout(e.timer); e.timer = null; }
+      }
+    };
 
     const markPromptCommitted = () => {
       if (activePromptRestore) {
@@ -1109,9 +1779,13 @@ export async function createEngineSession({
       const ids = new Set();
       for (const card of toolCards || []) {
         if (card?.itemId) ids.add(card.itemId);
+        // Seal not-yet-pushed specs too, so a card that pushes later (timer)
+        // enters already-finalized instead of flashing the active header form.
+        if (card && card.pushed === false && card.spec) card.spec.headerFinalized = true;
       }
       for (const aggregate of aggregateCards || []) {
         if (aggregate?.itemId) ids.add(aggregate.itemId);
+        if (aggregate && aggregate.pushed === false && aggregate.pendingSpec) aggregate.pendingSpec.headerFinalized = true;
       }
       if (ids.size === 0) return false;
       let changed = false;
@@ -1128,13 +1802,15 @@ export async function createEngineSession({
       for (const aggregate of aggregateCards) {
         const allCalls = [...aggregate.calls.values()];
         if (allCalls.length === 0) continue;
+        aggregate.ensureVisible?.();
         const errors = allCalls.filter((r) => r.isError).length;
         const summaries = aggregateSummaries(aggregate);
-        const detailText = formatAggregateDetail(summaries) || '';
+        const detailText = aggregateDisplayDetail(summaries, allCalls);
         const rawResult = aggregateRawResult(allCalls);
+        const displayDetail = toolAggregateDetailFallback(detailText, rawResult);
         patchItem(aggregate.itemId, {
-          result: detailText,
-          text: detailText,
+          result: displayDetail,
+          text: displayDetail,
           rawResult: rawResult || null,
           isError: errors > 0,
           count: allCalls.length,
@@ -1151,8 +1827,38 @@ export async function createEngineSession({
       openAggregateCard = null;
     };
 
+    const isAggregateTail = (aggregate) => {
+      if (!aggregate?.itemId) return false;
+      const last = state.items[state.items.length - 1];
+      return last?.kind === 'tool' && last.aggregate === true && last.id === aggregate.itemId;
+    };
+
+    const rememberActiveAggregate = (aggregate) => {
+      if (!aggregate) return;
+      if (!aggregateCards.includes(aggregate)) aggregateCards.push(aggregate);
+      aggregateByBucket.set(aggregate.bucket, aggregate);
+    };
+
     const ensureAggregateCard = (bucket) => {
-      if (openAggregateCard?.bucket === bucket) return openAggregateCard;
+      // Reuse the open aggregate when it is either still the transcript tail OR
+      // has not been pushed yet. The not-yet-pushed case matters for parallel
+      // tool batches: every call in one onToolCall batch is collected first and
+      // the card is pushed once afterward (syncAggregateHeader), so the 2nd+
+      // same-bucket call in the SAME batch must merge even though the card is
+      // not yet visible in state.items (isAggregateTail would be false).
+      if (openAggregateCard?.bucket === bucket
+          && (!openAggregateCard.pushed || isAggregateTail(openAggregateCard))) return openAggregateCard;
+      // If the previous aggregate was finalized/closed but is still the tail of
+      // the transcript (or was never pushed), continue that exact card instead
+      // of pushing a duplicate directly below it. Never reach past a visible
+      // assistant/tool/status item: that would make an older card's count change
+      // "in the middle" of history.
+      const tailAggregate = aggregateByBucket.get(bucket);
+      if (tailAggregate && (!tailAggregate.pushed || isAggregateTail(tailAggregate))) {
+        openAggregateCard = tailAggregate;
+        rememberActiveAggregate(tailAggregate);
+        return tailAggregate;
+      }
       const itemId = nextId();
       const aggregate = {
         itemId,
@@ -1164,7 +1870,10 @@ export async function createEngineSession({
         pushed: false,
         startedAt: Date.now(),
       };
-      aggregateCards.push(aggregate);
+      // Arm the deferred push once at creation; syncAggregateHeader only keeps
+      // pendingSpec current until the timer/result flushes it in call order.
+      registerDeferredAggregate(aggregate);
+      rememberActiveAggregate(aggregate);
       openAggregateCard = aggregate;
       return aggregate;
     };
@@ -1174,15 +1883,17 @@ export async function createEngineSession({
       const patch = {
         args: { categoryOrder: aggregate.categoryOrder.slice() },
         count: aggregate.calls.size,
-        completedCount: [...aggregate.calls.values()].filter((r) => r.resolved).length,
+        completedCount: [...aggregate.calls.values()].filter((r) => r.resolved || r.completedEarly).length,
         categories: Object.fromEntries(aggregate.categories),
       };
       if (aggregate.pushed) {
         patchItem(aggregate.itemId, patch);
         return;
       }
-      aggregate.pushed = true;
-      pushItem({
+      // Not yet visible: keep the latest header spec current. The deferred entry
+      // (armed at creation) pushes pendingSpec when its timer fires or a result
+      // forces it visible, preserving call order via flushDeferredUpTo.
+      aggregate.pendingSpec = {
         kind: 'tool',
         id: aggregate.itemId,
         name: '__aggregate__',
@@ -1194,14 +1905,20 @@ export async function createEngineSession({
         expanded: false,
         headerFinalized: false,
         startedAt: aggregate.startedAt || Date.now(),
-      });
+      };
     };
 
-    const ensureAssistant = () => {
+    const ensureAssistant = (initialText = '') => {
       if (!currentAssistantId) {
         currentAssistantId = nextId();
-        currentAssistantText = '';
-        pushItem({ kind: 'assistant', id: currentAssistantId, text: '', streaming: true });
+        // Do NOT reset currentAssistantText here. The first onTextDelta has
+        // already accumulated the opening chunk before this batched flush runs;
+        // wiping it dropped the leading characters and forced a later set() to
+        // re-add them. Segment resets are owned by closeAssistantSegment().
+        // Seed the new row with the already-visible text so the ● gutter and the
+        // first body line appear in the SAME set()/emit() — no empty "●-only"
+        // row that scrolls once on its own and again when the body lands.
+        pushItem({ kind: 'assistant', id: currentAssistantId, text: String(initialText || ''), streaming: true });
       }
       return currentAssistantId;
     };
@@ -1211,6 +1928,19 @@ export async function createEngineSession({
       currentAssistantText = '';
     };
 
+    const commitAssistantSegment = ({ sealToolBlock = false } = {}) => {
+      const text = currentAssistantText || '';
+      if (!text.trim()) {
+        closeAssistantSegment();
+        return false;
+      }
+      if (sealToolBlock) clearAggregateContinuation();
+      const id = currentAssistantId || ensureAssistant(text);
+      patchItem(id, { text, streaming: false });
+      closeAssistantSegment();
+      return true;
+    };
+
     const startThinkingSegment = () => {
       const now = Date.now();
       if (!thinkingStartedAt) thinkingStartedAt = now;
@@ -1232,11 +1962,17 @@ export async function createEngineSession({
     // batch accumulated text and flush at most once per STREAM_BATCH_INTERVAL_MS
     // (≈16ms / 60fps cap). A forced flush happens before any tool call,
     // finalization, or error so those code paths see the correct text state.
-    const STREAM_BATCH_INTERVAL_MS = 16;
+    // Flush cadence for streamed text/thinking. 8ms (~120fps) matches the Ink
+    // render maxFps (index.jsx render({ maxFps: 120 })), so a queued batch is
+    // never held back waiting for the next Ink frame. 16ms (~60fps) left every
+    // other Ink frame idle, which made fast provider streams visibly land in
+    // coarse chunks ("10 chars at a time").
+    const STREAM_BATCH_INTERVAL_MS = 8;
     let _batchTimer = null;
     let _pendingTextFlush = false;   // true when a text/spinner update is queued
     let _pendingThinkFlush = false;  // true when a thinking update is queued
     let _pendingThinkingLastEndedAt = 0;
+    let compactingActive = false;
 
     const flushStreamBatch = () => {
       if (_batchTimer !== null) {
@@ -1245,22 +1981,45 @@ export async function createEngineSession({
       }
       if (_pendingTextFlush) {
         _pendingTextFlush = false;
-        const id = ensureAssistant();
-        // Emit the accumulated assistant text and spinner update together so a
-        // streaming batch costs one set() → one emit() → one React reconcile.
+        // Show only COMPLETED lines while streaming. The in-progress trailing
+        // line stays hidden until its '\n' arrives, so the visible text never
+        // grows a glyph at a time (no "무"→pause→"무슨 일…" partial reveal, no
+        // CJK-width reflow jitter). The final non-streaming patch
+        // (streaming:false) always carries the full text, so the tail line that
+        // never got a newline still lands once at finalize.
+        const newlineIdx = currentAssistantText.lastIndexOf('\n');
+        const streamingVisibleText = newlineIdx >= 0
+          ? currentAssistantText.slice(0, newlineIdx + 1)
+          : '';
         const patch = {};
-        const index = state.items.findIndex((it) => it.id === id);
-        if (index >= 0) {
-          const current = state.items[index];
-          if (!Object.is(current.text, currentAssistantText) || current.streaming !== true) {
-            const items = state.items.slice();
-            items[index] = { ...current, text: currentAssistantText, streaming: true };
-            patch.items = items;
+        // Do NOT create the assistant row (and scroll the transcript) before
+        // there is a completed line with VISIBLE content to show. Until the
+        // first '\n' the only pending state is the spinner; the row appears
+        // together with its first visible line, so no empty "●-only" row
+        // flashes/scrolls ahead of text. `.trim()` also guards the
+        // whitespace-only case: a response that opens with leading newlines
+        // ("\n\n# …") completes a blank line first, whose estimated height
+        // still reserves rows and scrolls the transcript, but Markdown trims
+        // the body to nothing — so the scroll advances onto an empty band for
+        // a few seconds until a non-blank line lands. Don't create the row
+        // until there is real content to paint.
+        if (currentAssistantId || streamingVisibleText.trim()) {
+          const id = ensureAssistant(streamingVisibleText);
+          // Emit the accumulated assistant text and spinner update together so a
+          // streaming batch costs one set() → one emit() → one React reconcile.
+          const index = state.items.findIndex((it) => it.id === id);
+          if (index >= 0) {
+            const current = state.items[index];
+            if (!Object.is(current.text, streamingVisibleText) || current.streaming !== true) {
+              const items = state.items.slice();
+              items[index] = { ...current, text: streamingVisibleText, streaming: true };
+              patch.items = items;
+            }
           }
         }
         const responseLengthVal = assistantText.length + thinkingText.length;
         if (state.spinner) {
-          patch.spinner = { ...state.spinner, responseLength: responseLengthVal, thinking: false, thinkingLastEndedAt: _pendingThinkingLastEndedAt || state.spinner.thinkingLastEndedAt, mode: 'responding' };
+          patch.spinner = { ...state.spinner, responseLength: responseLengthVal, thinking: false, thinkingLastEndedAt: _pendingThinkingLastEndedAt || state.spinner.thinkingLastEndedAt, mode: compactingActive ? 'compacting' : 'responding' };
         }
         if (Object.keys(patch).length > 0) set(patch);
         _pendingThinkingLastEndedAt = 0;
@@ -1269,9 +2028,11 @@ export async function createEngineSession({
         _pendingThinkFlush = false;
         const responseLengthVal = assistantText.length + thinkingText.length;
         const thinkingElapsedMs = accumulatedThinkingMs + (thinkingSegmentStartedAt ? Math.max(0, Date.now() - thinkingSegmentStartedAt) : 0);
-        const patch = { thinking: thinkingText };
+        const patch = { thinking: compactingActive ? null : thinkingText };
         if (state.spinner) {
-          patch.spinner = { ...state.spinner, responseLength: responseLengthVal, thinking: true, thinkingStartedAt, thinkingSegmentStartedAt, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingElapsedMs, thinkingLastEndedAt: 0, mode: 'thinking' };
+          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);
       }
@@ -1283,10 +2044,87 @@ export async function createEngineSession({
       if (_batchTimer?.unref) _batchTimer.unref(); // don't prevent process exit
     };
 
+    // __earlyNotify: show 1-line summary + completedCount immediately; defer
+    // rawResult/expand and resultsDone to the history flush.
+    const markToolCardCompletedState = (callId, message) => {
+      const card = cardByCallId.get(callId);
+      if (!card) return;
+      const aggregate = card.aggregate;
+      if (aggregate && card.itemId === aggregate.itemId) {
+        const callRec = aggregate.calls.get(callId);
+        if (!callRec || callRec.resolved || callRec.completedEarly) return;
+        aggregate.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, callRec.name || 'tool') : rawText;
+        callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
+        assignAggregateSummaryOrder(aggregate, callRec);
+        callRec.isError = isError;
+        callRec.resultText = text;
+        callRec.completedEarly = true;
+        const allCalls = [...aggregate.calls.values()];
+        const completedCount = allCalls.filter((r) => r.resolved || r.completedEarly).length;
+        const errors = allCalls.filter((r) => r.isError).length;
+        const summaries = aggregateSummaries(aggregate);
+        let detailText;
+        if (errors > 0 && summaries.length === 0) {
+          const succeeded = completedCount - errors;
+          detailText = succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`;
+        } else {
+          detailText = aggregateDisplayDetail(summaries, allCalls);
+          if (errors > 0) {
+            detailText = detailText ? `${detailText} · ${errors} Failed` : `${errors} Failed`;
+          }
+        }
+        const rawResult = aggregateRawResult(allCalls);
+        const displayDetail = toolAggregateDetailFallback(detailText, rawResult);
+        const currentItem = state.items.find((it) => it.id === card.itemId);
+        const visualCompleted = Math.max(
+          completedCount,
+          Math.min(allCalls.length, Number(currentItem?.completedCount || 0)),
+        );
+        const patch = {
+          result: displayDetail,
+          text: displayDetail,
+          isError: errors > 0,
+          errorCount: errors,
+          count: allCalls.length,
+          completedCount: visualCompleted,
+        };
+        if (visualCompleted >= allCalls.length) {
+          patch.completedAt = Number(currentItem?.completedAt) || Date.now();
+        }
+        patchItem(card.itemId, patch);
+        return;
+      }
+      // Non-aggregate eager tools are rare; flipping completedCount without
+      // result changes pending/detail rendering and risks row jitter — wait for
+      // the real history flush (unchanged behavior).
+    };
+
+    const deliverToolResultMessage = (message) => {
+      if (message?.__earlyNotify === true) {
+        const earlyCallId = toolResultCallId(message);
+        if (earlyCallId) markToolCardCompletedState(earlyCallId, message);
+        return;
+      }
+      flushToolResults([message], toolCards, cardByCallId, toolGroups, resultsDone);
+    };
+
     try {
       const { result, session } = await runtime.ask(userText, {
         drainSteering: () => drainPendingSteering(),
         onSteerMessage: (text) => {
+          // Steering can be injected after a terminal no-tool response has
+          // already streamed but before runTurn finalizes. Seal the current
+          // assistant segment first so the steered user turn and the next
+          // assistant response do not get visually merged into one bubble.
+          flushStreamBatch();
+          if (currentAssistantId) {
+            patchItem(currentAssistantId, { text: currentAssistantText || assistantText, streaming: false });
+            closeAssistantSegment();
+          }
+          assistantText = '';
           const value = String(text || '').trim();
           if (value) {
             finalizeToolHeaders();
@@ -1295,17 +2133,20 @@ export async function createEngineSession({
         },
         onToolCall: async (_iter, calls) => {
           markPromptCommitted();
+          // Always flush any buffered mid-turn assistant text before the tool
+          // card appears. Without this, when neither a thinking panel nor a
+          // spinner is active the buffered text was dropped by the following
+          // closeAssistantSegment(), so the message above the tool card vanished.
+          flushStreamBatch();
           if (thinkingText && state.thinking) {
             const thinkingLastEndedAt = closeThinkingSegment();
-            flushStreamBatch(); // flush any buffered text/thinking before the tool card appears
             set({ thinking: null, spinner: state.spinner ? { ...state.spinner, thinking: false, thinkingAccumulatedMs: accumulatedThinkingMs, thinkingLastEndedAt, mode: 'tool-use' } : state.spinner });
           } else if (state.spinner) {
-            flushStreamBatch(); // flush any buffered text before the tool card appears
             set({ spinner: { ...state.spinner, mode: 'tool-use' } });
           }
           const batchCalls = (calls || []).filter(Boolean);
           if (batchCalls.length === 0) return;
-          closeAssistantSegment();
+          commitAssistantSegment({ sealToolBlock: true });
 
           const touchedAggregates = new Set();
           for (let i = 0; i < batchCalls.length; i++) {
@@ -1314,26 +2155,37 @@ export async function createEngineSession({
             const args = toolCallArgs(c);
             const category = classifyToolCategory(name, args);
             const bucket = aggregateBucketForCategory(category);
+            const categoryEntry = aggregateToolCategoryEntry(name, args, category);
             const callId = toolCallId(c);
             const callKey = callId || `__tool_${toolCards.length}_${i}`;
 
             if (!bucket) {
               openAggregateCard = null;
               const itemId = nextId();
-              pushItem({
-                kind: 'tool',
-                id: itemId,
-                name,
-                args,
-                result: null,
-                isError: false,
-                expanded: false,
-                headerFinalized: false,
-                count: 1,
-                completedCount: 0,
-                startedAt: Date.now(),
-              });
-              const card = { itemId, callId: callKey, done: false };
+              // Defer the visible push: hold the spec and only enter the
+              // transcript when the real header/detail will paint (delay
+              // elapsed) or its result lands first. Avoids reserving blank
+              // placeholder height that scrolls the body ahead of the glyphs.
+              const card = {
+                itemId,
+                callId: callKey,
+                done: false,
+                pushed: false,
+                spec: {
+                  kind: 'tool',
+                  id: itemId,
+                  name,
+                  args,
+                  result: null,
+                  isError: false,
+                  expanded: false,
+                  headerFinalized: false,
+                  count: 1,
+                  completedCount: 0,
+                  startedAt: Date.now(),
+                },
+              };
+              registerDeferredCard(card);
               if (callId) {
                 cardByCallId.set(callId, card);
               }
@@ -1342,9 +2194,13 @@ export async function createEngineSession({
             }
 
             const aggregateCard = ensureAggregateCard(bucket);
-            if (!aggregateCard.categories.has(category)) aggregateCard.categoryOrder.push(category);
-            aggregateCard.categories.set(category, (aggregateCard.categories.get(category) || 0) + 1);
-            aggregateCard.calls.set(callKey, { name, args, category, summary: null, summarySeq: null, isError: false, resultText: null, resolved: false });
+            if (!aggregateCard.categories.has(categoryEntry.key)) aggregateCard.categoryOrder.push(categoryEntry.key);
+            const prevCategory = aggregateCard.categories.get(categoryEntry.key);
+            aggregateCard.categories.set(categoryEntry.key, {
+              ...categoryEntry,
+              count: Number(prevCategory?.count || 0) + Number(categoryEntry.count || 1),
+            });
+            aggregateCard.calls.set(callKey, { name, args, category, summary: null, summarySeq: null, isError: false, resultText: null, resolved: false, completedEarly: false });
             touchedAggregates.add(aggregateCard);
             const card = { itemId: aggregateCard.itemId, callId: callKey, done: false, aggregate: aggregateCard };
             if (callId) {
@@ -1356,21 +2212,62 @@ export async function createEngineSession({
           for (const aggregateCard of touchedAggregates) {
             syncAggregateHeader(aggregateCard);
           }
+          for (const [bufferedCallId, bufferedMessage] of earlyResultBuffer) {
+            if (!cardByCallId.has(bufferedCallId)) continue;
+            deliverToolResultMessage(bufferedMessage);
+            earlyResultBuffer.delete(bufferedCallId);
+          }
           await yieldToRenderer();
         },
         onToolResult: (message) => {
-          flushToolResults([message], toolCards, cardByCallId, toolGroups, resultsDone);
+          const callId = toolResultCallId(message);
+          if (callId && !cardByCallId.has(callId) && !resultsDone.has(callId)) {
+            earlyResultBuffer.set(callId, message);
+            return;
+          }
+          deliverToolResultMessage(message);
+        },
+        onToolApproval: async (request) => {
+          markPromptCommitted();
+          flushStreamBatch();
+          if (state.spinner) set({ spinner: { ...state.spinner, mode: 'tool-approval' } });
+          return await requestToolApproval(request);
+        },
+        onCompactEvent: (event) => {
+          flushStreamBatch();
+          pushItem({
+            kind: 'statusdone',
+            id: nextId(),
+            label: compactEventLabel(event),
+            detail: compactEventDetail(event),
+          });
         },
         onStageChange: (stage) => {
           if (!state.spinner) return;
           const value = String(stage || '');
+          if (value === 'compacting') {
+            compactingActive = true;
+            const thinkingLastEndedAt = closeThinkingSegment();
+            _pendingThinkFlush = false;
+            set({
+              thinking: null,
+              spinner: {
+                ...state.spinner,
+                thinking: false,
+                thinkingSegmentStartedAt: 0,
+                thinkingAccumulatedMs: accumulatedThinkingMs,
+                thinkingLastEndedAt: thinkingLastEndedAt || state.spinner.thinkingLastEndedAt || 0,
+                mode: 'compacting',
+              },
+            });
+            return;
+          }
+          if (value === 'requesting' || value === 'streaming') compactingActive = false;
           const mode = value === 'requesting'
             ? 'requesting'
             : value === 'streaming'
               ? (state.spinner.thinking ? 'thinking' : 'responding')
-              : value === 'compacting'
-                ? 'compacting'
-                : null;
+              : null;
           if (!mode || state.spinner.mode === mode) return;
           set({ spinner: { ...state.spinner, mode } });
         },
@@ -1380,15 +2277,40 @@ export async function createEngineSession({
           markPromptCommitted();
           const thinkingLastEndedAt = closeThinkingSegment();
           if (state.thinking) set({ thinking: null }); // collapse thinking panel immediately, no batch delay
-          if (textChunk.trim()) clearAggregateContinuation();
           assistantText += textChunk;
-          ensureAssistant(); // create the assistant item in state immediately so the slot exists
           currentAssistantText += textChunk;
-          // Accumulate text; fire at most one render per STREAM_BATCH_INTERVAL_MS.
+          // Accumulate text and schedule a batched flush (≤1 render per
+          // STREAM_BATCH_INTERVAL_MS). Without scheduling, mid-turn text only
+          // surfaced via the tool-call/finalize flush, so a text→tool segment
+          // with no spinner/thinking dropped the message above the tool card.
           _pendingTextFlush = true;
           if (thinkingLastEndedAt) _pendingThinkingLastEndedAt = thinkingLastEndedAt;
           scheduleStreamFlush();
         },
+        onAssistantText: (text) => {
+          // Mid-turn assistant text that precedes a tool call. Providers that
+          // stream via onTextDelta already accumulated it into assistantText;
+          // providers that only return the final response.content (no deltas)
+          // never fired onTextDelta, so without this the preamble shows nothing
+          // before the tool card. De-dup against already-streamed text so the
+          // streaming path is unaffected.
+          const full = String(text ?? '');
+          if (!full.trim()) return;
+          // If the streaming path already produced text for THIS segment,
+          // onTextDelta owns the render — content is the same accumulated text
+          // (or a superset), so skip to avoid double-printing the preamble.
+          // Do not check turn-global assistantText: earlier closed preambles stay
+          // there across tool calls, and would suppress later non-streaming
+          // preambles even though currentAssistantText has been reset.
+          if (currentAssistantText.trim()) return;
+          markPromptCommitted();
+          closeThinkingSegment();
+          if (state.thinking) set({ thinking: null });
+          assistantText += full;
+          currentAssistantText += full;
+          _pendingTextFlush = true;
+          flushStreamBatch();
+        },
         onReasoningDelta: (chunk) => {
           if (String(chunk ?? '')) markPromptCommitted();
           startThinkingSegment();
@@ -1399,7 +2321,7 @@ export async function createEngineSession({
         },
         onUsageDelta: (delta) => {
           applyUsageDelta(state.stats, delta);
-          syncContextStats();
+          syncContextStats({ allowEstimated: true });
           const currentTurnInput = Math.max(0, state.stats.inputTokens - inputBaseline);
           const currentTurnOutput = Math.max(0, state.stats.outputTokens - outputBaseline);
           if (state.spinner) {
@@ -1409,24 +2331,30 @@ export async function createEngineSession({
           }
         },
       });
+      askResult = result;
       markPromptCommitted();
-      if (result?.postTurnCompact?.changed) autoCompactStatus = result.postTurnCompact;
 
       flushToolResults(session?.messages || [], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true });
       finalizeToolHeaders();
       flushStreamBatch(); // force-flush any batched streaming text before finalization writes
-      syncContextStats();
-
-      const finalText = (result?.content != null && String(result.content)) || assistantText;
-      if (assistantText.trim() && currentAssistantId) {
-        patchItem(currentAssistantId, { text: currentAssistantText || assistantText, streaming: false });
-      }
-      if (finalText && !assistantText.trim()) {
-        const id = ensureAssistant();
+      syncContextStats({ allowEstimated: true });
+
+      const finalText = result?.content != null ? String(result.content) : '';
+      if (finalText.trim()) {
+        // The persisted transcript is written from the provider's final content,
+        // while the live TUI row is fed by streaming deltas. If a provider/parser
+        // misses or suppresses an early delta, keeping the streamed buffer here
+        // leaves the final on-screen assistant row missing leading characters even
+        // though the transcript is correct. Always reconcile the active segment to
+        // the final provider text when it is available.
+        const id = currentAssistantId || ensureAssistant(finalText);
         currentAssistantText = finalText;
         patchItem(id, { text: finalText, streaming: false });
+      } else if (currentAssistantId && (currentAssistantText.trim() || assistantText.trim())) {
+        const streamedText = currentAssistantText || assistantText;
+        patchItem(currentAssistantId, { text: streamedText, streaming: false });
       }
-      state.stats.turns = (state.stats.turns || 0) + 1;
+      turnFinishedNormally = true;
     } catch (error) {
       flushStreamBatch(); // ensure any batched text lands before the error notice
       if (error?.name === 'SessionClosedError') {
@@ -1446,6 +2374,17 @@ export async function createEngineSession({
         pushNotice(toolErrorDisplay(error, 'turn'), 'error');
       }
     } finally {
+      denyAllToolApprovals(cancelled ? 'turn cancelled' : 'turn finished');
+      // Flush any still-deferred tool cards into the transcript and cancel their
+      // pending push timers so nothing fires (or leaks) after the turn ends. The
+      // finalize path above already patches results onto visible cards; this just
+      // guarantees every registered card is materialized before the turn closes.
+      if (deferredEntries.length) {
+        const last = deferredEntries[deferredEntries.length - 1];
+        if (last) flushDeferredUpTo(last);
+        clearDeferredTimers();
+      }
+      const producedTranscriptItem = state.items.length > itemsAtTurnStart;
       const reclaimed = cancelled && activePromptRestore?.reclaimed === true;
       activePromptRestore = null;
       closeThinkingSegment();
@@ -1453,25 +2392,24 @@ export async function createEngineSession({
       const thinkingElapsedMs = thinkingStartedAt ? accumulatedThinkingMs : 0;
       const finalOutputTokens = Math.max(0, Number(state.spinner?.outputTokens || 0), Math.round(Number(state.spinner?.responseLength || 0) / 4));
       const turnStatus = cancelled ? 'cancelled' : 'done';
+      const resultContent = askResult?.content != null ? String(askResult.content).trim() : '';
+      const assistantOutput = (currentAssistantText || assistantText || '').trim();
+      // Suppress only true pending-resume no-ops: no transcript items added and no model output; cancelled/error turns and any visible turn stay marked.
+      const isNoOpTurn = turnFinishedNormally
+        && !cancelled
+        && toolCards.length === 0
+        && !resultContent
+        && !assistantOutput
+        && !producedTranscriptItem;
+      if (!isNoOpTurn) {
+        state.stats.turns = (state.stats.turns || 0) + 1;
+      }
       // Pin the post-think summary into the transcript right after this turn's
       // output so it scrolls up with the answer and stays in the scrollback,
-      // mirroring Claude Code. (Previously TurnDone rendered only in the
+      // in scrollback. (Previously TurnDone rendered only in the
       // bottom-fixed live-status slot and vanished on the next turn.)
-      if (!reclaimed) {
+      if (!reclaimed && !isNoOpTurn) {
         pushItem({ kind: 'turndone', id: nextId(), elapsedMs, status: turnStatus, outputTokens: finalOutputTokens, thinkingElapsedMs, verb: pickDoneVerb(turnIndex) });
-        if (!cancelled && autoCompactStatus?.changed) {
-          const before = formatTokenCount(autoCompactStatus.beforeTokens || autoCompactStatus.pressureTokens || 0);
-          const after = formatTokenCount(autoCompactStatus.afterTokens || 0);
-          const trigger = formatTokenCount(autoCompactStatus.triggerTokens || 0);
-          pushItem({
-            kind: 'statusdone',
-            id: nextId(),
-            label: 'Auto-compact complete',
-            detail: [`context ${before}→${after}`, trigger !== '0' ? `trigger ${trigger}` : '']
-              .filter(Boolean)
-              .join(' · '),
-          });
-        }
       }
       set({
         busy: false,
@@ -1481,8 +2419,9 @@ export async function createEngineSession({
         stats: { ...state.stats },
         ...routeState(),
         toolMode: runtime.toolMode,
-        ...bridgeStatusState(),
+        ...agentStatusState({ force: true }),
       });
+      flushDeferredExecutionPendingResumeKick();
     }
     return cancelled ? 'cancelled' : 'done';
   }
@@ -1504,6 +2443,7 @@ export async function createEngineSession({
       mode,
       priority,
       key: options.key || null,
+      skipSlashCommands: options.skipSlashCommands === true,
       displayText: mode === 'task-notification' ? notificationDisplayText(displayText) : String(displayText || ''),
     };
   }
@@ -1512,7 +2452,8 @@ 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);
-    set({ queued: state.queued.filter((q) => !ids.has(q.id)) });
+    const queued = state.queued.filter((q) => !ids.has(q.id));
+    if (queued.length !== state.queued.length) set({ queued });
   }
 
   function requeueEntriesFront(entries) {
@@ -1531,16 +2472,19 @@ export async function createEngineSession({
     }
     if (restored.length === 0) return false;
     pending.unshift(...restored);
-    set({ queued: [...restored, ...state.queued] });
+    const visible = restored.filter(isQueuedEntryVisible);
+    if (visible.length > 0) set({ queued: [...visible, ...state.queued] });
     return true;
   }
 
-  function dequeueQueueBatch(maxPriority = 'later') {
+  function dequeueQueueBatch(maxPriority = 'later', options = {}) {
     if (pending.length === 0) return [];
     const max = queuePriorityValue(maxPriority);
+    const predicate = typeof options.predicate === 'function' ? options.predicate : () => true;
     let bestPriority = Infinity;
     let targetMode = null;
     for (const entry of pending) {
+      if (!predicate(entry)) continue;
       const p = queuePriorityValue(entry.priority);
       if (p > max) continue;
       if (p < bestPriority) {
@@ -1552,7 +2496,7 @@ export async function createEngineSession({
     const batch = [];
     for (let i = 0; i < pending.length;) {
       const entry = pending[i];
-      if ((entry.mode || 'prompt') === targetMode && queuePriorityValue(entry.priority) === bestPriority) {
+      if (predicate(entry) && (entry.mode || 'prompt') === targetMode && queuePriorityValue(entry.priority) === bestPriority) {
         batch.push(entry);
         pending.splice(i, 1);
       } else {
@@ -1568,7 +2512,7 @@ export async function createEngineSession({
     draining = true;
     try {
       while (pending.length > 0) {
-        // Drain one priority/mode bucket at a time, matching Claude Code's
+        // Drain one priority/mode bucket at a time (unified command queue):
         // unified command queue semantics: prompt steering stays editable and
         // task notifications stay non-editable but model-visible.
         const batch = dequeueQueueBatch('later');
@@ -1576,6 +2520,7 @@ export async function createEngineSession({
         const ids = new Set(batch.map((e) => e.id));
         const merged = mergePromptContents(batch);
         for (const entry of batch) {
+          if (entry.mode === 'pending-resume') continue;
           pushUserOrSyntheticItem(entry.text, entry.id);
         }
         const nonEditable = batch.filter((entry) => !isQueuedEntryEditable(entry));
@@ -1596,6 +2541,8 @@ export async function createEngineSession({
       }
     } finally {
       draining = false;
+      if (pending.length > 0) void drain();
+      else flushDeferredExecutionPendingResumeKick();
     }
   }
   function enqueue(text, options = {}) {
@@ -1605,13 +2552,17 @@ export async function createEngineSession({
       pendingNotificationKeys.add(entry.key);
     }
     pending.push(entry);
-    set({ queued: [...state.queued, entry] });
+    if (isQueuedEntryVisible(entry)) set({ queued: [...state.queued, entry] });
     void drain();
     return true;
   }
 
   function drainPendingSteering() {
-    const batch = dequeueQueueBatch('next');
+    // Mid-turn steering drain:
+    // getCommandsByMaxPriority('next') and exclude slash commands. Slash
+    // commands must run through the normal command processor after the turn,
+    // not be sent to the model as plain text.
+    const batch = dequeueQueueBatch('next', { predicate: (entry) => !isSlashQueuedEntry(entry) });
     if (batch.length === 0) return [];
     const out = batch
       .map((entry) => {
@@ -1631,24 +2582,20 @@ export async function createEngineSession({
   async function autoClearBeforeSubmit() {
     const cfg = autoClearState();
     const now = Date.now();
-    const idleMs = now - lastUserActivityAt;
+    const activityAt = sessionActivityTimestamp(runtime.session, lastUserActivityAt);
+    const idleMs = activityAt ? now - activityAt : 0;
     if (!cfg.enabled || state.busy || pending.length > 0 || autoClearRunning || idleMs < cfg.idleMs) {
-      lastUserActivityAt = now;
+      if (!activityAt) lastUserActivityAt = now;
       return false;
     }
     autoClearRunning = true;
+    const startedAt = Date.now();
+    set({ commandStatus: { active: true, verb: 'Auto-clearing idle conversation', startedAt, mode: 'auto-clear' } });
     try {
-      const beforeContext = runtime.contextStatus?.() || null;
-      await runtime.clear();
+      await runtime.clear({ compactType: cfg.compactType || null, requireCompactSuccess: !!cfg.compactType });
       resetStats();
-      const afterContext = syncContextStats({ allowEstimated: true }) || runtime.contextStatus?.() || null;
-      const idleLabel = formatIdleDuration(idleMs);
-      const thresholdLabel = formatIdleDuration(cfg.idleMs);
-      const beforeTokens = Number(beforeContext?.usedTokens || beforeContext?.currentEstimatedTokens || beforeContext?.usage?.lastContextTokens || 0);
-      const afterTokens = Number(afterContext?.usedTokens || afterContext?.currentEstimatedTokens || afterContext?.usage?.lastContextTokens || 0);
-      const contextDetail = beforeTokens > 0 || afterTokens > 0
-        ? `context ${formatTokenCount(beforeTokens)}→${formatTokenCount(afterTokens)}`
-        : 'context reset';
+      clearUiActivityBeforeContextSync();
+      syncContextStats({ allowEstimated: true });
       set({
         items: replaceItems([]),
         toasts: [],
@@ -1663,17 +2610,23 @@ export async function createEngineSession({
         kind: 'statusdone',
         id: nextId(),
         label: 'Auto-clear complete',
-        detail: [idleLabel ? `idle ${idleLabel}` : '', contextDetail, thresholdLabel ? `threshold ${thresholdLabel}` : '']
-          .filter(Boolean)
-          .join(' · '),
+        detail: formatElapsedSeconds(Date.now() - startedAt),
       });
       return true;
     } catch (error) {
-      pushNotice(`auto-clear failed: ${error?.message || error}`, 'error');
+      const message = presentErrorText(error, { surface: 'auto-clear' });
+      pushItem({
+        kind: 'statusdone',
+        id: nextId(),
+        label: 'Auto-clear skipped',
+        detail: `conversation kept · ${message}`,
+      });
+      pushNotice(`auto-clear skipped: ${message}`, 'error');
       return false;
     } finally {
       lastUserActivityAt = Date.now();
       autoClearRunning = false;
+      set({ commandStatus: null });
     }
   }
 
@@ -1698,6 +2651,63 @@ export async function createEngineSession({
     state.stats = createSessionStats();
     return state.stats;
   };
+  const clearUiActivityBeforeContextSync = () => {
+    state.items = replaceItems([]);
+    state.toasts = [];
+    state.queued = [];
+    state.thinking = null;
+    state.spinner = null;
+    state.lastTurn = null;
+    state.busy = false;
+  };
+  const resetTuiForPendingSessionReset = () => {
+    pendingSessionReset = true;
+    clearUiActivityBeforeContextSync();
+    resetStats();
+    state.stats.currentContextTokens = 0;
+    state.stats.currentEstimatedContextTokens = 0;
+    state.stats.currentContextSource = null;
+    state.stats.currentContextUpdatedAt = Date.now();
+    state.displayContextWindow = 0;
+    state.compactBoundaryTokens = 0;
+    state.autoCompactTokenLimit = 0;
+  };
+  const snapshotTuiBeforeSessionReset = () => ({
+    items: state.items.slice(),
+    toasts: state.toasts.slice(),
+    queued: state.queued.slice(),
+    thinking: state.thinking,
+    spinner: state.spinner,
+    lastTurn: state.lastTurn,
+    busy: state.busy,
+    stats: { ...state.stats },
+    sessionId: state.sessionId,
+  });
+  const restoreTuiAfterFailedSessionReset = (snapshot) => {
+    if (!snapshot) return;
+    pendingSessionReset = false;
+    state.items = replaceItems(snapshot.items);
+    state.toasts = snapshot.toasts.slice();
+    state.queued = snapshot.queued.slice();
+    state.thinking = snapshot.thinking;
+    state.spinner = snapshot.spinner;
+    state.lastTurn = snapshot.lastTurn;
+    state.busy = snapshot.busy;
+    state.stats = { ...snapshot.stats };
+    syncContextStats({ allowEstimated: true });
+    set({
+      items: state.items,
+      toasts: state.toasts,
+      queued: state.queued,
+      thinking: state.thinking,
+      spinner: state.spinner,
+      lastTurn: state.lastTurn,
+      busy: state.busy,
+      ...routeState(),
+      stats: { ...state.stats },
+      ...agentStatusState(),
+    });
+  };
   const resetStatsAndSyncContext = () => {
     resetStats();
     syncContextStats({ allowEstimated: true });
@@ -1715,11 +2725,10 @@ export async function createEngineSession({
       const t = promptDisplayText(text, options).trim();
       if (!t || state.commandBusy) return false;
       const mode = options.mode || 'prompt';
-      // Plain user input entered while a turn is busy is a post-turn follow-up
-      // by default, so it lands after any auto-compact/save boundary instead of
-      // being swallowed as mid-turn steering. Task notifications still opt into
-      // priority: 'next' and are injected at the next tool boundary.
-      const priority = options.priority;
+     // Prompt input queued while a turn is active keeps the
+     // default `next` priority, so it is injected at the next tool/model
+     // boundary. Explicit options.priority still wins.
+     const priority = options.priority;
       const queueOptions = {
         ...options,
         mode,
@@ -1738,8 +2747,8 @@ export async function createEngineSession({
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       try {
-        await runtime.setRoute({ model: m });
-        resetStatsAndSyncContext();
+        await runtime.setRoute({ model: m }, { applyToCurrentSession: true });
+        syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...state.stats } });
         return true;
       } finally {
@@ -1787,34 +2796,75 @@ export async function createEngineSession({
         })
         .catch((error) => pushNotice(toolErrorDisplay(error, 'tool'), 'error'));
     },
-    toggleBridgeMode: () => {
-      const mode = runtime.toggleBridgeMode();
-      set(bridgeStatusState({ force: true }));
-      pushNotice(`bridge mode -> ${mode}`, 'info');
-      return mode;
-    },
-    setBridgeMode: (mode) => {
-      const next = runtime.setBridgeMode(mode);
-      set(bridgeStatusState({ force: true }));
-      return next;
-    },
     getAutoClear: () => autoClearState(),
     setAutoClear: (input = {}) => {
       const next = runtime.setAutoClear?.(input) || autoClearState();
       set({ autoClear: next });
       return next;
     },
-    bridgeControl: async (args = {}) => {
+    getProfile: () => runtime.getProfile?.() || { title: '', language: 'system', languages: [] },
+    setProfile: (input = {}) => {
+      const next = runtime.setProfile?.(input) || runtime.getProfile?.() || null;
+      return next;
+    },
+    getCompactionSettings: () => {
+      return runtime.getCompactionSettings?.() || {};
+    },
+    setCompactionSettings: async (input = {}) => {
+      if (state.commandBusy) return null;
+      set({ commandBusy: true });
+      try {
+        const next = runtime.setCompactionSettings?.(input) || {};
+        syncContextStats({ allowEstimated: true });
+        set({ ...routeState(), stats: { ...state.stats } });
+        return next;
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
+    getMemorySettings: () => {
+      return runtime.getMemorySettings?.() || { enabled: true };
+    },
+    setMemoryEnabled: async (enabled) => {
       if (state.commandBusy) return null;
       set({ commandBusy: true });
       try {
-        const result = await runtime.bridgeControl(args);
-        const text = String(result || '').trim() || '(empty bridge result)';
+        const next = await runtime.setMemoryEnabled?.(enabled);
+        syncContextStats({ allowEstimated: true });
+        set({ ...routeState(), stats: { ...state.stats } });
+        return next;
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
+    getChannelSettings: (options = {}) => {
+      return runtime.getChannelSettings?.(options) || {
+        enabled: true,
+        ...(options?.includeStatus === false ? {} : { status: runtime.getChannelWorkerStatus?.() }),
+      };
+    },
+    setChannelsEnabled: async (enabled) => {
+      if (state.commandBusy) return null;
+      set({ commandBusy: true });
+      try {
+        const next = await runtime.setChannelsEnabled?.(enabled);
+        set({ ...routeState(), stats: { ...state.stats } });
+        return next;
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
+    agentControl: async (args = {}) => {
+      if (state.commandBusy) return null;
+      set({ commandBusy: true });
+      try {
+        const result = await runtime.agentControl(args);
+        const text = String(result ?? '').trim();
         const itemId = nextId();
         pushItem({
           kind: 'tool',
           id: itemId,
-          name: 'bridge',
+          name: 'agent',
           args,
           result: null,
           isError: false,
@@ -1823,8 +2873,8 @@ export async function createEngineSession({
           completedCount: 0,
           startedAt: Date.now(),
         });
-        updateBridgeJobCard(itemId, text, /^error:/i.test(text));
-        set(bridgeStatusState({ force: true }));
+        updateAgentJobCard(itemId, text, /^error:/i.test(text));
+        set(agentStatusState({ force: true }));
         return result;
       } finally {
         set({ commandBusy: false });
@@ -1845,10 +2895,12 @@ export async function createEngineSession({
       );
       return result;
     },
-    setCwd: (path) => {
+    setCwd: (path, options = {}) => {
       const next = runtime.setCwd(path);
       set({ cwd: next });
-      pushNotice(`cwd -> ${next}`, 'info');
+      if (options?.notice !== false) {
+        pushNotice(options?.message || `Project set: ${projectNameFromPath(next)}`, 'info');
+      }
       return next;
     },
     getSystemShell: () => {
@@ -2065,14 +3117,36 @@ export async function createEngineSession({
     },
     compact: async () => {
       if (state.commandBusy) return null;
+      if (state.busy) {
+        pushNotice('Compact skipped: turn in progress', 'info');
+        return { changed: false, reason: 'compact skipped: turn in progress' };
+      }
       const startedAt = Date.now();
       set({ commandBusy: true, commandStatus: { active: true, verb: 'Compacting conversation', startedAt, mode: 'compacting' } });
       try {
-        const result = await runtime.compact({ recoverBridge: true });
+        const result = await runtime.compact({ recoverAgent: true });
         syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...state.stats } });
         if (result) {
-          pushItem({ kind: 'turndone', id: nextId(), elapsedMs: Date.now() - startedAt, status: 'done', outputTokens: 0, thinkingElapsedMs: 0, verb: 'Compacted' });
+          pushItem({
+            kind: 'statusdone',
+            id: nextId(),
+            label: result.error ? 'Compact failed' : (result.changed === false ? 'Compact checked' : 'Compact complete'),
+            detail: compactEventDetail({
+              stage: 'manual',
+              trigger: 'manual',
+              status: result.error ? 'failed' : (result.changed === false ? 'no_change' : 'compacted'),
+              compactType: result.compactType,
+              beforeTokens: result.beforeTokens,
+              afterTokens: result.afterTokens,
+              beforeMessages: result.beforeMessages,
+              afterMessages: result.afterMessages,
+              semantic: result.semanticCompact,
+              recallFastTrack: result.recallFastTrack,
+              durationMs: Date.now() - startedAt,
+              error: result.error,
+            }),
+          });
         }
         return result;
       } finally {
@@ -2081,6 +3155,7 @@ export async function createEngineSession({
     },
     abort: () => {
       if (!state.busy) return false;
+      denyAllToolApprovals('interrupted by user');
       const restoreState = activePromptRestore;
       const restoreText = restoreState?.restorable ? restoreState.text : '';
       const restorePastedImages = restoreState?.restorable && restoreState?.pastedImages ? restoreState.pastedImages : null;
@@ -2107,12 +3182,49 @@ export async function createEngineSession({
       }
       return { aborted, restoreText, pastedImages: restorePastedImages };
     },
+    resolveToolApproval: (id, decision = {}) => {
+      const approved = decision === true || decision?.approved === true;
+      return finishToolApproval(id, approved, decision?.reason || (approved ? 'approved by user' : 'denied by user'));
+    },
     listPresets: () => {
       return runtime.listPresets();
     },
     listProviderModels: (options = {}) => {
       return runtime.listProviderModels(options);
     },
+    getSearchRoute: () => {
+      return runtime.getSearchRoute?.() || runtime.searchRoute || null;
+    },
+    listSearchModels: (options = {}) => {
+      return runtime.listSearchModels?.(options) || [];
+    },
+    setSearchRoute: async (opts) => {
+      if (state.commandBusy) return null;
+      const beforeRouteState = routeState();
+      const optimisticSearchRoute = opts?.provider && opts?.model
+        ? {
+            provider: String(opts.provider).trim(),
+            model: String(opts.model).trim(),
+            ...(opts.effort ? { effort: opts.effort } : {}),
+            ...(opts.fast === true ? { fast: true } : {}),
+            ...(opts.toolType ? { toolType: opts.toolType } : {}),
+          }
+        : null;
+      set({ commandBusy: true });
+      try {
+        if (optimisticSearchRoute?.provider && optimisticSearchRoute.model) {
+          set({ searchRoute: optimisticSearchRoute });
+        }
+        const result = await runtime.setSearchRoute?.(opts);
+        set({ ...routeState(), stats: { ...state.stats } });
+        return result;
+      } catch (e) {
+        set({ searchRoute: beforeRouteState.searchRoute || null });
+        throw e;
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     listAgents: () => {
       return runtime.listAgents?.() || [];
     },
@@ -2141,13 +3253,24 @@ export async function createEngineSession({
       if (state.commandBusy) return null;
       set({ commandBusy: true });
       try {
-        const result = runtime.setWorkflow?.(workflowId);
+        const result = await runtime.setWorkflow?.(workflowId);
         set({ ...routeState(), stats: { ...state.stats } });
         return result;
       } finally {
         set({ commandBusy: false });
       }
     },
+    // Theme is a TUI-local concern (no runtime round-trip). listThemes returns
+    // picker metadata; getTheme reports the active id; setTheme applies the
+    // palette in-place + persists ui.theme and bumps a themeEpoch so the React
+    // tree re-renders (markdown/status/spinner colorizers re-resolve).
+    listThemes: () => listThemes(),
+    getTheme: () => getThemeSetting(),
+    setTheme: (id, options = {}) => {
+      const applied = setThemeSetting(id, options);
+      set({ themeEpoch: (state.themeEpoch || 0) + 1 });
+      return applied;
+    },
     setAgentRoute: async (agentId, opts) => {
       return await runtime.setAgentRoute?.(agentId, opts);
     },
@@ -2187,6 +3310,17 @@ export async function createEngineSession({
         set({ commandBusy: false });
       }
     },
+    beginOAuthProviderLogin: async (provider) => {
+      if (state.commandBusy) throw new Error('command busy');
+      set({ commandBusy: true });
+      try {
+        const result = await runtime.beginOAuthProviderLogin(provider);
+        pushNotice(`provider oauth started: ${result.provider}`, 'info');
+        return result;
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     saveProviderApiKey: (provider, secret) => {
       const result = runtime.saveProviderApiKey(provider, secret);
       pushNotice(`provider api key saved: ${result.provider}`, 'info');
@@ -2298,8 +3432,11 @@ export async function createEngineSession({
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       try {
-        await runtime.setRoute(opts);
-        resetStatsAndSyncContext();
+        const routeOpts = opts && typeof opts === 'object' ? opts : {};
+        const applyToCurrentSession = routeOpts.applyToCurrentSession === false ? false : true;
+        const { applyToCurrentSession: _drop, ...nextRoute } = routeOpts;
+        await runtime.setRoute(nextRoute, { applyToCurrentSession });
+        if (applyToCurrentSession) syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...state.stats } });
         return true;
       } finally {
@@ -2311,13 +3448,31 @@ export async function createEngineSession({
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       clearToastTimers();
+      const rollbackSnapshot = snapshotTuiBeforeSessionReset();
+      resetTuiForPendingSessionReset();
+      set({
+        items: state.items,
+        toasts: state.toasts,
+        queued: state.queued,
+        thinking: null,
+        spinner: null,
+        lastTurn: null,
+        sessionId: null,
+        stats: { ...state.stats },
+      });
       try {
-        await runtime.clear({ recoverBridge: true });
+        await runtime.clear({ recoverAgent: true });
+        clearUiActivityBeforeContextSync();
+        pendingSessionReset = false;
         resetStatsAndSyncContext();
         set({ items: replaceItems([]), toasts: [], queued: [], thinking: null, spinner: null, lastTurn: null, ...routeState(), stats: { ...state.stats } });
         lastUserActivityAt = Date.now();
         return true;
+      } catch (error) {
+        restoreTuiAfterFailedSessionReset(rollbackSnapshot);
+        throw error;
       } finally {
+        pendingSessionReset = false;
         set({ commandBusy: false });
       }
     },
@@ -2328,12 +3483,30 @@ export async function createEngineSession({
       if (state.commandBusy) return false;
       set({ commandBusy: true });
       clearToastTimers();
+      const rollbackSnapshot = snapshotTuiBeforeSessionReset();
+      resetTuiForPendingSessionReset();
+      set({
+        items: state.items,
+        toasts: state.toasts,
+        queued: state.queued,
+        thinking: null,
+        spinner: null,
+        lastTurn: null,
+        sessionId: null,
+        stats: { ...state.stats },
+      });
       try {
         await runtime.newSession();
+        clearUiActivityBeforeContextSync();
+        pendingSessionReset = false;
         resetStatsAndSyncContext();
         set({ items: replaceItems([]), toasts: [], queued: [], thinking: null, spinner: null, lastTurn: null, ...routeState(), stats: { ...state.stats } });
         return true;
+      } catch (error) {
+        restoreTuiAfterFailedSessionReset(rollbackSnapshot);
+        throw error;
       } finally {
+        pendingSessionReset = false;
         set({ commandBusy: false });
       }
     },
@@ -2359,13 +3532,14 @@ export async function createEngineSession({
                 items.push({
                   kind: 'tool',
                   id: nextId(),
-                  name: synthetic.name || 'bridge',
+                  name: synthetic.name || 'agent',
                   args: synthetic.args || {
                     type: label,
                     task_id: synthetic.taskId || undefined,
                     description: synthetic.summary || 'agent notification',
                   },
                   result: synthetic.result,
+                  rawResult: synthetic.rawResult ?? text,
                   isError: synthetic.isError ?? /^(failed|error|killed|cancelled)$/i.test(label),
                   expanded: false,
                   count: 1,
@@ -2401,8 +3575,10 @@ export async function createEngineSession({
       if (disposed) return;
       disposed = true;
       clearToastTimers();
+      try { clearInterval(runtimePulseTimer); } catch {}
       try { unsubscribeRuntimeNotifications?.(); } catch {}
       unsubscribeRuntimeNotifications = null;
+      denyAllToolApprovals('runtime closing');
       await runtime.close(reason, options);
       listeners.clear();
     },