mergestorm 0.3.13 → 0.3.15

package/dist/ui/banner.js

@@ -3,9 +3,9 @@ import { CommandError } from "../errors.js";
 import { keyDisplay, loadConfig, resolveApiKey } from "../config.js";
 import { cliVersion } from "../version.js";
 import { ansi } from "./ansi.js";
-import { frameWidth, padVisible, preferBoxedUi, roundedBox, sideBySide, visibleWidth, } from "./box.js";
-import { TORNADO_LOGO } from "./logo.js";
-import { usageBar } from "./usage.js";
+import { frameWidth, padVisible, preferBoxedUi, roundedBox, terminalColumns, visibleWidth, } from "./box.js";
+import { STORM_MARK, STORM_MARK_WIDTH } from "./logo.js";
+import { formatResetLabel, usageBar } from "./usage.js";
 const WORDMARK = `
  __  __ ___ ___  ___ ___ ___ _____ ___  ___ __  __
 |  \\/  | __| _ \\/ __| __/ __|_   _/ _ \\| _ \\  \\/  |
@@ -14,7 +14,7 @@ const WORDMARK = `
 `.trimEnd();
 /** Used by the non-interactive `usage()` path in cli.ts — the boxed banner is shell-only. */
 export function printWordmark() {
-    console.log(ansi.boldGreen(WORDMARK));
+    console.log(ansi.boldBrightGreen(WORDMARK));
     console.log(ansi.dim(`  review local diffs fast · mergestorm.ai · v${cliVersion()}`));
     console.log("");
 }
@@ -73,53 +73,166 @@ const WHATS_NEW = {
         "review --router off|standard|max|manual (same smart router as Agents)",
         "review --specialists security,frontend,… to pin or invoke lanes",
     ],
+    "0.3.14": [
+        "Status / Usage / Jobs tabs (open with usage)",
+        "resize-safe home screen",
+    ],
+    "0.3.15": [
+        "mg pr --wait --after-sha, mg settings, mergestorm-pr-loop skill on npm",
+        "mg skill install copies review + pr-loop from the packed tarball",
+    ],
 };
-function formatStatusLines(me, key, barWidth, keyInvalid = false) {
-    if (!key) {
-        return [
-            `${ansi.dim("○")} not logged in — type ${ansi.green("login")} to sign in`,
-            `  or ${ansi.green("login --key")} to paste an API key`,
-        ];
+function densityFromVariant(variant) {
+    if (variant === "mini" || variant === "nano")
+        return variant;
+    return variant ? "compact" : "full";
+}
+/** Home usage bars stay compact (Claude-style), not full-bleed. */
+const BANNER_BAR_MAX = 30;
+/** `[` + `]` + ` 100% used` around the bar cells. */
+const BAR_CHROME_CELLS = 12;
+function statusLine(state) {
+    if (!state.key) {
+        return `${ansi.dim("○")} not logged in · type ${ansi.brightGreen("login")} to sign in`;
     }
-    if (keyInvalid) {
-        return [
-            `${ansi.dim("○")} API key invalid or revoked — type ${ansi.green("login")} to sign in again`,
-        ];
+    if (state.keyInvalid) {
+        return `${ansi.dim("○")} API key invalid or revoked · type ${ansi.brightGreen("login")} to sign in again`;
     }
-    const display = me?.key.prefix ?? keyDisplay(key) ?? "msk_live_…";
-    if (!me) {
-        return [`${ansi.green("●")} logged in (${ansi.bold(display)})`];
+    const display = state.me?.key.prefix ?? keyDisplay(state.key) ?? "msk_live_…";
+    if (!state.me) {
+        return `${ansi.brightGreen("●")} ${ansi.bold(display)} ${ansi.dim("· account details unavailable")}`;
     }
-    const plan = me.plan_label_key ?? me.plan_key;
-    const s = me.usage.standard;
-    return [
-        `${ansi.green("●")} ${ansi.bold(display)}  ·  ${plan}`,
-        usageBar(s.used, s.limit, { width: barWidth }),
-    ];
+    const plan = state.me.plan_label_key ?? state.me.plan_key;
+    return `${ansi.brightGreen("●")} ${ansi.bold(display)} · ${plan}`;
 }
-function tipsLines() {
-    return [
-        ansi.dim("Tips for getting started"),
-        `  ${ansi.green("review")}      review origin/HEAD or main`,
-        `  ${ansi.green("stack")}       create → submit → restack → land`,
-        `  ${ansi.green("/help")}       list all commands`,
-    ];
+function usageLine(me, contentCells, indent) {
+    const room = Math.max(8, contentCells - indent - BAR_CHROME_CELLS);
+    const bar = usageBar(me.usage.standard.used, me.usage.standard.limit, {
+        width: Math.min(BANNER_BAR_MAX, room),
+    });
+    const reset = ansi.dim(`· ${formatResetLabel(me.resets_at)}`);
+    const combined = `${bar} ${reset}`;
+    return visibleWidth(combined) <= contentCells - indent ? combined : bar;
+}
+/** First candidate that fits. Never mid-word clip — omit if nothing fits. */
+function firstFit(options, cells) {
+    for (const opt of options) {
+        if (visibleWidth(opt) <= cells)
+            return opt;
+    }
+    return null;
 }
-function whatsNewLines(version) {
+function tipsLine(cells) {
+    const sep = ansi.dim(" · ");
+    return firstFit([
+        [
+            `${ansi.brightGreen("review")} ${ansi.dim("a diff")}`,
+            `${ansi.brightGreen("usage")} ${ansi.dim("for tabs")}`,
+            `${ansi.brightGreen("/help")} ${ansi.dim("for all commands")}`,
+        ].join(sep),
+        [ansi.brightGreen("review"), ansi.brightGreen("usage"), ansi.brightGreen("/help")].join(sep),
+        [ansi.brightGreen("review"), ansi.brightGreen("/help")].join(sep),
+    ], cells);
+}
+function tagline(cells) {
+    return firstFit([
+        ansi.dim("local reviews + stacked PRs · mergestorm.ai"),
+        ansi.dim("reviews + stacked PRs"),
+        ansi.dim("reviews · stacks"),
+    ], cells);
+}
+/** Shorten until it fits. Never clip mid-word (that was "…Jobs tabs (open with usa"). */
+function whatsNewLine(version, cells) {
     const entries = WHATS_NEW[version];
     if (!entries || !entries.length)
-        return [];
-    return [
-        ansi.dim(`What's new in v${version}`),
-        ...entries.map((entry) => `  ${ansi.green("•")} ${entry}`),
+        return null;
+    const first = entries[0];
+    const noParen = first.replace(/\s*\([^)]*\)\s*$/, "").trim();
+    const candidates = [
+        `New in v${version}: ${first}`,
+        `New in v${version}: ${noParen}`,
+        `New: ${noParen}`,
+        `New in v${version}`,
     ];
+    const extra = entries.slice(1);
+    const withExtra = `${candidates[0]} · ${extra.join(" · ")}`;
+    const options = extra.length > 0 ? [withExtra, ...candidates] : candidates;
+    const hit = firstFit(options, cells);
+    return hit ? ansi.dim(hit) : null;
 }
-function centerLine(line, width) {
-    const room = Math.max(0, width - visibleWidth(line));
-    const left = Math.floor(room / 2);
-    return `${" ".repeat(left)}${line}${" ".repeat(room - left)}`;
+/**
+ * The whole welcome panel as rows, reflowed to `columns`. Every row fits in
+ * `columns - 1` cells so a redraw's cursor math stays honest; below
+ * MIN_BOXED_COLUMNS the frame drops away instead of wrapping.
+ */
+export function buildBannerRows(state, columns, opts) {
+    const boxed = preferBoxedUi(columns);
+    const density = opts?.density ?? (opts?.compact ? "compact" : "full");
+    const outer = frameWidth(80, columns);
+    const contentCells = boxed
+        ? Math.max(20, outer - 4)
+        : Math.max(20, terminalColumns(80, columns) - 1);
+    const indent = STORM_MARK_WIDTH + 2;
+    const pad = " ".repeat(indent);
+    const clip = (line) => visibleWidth(line) > contentCells ? padVisible(line, contentCells) : line;
+    const mark = (row) => padVisible(ansi.brightGreen(STORM_MARK[row] ?? ""), indent);
+    const title = `${ansi.boldBrightGreen("mergestorm")} ${ansi.dim(`v${state.version}`)}`;
+    if (density === "nano") {
+        const one = `${mark(0)}${title}  ${statusLine(state)}`;
+        return [clip(one)];
+    }
+    if (density === "mini") {
+        // Short pane: mark + who you are, then the same cues as the full home.
+        const line0 = clip(`${mark(0)}${title}  ${statusLine(state)}`);
+        const line1 = state.me && !state.keyInvalid
+            ? clip(`${mark(1)}${usageLine(state.me, contentCells, indent)}`)
+            : clip(mark(1));
+        const room = contentCells - indent;
+        const blurb = tagline(room);
+        const tips = tipsLine(room);
+        const fresh = whatsNewLine(state.version, room);
+        return [
+            line0,
+            line1,
+            ...(blurb ? [clip(`${pad}${blurb}`)] : []),
+            ...(tips ? [clip(`${pad}${tips}`)] : []),
+            ...(fresh ? [clip(`${pad}${fresh}`)] : []),
+        ];
+    }
+    const content = [
+        clip(`${pad}${title}`),
+        clip(`${mark(0)}${statusLine(state)}`),
+    ];
+    if (state.me && !state.keyInvalid) {
+        content.push(clip(`${mark(1)}${usageLine(state.me, contentCells, indent)}`));
+    }
+    else {
+        content.push(clip(mark(1)));
+    }
+    const room = contentCells - indent;
+    const blurb = tagline(room);
+    const tips = tipsLine(room);
+    const fresh = whatsNewLine(state.version, room);
+    if (blurb)
+        content.push(clip(`${pad}${blurb}`));
+    if (tips)
+        content.push(clip(`${pad}${tips}`));
+    if (fresh)
+        content.push(clip(`${pad}${fresh}`));
+    if (boxed && density === "full") {
+        content.splice(3, 0, "");
+        return [...roundedBox(content, { width: outer, padding: 1 })];
+    }
+    if (boxed) {
+        return [...roundedBox(content, { width: outer, padding: 1 })];
+    }
+    return content.map(clip);
 }
-export async function printBannerHeader() {
+/**
+ * Print the welcome panel and return a handle whose `rows()` reflows the
+ * same data for a new width (used by the prompt's resize redraw).
+ */
+export async function printBannerHeader(opts) {
     const cfg = await loadConfig();
     const key = resolveApiKey(cfg);
     let me = null;
@@ -138,46 +251,17 @@ export async function printBannerHeader() {
             }
         }
     }
-    const version = cliVersion();
-    const outer = frameWidth();
-    // Inner content width inside the box (borders + padding).
-    const inner = Math.max(40, outer - 4);
-    // Two columns: left = logo + status, right = tips + what's new.
-    const leftColW = Math.max(28, Math.floor(inner * 0.42));
-    const rightColW = Math.max(24, inner - leftColW - 2);
-    const barWidth = Math.max(12, leftColW - 4);
-    const logoLines = TORNADO_LOGO.map((line) => centerLine(ansi.brightGreen(line), leftColW));
-    const leftCol = [
-        ...logoLines,
-        "",
-        ...formatStatusLines(me, key, barWidth, keyInvalid),
-    ];
-    const rightCol = [
-        ...tipsLines(),
-        "",
-        ...whatsNewLines(version),
-    ];
-    // Clip right column lines that overflow the right pane.
-    const rightClipped = rightCol.map((line) => visibleWidth(line) <= rightColW ? line : padVisible(line, rightColW));
-    const rows = sideBySide(leftCol, rightClipped, leftColW, 2);
-    if (!preferBoxedUi()) {
-        // Narrow panes — plain lines beat wrapped box frames.
-        console.log(ansi.boldGreen(`mergestorm v${version}`));
-        for (const line of rows)
+    const state = { version: cliVersion(), me, key, keyInvalid };
+    if (opts?.paint !== false) {
+        for (const line of buildBannerRows(state)) {
             console.log(line);
-        console.log("");
-        return;
-    }
-    const panel = roundedBox(rows, {
-        title: `mergestorm v${version}`,
-        width: outer,
-        padding: 1,
-    });
-    for (const line of panel) {
-        console.log(line);
+        }
     }
-    console.log("");
+    return {
+        rows: (columns, variant) => buildBannerRows(state, columns, { density: densityFromVariant(variant) }),
+    };
 }
-export function shellPrompt(loggedIn) {
-    return loggedIn ? ansi.boldGreen("mergestorm") : ansi.dim("mergestorm");
+export function shellPrompt(_loggedIn) {
+    // Bright mark green. Never dim, never 32, never the word "mergestorm".
+    return ansi.boldBrightGreen("mg");
 }

package/dist/ui/findings.d.ts

@@ -26,5 +26,6 @@ export type RenderFindingsOptions = {
     /** When true and both lists are empty, print the empty message. */
     emptyMessage?: boolean;
 };
-/** Print inline + off-diff findings the same way for `review` and `status --pretty`. */
+export declare function formatFindingsLines(findings: ReviewFindings | null | undefined, opts?: RenderFindingsOptions): string[];
+/** Print inline + off-diff findings the same way for oneshot `review` / `status --pretty`. */
 export declare function renderFindings(findings: ReviewFindings | null | undefined, opts?: RenderFindingsOptions): void;

package/dist/ui/findings.js

@@ -1,17 +1,23 @@
-/** Print inline + off-diff findings the same way for `review` and `status --pretty`. */
-export function renderFindings(findings, opts = {}) {
+export function formatFindingsLines(findings, opts = {}) {
+    const lines = [];
     const inline = findings?.inline ?? [];
     const off = findings?.off_diff ?? findings?.offDiff ?? [];
     for (const c of inline) {
         const lane = c.specialist ? `[${c.specialist}]` : "";
-        console.log(`\n[${c.severity}]${lane} ${c.path}:${c.line}${c.title ? ` — ${c.title}` : ""}`);
-        console.log(c.body);
+        lines.push(`[${c.severity}]${lane} ${c.path}:${c.line}${c.title ? ` — ${c.title}` : ""}`);
+        lines.push(c.body);
     }
     for (const c of off) {
-        console.log(`\n[${c.severity}] off-diff ${c.path ?? ""}`);
-        console.log(c.body);
+        lines.push(`[${c.severity}] off-diff ${c.path ?? ""}`);
+        lines.push(c.body);
     }
     if (opts.emptyMessage && inline.length === 0 && off.length === 0) {
-        console.log("\nNo findings.");
+        lines.push("No findings.");
     }
+    return lines;
+}
+/** Print inline + off-diff findings the same way for oneshot `review` / `status --pretty`. */
+export function renderFindings(findings, opts = {}) {
+    for (const line of formatFindingsLines(findings, opts))
+        console.log(line);
 }

package/dist/ui/line-tabs.d.ts

@@ -0,0 +1,27 @@
+import { type TabsLayout } from "./tabs.js";
+export type LineTab = {
+    id: string;
+    label: string;
+    lines: string[];
+};
+export type LineTabsState = {
+    index: number;
+    scroll: number[];
+};
+export declare function initialLineTabsState(tabCount: number, start?: number): LineTabsState;
+export declare function reduceLineTabsKey(state: LineTabsState, key: "left" | "right" | "up" | "down" | "escape" | "q", tabCount: number, maxScroll: number): {
+    kind: "close";
+} | {
+    kind: "state";
+    state: LineTabsState;
+};
+export declare function layoutLineTabs(tabs: LineTab[], state: LineTabsState, columns?: number, rows?: number, color?: boolean): TabsLayout;
+/** Hold-to-read panel. TTY: tabbed frame. Pipe: print the lines. */
+export declare function showLinePanel(label: string, lines: string[]): Promise<void>;
+export declare function runLineTabsBrowser(opts: {
+    tabs: LineTab[];
+    initial?: number;
+    input?: NodeJS.ReadStream;
+    output?: NodeJS.WriteStream;
+    color?: boolean;
+}): Promise<void>;

package/dist/ui/line-tabs.js

@@ -0,0 +1,170 @@
+import * as readline from "node:readline";
+import { stdin, stdout } from "node:process";
+import { ansi } from "./ansi.js";
+import { frameWidth, preferBoxedUi, roundedBox, terminalColumns, } from "./box.js";
+import { padVisible, visibleWidth } from "./width.js";
+import { tabsBodyRows, tabsHintLine } from "./tabs.js";
+export function initialLineTabsState(tabCount, start = 0) {
+    const n = Math.max(1, tabCount);
+    return {
+        index: Math.max(0, Math.min(start, n - 1)),
+        scroll: Array.from({ length: n }, () => 0),
+    };
+}
+export function reduceLineTabsKey(state, key, tabCount, maxScroll) {
+    if (key === "q" || key === "escape")
+        return { kind: "close" };
+    const last = Math.max(0, tabCount - 1);
+    if (key === "left") {
+        return { kind: "state", state: { ...state, index: Math.max(0, state.index - 1) } };
+    }
+    if (key === "right") {
+        return { kind: "state", state: { ...state, index: Math.min(last, state.index + 1) } };
+    }
+    const scroll = state.scroll.slice();
+    const at = state.index;
+    if (key === "up")
+        scroll[at] = Math.max(0, (scroll[at] ?? 0) - 1);
+    if (key === "down")
+        scroll[at] = Math.min(maxScroll, (scroll[at] ?? 0) + 1);
+    return { kind: "state", state: { ...state, scroll } };
+}
+function titleOf(tabs, index, color) {
+    const parts = tabs.map((tab, i) => {
+        if (!color)
+            return i === index ? `[${tab.label}]` : ` ${tab.label} `;
+        return i === index ? ansi.boldBrightGreen(tab.label) : ansi.dim(tab.label);
+    });
+    return parts.join(color ? ansi.dim(" · ") : " · ");
+}
+export function layoutLineTabs(tabs, state, columns, rows, color = false) {
+    const boxed = preferBoxedUi(columns);
+    const cols = terminalColumns(80, columns);
+    const outer = frameWidth(80, columns);
+    const contentCells = boxed ? Math.max(20, outer - 4) : Math.max(20, cols - 1);
+    const bodyRows = tabsBodyRows(rows);
+    const tab = tabs[state.index] ?? tabs[0];
+    const content = tab ? tab.lines : [];
+    const start = Math.min(Math.max(0, state.scroll[state.index] ?? 0), Math.max(0, content.length - bodyRows));
+    const clip = (line) => visibleWidth(line) > contentCells ? padVisible(line, contentCells) : line;
+    const body = content.slice(start, start + bodyRows).map(clip);
+    while (body.length < bodyRows)
+        body.push("");
+    const hint = tabsHintLine("←→ tabs · ↑↓ scroll · esc close", undefined, cols, color);
+    const title = titleOf(tabs, state.index, color);
+    if (!boxed) {
+        const plainTitle = visibleWidth(title) > cols - 1 ? padVisible(title, cols - 1) : title;
+        return { lines: [plainTitle, ...body, hint], bodyRows, contentRows: content.length };
+    }
+    return {
+        lines: [...roundedBox(body, { title, width: outer, padding: 1 }), hint],
+        bodyRows,
+        contentRows: content.length,
+    };
+}
+const up = (n) => `\u001b[${n}A`;
+const clearDown = "\u001b[0J";
+const homeClear = `\u001b[H${clearDown}`;
+/** Hold-to-read panel. TTY: tabbed frame. Pipe: print the lines. */
+export async function showLinePanel(label, lines) {
+    const input = stdin;
+    const output = stdout;
+    if (!input.isTTY || !output.isTTY) {
+        for (const line of lines)
+            console.log(line);
+        return;
+    }
+    const id = label.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "page";
+    await runLineTabsBrowser({ tabs: [{ id, label, lines }] });
+}
+export async function runLineTabsBrowser(opts) {
+    const input = opts.input ?? stdin;
+    const output = opts.output ?? stdout;
+    const tabs = opts.tabs;
+    const color = opts.color ?? ansi.enabled;
+    if (!input.isTTY || !output.isTTY) {
+        for (const tab of tabs) {
+            console.log(`  ${tab.label}`);
+            for (const line of tab.lines)
+                console.log(line);
+            console.log("");
+        }
+        return;
+    }
+    return new Promise((resolve) => {
+        let state = initialLineTabsState(tabs.length, opts.initial ?? 0);
+        let lastLayout = null;
+        let linesDrawn = 0;
+        let finished = false;
+        const wasRaw = Boolean(input.isRaw);
+        readline.emitKeypressEvents(input);
+        input.setRawMode(true);
+        input.resume();
+        function render(prefix) {
+            if (prefix)
+                output.write(prefix);
+            else if (linesDrawn > 0)
+                output.write(`${up(linesDrawn)}\r${clearDown}`);
+            lastLayout = layoutLineTabs(tabs, state, output.columns, output.rows, color);
+            output.write(lastLayout.lines.join("\r\n") + "\r\n");
+            linesDrawn = lastLayout.lines.length;
+        }
+        function finish() {
+            if (finished)
+                return;
+            finished = true;
+            input.removeListener("keypress", onKeypress);
+            output.removeListener("resize", onResize);
+            input.setRawMode(wasRaw);
+            input.pause();
+            if (linesDrawn > 0)
+                output.write(`${up(linesDrawn)}\r${clearDown}`);
+            resolve();
+        }
+        function onResize() {
+            if (!finished)
+                render(homeClear);
+        }
+        function onKeypress(str, key) {
+            if (finished || !key)
+                return;
+            if (key.ctrl && key.name === "c") {
+                finish();
+                return;
+            }
+            let name = null;
+            if (key.name === "left" || key.name === "right" || key.name === "up" || key.name === "down") {
+                name = key.name;
+            }
+            else if (key.name === "escape")
+                name = "escape";
+            else if (key.name === "q" || str === "q")
+                name = "q";
+            if (!name)
+                return;
+            const maxScroll = lastLayout
+                ? Math.max(0, lastLayout.contentRows - lastLayout.bodyRows)
+                : 0;
+            const step = reduceLineTabsKey(state, name, tabs.length, maxScroll);
+            if (step.kind === "close") {
+                finish();
+                return;
+            }
+            state = step.state;
+            try {
+                render();
+            }
+            catch {
+                finish();
+            }
+        }
+        input.on("keypress", onKeypress);
+        output.on("resize", onResize);
+        try {
+            render(homeClear);
+        }
+        catch {
+            finish();
+        }
+    });
+}

package/dist/ui/logo.d.ts

@@ -1,5 +1,13 @@
 /**
- * Pixelated funnel logo, colored by the caller (see banner.ts).
- * Kept as plain glyphs here so consumers can measure/center it with visibleWidth.
+ * Compact two-row storm mark (Fable / 0.3.14 home). Colored by the caller.
+ * Block elements (U+2580..259F) are one cell each; no emoji, no gradients.
  */
+export declare const STORM_MARK: string[];
+/** Widest row of the mark, in cells (every mark glyph is single-cell). */
+export declare const STORM_MARK_WIDTH: number;
+/** @deprecated Alias — the home panel uses {@link STORM_MARK}. */
 export declare const TORNADO_LOGO: string[];
+/** @deprecated Alias. */
+export declare const TORNADO_LOGO_WIDTH: number;
+/** @deprecated Compact home is the full two-row mark. */
+export declare const TORNADO_LOGO_COMPACT: string[];

package/dist/ui/logo.js

@@ -1,12 +1,16 @@
 /**
- * Pixelated funnel logo, colored by the caller (see banner.ts).
- * Kept as plain glyphs here so consumers can measure/center it with visibleWidth.
+ * Compact two-row storm mark (Fable / 0.3.14 home). Colored by the caller.
+ * Block elements (U+2580..259F) are one cell each; no emoji, no gradients.
  */
-export const TORNADO_LOGO = [
-    "▟██████████▛",
-    " ▜████████▛",
-    "  ▝▜████▛▘",
-    "    ▜██▛",
-    "     ██",
-    "     ▝▘",
+export const STORM_MARK = [
+    "▟██▛",
+    " ▜▙",
 ];
+/** Widest row of the mark, in cells (every mark glyph is single-cell). */
+export const STORM_MARK_WIDTH = Math.max(...STORM_MARK.map((line) => line.length));
+/** @deprecated Alias — the home panel uses {@link STORM_MARK}. */
+export const TORNADO_LOGO = STORM_MARK;
+/** @deprecated Alias. */
+export const TORNADO_LOGO_WIDTH = STORM_MARK_WIDTH;
+/** @deprecated Compact home is the full two-row mark. */
+export const TORNADO_LOGO_COMPACT = STORM_MARK;

package/dist/ui/present.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The only way a shell command may show a result and return to home.
+ * TTY: hold-to-read panel (q). Pipe: print the lines.
+ *
+ * Do not `console.log` then return from a shell command — the next
+ * askLine homes + ED 0 and wipes it. Live waits (login poll, review
+ * progress) may still write; the *final* result goes through here
+ * or through `openTabsBrowser`.
+ */
+export declare function present(title: string, lines: string[]): Promise<void>;

package/dist/ui/present.js

@@ -0,0 +1,13 @@
+import { showLinePanel } from "./line-tabs.js";
+/**
+ * The only way a shell command may show a result and return to home.
+ * TTY: hold-to-read panel (q). Pipe: print the lines.
+ *
+ * Do not `console.log` then return from a shell command — the next
+ * askLine homes + ED 0 and wipes it. Live waits (login poll, review
+ * progress) may still write; the *final* result goes through here
+ * or through `openTabsBrowser`.
+ */
+export async function present(title, lines) {
+    await showLinePanel(title, lines);
+}