mergestorm 0.3.13 → 0.3.15

package/dist/ui/prompt.d.ts

@@ -17,6 +17,13 @@ export interface AskLineOptions {
     /** Streams (defaults: process.stdin / process.stdout). Injectable for tests. */
     input?: NodeJS.ReadStream;
     output?: NodeJS.WriteStream;
+    /**
+     * Welcome-panel rows sitting directly above this prompt, reflowed per
+     * width. Painted on every frame from the pane origin (`ESC[H`) so a
+     * resize cannot desync CUU counts. Pass `true` for compact, `"mini"` /
+     * `"nano"` for a short pane that still shows the mark.
+     */
+    header?: (columns?: number, variant?: boolean | "mini" | "nano") => string[];
 }
 /** Thrown when the user asks to close the prompt (Ctrl+D empty, or Ctrl+C twice). */
 export declare class PromptClosedError extends Error {
@@ -34,6 +41,12 @@ export declare function promptRedrawPrefix(inputRow: number): string;
  * (`down(2)`). Plain chrome is the content line (`down(1)`).
  */
 export declare function promptClearOverlay(boxed: boolean): string;
+/**
+ * Cursor home + ED 0: clears the whole screen from row 1 and leaves the
+ * cursor there. Used to redraw the welcome panel on resize, where the old
+ * frame's row count is unknowable after the terminal rewraps.
+ */
+export declare const HEADER_REDRAW_PREFIX = "\u001B[H\u001B[0J";
 export declare const DROPDOWN_MAX_COMMAND_ROWS = 8;
 export declare function formatSlashLabel(spec: CommandSpec): string;
 export declare function specMatchesTerm(spec: CommandSpec, term: string): boolean;
@@ -51,6 +64,39 @@ export type OverlayRow = {
     selected?: boolean;
 };
 /** Overlay rows (no invert). At most `maxRows` commands plus edge markers. */
+/** Prompt label + input chrome + footer hint. */
+export declare function promptChromeRows(boxed: boolean, hasPrompt: boolean, hasHint?: boolean): number;
+/**
+ * Rows available above the input bar for the slash list. Idle home
+ * passes 0 — do not pad a blank gap between header and prompt.
+ */
+export declare function overlayReserve(terminalRows: number | undefined, headerRows: number, boxed: boolean, hasPrompt: boolean): number;
+/** Pad so the slash list sits just above the input bar (Claude-style). */
+export declare function padOverlayRows(rows: OverlayRow[], reserve: number): OverlayRow[];
+export interface HomeFrameFit {
+    header: string[];
+    reserve: number;
+    boxed: boolean;
+    hasPrompt: boolean;
+    hasHint: boolean;
+}
+/**
+ * Pick a header density and input chrome that fit the pane.
+ * Never drops the mark when a mini/nano header is provided — a short
+ * pane unboxes the input instead of painting an overflowing frame.
+ * `dockBottom` uses leftover rows so the prompt sits on the last lines.
+ */
+export declare function fitHomeFrame(params: {
+    fullHeader: string[];
+    compactHeader: string[];
+    miniHeader?: string[];
+    nanoHeader?: string[];
+    terminalRows: number | undefined;
+    boxed: boolean;
+    hasPrompt: boolean;
+    dropdownCount: number;
+    dockBottom?: boolean;
+}): HomeFrameFit;
 export declare function dropdownOverlayRows(dropdown: CommandSpec[], index: number, maxRows: number): OverlayRow[];
 /** Input prefix glyph (U+203A), kept as an escape so editors can't mangle it. */
 export declare const INPUT_PREFIX_GLYPH = "\u203A";
@@ -73,7 +119,7 @@ export interface InputWindow {
  */
 export declare function inputWindow(buffer: string, cursor: number, cells: number, prevStart?: number): InputWindow;
 /** Cells available to the buffer (after the prefix) on a content row. */
-export declare function inputCells(columns: number | undefined): {
+export declare function inputCells(columns: number | undefined, boxedOverride?: boolean): {
     boxed: boolean;
     cells: number;
 };
@@ -86,6 +132,17 @@ export interface PromptFrameInput {
     /** Previous scroll origin, so left/right only move the window at the edges. */
     scrollStart?: number;
     overlay?: OverlayRow[];
+    /**
+     * When set, the overlay is padded to this many rows and drawn **above**
+     * the input bar. Height stays constant so `/` cannot scroll the header.
+     */
+    overlayReserve?: number;
+    /** Trailing footer row (empty or the Ctrl+C hint). */
+    hint?: string;
+    /** Welcome-panel rows painted with this frame (idle home screen). */
+    header?: string[];
+    /** Force boxed / plain input. Default follows {@link preferBoxedUi}. */
+    boxed?: boolean;
 }
 export interface PromptFrame {
     rows: string[];

package/dist/ui/prompt.js

@@ -31,6 +31,12 @@ export function promptRedrawPrefix(inputRow) {
 export function promptClearOverlay(boxed) {
     return `${down(boxed ? 2 : 1)}\r${clearDown}`;
 }
+/**
+ * Cursor home + ED 0: clears the whole screen from row 1 and leaves the
+ * cursor there. Used to redraw the welcome panel on resize, where the old
+ * frame's row count is unknowable after the terminal rewraps.
+ */
+export const HEADER_REDRAW_PREFIX = `\u001b[H${clearDown}`;
 export const DROPDOWN_MAX_COMMAND_ROWS = 8;
 export function formatSlashLabel(spec) {
     const extra = spec.aliases?.length
@@ -85,12 +91,108 @@ export function dropdownViewport(count, index, maxRows) {
     };
 }
 /** Overlay rows (no invert). At most `maxRows` commands plus edge markers. */
+/** Prompt label + input chrome + footer hint. */
+export function promptChromeRows(boxed, hasPrompt, hasHint = true) {
+    return (hasPrompt ? 1 : 0) + (boxed ? 3 : 1) + (hasHint ? 1 : 0);
+}
+function resolvedRows(terminalRows) {
+    return typeof terminalRows === "number" && Number.isFinite(terminalRows) && terminalRows >= 1
+        ? terminalRows
+        : 24;
+}
+/**
+ * Rows available above the input bar for the slash list. Idle home
+ * passes 0 — do not pad a blank gap between header and prompt.
+ */
+export function overlayReserve(terminalRows, headerRows, boxed, hasPrompt) {
+    const available = resolvedRows(terminalRows) - Math.max(0, headerRows) - promptChromeRows(boxed, hasPrompt);
+    return Math.max(0, Math.min(DROPDOWN_MAX_COMMAND_ROWS, available));
+}
+/** Pad so the slash list sits just above the input bar (Claude-style). */
+export function padOverlayRows(rows, reserve) {
+    const max = Math.max(0, reserve);
+    if (max === 0)
+        return [];
+    const visible = rows.slice(0, max);
+    const pad = max - visible.length;
+    return [...Array.from({ length: pad }, () => ({ text: " " })), ...visible];
+}
+/**
+ * Pick a header density and input chrome that fit the pane.
+ * Never drops the mark when a mini/nano header is provided — a short
+ * pane unboxes the input instead of painting an overflowing frame.
+ * `dockBottom` uses leftover rows so the prompt sits on the last lines.
+ */
+export function fitHomeFrame(params) {
+    const rows = resolvedRows(params.terminalRows);
+    const want = params.dropdownCount > 0
+        ? Math.min(DROPDOWN_MAX_COMMAND_ROWS, Math.max(1, params.dropdownCount))
+        : 0;
+    const headers = [
+        params.fullHeader,
+        params.compactHeader,
+        params.miniHeader ?? [],
+        params.nanoHeader ?? [],
+    ].filter((h, i, all) => h.length > 0 && all.findIndex((x) => x === h) === i);
+    const chromes = [];
+    if (params.boxed)
+        chromes.push({ boxed: true, hasPrompt: params.hasPrompt, hasHint: true });
+    chromes.push({ boxed: false, hasPrompt: params.hasPrompt, hasHint: true });
+    chromes.push({ boxed: false, hasPrompt: false, hasHint: true });
+    chromes.push({ boxed: false, hasPrompt: false, hasHint: false });
+    const tryFit = (header, chrome) => {
+        const chromeRows = promptChromeRows(chrome.boxed, chrome.hasPrompt, chrome.hasHint);
+        const avail = rows - header.length - chromeRows;
+        if (avail < 0)
+            return null;
+        if (params.dockBottom) {
+            return { header, reserve: avail, ...chrome };
+        }
+        if (want === 0) {
+            return { header, reserve: 0, ...chrome };
+        }
+        const maxList = Math.max(0, Math.min(DROPDOWN_MAX_COMMAND_ROWS, avail));
+        if (maxList < 1)
+            return null;
+        return { header, reserve: Math.min(want, maxList), ...chrome };
+    };
+    // Prefer keeping the input boxed: try every header density at the
+    // current chrome before unboxing. Otherwise a 12-row pane would pick
+    // the full banner + a plain prompt over compact + boxed.
+    for (const chrome of chromes) {
+        for (const header of headers) {
+            const hit = tryFit(header, chrome);
+            if (hit)
+                return hit;
+        }
+    }
+    const fallback = params.nanoHeader?.length
+        ? params.nanoHeader
+        : params.miniHeader?.length
+            ? params.miniHeader
+            : [];
+    return {
+        header: fallback,
+        reserve: params.dockBottom ? Math.max(0, rows - fallback.length - 1) : 0,
+        boxed: false,
+        hasPrompt: false,
+        hasHint: false,
+    };
+}
 export function dropdownOverlayRows(dropdown, index, maxRows) {
-    const view = dropdownViewport(dropdown.length, index, maxRows);
+    const max = Math.max(1, maxRows);
+    if (dropdown.length <= max) {
+        return dropdown.map((spec, i) => ({
+            text: `  ${formatSlashLabel(spec).padEnd(22)}${spec.summary}`,
+            selected: i === index,
+        }));
+    }
+    const cmdSlots = Math.max(1, max - 2);
+    const view = dropdownViewport(dropdown.length, index, cmdSlots);
     const rows = [];
     if (view.moreAbove > 0)
         rows.push({ text: `  \u2191 ${view.moreAbove} more` });
-    const end = Math.min(dropdown.length, view.start + Math.max(1, maxRows));
+    const end = Math.min(dropdown.length, view.start + cmdSlots);
     for (let i = view.start; i < end; i++) {
         const spec = dropdown[i];
         rows.push({
@@ -100,7 +202,7 @@ export function dropdownOverlayRows(dropdown, index, maxRows) {
     }
     if (view.moreBelow > 0)
         rows.push({ text: `  \u2193 ${view.moreBelow} more` });
-    return rows;
+    return rows.slice(0, max);
 }
 /** Input prefix glyph (U+203A), kept as an escape so editors can't mangle it. */
 export const INPUT_PREFIX_GLYPH = "\u203a";
@@ -133,8 +235,8 @@ export function inputWindow(buffer, cursor, cells, prevStart = 0) {
     };
 }
 /** Cells available to the buffer (after the prefix) on a content row. */
-export function inputCells(columns) {
-    const boxed = preferBoxedUi(columns);
+export function inputCells(columns, boxedOverride) {
+    const boxed = boxedOverride ?? preferBoxedUi(columns);
     const contentCells = boxed
         ? frameWidth(80, columns) - 2 - INPUT_BOX_PADDING * 2
         : terminalColumns(80, columns) - 1;
@@ -146,16 +248,37 @@ export function inputCells(columns) {
  * CUU count on the next redraw stays honest.
  */
 export function buildPromptFrame(params) {
-    const { boxed, cells } = inputCells(params.columns);
+    const { boxed, cells } = inputCells(params.columns, params.boxed);
     const cols = terminalColumns(80, params.columns);
     const win = inputWindow(params.buffer, params.cursor, cells, params.scrollStart ?? 0);
-    const inputRow = (params.prompt ? 1 : 0) + (boxed ? 1 : 0);
+    const header = params.header ?? [];
+    const reserve = params.overlayReserve;
+    const overlay = params.overlay ?? [];
+    const fitted = reserve != null ? padOverlayRows(overlay, reserve) : overlay;
+    const inputRow = header.length +
+        (reserve ?? 0) +
+        (params.prompt ? 1 : 0) +
+        (boxed ? 1 : 0);
     // Nothing we emit may wrap: a wrapped row is one the CUU count can't see.
     const clip = (text) => visibleWidth(text) > cols - 1 ? sliceVisible(text, 0, cols - 1) : text;
+    const paintOverlay = (row) => {
+        const text = clip(row.text);
+        return row.selected ? ansi.invert(text) : ansi.gray(text);
+    };
     const rows = [];
+    if (reserve != null) {
+        for (const line of header)
+            rows.push(clip(line));
+        for (const row of fitted)
+            rows.push(paintOverlay(row));
+    }
+    else {
+        for (const line of header)
+            rows.push(clip(line));
+    }
     if (params.prompt)
-        rows.push(ansi.dim(clip(params.prompt)));
-    const inputLine = `${ansi.green(INPUT_PREFIX_GLYPH)} ${win.text}`;
+        rows.push(clip(params.prompt));
+    const inputLine = `${ansi.brightGreen(INPUT_PREFIX_GLYPH)} ${win.text}`;
     if (boxed) {
         // Full terminal width input frame, not content-sized.
         rows.push(...roundedBox([inputLine], {
@@ -167,9 +290,12 @@ export function buildPromptFrame(params) {
         // Plain prompt on narrow TTYs (avoids wrapped borders).
         rows.push(inputLine);
     }
-    for (const row of params.overlay ?? []) {
-        const text = clip(row.text);
-        rows.push(row.selected ? ansi.invert(text) : ansi.gray(text));
+    if (reserve == null) {
+        for (const row of overlay)
+            rows.push(paintOverlay(row));
+    }
+    if (params.hint != null) {
+        rows.push(clip(params.hint === "" ? " " : params.hint));
     }
     // Boxed: border col + padding; plain: column 1.
     const targetCol = (boxed ? 1 + INPUT_BOX_PADDING : 0) + INPUT_PREFIX_CELLS + win.cursorCol + 1;
@@ -207,9 +333,9 @@ export async function askLine(opts) {
         // final overlay clear must use *these*, not a fresh measurement, because
         // the cursor is parked relative to what was actually drawn.
         let drawnInputRow = 0;
-        let drawnBoxed = true;
         let scrollStart = 0;
         let finished = false;
+        let exitHint = false;
         const ctrlCExit = new CtrlCExitGate();
         const wasRaw = Boolean(input.isRaw);
         readline.emitKeypressEvents(input);
@@ -223,44 +349,97 @@ export async function askLine(opts) {
                 dropdownDismissed = false;
             buffer = next;
         }
-        function render() {
-            if (linesDrawn > 0) {
-                output.write(promptRedrawPrefix(drawnInputRow));
-            }
-            // Re-measured every frame: the terminal may have been resized since
-            // the last draw, flipping boxed/plain or changing the frame width.
+        let lastRoom = 24;
+        function paint() {
             const columns = opts.columns ?? output.columns;
             const boxedNow = preferBoxedUi(columns);
-            const inputRowNow = (opts.prompt ? 1 : 0) + (boxedNow ? 1 : 0);
+            const rawRoom = opts.rows ?? output.rows;
+            const room = typeof rawRoom === "number" && Number.isFinite(rawRoom) && rawRoom >= 1
+                ? rawRoom
+                : lastRoom;
+            lastRoom = room;
+            const fullHeader = opts.header ? opts.header(columns, false) : [];
+            const compactHeader = opts.header ? opts.header(columns, true) : [];
+            const miniHeader = opts.header ? opts.header(columns, "mini") : [];
+            const nanoHeader = opts.header ? opts.header(columns, "nano") : [];
             const dropdown = currentDropdown();
-            let overlay = [];
             if (dropdown.length) {
                 if (dropdownIndex >= dropdown.length)
                     dropdownIndex = dropdown.length - 1;
-                const maxRows = dropdownMaxRows(opts.rows ?? output.rows, inputRowNow);
-                overlay = dropdownOverlayRows(dropdown, dropdownIndex, maxRows);
             }
             else {
                 dropdownIndex = 0;
             }
+            const roomRows = resolvedRows(room);
+            const fit = opts.header
+                ? fitHomeFrame({
+                    fullHeader,
+                    compactHeader,
+                    miniHeader,
+                    nanoHeader,
+                    terminalRows: room,
+                    boxed: boxedNow,
+                    hasPrompt: Boolean(opts.prompt),
+                    dropdownCount: dropdown.length,
+                    dockBottom: true,
+                })
+                : {
+                    header: [],
+                    reserve: overlayReserve(room, 0, boxedNow, Boolean(opts.prompt)),
+                    boxed: boxedNow,
+                    hasPrompt: Boolean(opts.prompt),
+                    hasHint: true,
+                };
+            const overlay = dropdown.length
+                ? dropdownOverlayRows(dropdown, dropdownIndex, Math.max(1, Math.min(DROPDOWN_MAX_COMMAND_ROWS, fit.reserve)))
+                : [];
             const frame = buildPromptFrame({
-                prompt: opts.prompt,
+                prompt: fit.hasPrompt ? opts.prompt : undefined,
                 buffer,
                 cursor,
                 columns,
                 scrollStart,
                 overlay,
+                overlayReserve: opts.header || dropdown.length ? fit.reserve : undefined,
+                header: fit.header,
+                hint: fit.hasHint ? (exitHint ? ansi.dim(CTRL_C_EXIT_HINT) : " ") : undefined,
+                boxed: fit.boxed,
             });
-            output.write(frame.rows.join("\r\n") + "\r\n");
+            // Never write more rows than the pane — that scrolls the welcome
+            // tail (tips / what's new) into view and looks like a broken frame.
+            if (frame.rows.length > roomRows) {
+                const keep = frame.rows.slice(frame.rows.length - roomRows);
+                const shift = frame.rows.length - keep.length;
+                frame.rows = keep;
+                frame.inputRow = Math.max(0, frame.inputRow - shift);
+            }
+            // Home screen owns the pane: always origin + ED 0. Relative CUU after
+            // a split-drag is what tore the previous layout (cursor home vs
+            // includeHeader flipping mid-resize).
+            if (opts.header) {
+                output.write(HEADER_REDRAW_PREFIX);
+            }
+            else if (linesDrawn > 0) {
+                output.write(promptRedrawPrefix(drawnInputRow));
+            }
+            // A full-pane write plus a trailing newline scrolls row 1 into
+            // scrollback — that was the missing top border. Stop on the last
+            // cell of the last row and CUU from there.
+            const fillsPane = Boolean(opts.header) && frame.rows.length >= roomRows;
+            output.write(frame.rows.join("\r\n") + (fillsPane ? "" : "\r\n"));
             linesDrawn = frame.rows.length;
             drawnInputRow = frame.inputRow;
-            drawnBoxed = frame.boxed;
             scrollStart = frame.scrollStart;
-            output.write(`${up(linesDrawn - frame.inputRow)}${col(frame.targetCol)}`);
+            const fromRow = fillsPane ? linesDrawn - 1 : linesDrawn;
+            output.write(`${up(Math.max(0, fromRow - frame.inputRow))}${col(frame.targetCol)}`);
+        }
+        function render() {
+            paint();
         }
         function onResize() {
-            if (!finished)
-                render();
+            if (finished)
+                return;
+            paint();
         }
         function cleanup() {
             input.removeListener("keypress", onKeypress);
@@ -275,9 +454,19 @@ export async function askLine(opts) {
                 return;
             finished = true;
             cleanup();
-            if (linesDrawn > 0)
-                output.write(promptClearOverlay(drawnBoxed));
-            output.write("\n");
+            // Home chrome already fills the pane. down() + newline scrolls that
+            // frame (cursor to the bottom, input jumps up) before /usage paints.
+            // Leave the idle screen in place; the next TUI / askLine homes over it.
+            // Bare prompts still need the newline so oneshot output starts below.
+            // Leaving the shell: one newline so the OS prompt is not on the box.
+            if (!opts.header || err instanceof PromptClosedError) {
+                if (linesDrawn > 0) {
+                    const below = linesDrawn - drawnInputRow - 1;
+                    if (below > 0)
+                        output.write(down(below));
+                }
+                output.write("\n");
+            }
             if (err)
                 reject(err);
             else
@@ -292,23 +481,17 @@ export async function askLine(opts) {
             try {
                 if (finished || !key)
                     return;
-                if (!(key.ctrl && key.name === "c"))
+                if (!(key.ctrl && key.name === "c")) {
                     ctrlCExit.reset();
+                    exitHint = false;
+                }
                 const dropdown = currentDropdown();
                 if (key.ctrl && key.name === "c") {
                     if (ctrlCExit.press()) {
                         finish(null, new PromptClosedError());
                         return;
                     }
-                    setBuffer("");
-                    cursor = 0;
-                    scrollStart = 0;
-                    historyIndex = history.length;
-                    dropdownIndex = 0;
-                    if (linesDrawn > 0)
-                        output.write(promptClearOverlay(drawnBoxed));
-                    output.write(`\n${ansi.dim(CTRL_C_EXIT_HINT)}\n`);
-                    linesDrawn = 0;
+                    exitHint = true;
                     render();
                     return;
                 }

package/dist/ui/select.js

@@ -38,7 +38,7 @@ export async function selectFromList(opts) {
                 rows.push(ansi.bold(opts.title));
             items.forEach((item, i) => {
                 const body = opts.render(item, i);
-                const marker = i === index ? ansi.green("›") : " ";
+                const marker = i === index ? ansi.brightGreen("›") : " ";
                 const line = ` ${marker} ${body}`;
                 rows.push(i === index ? ansi.invert(line) : line);
             });

package/dist/ui/tabs.d.ts

@@ -0,0 +1,125 @@
+import { type UsagePanelInput } from "./usage.js";
+export type TabId = "status" | "usage" | "jobs" | "config";
+export declare const TAB_ORDER: readonly TabId[];
+export type TabsJob = {
+    id: string;
+    cells: {
+        job: string;
+        status: string;
+        verdict: string;
+        thread: string;
+        when: string;
+    };
+};
+/** One Config-tab row: a writable on/off toggle or a read-only connection. */
+export type TabsConfigRow = {
+    /** Settings key sent on PATCH (writable rows only). */
+    key: string;
+    label: string;
+    value: boolean;
+    writable: boolean;
+};
+export type TabsData = {
+    /** Prebuilt whoami + credits lines for the Status tab. */
+    statusLines: string[];
+    /** Right-aligned chrome note (reachability). Lives on the hint row. */
+    footerNote?: string;
+    /** Usage panel input minus width concerns; null when the API degraded. */
+    usage: Omit<UsagePanelInput, "columns" | "color"> | null;
+    /** Usage-tab body when the panel is unavailable (overrides the default). */
+    usageEmptyText?: string;
+    jobs: TabsJob[];
+    /** Jobs-tab body when the list is empty (e.g. the list call failed). */
+    jobsEmptyText?: string;
+    /** Config tab rows; null when GET /api/v1/settings degraded. */
+    config: TabsConfigRow[] | null;
+    /** Config-tab body when settings are unavailable (overrides the default). */
+    configEmptyText?: string;
+    /** Transient Config-tab status line (PATCH in flight or rejected). */
+    configNote?: string;
+    color?: boolean;
+};
+export type TabsDetail = {
+    jobId: string;
+    rows: string[];
+};
+export type TabsState = {
+    tab: TabId;
+    /** Body scroll per scrollable view; jobs and config scroll by selection. */
+    scroll: {
+        status: number;
+        usage: number;
+        detail: number;
+    };
+    jobsIndex: number;
+    configIndex: number;
+    /** In-place `status <id>` view on the Jobs tab; Esc returns to the list. */
+    detail: TabsDetail | null;
+};
+export declare function initialTabsState(tab?: TabId): TabsState;
+export type TabsKeyName = "left" | "right" | "up" | "down" | "return" | "space" | "escape" | "q";
+export type TabsStep = {
+    kind: "state";
+    state: TabsState;
+} | {
+    kind: "close";
+} | {
+    kind: "open-job";
+    index: number;
+    state: TabsState;
+} | {
+    kind: "toggle-setting";
+    key: string;
+    value: boolean;
+    state: TabsState;
+};
+export type TabsReduceCtx = {
+    jobsCount: number;
+    /** Max scroll offset of the active view (content rows minus body rows). */
+    maxScroll: number;
+    /** Config rows so Space knows which key to flip (read-only rows no-op). */
+    config?: readonly TabsConfigRow[];
+};
+/**
+ * One keypress against the browser state. Pure so tests can drive the whole
+ * key map without a TTY. Tabs clamp at the ends (no wrap-around, so "which
+ * tab am I on" never gets ambiguous); Esc backs out of a job detail before
+ * it closes the browser; `q` always closes.
+ */
+export declare function reduceTabsKey(state: TabsState, key: TabsKeyName, ctx: TabsReduceCtx): TabsStep;
+/** Body rows available inside the frame: total rows minus chrome + hint. */
+export declare function tabsBodyRows(rows: number | undefined): number;
+export type TabsLayout = {
+    /** Full frame (border, body, hint); no line wider than `columns - 1`. */
+    lines: string[];
+    bodyRows: number;
+    /** Content rows of the active view before clipping (drives max scroll). */
+    contentRows: number;
+};
+export declare function tabsMaxScroll(layout: TabsLayout): number;
+/** Key hint on the left, optional reachability note on the right. */
+export declare function tabsHintLine(left: string, right: string | undefined, columns: number, color: boolean): string;
+/**
+ * The whole browser frame for one render: tab strip in the top border, the
+ * active tab's body clipped to `rows - 4`, and a dim key hint. Pure; the
+ * raw-mode loop and tests both consume it.
+ */
+export declare function layoutTabs(state: TabsState, data: TabsData, columns?: number, rows?: number): TabsLayout;
+export type TabsBrowserOptions = {
+    initial?: TabId;
+    data: TabsData;
+    /** Fetches `status <id>` rows for the Jobs tab's Enter action. */
+    loadJobDetail?: (jobId: string) => Promise<string[]>;
+    /** PATCHes one setting for the Config tab's Space action; resolves to the refreshed rows. */
+    toggleSetting?: (key: string, value: boolean) => Promise<TabsConfigRow[]>;
+    input?: NodeJS.ReadStream;
+    output?: NodeJS.WriteStream;
+};
+/**
+ * Raw-mode tabbed browser (Status / Usage / Jobs / Config) on the select.ts
+ * loop: Left/Right switch tabs, Up/Down scroll or select, Enter opens a job
+ * in place, Space toggles a Config setting, `q`/Esc close, resize re-renders.
+ * Non-TTY streams fall back to the static panels (callers normally gate on
+ * TTY already).
+ */
+export declare function runTabsBrowser(opts: TabsBrowserOptions): Promise<void>;