@xenosystem/agent-conversation 0.1.36 → 0.1.38

package/dist/components/agent/transcript/stepModel.js

@@ -0,0 +1,701 @@
+import { compactCommandPreview, isCommandToolCall } from '../toolCardDisplay.js';
+import { buildInlineDiffPreviewLines, countTextLines, deriveApprovalCardInfo, deriveEditorDiffStats, deriveFileToolPrimaryText, deriveTerminalToolOutput, deriveToolCallFileName, deriveToolCallFilePath, deriveToolDiffStats, formatToolDuration, humanizeToolName, isToolDisplayNoise, parseStructuredCommandContent, readToolStringParam, stripToolDisplayPrefix, toolCallLabel, } from '../toolCallDerive.js';
+const HIDDEN_TOOLS = new Set([
+    'toolsearch', 'tool_search', 'tool_describe', 'condensationrequesttool', 'condensation', 'secrets',
+    'waitformcpservers', 'listmcpresourcestool', 'list_mcp_resources', 'list_mcp_resource_templates',
+    'taskcreate', 'taskupdate', 'taskclear', 'taskget', 'tasklist', 'todowrite', 'write_todos', 'todo',
+]);
+/**
+ * The calls that mean "here is the plan — may I start?". They are the one permission whose subject
+ * is the conversation's plan rather than a path or a command, so they draw the plan row's card.
+ */
+const PLAN_APPROVAL_TOOLS = new Set([
+    'exitplanmode', 'exit_plan_mode', 'approveplan', 'approve_plan', 'planapproval', 'plan_approval',
+]);
+const SUBWORK_TOOLS = new Set([
+    'agent', 'task', 'delegate_task', 'subagent', 'subagents', 'spawn', 'create_thread', 'fork_thread',
+    'send_message_to_thread', 'handoff_thread', 'new_task', 'sendmessage', 'send_message',
+]);
+const MACHINE_ACTIONS = {
+    screenshot: { verb: 'Captured screen', glyph: 'scan-eye' },
+    capture_screen_context: { verb: 'Captured screen', glyph: 'scan-eye' },
+    zoom: { verb: 'Zoomed', glyph: 'scan-eye' },
+    left_click: { verb: 'Clicked', glyph: 'navigation' },
+    click: { verb: 'Clicked', glyph: 'navigation' },
+    right_click: { verb: 'Right-clicked', glyph: 'navigation' },
+    middle_click: { verb: 'Middle-clicked', glyph: 'navigation' },
+    double_click: { verb: 'Double-clicked', glyph: 'navigation' },
+    triple_click: { verb: 'Triple-clicked', glyph: 'navigation' },
+    left_click_drag: { verb: 'Dragged', glyph: 'navigation' },
+    drag: { verb: 'Dragged', glyph: 'navigation' },
+    mouse_move: { verb: 'Moved', glyph: 'navigation' },
+    move: { verb: 'Moved', glyph: 'navigation' },
+    type: { verb: 'Typed', glyph: 'feather' },
+    key: { verb: 'Pressed', glyph: 'hand' },
+    keypress: { verb: 'Pressed', glyph: 'hand' },
+    hold_key: { verb: 'Held', glyph: 'hand' },
+    scroll: { verb: 'Scrolled', glyph: 'arrow-left-right' },
+    wait: { verb: 'Waited', glyph: 'clock' },
+    // what the agent DID, not what the API is called: it looked at the windows that are open
+    // ...and the bench draws that look as an eye, not as the window it looked at
+    list_apps: { verb: 'Looking up windows', glyph: 'eye' },
+    list_windows: { verb: 'Looking up windows', glyph: 'eye' },
+    window_state: { verb: 'Read the window', glyph: 'app-window' },
+    launch: { verb: 'Opened', glyph: 'app-window' },
+};
+const BROWSER_ACTIONS = {
+    navigate: { verb: 'Opened', glyph: 'app-window' },
+    goto: { verb: 'Opened', glyph: 'app-window' },
+    back: { verb: 'Went back', glyph: 'app-window' },
+    click: { verb: 'Clicked', glyph: 'navigation' },
+    type: { verb: 'Typed', glyph: 'feather' },
+    press: { verb: 'Pressed', glyph: 'hand' },
+    key: { verb: 'Pressed', glyph: 'hand' },
+    scroll: { verb: 'Scrolled', glyph: 'arrow-left-right' },
+    snapshot: { verb: 'Captured page', glyph: 'scan-eye' },
+    vision: { verb: 'Captured page', glyph: 'scan-eye' },
+    screenshot: { verb: 'Captured page', glyph: 'scan-eye' },
+    console: { verb: 'Read console', glyph: 'terminal' },
+    dialog: { verb: 'Answered dialog', glyph: 'help' },
+};
+function normalizeName(toolName) {
+    return (toolName || '').trim().toLowerCase();
+}
+function param(toolCall, keys) {
+    return readToolStringParam(toolCall.params, keys);
+}
+function numberParam(toolCall, keys) {
+    for (const key of keys) {
+        const value = toolCall.params?.[key];
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+        if (typeof value === 'string' && /^\d+$/.test(value.trim()))
+            return Number.parseInt(value, 10);
+    }
+    return null;
+}
+function fileName(path) {
+    const parts = path.replace(/[\\/]+$/, '').split(/[/\\]/).filter(Boolean);
+    return parts[parts.length - 1] || path;
+}
+function formatCount(count, noun) {
+    return `${count.toLocaleString('en-US')} ${noun}${count === 1 ? '' : 's'}`;
+}
+function domainOf(url) {
+    try {
+        return new URL(url).hostname.replace(/^www\./, '');
+    }
+    catch {
+        return url;
+    }
+}
+function resultText(toolCall) {
+    return isToolDisplayNoise(toolCall.result) ? '' : (toolCall.result || '').trim();
+}
+function outcomeTone(toolCall) {
+    if (toolCall.outcome === 'cancelled')
+        return 'stop';
+    if (toolCall.outcome === 'failed' || toolCall.success === false)
+        return 'bad';
+    return 'none';
+}
+/** A settled row that failed says so in its result unless the result already carries the exit. */
+function failedResult(toolCall, result) {
+    if (toolCall.status !== 'done')
+        return result;
+    if (toolCall.outcome === 'cancelled')
+        return 'cancelled';
+    if ((toolCall.outcome === 'failed' || toolCall.success === false) && !/^exit\b/.test(result))
+        return 'failed';
+    return result;
+}
+/** The hunks of a diff, split where the changed lines are not contiguous. */
+export function diffHunks(diff, id) {
+    const lines = buildInlineDiffPreviewLines(diff, 400);
+    const hunks = [];
+    let current = [];
+    const flush = () => {
+        if (!current.length)
+            return;
+        const first = current.find((line) => line.kind !== 'ellipsis');
+        const start = first?.newLineNumber ?? first?.oldLineNumber ?? 0;
+        const changed = current.filter((line) => line.kind === 'added' || line.kind === 'removed').length;
+        hunks.push({ id: `${id}:${hunks.length}`, header: `@@ ${start} · ${changed} line${changed === 1 ? '' : 's'}`, lines: current });
+        current = [];
+    };
+    for (const line of lines) {
+        if (line.kind === 'ellipsis') {
+            flush();
+            continue;
+        }
+        current.push(line);
+    }
+    flush();
+    return hunks;
+}
+/** An edit expressed as old/new strings, with no diff object — the hunk is the two strings. */
+function hunksFromReplacement(toolCall) {
+    const oldString = typeof toolCall.params?.old_string === 'string' ? toolCall.params.old_string : '';
+    const newString = typeof toolCall.params?.new_string === 'string' ? toolCall.params.new_string : '';
+    if (!oldString && !newString)
+        return [];
+    const lines = [
+        ...oldString.split(/\r?\n/).map((text) => ({ kind: 'removed', text })),
+        ...newString.split(/\r?\n/).map((text) => ({ kind: 'added', text })),
+    ];
+    return [{ id: `${toolCall.id}:0`, header: `@@ ${lines.length} line${lines.length === 1 ? '' : 's'}`, lines }];
+}
+function parseGrepMatches(text) {
+    const groups = new Map();
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trimEnd();
+        if (!line)
+            continue;
+        // path:line:text — the path may carry a drive letter, so the first colon after a single letter is not a separator
+        const match = line.match(/^((?:[A-Za-z]:)?[^:\n]+?):(\d+):(.*)$/);
+        if (!match)
+            continue;
+        const [, file, n, content] = match;
+        const list = groups.get(file) || [];
+        list.push({ n: Number.parseInt(n, 10).toLocaleString('en-US'), text: content.trim() });
+        groups.set(file, list);
+    }
+    return [...groups.entries()].map(([file, lines]) => ({ file, lines }));
+}
+function parseSources(text) {
+    const items = [];
+    const seen = new Set();
+    const blocks = text.split(/\n\s*\n/);
+    for (const block of blocks) {
+        const url = block.match(/https?:\/\/[^\s)>\]"']+/)?.[0];
+        if (!url || seen.has(url))
+            continue;
+        seen.add(url);
+        const titleLine = block.split(/\r?\n/).map((line) => line.trim()).find((line) => line && !line.includes(url));
+        const title = (titleLine || '').replace(/^(?:title:|\d+[.)]|[-*•])\s*/i, '').trim() || domainOf(url);
+        items.push({ title, url, domain: domainOf(url) });
+    }
+    return items;
+}
+/**
+ * The SDK reports a backgrounded command by naming the task in the tool's own output; the store
+ * already parses the same sentence to build `sessionUi.backgroundTasks`. Reading it here keeps the
+ * row and the tray describing ONE task rather than two views that can disagree.
+ */
+function backgroundTaskIdOf(output) {
+    const match = output.match(/(?:Background task started|Command moved to background):\s*([^\s\r\n]+)/i);
+    return match?.[1]?.trim() || null;
+}
+function commandStep(toolCall, live) {
+    const command = param(toolCall, ['command']);
+    const parsed = parseStructuredCommandContent(toolCall.result || '');
+    const duration = formatToolDuration(toolCall.durationMs);
+    const taskId = backgroundTaskIdOf(toolCall.result || '');
+    if (taskId) {
+        // Not "Ran": nothing has finished. The row stays a live mark until the task reports an ending,
+        // and the result names the handle, because the id is what Output and Stop act on.
+        return {
+            family: 'shell',
+            glyph: 'terminal',
+            verb: 'Started',
+            object: command ? compactCommandPreview(command) : 'a command',
+            objectMono: true,
+            result: `in the background · ${taskId}`,
+            resultLate: false,
+            tone: outcomeTone(toolCall),
+            live: true,
+            background: { taskId, action: 'started' },
+            detail: parsed.stdout || parsed.stderr
+                ? { kind: 'output', text: [parsed.stdout, parsed.stderr].filter(Boolean).join('\n'), streaming: true, foot: { cwd: parsed.cwd || toolCall.cwd || undefined } }
+                : null,
+        };
+    }
+    const exit = parsed.exit || (toolCall.status === 'done' && toolCall.success === true ? 'exit 0' : '');
+    const result = [exit, duration].filter(Boolean).join(' · ');
+    const output = [parsed.stdout, parsed.stderr].filter(Boolean).join('\n');
+    const rawOutput = !parsed.command && !parsed.stdout && !parsed.stderr ? resultText(toolCall) : output;
+    const failed = toolCall.success === false || /^exit [1-9]/.test(exit);
+    return {
+        family: 'shell',
+        glyph: 'terminal',
+        verb: live ? 'Running' : 'Ran',
+        object: command ? compactCommandPreview(command) : 'a command',
+        objectMono: true,
+        result: failedResult(toolCall, result),
+        resultLate: true,
+        tone: failed ? 'bad' : outcomeTone(toolCall),
+        detail: rawOutput || live
+            ? { kind: 'output', text: rawOutput, error: parsed.error || undefined, streaming: live, foot: { duration: duration || undefined, exit: exit || undefined, cwd: parsed.cwd || toolCall.cwd || undefined } }
+            : null,
+    };
+}
+function fileStep(toolCall, name, live) {
+    const path = deriveToolCallFilePath(toolCall);
+    const displayName = path ? fileName(path) : deriveToolCallFileName(toolCall);
+    const text = resultText(toolCall);
+    if (name === 'read' || name === 'read_file') {
+        const offset = numberParam(toolCall, ['offset', 'start_line', 'startLine']);
+        const limit = numberParam(toolCall, ['limit', 'end_line', 'endLine']);
+        const ranged = offset !== null && limit !== null;
+        const from = ranged ? offset : 1;
+        const to = ranged ? (name === 'read' ? offset + limit - 1 : limit) : null;
+        const lines = text ? text.split(/\r?\n/) : [];
+        const shown = lines.slice(0, 60);
+        return {
+            family: 'files',
+            glyph: 'file',
+            verb: live ? 'Reading' : 'Read',
+            object: displayName,
+            objectMono: true,
+            result: failedResult(toolCall, ranged && to !== null ? `lines ${from}–${to}` : lines.length ? formatCount(lines.length, 'line') : ''),
+            resultLate: false,
+            detail: shown.length ? { kind: 'slice', from, lines: shown, more: lines.length - shown.length } : null,
+            filePath: path,
+        };
+    }
+    const primary = deriveFileToolPrimaryText(toolCall);
+    const created = primary === 'Created file' || (!toolCall.diff && (name === 'write' || name === 'write_file' || name === 'writefiles'));
+    const stats = deriveToolDiffStats(toolCall);
+    const hunks = toolCall.diff ? diffHunks(toolCall.diff, toolCall.id) : hunksFromReplacement(toolCall);
+    const contentLines = typeof toolCall.params?.content === 'string' ? countTextLines(toolCall.params.content) : 0;
+    const result = stats && !created
+        ? `+${stats.added} −${stats.removed}`
+        : created && (stats?.added || contentLines)
+            ? formatCount(stats?.added || contentLines, 'line')
+            : '';
+    return {
+        family: 'files',
+        glyph: created ? 'plus' : 'edit',
+        verb: live ? (created ? 'Creating' : 'Editing') : (created ? 'Created' : 'Edited'),
+        object: displayName,
+        objectMono: true,
+        result: failedResult(toolCall, result),
+        resultLate: false,
+        detail: hunks.length ? { kind: 'diff', diff: toolCall.diff ?? null, hunks, path } : null,
+        filePath: path,
+        diffStats: stats,
+    };
+}
+function searchStep(toolCall, name, live) {
+    const text = resultText(toolCall);
+    if (name === 'glob' || name === 'file_search' || name === 'find_files' || name === 'list_files' || name === 'list_directory') {
+        const pattern = param(toolCall, ['pattern', 'glob', 'query', 'path']);
+        const paths = text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !/^no files/i.test(line));
+        const listing = name === 'list_files' || name === 'list_directory';
+        return {
+            family: listing ? 'files' : 'search',
+            glyph: listing ? 'folder' : 'search',
+            verb: live ? (listing ? 'Listing' : 'Finding') : (listing ? 'Listed' : 'Found'),
+            object: pattern || (listing ? 'a directory' : 'files'),
+            objectMono: true,
+            result: failedResult(toolCall, paths.length ? formatCount(paths.length, listing ? 'entr' : 'file').replace('entrs', 'entries').replace(/entr$/, 'entry') : ''),
+            resultLate: false,
+            detail: paths.length ? { kind: 'list', items: paths.slice(0, 80).map((p) => ({ label: fileName(p), where: p !== fileName(p) ? p.slice(0, p.length - fileName(p).length).replace(/[\\/]$/, '') : undefined, path: p })) } : null,
+        };
+    }
+    const pattern = param(toolCall, ['pattern', 'query', 'regex']);
+    const where = param(toolCall, ['path', 'directory', 'cwd']);
+    const groups = parseGrepMatches(text);
+    const matchCount = groups.reduce((sum, group) => sum + group.lines.length, 0);
+    const result = matchCount
+        ? `${formatCount(matchCount, 'match').replace('matchs', 'matches')} · ${formatCount(groups.length, 'file')}`
+        : text && /no matches|0 matches/i.test(text) ? 'no matches' : '';
+    return {
+        family: 'search',
+        glyph: 'search',
+        verb: live ? 'Searching' : 'Searched',
+        object: pattern ? `“${pattern}”${where ? ` in ${where}` : ''}` : 'the project',
+        objectMono: true,
+        result: failedResult(toolCall, result),
+        resultLate: false,
+        detail: groups.length ? { kind: 'matches', groups } : text ? { kind: 'prose', text } : null,
+    };
+}
+function webStep(toolCall, name, live) {
+    const text = resultText(toolCall);
+    const isSearch = name.includes('search');
+    if (isSearch) {
+        const query = param(toolCall, ['query', 'q', 'search']);
+        const citations = toolCall.webContext?.evidence.citations;
+        const items = citations?.length
+            ? citations.map((citation) => ({ title: citation.title || domainOf(citation.url), url: citation.url, domain: domainOf(citation.url) }))
+            : parseSources(text);
+        return {
+            family: 'web',
+            glyph: 'globe',
+            verb: live ? 'Searching the web' : 'Searched the web',
+            object: query || 'the web',
+            objectMono: false,
+            result: failedResult(toolCall, items.length ? formatCount(items.length, 'result') : ''),
+            resultLate: false,
+            detail: items.length ? { kind: 'sources', items } : text ? { kind: 'prose', text } : null,
+        };
+    }
+    const url = param(toolCall, ['url', 'href']) || toolCall.webContext?.evidence.finalUrl || toolCall.webContext?.evidence.sourceUrl || '';
+    return {
+        family: 'web',
+        glyph: 'globe',
+        verb: live ? 'Reading' : 'Read',
+        object: url ? domainOf(url) + (url.replace(/^https?:\/\/[^/]+/, '').replace(/\/$/, '') || '') : 'a page',
+        objectMono: true,
+        result: failedResult(toolCall, ''),
+        resultLate: false,
+        detail: text ? { kind: 'prose', text } : null,
+    };
+}
+/**
+ * A step through a connector — an MCP server, a XENO connection. The row says what the agent DID
+ * in the service's terms, not what the API call was called: `Read · Gmail · from Lil Bro · 3 threads`,
+ * never `Asked · gmail · list threads`.
+ *
+ *   verb    from the tool's shape: list/get/read/search/find → Read; send/post/reply → Sent;
+ *           create/add → Created; update/set → Updated; delete/remove → Deleted.
+ *   object  the service, title-cased, then the params that narrow the read (`from Lil Bro`).
+ *   result  a READ answers with rows, and the row counts them in the tool's own noun
+ *           (`list_threads` → threads); anything else answers with the fact that it happened.
+ *   detail  the rows, one per line, split into what and when on the last ` — `.
+ */
+function connectorStep(toolCall, input) {
+    const { service, tool, live, text, merge } = input;
+    const shape = tool.match(/^(list|get|read|search|find|fetch|query|send|post|reply|create|add|update|set|delete|remove)(?:_(.+))?$/);
+    const action = shape?.[1] ?? '';
+    const noun = (shape?.[2] ?? tool).replace(/_/g, ' ');
+    const reading = /^(list|get|read|search|find|fetch|query)$/.test(action) || !action;
+    const verb = reading ? (live ? 'Reading' : 'Read')
+        : /^(send|post|reply)$/.test(action) ? (live ? 'Sending' : 'Sent')
+            : /^(create|add)$/.test(action) ? (live ? 'Creating' : 'Created')
+                : /^(update|set)$/.test(action) ? (live ? 'Updating' : 'Updated')
+                    : (live ? 'Deleting' : 'Deleted');
+    const title = service.charAt(0).toUpperCase() + service.slice(1);
+    // the params that narrow it, as phrases: `from Lil Bro`, `in Inbox`, `“demo”`
+    const params = toolCall.params && typeof toolCall.params === 'object' ? toolCall.params : {};
+    const phrases = Object.entries(params)
+        .filter(([, value]) => typeof value === 'string' && value.trim())
+        .slice(0, 2)
+        .map(([key, value]) => (/^(query|q|search|text)$/.test(key) ? `“${String(value)}”` : `${key.replace(/_/g, ' ')} ${String(value)}`));
+    const object = [title, ...phrases].join(' · ');
+    const rows = reading ? text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean) : [];
+    const items = rows.slice(0, 80).map((line) => {
+        const split = line.lastIndexOf(' — ');
+        return split > 0 ? { label: line.slice(0, split).trim(), where: line.slice(split + 3).trim() } : { label: line };
+    });
+    const singular = noun.replace(/s$/, '');
+    return merge({
+        family: 'connectors',
+        glyph: 'link',
+        verb,
+        object,
+        objectMono: true,
+        result: failedResult(toolCall, rows.length ? formatCount(rows.length, singular) : ''),
+        detail: items.length ? { kind: 'list', items } : text ? { kind: 'prose', text } : null,
+    });
+}
+function askFor(toolCall, name) {
+    const permission = toolCall.permissionRequest;
+    if (permission) {
+        const info = deriveApprovalCardInfo(toolCall, permission);
+        const status = permission.status === 'pending' ? 'pending' : permission.status === 'granted' ? 'yes' : permission.status === 'denied' ? 'no' : 'cancelled';
+        const isCommand = isCommandToolCall(toolCall) || name === 'terminalwriteinput';
+        const isDirectory = !!permission.directory && !/^__.*__$/.test(permission.directory) && !isCommand;
+        const isApp = name === 'openapp' || name === 'open_app';
+        if (isDirectory || isApp) {
+            const subject = isApp ? (param(toolCall, ['app', 'appPath']) || 'an app') : permission.directory;
+            return {
+                kind: 'grant',
+                status,
+                subject: isApp ? 'app' : 'folder',
+                title: `Wants to use ${isApp ? subject : 'a folder'}`,
+                what: subject,
+                // how far the yes reaches — said beside the subject, where the person is deciding. A machine
+                // grant is scoped the way the host scopes it (`AgentMachineScope`: it dies with the SESSION);
+                // a folder is the conversation's for as long as the conversation lasts.
+                whatScope: isApp ? 'this session' : 'this conversation',
+                // what a window grant actually permits, named: seeing it, clicking, typing, keys — and its end
+                body: isApp
+                    ? `It can see the ${subject} window, click, type and press keys in it. Nothing outside it, and nothing after this session.`
+                    : 'It can read and write inside this folder for the rest of this conversation. Nothing outside it.',
+                bodyMono: false,
+                mainLabel: isApp ? 'Allow for this session' : 'Allow for this conversation',
+                verdict: status === 'yes' ? `Allowed — it can use ${subject} until this ${isApp ? 'session' : 'conversation'} ends.` : status === 'no' ? 'Refused — it cannot use it.' : status === 'cancelled' ? 'Cancelled.' : undefined,
+                permission,
+                canAllowAlways: !!permission.allowAlwaysOptionId || !!permission.directory,
+                canDenyAlways: !!permission.rejectAlwaysOptionId,
+            };
+        }
+        /*
+         * The PLAN is the ask: the agent has written the steps and wants a go before it starts any of
+         * them (bench `.xrow.plan.ask`). The steps themselves are deliberately NOT read from this call's
+         * params — the card shows the conversation's plan, the same list the plan row and the tray read,
+         * so the three can never disagree about what was approved.
+         */
+        if (PLAN_APPROVAL_TOOLS.has(name)) {
+            return {
+                kind: 'plan',
+                status,
+                title: 'Plan — needs your go',
+                what: permission.directory || 'In the project, on this machine',
+                whatScope: 'this turn',
+                bodyMono: false,
+                mainLabel: 'Go',
+                verdict: status === 'yes' ? 'Go.' : status === 'no' ? 'Refused — nothing was started.' : status === 'cancelled' ? 'Cancelled — nothing was started.' : undefined,
+                permission,
+                canAllowAlways: false,
+                canDenyAlways: false,
+            };
+        }
+        const isWrite = name.startsWith('write') || name.startsWith('edit');
+        const isSend = /send|message|mail|post/.test(name);
+        return {
+            kind: 'approve',
+            whatScope: 'once',
+            status,
+            title: isWrite ? 'Wants to write a file' : isSend ? 'Wants to send' : 'Wants to run a command',
+            scope: 'Ask first',
+            what: permission.path && !isCommand ? permission.path : 'In the project, on this machine',
+            body: info.body,
+            bodyMono: true,
+            mainLabel: isWrite ? 'Write' : isSend ? 'Send' : info.runLabel,
+            verdict: status === 'yes' ? 'Approved — it ran once, in the project.' : status === 'no' ? 'Refused — it did not run.' : status === 'cancelled' ? 'Cancelled — it did not run.' : undefined,
+            permission,
+            canAllowAlways: !!permission.allowAlwaysOptionId || !!permission.directory,
+            canDenyAlways: !!permission.rejectAlwaysOptionId,
+        };
+    }
+    const askUser = toolCall.askUserRequest;
+    if (askUser) {
+        const status = askUser.status === 'pending' ? 'pending' : askUser.status === 'answered' ? 'yes' : 'cancelled';
+        const answer = askUser.selectedOption || askUser.answer;
+        return {
+            kind: 'question',
+            status,
+            title: 'Wants to know',
+            what: askUser.question,
+            body: askUser.context,
+            bodyMono: false,
+            options: askUser.options?.length ? askUser.options : undefined,
+            mainLabel: 'Answer',
+            verdict: status === 'yes' && answer ? `Answered — ${answer}` : status === 'cancelled' ? 'Cancelled — no answer.' : undefined,
+            answer,
+            askUser,
+            canAllowAlways: false,
+            canDenyAlways: false,
+        };
+    }
+    return null;
+}
+/**
+ * ONE row from ONE tool call. The family decides the glyph and the verb; the tool call's params,
+ * result and diff decide the object, the result and what opens under it.
+ */
+export function deriveStepRow(toolCall) {
+    const name = normalizeName(toolCall.toolName);
+    const live = toolCall.status === 'running' && !toolCall.permissionRequest && !toolCall.askUserRequest;
+    const ask = askFor(toolCall, name);
+    const base = {
+        id: toolCall.id,
+        family: 'housekeeping',
+        glyph: 'zap',
+        verb: humanizeToolName(toolCall.toolName),
+        object: '',
+        objectMono: false,
+        result: '',
+        resultLate: false,
+        tone: outcomeTone(toolCall),
+        live: live || ask?.status === 'pending',
+        hidden: HIDDEN_TOOLS.has(name),
+        detail: null,
+        ask,
+        filePath: null,
+        diffStats: null,
+        background: null,
+        toolCall,
+    };
+    const text = resultText(toolCall);
+    const merge = (part) => ({ ...base, ...part });
+    if (isCommandToolCall(toolCall))
+        return merge(commandStep(toolCall, live));
+    switch (name) {
+        case 'read':
+        case 'read_file':
+        case 'write':
+        case 'write_file':
+        case 'writefiles':
+        case 'edit':
+        case 'edit_file':
+        case 'multiedit':
+        case 'apply_patch':
+        case 'replace_in_file':
+        case 'write_to_file':
+        case 'create_file':
+        case 'str_replace_editor':
+            return merge(fileStep(toolCall, name, live));
+        case 'delete_file':
+        case 'delete':
+            return merge({ family: 'files', glyph: 'trash', verb: live ? 'Deleting' : 'Deleted', object: fileName(param(toolCall, ['path', 'file_path']) || 'a file'), objectMono: true, tone: 'bad' }); // a deletion's marker is red whether or not it succeeded — the reference says so
+        case 'undo_edit':
+            return merge({ family: 'files', glyph: 'refresh', verb: 'Reverted', object: fileName(param(toolCall, ['path', 'file_path']) || 'a file'), objectMono: true });
+        case 'glob':
+        case 'grep':
+        case 'file_search':
+        case 'find_files':
+        case 'list_files':
+        case 'list_directory':
+        case 'search_files':
+        case 'grep_search':
+        case 'codebase_search':
+        case 'search_file_content':
+            return merge(searchStep(toolCall, name, live));
+        case 'websearch':
+        case 'web_search':
+        case 'google_web_search':
+        case 'x_search':
+        case 'web_fetch':
+        case 'webfetch':
+        case 'fetch':
+        case 'web_extract':
+        case 'read_web_page':
+            return merge(webStep(toolCall, name, live));
+        case 'taskoutput':
+        case 'task_output':
+        case 'read_task_output':
+        case 'bashoutput': {
+            const taskId = param(toolCall, ['task_id', 'taskId', 'id', 'bash_id']);
+            return merge({
+                family: 'shell', glyph: 'terminal', verb: live ? 'Reading' : 'Read', object: taskId ? `background ${taskId}` : 'a background run', objectMono: true,
+                result: failedResult(toolCall, text ? formatCount(countTextLines(text), 'line') : ''),
+                ...(taskId ? { background: { taskId, action: 'read' } } : {}),
+                detail: text ? { kind: 'output', text, streaming: live, foot: {} } : null,
+            });
+        }
+        case 'taskstop':
+        case 'task_stop':
+        case 'killbash':
+        case 'kill_bash': {
+            const taskId = param(toolCall, ['task_id', 'taskId', 'id', 'bash_id', 'shell_id']);
+            return merge({
+                family: 'shell', glyph: 'stop', verb: live ? 'Stopping' : 'Stopped', object: taskId ? `background ${taskId}` : 'a background run', objectMono: true,
+                result: failedResult(toolCall, toolCall.status === 'done' ? 'stopped' : ''),
+                ...(taskId ? { background: { taskId, action: 'stopped' } } : {}),
+                detail: text ? { kind: 'output', text, streaming: false, foot: {} } : null,
+            });
+        }
+        case 'terminalwriteinput': {
+            const output = deriveTerminalToolOutput(toolCall);
+            return merge({ family: 'shell', glyph: 'terminal', verb: live ? 'Typing into' : 'Typed into', object: `terminal${output?.terminalId ? ` ${output.terminalId}` : ''}`, objectMono: true, result: failedResult(toolCall, ''), detail: output ? { kind: 'output', text: output.output, streaming: live, foot: { cwd: output.cwd } } : null });
+        }
+        case 'terminalreadoutput':
+        case 'terminallist': {
+            const output = deriveTerminalToolOutput(toolCall);
+            return merge({ family: 'shell', glyph: 'terminal', verb: live ? 'Reading' : 'Read', object: 'terminal output', objectMono: false, result: failedResult(toolCall, output ? formatCount(countTextLines(output.output), 'line') : ''), detail: output ? { kind: 'output', text: output.output, streaming: live, foot: { cwd: output.cwd } } : null });
+        }
+        case 'openapp':
+        case 'open_app': {
+            const app = param(toolCall, ['app', 'appPath', 'name']);
+            // the bench's rail marks a grant with a lock — the turn is held on the answer; the window itself is named on the card
+            return merge({ family: 'machine', glyph: toolCall.permissionRequest ? 'lock' : 'app-window', verb: live ? 'Opening' : 'Opened', object: app ? fileName(app) : 'an app', objectMono: false, result: failedResult(toolCall, '') });
+        }
+        case 'choosedirectory': {
+            const directory = param(toolCall, ['directory', 'path']) || toolCall.artifacts?.find((artifact) => artifact.type === 'directory')?.value || '';
+            const chooseDirectoryId = param(toolCall, ['chooseDirectoryId']);
+            if (live && chooseDirectoryId && !ask) {
+                // the folder picker: a grant the person gives by choosing, not by allowing
+                return merge({ family: 'person', glyph: 'folder', verb: 'Asking for', object: 'a folder', objectMono: false, live: true, ask: { kind: 'grant', status: 'pending', title: 'Wants a folder', scope: 'this conversation', what: 'A folder it can work in', body: 'Pick the folder this conversation may read and write. Nothing outside it.', bodyMono: false, mainLabel: 'Choose folder', canAllowAlways: false, canDenyAlways: false, host: { kind: 'choose-directory', chooseDirectoryId } } });
+            }
+            return merge({ family: 'person', glyph: 'folder', verb: live ? 'Choosing' : 'Chose', object: directory || 'a folder', objectMono: true, result: failedResult(toolCall, '') });
+        }
+        case 'chooseworkspaceplacement': {
+            const workspacePlacementId = param(toolCall, ['workspacePlacementId']);
+            if (live && workspacePlacementId && !ask) {
+                return merge({ family: 'person', glyph: 'folder', verb: 'Asking', object: 'where this conversation should live', objectMono: false, live: true, ask: { kind: 'question', status: 'pending', title: 'Wants to know', what: 'Where should this conversation live?', bodyMono: false, mainLabel: 'Choose', canAllowAlways: false, canDenyAlways: false, host: { kind: 'workspace-placement', workspacePlacementId } } });
+            }
+            return merge({ family: 'housekeeping', glyph: 'folder', verb: 'Workspace', object: stripToolDisplayPrefix(toolCall.summary && !isToolDisplayNoise(toolCall.summary) ? toolCall.summary : toolCallLabel(toolCall.toolName, toolCall.params)), objectMono: false, result: failedResult(toolCall, '') });
+        }
+        case 'workspaceselection':
+        case 'xenoworkspacemanage':
+            return merge({ family: 'housekeeping', glyph: 'folder', verb: 'Workspace', object: stripToolDisplayPrefix(toolCall.summary && !isToolDisplayNoise(toolCall.summary) ? toolCall.summary : toolCallLabel(toolCall.toolName, toolCall.params)), objectMono: false, result: failedResult(toolCall, '') });
+        case 'askuser':
+        case 'ask_user':
+        case 'askuserquestion':
+        case 'request_user_input':
+        case 'ask_followup_question':
+        case 'clarify':
+            return merge({ family: 'person', glyph: 'help', verb: ask?.status === 'pending' ? 'Asking' : ask?.status === 'yes' ? 'You said' : 'Asked', object: ask?.status === 'yes' && ask.answer ? ask.answer : (toolCall.askUserRequest?.question || param(toolCall, ['question', 'prompt']) || ''), objectMono: false });
+        case 'exitplanmode':
+        case 'exit_plan_mode':
+        case 'approveplan':
+        case 'approve_plan':
+        case 'planapproval':
+        case 'plan_approval':
+            // the head is written by the row, from the plan itself — the count belongs to the list, not to this call
+            return merge({ family: 'plan', glyph: 'list', verb: 'Planned', object: '', objectMono: false });
+        case 'think':
+        case 'thinking':
+            return merge({ family: 'plan', glyph: 'brain', verb: 'Thought', object: '', objectMono: false, detail: text ? { kind: 'prose', text } : null });
+        case 'save_memory':
+        case 'memory':
+        case 'remember':
+            return merge({ family: 'plan', glyph: 'bookmark', verb: 'Remembered', object: `“${param(toolCall, ['fact', 'content', 'text', 'memory']) || text}”`, objectMono: false });
+        case 'create_goal':
+        case 'update_goal':
+            return merge({ family: 'plan', glyph: 'target', verb: name === 'create_goal' ? 'Set goal' : 'Updated goal', object: param(toolCall, ['goal', 'objective', 'text', 'title']), objectMono: false });
+        case 'croncreate':
+        case 'cron':
+        case 'schedule':
+        case 'schedulewakeup':
+        case 'automation_update':
+            return merge({ family: 'time', glyph: 'calendar', verb: 'Scheduled', object: param(toolCall, ['name', 'title', 'prompt', 'schedule', 'cron']) || text, objectMono: false });
+        case 'view_image':
+        case 'vision_analyze':
+            return merge({ family: 'media', glyph: 'image', verb: live ? 'Looking at' : 'Looked at', object: fileName(param(toolCall, ['path', 'file_path', 'image']) || 'an image'), objectMono: true });
+        case 'image_generate':
+        case 'video_generate':
+        case 'text_to_speech':
+        case 'tts':
+        case 'music_generate':
+            return merge({ family: 'media', glyph: name === 'text_to_speech' || name === 'tts' ? 'waves' : 'image', verb: live ? 'Generating' : 'Generated', object: name.replace(/_generate$/, '').replace('text_to_speech', 'speech').replace('tts', 'speech'), objectMono: false });
+        default:
+            break;
+    }
+    if (SUBWORK_TOOLS.has(name)) {
+        const brief = param(toolCall, ['prompt', 'description', 'brief', 'task', 'message', 'instruction']);
+        return merge({ family: 'subwork', glyph: 'bot', verb: live ? 'Delegating' : 'Delegated', object: brief, objectMono: false, result: failedResult(toolCall, toolCall.status === 'done' ? 'done' : ''), detail: text ? { kind: 'prose', text } : null });
+    }
+    if (name.startsWith('browser_') || name.startsWith('browser')) {
+        const action = name.replace(/^browser_?/, '');
+        const entry = BROWSER_ACTIONS[action];
+        const target = param(toolCall, ['url', 'selector', 'ref', 'text', 'key', 'element']);
+        return merge({ family: 'browser', glyph: entry?.glyph || 'app-window', verb: entry?.verb || humanizeToolName(action || 'browser'), object: target, objectMono: true, result: failedResult(toolCall, '') });
+    }
+    if (MACHINE_ACTIONS[name] || name === 'computer' || name === 'computer_use') {
+        const action = MACHINE_ACTIONS[name] ? name : param(toolCall, ['action']);
+        const entry = MACHINE_ACTIONS[action];
+        const target = param(toolCall, ['text', 'key', 'coordinate', 'app', 'direction']);
+        /*
+         * A look at the machine answers with what it FOUND, and the row says so: one window is named,
+         * several are counted. Every other action's result is the fact that it happened, which the row
+         * already carries in its verb.
+         */
+        const windows = /^list_(apps|windows)$/.test(action) ? text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean) : [];
+        const found = windows.length === 1 ? `1 ${windows[0]} window` : windows.length ? `${windows.length} windows` : '';
+        // Only embedded raster evidence is renderable here. Never fetch a URL found in tool output
+        // (or render an SVG payload); those require the host's asset/access policy.
+        const frame = /^(?:screenshot|capture_screen_context|zoom)$/.test(action)
+            ? text.trim().match(/^data:image\/(?:png|jpeg|webp);base64,[A-Za-z0-9+/=\r\n]+$/)?.[0] : undefined;
+        return merge({ family: 'machine', glyph: entry?.glyph || 'monitor', verb: entry?.verb || humanizeToolName(action || 'Acted'), object: target, objectMono: !!param(toolCall, ['text']), result: failedResult(toolCall, found), detail: frame ? { kind: 'frames', frames: [{ src: frame, alt: 'Captured screen' }] } : null });
+    }
+    const mcp = name.match(/^mcp__([^_]+(?:_[^_]+)*?)__(.+)$/);
+    if (mcp) {
+        const [, server, tool] = mcp;
+        return connectorStep(toolCall, { service: server, tool: tool, live, text, merge });
+    }
+    const app = name.match(/^([a-z0-9-]+)__([a-z0-9]+)_([a-z0-9_]+)$/);
+    if (app) {
+        const [, product, domain, verb] = app;
+        return merge({ family: 'apps', glyph: 'zap', verb: `In ${product.charAt(0).toUpperCase()}${product.slice(1)}`, object: `${domain} · ${verb.replace(/_/g, ' ')}`, objectMono: false, result: failedResult(toolCall, ''), detail: text ? { kind: 'prose', text } : null });
+    }
+    const label = toolCall.summary && !isToolDisplayNoise(toolCall.summary)
+        ? stripToolDisplayPrefix(toolCall.summary)
+        : stripToolDisplayPrefix(toolCallLabel(toolCall.toolName, toolCall.params));
+    return merge({ object: label === base.verb ? '' : label, result: failedResult(toolCall, ''), detail: text ? { kind: 'prose', text } : null });
+}
+//# sourceMappingURL=stepModel.js.map