unfold-deploy 0.1.0 → 0.2.0

package/dist/commands/observe.js

@@ -50,10 +50,25 @@ export async function observe(opts) {
         session.subscribe((_e, state) => panel.update(state));
         panel.start();
     }
+    const show = (chunk) => {
+        process.stdout.write(chunk);
+        panel?.afterChildOutput(chunk);
+    };
+    // Structured CLIs (JSON events) are shown as readable lines, not raw output.
+    const formatted = !!opts.provider.createPresenter;
+    if (formatted) {
+        let shown = 0;
+        session.subscribe((e) => {
+            if (e.type !== 'log' || e.line.seq <= shown)
+                return;
+            shown = e.line.seq;
+            show(e.line.text.replace(/\r?\n/g, '\r\n') + '\r\n');
+        });
+    }
     const term = {
         write(chunk) {
-            process.stdout.write(chunk);
-            panel?.afterChildOutput(chunk);
+            if (!formatted)
+                show(chunk);
         },
         rows: () => panel?.childRows ?? (process.stdout.rows || 30),
         onRowsChange: (fn) => rowsListeners.add(fn),

package/dist/commands/replay.js

@@ -28,9 +28,24 @@ export async function runReplay(file, flags, speed) {
         save: false,
         waitForBrowser: true,
         run: async (session, term) => {
-            // Re-run the original lines through today's parser so parser fixes apply to old runs.
             const t0 = started.at;
             const start = Date.now();
+            const wait = async (at) => {
+                const ms = (at - t0) / speed - (Date.now() - start);
+                if (ms > 0)
+                    await new Promise((r) => setTimeout(r, Math.min(ms, 2000)));
+            };
+            if (provider.createPresenter) {
+                // Structured providers: raw events aren't saved, so replay the recorded events.
+                for (const e of events) {
+                    if (e.type === 'log')
+                        await wait(e.line.at);
+                    session.inject(e);
+                }
+                session.endReplay(ended?.exitCode ?? null, ended?.signal ?? null, ended?.interrupted ?? false);
+                return { exitCode: ended?.exitCode ?? null, signal: ended?.signal ?? null, interrupted: ended?.interrupted ?? false };
+            }
+            // Re-run the original lines through today's parser so parser fixes apply to old runs.
             for (const e of events) {
                 if (e.type !== 'log')
                     continue;

package/dist/commands/run.js

@@ -6,7 +6,7 @@ export async function runLive(provider, userArgs, flags) {
     const spec = provider.launch(userArgs);
     const bin = which(spec.bin);
     if (!bin) {
-        say(`Could not find "${spec.bin}" on your PATH. Install it first (for Vercel: npm i -g vercel), then run vercel login.`);
+        say(`Could not find "${spec.bin}" on your PATH.${provider.install ? ` ${provider.install}` : ''}`);
         return 127;
     }
     for (const msg of provider.preflight?.(cwd) ?? [])

package/dist/core/errors.js

@@ -0,0 +1,3 @@
+/** A mistake in how Unfold was invoked: printed without a stack trace. */
+export class UsageError extends Error {
+}

package/dist/core/flow.js

@@ -30,6 +30,7 @@ export class FlowReducer {
                 exitCode: null,
                 exitSignal: null,
                 stages: event.stages.map((d) => ({ ...d, status: 'pending', evidence: [] })),
+                notes: event.notes,
                 facts: [],
                 errors: [],
                 lineCount: 0,
@@ -94,6 +95,13 @@ export class FlowReducer {
                         st.note = sig.note;
                     }
                 }
+                else if (sig.status === 'unverified') {
+                    // A parser saying "this happened but didn't succeed" (e.g. checks ran and failed).
+                    if (st.status === 'pending' || st.status === 'active') {
+                        st.status = 'unverified';
+                        st.note = sig.note;
+                    }
+                }
                 else if (st.status !== 'confirmed') {
                     st.status = 'failed';
                     st.endedAt = e.at;
@@ -126,9 +134,12 @@ export class FlowReducer {
                 if (sig.severity === 'fatal') {
                     const st = this.stage(s, sig.stage) ?? this.currentStage(s);
                     if (st && st.status !== 'confirmed') {
+                        // Keep a note the parser already gave the failure (e.g. "Creating Revision failed.");
+                        // the full message is shown as the error.
+                        if (st.status !== 'failed' || !st.note)
+                            st.note = sig.message;
                         st.status = 'failed';
                         st.endedAt = e.at;
-                        st.note = sig.message;
                         s.failedStage = st.id;
                         info.stage = st.id;
                         this.addEvidence(st, e.seq, e.at, 'Error reported here');

package/dist/core/session.js

@@ -12,6 +12,7 @@ export class Session {
     reducer = new FlowReducer();
     runId;
     parser;
+    present;
     decoder;
     redactor;
     listeners = new Set();
@@ -23,9 +24,10 @@ export class Session {
         this.opts = opts;
         this.now = opts.now ?? Date.now;
         this.runId = new Date(this.now()).toISOString().replace(/[:.]/g, '-') + '-' + randomBytes(3).toString('hex');
-        this.parser = opts.provider.createParser();
+        this.parser = opts.provider.createParser({ cwd: opts.cwd });
         this.redactor = opts.redactor ?? new Redactor();
-        this.decoder = new TerminalDecoder((l) => this.onLine(l));
+        this.present = opts.provider.createPresenter?.({ cwd: opts.cwd });
+        this.decoder = new TerminalDecoder((l) => this.onLine(l), opts.provider.maxLineLength);
     }
     get state() {
         return this.reducer.state;
@@ -52,6 +54,21 @@ export class Session {
             notes: p.notes,
         });
     }
+    /**
+     * Replays an already-processed event (log, signal, fix) from a saved run. Used for
+     * providers whose raw output isn't saved, such as JSON event streams.
+     */
+    inject(event) {
+        if (event.type === 'log' || event.type === 'signal' || event.type === 'fix.ready')
+            this.emit(event);
+    }
+    /** Ends a replayed run without re-running the parser. */
+    endReplay(exitCode, signal, interrupted) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.emit({ type: 'run.ended', at: this.now(), exitCode, signal, interrupted });
+    }
     /** Feed raw terminal output (may contain partial lines and escape codes). */
     write(chunk) {
         if (!this.ended)
@@ -62,6 +79,10 @@ export class Session {
             return;
         this.decoder.end();
         this.ended = true;
+        const at = this.now();
+        const seq = this.last?.line.seq ?? 0;
+        for (const signal of this.parser.finish?.() ?? [])
+            this.emit({ type: 'signal', at, seq, signal });
         this.emit({ type: 'run.ended', at: this.now(), exitCode, signal, interrupted });
         const prompt = buildFixPrompt(this.state, this.logs, this.opts.provider.fixHints?.(this.state) ?? []);
         if (prompt) {
@@ -76,9 +97,19 @@ export class Session {
         }
     }
     onLine({ text: rawText, transient }) {
-        const text = this.redactor.line(rawText);
-        const key = redrawKey(text);
+        const raw = this.redactor.line(rawText);
         const at = this.now();
+        const shown = this.present ? this.present(raw) : raw;
+        if (shown === null) {
+            // Hidden line (e.g. a structured event with nothing to show): its signals attach
+            // to the last visible line.
+            const seq = this.last?.line.seq ?? 0;
+            for (const signal of this.parser.feed({ seq, at, text: raw }))
+                this.emit({ type: 'signal', at, seq, signal });
+            return;
+        }
+        const text = shown;
+        const key = redrawKey(text);
         let line;
         // A redrawn spinner/progress line replaces the previous one instead of piling up.
         if (this.last?.transient && this.last.key === key) {
@@ -93,7 +124,7 @@ export class Session {
         }
         this.last = { line, transient, key };
         this.emit({ type: 'log', line });
-        for (const signal of this.parser.feed(line))
+        for (const signal of this.parser.feed({ ...line, text: raw }))
             this.emit({ type: 'signal', at, seq: line.seq, signal });
     }
     emit(event) {

package/dist/core/terminal.js

@@ -9,12 +9,14 @@ export function stripSpinner(text) {
 }
 export class TerminalDecoder {
     emit;
+    maxLine;
     buf = '';
     esc = 'none';
     csiParams = '';
     pendingCR = false;
-    constructor(emit) {
+    constructor(emit, maxLine = MAX_LINE) {
         this.emit = emit;
+        this.maxLine = maxLine;
     }
     write(chunk) {
         for (const ch of chunk)
@@ -82,7 +84,7 @@ export class TerminalDecoder {
             this.buf += '  ';
         }
         else if (ch >= ' ' || ch > '\x7f') {
-            if (this.buf.length < MAX_LINE)
+            if (this.buf.length < this.maxLine)
                 this.buf += ch;
         }
     }

package/dist/providers/agents/claude.js

@@ -0,0 +1,205 @@
+import { UsageError } from '../../core/errors.js';
+import { agentFixHints, AGENT_NOTES, agentStages, CheckTracker, classifyCommand, oneLine, relPath } from './shared.js';
+const parse = (text) => {
+    if (!text.startsWith('{'))
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+const EXPLORE_TOOLS = new Set(['Read', 'Glob', 'Grep', 'LS', 'WebFetch', 'WebSearch', 'NotebookRead', 'Task', 'Agent', 'ToolSearch']);
+const CHANGE_TOOLS = new Set(['Edit', 'MultiEdit', 'Write', 'NotebookEdit']);
+function activity(name, input) {
+    if (name === 'Bash')
+        return classifyCommand(String(input.command ?? ''));
+    if (CHANGE_TOOLS.has(name))
+        return 'change';
+    if (EXPLORE_TOOLS.has(name) || name.startsWith('mcp__'))
+        return 'explore';
+    return undefined; // TodoWrite and other bookkeeping
+}
+function describe(name, input, cwd) {
+    const path = typeof input.file_path === 'string' ? relPath(input.file_path, cwd) : typeof input.notebook_path === 'string' ? relPath(input.notebook_path, cwd) : '';
+    switch (name) {
+        case 'Bash':
+            return `$ ${oneLine(String(input.command ?? ''), 140)}`;
+        case 'Read':
+            return `Read ${path}`;
+        case 'Edit':
+        case 'MultiEdit':
+            return `Edit ${path}`;
+        case 'Write':
+            return `Write ${path}`;
+        case 'NotebookEdit':
+            return `Edit ${path}`;
+        case 'Glob':
+            return `Find files ${String(input.pattern ?? '')}`;
+        case 'Grep':
+            return `Search for ${oneLine(String(input.pattern ?? ''), 60)}`;
+        case 'WebFetch':
+            return `Fetch ${String(input.url ?? '')}`;
+        case 'WebSearch':
+            return `Web search: ${oneLine(String(input.query ?? ''), 60)}`;
+        case 'Task':
+        case 'Agent':
+            return `Subagent: ${oneLine(String(input.description ?? input.prompt ?? ''), 60)}`;
+        default:
+            return name.startsWith('mcp__') ? `Tool ${name.slice(5).replace('__', '.')}` : name;
+    }
+}
+const resultText = (content) => typeof content === 'string' ? content : Array.isArray(content) ? content.map((c) => (typeof c === 'object' && c && 'text' in c ? String(c.text) : '')).join(' ') : '';
+export class ClaudeParser {
+    cwd;
+    pending = new Map();
+    checks = new CheckTracker();
+    feed(line) {
+        const e = parse(line.text.trim());
+        if (!e) {
+            // Plain text: Claude Code's own errors (bad flags, not logged in) land here.
+            const t = line.text.trim();
+            return /error|invalid|not logged in|unauthorized/i.test(t) ? [{ kind: 'error', severity: 'cause', stage: 'start', message: t }] : [];
+        }
+        const out = [];
+        if (e.type === 'system' && e.subtype === 'init') {
+            this.cwd = e.cwd;
+            if (e.claude_code_version)
+                out.push({ kind: 'fact', key: 'cliVersion', label: 'Claude Code', value: e.claude_code_version, stage: 'start' });
+            if (e.model)
+                out.push({ kind: 'fact', key: 'model', label: 'Model', value: e.model, stage: 'start' });
+            if (e.permissionMode)
+                out.push({ kind: 'fact', key: 'permissionMode', label: 'Permission mode', value: e.permissionMode, stage: 'start' });
+            out.push({ kind: 'stage', stage: 'start', status: 'confirmed', note: `Session started${e.model ? ` with ${e.model}` : ''}.` });
+            return out;
+        }
+        if (e.type === 'assistant') {
+            for (const b of e.message?.content ?? []) {
+                if (b.type !== 'tool_use' || !b.id || !b.name)
+                    continue;
+                const input = b.input ?? {};
+                const kind = activity(b.name, input);
+                this.pending.set(b.id, { name: b.name, input, kind });
+                if (kind)
+                    out.push({ kind: 'stage', stage: kind, status: 'active', note: describe(b.name, input, this.cwd) });
+            }
+            return out;
+        }
+        if (e.type === 'user') {
+            for (const b of e.message?.content ?? []) {
+                if (b.type !== 'tool_result' || !b.tool_use_id)
+                    continue;
+                const call = this.pending.get(b.tool_use_id);
+                if (!call?.kind)
+                    continue;
+                this.pending.delete(b.tool_use_id);
+                const what = describe(call.name, call.input, this.cwd);
+                if (call.kind === 'verify')
+                    this.checks.record(String(call.input.command ?? call.name), !b.is_error);
+                if (b.is_error) {
+                    const why = oneLine(resultText(b.content), 120);
+                    out.push({ kind: 'evidence', stage: call.kind, note: `Failed: ${what}${why ? ` (${why})` : ''}` });
+                    if (call.kind === 'verify')
+                        out.push({ kind: 'error', severity: 'cause', stage: 'verify', message: `${what}: ${why}`, priority: 1 });
+                }
+                else {
+                    if (call.kind === 'change' && typeof call.input.file_path === 'string')
+                        this.checks.changed.add(relPath(call.input.file_path, this.cwd));
+                    out.push({ kind: 'stage', stage: call.kind, status: 'confirmed', note: call.kind === 'verify' ? `Check passed: ${what.replace(/^\$ /, '')}` : what });
+                }
+            }
+            return out;
+        }
+        if (e.type === 'result') {
+            const secs = e.duration_ms !== undefined ? `${(e.duration_ms / 1000).toFixed(1)}s` : undefined;
+            if (e.total_cost_usd !== undefined)
+                out.push({ kind: 'fact', key: 'cost', label: 'Cost', value: `$${e.total_cost_usd.toFixed(2)}`, stage: 'done' });
+            if (e.num_turns !== undefined)
+                out.push({ kind: 'fact', key: 'turns', label: 'Turns', value: String(e.num_turns), stage: 'done' });
+            if (secs)
+                out.push({ kind: 'fact', key: 'duration', label: 'Duration', value: secs, stage: 'done' });
+            const denied = [...new Set((e.permission_denials ?? []).map((d) => d.tool_name).filter(Boolean))];
+            if (denied.length)
+                out.push({ kind: 'fact', key: 'denied', label: 'Permission denied', value: denied.join(', '), stage: 'done' });
+            if (e.subtype === 'success' && !e.is_error) {
+                if (e.result)
+                    out.push({ kind: 'fact', key: 'answer', label: 'Answer', value: oneLine(e.result, 300), stage: 'done' });
+                out.push({ kind: 'stage', stage: 'done', status: 'confirmed', note: `Finished${secs ? ` in ${secs}` : ''}${e.num_turns ? ` after ${e.num_turns} turns` : ''}.` });
+            }
+            else {
+                const reason = e.subtype === 'error_max_turns' ? 'It hit the maximum number of turns.' : oneLine(e.result || String(e.api_error_status ?? '') || e.subtype || 'The session ended with an error.', 200);
+                out.push({ kind: 'error', severity: 'fatal', stage: 'done', message: reason });
+            }
+            if (denied.length)
+                out.push({ kind: 'error', severity: 'cause', stage: 'done', message: `Permission denied for: ${denied.join(', ')}`, priority: 2 });
+        }
+        return out;
+    }
+    finish() {
+        return this.checks.finish();
+    }
+}
+/** Turns stream-json events into readable terminal lines. */
+export function claudePresenter() {
+    let cwd;
+    const calls = new Map();
+    return (raw) => {
+        const e = parse(raw.trim());
+        if (!e)
+            return raw.trim() ? raw : null;
+        if (e.type === 'system' && e.subtype === 'init') {
+            cwd = e.cwd;
+            return `● Claude Code ${e.claude_code_version ?? ''} · ${e.model ?? 'model'} · permission mode: ${e.permissionMode ?? 'default'}`;
+        }
+        if (e.type === 'assistant') {
+            const lines = [];
+            for (const b of e.message?.content ?? []) {
+                if (b.type === 'tool_use' && b.name) {
+                    const d = describe(b.name, b.input ?? {}, cwd);
+                    if (b.id)
+                        calls.set(b.id, d);
+                    if (b.name !== 'TodoWrite')
+                        lines.push(`  ${d.startsWith('$') ? d : `→ ${d}`}`);
+                }
+                else if (b.type === 'text' && b.text?.trim()) {
+                    lines.push(`› ${oneLine(b.text, 300)}`);
+                }
+            }
+            return lines.length ? lines.join('\n') : null;
+        }
+        if (e.type === 'user') {
+            const failed = (e.message?.content ?? []).filter((b) => b.type === 'tool_result' && b.is_error);
+            return failed.length ? failed.map((b) => `    ✗ ${oneLine(resultText(b.content), 140)}`).join('\n') : null;
+        }
+        if (e.type === 'result') {
+            const ok = e.subtype === 'success' && !e.is_error;
+            const bits = [e.duration_ms !== undefined ? `${(e.duration_ms / 1000).toFixed(1)}s` : '', e.num_turns ? `${e.num_turns} turns` : '', e.total_cost_usd !== undefined ? `$${e.total_cost_usd.toFixed(2)}` : ''].filter(Boolean);
+            return `■ ${ok ? 'Done' : `Failed (${e.subtype})`}${bits.length ? ` · ${bits.join(' · ')}` : ''}`;
+        }
+        return null; // hooks, rate limits, partial messages
+    };
+}
+export const claude = {
+    id: 'claude',
+    title: 'Claude Code task',
+    stages: agentStages('Claude Code', 'https://docs.claude.com/en/docs/claude-code/sdk/sdk-headless', 'Allow tools with `--allowedTools` (for example `--allowedTools Read Edit Bash`) or `--permission-mode acceptEdits`.'),
+    notes: { ...AGENT_NOTES, docsLabel: 'Claude Code docs' },
+    install: 'Install Claude Code (https://docs.claude.com/en/docs/claude-code), then run `claude` once to log in.',
+    maxLineLength: 2_000_000,
+    launch(userArgs) {
+        const args = userArgs.filter((a) => a !== '-p' && a !== '--print');
+        if (!args.some((a) => !a.startsWith('-'))) {
+            throw new UsageError('give Claude Code a task, for example: unfold claude "fix the failing test" --allowedTools Read Edit Bash');
+        }
+        const out = ['-p', ...args];
+        if (!args.some((a) => a.startsWith('--output-format')))
+            out.push('--output-format', 'stream-json');
+        if (!args.includes('--verbose'))
+            out.push('--verbose');
+        return { bin: process.env.UNFOLD_CLAUDE_BIN || 'claude', args: out };
+    },
+    createParser: () => new ClaudeParser(),
+    createPresenter: claudePresenter,
+    fixHints: (state) => agentFixHints(state, 'Allow it with `--allowedTools <tool>` or `--permission-mode acceptEdits`, or run the task interactively.'),
+};

package/dist/providers/agents/codex.js

@@ -0,0 +1,152 @@
+import { UsageError } from '../../core/errors.js';
+import { agentFixHints, AGENT_NOTES, agentStages, CheckTracker, classifyCommand, oneLine, relPath, unwrapShell } from './shared.js';
+const parse = (text) => {
+    if (!text.startsWith('{'))
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+const k = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));
+function describeChanges(changes, cwd) {
+    return changes.map((c) => `${c.kind === 'add' ? 'add' : c.kind === 'delete' ? 'delete' : 'edit'} ${relPath(c.path, cwd)}`).join(', ');
+}
+export class CodexParser {
+    cwd;
+    checks = new CheckTracker();
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    feed(line) {
+        const e = parse(line.text.trim());
+        if (!e) {
+            const t = line.text.trim();
+            // Codex prints its own warnings and errors as plain text; MCP transport noise is not a task error.
+            return /^(error|fatal)\b|not logged in|unauthorized/i.test(t) && !/rmcp::|mcp/i.test(t) ? [{ kind: 'error', severity: 'cause', stage: 'start', message: t }] : [];
+        }
+        const it = e.item ?? {};
+        switch (e.type) {
+            case 'thread.started':
+                return [{ kind: 'stage', stage: 'start', status: 'confirmed', note: 'Session started.' }];
+            case 'item.started':
+                if (it.type === 'command_execution' && it.command) {
+                    const cmd = unwrapShell(it.command);
+                    return [{ kind: 'stage', stage: classifyCommand(cmd), status: 'active', note: `$ ${oneLine(cmd, 140)}` }];
+                }
+                if (it.type === 'file_change')
+                    return [{ kind: 'stage', stage: 'change', status: 'active', note: `Editing ${describeChanges(it.changes ?? [], this.cwd)}` }];
+                return [];
+            case 'item.completed':
+                return this.completed(it);
+            case 'turn.completed': {
+                const u = e.usage ?? {};
+                const out = [];
+                if (u.input_tokens !== undefined)
+                    out.push({ kind: 'fact', key: 'tokens', label: 'Tokens', value: `${k(u.input_tokens)} in (${k(u.cached_input_tokens ?? 0)} cached), ${k(u.output_tokens ?? 0)} out`, stage: 'done' });
+                out.push({ kind: 'stage', stage: 'done', status: 'confirmed', note: 'Finished the turn.' });
+                return out;
+            }
+            case 'turn.failed':
+                return [{ kind: 'error', severity: 'fatal', stage: 'done', message: e.error?.message ?? 'The turn failed.' }];
+            case 'error':
+                return [{ kind: 'error', severity: 'fatal', stage: 'done', message: e.message ?? e.error?.message ?? 'Codex reported an error.' }];
+            default:
+                return [];
+        }
+    }
+    completed(it) {
+        switch (it.type) {
+            case 'command_execution': {
+                const cmd = unwrapShell(it.command ?? '');
+                const kind = classifyCommand(cmd);
+                const ok = it.exit_code === 0 && it.status !== 'failed';
+                if (kind === 'verify')
+                    this.checks.record(cmd, ok);
+                if (ok)
+                    return [{ kind: 'stage', stage: kind, status: 'confirmed', note: kind === 'verify' ? `Check passed: ${oneLine(cmd, 100)}` : `$ ${oneLine(cmd, 140)}` }];
+                const out = [{ kind: 'evidence', stage: kind, note: `Failed (exit ${it.exit_code ?? '?'}): $ ${oneLine(cmd, 120)}` }];
+                if (kind === 'verify') {
+                    const tail = oneLine((it.aggregated_output ?? '').trim().split('\n').slice(-3).join(' '), 160);
+                    out.push({ kind: 'error', severity: 'cause', stage: 'verify', message: `${oneLine(cmd, 80)} exited with ${it.exit_code ?? '?'}${tail ? `: ${tail}` : ''}`, priority: 2 });
+                }
+                return out;
+            }
+            case 'file_change': {
+                const changes = it.changes ?? [];
+                if (it.status === 'failed')
+                    return [{ kind: 'evidence', stage: 'change', note: `Failed to change ${describeChanges(changes, this.cwd)}` }];
+                for (const c of changes)
+                    this.checks.changed.add(relPath(c.path, this.cwd));
+                return [{ kind: 'stage', stage: 'change', status: 'confirmed', note: `Changed: ${describeChanges(changes, this.cwd)}` }];
+            }
+            case 'mcp_tool_call':
+                return [{ kind: 'stage', stage: 'explore', status: it.status === 'failed' ? 'active' : 'confirmed', note: `Tool ${it.server ?? ''}.${it.tool ?? ''}` }];
+            case 'web_search':
+                return [{ kind: 'stage', stage: 'explore', status: 'confirmed', note: `Web search: ${oneLine(it.query ?? '', 60)}` }];
+            case 'agent_message':
+                return it.text ? [{ kind: 'fact', key: 'answer', label: 'Answer', value: oneLine(it.text, 300), stage: 'done' }] : [];
+            case 'error':
+                return [{ kind: 'error', severity: 'cause', stage: 'done', message: it.message ?? 'Codex reported an error.' }];
+            default:
+                return [];
+        }
+    }
+    finish() {
+        return this.checks.finish();
+    }
+}
+export function codexPresenter(cwd = process.cwd()) {
+    return (raw) => {
+        const e = parse(raw.trim());
+        if (!e)
+            return raw.trim() && !/rmcp::/.test(raw) ? raw : null;
+        const it = e.item ?? {};
+        if (e.type === 'thread.started')
+            return '● Codex session started';
+        if (e.type === 'item.started' && it.type === 'command_execution')
+            return `  $ ${oneLine(unwrapShell(it.command ?? ''), 140)}`;
+        if (e.type === 'item.completed') {
+            if (it.type === 'command_execution')
+                return it.exit_code === 0 ? null : `    ✗ exit ${it.exit_code ?? '?'}${it.aggregated_output?.trim() ? `: ${oneLine(it.aggregated_output.trim().split('\n').at(-1), 120)}` : ''}`;
+            if (it.type === 'file_change')
+                return `  ✎ ${describeChanges(it.changes ?? [], cwd)}${it.status === 'failed' ? ' (failed)' : ''}`;
+            if (it.type === 'agent_message' && it.text)
+                return `› ${oneLine(it.text, 300)}`;
+            if (it.type === 'mcp_tool_call')
+                return `  → Tool ${it.server ?? ''}.${it.tool ?? ''}`;
+            if (it.type === 'web_search')
+                return `  → Web search: ${oneLine(it.query ?? '', 60)}`;
+            if (it.type === 'error')
+                return `  ✗ ${it.message ?? 'error'}`;
+            return null;
+        }
+        if (e.type === 'turn.completed') {
+            const u = e.usage ?? {};
+            return `■ Done${u.input_tokens !== undefined ? ` · ${k(u.input_tokens)} tokens in, ${k(u.output_tokens ?? 0)} out` : ''}`;
+        }
+        if (e.type === 'turn.failed' || e.type === 'error')
+            return `■ Failed: ${e.error?.message ?? e.message ?? ''}`;
+        return null;
+    };
+}
+export const codex = {
+    id: 'codex',
+    title: 'Codex task',
+    stages: agentStages('Codex', 'https://developers.openai.com/codex/cli', 'Codex runs in a sandbox; use `--sandbox workspace-write` to let it edit files.'),
+    notes: { ...AGENT_NOTES, docsLabel: 'Codex docs' },
+    install: 'Install the Codex CLI (`npm i -g @openai/codex`), then run `codex login`.',
+    maxLineLength: 2_000_000,
+    launch(userArgs) {
+        const args = userArgs[0] === 'exec' ? userArgs.slice(1) : [...userArgs];
+        if (!args.some((a) => !a.startsWith('-'))) {
+            throw new UsageError('give Codex a task, for example: unfold codex "fix the failing test" --sandbox workspace-write');
+        }
+        return { bin: process.env.UNFOLD_CODEX_BIN || 'codex', args: ['exec', ...(args.includes('--json') ? [] : ['--json']), ...args] };
+    },
+    createParser: (ctx) => new CodexParser(ctx.cwd),
+    createPresenter: (ctx) => codexPresenter(ctx.cwd),
+    fixHints: (state) => agentFixHints(state, 'Give it more room with `--sandbox workspace-write`.'),
+};