mixdog 0.9.3 → 0.9.4

package/src/tui/engine.mjs

@@ -19,7 +19,6 @@ import {
 } from '../runtime/shared/tool-surface.mjs';
 import {
   isModelVisibleToolCompletionWrapper,
-  modelVisibleToolCompletionMessage,
 } from '../runtime/shared/tool-execution-contract.mjs';
 import { presentErrorText } from '../runtime/shared/err-text.mjs';
 import { listThemes, getThemeSetting, setThemeSetting } from './theme.mjs';
@@ -48,13 +47,8 @@ import {
   toolCallArgs,
 } from './engine/tool-call-fields.mjs';
 import {
-  parseAgentJob,
-  parseAgentResultEnvelope,
   parseBackgroundTaskEnvelope,
   parseSyntheticAgentMessage,
-  isStatusOnlyAgentCompletionNotification,
-  agentJobResultText,
-  agentArgsWithResultMetadata,
   toolResultStatus,
   isErrorToolStatus,
 } from './engine/agent-envelope.mjs';
@@ -64,7 +58,6 @@ import {
   isQueuedEntryEditable,
   isQueuedEntryVisible,
   isSlashQueuedEntry,
-  shortTextFingerprint,
   notificationDisplayText,
   sessionActivityTimestamp,
   promptDisplayText,
@@ -73,6 +66,19 @@ import {
   mergePastedTexts,
   callCommitCallbacks,
 } from './engine/queue-helpers.mjs';
+import {
+  resolveTuiRuntimeNotificationDelivery,
+} from './engine/notification-plan.mjs';
+import { yieldToRenderer } from './engine/render-timing.mjs';
+import {
+  aggregateRawResult,
+  aggregateBucketForCategory,
+  aggregateSummaries,
+  assignAggregateSummaryOrder,
+} from './engine/tool-result-status.mjs';
+import { createToolApproval } from './engine/tool-approval.mjs';
+import { createToolCardResults } from './engine/tool-card-results.mjs';
+import { createAgentJobFeed } from './engine/agent-job-feed.mjs';
 
 // Source tests resolve from src/tui/engine.mjs; the built bundle resolves from
 // src/tui/dist/index.mjs.
@@ -92,77 +98,9 @@ const nextId = () => `it_${++_idSeq}`;
 // keep resolving them from engine.mjs unchanged.
 export { toolResultText, toolAggregateDetailFallback, toolGroupedDisplayFallback };
 export { parseBackgroundTaskEnvelope };
-
-// Ink renders through a maxFps throttle (120fps in index.jsx, ≈8.3ms). A plain
-// setImmediate only yields to the event loop; if Ink already painted within the
-// current throttle window, the next paint may still be queued and our following
-// transcript mutation can coalesce into the same visible frame. Wait just past
-// one render window when we intentionally split transcript commits for visual
-// stability (preamble frame → tool-card frame).
-const RENDER_THROTTLE_FLUSH_MS = 12;
-const yieldToRenderer = () => new Promise((resolve) => {
-  setTimeout(resolve, RENDER_THROTTLE_FLUSH_MS);
-});
-
-function notificationQueueKey(event, text, parsed) {
-  const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
-  const synthetic = parseSyntheticAgentMessage(text);
-  if (synthetic?.name === 'agent' && String(synthetic.args?.type || '').toLowerCase() === 'result') {
-    const taskId = String(synthetic.args?.task_id || '').trim();
-    const executionId = String(meta.execution_id || '').trim();
-    const tag = String(synthetic.args?.tag || '').trim();
-    const resultId = taskId
-      ? `task:${taskId}`
-      : executionId
-        ? `exec:${executionId}`
-        : tag
-          ? `tag:${tag}:${shortTextFingerprint(synthetic.result || text)}`
-          : '';
-    const agent = String(synthetic.args?.agent || '').trim();
-    if (resultId || agent) return ['agent-result', resultId, agent].filter(Boolean).join(':');
-  }
-  const id = String(meta.execution_id || parsed?.taskId || '').trim();
-  if (!id) return '';
-  const type = String(meta.type || '').trim();
-  const status = String(meta.status || parsed?.status || '').trim();
-  const fallbackKind = String(text || '').split('\n', 1)[0]?.trim() || 'notification';
-  // Distinguish a body-carrying completion from a header-only preview that
-  // shares the same id/type/status. An early agent preview can arrive before
-  // the session is persisted (no result body); the canonical notification that
-  // follows DOES carry the body. Without this dimension the bodyless preview
-  // would claim the dedupe key and suppress the real result. A blank-line gap
-  // separates the task header block from the result body in the envelope.
-  const hasBody = /\n\s*\n[\s\S]*\S/.test(String(text || '')) ? 'b1' : 'b0';
-  return [id, type || fallbackKind, status, hasBody].filter(Boolean).join(':');
-}
-
-/** Pure delivery plan for runtime.onNotification execution envelopes (tests + handler). */
-export function resolveTuiRuntimeNotificationDelivery(event, text) {
-  const trimmed = String(text ?? '').trim();
-  if (!trimmed) return { action: 'ignore' };
-  const parsed = parseAgentJob(trimmed);
-  const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
-  if (!isExecutionNotification(event, trimmed, parsed)) {
-    return { action: 'enqueue', displayText: trimmed, modelContent: trimmed };
-  }
-  if (isStatusOnlyAgentCompletionNotification(trimmed)) {
-    return { action: 'status-only', displayText: trimmed, modelContent: '' };
-  }
-  const modelContent = modelVisibleToolCompletionMessage(trimmed, meta);
-  return {
-    action: 'execution-ui',
-    displayText: trimmed,
-    modelContent,
-  };
-}
-
-function isExecutionNotification(event, text, parsed) {
-  const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
-  if (meta.execution_id || meta.execution_surface) return true;
-  if (parseAgentResultEnvelope(text)) return true;
-  if (parseBackgroundTaskEnvelope(text)) return true;
-  return Boolean(parsed?.taskId && /^(?:agent task:|task_id:)/mi.test(String(text || '')));
-}
+// Re-export the pure notification delivery plan (moved to ./engine/notification-plan.mjs)
+// so importers/tests keep resolving resolveTuiRuntimeNotificationDelivery from engine.mjs.
+export { resolveTuiRuntimeNotificationDelivery };
 
 export async function createEngineSession({
   provider: providerName,
@@ -187,7 +125,7 @@ export async function createEngineSession({
   bootProfile('engine:create:runtime-ready', { ms: (performance.now() - startedAt).toFixed(1) });
   const cwd = runtime.cwd || process.cwd();
   const stateStartedAt = performance.now();
-  const autoClearState = () => runtime.getAutoClear?.() || runtime.autoClear || { enabled: true, idleMs: 60 * 60 * 1000 };
+  const autoClearState = () => runtime.getAutoClear?.() || runtime.autoClear || { enabled: true, idleMs: 60 * 60 * 1000, custom: false, providerDefault: 60 * 60 * 1000, provider: null };
   const AGENT_STATUS_CACHE_MS = 250;
   let agentStatusCache = null;
   let agentStatusCacheAt = 0;
@@ -535,6 +473,16 @@ export async function createEngineSession({
     pushItem({ kind: 'notice', id, text: value, tone });
     return id;
   };
+  // Remove a transcript notice previously created via pushNotice(...,
+  // {transcript:true}). Used for transient-but-persistent notices (e.g. the
+  // manual OAuth URL) that must disappear once their flow concludes.
+  const removeNotice = (id) => {
+    if (id == null) return false;
+    const items = state.items.filter((it) => !(it?.kind === 'notice' && it?.id === id));
+    if (items.length === state.items.length) return false;
+    set({ items: replaceItems(items) });
+    return true;
+  };
   // Sticky (non-TTL) input-hint-line progress state, for long-running
   // installs (e.g. voice runtime download) that would otherwise spam the
   // 3s toast queue. Distinct from pushToast/pushNotice: it persists across
@@ -545,80 +493,18 @@ export async function createEngineSession({
     const value = String(text ?? '').trim();
     set({ progressHint: value ? { text: value, tone } : null });
   };
-  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 {
+    presentNextToolApproval,
+    finishToolApproval,
+    denyAllToolApprovals,
+    requestToolApproval,
+  } = createToolApproval({
+    getState: () => state,
+    set,
+    nextId,
+    getDisposed: () => disposed,
+    timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
+  });
   const patchItem = (id, patch) => {
     let index = itemIndexById.get(id);
     if (!Number.isInteger(index) || state.items[index]?.id !== id) {
@@ -666,404 +552,51 @@ export async function createEngineSession({
   let autoClearRunning = false;
   const pendingNotificationKeys = new Set();
   const displayedExecutionNotificationKeys = new Set();
-  let executionResumeKickDeferred = false;
-
-  function kickExecutionPendingResume() {
-    if (disposed) return;
-    if (state.busy) {
-      executionResumeKickDeferred = true;
-      return;
-    }
-    if (pending.some((entry) => entry.mode === 'pending-resume')) {
-      executionResumeKickDeferred = true;
-      return;
-    }
-    executionResumeKickDeferred = false;
-    pending.push(makeQueueEntry('', { mode: 'pending-resume', priority: 'next' }));
-    void drain();
-  }
-
-  function flushDeferredExecutionPendingResumeKick() {
-    if (!executionResumeKickDeferred || disposed || state.busy) return;
-    kickExecutionPendingResume();
-  }
-
-  function scheduleExecutionPendingResumeKick() {
-    // notifyFnForSession enqueues the model-visible body after onNotification
-    // returns; defer the kick so askSession pre-drain sees session pending.
-    queueMicrotask(() => kickExecutionPendingResume());
-  }
-
-  function updateAgentJobCard(itemId, text, isError = false) {
-    const parsed = parseAgentJob(text);
-    const current = state.items.find((it) => it.id === itemId);
-    const rawDisplayText = agentJobResultText(text, parsed) || String(text ?? '').trim();
-    const displayText = isError ? toolErrorDisplay(rawDisplayText, 'agent') : rawDisplayText;
-    patchItem(itemId, {
-      result: displayText,
-      text: displayText,
-      isError,
-      errorCount: isError ? 1 : 0,
-      ...(parsed ? { args: agentArgsWithResultMetadata(current?.args, parsed) } : {}),
-    });
-  }
-
-  if (typeof runtime.onNotification === 'function') {
-    unsubscribeRuntimeNotifications = runtime.onNotification((event) => {
+  const {
+    kickExecutionPendingResume,
+    flushDeferredExecutionPendingResumeKick,
+    scheduleExecutionPendingResumeKick,
+    updateAgentJobCard,
+    subscribeRuntimeNotifications,
+  } = createAgentJobFeed({
+    runtime,
+    getState: () => state,
+    set,
+    nextId,
+    getDisposed: () => disposed,
+    patchItem,
+    enqueue: (...args) => enqueue(...args),
+    drain: (...args) => drain(...args),
+    pushUserOrSyntheticItem,
+    makeQueueEntry: (...args) => makeQueueEntry(...args),
+    getPending: () => pending,
+    agentStatusState,
+    displayedExecutionNotificationKeys,
+  });
+  unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
+
+  // Remote seat superseded by another session: runtime already stopped its
+  // worker; sync the indicator and tell the user. Non-user-initiated, so a
+  // toast (not transcript) is right.
+  let unsubscribeRemoteState = null;
+  if (typeof runtime.onRemoteStateChange === 'function') {
+    unsubscribeRemoteState = runtime.onRemoteStateChange(({ enabled, reason }) => {
       if (disposed) return;
-      const text = String(event?.content ?? event?.text ?? event ?? '').trim();
-      if (!text) return;
-      const parsed = parseAgentJob(text);
-      const notificationKey = notificationQueueKey(event, text, parsed);
-      const delivery = resolveTuiRuntimeNotificationDelivery(event, text);
-      if (delivery.action === 'ignore') return;
-      if (delivery.action === 'status-only') {
-        if (parsed?.taskId) set(agentStatusState({ force: true }));
-        return true;
-      }
-      if (delivery.action === 'execution-ui') {
-        const firstDelivery = !notificationKey || !displayedExecutionNotificationKeys.has(notificationKey);
-        if (firstDelivery) {
-          if (notificationKey) displayedExecutionNotificationKeys.add(notificationKey);
-          pushUserOrSyntheticItem(delivery.displayText, nextId());
-        }
-        if (parsed?.taskId) set(agentStatusState({ force: true }));
-        if (String(delivery.modelContent || '').trim()) {
-          scheduleExecutionPendingResumeKick();
-        }
-        return true;
-      }
-      if (parsed?.taskId) {
-        set(agentStatusState({ force: true }));
+      set({ remoteEnabled: enabled === true });
+      if (reason === 'superseded') {
+        pushNotice('Remote mode OFF — another session took over remote.', 'warn');
       }
-      const modelContent = String(delivery.modelContent ?? delivery.displayText ?? text).trim();
-      if (!modelContent) return true;
-      enqueue(modelContent, {
-        mode: 'task-notification',
-        priority: 'next',
-        key: notificationKey || undefined,
-        displayText: delivery.displayText || text,
-      });
-      return true;
     });
   }
 
-  const CANCELLED_RESULT_STATUS_LINE = '[status: cancelled]';
-
-  function normalizedResultStatusToken(value) {
-    const raw = String(value || '').trim().toLowerCase();
-    if (!raw) return '';
-    if (/^(running|pending|queued|in_progress|in-progress)$/.test(raw)) return 'running';
-    if (/^(completed|complete|done|success|succeeded|ok)$/.test(raw)) return 'completed';
-    if (/^(failed|fail|error|errored|timeout|timed_out|killed)$/.test(raw)) return 'failed';
-    if (/^(cancelled|canceled|cancel)$/.test(raw)) return 'cancelled';
-    return '';
-  }
-
-  function resultTextTerminalStatus(text) {
-    const body = String(text || '');
-    const tagged = body.match(/<status[^>]*>([\s\S]*?)<\/status>/i)?.[1]?.trim();
-    if (tagged) return normalizedResultStatusToken(tagged);
-    const bracketed = body.match(/^\[status:\s*([^\]]*)\]/mi)?.[1]?.trim();
-    if (bracketed) return normalizedResultStatusToken(bracketed);
-    const inline = body.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
-    return normalizedResultStatusToken(inline);
-  }
-
-  function itemHasKnownTerminalStatus(item, texts = []) {
-    const settled = (token) => token === 'completed' || token === 'failed' || token === 'cancelled';
-    if (settled(normalizedResultStatusToken(item?.args?.status))) return true;
-    for (const text of texts) {
-      if (settled(resultTextTerminalStatus(text))) return true;
-    }
-    return false;
-  }
-
-  function withCancelledResultMarker(text, item) {
-    const body = String(text || '');
-    // Do NOT inspect item.rawResult here: aggregate rawResult is child tool
-    // output (`1. grep\n<result>…`) that can incidentally contain a `status:`
-    // line, which would false-positive as an already-terminal status and skip
-    // the cancelled marker. Only result/text/body are engine-controlled
-    // collapsed detail (empty / status word / an existing marker), so they are
-    // the trustworthy terminal-status sources.
-    const sources = [item?.result, item?.text, body];
-    if (itemHasKnownTerminalStatus(item, sources)) return body;
-    if (!body.trim()) return `${CANCELLED_RESULT_STATUS_LINE}\n`;
-    return `${CANCELLED_RESULT_STATUS_LINE}\n${body}`;
-  }
-
-  function groupedToolResultText(group) {
-    const completed = Math.min(group.count, group.completed);
-    if (group.count <= 1) return group.results.at(-1)?.text ?? '';
-    if (group.errors > 0) {
-      const succeeded = Math.max(0, completed - group.errors);
-      const reasons = group.results
-        .filter((result) => result?.isError)
-        .map((result) => firstErrorLine(result?.text))
-        .filter(Boolean);
-      const uniqueReasons = [...new Set(reasons)].slice(0, 2);
-      const base = succeeded > 0
-        ? `${succeeded} Ok · ${group.errors} Failed`
-        : `${group.errors} Failed`;
-      return [
-        `${base}${uniqueReasons[0] ? ` · ${uniqueReasons[0]}` : ''}`,
-        ...uniqueReasons.slice(1),
-      ].join('\n');
-    }
-    for (const result of group.results || []) {
-      const line = String(result?.text || '').trim();
-      if (line) return result.text;
-    }
-    return '';
-  }
-
-  function firstErrorLine(text) {
-    const clean = toolErrorDisplay(text, 'tool');
-    if (clean) return clean;
-    for (const line of String(text || '').split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      if (/^(Error|\[?error|FAIL\b)/i.test(trimmed)) return trimmed;
-    }
-    return String(text || '').split('\n').map((line) => line.trim()).find(Boolean) || '';
-  }
-
-  function aggregateRawResult(calls) {
-    const chunks = [];
-    for (const rec of calls || []) {
-      if (rec?.resolved !== true) continue;
-      let text = String(rec?.resultText || '').replace(/\s+$/, '');
-      if (!text.trim()) continue;
-      const label = String(rec?.name || rec?.category || 'tool').trim() || 'tool';
-      chunks.push(`${chunks.length + 1}. ${label}\n${text}`);
-    }
-    return chunks.join('\n\n');
-  }
-
-  function aggregateBucketForCategory(category) {
-    // Merge consecutive tool calls of the SAME category into one aggregate card;
-    // a different category opens a fresh card (no cross-category merge). The
-    // bucket key is the category itself, so a run of Search calls collapses into
-    // one Search card while an adjacent Read/Patch stays separate. Falls back to
-    // 'default' when a call has no resolved category. Hook/approval denials keep
-    // their dedicated ToolHookDenialCard path in App.jsx.
-    const key = String(category || '').trim();
-    return key ? `category:${key}` : 'default';
-  }
-
-  function aggregateSummaries(aggregate) {
-    return [...(aggregate?.calls?.values?.() || [])]
-      .filter((r) => r.summary)
-      .sort((a, b) => Number(a.summarySeq ?? 0) - Number(b.summarySeq ?? 0))
-      .map((r) => r.summary);
-  }
-
-  function assignAggregateSummaryOrder(aggregate, callRec) {
-    if (!aggregate || !callRec?.summary || callRec.summarySeq != null) return;
-    const next = Math.max(0, Number(aggregate.nextSummarySeq || 0));
-    callRec.summarySeq = next;
-    aggregate.nextSummarySeq = next + 1;
-  }
-
-  function patchToolCardResult(card, message, toolGroups, done) {
-    if (!card || card.done) return false;
-    const callId = toolResultCallId(message) || card.callId;
-    if (callId && done.has(callId)) return false;
-    // Any resolving call clears its active-summary entry (keyed by the same
-    // callKey used at markToolCallActive; card.callId holds it for both branches).
-    markToolCallDone(card.callId);
-    // A result for this card arrived (possibly before its deferred push delay
-    // elapsed) — surface the card now so the patch below has a live item and the
-    // fast tool paints a completed card directly, no pending placeholder stage.
-    // ensureVisible flushes this card AND every earlier-created still-deferred
-    // card in order, so transcript order always matches call order.
-    (card.aggregate?.ensureVisible || card.ensureVisible)?.();
-    const rawText = toolResultText(message?.content);
-    const isError = message?.isError === true || message?.toolKind === 'error' || /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText));
-    const text = isError ? toolErrorDisplay(rawText, card?.name || 'tool') : rawText;
-
-    // Aggregate card handling — collect semantic summaries per call
-    const aggregate = card.aggregate;
-    if (aggregate && card.itemId === aggregate.itemId) {
-      const callRec = callId ? aggregate.calls.get(callId) : null;
-      if (!callRec) return false;
-      if (callRec.resolved) {
-        card.done = true;
-        if (callId) done.add(callId);
-        return false;
-      }
-      callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
-      assignAggregateSummaryOrder(aggregate, callRec);
-      callRec.isError = isError;
-      callRec.resultText = text;
-      callRec.resolved = true;
-      const allCalls = [...aggregate.calls.values()];
-      const completed = allCalls.filter((r) => r.resolved).length;
-      const errors = allCalls.filter((r) => r.isError).length;
-      // Collapsed detail carries the merged per-call count summary
-      // ("512 lines, 6 matches, 3 files") so the finished card answers "how
-      // much" without ctrl+o. Failures keep a bare 'N Ok · N Failed' status so
-      // an error stays visible while collapsed.
-      const succeeded = completed - errors;
-      const detailText = errors > 0
-        ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
-        : formatAggregateDetail(aggregateSummaries(aggregate));
-      const currentItem = state.items.find((it) => it.id === card.itemId);
-      const earlyCompleted = allCalls.filter((r) => r.resolved || r.completedEarly).length;
-      const visualCompleted = Math.max(completed, earlyCompleted, Math.min(allCalls.length, Number(currentItem?.completedCount || 0)));
-      const rawResult = aggregateRawResult(allCalls);
-      // The numbered+labelled raw (rawResult) is preserved for ctrl+o expansion.
-      const displayDetail = detailText;
-      patchItem(card.itemId, {
-        result: displayDetail,
-        text: displayDetail,
-        rawResult: rawResult || null,
-        isError: errors > 0,
-        errorCount: errors,
-        count: allCalls.length,
-        completedCount: visualCompleted,
-        completedAt: Number(currentItem?.completedAt) || Date.now(),
-      });
-      card.done = true;
-      if (callId) done.add(callId);
-      return true;
-    }
-
-    // Non-aggregate (legacy agent-job cards, etc.)
-    const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, results: [] };
-    group.completed = Math.min(group.count, group.completed + 1);
-    group.errors += isError ? 1 : 0;
-    group.results.push({ text, isError });
-    toolGroups.set(card.itemId, group);
-    const resultText = groupedToolResultText(group);
-    const displayResult = toolGroupedDisplayFallback(resultText, text, rawText);
-    const patch = {
-      result: displayResult,
-      text: displayResult,
-      isError: group.errors > 0,
-      errorCount: group.errors,
-      count: group.count,
-      completedCount: group.completed,
-      completedAt: Date.now(),
-    };
-    if (group.count <= 1) {
-      const body = String(text || rawText || '').trim();
-      if (body) patch.rawResult = text || rawText;
-      const parsedAgent = parseAgentJob(rawText);
-      if (parsedAgent) {
-        patch.args = agentArgsWithResultMetadata(state.items.find((it) => it.id === card.itemId)?.args, parsedAgent);
-        set(agentStatusState({ force: true }));
-      }
-    }
-    patchItem(card.itemId, patch);
-    if (group.count <= 1) updateAgentJobCard(card.itemId, rawText, isError);
-    card.done = true;
-    if (callId) done.add(callId);
-    return true;
-  }
-
-  const flushToolResults = (messages, toolCards, cardByCallId, toolGroups, done, { finalize = false, cancelled = false } = {}) => {
-    const results = [];
-    for (const m of messages || []) {
-      if (!m || m.role !== 'tool') continue;
-      const callId = toolResultCallId(m);
-      results.push({ message: m, callId, used: false });
-      if (!callId || done.has(callId)) continue;
-      const card = cardByCallId.get(callId);
-      if (patchToolCardResult(card, m, toolGroups, done)) {
-        results[results.length - 1].used = true;
-      }
-    }
-
-    const openCards = (toolCards || []).filter((card) => !card.done);
-    if (openCards.length === 0) return;
-
-    const unusedResults = results.filter((result) => !result.used);
-    const fallbackResults = unusedResults.slice(-openCards.length);
-    for (let i = 0; i < fallbackResults.length; i++) {
-      const card = openCards[i];
-      const result = fallbackResults[i];
-      if (!card || !result || card.done) continue;
-      if (patchToolCardResult(card, result.message, toolGroups, done)) {
-        if (result.callId) done.add(result.callId);
-        result.used = true;
-      }
-    }
-
-    if (!finalize) return;
-    for (const card of toolCards || []) {
-      if (card.done) continue;
-      // Finalize must surface any still-deferred card before patching its result
-      // so the completed/cancelled card is never silently dropped.
-      (card.aggregate?.ensureVisible || card.ensureVisible)?.();
-      // Aggregate finalize — mark any remaining calls as done
-      const aggregate = card.aggregate;
-      if (aggregate && card.itemId === aggregate.itemId) {
-        const allCalls = [...aggregate.calls.values()];
-        // Never let a call that truly never resolved be presented as a real
-        // completion. Stamp it resolved so completedCount reflects an honest
-        // (if degenerate) accounting instead of manufacturing success out of
-        // a call that never came back. A record already marked completedEarly
-        // (via __earlyNotify) already carries a real isError/resultText/summary
-        // from its actual result — preserve those; only blank-fill for calls
-        // truly never heard from (no completedEarly, no resolved).
-        for (const rec of allCalls) {
-          if (rec.resolved) continue;
-          rec.resolved = true;
-          if (!rec.completedEarly) {
-            rec.isError = false;
-            rec.resultText = rec.resultText || '';
-          }
-        }
-        const completed = allCalls.filter((r) => r.resolved).length;
-        const totalCompleted = completed;
-        const errors = allCalls.filter((r) => r.isError).length;
-        const succeeded = completed - errors;
-        const rawResult = aggregateRawResult(allCalls);
-        // Collapsed detail carries the merged per-call count summary; failures
-        // keep a bare 'N Ok · N Failed' status. Raw is kept for ctrl+o.
-        let displayDetail = errors > 0
-          ? (succeeded > 0 ? `${succeeded} Ok · ${errors} Failed` : `${errors} Failed`)
-          : formatAggregateDetail(aggregateSummaries(aggregate));
-        if (cancelled) {
-          // Cancelled aggregates MUST keep the [status: cancelled] marker on the
-          // result so terminalStatus parsing resolves to 'cancelled'. Only normal
-          // completions drop the summary; cancelled ones prepend the marker.
-          const currentItem = state.items.find((it) => it.id === card.itemId);
-          displayDetail = withCancelledResultMarker(displayDetail, currentItem);
-        }
-        patchItem(card.itemId, {
-          result: displayDetail,
-          text: displayDetail,
-          rawResult: rawResult || null,
-          isError: errors > 0,
-          errorCount: errors,
-          count: allCalls.length,
-          completedCount: totalCompleted,
-          completedAt: Date.now(),
-        });
-        for (const sibling of toolCards || []) {
-          if (sibling.itemId !== card.itemId) continue;
-          sibling.done = true;
-          if (sibling.callId) done.add(sibling.callId);
-        }
-        continue;
-      }
-      // Non-aggregate finalize
-      const group = toolGroups.get(card.itemId) || { count: 1, completed: 0, errors: 0, results: [] };
-      group.completed = Math.min(group.count, group.completed + 1);
-      toolGroups.set(card.itemId, group);
-      let resultText = groupedToolResultText(group);
-      if (cancelled) {
-        const currentItem = state.items.find((it) => it.id === card.itemId);
-        resultText = withCancelledResultMarker(resultText, currentItem);
-      }
-      patchItem(card.itemId, { result: resultText, text: resultText, isError: group.errors > 0, errorCount: group.errors, count: group.count, completedCount: group.completed, completedAt: Date.now() });
-      card.done = true;
-      if (card.callId) done.add(card.callId);
-    }
-  };
+  const { patchToolCardResult, flushToolResults } = createToolCardResults({
+    getState: () => state,
+    set,
+    patchItem,
+    markToolCallDone,
+    updateAgentJobCard,
+    agentStatusState,
+  });
 
   async function runTurn(userText, options = {}) {
     const turnIndex = state.stats.turns || 0;
@@ -1105,7 +638,7 @@ export async function createEngineSession({
     // cards (send() still in flight). Hold those by callId until the batch lands.
     const earlyResultBuffer = new Map();
     const aggregateCards = []; // active aggregate cards in the current consecutive tool block
-    const aggregateByBucket = new Map(); // per-bucket reusable card for the current consecutive tool block; cleared on block seal
+    let tailAggregate = null; // most recently touched aggregate card; only the tail may absorb the next same-bucket call
 
     // ── Deferred tool-card push (scroll/text sync) ────────────────────────────
     // A tool card used to enter the transcript the instant onToolCall fired,
@@ -1264,28 +797,25 @@ export async function createEngineSession({
       aggregateCards.length = 0;
       // Seal the block: same-bucket calls after this point must open a fresh
       // card, never continue one from before the seal (assistant text/turn
-      // end boundary). Cross-block behavior is unchanged by the in-block
-      // reuse relaxation below.
-      aggregateByBucket.clear();
+      // end boundary).
+      tailAggregate = null;
     };
 
     const rememberActiveAggregate = (aggregate) => {
       if (!aggregate) return;
       if (!aggregateCards.includes(aggregate)) aggregateCards.push(aggregate);
-      aggregateByBucket.set(aggregate.bucket, aggregate);
+      tailAggregate = aggregate;
     };
 
     const ensureAggregateCard = (bucket) => {
-      // Reuse any same-bucket aggregate created earlier in the SAME consecutive
-      // tool block, even when a different-category card was interleaved after
-      // it (Read, Search, Read → the two Reads merge into one card; the Search
-      // stays separate). The block is only sealed — forcing a fresh card per
-      // bucket — by clearAggregateContinuation (assistant text lands or the
-      // turn ends), which clears aggregateByBucket. Reusing a pushed, non-tail
-      // card is safe: the aggregate card body is a fixed header+1-detail-row
-      // height, so patching its count/completedCount later never reflows the
-      // cards that were pushed after it.
-      const cached = aggregateByBucket.get(bucket);
+      // Only the TAIL aggregate (most recent card) may absorb the next call,
+      // and only when the bucket matches. Any different-bucket aggregate or
+      // standalone card in between breaks the run, so Search, Memory, Search
+      // renders as three cards in call order — a new call never merges into
+      // an earlier card above the current tail (which read as out-of-order
+      // count changes in the transcript). clearAggregateContinuation seals
+      // the block at assistant-text/turn boundaries.
+      const cached = tailAggregate && tailAggregate.bucket === bucket ? tailAggregate : null;
       if (cached) {
         rememberActiveAggregate(cached);
         return cached;
@@ -1632,7 +1162,11 @@ export async function createEngineSession({
             // Category drives the aggregate bucket so only same-category calls
             // merge into one card; classify first, then bucket by it.
             const category = classifyToolCategory(name, args);
-            const bucket = aggregateBucketForCategory(category);
+            // Agent/bridge calls always get their own standalone card so
+            // ToolExecution's isAgentTool/agentActionTitle path renders a
+            // "Spawn <Agent> (model, tag)" header instead of being folded
+            // into the "Called N agent(s)" category-aggregate card.
+            const bucket = category === 'Agent' ? null : aggregateBucketForCategory(category);
             const callId = toolCallId(c);
             const callKey = callId || `__tool_${toolCards.length}_${i}`;
             // The old App scan counted multi-pattern calls via
@@ -1673,6 +1207,10 @@ export async function createEngineSession({
                 cardByCallId.set(callId, card);
               }
               toolCards.push(card);
+              // A standalone card (Agent) breaks the consecutive run too: a
+              // later same-bucket call must open a fresh card BELOW it, not
+              // merge into an aggregate above it.
+              tailAggregate = null;
               continue;
             }
 
@@ -2856,6 +2394,16 @@ export async function createEngineSession({
       set({ remoteEnabled: next });
       return next;
     },
+    // Force-claim remote for this session (single-holder, last-wins). Always
+    // turns remote ON here and steals the bridge seat; the previous holder is
+    // superseded and flips itself OFF via onRemoteStateChange. Used by the
+    // `/remote` slash command — repeated /remote just re-claims (idempotent).
+    claimRemote: () => {
+      runtime.startRemote?.();
+      const next = runtime.isRemoteEnabled?.() === true;
+      set({ remoteEnabled: next });
+      return next;
+    },
     isRemoteEnabled: () => runtime.isRemoteEnabled?.() === true,
     // Theme is a TUI-local concern (no runtime round-trip). listThemes returns
     // picker metadata; getTheme reports the active id; setTheme applies the
@@ -2938,6 +2486,15 @@ export async function createEngineSession({
         'info');
       return true;
     },
+    loginOpenCodeGoUsage: async () => {
+      if (state.commandBusy) throw new Error('command busy');
+      set({ commandBusy: true });
+      try {
+        return await runtime.loginOpenCodeGoUsage();
+      } finally {
+        set({ commandBusy: false });
+      }
+    },
     saveOpenAIUsageSessionKey: (secret) => {
       runtime.saveOpenAIUsageSessionKey(secret);
       pushNotice('OpenAI usage auth saved', 'info');
@@ -3062,6 +2619,7 @@ export async function createEngineSession({
       }
     },
     pushNotice,
+    removeNotice,
     setProgressHint,
     clear: async () => {
       if (state.commandBusy) return false;
@@ -3199,6 +2757,8 @@ export async function createEngineSession({
       try { clearInterval(runtimePulseTimer); } catch {}
       try { unsubscribeRuntimeNotifications?.(); } catch {}
       unsubscribeRuntimeNotifications = null;
+      try { unsubscribeRemoteState?.(); } catch {}
+      unsubscribeRemoteState = null;
       denyAllToolApprovals('runtime closing');
       await runtime.close(reason, options);
       listeners.clear();