@vale-dinap/lucidly 0.0.0-stage → 0.2.0

package/dist/adapters/claude-code.js

@@ -0,0 +1,367 @@
+import { PLANNING_TOOLS, summarizeTool } from "./claude-tools.js";
+const REJECTED = /doesn't want to (?:proceed|take this action)|user rejected|tool use was rejected|permission to use .* (?:was )?denied/i;
+function blockText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return content == null ? '' : JSON.stringify(content);
+    return content
+        .map((b) => (b?.type === 'text' ? b.text : b?.type === 'image' ? '[image]' : typeof b === 'string' ? b : ''))
+        .filter(Boolean)
+        .join('\n');
+}
+const TAG = /<\/?[a-z][a-z_-]*(?:\s[^>]*)?\/?>/g;
+/** Turn a raw user message into prompt text, or null when it is harness noise. */
+export function cleanPrompt(s) {
+    let t = s
+        .replace(/<(system-reminder|ide_opened_file|ide_selection|ide_diagnostics)>[\s\S]*?<\/\1>/g, '')
+        .trim();
+    if (/^<(local-command-stdout|local-command-stderr|local-command-caveat|bash-stdout|bash-stderr|task-notification)>/.test(t))
+        return null;
+    const cmd = /<command-name>([\s\S]*?)<\/command-name>/.exec(t);
+    if (cmd) {
+        const args = /<command-args>([\s\S]*?)<\/command-args>/.exec(t)?.[1]?.trim() ?? '';
+        return `${cmd[1].trim()} ${args}`.trim();
+    }
+    const bash = /^<bash-input>([\s\S]*?)<\/bash-input>/.exec(t);
+    if (bash)
+        return `! ${bash[1].trim()}`;
+    if (/<pasted_content[\s>]/.test(t)) {
+        const own = t.replace(/<pasted_content[^>]*>[\s\S]*?<\/pasted_content>/g, ' ').replace(TAG, '').trim();
+        if (own)
+            return own;
+        const inner = /<pasted_content[^>]*>([\s\S]*?)(?:<\/pasted_content>|$)/.exec(t)?.[1] ?? '';
+        const line = inner.split('\n').find((l) => l.trim() && !/^-{3,}$/.test(l.trim()));
+        return line ? `[pasted] ${line.trim()}` : '[pasted content]';
+    }
+    t = t.replace(TAG, '').trim();
+    return t || null;
+}
+/** Prompt text for the detail view: harness markup removed, pasted content kept. */
+export function displayPrompt(s) {
+    const cmd = /<command-name>[\s\S]*?<\/command-name>/.test(s) ? cleanPrompt(s) : null;
+    if (cmd)
+        return cmd;
+    return s
+        .replace(/<(system-reminder|ide_opened_file|ide_selection|ide_diagnostics)>[\s\S]*?<\/\1>/g, '')
+        .replace(/<pasted_content[^>]*>/g, '──── pasted ────\n')
+        .replace(/<\/pasted_content>/g, '\n────────────────')
+        .replace(TAG, '')
+        .trim();
+}
+/** Harness notifications injected as user messages (background task finished...). */
+export function harnessNotice(s) {
+    const m = /<task-notification>([\s\S]*?)(?:<\/task-notification>|$)/.exec(s);
+    if (!m)
+        return null;
+    const summary = /<summary>([\s\S]*?)<\/summary>/.exec(m[1])?.[1]?.trim();
+    const status = /<status>([\s\S]*?)<\/status>/.exec(m[1])?.[1]?.trim();
+    return summary ?? `Background task ${status ?? 'update'}`;
+}
+function mapStatus(s) {
+    return s === 'completed' ? 'completed' : s === 'in_progress' ? 'in_progress' : 'pending';
+}
+function toHunks(sp) {
+    const out = [];
+    for (const h of sp) {
+        if (!h || !Array.isArray(h.lines))
+            continue;
+        out.push({
+            oldStart: Number(h.oldStart) || 0,
+            oldLines: Number(h.oldLines) || 0,
+            newStart: Number(h.newStart) || 0,
+            newLines: Number(h.newLines) || 0,
+            lines: h.lines.map(String),
+        });
+    }
+    return out.length ? out : undefined;
+}
+export class ClaudeCodeAdapter {
+    name = 'claude-code';
+    seen = new Set();
+    metaSent = false;
+    cwdSent = false;
+    /** TaskCreate callId → subject, and task id → subject. */
+    taskCalls = new Map();
+    taskIds = new Map();
+    planCalls = new Set();
+    /** Background subagent calls still running, by tool_use id. */
+    bgCalls = new Set();
+    /** Message ids whose usage was already counted (a message spans several records). */
+    counted = new Set();
+    /** Usage of the latest message, held until its content blocks have been emitted. */
+    pendingUsage = null;
+    /** @param scope set for subagent transcripts: the callId of the spawning Agent call. */
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    push(input) {
+        const rec = input;
+        if (!rec || typeof rec !== 'object')
+            return [];
+        if (rec.uuid) {
+            if (this.seen.has(rec.uuid))
+                return [];
+            this.seen.add(rec.uuid);
+        }
+        const out = [];
+        if (this.pendingUsage && (rec.type !== 'assistant' || rec.message?.id !== this.pendingUsage.id))
+            out.push(...this.flush());
+        const ts = rec.timestamp;
+        const emit = (e) => {
+            if (this.scope)
+                e.scope = this.scope;
+            if (!e.ts && ts)
+                e.ts = ts;
+            out.push(e);
+        };
+        // The first records (queue operations, snapshots) often carry a session id but no cwd:
+        // announce the run once, and the working folder as soon as a record has it.
+        if (!this.scope && !this.metaSent && (rec.cwd || rec.sessionId || rec.session_id)) {
+            this.metaSent = true;
+            this.cwdSent = !!rec.cwd;
+            emit({ type: 'run.meta', agent: 'Claude Code', cwd: rec.cwd, sessionId: rec.sessionId ?? rec.session_id });
+        }
+        else if (!this.scope && !this.cwdSent && rec.cwd) {
+            this.cwdSent = true;
+            emit({ type: 'run.meta', cwd: rec.cwd });
+        }
+        switch (rec.type) {
+            case 'ai-title':
+            case 'summary':
+                if (!this.scope && (rec.aiTitle || rec.summary))
+                    emit({ type: 'run.meta', title: rec.aiTitle ?? rec.summary });
+                break;
+            case 'user':
+                if (!rec.isSidechain || this.scope)
+                    this.onUser(rec, emit);
+                break;
+            case 'queue-operation':
+                // Background work finishing is queued for the agent as a task notification.
+                if (!this.scope && typeof rec.content === 'string')
+                    this.onQueued(rec.content, emit);
+                break;
+            case 'assistant':
+                if (!rec.isSidechain || this.scope) {
+                    this.onAssistant(rec, emit);
+                    this.noteUsage(rec);
+                }
+                break;
+            case 'system':
+                this.onSystem(rec, emit);
+                break;
+            case 'result':
+                // stream-json end of a run
+                if (rec.is_error)
+                    emit({ type: 'notice', level: 'error', text: `Run ended with an error (${rec.subtype ?? 'error'})`, raw: rec.result });
+                emit({ type: 'turn.end' });
+                break;
+        }
+        return out;
+    }
+    /** Emits the held usage event. Sources call this at the end of each batch of lines. */
+    flush() {
+        const p = this.pendingUsage;
+        this.pendingUsage = null;
+        return p ? [p.ev] : [];
+    }
+    noteUsage(rec) {
+        const m = rec.message;
+        const u = m?.usage;
+        if (!u || !m.model || m.model === '<synthetic>' || rec.isApiErrorMessage)
+            return;
+        const id = m.id ?? rec.uuid;
+        if (!id || this.counted.has(id))
+            return;
+        this.counted.add(id);
+        const ev = {
+            type: 'usage',
+            model: String(m.model),
+            input: Number(u.input_tokens) || 0,
+            output: Number(u.output_tokens) || 0,
+            cacheRead: Number(u.cache_read_input_tokens) || 0,
+            cacheWrite: Number(u.cache_creation_input_tokens) || 0,
+        };
+        if (this.scope)
+            ev.scope = this.scope;
+        if (rec.timestamp)
+            ev.ts = rec.timestamp;
+        this.pendingUsage = { id, ev };
+    }
+    onUser(rec, emit) {
+        if (rec.isMeta)
+            return;
+        // The summary itself is not a prompt; the compact_boundary record already marks the event.
+        if (rec.isCompactSummary || rec.isVisibleInTranscriptOnly)
+            return;
+        const content = rec.message?.content;
+        const blocks = typeof content === 'string' ? [{ type: 'text', text: content }] : Array.isArray(content) ? content : [];
+        const texts = [];
+        // Claude Code attaches the edit's real diff (with file line numbers) to the record.
+        const results = blocks.filter((b) => b.type === 'tool_result').length;
+        const sp = rec.toolUseResult?.structuredPatch;
+        const patch = results === 1 && Array.isArray(sp) && sp.length ? toHunks(sp) : undefined;
+        for (const b of blocks) {
+            if (b.type === 'tool_result') {
+                const id = b.tool_use_id;
+                const output = blockText(b.content);
+                if (this.taskCalls.has(id)) {
+                    const m = /#?(\d+)/.exec(output);
+                    if (m)
+                        this.taskIds.set(m[1], this.taskCalls.get(id));
+                }
+                if (this.planCalls.has(id))
+                    continue;
+                const tr = rec.toolUseResult;
+                const fo = tr?.usage?.output_tokens;
+                if (results === 1 && tr?.agentId && typeof fo === 'number') {
+                    // The subagent's own transcript may hold a placeholder for its last response's output.
+                    emit({ type: 'usage', scope: id, final: true, model: String(tr.resolvedModel ?? ''), input: 0, output: fo, cacheRead: 0, cacheWrite: 0 });
+                }
+                const rejected = !!b.is_error && REJECTED.test(output);
+                if (!b.is_error && (tr?.isAsync || tr?.status === 'async_launched')) {
+                    this.bgCalls.add(id);
+                    emit({ type: 'tool.end', callId: id, ok: true, output, background: true });
+                    continue;
+                }
+                emit({ type: 'tool.end', callId: id, ok: !b.is_error, rejected, output, ...(patch && !b.is_error ? { patch } : {}) });
+            }
+            else if (b.type === 'text') {
+                texts.push(b.text);
+            }
+            else if (b.type === 'image') {
+                texts.push('[image]');
+            }
+        }
+        if (texts.length === 0)
+            return;
+        const raw = texts.join('\n');
+        if (/^\s*\[Request interrupted by user/.test(raw)) {
+            emit({ type: 'turn.end', interrupted: true });
+            return;
+        }
+        const notice = harnessNotice(raw);
+        if (notice)
+            this.onQueued(raw, emit);
+        if (notice) {
+            emit({ type: 'notice', level: 'info', text: notice, raw });
+            return;
+        }
+        const text = cleanPrompt(raw);
+        if (text)
+            emit({ type: 'user.prompt', text, raw: displayPrompt(raw) || text });
+    }
+    /** A task notification for a background subagent we saw start: it finished (or failed). */
+    onQueued(text, emit) {
+        const m = /<task-notification>([\s\S]*?)(?:<\/task-notification>|$)/.exec(text);
+        if (!m)
+            return;
+        const id = /<tool-use-id>([\s\S]*?)<\/tool-use-id>/.exec(m[1])?.[1]?.trim();
+        if (!id || !this.bgCalls.has(id))
+            return;
+        const status = /<status>([\s\S]*?)<\/status>/.exec(m[1])?.[1]?.trim() ?? '';
+        if (status === 'running')
+            return;
+        this.bgCalls.delete(id);
+        const summary = /<summary>([\s\S]*?)<\/summary>/.exec(m[1])?.[1]?.trim();
+        const result = /<result>([\s\S]*?)<\/result>/.exec(m[1])?.[1]?.trim();
+        const ok = status === 'completed';
+        emit({ type: 'tool.end', callId: id, ok, output: [summary, result].filter(Boolean).join('\n\n') || `Background agent ${status}` });
+    }
+    onAssistant(rec, emit) {
+        const content = rec.message?.content;
+        if (!Array.isArray(content))
+            return;
+        if (rec.isApiErrorMessage || rec.message?.model === '<synthetic>') {
+            // Harness-generated, not the model speaking (API errors, connection failures).
+            const text = blockText(content).trim();
+            if (text && text !== 'No response requested.')
+                emit({ type: 'notice', level: 'error', text, blocking: !!rec.isApiErrorMessage });
+            return;
+        }
+        for (const b of content) {
+            if (b.type === 'text') {
+                const t = String(b.text ?? '');
+                if (t.trim() && t.trim() !== 'No response requested.')
+                    emit({ type: 'agent.text', text: t });
+            }
+            else if (b.type === 'thinking') {
+                if (b.thinking?.trim())
+                    emit({ type: 'agent.thinking', text: b.thinking });
+            }
+            else if (b.type === 'tool_use') {
+                this.onToolUse(b, emit);
+            }
+        }
+    }
+    onToolUse(b, emit) {
+        const name = b.name;
+        const input = b.input ?? {};
+        if (PLANNING_TOOLS.has(name)) {
+            this.planCalls.add(b.id);
+            const raw = JSON.stringify(input, null, 2);
+            if (name === 'TodoWrite' && Array.isArray(input.todos)) {
+                const items = input.todos.map((t) => ({
+                    id: t.id ? String(t.id) : undefined,
+                    title: String(t.content ?? t.subject ?? ''),
+                    status: mapStatus(t.status),
+                }));
+                emit({ type: 'plan.set', source: 'TodoWrite', replace: true, items, raw });
+            }
+            else if (name === 'TaskCreate') {
+                const title = String(input.subject ?? input.description ?? 'Task');
+                this.taskCalls.set(b.id, title);
+                emit({ type: 'plan.set', source: 'Tasks', replace: false, items: [{ title, status: 'pending' }], raw });
+            }
+            else if (name === 'TaskUpdate') {
+                const id = String(input.taskId ?? input.id ?? '');
+                const title = this.taskIds.get(id);
+                if (input.status === 'deleted')
+                    emit({ type: 'plan.update', title, deleted: true, raw });
+                else
+                    emit({ type: 'plan.update', title, status: input.status ? mapStatus(input.status) : undefined, raw });
+            }
+            else if (name === 'ExitPlanMode' && typeof input.plan === 'string') {
+                // A plan-mode plan is prose; let the engine extract steps from it like any text plan.
+                emit({ type: 'agent.text', text: input.plan });
+            }
+            return;
+        }
+        const s = summarizeTool(name, input);
+        emit({
+            type: 'tool.start',
+            callId: b.id,
+            tool: name,
+            kind: s.kind,
+            label: s.label,
+            detail: s.detail,
+            command: s.command,
+            files: s.files,
+            spawnsAgent: s.spawnsAgent,
+            raw: s.raw,
+        });
+    }
+    onSystem(rec, emit) {
+        const sub = rec.subtype ?? '';
+        const content = typeof rec.content === 'string' ? rec.content : '';
+        // (stream-json's `init` record is covered by the generic first-record run.meta in push())
+        if (sub === 'turn_duration') {
+            emit({ type: 'turn.end' });
+        }
+        else if (sub === 'compact_boundary') {
+            emit({ type: 'notice', level: 'info', text: 'Context compacted' });
+        }
+        else if (sub.startsWith('model_refusal') || sub === 'refusal') {
+            const why = rec.apiRefusalExplanation ? `: ${rec.apiRefusalExplanation}` : '';
+            emit({ type: 'notice', level: 'error', text: `Request refused by the model${why}`, blocking: true });
+        }
+        else if (sub === 'api_error') {
+            emit({ type: 'notice', level: 'error', text: content || 'API error', raw: JSON.stringify(rec.error ?? rec, null, 2) });
+        }
+        else if (sub === 'informational' && content) {
+            const limit = /usage limit|rate limit|limit reached/i.test(content);
+            emit({ type: 'notice', level: limit ? 'warning' : 'info', text: content, blocking: limit });
+        }
+    }
+}

package/dist/adapters/claude-tools.js

@@ -0,0 +1,123 @@
+import { firstLine, truncate } from "../core/text.js";
+const str = (v) => (typeof v === 'string' ? v : v == null ? '' : JSON.stringify(v));
+export function baseName(p) {
+    const parts = p.split(/[\\/]/).filter(Boolean);
+    return parts[parts.length - 1] ?? p;
+}
+function host(url) {
+    try {
+        const u = new URL(url);
+        return truncate(u.host + (u.pathname === '/' ? '' : u.pathname), 60);
+    }
+    catch {
+        return truncate(url, 60);
+    }
+}
+function pretty(input) {
+    try {
+        return JSON.stringify(input, null, 2);
+    }
+    catch {
+        return String(input);
+    }
+}
+function mcpName(name) {
+    const m = /^mcp__(.+?)__(.+)$/.exec(name);
+    if (!m)
+        return null;
+    const server = m[1].replace(/^claude_ai_/, '').replace(/[_-]+/g, ' ');
+    return `${server} › ${m[2].replace(/_/g, ' ')}`;
+}
+/**
+ * The part of a shell command worth showing: drops leading `cd dir &&`, `VAR=x;`,
+ * `set -e;` style preambles so "cd /long/path && npm test" reads as "npm test".
+ */
+export function essentialCommand(cmd) {
+    let c = cmd.trim();
+    const preamble = /^(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)|[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S*)|set\s+-\S+|export\s+[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S*))\s*(?:&&|;|\n)\s*/;
+    for (let i = 0; i < 5; i++) {
+        const m = preamble.exec(c);
+        if (!m || m[0].length >= c.length)
+            break;
+        c = c.slice(m[0].length);
+    }
+    return c;
+}
+export function summarizeTool(name, input) {
+    const file = str(input.file_path ?? input.notebook_path ?? input.path);
+    switch (name) {
+        case 'Read':
+            return { kind: 'read', label: `Read ${baseName(file)}`, files: [file], raw: `Read ${file}` };
+        case 'Write':
+            return {
+                kind: 'write',
+                label: `Write ${baseName(file)}`,
+                files: [file],
+                raw: `Write ${file}\n\n${str(input.content)}`,
+            };
+        case 'Edit':
+        case 'MultiEdit':
+        case 'NotebookEdit': {
+            const edits = Array.isArray(input.edits) ? input.edits : [input];
+            const diff = edits
+                .map((e) => {
+                const oldS = str(e.old_string);
+                const newS = str(e.new_string ?? e.new_source);
+                return `${oldS.split('\n').map((l) => '- ' + l).join('\n')}\n${newS.split('\n').map((l) => '+ ' + l).join('\n')}`;
+            })
+                .join('\n\n');
+            return { kind: 'edit', label: `Edit ${baseName(file)}`, files: [file], raw: `Edit ${file}\n\n${diff}` };
+        }
+        case 'Bash':
+        case 'PowerShell': {
+            const cmd = str(input.command);
+            const desc = str(input.description);
+            const short = firstLine(essentialCommand(cmd), 80);
+            return {
+                kind: 'command',
+                label: desc ? truncate(desc, 80) : `$ ${short}`,
+                detail: `$ ${short}`,
+                command: short,
+                raw: `${name === 'PowerShell' ? 'PS>' : '$'} ${cmd}`,
+            };
+        }
+        case 'Grep':
+            return {
+                kind: 'search',
+                label: `Search “${truncate(str(input.pattern), 50)}”`,
+                detail: str(input.path) || undefined,
+                raw: pretty(input),
+            };
+        case 'Glob':
+            return { kind: 'search', label: `Find ${truncate(str(input.pattern), 60)}`, raw: pretty(input) };
+        case 'WebSearch':
+            return { kind: 'web', label: `Web search: ${truncate(str(input.query), 60)}`, raw: pretty(input) };
+        case 'WebFetch':
+            return { kind: 'web', label: `Fetch ${host(str(input.url))}`, detail: str(input.prompt) || undefined, raw: pretty(input) };
+        case 'Agent':
+        case 'Task': {
+            const desc = str(input.description) || str(input.subagent_type) || 'Subagent';
+            return {
+                kind: 'agent',
+                label: `Subagent: ${truncate(desc, 70)}`,
+                detail: str(input.subagent_type) || undefined,
+                spawnsAgent: true,
+                raw: str(input.prompt) || pretty(input),
+            };
+        }
+        case 'AskUserQuestion': {
+            const qs = Array.isArray(input.questions) ? input.questions : [];
+            const q = qs[0] ? str(qs[0].question) : 'Question';
+            return { kind: 'ask', label: `Ask: ${truncate(q, 80)}`, raw: pretty(input) };
+        }
+        case 'Skill':
+            return { kind: 'other', label: `Skill: ${str(input.skill)}`, raw: pretty(input) };
+        case 'ToolSearch':
+            return { kind: 'other', label: 'Load tools', detail: str(input.query), raw: pretty(input) };
+        default: {
+            return { kind: 'other', label: mcpName(name) ?? name, raw: pretty(input) };
+        }
+    }
+}
+/** Tools that express a plan rather than an action. */
+export const PLANNING_TOOLS = new Set(['TodoWrite', 'TaskCreate', 'TaskUpdate', 'ExitPlanMode']);

package/dist/adapters/text.js

@@ -0,0 +1,106 @@
+import { truncate } from "../core/text.js";
+import { baseName } from "./claude-tools.js";
+const ANSI = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07]*\x07/g;
+const COMMAND = /^\s*(?:\$|>|PS[^>]*>|Running:?|Executing:?|Run:)\s+(.+)$/;
+const FILE_OP = /^\s*(Reading|Read|Opening|Editing|Edited|Updating|Updated|Writing|Wrote|Creating|Created)\s+(?:file\s+)?[`'"]?([^\s`'"]+\.[A-Za-z0-9]{1,8})[`'"]?\s*$/i;
+const ERROR = /^\s*(?:error\b|fatal\b|traceback\b|exception\b|panic\b|✗|✘|×\s|FAIL(?:ED)?\b|npm ERR!)|exit(?:ed with)? code [1-9]/i;
+const PROMPT = /^\s*(?:user|you|human|prompt)\s*[:>]\s*(.+)$/i;
+function fileKind(verb) {
+    const v = verb.toLowerCase();
+    if (v.startsWith('read') || v.startsWith('open'))
+        return 'read';
+    if (v.startsWith('writ') || v.startsWith('wrote') || v.startsWith('creat'))
+        return 'write';
+    return 'edit';
+}
+export class TextAdapter {
+    name = 'text';
+    buffer = '';
+    paragraph = [];
+    open = null;
+    n = 0;
+    push(input) {
+        this.buffer += String(input).replace(ANSI, '');
+        const lines = this.buffer.split(/\r?\n/);
+        this.buffer = lines.pop() ?? '';
+        const out = [];
+        for (const l of lines)
+            this.line(l, out);
+        return out;
+    }
+    flush() {
+        const out = [];
+        if (this.buffer)
+            this.line(this.buffer, out);
+        this.buffer = '';
+        this.flushParagraph(out);
+        this.closeTool(out);
+        out.push({ type: 'turn.end', ts: new Date().toISOString() });
+        return out;
+    }
+    line(raw, out) {
+        const ts = new Date().toISOString();
+        const line = raw.replace(/\s+$/, '');
+        const prompt = PROMPT.exec(line);
+        const cmd = COMMAND.exec(line);
+        const file = FILE_OP.exec(line);
+        if (prompt) {
+            this.flushParagraph(out);
+            this.closeTool(out);
+            out.push({ type: 'user.prompt', text: prompt[1], ts, raw: line });
+            return;
+        }
+        if (cmd) {
+            this.flushParagraph(out);
+            this.closeTool(out);
+            const callId = `text-${++this.n}`;
+            const command = cmd[1].trim();
+            out.push({ type: 'tool.start', callId, tool: 'shell', kind: 'command', label: `$ ${truncate(command, 80)}`, command, ts, raw: line });
+            this.open = { callId, output: [], failed: false };
+            return;
+        }
+        if (file) {
+            this.flushParagraph(out);
+            this.closeTool(out);
+            const callId = `text-${++this.n}`;
+            const kind = fileKind(file[1]);
+            const verb = kind === 'read' ? 'Read' : kind === 'write' ? 'Write' : 'Edit';
+            out.push({ type: 'tool.start', callId, tool: 'file', kind, label: `${verb} ${baseName(file[2])}`, files: [file[2]], ts, raw: line });
+            out.push({ type: 'tool.end', callId, ok: true, ts });
+            return;
+        }
+        if (this.open) {
+            // Command output continues until a blank line followed by prose, or the next action.
+            if (line.trim() === '' && this.open.output.length > 0) {
+                this.closeTool(out);
+                return;
+            }
+            if (ERROR.test(line))
+                this.open.failed = true;
+            this.open.output.push(raw);
+            return;
+        }
+        if (line.trim() === '') {
+            this.flushParagraph(out);
+            return;
+        }
+        if (ERROR.test(line)) {
+            this.flushParagraph(out);
+            out.push({ type: 'notice', level: 'error', text: truncate(line.trim(), 160), ts, raw: line });
+            return;
+        }
+        this.paragraph.push(line);
+    }
+    flushParagraph(out) {
+        if (!this.paragraph.length)
+            return;
+        out.push({ type: 'agent.text', text: this.paragraph.join('\n'), ts: new Date().toISOString() });
+        this.paragraph = [];
+    }
+    closeTool(out) {
+        if (!this.open)
+            return;
+        out.push({ type: 'tool.end', callId: this.open.callId, ok: !this.open.failed, output: this.open.output.join('\n'), ts: new Date().toISOString() });
+        this.open = null;
+    }
+}