mergestorm 0.3.9 → 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("");
 }
@@ -66,53 +66,173 @@ const WHATS_NEW = {
         "npm description points at MIT build-from-source URL",
         "Dashboard links → Settings → API / Work (product URL cleanup)",
     ],
+    "0.3.10": [
+        "README: verify public git SHA + npm integrity (build from mergestorm-cli)",
+    ],
+    "0.3.12": [
+        "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 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);
 }
-function whatsNewLines(version) {
+/** 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;
@@ -131,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/box.d.ts

@@ -1,24 +1,30 @@
-export declare function visibleWidth(str: string): number;
+import { padVisible, sliceVisible, visibleWidth } from "./width.js";
+export { padVisible, sliceVisible, visibleWidth };
 /** Below this width, boxed chrome wraps on real TTYs — prefer plain output. */
 export declare const MIN_BOXED_COLUMNS = 48;
-/** Usable terminal columns (TTY), with a sensible fallback for pipes/tests. */
-export declare function terminalColumns(fallback?: number): number;
+/**
+ * Usable terminal columns (TTY), with a sensible fallback for pipes/tests.
+ * Pass `columns` to measure a stream other than process.stdout (or a
+ * post-resize value); `undefined` reads stdout at call time.
+ */
+export declare function terminalColumns(fallback?: number, columns?: number): number;
 /**
  * Whether rounded/full-bleed boxes fit without wrapping.
  * Non-TTY (unknown columns) keeps boxes for tests and CI logs.
  */
-export declare function preferBoxedUi(): boolean;
+export declare function preferBoxedUi(columns?: number): boolean;
 /**
  * Outer box width for Claude-style full-bleed frames.
  * Never wider than the terminal (minus 1 so the right border doesn't wrap).
  */
-export declare function frameWidth(fallback?: number): number;
+export declare function frameWidth(fallback?: number, columns?: number): number;
 export interface RoundedBoxOptions {
     title?: string;
     padding?: number;
     /**
-     * Exact outer width (including borders). When set, content is padded to fill.
-     * Prefer this for full-width Claude-style frames.
+     * Exact outer width (including borders). When set, content is padded to
+     * fill and *clipped* to fit: no row is ever wider than this, because a row
+     * that wraps is a row the redraw math doesn't know about.
      */
     width?: number;
     /** Grow to at least this outer width (content may still be wider). */
@@ -29,8 +35,6 @@ export interface RoundedBoxOptions {
  * `minWidth` to stretch to the terminal like Claude Code.
  */
 export declare function roundedBox(lines: string[], opts?: RoundedBoxOptions): string[];
-/** Pad/truncate a line to an exact visible width (ANSI-safe). */
-export declare function padVisible(line: string, width: number): string;
 /**
  * Join left/right columns into rows of equal left-column width.
  * Extra rows on either side are blank-padded.

package/dist/ui/box.js

@@ -1,14 +1,18 @@
 import { stdout } from "node:process";
 import { ansi } from "./ansi.js";
-const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
-export function visibleWidth(str) {
-    return str.replace(ANSI_PATTERN, "").length;
-}
+import { padVisible, sliceVisible, visibleWidth } from "./width.js";
+// Cell arithmetic lives in width.ts; re-exported so existing `./box.js`
+// importers (banner, prompt) keep working.
+export { padVisible, sliceVisible, visibleWidth };
 /** Below this width, boxed chrome wraps on real TTYs — prefer plain output. */
 export const MIN_BOXED_COLUMNS = 48;
-/** Usable terminal columns (TTY), with a sensible fallback for pipes/tests. */
-export function terminalColumns(fallback = 80) {
-    const cols = stdout.columns;
+/**
+ * Usable terminal columns (TTY), with a sensible fallback for pipes/tests.
+ * Pass `columns` to measure a stream other than process.stdout (or a
+ * post-resize value); `undefined` reads stdout at call time.
+ */
+export function terminalColumns(fallback = 80, columns) {
+    const cols = columns ?? stdout.columns;
     if (typeof cols === "number" && Number.isFinite(cols) && cols >= 1) {
         return cols;
     }
@@ -18,8 +22,8 @@ export function terminalColumns(fallback = 80) {
  * Whether rounded/full-bleed boxes fit without wrapping.
  * Non-TTY (unknown columns) keeps boxes for tests and CI logs.
  */
-export function preferBoxedUi() {
-    const cols = stdout.columns;
+export function preferBoxedUi(columns) {
+    const cols = columns ?? stdout.columns;
     if (typeof cols !== "number" || !Number.isFinite(cols))
         return true;
     return cols >= MIN_BOXED_COLUMNS;
@@ -28,8 +32,8 @@ export function preferBoxedUi() {
  * Outer box width for Claude-style full-bleed frames.
  * Never wider than the terminal (minus 1 so the right border doesn't wrap).
  */
-export function frameWidth(fallback = 80) {
-    return Math.max(20, terminalColumns(fallback) - 1);
+export function frameWidth(fallback = 80, columns) {
+    return Math.max(20, terminalColumns(fallback, columns) - 1);
 }
 const ROUNDED = { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" };
 const ASCII = { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" };
@@ -49,12 +53,17 @@ function centerLabel(label, width, fill) {
 export function roundedBox(lines, opts = {}) {
     const padding = Math.max(0, opts.padding ?? 1);
     const chars = boxChars();
-    const title = opts.title ? ` ${opts.title} ` : "";
+    let title = opts.title ? ` ${opts.title} ` : "";
     const contentInner = Math.max(0, ...lines.map(visibleWidth), visibleWidth(title)) + padding * 2;
     let innerWidth = contentInner;
+    let body = lines;
     if (opts.width !== undefined) {
-        // outer = inner + 2 border cols
-        innerWidth = Math.max(contentInner, opts.width - 2);
+        // outer = inner + 2 border cols; clamp, never grow.
+        innerWidth = Math.max(0, opts.width - 2);
+        const contentCells = Math.max(0, innerWidth - padding * 2);
+        body = lines.map((line) => visibleWidth(line) > contentCells ? padVisible(line, contentCells) : line);
+        if (visibleWidth(title) > innerWidth)
+            title = sliceVisible(title, 0, innerWidth);
     }
     else if (opts.minWidth !== undefined) {
         innerWidth = Math.max(contentInner, opts.minWidth - 2);
@@ -63,37 +72,12 @@ export function roundedBox(lines, opts = {}) {
         ? `${chars.tl}${centerLabel(title, innerWidth, chars.h)}${chars.tr}`
         : `${chars.tl}${chars.h.repeat(innerWidth)}${chars.tr}`);
     const bottom = ansi.gray(`${chars.bl}${chars.h.repeat(innerWidth)}${chars.br}`);
-    const body = lines.map((line) => {
-        const gap = Math.max(0, innerWidth - padding - visibleWidth(line));
-        return `${ansi.gray(chars.v)}${" ".repeat(padding)}${line}${" ".repeat(gap)}${ansi.gray(chars.v)}`;
+    const leftPad = Math.min(padding, innerWidth);
+    const rows = body.map((line) => {
+        const gap = Math.max(0, innerWidth - leftPad - visibleWidth(line));
+        return `${ansi.gray(chars.v)}${" ".repeat(leftPad)}${line}${" ".repeat(gap)}${ansi.gray(chars.v)}`;
     });
-    return [top, ...body, bottom];
-}
-/** Pad/truncate a line to an exact visible width (ANSI-safe). */
-export function padVisible(line, width) {
-    const w = visibleWidth(line);
-    if (w === width)
-        return line;
-    if (w < width)
-        return `${line}${" ".repeat(width - w)}`;
-    // Truncate while preserving ANSI codes: walk the string counting only
-    // visible characters, then slice the original at that position.
-    let visible = 0;
-    let i = 0;
-    const re = /\u001b\[[0-9;]*m/g;
-    while (visible < width && i < line.length) {
-        re.lastIndex = i;
-        const m = re.exec(line);
-        if (m && m.index === i) {
-            i = re.lastIndex;
-        }
-        else {
-            const code = line.charCodeAt(i);
-            i += code >= 0xd800 && code <= 0xdbff ? 2 : 1;
-            visible++;
-        }
-    }
-    return line.slice(0, i);
+    return [top, ...rows, bottom];
 }
 /**
  * Join left/right columns into rows of equal left-column width.

package/dist/ui/findings.d.ts

@@ -1,11 +1,13 @@
 /** Shared review-job findings payload (API may send snake or camel for off-diff). */
 export type ReviewFindings = {
+    specialists_run?: string[];
     inline?: {
         path: string;
         line: number;
         severity: string;
         body: string;
         title?: string;
+        specialist?: string;
     }[];
     off_diff?: {
         path?: string;
@@ -24,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,16 +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) {
-        console.log(`\n[${c.severity}] ${c.path}:${c.line}${c.title ? ` — ${c.title}` : ""}`);
-        console.log(c.body);
+        const lane = c.specialist ? `[${c.specialist}]` : "";
+        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/job-envelope.d.ts

@@ -0,0 +1,68 @@
+import type { ReviewFindings } from "./findings.js";
+export declare const REVIEW_JOB_ENVELOPE_SCHEMA: "mergestorm.review_job/v1";
+export type ReviewJobRow = {
+    job_id?: string | null;
+    id?: string | null;
+    status?: string | null;
+    thread_slug?: string | null;
+    thread_job_number?: number | null;
+    base_label?: string | null;
+    head_label?: string | null;
+    router_mode?: string | null;
+    specialists_requested?: string[] | null;
+    specialists_run?: string[] | null;
+    verdict?: string | null;
+    summary?: string | null;
+    findings?: ReviewFindings | null;
+    truncated?: boolean | null;
+    error?: string | null;
+    credits?: {
+        standard: number;
+    } | null;
+    webhook_secret?: string | null;
+    created_at?: string | null;
+    finished_at?: string | null;
+    retry_after_seconds?: number | null;
+};
+export type ReviewJobEnvelope = {
+    schema: typeof REVIEW_JOB_ENVELOPE_SCHEMA;
+    job_id: string | null;
+    status: string;
+    thread: {
+        slug: string;
+        job_number: number | null;
+    } | null;
+    base_label: string | null;
+    head_label: string | null;
+    router_mode: string | null;
+    specialists_requested: string[];
+    specialists_run: string[];
+    verdict: string | null;
+    summary: string | null;
+    findings: ReviewFindings | null;
+    truncated: boolean;
+    error: string | null;
+    credits: {
+        standard: number;
+    } | null;
+    webhook_secret: string | null;
+    created_at: string | null;
+    finished_at: string | null;
+    retry_after_seconds?: number;
+};
+export type ReviewEnvelopeFallbacks = {
+    jobId?: string | null;
+    status?: string;
+    threadSlug?: string | null;
+    baseLabel?: string | null;
+    headLabel?: string | null;
+    routerMode?: string | null;
+    specialistsRequested?: string[];
+    error?: string | null;
+    retryAfterSeconds?: number | null;
+};
+/**
+ * Stable machine envelope shared by submit and terminal review output.
+ * Fields added by the API-envelope work are nullable until that API lands.
+ */
+export declare function toReviewJobEnvelope(row: ReviewJobRow | null | undefined, fallback?: ReviewEnvelopeFallbacks): ReviewJobEnvelope;

package/dist/ui/job-envelope.js

@@ -0,0 +1,35 @@
+export const REVIEW_JOB_ENVELOPE_SCHEMA = "mergestorm.review_job/v1";
+/**
+ * Stable machine envelope shared by submit and terminal review output.
+ * Fields added by the API-envelope work are nullable until that API lands.
+ */
+export function toReviewJobEnvelope(row, fallback = {}) {
+    const slug = row?.thread_slug ?? fallback.threadSlug ?? null;
+    const findings = row?.findings ?? null;
+    const retryAfter = fallback.retryAfterSeconds ?? row?.retry_after_seconds ?? undefined;
+    return {
+        schema: REVIEW_JOB_ENVELOPE_SCHEMA,
+        job_id: row?.job_id ?? row?.id ?? fallback.jobId ?? null,
+        status: row?.status ?? fallback.status ?? "failed",
+        thread: slug
+            ? { slug, job_number: row?.thread_job_number ?? null }
+            : null,
+        base_label: row?.base_label ?? fallback.baseLabel ?? null,
+        head_label: row?.head_label ?? fallback.headLabel ?? null,
+        router_mode: row?.router_mode ?? fallback.routerMode ?? null,
+        specialists_requested: row?.specialists_requested ?? fallback.specialistsRequested ?? [],
+        specialists_run: row?.specialists_run ?? findings?.specialists_run ?? [],
+        verdict: row?.verdict ?? null,
+        summary: row?.summary ?? null,
+        findings,
+        truncated: row?.truncated ?? false,
+        error: fallback.error !== undefined ? fallback.error : (row?.error ?? null),
+        credits: row?.credits ?? null,
+        webhook_secret: row?.webhook_secret ?? null,
+        created_at: row?.created_at ?? null,
+        finished_at: row?.finished_at ?? null,
+        ...(retryAfter != null && Number.isFinite(retryAfter)
+            ? { retry_after_seconds: retryAfter }
+            : {}),
+    };
+}

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>;