@crouton-kit/humanloop 0.1.0 → 0.1.3

package/dist/tui/render.js

@@ -1,5 +1,45 @@
+import { execFileSync } from 'node:child_process';
 import stringWidth from 'string-width';
-import { getTerminalSize } from './terminal.js';
+// ── Termrender body rendering ────────────────────────────────────────────────
+let _termrenderAvail = null;
+function isTermrenderAvailable() {
+    if (_termrenderAvail !== null)
+        return _termrenderAvail;
+    try {
+        execFileSync('termrender', ['--version'], { stdio: 'pipe', timeout: 3000 });
+        _termrenderAvail = true;
+    }
+    catch {
+        _termrenderAvail = false;
+    }
+    return _termrenderAvail;
+}
+const _bodyCache = new Map();
+function renderBody(text, width) {
+    const key = `${text}\0${width}`;
+    const cached = _bodyCache.get(key);
+    if (cached)
+        return cached;
+    if (isTermrenderAvailable()) {
+        try {
+            const out = execFileSync('termrender', ['--width', String(width)], {
+                input: text,
+                encoding: 'utf-8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const lines = out.split('\n');
+            if (lines.length > 0 && lines[lines.length - 1] === '')
+                lines.pop();
+            _bodyCache.set(key, lines);
+            return lines;
+        }
+        catch { /* fall through */ }
+    }
+    const fallback = wrap(sanitize(text), width);
+    _bodyCache.set(key, fallback);
+    return fallback;
+}
 // ── ANSI helpers ─────────────────────────────────────────────────────────────
 const ESC = '\x1b[';
 const RESET = `${ESC}0m`;
@@ -8,24 +48,32 @@ const DIM = `${ESC}2m`;
 const ITALIC = `${ESC}3m`;
 const GREEN = `${ESC}32m`;
 const YELLOW = `${ESC}33m`;
-const BLUE = `${ESC}34m`;
-const MAGENTA = `${ESC}35m`;
 const CYAN = `${ESC}36m`;
-const GRAY = `${ESC}90m`;
-const BG_BLUE = `${ESC}44m`;
-const WHITE = `${ESC}37m`;
+const CONTROL_CHARS_RE = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b[@-_]|[\x00-\x08\x0B\x0E-\x1F\x7F-\x9F]/g;
+export function sanitize(text) {
+    if (typeof text !== 'string')
+        return '';
+    return text.replace(CONTROL_CHARS_RE, '');
+}
+function singleLine(text) {
+    return sanitize(text).replace(/\s+/g, ' ').trim();
+}
 function truncate(text, maxWidth) {
+    if (maxWidth < 1)
+        return '';
     if (stringWidth(text) <= maxWidth)
         return text;
+    const chars = [...text];
     let w = 0;
-    let i = 0;
-    for (; i < text.length; i++) {
-        const cw = stringWidth(text[i]);
+    let out = '';
+    for (const ch of chars) {
+        const cw = stringWidth(ch);
         if (w + cw + 1 > maxWidth)
             break;
+        out += ch;
         w += cw;
     }
-    return text.slice(0, i) + '…';
+    return out + '…';
 }
 function padRight(text, width) {
     const w = stringWidth(text);
@@ -34,26 +82,61 @@ function padRight(text, width) {
     return text + ' '.repeat(width - w);
 }
 function hline(width, char = '─') {
+    if (width < 1)
+        return '';
     return char.repeat(width);
 }
 function wrap(text, maxWidth) {
-    const words = text.split(/\s+/);
-    const lines = [];
-    let current = '';
-    for (const word of words) {
-        const candidate = current ? `${current} ${word}` : word;
-        if (stringWidth(candidate) <= maxWidth) {
-            current = candidate;
+    if (maxWidth < 1)
+        return [text];
+    const out = [];
+    const paragraphs = text.split('\n');
+    for (let p = 0; p < paragraphs.length; p++) {
+        const para = paragraphs[p];
+        if (para === '') {
+            out.push('');
+            continue;
         }
-        else {
-            if (current)
-                lines.push(current);
-            current = word;
+        const words = para.split(/[ \t]+/).filter(Boolean);
+        let current = '';
+        for (let word of words) {
+            while (stringWidth(word) > maxWidth) {
+                if (current) {
+                    out.push(current);
+                    current = '';
+                }
+                const piece = sliceByWidth(word, maxWidth);
+                out.push(piece);
+                word = word.slice(piece.length);
+            }
+            const candidate = current ? `${current} ${word}` : word;
+            if (stringWidth(candidate) <= maxWidth) {
+                current = candidate;
+            }
+            else {
+                if (current)
+                    out.push(current);
+                current = word;
+            }
         }
+        if (current)
+            out.push(current);
     }
-    if (current)
-        lines.push(current);
-    return lines.length > 0 ? lines : [''];
+    return out.length > 0 ? out : [''];
+}
+function sliceByWidth(s, maxWidth) {
+    let w = 0;
+    let out = '';
+    for (const ch of s) {
+        const cw = stringWidth(ch);
+        if (w + cw > maxWidth)
+            break;
+        out += ch;
+        w += cw;
+    }
+    if (out === '' && s.length > 0)
+        out = [...s][0];
+    return out;
 }
 function hardWrap(text, maxWidth) {
     if (maxWidth < 1)
@@ -67,7 +150,7 @@ function hardWrap(text, maxWidth) {
         }
         let current = '';
         let currentW = 0;
-        for (const ch of seg) {
+        for (const ch of [...seg]) {
             const cw = stringWidth(ch);
             if (currentW + cw > maxWidth) {
                 out.push(current);
@@ -84,196 +167,285 @@ function hardWrap(text, maxWidth) {
     return out;
 }
 // ── Frame buffer ─────────────────────────────────────────────────────────────
-let prevFrame = [];
-export function flush(lines) {
-    const { rows } = getTerminalSize();
-    process.stdout.write('\x1b[?2026h');
+export function diffFrame(prevFrame, nextLines, rows) {
+    const writes = [];
     for (let i = 0; i < rows; i++) {
-        const line = i < lines.length ? lines[i] : '';
+        const line = i < nextLines.length ? nextLines[i] : '';
         if (prevFrame[i] !== line) {
-            process.stdout.write(`${ESC}${i + 1};1H${ESC}2K${line}`);
+            writes.push(`${ESC}${i + 1};1H${ESC}2K${line}`);
         }
     }
-    process.stdout.write('\x1b[?2026l');
-    prevFrame = [...lines];
+    return { writes, nextPrevFrame: [...nextLines] };
 }
 // ── Renderers ────────────────────────────────────────────────────────────────
-export function renderOverview(state) {
-    const { cols, rows } = getTerminalSize();
+export function renderOverview(state, cols, rows) {
     const lines = [];
     const title = `${BOLD}${CYAN} Decisions ${RESET}`;
-    const progress = `${state.answers.size}/${state.questions.length} answered`;
+    const progress = `${state.responses.size}/${state.interactions.length} answered`;
     lines.push('');
     lines.push(`  ${title}  ${DIM}${progress}${RESET}`);
     lines.push(`  ${DIM}${hline(Math.min(cols - 4, 60))}${RESET}`);
     lines.push('');
-    for (let i = 0; i < state.questions.length; i++) {
-        const q = state.questions[i];
-        const answer = state.answers.get(q.id);
-        const icon = answer ? `${GREEN}✓${RESET}` : `${DIM}○${RESET}`;
-        const label = q.type === 'validation' ? q.statement : q.question;
-        const typeTag = `${DIM}[${q.type}]${RESET}`;
+    const rowsBuf = [];
+    for (let i = 0; i < state.interactions.length; i++) {
+        const interaction = state.interactions[i];
+        const response = state.responses.get(interaction.id);
+        const icon = response ? `${GREEN}✓${RESET}` : `${DIM}○${RESET}`;
+        const label = singleLine(interaction.title);
         const cursor = i === state.currentIndex ? `${CYAN}▸${RESET} ` : '  ';
-        lines.push(`  ${cursor}${icon} ${truncate(label, cols - 20)} ${typeTag}`);
-        if (answer) {
-            const summary = answerSummary(answer);
-            lines.push(`      ${DIM}${truncate(summary, cols - 10)}${RESET}`);
+        const labelMax = Math.max(10, cols - 16);
+        rowsBuf.push({
+            line: `  ${cursor}${icon} ${truncate(label, labelMax)}`,
+            questionIndex: i,
+        });
+        if (response) {
+            const summary = singleLine(responseSummary(response, interaction));
+            const summaryMax = Math.max(10, cols - 10);
+            rowsBuf.push({
+                line: `      ${DIM}${truncate(summary, summaryMax)}${RESET}`,
+                questionIndex: i,
+            });
         }
     }
-    lines.push('');
+    const reserved = 4 + 3 + 2;
+    const available = Math.max(1, rows - reserved);
+    let scroll = state.scrollOffset || 0;
+    const focusRow = rowsBuf.findIndex((r) => r.questionIndex === state.currentIndex);
+    if (focusRow >= 0) {
+        if (focusRow < scroll)
+            scroll = focusRow;
+        if (focusRow >= scroll + available)
+            scroll = focusRow - available + 1;
+    }
+    scroll = Math.max(0, Math.min(scroll, Math.max(0, rowsBuf.length - available)));
+    if (scroll > 0) {
+        lines.push(`  ${DIM}↑ ${scroll} more above${RESET}`);
+    }
+    else {
+        lines.push('');
+    }
+    const end = Math.min(rowsBuf.length, scroll + available);
+    for (let i = scroll; i < end; i++)
+        lines.push(rowsBuf[i].line);
+    if (end < rowsBuf.length) {
+        lines.push(`  ${DIM}↓ ${rowsBuf.length - end} more below${RESET}`);
+    }
+    else {
+        lines.push('');
+    }
     lines.push(`  ${DIM}${hline(Math.min(cols - 4, 60))}${RESET}`);
     lines.push(`  ${DIM}enter${RESET} review  ${DIM}j/k${RESET} navigate  ${DIM}q${RESET} finish`);
     while (lines.length < rows)
         lines.push('');
-    return lines;
+    return lines.slice(0, rows);
 }
-export function renderItemReview(state) {
-    const { cols, rows } = getTerminalSize();
-    const lines = [];
-    const q = state.questions[state.currentIndex];
-    const visual = state.visuals.get(q.id);
-    const answer = state.answers.get(q.id);
-    const maxW = Math.min(cols - 4, 76);
-    // Header
-    const pos = `${state.currentIndex + 1}/${state.questions.length}`;
-    lines.push('');
-    lines.push(`  ${BOLD}${CYAN}[${pos}]${RESET} ${DIM}${q.type}${RESET}`);
-    lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
-    lines.push('');
-    // Question / Statement
-    const headline = q.type === 'validation' ? q.statement : q.question;
-    for (const line of wrap(headline, maxW)) {
-        lines.push(`  ${BOLD}${line}${RESET}`);
+export function renderItemReview(state, cols, rows) {
+    const interaction = state.interactions[state.currentIndex];
+    const visual = state.visuals.get(interaction.id);
+    const response = state.responses.get(interaction.id);
+    const maxW = Math.min(cols - 4, 120);
+    // Pre-body: position, divider, title, subtitle (always visible)
+    const preLines = [];
+    const pos = `${state.currentIndex + 1}/${state.interactions.length}`;
+    preLines.push('');
+    preLines.push(`  ${BOLD}${CYAN}[${pos}]${RESET}`);
+    preLines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+    preLines.push('');
+    for (const line of wrap(sanitize(interaction.title), maxW)) {
+        preLines.push(`  ${BOLD}${line}${RESET}`);
     }
-    for (const line of wrap(q.rationale, maxW)) {
-        lines.push(`  ${ITALIC}${GRAY}${line}${RESET}`);
+    if (interaction.subtitle) {
+        for (const line of wrap(sanitize(interaction.subtitle), maxW)) {
+            preLines.push(`  ${DIM}${line}${RESET}`);
+        }
     }
-    lines.push('');
-    // Visual context
+    // Body: rendered question body + expanded visual block (scrollable)
+    const bodyLines = [];
+    if (interaction.body) {
+        bodyLines.push('');
+        for (const line of renderBody(interaction.body, maxW)) {
+            bodyLines.push(`  ${line}`);
+        }
+    }
+    if (visual && visual.status === 'ready' && state.detailExpanded) {
+        bodyLines.push('');
+        bodyLines.push(`  ${DIM}── context ${hline(maxW - 12)}${RESET}`);
+        for (const vl of visual.content.split('\n')) {
+            bodyLines.push(`  ${vl}`);
+        }
+        bodyLines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+    }
+    // Post-body: visual status hint, input buffer or actions, footer (always visible)
+    const postLines = [];
+    postLines.push('');
     if (visual) {
         if (visual.status === 'loading') {
-            lines.push(`  ${DIM}loading context...${RESET}`);
+            postLines.push(`  ${DIM}loading context...${RESET}`);
+            postLines.push('');
         }
         else if (visual.status === 'error') {
-            lines.push(`  ${YELLOW}visual context unavailable${RESET}`);
+            postLines.push(`  ${YELLOW}visual context unavailable${RESET}`);
+            postLines.push('');
         }
-        else if (state.detailExpanded) {
-            lines.push(`  ${DIM}── context ${hline(maxW - 12)}${RESET}`);
-            for (const vl of visual.content.split('\n')) {
-                lines.push(`  ${vl}`);
-            }
-            lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+        else if (!state.detailExpanded) {
+            postLines.push(`  ${DIM}[space] expand context${RESET}`);
+            postLines.push('');
         }
-        else {
-            lines.push(`  ${DIM}[space] expand context${RESET}`);
-        }
-        lines.push('');
     }
-    // Input mode
     if (state.inputMode) {
-        lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
-        const label = state.inputMode.kind === 'comment' ? 'Comment'
-            : state.inputMode.kind === 'freetext' ? 'Response'
-                : 'Custom option';
-        lines.push(`  ${YELLOW}${label}:${RESET}`);
+        postLines.push(`  ${DIM}${hline(maxW)}${RESET}`);
+        const label = interaction.freetextLabel !== undefined
+            ? interaction.freetextLabel
+            : state.inputMode.kind === 'comment' ? 'Comment' : 'Response';
+        // Show attached option (comment mode only) — Tab cycles
+        let attachedLine;
+        if (state.inputMode.kind === 'comment') {
+            const attachedId = state.inputMode.selectedOptionId;
+            const opts = interaction.options;
+            if (opts.length > 0) {
+                const attached = attachedId !== undefined
+                    ? opts.find((o) => o.id === attachedId)
+                    : undefined;
+                const valueText = attached !== undefined
+                    ? `${CYAN}${sanitize(attached.label)}${RESET}`
+                    : `${DIM}none${RESET}`;
+                attachedLine = `  ${DIM}attached:${RESET} ${valueText}  ${DIM}[tab to cycle]${RESET}`;
+            }
+        }
+        postLines.push(`  ${YELLOW}${label}:${RESET}`);
         const bufLines = hardWrap(state.inputMode.buffer, maxW - 1);
         for (let i = 0; i < bufLines.length; i++) {
             const isLast = i === bufLines.length - 1;
-            lines.push(`  ${bufLines[i]}${isLast ? '█' : ''}`);
+            postLines.push(`  ${bufLines[i]}${isLast ? '█' : ''}`);
         }
-        lines.push('');
-        lines.push(`  ${DIM}enter${RESET} submit  ${DIM}esc${RESET} cancel`);
+        if (attachedLine !== undefined) {
+            postLines.push('');
+            postLines.push(attachedLine);
+        }
+        postLines.push('');
+        postLines.push(`  ${DIM}enter${RESET} submit  ${DIM}esc${RESET} cancel`);
     }
     else {
-        // Actions
-        lines.push(...renderActions(q, state.selectedAction, answer));
+        postLines.push(...renderActions(interaction, state.selectedAction, response));
     }
-    // Footer
-    while (lines.length < rows - 1)
-        lines.push('');
+    // Window the body
+    const reservedRows = preLines.length + postLines.length + 1; // +1 for footer
+    const bodyHeight = Math.max(1, rows - reservedRows);
+    const overflows = bodyLines.length > bodyHeight;
+    let scroll = state.scrollOffset || 0;
+    const maxScroll = Math.max(0, bodyLines.length - bodyHeight);
+    scroll = Math.max(0, Math.min(scroll, maxScroll));
+    state.scrollOffset = scroll;
+    let visibleBody;
+    if (overflows) {
+        visibleBody = bodyLines.slice(scroll, scroll + bodyHeight);
+        if (scroll > 0) {
+            visibleBody[0] = `  ${DIM}↑ ${scroll} more above${RESET}`;
+        }
+        const remainingBelow = bodyLines.length - (scroll + bodyHeight);
+        if (remainingBelow > 0) {
+            visibleBody[visibleBody.length - 1] = `  ${DIM}↓ ${remainingBelow} more below${RESET}`;
+        }
+    }
+    else {
+        visibleBody = bodyLines;
+    }
+    // Footer hint — mention scroll keys when body overflows
     const footerParts = [
         `${DIM}n/p${RESET} prev/next`,
         `${DIM}space${RESET} expand`,
         `${DIM}q${RESET} overview`,
     ];
-    lines.push(`  ${footerParts.join('  ')}`);
+    if (overflows)
+        footerParts.unshift(`${DIM}u/d${RESET} scroll`);
+    const footer = `  ${footerParts.join('  ')}`;
+    // Assemble — pad to fill rows so post-body sits at the bottom
+    const lines = [...preLines, ...visibleBody, ...postLines];
+    while (lines.length < rows - 1)
+        lines.push('');
+    lines.push(footer);
+    // Final clamp (safety net for very small terminals)
+    if (lines.length > rows) {
+        return [...lines.slice(0, rows - 1), footer];
+    }
     return lines;
 }
-function renderActions(q, selectedAction, existing) {
+function renderActions(interaction, selectedAction, existing) {
     const lines = [];
-    if (q.type === 'validation') {
-        const actions = [
-            { key: '1', label: 'Approve', desc: 'accept as stated' },
-            { key: '2', label: 'Approve + comment', desc: 'accept with note' },
-            { key: '3', label: 'Reject', desc: 'do not accept as stated' },
-            { key: '4', label: 'Comment', desc: 'feedback without decision' },
-        ];
-        for (let i = 0; i < actions.length; i++) {
-            const a = actions[i];
-            const cursor = i === selectedAction ? `${CYAN}▸${RESET}` : ' ';
-            const keyBadge = `${DIM}[${a.key}]${RESET}`;
-            lines.push(`  ${cursor} ${keyBadge} ${a.label} ${DIM}— ${a.desc}${RESET}`);
-        }
+    const opts = interaction.options;
+    for (let i = 0; i < opts.length; i++) {
+        const o = opts[i];
+        const cursor = i === selectedAction ? `${CYAN}▸${RESET}` : ' ';
+        const sc = o.shortcut ?? ' ';
+        const keyBadge = `${DIM}[${sc}]${RESET}`;
+        const desc = o.description ? ` ${DIM}— ${sanitize(o.description)}${RESET}` : '';
+        lines.push(`  ${cursor} ${keyBadge} ${sanitize(o.label)}${desc}`);
     }
-    else if (q.type === 'choice') {
-        for (let i = 0; i < q.options.length; i++) {
-            const cursor = i === selectedAction ? `${CYAN}▸${RESET}` : ' ';
-            const keyBadge = `${DIM}[${i + 1}]${RESET}`;
-            lines.push(`  ${cursor} ${keyBadge} ${q.options[i]}`);
-        }
-        const otherIdx = q.options.length;
-        const cursor = otherIdx === selectedAction ? `${CYAN}▸${RESET}` : ' ';
-        lines.push(`  ${cursor} ${DIM}[${otherIdx + 1}]${RESET} ${ITALIC}Other (custom)${RESET}`);
+    if (interaction.allowFreetext && opts.length > 0) {
+        const cursor = opts.length === selectedAction ? `${CYAN}▸${RESET}` : ' ';
+        const label = interaction.freetextLabel !== undefined ? interaction.freetextLabel : 'Add comment';
+        lines.push(`  ${cursor} ${DIM}[c]${RESET} ${label}`);
     }
-    else {
-        lines.push(`  ${DIM}[r]${RESET} Enter response`);
+    else if (interaction.allowFreetext && opts.length === 0) {
+        const ftLabel = interaction.freetextLabel !== undefined ? interaction.freetextLabel : 'Enter response';
+        lines.push(`  ${DIM}[r]${RESET} ${ftLabel}`);
     }
     if (existing) {
         lines.push('');
-        lines.push(`  ${GREEN}Current: ${answerSummary(existing)}${RESET}`);
+        lines.push(`  ${GREEN}Current: ${responseSummary(existing, interaction)}${RESET}`);
     }
     return lines;
 }
-export function renderFinal(state) {
-    const { cols, rows } = getTerminalSize();
-    const lines = [];
+export function renderFinal(state, cols, rows) {
+    const header = [];
+    const footer = [];
     const maxW = Math.min(cols - 4, 60);
-    const total = state.questions.length;
-    const answered = state.answers.size;
-    lines.push('');
-    lines.push(`  ${BOLD}${CYAN} Summary ${RESET}`);
-    lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
-    lines.push('');
-    lines.push(`  ${answered}/${total} questions answered`);
-    lines.push('');
-    for (const q of state.questions) {
-        const answer = state.answers.get(q.id);
-        const icon = answer ? `${GREEN}✓${RESET}` : `${YELLOW}○${RESET}`;
-        const label = q.type === 'validation' ? q.statement : q.question;
-        lines.push(`  ${icon} ${truncate(label, maxW - 4)}`);
-        if (answer) {
-            lines.push(`    ${DIM}${truncate(answerSummary(answer), maxW - 6)}${RESET}`);
+    const total = state.interactions.length;
+    const answered = state.responses.size;
+    header.push('');
+    header.push(`  ${BOLD}${CYAN} Summary ${RESET}`);
+    header.push(`  ${DIM}${hline(maxW)}${RESET}`);
+    header.push('');
+    header.push(`  ${answered}/${total} questions answered`);
+    header.push('');
+    footer.push('');
+    footer.push(`  ${DIM}${hline(maxW)}${RESET}`);
+    if (answered < total) {
+        footer.push(`  ${YELLOW}${total - answered} unanswered — press p to go back${RESET}`);
+    }
+    footer.push(`  ${DIM}enter${RESET} submit  ${DIM}p${RESET} go back`);
+    const questionRows = [];
+    for (const interaction of state.interactions) {
+        const response = state.responses.get(interaction.id);
+        const icon = response ? `${GREEN}✓${RESET}` : `${YELLOW}○${RESET}`;
+        const label = singleLine(interaction.title);
+        questionRows.push(`  ${icon} ${truncate(label, Math.max(10, maxW - 4))}`);
+        if (response) {
+            questionRows.push(`    ${DIM}${truncate(singleLine(responseSummary(response, interaction)), Math.max(10, maxW - 6))}${RESET}`);
         }
     }
-    lines.push('');
-    lines.push(`  ${DIM}${hline(maxW)}${RESET}`);
-    if (answered < total) {
-        lines.push(`  ${YELLOW}${total - answered} unanswered — press p to go back${RESET}`);
+    const available = Math.max(1, rows - header.length - footer.length - 1);
+    let visible = questionRows;
+    if (questionRows.length > available) {
+        visible = [
+            ...questionRows.slice(0, available - 1),
+            `  ${DIM}… ${questionRows.length - (available - 1)} more rows omitted${RESET}`,
+        ];
     }
-    lines.push(`  ${DIM}enter${RESET} submit  ${DIM}p${RESET} go back`);
+    const lines = [...header, ...visible, ...footer];
     while (lines.length < rows)
         lines.push('');
-    return lines;
+    return lines.slice(0, rows);
 }
-function answerSummary(a) {
-    switch (a.type) {
-        case 'validation':
-            return a.approved
-                ? (a.comment ? `approved: "${a.comment}"` : 'approved')
-                : (a.comment ? `commented: "${a.comment}"` : 'commented');
-        case 'choice':
-            return a.isCustom ? `custom: "${a.selected}"` : a.selected;
-        case 'freetext':
-            return a.response;
-    }
+export function responseSummary(r, interaction) {
+    const opt = r.selectedOptionId
+        ? interaction.options.find((o) => o.id === r.selectedOptionId)
+        : undefined;
+    if (opt && r.freetext)
+        return `${sanitize(opt.label)}: "${sanitize(r.freetext)}"`;
+    if (opt)
+        return sanitize(opt.label);
+    if (r.freetext)
+        return sanitize(r.freetext);
+    return '(empty)';
 }

package/dist/tui/terminal.js

@@ -41,6 +41,11 @@ export function parseKeypress(data) {
         const ch = String.fromCharCode(str.charCodeAt(0) + 64).toLowerCase();
         return { input: ch, key };
     }
+    // Multi-byte chunks (paste, multi-byte UTF-8, unknown escape sequences)
+    // are returned as-is in `input`; the input-mode handler is responsible for
+    // sanitising them before appending to its buffer. Top-level handlers
+    // ignore strings of length > 1, which is the desired behaviour for
+    // accidentally pasted text in overview/item-review.
     return { input: str, key };
 }
 export function setupTerminal() {

package/dist/tui/tmux.d.ts

@@ -1,6 +1,10 @@
-import type { DecisionsOutput } from '../types.js';
+import type { InteractionResponse } from '../types.js';
+export interface TuiOutput {
+    responses: InteractionResponse[];
+    completedAt: string;
+}
 export interface TmuxDispatchOpts {
     sessionId?: string;
     visuals: boolean;
 }
-export declare function dispatchToTmuxPane(file: string, opts: TmuxDispatchOpts): Promise<DecisionsOutput>;
+export declare function dispatchToTmuxPane(file: string, opts: TmuxDispatchOpts): Promise<TuiOutput>;

package/dist/tui/tmux.js

@@ -32,12 +32,30 @@ export async function dispatchToTmuxPane(file, opts) {
     const dir = mkdtempSync(join(tmpdir(), 'hl-'));
     const resultPath = join(dir, 'result.json');
     const cmd = buildChildCmd(file, resultPath, opts);
-    execFileSync('tmux', ['split-window', '-h', '-d', cmd], { stdio: 'ignore' });
-    await new Promise((resolve) => {
+    // Capture the spawned pane id so we can detect if the user closes it
+    // without finishing — otherwise the parent would poll forever.
+    const paneId = execFileSync('tmux', ['split-window', '-P', '-F', '#{pane_id}', '-h', '-d', cmd], { encoding: 'utf8' }).trim();
+    await new Promise((resolve, reject) => {
         const poll = setInterval(() => {
             if (existsSync(resultPath)) {
                 clearInterval(poll);
                 resolve();
+                return;
+            }
+            // Check the pane is still alive. If it's gone and there's still no
+            // result file, the child died (closed pane, crash, etc).
+            try {
+                const panes = execFileSync('tmux', ['list-panes', '-a', '-F', '#{pane_id}'], {
+                    encoding: 'utf8',
+                });
+                if (!panes.split('\n').map((s) => s.trim()).includes(paneId)) {
+                    clearInterval(poll);
+                    reject(new Error(`tmux pane ${paneId} closed before writing a result`));
+                }
+            }
+            catch (err) {
+                clearInterval(poll);
+                reject(new Error(`tmux list-panes failed: ${err instanceof Error ? err.message : String(err)}`));
             }
         }, 150);
     });