@north-light/api 0.3.580 → 0.3.587

package/dist/clients/inbox/tui/input.js

@@ -0,0 +1,392 @@
+import { isResponseBearingSlot } from '../../../core/human/page-schema.js';
+import { panItemReview, verticalCursor, wordLeftIndex, wordRightIndex } from './render.js';
+import { commentAnchors, commentIdFor, pageComplete, responseAnswers, slotActions, slotAnswered, terminalAnswerable } from './slots.js';
+/** Only a single-mode options/cards pick jumps ahead; a table pick leaves the user on the table. */
+const autoAdvances = (slot, mode) => mode === 'single' && (slot.kind === 'options' || slot.kind === 'cards');
+export function handleKeypress(input, key, state, render, exit) {
+    if (key.ctrl && input === 'c') {
+        exit(false);
+        return;
+    }
+    state.hint = undefined;
+    if (state.inputMode !== null) {
+        handleInputMode(input, key, state, render);
+        return;
+    }
+    if (state.phase === 'overview')
+        handleOverview(input, key, state, render, exit);
+    else if (state.phase === 'item-review')
+        handleItemReview(input, key, state, render, exit);
+    else
+        handleFinal(input, key, state, render, exit);
+}
+/** The one vertical-scroll gesture, shared by all three page screens: a long
+ *  page must be readable wherever its content sits, and every screen draws its
+ *  content into the same windowed rectangle. Each screen clamps the offset
+ *  against its own rendered length at draw time, so this only ever moves it. */
+function scrollKey(input, key, state) {
+    if (input === 'd' || key.pageDown || (key.ctrl && (input === 'd' || input === 'e'))) {
+        state.scrollOffset += input === 'e' ? 1 : 10;
+        state.followSelection = false;
+        return true;
+    }
+    if (input === 'u' || key.pageUp || (key.ctrl && (input === 'u' || input === 'y'))) {
+        state.scrollOffset = Math.max(0, state.scrollOffset - (input === 'y' ? 1 : 10));
+        state.followSelection = false;
+        return true;
+    }
+    return false;
+}
+function handleOverview(input, key, state, render, exit) {
+    if (scrollKey(input, key, state)) {
+        render();
+        return;
+    }
+    if (input === 'j' || key.downArrow) {
+        state.currentIndex = Math.min(state.currentIndex + 1, Math.max(0, state.slots.length - 1));
+        state.followSelection = true;
+    }
+    else if (input === 'k' || key.upArrow) {
+        state.currentIndex = Math.max(state.currentIndex - 1, 0);
+        state.followSelection = true;
+    }
+    else if ((key.return || input === ' ') && state.slots.length > 0) {
+        state.phase = 'item-review';
+        resetItem(state);
+    }
+    else if (input === 'q' || key.escape) {
+        exit(!state.manifest.slots.some(isResponseBearingSlot));
+        return;
+    }
+    else
+        return;
+    render();
+}
+function handleItemReview(input, key, state, render, exit) {
+    const slot = state.slots[state.currentIndex];
+    if (slot === undefined) {
+        state.phase = 'overview';
+        render();
+        return;
+    }
+    const actions = slotActions(slot);
+    if (input === 'n') {
+        advanceItem(state, 1);
+        render();
+        return;
+    }
+    if (input === 'p') {
+        advanceItem(state, -1);
+        render();
+        return;
+    }
+    if (input === 'q' || key.escape) {
+        exit(false);
+        return;
+    }
+    if (scrollKey(input, key, state)) {
+        render();
+        return;
+    }
+    if ((input === 'h' || input === 'l' || key.leftArrow || key.rightArrow) && state.hscrollMax > 0 && !actions.some((a) => a.kind === 'select' && a.shortcut === input)) {
+        panItemReview(state, input === 'h' || key.leftArrow ? -1 : 1);
+        render();
+        return;
+    }
+    if (input === 'j' || key.downArrow) {
+        state.selectedAction = Math.min(state.selectedAction + 1, Math.max(0, actions.length - 1));
+        render();
+        return;
+    }
+    if (input === 'k' || key.upArrow) {
+        state.selectedAction = Math.max(0, state.selectedAction - 1);
+        render();
+        return;
+    }
+    if (input === 'c' && commentAnchors(slot).length > 0) {
+        startComment(state, slot, actions);
+        render();
+        return;
+    }
+    const shortcut = actions.find((a) => a.kind === 'select' && a.shortcut === input);
+    if (shortcut?.kind === 'select') {
+        commitSelection(state, slot, shortcut, autoAdvances(slot, shortcut.mode));
+        render();
+        if (autoAdvances(slot, shortcut.mode) && state.phase === 'final' && pageComplete(state))
+            exit(true);
+        return;
+    }
+    if (input === ' ' && actions[state.selectedAction]?.kind === 'select') {
+        const action = actions[state.selectedAction];
+        commitSelection(state, slot, action, autoAdvances(slot, action.mode));
+        render();
+        if (autoAdvances(slot, action.mode) && state.phase === 'final' && pageComplete(state))
+            exit(true);
+        return;
+    }
+    if (input === 'r' && actions.some((a) => a.kind === 'freetext')) {
+        const r = responseFor(slot, state.responses.get(slot.id));
+        state.inputMode = { kind: 'freetext', buffer: r.freetext ?? '', cursor: [...(r.freetext ?? '')].length };
+        render();
+        return;
+    }
+    if (input === 'e' && actions.some((a) => a.kind === 'edit')) {
+        const r = responseFor(slot, state.responses.get(slot.id));
+        state.inputMode = { kind: 'text', buffer: r.text, cursor: [...r.text].length };
+        render();
+        return;
+    }
+    if (input === 'a' && actions.some((a) => a.kind === 'accept')) {
+        setResponse(state, slot, { text: slot.config.initialText, edited: false });
+        advanceToNextIncomplete(state);
+        render();
+        return;
+    }
+    if (key.return) {
+        const action = actions[state.selectedAction];
+        if (action?.kind === 'freetext') {
+            const r = responseFor(slot, state.responses.get(slot.id));
+            state.inputMode = { kind: 'freetext', buffer: r.freetext ?? '', cursor: [...(r.freetext ?? '')].length };
+            render();
+            return;
+        }
+        if (action?.kind === 'edit') {
+            const r = responseFor(slot, state.responses.get(slot.id));
+            state.inputMode = { kind: 'text', buffer: r.text, cursor: [...r.text].length };
+            render();
+            return;
+        }
+        if (action?.kind === 'accept') {
+            setResponse(state, slot, { text: slot.config.initialText, edited: false });
+            advanceToNextIncomplete(state);
+            render();
+            return;
+        }
+        if (slotAnswered(state, slot)) {
+            advanceToNextIncomplete(state);
+            render();
+            return;
+        }
+        // Enter settles a question whose current value already answers it: an optional picker
+        // left empty is a real answer, not a skipped one.
+        if (terminalAnswerable(slot)) {
+            const settled = responseFor(slot, state.responses.get(slot.id));
+            if (responseAnswers(state, slot, settled)) {
+                setResponse(state, slot, settled);
+                advanceToNextIncomplete(state);
+                render();
+                return;
+            }
+        }
+        if (isResponseBearingSlot(slot)) {
+            state.hint = terminalAnswerable(slot) ? 'Select at least one option (space to toggle), or q to go back' : 'This must be answered in Northlight';
+            render();
+            return;
+        }
+        advanceItem(state, 1);
+        render();
+    }
+}
+function handleFinal(input, key, state, render, exit) {
+    if (input === 'q' || key.escape) {
+        state.phase = state.slots.length === 1 ? 'item-review' : 'overview';
+        state.scrollOffset = 0;
+        render();
+        return;
+    }
+    if (scrollKey(input, key, state)) {
+        render();
+        return;
+    }
+    if (key.return && (pageComplete(state) || !state.manifest.slots.some(isResponseBearingSlot)))
+        exit(true);
+}
+function resetItem(state) { state.selectedAction = 0; state.scrollOffset = 0; state.followSelection = true; state.hscrollOffset = 0; state.hscrollMax = 0; }
+function advanceItem(state, delta) {
+    const next = state.currentIndex + delta;
+    // Every phase reads the one scrollOffset, so entering a screen starts it at
+    // the top rather than inheriting how far the previous screen was scrolled.
+    if (next < 0) {
+        state.phase = state.slots.length > 1 ? 'overview' : 'item-review';
+        state.scrollOffset = 0;
+        state.followSelection = true;
+        return;
+    }
+    if (next >= state.slots.length) {
+        state.phase = 'final';
+        state.scrollOffset = 0;
+        state.followSelection = true;
+        return;
+    }
+    state.currentIndex = next;
+    resetItem(state);
+}
+function advanceToNextIncomplete(state) {
+    for (let i = state.currentIndex + 1; i < state.slots.length; i++) {
+        const slot = state.slots[i];
+        if (isResponseBearingSlot(slot) && !slotAnswered(state, slot)) {
+            state.currentIndex = i;
+            resetItem(state);
+            return;
+        }
+    }
+    state.phase = 'final';
+    state.scrollOffset = 0;
+}
+function responseFor(slot, existing) {
+    if (existing !== undefined)
+        return existing;
+    if (slot.kind === 'options')
+        return { selectedOptionIds: [], comments: [] };
+    if (slot.kind === 'cards')
+        return { selectedCardIds: [] };
+    if (slot.kind === 'table')
+        return { selectedRowIds: [], selectedColumnIds: [], comments: [] };
+    if (slot.kind === 'text')
+        return { text: slot.config.initialText, edited: false };
+    return {};
+}
+function commentsFor(response) { return [...((response?.comments) ?? [])]; }
+function setResponse(state, slot, response) { if (slot.id === undefined)
+    return; state.responses.set(slot.id, response); state.persist?.(); }
+function commitSelection(state, slot, action, advance) {
+    const response = responseFor(slot, state.responses.get(slot.id));
+    if (slot.kind === 'options') {
+        const r = response;
+        const ids = toggleIds(r.selectedOptionIds, action.id, action.mode);
+        setResponse(state, slot, { ...r, selectedOptionIds: ids });
+    }
+    else if (slot.kind === 'cards') {
+        const r = response;
+        setResponse(state, slot, { ...r, selectedCardIds: toggleIds(r.selectedCardIds, action.id, action.mode) });
+    }
+    else if (slot.kind === 'table') {
+        const r = response;
+        if (action.group === 'row')
+            setResponse(state, slot, { ...r, selectedRowIds: toggleIds(r.selectedRowIds, action.id, action.mode) });
+        else
+            setResponse(state, slot, { ...r, selectedColumnIds: toggleIds(r.selectedColumnIds, action.id, action.mode) });
+    }
+    if (advance)
+        advanceToNextIncomplete(state);
+}
+function toggleIds(ids, id, mode) { if (mode === 'single')
+    return [id]; return ids.includes(id) ? ids.filter((x) => x !== id) : [...ids, id]; }
+function anchorFor(action) {
+    if (action?.kind !== 'select')
+        return undefined;
+    if (action.group === 'option')
+        return { kind: 'option', optionId: action.id };
+    if (action.group === 'row')
+        return { kind: 'row', rowId: action.id };
+    return undefined;
+}
+function startComment(state, slot, actions) {
+    const anchor = anchorFor(actions[state.selectedAction]) ?? commentAnchors(slot)[0];
+    const comments = commentsFor(slot.id === undefined ? undefined : state.responses.get(slot.id));
+    const prior = comments.find((c) => c.id === commentIdFor(anchor))?.text ?? '';
+    state.inputMode = { kind: 'comment', buffer: prior, cursor: [...prior].length, anchor };
+}
+function cycleCommentAnchor(state) {
+    if (state.inputMode?.kind !== 'comment')
+        return;
+    const slot = state.slots[state.currentIndex];
+    const anchors = commentAnchors(slot);
+    if (anchors.length === 0)
+        return;
+    const current = commentIdFor(state.inputMode.anchor);
+    const index = anchors.findIndex((a) => commentIdFor(a) === current);
+    const anchor = anchors[(index + 1) % anchors.length];
+    const prior = commentsFor(slot.id === undefined ? undefined : state.responses.get(slot.id)).find((c) => c.id === commentIdFor(anchor))?.text ?? '';
+    state.inputMode = { kind: 'comment', anchor, buffer: prior, cursor: [...prior].length };
+}
+function handleInputMode(input, key, state, render) {
+    const mode = state.inputMode;
+    if (key.escape) {
+        state.inputMode = null;
+        render();
+        return;
+    }
+    if (key.tab && mode.kind === 'comment') {
+        cycleCommentAnchor(state);
+        render();
+        return;
+    }
+    if (key.return) {
+        commitInput(state);
+        render();
+        return;
+    }
+    if (key.newline) {
+        insert(mode, '\n');
+        render();
+        return;
+    }
+    if (key.wordLeft)
+        mode.cursor = wordLeftIndex(mode.buffer, mode.cursor);
+    else if (key.wordRight)
+        mode.cursor = wordRightIndex(mode.buffer, mode.cursor);
+    else if (key.leftArrow)
+        mode.cursor = Math.max(0, mode.cursor - 1);
+    else if (key.rightArrow)
+        mode.cursor = Math.min([...mode.buffer].length, mode.cursor + 1);
+    else if (key.upArrow)
+        mode.cursor = verticalCursor(mode.buffer, mode.cursor, -1, inputWrapWidth(state));
+    else if (key.downArrow)
+        mode.cursor = verticalCursor(mode.buffer, mode.cursor, 1, inputWrapWidth(state));
+    else if (key.home || (key.ctrl && input === 'a'))
+        mode.cursor = lineStart(mode.buffer, mode.cursor);
+    else if (key.end || (key.ctrl && input === 'e'))
+        mode.cursor = lineEnd(mode.buffer, mode.cursor);
+    // Alt+Backspace (and its ctrl+w form) erase a word; both arrive with the meta
+    // flag set, so this precedes the single-character backspace below.
+    else if (key.meta && key.backspace)
+        wordBackspace(mode);
+    else if (key.backspace || input === '\x7f')
+        backspace(mode);
+    else if (key.del || (key.ctrl && input === 'd'))
+        del(mode);
+    else if (!key.ctrl && !key.meta)
+        insertTyped(mode, input);
+    render();
+}
+function commitInput(state) {
+    const mode = state.inputMode;
+    const slot = state.slots[state.currentIndex];
+    const response = responseFor(slot, slot.id === undefined ? undefined : state.responses.get(slot.id));
+    if (mode.kind === 'comment') {
+        const anchor = mode.anchor;
+        const id = commentIdFor(anchor);
+        const comments = commentsFor(response).filter((c) => c.id !== id);
+        if (mode.buffer.trim() !== '')
+            comments.push({ id, anchor, text: mode.buffer });
+        setResponse(state, slot, { ...response, comments });
+    }
+    else if (mode.kind === 'freetext') {
+        setResponse(state, slot, { ...response, freetext: mode.buffer });
+        advanceToNextIncomplete(state);
+    }
+    else {
+        setResponse(state, slot, { text: mode.buffer, edited: mode.buffer !== slot.config.initialText });
+        advanceToNextIncomplete(state);
+    }
+    state.inputMode = null;
+}
+function insert(mode, text) { const chars = [...mode.buffer]; chars.splice(mode.cursor, 0, ...text); mode.buffer = chars.join(''); mode.cursor += [...text].length; }
+function backspace(mode) { if (mode.cursor === 0)
+    return; const chars = [...mode.buffer]; chars.splice(mode.cursor - 1, 1); mode.buffer = chars.join(''); mode.cursor--; }
+function wordBackspace(mode) { const to = wordLeftIndex(mode.buffer, mode.cursor); if (to === mode.cursor)
+    return; const chars = [...mode.buffer]; chars.splice(to, mode.cursor - to); mode.buffer = chars.join(''); mode.cursor = to; }
+/** Typed and pasted text only: an unrecognized escape sequence reaches this
+ *  handler as raw bytes, and inserting those would put control characters into
+ *  the answer. Newlines survive because a paste may legitimately carry them. */
+function insertTyped(mode, input) {
+    const clean = input.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '').replace(/\r\n?/g, '\n').replace(/[\x00-\x09\x0B-\x1F\x7F]/g, '');
+    if (clean.length > 0)
+        insert(mode, clean);
+}
+function del(mode) { const chars = [...mode.buffer]; if (mode.cursor >= chars.length)
+    return; chars.splice(mode.cursor, 1); mode.buffer = chars.join(''); }
+function lineStart(buffer, cursor) { const before = [...buffer].slice(0, cursor).join(''); const i = before.lastIndexOf('\n'); return i < 0 ? 0 : [...before.slice(0, i + 1)].length; }
+function lineEnd(buffer, cursor) { const chars = [...buffer]; const i = chars.slice(cursor).indexOf('\n'); return i < 0 ? chars.length : cursor + i; }
+function inputWrapWidth(state) { return Math.max(10, Math.min(state.wrapWidth - 8, 116)); }

package/dist/clients/inbox/tui/keys.d.ts

@@ -0,0 +1,28 @@
+export interface Key {
+    upArrow: boolean;
+    downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    /** Word-wise cursor motion (ctrl/alt + arrow, or readline alt-b / alt-f). */
+    wordLeft: boolean;
+    wordRight: boolean;
+    home: boolean;
+    end: boolean;
+    pageUp: boolean;
+    pageDown: boolean;
+    /** Forward delete (the Del key / \x1b[3~). */
+    del: boolean;
+    return: boolean;
+    /** Newline-insert chord (ctrl+j / alt+enter) — distinct from return=submit. */
+    newline: boolean;
+    escape: boolean;
+    ctrl: boolean;
+    meta: boolean;
+    tab: boolean;
+    backspace: boolean;
+}
+export type KeypressHandler = (input: string, key: Key) => void;
+export declare function decodeInboxKey(data: string): {
+    input: string;
+    key: Key;
+};

package/dist/clients/inbox/tui/keys.js

@@ -0,0 +1,104 @@
+import { decodeKittyPrintable, matchesKey, parseKey } from '@earendil-works/pi-tui';
+import { normalizeShiftedMeta } from '../../../core/keybindings/index.js';
+function emptyKey() {
+    return {
+        upArrow: false,
+        downArrow: false,
+        leftArrow: false,
+        rightArrow: false,
+        wordLeft: false,
+        wordRight: false,
+        home: false,
+        end: false,
+        pageUp: false,
+        pageDown: false,
+        del: false,
+        return: false,
+        newline: false,
+        escape: false,
+        ctrl: false,
+        meta: false,
+        tab: false,
+        backspace: false,
+    };
+}
+function withFlag(...flags) {
+    const key = emptyKey();
+    for (const flag of flags)
+        key[flag] = true;
+    return key;
+}
+function isPlainText(data) {
+    return data.length > 0 && !data.includes('\x1b') && data.charCodeAt(0) >= 0x20;
+}
+const BRACKETED_PASTE_START = '\x1b[200~';
+const BRACKETED_PASTE_END = '\x1b[201~';
+function bracketedPaste(data) {
+    if (!data.startsWith(BRACKETED_PASTE_START) || !data.endsWith(BRACKETED_PASTE_END))
+        return undefined;
+    return data.slice(BRACKETED_PASTE_START.length, -BRACKETED_PASTE_END.length);
+}
+export function decodeInboxKey(data) {
+    const pasted = bracketedPaste(data);
+    if (pasted !== undefined)
+        return { input: pasted, key: emptyKey() };
+    const normalized = normalizeShiftedMeta(data);
+    const parsed = parseKey(normalized);
+    if (matchesKey(normalized, 'up'))
+        return { input: '', key: withFlag('upArrow') };
+    if (matchesKey(normalized, 'down'))
+        return { input: '', key: withFlag('downArrow') };
+    if (matchesKey(normalized, 'left'))
+        return { input: '', key: withFlag('leftArrow') };
+    if (matchesKey(normalized, 'right'))
+        return { input: '', key: withFlag('rightArrow') };
+    if (matchesKey(normalized, 'ctrl+left') || matchesKey(normalized, 'alt+left') || matchesKey(normalized, 'alt+b')) {
+        return { input: '', key: withFlag('wordLeft') };
+    }
+    if (matchesKey(normalized, 'ctrl+right') || matchesKey(normalized, 'alt+right') || matchesKey(normalized, 'alt+f')) {
+        return { input: '', key: withFlag('wordRight') };
+    }
+    if (matchesKey(normalized, 'home'))
+        return { input: '', key: withFlag('home') };
+    if (matchesKey(normalized, 'end'))
+        return { input: '', key: withFlag('end') };
+    if (matchesKey(normalized, 'pageUp'))
+        return { input: '', key: withFlag('pageUp') };
+    if (matchesKey(normalized, 'pageDown'))
+        return { input: '', key: withFlag('pageDown') };
+    if (matchesKey(normalized, 'delete'))
+        return { input: '', key: withFlag('del') };
+    if (matchesKey(normalized, 'alt+enter') || parsed === 'ctrl+alt+j') {
+        return { input: '', key: withFlag('newline') };
+    }
+    // Enter submits; Ctrl-J inserts a newline. Check Ctrl-J first because pi-tui
+    // also recognizes a plain LF as Enter for terminals that do not distinguish it.
+    if (matchesKey(normalized, 'ctrl+j'))
+        return { input: '', key: withFlag('newline') };
+    if (matchesKey(normalized, 'enter'))
+        return { input: '', key: withFlag('return') };
+    // Ctrl-W is the word-erase form of Alt+Backspace on some terminals. Keep it
+    // ahead of the generic Ctrl-letter mapping below.
+    if (matchesKey(normalized, 'alt+backspace') || matchesKey(normalized, 'ctrl+w')) {
+        return { input: '', key: withFlag('meta', 'backspace') };
+    }
+    if (matchesKey(normalized, 'escape'))
+        return { input: '', key: withFlag('escape') };
+    if (matchesKey(normalized, 'tab'))
+        return { input: '', key: withFlag('tab') };
+    if (matchesKey(normalized, 'backspace'))
+        return { input: '', key: withFlag('backspace') };
+    if (matchesKey(normalized, 'alt+shift+r'))
+        return { input: 'R', key: withFlag('meta') };
+    if (parsed?.startsWith('ctrl+') && parsed.length === 'ctrl+'.length + 1) {
+        const letter = parsed.slice('ctrl+'.length);
+        if (/^[a-z]$/.test(letter))
+            return { input: letter, key: withFlag('ctrl') };
+    }
+    const kittyPrintable = decodeKittyPrintable(data);
+    if (kittyPrintable !== undefined)
+        return { input: kittyPrintable, key: emptyKey() };
+    if (isPlainText(data))
+        return { input: data, key: emptyKey() };
+    return { input: data, key: emptyKey() };
+}

package/dist/clients/inbox/tui/page-body.d.ts

@@ -0,0 +1,10 @@
+import type { PageManifest } from '../../../core/human/page-schema.js';
+/** What a page says, as terminal rows: the authored prose, then each question
+ *  with its own body and the choices it offers. One projection serves every
+ *  read-only view of a page — the inline transcript block and the inbox list's
+ *  preview — so a reader is never asked to settle a page from a summary that
+ *  showed them less than the page itself does.
+ *
+ *  `maxW` is the prose measure, `paneW` the full rectangle a wide block (a
+ *  table, a code fence) may use. Callers window or fold the result. */
+export declare function pageBodyLines(manifest: PageManifest, displayMarkdown: string, maxW: number, paneW: number): string[];

package/dist/clients/inbox/tui/page-body.js

@@ -0,0 +1,69 @@
+import { renderMarkdownBlockAwareLines } from '../../../core/termrender/termrender.js';
+import { describeSlot, tableMarkdown, terminalAnswerable } from './slots.js';
+import { rewriteMarkdownDocLinks } from '../../attach/render/markdown-source.js';
+import { BOLD, DIM, RESET, sanitize, singleLine, truncate, wrap } from './ansi.js';
+/** What a page says, as terminal rows: the authored prose, then each question
+ *  with its own body and the choices it offers. One projection serves every
+ *  read-only view of a page — the inline transcript block and the inbox list's
+ *  preview — so a reader is never asked to settle a page from a summary that
+ *  showed them less than the page itself does.
+ *
+ *  `maxW` is the prose measure, `paneW` the full rectangle a wide block (a
+ *  table, a code fence) may use. Callers window or fold the result. */
+export function pageBodyLines(manifest, displayMarkdown, maxW, paneW) {
+    // `[[owner/name]]` document links become readable, clickable links here as they do in the transcript.
+    const md = (text) => renderMarkdownBlockAwareLines(rewriteMarkdownDocLinks(text), maxW, paneW);
+    // An HTML page carries no slots, so its projected document is the whole of
+    // what a terminal reader gets — a browser renders it, this one reads it.
+    if (manifest.dialect === 'html')
+        return displayMarkdown === '' ? [`${DIM}HTML page — open in Northlight to read this${RESET}`] : md(displayMarkdown);
+    const lines = displayMarkdown === '' ? [] : md(displayMarkdown);
+    let priorStep = -1;
+    for (const slot of manifest.slots) {
+        if (manifest.steps > 1 && slot.step !== priorStep) {
+            if (lines.length > 0)
+                lines.push('');
+            lines.push(`${BOLD}Step ${slot.step + 1}/${manifest.steps}${RESET}`);
+            priorStep = slot.step;
+        }
+        if (lines.length > 0)
+            lines.push('');
+        for (const line of wrap(singleLine(describeSlot(slot)), maxW))
+            lines.push(`${BOLD}${line}${RESET}`);
+        const body = slot.config.body;
+        if (typeof body === 'string' && body !== '')
+            lines.push(...md(body));
+        if (!terminalAnswerable(slot)) {
+            lines.push(`${DIM}${sanitize(slot.kind)} — open in Northlight to answer this${RESET}`);
+            continue;
+        }
+        if (slot.kind === 'text') {
+            lines.push(...md(slot.config.initialText));
+        }
+        else if (slot.kind === 'table') {
+            lines.push(...md(tableMarkdown(slot.config)));
+        }
+        else if (slot.kind === 'cards') {
+            for (const card of slot.config.cards ?? []) {
+                lines.push(`  • ${truncate(sanitize(singleLine(card.subtitle === undefined ? card.title : `${card.title} — ${card.subtitle}`)), Math.max(10, maxW - 4))}`);
+                if (card.body !== undefined)
+                    for (const line of wrap(sanitize(card.body), Math.max(10, maxW - 6)))
+                        lines.push(`    ${DIM}${line}${RESET}`);
+            }
+        }
+        else if (slot.kind === 'options') {
+            for (const option of slot.config.options) {
+                lines.push(`  • ${truncate(sanitize(singleLine(option.label)), Math.max(10, maxW - 4))}`);
+                if (option.description !== undefined)
+                    for (const line of wrap(sanitize(option.description), Math.max(10, maxW - 6)))
+                        lines.push(`    ${DIM}${line}${RESET}`);
+            }
+        }
+        else if (slot.kind === 'chart') {
+            const config = slot.config;
+            const title = config.title ?? `${config.x ?? ''} vs ${(config.y ?? []).map((y) => y.label ?? y.field).join(', ')}`;
+            lines.push(`${DIM}chart — ${sanitize(config.kind ?? 'chart')}: ${sanitize(title)}${RESET}`);
+        }
+    }
+    return lines;
+}

package/dist/clients/inbox/tui/panel.d.ts

@@ -0,0 +1,4 @@
+import type { PageResponses } from '../../../core/human/page-schema.js';
+import type { MountedPanel, MountedPanelOpts, TuiState } from './types.js';
+export declare function collectResponses(state: TuiState): PageResponses;
+export declare function mountPanel(opts: MountedPanelOpts): MountedPanel;