@cruxy/cli 1.2.1 → 1.4.0

package/dist/tui/context-gauge.js

@@ -0,0 +1,48 @@
+import { readContext } from "../agent/context.js";
+/**
+ * The rail's context-window reading (P4 track 3) — the memoized, TUI-side half.
+ *
+ * The measurement itself moved to `agent/context.ts` in P6 track 3, so the
+ * panel, `/context` and the compaction seam all read one implementation. What
+ * stays here is the only thing that was ever TUI-specific: the memo.
+ *
+ * `estimateTokens` walks every block of every message, so it is O(history) — a
+ * full-window conversation is ~400k characters to scan. The rail repaints at
+ * ~30fps, so sampling on the paint path would scan that history thirty times a
+ * second to produce a number that only changes when a message is added.
+ *
+ * So the read and the walk are separated, the same shape as `GitStatusCache`:
+ * {@link current} is a field read the paint path may call freely, and
+ * {@link sample} does the walk at the seams where the history can actually have
+ * changed.
+ *
+ * WHERE THE NUMBER COMES FROM, and where it deliberately does NOT: see
+ * `agent/context.ts`. The short version is that `Session.usage` is the wrong
+ * source — it sums input+output across every `send` and never decreases, not
+ * even when compaction frees the window it is supposed to describe.
+ */
+export { readContext, } from "../agent/context.js";
+/** A memoized context reading. */
+export class ContextGauge {
+    source;
+    budget;
+    value;
+    constructor(source, budget) {
+        this.source = source;
+        this.budget = budget;
+    }
+    /** The last sampled reading; `undefined` before the first sample. */
+    current() {
+        return this.value;
+    }
+    /** Re-measure the history. Cheap enough at a turn or tool boundary, not per frame. */
+    sample() {
+        try {
+            this.value = readContext(this.source(), this.budget);
+        }
+        catch {
+            // A source that throws (a session torn down mid-turn) keeps the previous
+            // reading rather than blanking a panel that was correct a moment ago.
+        }
+    }
+}

package/dist/tui/git-status.js

@@ -0,0 +1,108 @@
+import { getGitInfoAsync, getGitTreeAsync, } from "../utils/git.js";
+export class GitStatusCache {
+    cwd;
+    probe;
+    value = undefined;
+    /** Set by {@link invalidate}; cleared once a refresh has actually settled. */
+    stale = true;
+    /** The refresh in flight, so concurrent triggers share one probe. */
+    inFlight = null;
+    constructor(cwd, probe = getGitInfoAsync) {
+        this.cwd = cwd;
+        this.probe = probe;
+    }
+    /**
+     * The last known state — a plain field read, safe from the paint path. Never
+     * probes, never blocks, and never lies about freshness: a stale value is the
+     * previous truth, which is a better answer than a stalled frame.
+     */
+    current() {
+        return this.value;
+    }
+    /**
+     * Mark the working tree as possibly changed. Cheap and idempotent — call it
+     * from every seam that could have written a file; the coalescing in
+     * {@link refresh} makes over-calling free.
+     */
+    invalidate() {
+        this.stale = true;
+    }
+    /**
+     * Re-probe if stale, and resolve once the value has settled.
+     *
+     * Concurrent callers share the in-flight probe rather than starting their own:
+     * a turn that writes ten files fires ten invalidations, and those must not
+     * become ten `git status` runs.
+     */
+    async refresh() {
+        if (!this.stale)
+            return;
+        if (this.inFlight)
+            return this.inFlight;
+        // Cleared BEFORE awaiting, so a write landing mid-probe re-marks it and the
+        // next refresh runs again. Clearing after would swallow that invalidation
+        // and leave the panel showing a tree that has already moved on.
+        this.stale = false;
+        this.inFlight = this.run();
+        try {
+            await this.inFlight;
+        }
+        finally {
+            this.inFlight = null;
+        }
+    }
+    async run() {
+        try {
+            this.value = await this.probe(this.cwd);
+        }
+        catch {
+            // A probe that throws is unknown, not "not a repo" — keep the last known
+            // value rather than downgrading the panel on a transient failure.
+        }
+    }
+}
+/**
+ * The same discipline across every declared root (P7 track 3).
+ *
+ * The rail names ONE branch because it has one line to do it in; the Overview
+ * view reports every root, because writes fan across all of them when
+ * checkpoints are on and a primary-only answer would under-report what a turn
+ * touched. That is more subprocesses, not a different rule — so this is a fan
+ * over {@link GitStatusCache} rather than a second implementation of it, and
+ * `current` stays the pure field read the paint path is allowed to call.
+ *
+ * Probes run CONCURRENTLY. They are independent processes against independent
+ * working trees, and serialising them would make a four-root workspace four
+ * times slower to settle for no gain.
+ */
+export class WorkspaceGitCache {
+    caches = new Map();
+    /**
+     * Probes with {@link getGitTreeAsync} by default, not the rail's cheaper
+     * {@link getGitInfoAsync} (P7 track 4): its consumers are the Overview and
+     * Git views, and the Git view needs the per-file list. The rail keeps the two
+     * -subprocess probe, because one line of branch-and-count has no use for a
+     * third.
+     */
+    constructor(paths, probe = getGitTreeAsync) {
+        for (const p of paths)
+            this.caches.set(p, new GitStatusCache(p, probe));
+    }
+    /**
+     * Last known state for one root — a field read, safe from the paint path.
+     * An unknown path reads as unprobed rather than throwing: the workspace can
+     * gain a root (`/add-root`) between this cache being built and a paint.
+     */
+    current(absPath) {
+        return this.caches.get(absPath)?.current();
+    }
+    /** Mark every root as possibly changed. Cheap and idempotent. */
+    invalidate() {
+        for (const c of this.caches.values())
+            c.invalidate();
+    }
+    /** Re-probe every stale root, in parallel, and resolve when all have settled. */
+    async refresh() {
+        await Promise.all([...this.caches.values()].map((c) => c.refresh()));
+    }
+}

package/dist/tui/git-view.js

@@ -0,0 +1,121 @@
+import { formatStat } from "../render/diff.js";
+import { fitMiddle } from "../render/layout.js";
+/** Verb column, fixed width so the paths align into a scannable column. */
+const VERBS = {
+    added: "added",
+    modified: "modified",
+    deleted: "deleted",
+    renamed: "renamed",
+    untracked: "new",
+    conflicted: "conflict",
+};
+const VERB_COLS = 8;
+/**
+ * How many files to list per root before summarising the rest.
+ *
+ * A cap rather than the whole list because a `node_modules` accident produces
+ * thousands of untracked paths, and a pane that has to be scrolled past them to
+ * reach the next root is worse than one that says how many it held back. The
+ * remainder is COUNTED, never silently dropped.
+ */
+export const GIT_VIEW_MAX_FILES = 200;
+/** Colour by what happened, so the shape of a change is legible before the path. */
+function styleVerb(status, theme) {
+    const verb = VERBS[status].padEnd(VERB_COLS);
+    switch (status) {
+        case "deleted":
+            return theme.danger(verb);
+        case "added":
+        case "untracked":
+            return theme.success(verb);
+        case "conflicted":
+            return theme.warning(verb);
+        default:
+            return theme.muted(verb);
+    }
+}
+/** `modified src/x.ts  +12/-3` — verb, path, then the counts when known. */
+function fileRow(file, theme, cols) {
+    const stat = formatStat(file, theme);
+    // The path is middle-truncated so the basename — the part that identifies the
+    // file — survives a narrow pane, the same rule `render/diff.ts` applies.
+    const room = Math.max(8, cols - VERB_COLS - 2 - (stat === "" ? 0 : 9));
+    const path = fitMiddle(file.path, room, theme.glyph.ellipsis);
+    return `${styleVerb(file.status, theme)} ${path}${stat === "" ? "" : ` ${stat}`}`;
+}
+/** One root's block: its heading, then its files or why there are none. */
+function rootLines(root, theme, cols, multiRoot) {
+    const lines = [];
+    if (multiRoot) {
+        const mark = root.primary ? theme.accent(theme.glyph.pointer) : " ";
+        lines.push(`${mark} ${theme.strong(root.name)}`);
+    }
+    // The tri-state, drawn as three different sentences. "Not probed" and "not a
+    // repo" are not the same claim, and neither is "clean" — see `status-view.ts`.
+    if (root.state === undefined) {
+        lines.push(theme.muted(`  checking${theme.glyph.ellipsis}`));
+        return lines;
+    }
+    if (root.state === null) {
+        lines.push(theme.muted("  not a git repo"));
+        return lines;
+    }
+    const { branch, files } = root.state;
+    lines.push(`  ${theme.strong(branch)}`);
+    if (files === undefined) {
+        // The cheap probe ran, so dirtiness is known but the list was never asked
+        // for. Say that rather than render an empty list as "nothing changed".
+        lines.push(theme.muted(root.state.changed > 0
+            ? `  ${root.state.changed} changed — file list not loaded`
+            : "  clean"));
+        return lines;
+    }
+    if (files.length === 0) {
+        lines.push(theme.success("  clean"));
+        return lines;
+    }
+    for (const file of files.slice(0, GIT_VIEW_MAX_FILES)) {
+        lines.push(`  ${fileRow(file, theme, Math.max(8, cols - 2))}`);
+    }
+    const hidden = files.length - GIT_VIEW_MAX_FILES;
+    if (hidden > 0) {
+        lines.push(theme.muted(`  ${theme.glyph.ellipsis}${hidden} more`));
+    }
+    return lines;
+}
+/** The whole Git view, as lines. Pure: no probe, no disk, no clock. */
+export function gitViewLines(theme, cols, roots) {
+    const lines = [theme.heading("git")];
+    if (roots.length === 0) {
+        lines.push(theme.muted("no declared roots"));
+        return lines;
+    }
+    const multiRoot = roots.length > 1;
+    for (const root of roots) {
+        lines.push("");
+        lines.push(...rootLines(root, theme, cols, multiRoot));
+    }
+    return lines;
+}
+/**
+ * The Git view as a registered source.
+ *
+ * `roots` is a callback rather than an array so `/add-root` mid-session is
+ * reflected without re-registering the view — the workspace is the owner of
+ * that list, and copying it here would make this the second place it lives.
+ */
+export function createGitView(roots, git) {
+    return {
+        id: "git",
+        label: "git",
+        lines: (theme, cols) => gitViewLines(theme, cols, roots().map((r) => ({
+            name: r.name,
+            primary: r.primary,
+            state: git.current(r.absPath),
+        }))),
+        refresh: async () => {
+            git.invalidate();
+            await git.refresh();
+        },
+    };
+}

package/dist/tui/index.js

@@ -0,0 +1,15 @@
+export { budgetColumns, bodyRows, columnOf, composeScreen, droppedForWidth, fitBlock, padTo, railOpen, stackPanels, CHROME_ROWS, CLOSABLE_PANELS, GUTTER, MIN_MAIN_COLS, RAIL_COLS, RAIL_PANELS, SIDEBAR_COLS, } from "./layout.js";
+export { COLUMN_LABELS, PANEL_LABELS, contextPanelLines, gitPanelLines, headerModel, modelPanelLines, mainWelcome, railBlocks, sidebarLines, toolsPanelLines, } from "./panels.js";
+export { ContextGauge, readContext, } from "./context-gauge.js";
+export { ToolVersions, parseVersion, } from "./tool-versions.js";
+export { GitStatusCache, WorkspaceGitCache, } from "./git-status.js";
+export { createOverviewView } from "./overview.js";
+export { createGitView, gitViewLines, GIT_VIEW_MAX_FILES, } from "./git-view.js";
+export { createTasksView, tasksViewLines, TASKS_VIEW_MAX_JOBS, TASKS_VIEW_TAIL, } from "./tasks-view.js";
+export { createSettingsView, settingsViewLines, formatSettingValue, } from "./settings-view.js";
+export { TuiRenderer, PAINT_INTERVAL_MS, VIEW_PULSE_MS, SCROLL_PAGE_OVERLAP, SCROLLBACK_LINES, } from "./renderer.js";
+export { CONVERSATION_VIEW, cycleView, navLines, viewLabel, viewOrder, } from "./views.js";
+export { runTui, renderInput, TUI_COMMANDS } from "./app.js";
+export { openPalette, paletteItems, paletteInsertion, paletteLabel, } from "./palette.js";
+export { canOverlay, createKeyLease, createOverlayFrame, createOverlayIO, } from "./overlay.js";
+export { supportsTui } from "./supports.js";

package/dist/tui/layout.js

@@ -0,0 +1,314 @@
+import { fit, visibleWidth } from "../render/layout.js";
+export const RAIL_PANELS = [
+    "context",
+    "model",
+    "git",
+    "tools",
+];
+export const CLOSABLE_PANELS = ["sidebar", ...RAIL_PANELS];
+/** Which column a panel is drawn in — the bridge between the two identities. */
+export function columnOf(panel) {
+    return panel === "sidebar" ? "sidebar" : "rail";
+}
+/** True when any rail panel is open, i.e. the rail column should be budgeted. */
+export function railOpen(open) {
+    return RAIL_PANELS.some((p) => open.has(p));
+}
+/** Fixed column widths; `main` takes whatever is left. */
+export const SIDEBAR_COLS = 18;
+/**
+ * 24, not the 20 P1 shipped.
+ *
+ * The rail's widest real content is a git branch name, and 20 could not hold
+ * one: `feat/p3-test-results` is exactly 20 columns before the marker glyph and
+ * change count the git panel has to put beside it. Every line here is hard
+ * truncated by {@link padTo}, so the branch — the part that identifies WHERE the
+ * work is happening — was the first thing to be cut.
+ *
+ * The cost is 4 columns off `main`, and it is affordable at the size that
+ * matters: at an 80-column terminal `main` goes 40 → 36, still comfortably over
+ * {@link MIN_MAIN_COLS}. Below that the rail was already being dropped whole.
+ */
+export const RAIL_COLS = 24;
+/** One blank column between adjacent panels. */
+export const GUTTER = 1;
+/** Below this, `main` is too cramped to read and a side column is dropped. */
+export const MIN_MAIN_COLS = 24;
+/** Rows the chrome costs: header + rule + (body) + rule + status + input. */
+export const CHROME_ROWS = 5;
+/** Below this height there is no room for a body; the shell collapses. */
+export const MIN_BODY_ROWS = 1;
+/**
+ * Resolve column widths for an inner width, honoring what the user has open.
+ * Degrades the same way the status line does (U.12) — shed context, keep the
+ * thing that carries meaning:
+ *
+ * - wide: sidebar + main + rail
+ * - medium: drop the rail, keep sidebar + main
+ * - narrow: main only
+ *
+ * A dropped column returns 0 — the caller distinguishes "closed by the user"
+ * from "dropped for width" via {@link droppedForWidth}, so the TUI can say so
+ * rather than silently losing a panel the user opened.
+ */
+export function budgetColumns(width, open) {
+    const wantSidebar = open.has("sidebar");
+    const wantRail = railOpen(open);
+    const gutters = (n) => Math.max(0, n - 1) * GUTTER;
+    if (wantSidebar && wantRail) {
+        const fixed = SIDEBAR_COLS + RAIL_COLS + gutters(3);
+        if (width - fixed >= MIN_MAIN_COLS) {
+            return { sidebar: SIDEBAR_COLS, main: width - fixed, rail: RAIL_COLS };
+        }
+    }
+    const single = wantSidebar ? SIDEBAR_COLS : wantRail ? RAIL_COLS : 0;
+    if (single > 0) {
+        const fixed = single + gutters(2);
+        if (width - fixed >= MIN_MAIN_COLS) {
+            return {
+                sidebar: wantSidebar ? SIDEBAR_COLS : 0,
+                main: width - fixed,
+                rail: wantSidebar ? 0 : RAIL_COLS,
+            };
+        }
+    }
+    return { sidebar: 0, main: Math.max(1, width), rail: 0 };
+}
+/**
+ * COLUMNS the user has open but the current width cannot fit — the honest
+ * complement to {@link budgetColumns}. The TUI surfaces these rather than
+ * letting a column vanish with no explanation.
+ *
+ * Reported per column, not per panel: width is a column-level budget, so four
+ * open rail panels losing their column is one fact, not four. Callers map a
+ * panel to its column with {@link columnOf}. The vertical mirror of this is
+ * {@link stackPanels}, which reports what a column's HEIGHT could not fit.
+ */
+export function droppedForWidth(budget, open) {
+    const dropped = [];
+    if (open.has("sidebar") && budget.sidebar === 0)
+        dropped.push("sidebar");
+    if (railOpen(open) && budget.rail === 0)
+        dropped.push("rail");
+    return dropped;
+}
+/** Rows available to the body at a given terminal height (at least 1). */
+export function bodyRows(height) {
+    return Math.max(MIN_BODY_ROWS, height - CHROME_ROWS);
+}
+/**
+ * Truncate to exactly `width` visible columns and pad with spaces to fill it.
+ * Column joining needs every cell to be the SAME visible width or the grid
+ * shears — `fit` alone only guarantees the upper bound.
+ */
+export function padTo(text, width) {
+    if (width <= 0)
+        return "";
+    const clipped = fit(text, width);
+    return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+/**
+ * Take the LAST `rows` lines of a panel's content and pad the block to exactly
+ * that many rows. Last-N (not first-N) because a SCROLLING panel is a tail view:
+ * the newest conversation line, the newest session, matter most.
+ *
+ * That rule is right for `main` and the sidebar and WRONG for the rail, which is
+ * a stack of fixed panels rather than a feed — see {@link stackPanels}. Do not
+ * reach for this to fit the rail.
+ */
+export function fitBlock(lines, rows, width) {
+    const tail = lines.length > rows ? lines.slice(lines.length - rows) : lines;
+    const out = tail.map((l) => padTo(l, width));
+    while (out.length < rows)
+        out.push(" ".repeat(Math.max(0, width)));
+    return out;
+}
+/**
+ * Window `rows` lines out of a block, `offset` display lines up from the end
+ * (P7 track 1). `offset === 0` is the tail view {@link fitBlock} gives, and the
+ * two agree line-for-line there.
+ *
+ * The offset is measured from the BOTTOM because that is the edge the user is
+ * anchored to: the live tail is the home position, and "how far back am I" is
+ * the question both the clamp and the notice need answered. Measuring from the
+ * top would make every append renumber the position.
+ *
+ * Clamping belongs here rather than at the key handler because only this
+ * function knows the content: the handler would have to re-derive the wrapped
+ * line count to bound a keypress, which is the calculation this already did.
+ */
+export function scrollWindow(lines, rows, offset) {
+    const visible = Math.max(0, rows);
+    // Everything above the last `visible` lines is reachable, and no further: the
+    // top of the document is the top of the window, never a screen of blank rows
+    // above it.
+    const maxOffset = Math.max(0, lines.length - visible);
+    const clamped = Math.min(Math.max(0, Math.floor(offset)), maxOffset);
+    const end = lines.length - clamped;
+    const start = Math.max(0, end - visible);
+    return {
+        lines: lines.slice(start, end),
+        offset: clamped,
+        hiddenBelow: clamped,
+        hiddenAbove: start,
+    };
+}
+/**
+ * The scrollback notice: how far back the view is, and how to get out of it.
+ *
+ * Shown only while scrolled, and it costs a row from the window rather than
+ * overlaying one — the same trade {@link stackPanels} makes for its overflow
+ * notice, for the same reason: silently hiding a line to report hidden lines
+ * would be the one dishonest way to draw this.
+ *
+ * It names the key because a scrolled view is a mode, and a mode the user
+ * cannot see the exit from is a trap — there is no scrollbar here to drag.
+ */
+export function scrollNotice(hiddenBelow, theme) {
+    const glyph = theme.unicode ? "↓" : "v";
+    return theme.warning(`${glyph} ${hiddenBelow} more line${hiddenBelow === 1 ? "" : "s"} below · PgDn / Esc to return`);
+}
+/** Rows the overflow notice costs when at least one panel is dropped. */
+const OVERFLOW_ROWS = 1;
+/**
+ * The overflow notice: how many panels the height could not hold. Kept short
+ * enough to survive {@link RAIL_COLS} after truncation.
+ */
+function overflowNotice(count, theme) {
+    return theme.muted(`${theme.glyph.ellipsis}${count} more panel${count === 1 ? "" : "s"}`);
+}
+/**
+ * Stack fixed panels TOP-DOWN into a row budget, reporting what did not fit.
+ *
+ * This is the vertical mirror of {@link droppedForWidth}, and it exists because
+ * {@link fitBlock} is actively wrong here. `fitBlock` keeps the LAST N rows —
+ * correct for a feed, but applied to a stack of fixed panels it eats the TOP of
+ * the rail first. Below roughly 19 body rows that silently deleted the context
+ * panel: no marker, no notice, a panel the user had open simply absent. A panel
+ * must never vanish without saying so — the same rule `droppedForWidth` enforces
+ * across the other axis.
+ *
+ * Panels are placed whole or not at all. A half-drawn gauge or a title with its
+ * body cut off reads as a rendering bug, and worse, reads as DATA — a context
+ * meter clipped to its first row looks like a real (wrong) number. Dropping it
+ * and counting it is the honest failure.
+ *
+ * One blank separator row sits between adjacent panels, and is charged for here
+ * rather than baked into each block, so a panel's own height stays its own
+ * business.
+ */
+export function stackPanels(blocks, rows, theme) {
+    if (rows <= 0) {
+        return { lines: [], dropped: blocks.map((b) => b.id) };
+    }
+    // Cost of placing the first `n` blocks: their heights plus the separators
+    // between them. Computed against the same rule the placement loop uses, so
+    // the "does everything fit" test below cannot drift from the loop.
+    const costOf = (n) => blocks
+        .slice(0, n)
+        .reduce((sum, b, i) => sum + b.lines.length + (i > 0 ? 1 : 0), 0);
+    // Everything fits: no notice row, nothing dropped, no budget games.
+    const fitsWhole = costOf(blocks.length) <= rows;
+    // Otherwise the notice itself needs a row, and it must be paid for BEFORE
+    // deciding what fits — reserving it afterwards could push out a panel that
+    // the user was just told fit.
+    const budget = fitsWhole ? rows : rows - OVERFLOW_ROWS;
+    // The longest PREFIX that fits. Not a best-fit pack: skipping a tall panel to
+    // squeeze in a shorter one below it would reorder the rail, and the order is
+    // meaningful — it is the order the user reads, and the order `/help` lists.
+    let placed = 0;
+    while (placed < blocks.length && costOf(placed + 1) <= budget)
+        placed++;
+    const lines = [];
+    for (let i = 0; i < placed; i++) {
+        if (i > 0)
+            lines.push("");
+        lines.push(...blocks[i].lines);
+    }
+    const dropped = blocks.slice(placed).map((b) => b.id);
+    if (dropped.length > 0)
+        lines.push(overflowNotice(dropped.length, theme));
+    return { lines, dropped };
+}
+/**
+ * Body rows an overlay may occupy at a given height — its budget, so a caller
+ * can fit its own content to the drawer instead of discovering the truncation.
+ * Always leaves at least one row to the columns: an overlay never blanks the
+ * conversation the way the old full-frame clear did.
+ */
+export function overlayRows(height) {
+    return Math.max(0, bodyRows(height) - 1);
+}
+/**
+ * Fit overlay content to `rows`, keeping the FIRST row and the tail.
+ *
+ * A safety net, not the fitting strategy: {@link overlayRows} publishes the
+ * budget and callers are expected to compose within it. When one does not, this
+ * keeps the two rows a modal cannot lose — row 0 (its identity: what is being
+ * asked, and at what risk) and the last rows (what the user can press) — rather
+ * than the plain tail every feed-shaped block here uses. A drawer is not a feed.
+ */
+export function fitOverlay(lines, rows) {
+    if (rows <= 0)
+        return [];
+    if (lines.length <= rows)
+        return lines;
+    if (rows === 1)
+        return [lines[0]];
+    return [lines[0], ...lines.slice(lines.length - (rows - 1))];
+}
+/** Compose the header row: left flush, right flush, dropped when it won't fit. */
+function headerRow(vm, width, theme) {
+    const left = theme.strong(theme.accent(fit(vm.headerLeft, width)));
+    const leftW = visibleWidth(fit(vm.headerLeft, width));
+    const room = width - leftW - 2;
+    if (room < 8 || vm.headerRight === "")
+        return padTo(left, width);
+    const right = fit(vm.headerRight, room);
+    const gap = width - leftW - visibleWidth(right);
+    return left + " ".repeat(Math.max(1, gap)) + theme.muted(right);
+}
+/**
+ * Compose the full screen: exactly `height` rows, each at most `width` visible
+ * columns. The caller hands these straight to the transient frame.
+ *
+ * Every row is padded to the full width so a repaint fully overwrites the row
+ * beneath it — a short row would leave the previous paint's tail on screen.
+ */
+export function composeScreen(vm, width, height, open, theme) {
+    const budget = budgetColumns(width, open);
+    const rows = bodyRows(height);
+    // The rule follows the theme's unicode axis (U.1) like every other glyph —
+    // a box-drawing dash would mojibake on a CRUXY_ASCII / dumb terminal.
+    const rule = theme.muted((theme.unicode ? "─" : "-").repeat(Math.max(0, width)));
+    // An overlay is a drawer: it takes rows from the BOTTOM of the body and the
+    // columns render into what is left. The columns keep at least one row, so a
+    // modal never blanks the conversation behind it.
+    const drawer = fitOverlay(vm.overlay ?? [], overlayRows(height));
+    const columnRows = Math.max(1, rows - drawer.length);
+    const columns = [];
+    if (budget.sidebar > 0)
+        columns.push(fitBlock(vm.sidebar, columnRows, budget.sidebar));
+    columns.push(fitBlock(vm.main, columnRows, budget.main));
+    if (budget.rail > 0)
+        columns.push(fitBlock(vm.rail, columnRows, budget.rail));
+    const body = [];
+    for (let r = 0; r < columnRows; r++) {
+        body.push(columns.map((c) => c[r]).join(" ".repeat(GUTTER)));
+    }
+    // Padded to the full width like every other row: the grid shears otherwise,
+    // and a short overlay row would leave stale column bytes to its right.
+    for (const line of drawer)
+        body.push(padTo(line, width));
+    const screen = [
+        headerRow(vm, width, theme),
+        rule,
+        ...body,
+        rule,
+        padTo(vm.status === "" ? "" : theme.muted(vm.status), width),
+        padTo(vm.input, width),
+    ];
+    // A terminal shorter than the chrome itself: keep the last `height` rows, so
+    // the input line — the only row the user can act on — always survives.
+    return screen.length > height ? screen.slice(screen.length - height) : screen;
+}