unfold-deploy 0.0.0-stage → 0.2.0

package/dist/tui/explore.js

@@ -0,0 +1,220 @@
+// Full-screen terminal explorer for a finished run (`unfold show`).
+import { spawn } from 'node:child_process';
+import { rankCauses } from '../core/fix-prompt.js';
+import { padEnd, style, truncate, wrapText } from './ansi.js';
+import { commandLabel, elapsed, flowLine, focusStage, glyph, outcomeLabel, STATUS_WORD } from './render.js';
+import { onRestore } from './restore.js';
+const stripStamp = (t) => t.replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z {0,2}/, '');
+function rel(state, at) {
+    const sec = Math.max(0, (at - state.startedAt) / 1000);
+    return sec < 60 ? `+${sec.toFixed(1)}s` : `+${Math.floor(sec / 60)}m${Math.round(sec % 60)}s`;
+}
+function observed(m, st, w, s) {
+    const out = [s.bold('OBSERVED IN THIS RUN'), ''];
+    out.push(`${glyph(st, s)} ${s.bold(st.title)} ${s.dim('·')} ${STATUS_WORD[st.status]}`);
+    const note = st.status === 'pending' ? 'Nothing about this stage has appeared in the output yet.' : (st.note ?? '');
+    for (const l of wrapText(note, w))
+        out.push(st.status === 'failed' ? s.red(l) : st.status === 'unverified' ? s.yellow(l) : l);
+    if (st.status === 'failed') {
+        const fatal = m.state.errors.find((e) => e.severity === 'fatal' && e.stage === st.id);
+        const causes = rankCauses(m.state).filter((c) => c.stage === st.id).slice(0, 4);
+        out.push('');
+        const labelled = (label, text) => wrapText(text, w - 7).map((l, i) => (i ? '       ' : label.padEnd(7)) + l);
+        if (fatal)
+            out.push(...labelled('Error', `${fatal.message} (line ${fatal.seq})`).map((l, i) => (i ? l : s.red(l))));
+        for (const c of causes)
+            out.push(...labelled('Cause', `${c.message} (line ${c.seq})`).map((l, i) => (i ? l : s.yellow(l))));
+    }
+    const facts = m.state.facts.filter((f) => f.stage === st.id);
+    if (facts.length) {
+        out.push('');
+        const kw = Math.max(...facts.map((f) => f.label.length)) + 2;
+        for (const f of facts)
+            out.push(truncate(`${s.dim(f.label.padEnd(kw))}${f.href ? s.cyan(f.value) : f.value}`, w));
+    }
+    out.push('', s.dim('Evidence from the output'));
+    if (!st.evidence.length)
+        out.push(s.dim('No output from this run relates to this stage.'));
+    for (const e of st.evidence) {
+        const text = stripStamp(m.logs.find((l) => l.seq === e.seq)?.text ?? e.text);
+        out.push(`${s.dim(rel(m.state, e.at).padEnd(7))}${truncate(e.note, w - 7)}`);
+        out.push(`       ${truncate(s.dim(`${text}`), w - 16)} ${s.dim(`line ${e.seq}`)}`);
+    }
+    return out;
+}
+function explanation(st, w, s) {
+    const out = [s.dim(s.bold('HOW THIS STAGE WORKS')) + s.dim(' · general, not from this run'), ''];
+    out.push(...wrapText(st.summary, w).map(s.bold), '');
+    for (const p of st.explanation)
+        out.push(...wrapText(p, w).map(s.dim), '');
+    out.push(...wrapText(`What would confirm it: ${st.confirmedBy}`, w));
+    if (st.docsUrl)
+        out.push('', s.cyan(truncate(st.docsUrl, w)));
+    return out;
+}
+function stageBody(m, cols, s) {
+    const st = m.state.stages[m.stage];
+    if (cols >= 120) {
+        const lw = Math.floor((cols - 5) * 0.58);
+        const rw = cols - 5 - lw;
+        const left = observed(m, st, lw, s);
+        const right = explanation(st, rw, s);
+        return Array.from({ length: Math.max(left.length, right.length) }, (_, i) => `  ${padEnd(truncate(left[i] ?? '', lw), lw)}   ${truncate(right[i] ?? '', rw)}`);
+    }
+    const w = cols - 4;
+    return [...observed(m, st, w, s), '', ...explanation(st, w, s)].map((l) => `  ${truncate(l, w)}`);
+}
+function logsBody(m, cols, s) {
+    const errs = new Set(m.state.errors.map((e) => e.seq));
+    const ev = new Set(m.state.stages.flatMap((st) => st.evidence.map((e) => e.seq)));
+    const nw = String(m.logs.at(-1)?.seq ?? 0).length;
+    return m.logs.map((l) => {
+        const marker = errs.has(l.seq) ? s.red('▌') : ev.has(l.seq) ? s.green('▌') : ' ';
+        const body = truncate(l.text, cols - nw - 5);
+        const stamp = /^\d{4}-\d{2}-\d{2}T[\d:.]+Z/.exec(body)?.[0] ?? '';
+        const rest = body.slice(stamp.length);
+        const text = s.dim(stamp) + (errs.has(l.seq) ? s.red(rest) : rest);
+        const row = `${marker} ${s.dim(String(l.seq).padStart(nw))}  ${text}`;
+        return l.seq === m.mark ? s.inverse(padEnd(row, cols - 1)) : row;
+    });
+}
+function promptBody(m, cols) {
+    if (!m.state.fix)
+        return ['  No fix prompt: fix prompts are created when a run fails.'];
+    return m.state.fix.prompt.split('\n').flatMap((l) => (l ? wrapText(l, cols - 4) : [''])).map((l) => `  ${l}`);
+}
+export function body(m, cols, s) {
+    return m.view === 'logs' ? logsBody(m, cols, s) : m.view === 'prompt' ? promptBody(m, cols) : stageBody(m, cols, s);
+}
+/** Renders one full screen as exactly `rows` lines. */
+export function screen(m, cols, rows, s = style(true)) {
+    const st = m.state;
+    const head = [
+        truncate(` ${s.bold('unfold')} ${s.dim('·')} ${outcomeLabel(st, s)} ${s.dim(`in ${elapsed(st)}`)}${st.mode !== 'live' ? s.dim(` · ${st.mode}`) : ''} ${s.dim('·')} ${commandLabel(st)}`, cols - 1),
+        truncate(` ${flowLine(st, s, { selected: m.view === 'stage' ? st.stages[m.stage].id : undefined })}`, cols - 1),
+        s.dim('─'.repeat(cols - 1)),
+    ];
+    const keys = m.view === 'stage'
+        ? '←/→ stage  ↑/↓ scroll  l logs  e error  f fix prompt  c/x copy claude/codex command  q quit'
+        : m.view === 'logs'
+            ? '↑/↓ PgUp/PgDn scroll  e error  l back  q quit'
+            : '↑/↓ scroll  c/x copy claude/codex command  f back  q quit';
+    const foot = [s.dim('─'.repeat(cols - 1)), truncate(m.message ? ` ${s.green(m.message)}` : s.dim(` ${keys}`), cols - 1)];
+    const avail = Math.max(1, rows - head.length - foot.length);
+    const lines = body(m, cols, s);
+    const maxScroll = Math.max(0, lines.length - avail);
+    m.scroll = Math.min(Math.max(0, m.scroll), maxScroll);
+    const visible = lines.slice(m.scroll, m.scroll + avail);
+    while (visible.length < avail)
+        visible.push('');
+    return [...head, ...visible, ...foot];
+}
+function copy(text) {
+    const [cmd, args] = process.platform === 'darwin' ? ['pbcopy', []] : process.platform === 'win32' ? ['clip', []] : ['xclip', ['-selection', 'clipboard']];
+    try {
+        const p = spawn(cmd, args, { stdio: ['pipe', 'ignore', 'ignore'] });
+        p.on('error', () => { });
+        p.stdin.end(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Interactive loop. Resolves when the user quits. */
+export function explore(state, logs) {
+    const out = process.stdout;
+    const stdin = process.stdin;
+    const s = style(true);
+    const m = { state, logs: [...logs].sort((a, b) => a.seq - b.seq), stage: state.stages.indexOf(focusStage(state)), view: 'stage', scroll: 0 };
+    let msgTimer;
+    const draw = () => {
+        const rows = out.rows || 24;
+        const cols = out.columns || 80;
+        out.write('\x1b[H' + screen(m, cols, rows, s).map((l) => l + '\x1b[K').join('\r\n') + '\x1b[J');
+    };
+    const flash = (msg) => {
+        m.message = msg;
+        draw();
+        if (msgTimer)
+            clearTimeout(msgTimer);
+        msgTimer = setTimeout(() => ((m.message = undefined), draw()), 1800);
+    };
+    const jumpToError = () => {
+        const target = rankCauses(state)[0] ?? state.errors.find((e) => e.severity === 'fatal');
+        if (!target)
+            return flash('No errors in this run.');
+        m.view = 'logs';
+        m.mark = target.seq;
+        const page = Math.max(1, (out.rows || 24) - 5);
+        m.scroll = Math.max(0, m.logs.findIndex((l) => l.seq === target.seq) - Math.floor(page / 3));
+        draw();
+    };
+    const copyCmd = (agent) => {
+        const cmd = state.fix?.commands?.[agent];
+        if (!cmd)
+            return flash(state.fix ? 'The prompt was not saved, so there is no command to copy.' : 'Nothing to fix: fix prompts are created when a run fails.');
+        flash(copy(cmd) ? `Copied the ${agent === 'claude' ? 'Claude Code' : 'Codex'} command. Paste it in your project folder.` : cmd);
+    };
+    return new Promise((resolve) => {
+        const page = () => Math.max(1, (out.rows || 24) - 6);
+        const onKey = (buf) => {
+            const k = buf.toString();
+            if (k === 'q' || k === '\x1b' || k === '\x03')
+                return finish();
+            if (k === '\x1b[C' || k === '\t' || k === 'L')
+                ((m.stage = (m.stage + 1) % state.stages.length), (m.view = 'stage'), (m.scroll = 0));
+            else if (k === '\x1b[D' || k === '\x1b[Z' || k === 'H')
+                ((m.stage = (m.stage - 1 + state.stages.length) % state.stages.length), (m.view = 'stage'), (m.scroll = 0));
+            else if (k === '\x1b[B' || k === 'j')
+                m.scroll++;
+            else if (k === '\x1b[A' || k === 'k')
+                m.scroll--;
+            else if (k === '\x1b[6~' || k === ' ')
+                m.scroll += page();
+            else if (k === '\x1b[5~' || k === 'b')
+                m.scroll -= page();
+            else if (k === 'g')
+                m.scroll = 0;
+            else if (k === 'G')
+                m.scroll = 1e9;
+            else if (k === 'l')
+                ((m.view = m.view === 'logs' ? 'stage' : 'logs'), (m.scroll = m.view === 'logs' ? 1e9 : 0));
+            else if (k === 'f')
+                ((m.view = m.view === 'prompt' ? 'stage' : 'prompt'), (m.scroll = 0));
+            else if (k === 'e')
+                return jumpToError();
+            else if (k === 'c')
+                return copyCmd('claude');
+            else if (k === 'x')
+                return copyCmd('codex');
+            else if (/^[1-9]$/.test(k) && Number(k) <= state.stages.length)
+                ((m.stage = Number(k) - 1), (m.view = 'stage'), (m.scroll = 0));
+            draw();
+        };
+        const release = onRestore(() => {
+            if (stdin.isTTY)
+                stdin.setRawMode(false);
+            out.write('\x1b[?25h\x1b[?1049l');
+        });
+        const finish = () => {
+            release();
+            stdin.off('data', onKey);
+            out.off('resize', draw);
+            if (msgTimer)
+                clearTimeout(msgTimer);
+            if (stdin.isTTY)
+                stdin.setRawMode(false);
+            stdin.pause();
+            out.write('\x1b[?25h\x1b[?1049l');
+            resolve();
+        };
+        out.write('\x1b[?1049h\x1b[?25l');
+        if (stdin.isTTY)
+            stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on('data', onKey);
+        out.on('resize', draw);
+        draw();
+    });
+}

package/dist/tui/panel.js

@@ -0,0 +1,118 @@
+import { style, truncate, width } from './ansi.js';
+import { elapsed, flowLine, focusStage, outcomeLabel } from './render.js';
+import { onRestore } from './restore.js';
+const HEIGHT = 3;
+const ESC = '\x1b';
+/** Whether the terminal can host the panel. */
+export function panelSupported(out = process.stdout) {
+    return !!out.isTTY && process.env.TERM !== 'dumb' && (out.rows ?? 0) >= 12 && (out.columns ?? 0) >= 50 && !process.env.UNFOLD_NO_PANEL;
+}
+export class LivePanel {
+    opts;
+    out;
+    s;
+    state;
+    frame = 0;
+    timer;
+    active = false;
+    /** True while the last child chunk ended inside an escape sequence. */
+    midEscape = false;
+    dirty = false;
+    releaseRestore;
+    constructor(opts) {
+        this.opts = opts;
+        this.out = opts.out ?? process.stdout;
+        this.s = style(true);
+    }
+    /** Rows the wrapped command may use. */
+    get childRows() {
+        return Math.max(1, (this.out.rows || 24) - (this.active ? HEIGHT : 0));
+    }
+    start() {
+        if (this.active)
+            return;
+        this.active = true;
+        this.releaseRestore = onRestore(() => this.out.write(`${ESC}[r${ESC}[0m\r\n`));
+        // Make room: scroll existing content up so the panel doesn't cover it.
+        this.out.write('\n'.repeat(HEIGHT) + `${ESC}[${HEIGHT}A`);
+        this.setRegion();
+        this.draw();
+        this.timer = setInterval(() => {
+            this.frame++;
+            this.draw();
+        }, 120);
+        this.out.on('resize', this.onResize);
+        this.opts.onRowsChange?.(this.childRows);
+    }
+    update(state) {
+        this.state = state;
+        this.dirty = true;
+    }
+    /** Call after forwarding child output so we never draw in the middle of an escape sequence. */
+    afterChildOutput(chunk) {
+        const lastEsc = chunk.lastIndexOf(ESC);
+        if (lastEsc === -1) {
+            if (this.midEscape)
+                this.midEscape = !/[@-~]/.test(chunk);
+        }
+        else {
+            const tail = chunk.slice(lastEsc);
+            this.midEscape = !/^\x1b(\[[0-9;?]*[@-~]|\][^\x07]*(\x07|\x1b\\)|[^[\]])/.test(tail);
+        }
+        if (this.dirty)
+            this.draw();
+    }
+    /** Removes the panel and gives the whole screen back, leaving the cursor below the output. */
+    stop() {
+        if (!this.active)
+            return;
+        this.active = false;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.out.off('resize', this.onResize);
+        const rows = this.out.rows || 24;
+        let seq = `${ESC}7`;
+        for (let r = rows - HEIGHT + 1; r <= rows; r++)
+            seq += `${ESC}[${r};1H${ESC}[2K`;
+        seq += `${ESC}[r${ESC}8\r\n`;
+        this.out.write(seq);
+        this.releaseRestore?.();
+        this.opts.onRowsChange?.(this.childRows);
+    }
+    onResize = () => {
+        this.setRegion();
+        this.draw();
+        this.opts.onRowsChange?.(this.childRows);
+    };
+    setRegion() {
+        // DECSTBM homes the cursor, so save and restore around it.
+        this.out.write(`${ESC}7${ESC}[1;${this.childRows}r${ESC}8`);
+    }
+    draw() {
+        if (!this.active || this.midEscape)
+            return;
+        this.dirty = false;
+        const rows = this.out.rows || 24;
+        const cols = this.out.columns || 80;
+        const lines = this.lines(cols);
+        let seq = `${ESC}7${ESC}[0m`;
+        lines.forEach((l, i) => (seq += `${ESC}[${rows - HEIGHT + 1 + i};1H${ESC}[2K${truncate(l, cols - 1)}`));
+        this.out.write(seq + `${ESC}8`);
+    }
+    lines(cols) {
+        const s = this.s;
+        const st = this.state;
+        // The status and timer always fit; the command title gives way.
+        const right = st ? ` ${outcomeLabel(st, s)} ${s.dim(elapsed(st))} ` : '';
+        const room = cols - 1 - 2 - width(right) - 2;
+        const label = truncate(` unfold · ${this.opts.title} `, Math.max(10, room));
+        const fill = Math.max(2, cols - 1 - 2 - width(label) - width(right));
+        const rule = s.dim('──') + s.bold(label) + s.dim('─'.repeat(fill)) + right;
+        if (!st)
+            return [rule, '', ''];
+        const focus = focusStage(st);
+        const last = focus.evidence.at(-1);
+        const detail = `${s.bold(focus.title)}${s.dim(':')} ${focus.note ?? focus.summary}${last && last.note !== focus.note ? s.dim(`  ·  ${last.note}`) : ''}`;
+        return [rule, ` ${flowLine(st, s, { frame: this.frame })}`, ` ${detail}`];
+    }
+}

package/dist/tui/render.js

@@ -0,0 +1,140 @@
+// Pure renderers shared by the live panel, the end-of-run summary and the explorer.
+import { rankCauses } from '../core/fix-prompt.js';
+import { style as makeStyle, truncate, wrapText } from './ansi.js';
+export const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export const STATUS_WORD = {
+    pending: 'waiting',
+    active: 'in progress',
+    confirmed: 'confirmed',
+    failed: 'failed',
+    unverified: 'unverified',
+};
+export function glyph(st, s, frame = 0) {
+    switch (st.status) {
+        case 'confirmed':
+            return s.green('✓');
+        case 'failed':
+            return s.red('✗');
+        case 'active':
+            return s.cyan(SPINNER[frame % SPINNER.length]);
+        case 'unverified':
+            return s.yellow('?');
+        default:
+            return s.dim('○');
+    }
+}
+const OUTCOME = { running: 'Running', success: 'Done', failure: 'Failed', interrupted: 'Stopped' };
+export function outcomeLabel(state, s) {
+    if (state.outcome === 'success' && state.stages.at(-1)?.status !== 'confirmed')
+        return s.yellow('Exited 0, not confirmed');
+    const word = state.outcome === 'success' ? (state.notes?.success ?? OUTCOME.success) : OUTCOME[state.outcome];
+    return state.outcome === 'success' ? s.green(word) : state.outcome === 'failure' ? s.red(word) : state.outcome === 'interrupted' ? s.yellow(word) : s.cyan(word);
+}
+export function elapsed(state, now = Date.now()) {
+    const sec = Math.max(0, ((state.endedAt ?? now) - state.startedAt) / 1000);
+    return sec < 60 ? `${sec.toFixed(1)}s` : `${Math.floor(sec / 60)}m ${Math.round(sec % 60)}s`;
+}
+/** The stage most worth showing right now. */
+export function focusStage(state) {
+    const st = state.stages;
+    if (state.failedStage)
+        return st.find((x) => x.id === state.failedStage);
+    const active = [...st].reverse().find((x) => x.status === 'active');
+    if (active)
+        return active;
+    if (state.outcome === 'success')
+        return st.at(-1);
+    const i = st.findIndex((x) => x.id === state.lastConfirmed);
+    if (state.outcome === 'interrupted')
+        return st[i + 1] ?? st[0];
+    return st[i] ?? st[0];
+}
+/** `✓ Prepare ── ✓ Upload ── ⠙ Build ── ○ Preview`, with an optional selected stage. */
+export function flowLine(state, s, opts = {}) {
+    return state.stages
+        .map((st, i) => {
+        const prev = state.stages[i - 1];
+        const link = i === 0 ? '' : prev?.status === 'confirmed' ? s.green(' ── ') : s.dim(' ── ');
+        const title = st.id === opts.selected ? s.inverse(` ${st.title} `) : st.status === 'pending' ? s.dim(st.title) : st.status === 'failed' ? s.red(s.bold(st.title)) : s.bold(st.title);
+        return `${link}${glyph(st, s, opts.frame)} ${title}`;
+    })
+        .join('');
+}
+const stripStamp = (t) => t.replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z {0,2}/, '');
+/** The command as shown in headers: executable base name plus arguments. */
+export const commandLabel = (state) => [state.command[0]?.split(/[\\/]/).pop(), ...state.command.slice(1)].join(' ');
+/** End-of-run summary printed in the terminal. */
+export function summary(state, logs, opts = {}) {
+    const s = opts.s ?? makeStyle();
+    const cols = Math.max(40, Math.min(opts.cols ?? 100, 110));
+    const out = [];
+    const line = (t = '') => out.push(truncate(t, cols));
+    // Labelled text that must stay complete: wrapped under its label, never cut.
+    const block = (label, text, suffix = '') => {
+        const indent = 10;
+        wrapText(text + suffix, Math.max(20, cols - indent)).forEach((l, i) => out.push((i === 0 ? `  ${label}` : '').padEnd(i === 0 ? 0 : indent) + (i === 0 ? ' '.repeat(Math.max(1, indent - 2 - label.replace(/\x1b\[[0-9;]*m/g, '').length)) : '') + l));
+    };
+    const titleW = Math.max(...state.stages.map((x) => x.title.length)) + 2;
+    // Outcome first so it survives truncation; only the command gives way.
+    line(`${s.bold('unfold')} ${s.dim('·')} ${outcomeLabel(state, s)} ${s.dim(`in ${elapsed(state)}`)} ${s.dim('·')} ${commandLabel(state)}`);
+    line();
+    for (const st of state.stages) {
+        const note = st.note ?? st.summary;
+        const indent = 4 + titleW;
+        wrapText(note, Math.max(20, cols - indent)).forEach((l, i) => {
+            const text = st.status === 'unverified' || st.status === 'pending' ? s.dim(l) : l;
+            out.push(i === 0 ? `  ${glyph(st, s)} ${(st.status === 'failed' ? s.red : s.bold)(st.title.padEnd(titleW))}${text}` : ' '.repeat(indent) + text);
+        });
+    }
+    if (state.outcome === 'failure') {
+        const fatal = state.errors.find((e) => e.severity === 'fatal');
+        const cause = rankCauses(state)[0];
+        line();
+        if (fatal)
+            block(s.red('Error'), fatal.message, ` (line ${fatal.seq})`);
+        if (cause)
+            block(s.yellow('Cause'), cause.message, ` (line ${cause.seq})`);
+        const ref = logs
+            .map((l) => stripStamp(l.text))
+            .find((t) => /^\.{0,2}\/?[\w@.-]+(\/[\w@.[\]-]+)*\.[A-Za-z]{1,5}:\d+/.test(t.trim()));
+        if (ref)
+            line(`  ${s.dim('File')}    ${ref.trim()}`);
+    }
+    if (state.outcome === 'interrupted') {
+        line();
+        block(s.yellow('Stopped'), focusStage(state).note ?? 'Ctrl+C stopped the command before it finished.');
+    }
+    const highlights = (state.notes?.highlights ?? []).map((k) => state.facts.find((f) => f.key === k)).filter((f) => !!f);
+    if (highlights.length) {
+        line();
+        const kw = Math.max(...highlights.map((f) => f.label.length)) + 2;
+        for (const f of highlights)
+            wrapText(f.value, Math.max(20, cols - kw - 2)).forEach((l, n) => out.push(`  ${n === 0 ? s.dim(f.label) + ' '.repeat(kw - f.label.length) : ' '.repeat(kw)}${l}`));
+    }
+    const url = state.facts.find((f) => f.key === 'alias') ?? state.facts.find((f) => f.key === 'deploymentUrl');
+    const inspect = state.facts.find((f) => f.key === 'inspectUrl' || f.key === 'logsUrl');
+    if (url || inspect)
+        line();
+    if (url && state.outcome === 'success')
+        line(`  ${s.dim('URL'.padEnd(8))}${s.cyan(url.value)}`);
+    if (inspect)
+        out.push(`  ${s.dim((inspect.key === 'logsUrl' ? 'Logs' : 'Inspect').padEnd(8))}${inspect.value}`);
+    if (state.fix?.commands) {
+        line();
+        line(`  ${s.bold('Fix it with an agent')} ${s.dim('(prompt built from this run)')}`);
+        // Printed in full so they can be copied as-is.
+        out.push(`  ${s.dim('Claude'.padEnd(8))}${state.fix.commands.claude}`);
+        out.push(`  ${s.dim('Codex'.padEnd(8))}${state.fix.commands.codex}`);
+    }
+    // Output but nothing recognized: likely a CLI format Unfold doesn't know yet.
+    if (state.endedAt && state.lineCount > 3 && state.stages.every((x) => x.status === 'unverified' || x.status === 'pending')) {
+        const version = state.facts.find((f) => f.key === 'cliVersion');
+        line();
+        for (const l of wrapText(`Unfold didn't recognize any of this output${version ? ` (${version.label} ${version.value})` : ''}, so no stage is confirmed. If this was a normal run, please report it at https://github.com/faizm10/unfold/issues.`, cols - 4))
+            out.push(`  ${s.yellow(l)}`);
+    }
+    const unverified = state.stages.filter((x) => x.status === 'unverified').length;
+    line();
+    line(s.dim(`  ${unverified ? `? = the output never confirmed it. ` : ''}Explore: unfold show${opts.webUrl ? ` · Browser: ${opts.webUrl}` : ' · in a browser: unfold show --web'}`));
+    return out.join('\n') + '\n';
+}

package/dist/tui/restore.js

@@ -0,0 +1,29 @@
+// Puts the terminal back the way we found it, even if Unfold crashes or is killed.
+// Anything that changes terminal state (raw mode, scroll region, alternate screen)
+// registers an undo here and removes it once it has cleaned up normally.
+const undos = new Set();
+let installed = false;
+function restoreAll() {
+    for (const undo of [...undos].reverse()) {
+        try {
+            undo();
+        }
+        catch {
+            // keep restoring the rest
+        }
+    }
+    undos.clear();
+}
+/** Registers an undo; call the returned function after cleaning up normally. */
+export function onRestore(undo) {
+    if (!installed) {
+        installed = true;
+        process.on('exit', restoreAll);
+    }
+    undos.add(undo);
+    return () => undos.delete(undo);
+}
+/** Restores the terminal now (used before printing a crash report). */
+export function restoreTerminal() {
+    restoreAll();
+}