mixdog 0.9.170 → 0.9.172

package/src/runtime/shared/tool-card-model/card-status.mjs

@@ -0,0 +1,83 @@
+/**
+ * card-status.mjs — the terminal status of a single tool card and the
+ * status-derived fragments (shell status, header failure, agent completion)
+ * the detail and header rows are built from.
+ */
+import { backgroundTaskFailureStatusLabel } from '../err-text.mjs';
+import { agentTerminalDetail, isAgentTool } from './agent-surface.mjs';
+import { backgroundTaskElapsed, backgroundTaskFailureDetail, isBackgroundTaskTool } from './background-task.mjs';
+import { shellDisplayStatus } from './shell-surface.mjs';
+import { normalizeTerminalStatus, resultTerminalStatus, shellResultElapsed } from './terminal-status.mjs';
+import { gitResultError, gitResultExitCode } from './git-result.mjs';
+
+function shellFragments(base, display, isShellSurface) {
+  if (!isShellSurface) return { shellStatus: '', shellElapsed: '' };
+  const { pending, failedCount, exitFailedCount, isError, elapsed } = base;
+  return {
+    shellStatus: shellDisplayStatus({
+      pending,
+      failedCount,
+      exitFailedCount,
+      isError,
+      result: display.displayedResultText,
+    }),
+    shellElapsed: shellResultElapsed(display.displayedResultText) || elapsed,
+  };
+}
+
+function backgroundElapsedFor(base, display, normalizedName, parsedArgs) {
+  if (display.backgroundMeta) return backgroundTaskElapsed(display.backgroundMeta, base.elapsed);
+  if (isBackgroundTaskTool(normalizedName)) return backgroundTaskElapsed(parsedArgs, base.elapsed);
+  return '';
+}
+
+/** Failures that replace the detail row with a header status word. */
+function headerFailures(base, display, normalizedName, parsedArgs) {
+  const { pending, isError } = base;
+  const backgroundMetadataFailureLabel = display.isBackgroundMetadataResult
+    ? backgroundTaskFailureDetail(display.backgroundMeta, parsedArgs)
+    : '';
+  const backgroundMetadataHeaderFailure =
+    backgroundMetadataFailureLabel && !display.hasDisplayResult ? backgroundMetadataFailureLabel : '';
+  const agentHeaderFailure =
+    !pending && isAgentTool(normalizedName) && isError && parsedArgs?.error && !display.hasDisplayResult
+      ? backgroundTaskFailureStatusLabel(parsedArgs?.status, parsedArgs?.error, { surface: 'agent' })
+      : '';
+  return { backgroundMetadataHeaderFailure, agentHeaderFailure };
+}
+
+export function deriveCardStatus(base, { normalizedName, parsedArgs, isShellSurface }, display) {
+  const { pending, isError, elapsed, failedCount } = base;
+  const { shellStatus, shellElapsed } = shellFragments(base, display, isShellSurface);
+  const { backgroundMetadataHeaderFailure, agentHeaderFailure } = headerFailures(
+    base,
+    display,
+    normalizedName,
+    parsedArgs
+  );
+  const agentCompletionDetail =
+    !pending && isAgentTool(normalizedName) && !agentHeaderFailure
+      ? agentTerminalDetail(parsedArgs?.status, isError, elapsed, parsedArgs?.error)
+      : '';
+  const gitFailed = normalizedName === 'git' &&
+    (gitResultExitCode(display.displayedResultText) !== null || Boolean(gitResultError(display.displayedResultText)));
+  const failedOrCompleted = isError || failedCount > 0 || gitFailed ? 'failed' : 'completed';
+  const terminalStatus = pending
+    ? 'running'
+    : shellStatus ||
+      normalizeTerminalStatus(display.backgroundMeta?.status) ||
+      normalizeTerminalStatus(parsedArgs?.status) ||
+      resultTerminalStatus(display.displayedResultText) ||
+      failedOrCompleted;
+  return {
+    shellStatus,
+    shellElapsed,
+    backgroundElapsed: backgroundElapsedFor(base, display, normalizedName, parsedArgs),
+    backgroundMetadataHeaderFailure,
+    agentHeaderFailure,
+    headerFailureText: backgroundMetadataHeaderFailure || agentHeaderFailure || '',
+    agentCompletionDetail,
+    agentDetail: !pending && isAgentTool(normalizedName) && !display.hasDisplayResult ? agentCompletionDetail : '',
+    terminalStatus,
+  };
+}

package/src/runtime/shared/tool-card-model/displayed-result.mjs

@@ -0,0 +1,44 @@
+/**
+ * displayed-result.mjs — which text of the tool result the collapsed card
+ * actually shows: the background-task body over its envelope, never an
+ * error-only body, with the leading status marker stripped.
+ */
+import { summarizeToolResult } from '../tool-surface.mjs';
+import { isBackgroundErrorOnlyBody } from '../err-text.mjs';
+import { isBackgroundTaskResponseArgs, isBackgroundTaskTool, resolveBackgroundTaskMeta } from './background-task.mjs';
+import { stripLeadingStatusMarkerFromText } from './terminal-status.mjs';
+
+export function resolveDisplayedResult(base, { normalizedName, parsedArgs }) {
+  const { name, args, rt, pending, isError } = base;
+  const isBackgroundTool = isBackgroundTaskTool(normalizedName);
+  const backgroundMeta = !pending && isBackgroundTool ? resolveBackgroundTaskMeta(parsedArgs, rt || '') : null;
+  const backgroundError = backgroundMeta?.error || parsedArgs?.error || '';
+  const errorOnlyResult = Boolean(rt) && isBackgroundErrorOnlyBody(rt, backgroundError);
+  const backgroundResultText = backgroundMeta?.hasResponse ? backgroundMeta.body : '';
+  const displayedResultText = backgroundResultText || (errorOnlyResult ? '' : rt || '');
+  const hasDisplayResult = Boolean(String(displayedResultText || '').trim());
+  const displayedResultBodyText = normalizedName === 'git'
+    ? displayedResultText
+    : stripLeadingStatusMarkerFromText(displayedResultText);
+  const hasDisplayBody = Boolean(String(displayedResultBodyText || '').trim());
+  const lines = displayedResultBodyText ? displayedResultBodyText.split('\n') : [];
+  const isBackgroundResult = !pending && isBackgroundTool && Boolean(backgroundMeta);
+  const isBackgroundResponse =
+    isBackgroundResult && (backgroundMeta?.hasResponse || isBackgroundTaskResponseArgs(normalizedName, parsedArgs));
+  return {
+    backgroundMeta,
+    displayedResultText,
+    hasDisplayResult,
+    displayedResultBodyText,
+    hasDisplayBody,
+    totalLines: lines.length,
+    resultSummary:
+      !pending && (hasDisplayBody || normalizedName === 'git')
+        ? summarizeToolResult(name, args, displayedResultBodyText, isError)
+        : null,
+    firstResultLine: hasDisplayResult ? String(lines[0] ?? '') : '',
+    isBackgroundResult,
+    isBackgroundResponse,
+    isBackgroundMetadataResult: isBackgroundResult && !isBackgroundResponse && Boolean(backgroundMeta),
+  };
+}

package/src/runtime/shared/tool-card-model/generic-detail.mjs

@@ -0,0 +1,79 @@
+/**
+ * generic-detail.mjs — the completed-detail row for tools without a
+ * dedicated surface, plus the load_tool and web-search conventions.
+ */
+const OUTPUT_DETAIL_TOOL_NAMES = new Set([
+  'shell',
+  'bash',
+  'bash_session',
+  'shell_command',
+  'job_wait',
+  'read',
+  'view_image',
+  'read_mcp_resource',
+  'grep',
+  'glob',
+  'search_query',
+  'image_query',
+  'web_search',
+  'web_search_call',
+  'web_fetch',
+  'fetch',
+  'list',
+  'ls',
+  'code_graph',
+  'recall',
+  'recall_memory',
+  'search_memories',
+  'remember',
+  'save_memory',
+  'update_memory',
+]);
+
+function isOutputDetailTool(normalizedName, label) {
+  const n = String(normalizedName || '').toLowerCase();
+  const l = String(label || '').toLowerCase();
+  return OUTPUT_DETAIL_TOOL_NAMES.has(n) || l === 'read' || l === 'search' || l === 'web search' || l === 'run';
+}
+
+export function genericCompletedDetail({ normalizedName, label, hasResult, firstResultLine, isError }) {
+  const n = String(normalizedName || '').toLowerCase();
+  const l = String(label || '').toLowerCase();
+  if (isError) return hasResult ? firstResultLine : 'Failed';
+  if (n === 'shell' || n === 'bash' || n === 'bash_session' || n === 'shell_command' || n === 'job_wait') {
+    return '';
+  }
+  if (isOutputDetailTool(n, l)) {
+    return hasResult ? firstResultLine : '';
+  }
+  return '';
+}
+
+export function toolSearchLoadedSummary(resultText) {
+  let parsed;
+  try {
+    parsed = JSON.parse(String(resultText || ''));
+  } catch {
+    const text = String(resultText || '');
+    const loaded = /^Loaded deferred tools:\s*(.+)$/m.exec(text)?.[1] || '';
+    const already = /^Already active:\s*(.+)$/m.exec(text)?.[1] || '';
+    return [...(loaded ? [`Loaded: ${loaded}`] : []), ...(already ? [`Already active: ${already}`] : [])].join(' · ');
+  }
+  const tools = parsed?.selected?.tools;
+  if (!tools || typeof tools !== 'object') return '';
+  const uniqueNames = (names) => [
+    ...new Set((Array.isArray(names) ? names : []).map((name) => String(name || '').trim()).filter(Boolean)),
+  ];
+  const loaded = uniqueNames(tools.added);
+  const already = uniqueNames(tools.already);
+  return [
+    ...(loaded.length ? [`Loaded: ${loaded.join(', ')}`] : []),
+    ...(already.length ? [`Already active: ${already.join(', ')}`] : []),
+  ].join(' · ');
+}
+
+export function shouldPrefixSyncElapsed(normalizedName, label) {
+  const n = String(normalizedName || '').toLowerCase();
+  const l = String(label || '').toLowerCase();
+  return n === 'web_search' || l === 'search' || l === 'web search';
+}

package/src/runtime/shared/tool-card-model/git-result.mjs

@@ -0,0 +1,9 @@
+// Only command result headers, not arbitrary lines in a patch, carry exits.
+export function gitResultExitCode(text) {
+  const match = /(?:^(?:## [^\n]+\n)?|\n## [^\n]+\n)exit ([1-9]\d*)\r?(?:\n|$)/.exec(String(text ?? ''));
+  return match ? Number(match[1]) : null;
+}
+
+export function gitResultError(text) {
+  return /(?:^|\n)error: command failed: [^\n]+|^error: [^\n]+/.exec(String(text ?? ''))?.[0].trim() || '';
+}

package/src/runtime/shared/tool-card-model/inline-text.mjs

@@ -0,0 +1,78 @@
+/**
+ * inline-text.mjs — single-row text hygiene and the row budgets shared by
+ * every collapsed tool-card surface.
+ */
+import stripAnsi from 'strip-ansi';
+
+export const MIN_RESULT_LINE_CHARS = 24;
+// Hard cap for the collapsed result detail row (the second line under the ⎿
+// gutter). Independent of terminal width so a wide terminal never lets a long
+// line (e.g. an agent response brief) stretch the whole row — anything past
+// this is truncated with an ellipsis. Expanding still shows the full body.
+export const RESULT_LINE_HARD_MAX = 80;
+// Hard cap for the parenthesized header arg summary so a long path/query does
+// not eat the whole header line; anything longer is truncated with an ellipsis.
+export const SUMMARY_MAX_CHARS = 48;
+export const HEADER_FAILURE_STATUS_MAX = 32;
+
+// Collapsed tool headers/details are laid out as single rows. Never let raw
+// C0/control bytes (CR, tabs, cursor escapes, etc.) reach those rows.
+const INLINE_CONTROL_RE = /[\u0000-\u001F\u007F]/g;
+
+export function safeInlineText(value) {
+  return stripAnsi(String(value ?? ''))
+    .replace(/\r\n?/g, '\n')
+    .replace(/\t/g, ' ')
+    .replace(/\n+/g, ' ')
+    .replace(INLINE_CONTROL_RE, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function clipPlain(text, maxChars) {
+  const value = safeInlineText(text);
+  const max = Math.max(1, Number(maxChars) || 1);
+  if (value.length <= max) return value;
+  return `${value.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function normalizeCount(value) {
+  const n = Number(value || 0);
+  return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+}
+
+export function normalizeCountMap(value = {}) {
+  const out = {};
+  for (const [key, raw] of Object.entries(value || {})) {
+    if (raw && typeof raw === 'object') {
+      out[key] = { ...raw, count: normalizeCount(raw.count) };
+    } else {
+      out[key] = normalizeCount(raw);
+    }
+  }
+  return out;
+}
+
+// `+N`/`-N` line-delta tokens inside a detail row ("+177 lines"). Surfaces
+// color the token (TUI theme / desktop CSS); the SPLIT lives here so both
+// recognize the same grammar.
+const LINE_DELTA_RE = /(^|[\s([,{·])([+-]\s*\d+)(?=\s+Lines?\b)/gi;
+
+export function splitLineDeltaTokens(text) {
+  const value = String(text ?? '');
+  const parts = [];
+  let last = 0;
+  let match;
+  LINE_DELTA_RE.lastIndex = 0;
+  while ((match = LINE_DELTA_RE.exec(value))) {
+    const prefix = match[1] || '';
+    const token = (match[2] || '').replace(/\s+/g, '');
+    const tokenStart = match.index + prefix.length;
+    if (match.index > last) parts.push({ text: value.slice(last, match.index) });
+    if (prefix) parts.push({ text: prefix });
+    if (token) parts.push({ text: token, delta: token.startsWith('+') ? '+' : '-' });
+    last = tokenStart + (match[2] || '').length;
+  }
+  if (last < value.length) parts.push({ text: value.slice(last) });
+  return parts;
+}

package/src/runtime/shared/tool-card-model/shell-surface.mjs

@@ -0,0 +1,45 @@
+/**
+ * shell-surface.mjs — the shell/run tool family: its status merge and header.
+ */
+import { pluralize } from '../tool-primitives.mjs';
+import { shellResultStatus } from './terminal-status.mjs';
+
+export function isShellTool(normalizedName, label = '') {
+  const n = String(normalizedName || '').toLowerCase();
+  const l = String(label || '').toLowerCase();
+  return (
+    n === 'shell' || n === 'bash' || n === 'bash_session' || n === 'shell_command' || n === 'job_wait' || l === 'run'
+  );
+}
+
+export function shellDisplayStatus({
+  pending = false,
+  failedCount = 0,
+  exitFailedCount = 0,
+  isError = false,
+  result = '',
+} = {}) {
+  const status = shellResultStatus(result);
+  if (pending || /^(running|pending|queued)$/.test(status)) return 'running';
+  if (/^cancel/.test(status)) return 'cancelled';
+  if (/^(failed|error|killed|timeout)$/.test(status)) return 'failed';
+  // A command that RAN but exited non-zero is a command failure, not a failed
+  // tool invocation: render the warning state unless a real tool failure also
+  // exists in the group.
+  const realFailed = Math.max(0, Number(failedCount) - Number(exitFailedCount));
+  if (realFailed > 0) return 'failed';
+  if (Number(exitFailedCount) > 0) return 'exit';
+  if (isError || failedCount > 0) return 'failed';
+  return 'completed';
+}
+
+export function shellHeader(status, count = 1, verifying = false) {
+  const n = Math.max(1, Number(count) || 1);
+  const object = `${n} ${pluralize(n, 'command')}`;
+  // A shell that follows an edit in the same batch IS the verification —
+  // label it as such while healthy; failures keep the neutral Ran + detail.
+  if (verifying && status === 'running') return `Verifying ${object}`;
+  if (verifying && status === 'completed') return `Verified ${object}`;
+  if (status === 'running') return `Running ${object}`;
+  return `Ran ${object}`;
+}

package/src/runtime/shared/tool-card-model/terminal-status.mjs

@@ -0,0 +1,109 @@
+/**
+ * terminal-status.mjs — terminal status words, their outcome tone, status
+ * marker stripping and the ` · <time>` detail conventions.
+ */
+import { normalizeToolTerminalStatus, toolResultTerminalStatus } from '../tool-status.mjs';
+import { formatElapsed } from '../time-format.mjs';
+
+export function shellResultStatus(value) {
+  const match = String(value || '').match(
+    /(?:^|\b)status:\s*(running|pending|queued|completed|failed|cancelled|canceled)\b/im
+  );
+  return match ? String(match[1] || '').toLowerCase() : '';
+}
+
+export function normalizeTerminalStatus(value) {
+  return normalizeToolTerminalStatus(value);
+}
+
+// Semantic outcome shared by TUI and desktop. A returned command/task failure
+// means the tool transport worked, so it is warning-yellow; red is reserved
+// for a failed invocation. A failed mutation that still committed a diff is
+// likewise partial success, not a total failure.
+export function deriveToolOutcomeTone({
+  pending = false,
+  groupCount = 1,
+  callFailedCount = 0,
+  exitFailedCount = 0,
+  terminalStatus = '',
+  partialMutation = false,
+} = {}) {
+  if (pending) return 'running';
+  const status = normalizeTerminalStatus(terminalStatus);
+  if (status === 'cancelled' || status === 'denied') return 'warning';
+  const count = Math.max(1, Number(groupCount) || 1);
+  const callFailures = Math.max(0, Number(callFailedCount) || 0);
+  if (callFailures > 0) {
+    if (partialMutation || (count > 1 && callFailures < count)) return 'warning';
+    return 'error';
+  }
+  if (status === 'failed' || Number(exitFailedCount) > 0) return 'warning';
+  return 'success';
+}
+
+export function displayTerminalStatus(value) {
+  // 'exit' is a shell-only pseudo-status (command RAN but exited non-zero); it
+  // is intentionally NOT a normalized terminal status so it never colors red.
+  if (
+    String(value || '')
+      .trim()
+      .toLowerCase() === 'exit'
+  )
+    return 'Exited';
+  const status = normalizeTerminalStatus(value);
+  if (status === 'running') return 'Running';
+  if (status === 'completed') return 'Finished';
+  if (status === 'failed') return 'Failed';
+  if (status === 'cancelled') return 'Cancelled';
+  if (status === 'denied') return 'Denied';
+  return '';
+}
+
+export function resultTerminalStatus(value) {
+  return toolResultTerminalStatus(value);
+}
+
+const LEADING_STATUS_MARKER_LINE_RE = /^\[status:\s*[^\]]*\]\s*$/i;
+
+export function stripLeadingStatusMarkerLines(lines) {
+  const out = Array.isArray(lines) ? lines.slice() : [];
+  if (out.length > 0 && LEADING_STATUS_MARKER_LINE_RE.test(String(out[0] ?? '').trim())) out.shift();
+  return out;
+}
+
+export function stripLeadingStatusMarkerFromText(text) {
+  return stripLeadingStatusMarkerLines(String(text || '').split('\n')).join('\n');
+}
+
+export function shellResultElapsed(value) {
+  const match = String(value || '').match(/^\[elapsed:\s*(\d+)\s*ms\]/im);
+  if (!match) return '';
+  const elapsedMs = Number(match[1]);
+  return Number.isFinite(elapsedMs) && elapsedMs >= 1000 ? formatElapsed(elapsedMs) : '';
+}
+
+export function clampFailureCount(errorCount, groupCount, isError) {
+  const explicit = Number(errorCount);
+  if (Number.isFinite(explicit)) return Math.max(0, Math.min(groupCount, Math.floor(explicit)));
+  return isError ? groupCount : 0;
+}
+
+export function prefixElapsed(detail, elapsed = '') {
+  const text = String(detail || '').trim();
+  const time = String(elapsed || '').trim();
+  if (!time) return text;
+  // Unified convention: the elapsed time ALWAYS goes at the END, ` · ` separated.
+  // Guard against a double-append when the text already ends with the same time.
+  if (text?.endsWith(`· ${time}`)) return text;
+  return text ? `${text} · ${time}` : time;
+}
+
+export function mergeTerminalDetail(status, detail = '') {
+  const label = displayTerminalStatus(status);
+  const text = String(detail || '').trim();
+  if (!label) return text;
+  if (label === 'Finished' && text) return text;
+  if (!text) return label;
+  if (text.toLowerCase().startsWith(label.toLowerCase())) return text;
+  return `${label} · ${text}`;
+}

package/src/runtime/shared/tool-card-model.golden-cases.mjs

@@ -0,0 +1,208 @@
+/**
+ * Representative deriveToolCardModel inputs. Every case fixes nowMs so the
+ * derived model is deterministic; tool-card-model.golden.json holds the
+ * expected models and tool-card-model.test.mjs compares against it.
+ */
+const NOW_MS = 20000;
+
+// Git expectations are authored from the text contract rather than captured
+// from the model, so a rendering regression cannot bless its own output.
+export const GIT_GOLDEN_CASES = [
+  { result: '## main\n M a.txt\n', summary: '## main', status: 'completed' },
+  { result: '', summary: '(No Output)', status: 'completed' },
+  { result: '## git add a.txt\n\n## git status\n## main\nA  a.txt\n', summary: '## main', status: 'completed' },
+  { result: 'diff --git a/a.txt b/a.txt\n... [4 more lines omitted; raise output_limit or narrow the command]', summary: 'diff --git a/a.txt b/a.txt', status: 'completed' },
+  { result: 'exit 128\nfatal: missing ref\n', summary: 'Exit 128', status: 'failed' },
+  { result: '## git show missing\nexit 128\nfatal: missing\nerror: command failed: git show missing', summary: 'Exit 128', status: 'failed' },
+  { result: '{"ok":true,"clean":true}', summary: 'Ok', status: 'completed' },
+];
+
+const BACKGROUND_RUNNING =
+  'background task\ntask_id: t1\nsurface: shell\nstatus: running\nstarted: 2024-01-01T00:00:00Z\n\nbuilding…';
+const BACKGROUND_DONE =
+  '<task-notification>\n<task-id>t2</task-id>\n<status>completed</status>\n<exit-code>0</exit-code>\n<summary>Shell task completed (exit 0)</summary>\n<result>\nall good\nline2\n</result>\n</task-notification>';
+const BACKGROUND_FAILED = 'background task\ntask_id: t3\nsurface: web_search\nstatus: failed\nerror: boom\n';
+
+export const GOLDEN_CASES = [
+  {
+    id: 'shell-pending',
+    input: { name: 'shell', args: { command: 'npm test' }, completedCount: 0, startedAt: 1000, nowMs: NOW_MS },
+  },
+  {
+    id: 'shell-done',
+    input: {
+      name: 'shell',
+      args: { command: 'ls' },
+      result: '[elapsed: 2500 ms]\nfile-a\nfile-b',
+      startedAt: 1000,
+      completedAt: 5000,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'shell-exit-failure',
+    input: {
+      name: 'shell',
+      args: { command: 'false' },
+      result: '[status: failed]\nexit 1',
+      exitErrorCount: 1,
+      errorCount: 1,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'shell-verified-group',
+    input: {
+      name: 'shell',
+      args: { command: 'npm test', verifyShell: true },
+      count: 2,
+      completedCount: 2,
+      result: 'ok',
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'agent-spawn-pending',
+    input: {
+      name: 'agent',
+      args: { type: 'spawn', agent: 'worker', model: 'gpt-5', tag: 'lens-a' },
+      completedCount: 0,
+      startedAt: 1000,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'agent-response',
+    input: {
+      name: 'agent',
+      args: { type: 'send', agent: 'heavy-worker', status: 'completed' },
+      result: 'Here is the review summary.\nmore',
+      startedAt: 1000,
+      completedAt: 4000,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'agent-failed',
+    input: {
+      name: 'agent',
+      args: { type: 'spawn', agent: 'worker', status: 'failed', error: 'spawn refused' },
+      isError: true,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'agent-list',
+    input: { name: 'agent', args: { type: 'list' }, result: '(no agents or tasks)', nowMs: NOW_MS },
+  },
+  {
+    id: 'background-running',
+    input: {
+      name: 'shell',
+      args: { task_id: 't1', status: 'running', type: 'progress' },
+      result: BACKGROUND_RUNNING,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'background-response',
+    input: { name: 'shell', args: { task_id: 't2' }, result: BACKGROUND_DONE, nowMs: NOW_MS },
+  },
+  {
+    id: 'background-failed',
+    input: { name: 'web_search', args: { task_id: 't3' }, result: BACKGROUND_FAILED, isError: true, nowMs: NOW_MS },
+  },
+  {
+    id: 'load-tool',
+    input: {
+      name: 'load_tool',
+      args: { names: ['office', 'media'] },
+      result: JSON.stringify({ selected: { tools: { added: ['office'], already: ['media'] } } }),
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'skill-error',
+    input: { name: 'skill', args: { name: 'pdf' }, result: 'Failed to load', isError: true, nowMs: NOW_MS },
+  },
+  { id: 'skill-ok', input: { name: 'skill', args: { name: 'pdf' }, result: 'loaded', nowMs: NOW_MS } },
+  {
+    id: 'read',
+    input: { name: 'read', args: { file_path: 'C:/x/y.mjs' }, result: '1→line\n2→line', nowMs: NOW_MS },
+  },
+  { id: 'view-image', input: { name: 'view_image', args: { path: 'a.png' }, result: 'ok', nowMs: NOW_MS } },
+  {
+    id: 'web-search',
+    input: {
+      name: 'web_search',
+      args: { query: 'node test runner' },
+      result: 'Result 1\nResult 2',
+      startedAt: 1000,
+      completedAt: 3500,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'aggregate-pending',
+    input: {
+      aggregate: true,
+      categories: { read: 2, search: 1 },
+      count: 3,
+      completedCount: 1,
+      args: { categoryOrder: ['read', 'search'] },
+      startedAt: 1000,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'aggregate-done',
+    input: {
+      aggregate: true,
+      categories: { read: 2 },
+      doneCategories: { read: 2 },
+      count: 2,
+      completedCount: 2,
+      result: 'Loaded 2 files',
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'aggregate-loading-targets',
+    input: {
+      aggregate: true,
+      args: { loadingTargets: ['office', 'media'] },
+      count: 2,
+      completedCount: 2,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'grep-group-partial-failure',
+    input: {
+      name: 'grep',
+      args: { pattern: 'foo' },
+      count: 3,
+      completedCount: 3,
+      result: 'a\tb\r\nc',
+      errorCount: 1,
+      callErrorCount: 1,
+      nowMs: NOW_MS,
+    },
+  },
+  {
+    id: 'edit-error',
+    input: { name: 'edit', args: { file_path: 'x.mjs' }, isError: true, result: 'Error: no match', nowMs: NOW_MS },
+  },
+  {
+    id: 'agent-brief-truncated',
+    input: {
+      name: 'agent',
+      args: { type: 'spawn', agent: 'worker', status: 'failed', error: 'x'.repeat(120) },
+      result:
+        'Agent result\nstatus: failed\n\nThe worker failed after a very long explanation that keeps going and going',
+      isError: true,
+      nowMs: NOW_MS,
+    },
+    options: { maxResultChars: 30 },
+  },
+];