@cruxy/cli 1.2.0 → 1.3.0

package/dist/render/diff.js

@@ -7,8 +7,109 @@ import { fit, fitMiddle } from "./layout.js";
  * `+`/`-` lines from the exact same code path. Diff add/remove intentionally
  * reuse the `success`/`danger` hues (green/red), as before.
  */
-/** Cap on rendered preview lines before collapsing the rest. */
+/** Default cap on rendered preview lines before collapsing the rest. A DEFAULT,
+ * not a constant of the format: a surface that owns a sized region (the TUI's
+ * main column) passes its own cap, so the collapse point matches the space the
+ * block will actually be drawn into. */
 export const PREVIEW_MAX_LINES = 40;
+/** Lines a replacement string contributes: "" → 0, "a\nb" and "a\nb\n" → 2. */
+function lineCount(text) {
+    if (text === "")
+        return 0;
+    const body = text.endsWith("\n") ? text.slice(0, -1) : text;
+    return body.split("\n").length;
+}
+/**
+ * Whether a replacement covers whole lines, which is what makes its count
+ * exact. An `edit_file` swap is an arbitrary substring — usually neither empty
+ * nor newline-terminated — so most edits are honestly approximate.
+ */
+function lineAligned(text) {
+    return text === "" || text.endsWith("\n");
+}
+/** One file's stat from a patch entry. */
+function patchFileStat(file) {
+    if (file.op === "delete") {
+        // Only a path is recorded, so the removed count is unknowable here.
+        return {
+            path: file.path,
+            op: "delete",
+            added: 0,
+            removed: null,
+            approximate: false,
+        };
+    }
+    if (file.op === "create") {
+        return {
+            path: file.path,
+            op: "create",
+            // The pre-capped listing plus what the cap dropped: the whole file.
+            added: file.lines.length + file.omittedLines,
+            removed: 0,
+            approximate: false,
+        };
+    }
+    let added = 0;
+    let removed = 0;
+    let approximate = false;
+    for (const hunk of file.hunks) {
+        added += lineCount(hunk.newStr);
+        removed += lineCount(hunk.oldStr);
+        if (!lineAligned(hunk.oldStr) || !lineAligned(hunk.newStr))
+            approximate = true;
+    }
+    return { path: file.path, op: "update", added, removed, approximate };
+}
+/**
+ * Per-file line counts for any preview — the structured form, so a caller can
+ * lay out a summary rather than scrape it back out of rendered text.
+ *
+ * Empty for `pr`, `rollback` and `rollback-set`: the first changes no files
+ * here, and the latter two are restores whose own renderers already lead with
+ * their blast radius.
+ */
+export function previewStats(preview) {
+    if (!preview)
+        return [];
+    if (preview.type === "patch")
+        return preview.files.map(patchFileStat);
+    if (preview.type === "edit") {
+        return [
+            {
+                path: "",
+                op: "update",
+                added: lineCount(preview.newStr),
+                removed: lineCount(preview.oldStr),
+                approximate: !lineAligned(preview.oldStr) || !lineAligned(preview.newStr),
+            },
+        ];
+    }
+    if (preview.type === "write") {
+        return [
+            {
+                path: "",
+                op: preview.exists ? "update" : "create",
+                added: preview.lines.length + preview.omittedLines,
+                // Overwriting discards the previous contents, whose length the preview
+                // does not record.
+                removed: preview.exists ? null : 0,
+                approximate: false,
+            },
+        ];
+    }
+    return [];
+}
+/** `+12/-3`, `~+1/-1`, `+8` — omitting a side the preview cannot count. */
+export function formatStat(stat, c) {
+    const parts = [];
+    if (stat.added !== null && stat.added > 0)
+        parts.push(c.success(`+${stat.added}`));
+    if (stat.removed !== null && stat.removed > 0)
+        parts.push(c.danger(`-${stat.removed}`));
+    if (parts.length === 0)
+        return "";
+    return `${stat.approximate ? "~" : ""}${parts.join("/")}`;
+}
 function diffLines(oldStr, newStr, c) {
     const removed = oldStr.split("\n").map((l) => c.danger(`- ${l}`));
     const added = newStr.split("\n").map((l) => c.success(`+ ${l}`));
@@ -22,20 +123,25 @@ function diffLines(oldStr, newStr, c) {
 function fitPath(path, c, width) {
     return fitMiddle(path, Math.max(1, width - 10), c.glyph.ellipsis);
 }
+/** `update src/x.ts  +12/-3` — the verb, the path, then the counts (P3). */
+function fileHeader(verb, file, c, width) {
+    const stat = formatStat(patchFileStat(file), c);
+    return `${verb} ${fitPath(file.path, c, width)}${stat === "" ? "" : `  ${stat}`}`;
+}
 function renderPatchFiles(files, c, width = Infinity) {
     const out = [];
     for (const file of files) {
         if (file.op === "delete") {
-            out.push(c.danger(`delete ${fitPath(file.path, c, width)}`));
+            out.push(c.danger(fileHeader("delete", file, c, width)));
         }
         else if (file.op === "create") {
-            out.push(c.success(`create ${fitPath(file.path, c, width)}`));
+            out.push(c.success(fileHeader("create", file, c, width)));
             out.push(...file.lines.map((l) => c.success(`+ ${l}`)));
             if (file.omittedLines > 0)
                 out.push(c.muted(`  ...${file.omittedLines} more lines`));
         }
         else {
-            out.push(c.warning(`update ${fitPath(file.path, c, width)}`));
+            out.push(c.warning(fileHeader("update", file, c, width)));
             for (const hunk of file.hunks)
                 out.push(...diffLines(hunk.oldStr, hunk.newStr, c));
         }
@@ -123,14 +229,25 @@ function bodyLines(body) {
 /**
  * Render any {@link ActionPreview} as an indented block: a diff for edits and
  * patches, a create/overwrite listing for writes, the publish plan for PRs.
- * Long previews collapse past {@link PREVIEW_MAX_LINES}.
+ *
+ * `maxLines` defaults to {@link PREVIEW_MAX_LINES} so existing callers are
+ * unchanged, but it is a PARAMETER because the right collapse point belongs to
+ * whatever will draw the block — the TUI passes the rows its main column
+ * actually has, so a preview no longer collapses at 40 lines in a pane that can
+ * show 12 or one that could show 80.
  */
-export function renderActionPreview(preview, c, width = Infinity) {
+export function renderActionPreview(preview, c, width = Infinity, maxLines = PREVIEW_MAX_LINES) {
     if (!preview)
         return "";
     let lines;
     if (preview.type === "edit") {
-        lines = diffLines(preview.oldStr, preview.newStr, c);
+        // A headline stat, so a one-line swap is legible without counting the
+        // diff rows — and `~` marks it as lines touched, not lines gained/lost.
+        const stat = formatStat(previewStats(preview)[0], c);
+        lines = [
+            ...(stat === "" ? [] : [c.muted(`edit  ${stat}`)]),
+            ...diffLines(preview.oldStr, preview.newStr, c),
+        ];
     }
     else if (preview.type === "patch") {
         lines = renderPatchFiles(preview.files, c, width);
@@ -145,19 +262,25 @@ export function renderActionPreview(preview, c, width = Infinity) {
         lines = renderRollbackSetPreview(preview, c);
     }
     else {
-        const header = preview.exists
+        const stat = formatStat(previewStats(preview)[0], c);
+        const label = preview.exists
             ? c.warning("OVERWRITE existing")
             : c.success("create");
+        const header = stat === "" ? label : `${label}  ${stat}`;
         const body = preview.lines.map((l) => `  ${l}`);
         if (preview.omittedLines > 0)
             body.push(c.muted(`  ...${preview.omittedLines} more lines`));
         lines = [header, ...body];
     }
-    if (lines.length > PREVIEW_MAX_LINES) {
-        const hidden = lines.length - PREVIEW_MAX_LINES;
+    // Collapse against the CALLER's budget, marker INCLUDED — a block handed a
+    // pane's height must fit that pane. With only one row to spend, the marker
+    // wins: "...60 more" is the honest answer, where a single arbitrary diff row
+    // would read as the whole change.
+    if (Number.isFinite(maxLines) && lines.length > maxLines) {
+        const kept = Math.max(0, maxLines - 1);
         lines = [
-            ...lines.slice(0, PREVIEW_MAX_LINES),
-            c.muted(`...${hidden} more`),
+            ...lines.slice(0, kept),
+            c.muted(`...${lines.length - kept} more`),
         ];
     }
     // Horizontal fit at the single choke point (U.12): every content line is
@@ -169,3 +292,66 @@ export function renderActionPreview(preview, c, width = Infinity) {
     const room = Math.max(1, width - 2);
     return lines.map((l) => `  ${fit(l, room, c.glyph.ellipsis)}`).join("\n");
 }
+/**
+ * Colour a UNIFIED diff — git's own output — for `/diff` (P6 track 4).
+ *
+ * A second diff renderer would be exactly what this module's header rules out,
+ * so it lives here beside the others and reuses their palette: add/remove take
+ * the same `success`/`danger` hues an `ActionPreview` does, so a change looks
+ * the same whether you saw it in an approval prompt or asked for it afterwards.
+ *
+ * What differs is the INPUT. Everything else here renders a structured
+ * `ActionPreview` cruxy built itself; this takes text git produced, which means
+ * the file/hunk structure arrives as line prefixes rather than as fields. So the
+ * rule is deliberately narrow — style by leading marker, change nothing else:
+ *
+ *  - `+++` / `---` before `+` / `-`, or every file header reads as a hunk;
+ *  - `` is git's own note, not a removal;
+ *  - the body is passed through verbatim. No re-wrapping, no re-indenting, no
+ *    tab expansion. A diff whose whitespace has been "tidied" is a diff you
+ *    cannot trust to show you a whitespace bug.
+ *
+ * Truncation is from the TOP of the tail, not the bottom: the marker says how
+ * many lines were dropped, and the lines kept are the FIRST ones, because a diff
+ * read from the middle is worse than a diff read from the start and stopped.
+ */
+export function renderUnifiedDiff(diff, c, opts = {}) {
+    const maxLines = opts.maxLines ?? PREVIEW_MAX_LINES;
+    const width = opts.width ?? Infinity;
+    const body = diff.replace(/\n+$/, "");
+    // `"".split("\n")` is `[""]`, not `[]` — an empty diff would otherwise render
+    // as one blank row. The caller guards this today; the renderer should not
+    // depend on that.
+    if (body === "")
+        return [];
+    const raw = body.split("\n");
+    const truncated = raw.length > maxLines;
+    // Reserve the marker's own row, so the block fits the budget it was given.
+    const kept = truncated ? raw.slice(0, Math.max(0, maxLines - 1)) : raw;
+    const styled = kept.map((line) => {
+        if (line.startsWith("diff --git") || line.startsWith("index ")) {
+            return c.strong(line);
+        }
+        // Before the +/- tests: a `+++ b/file` header is a file marker, not an
+        // addition, and colouring it green makes every header read as one.
+        if (line.startsWith("+++") || line.startsWith("---"))
+            return c.muted(line);
+        if (line.startsWith("@@"))
+            return c.accent(line);
+        // git's own note about a missing trailing newline. It starts with a
+        // backslash, but it is prose about the diff rather than part of it.
+        if (line.startsWith("\\"))
+            return c.muted(line);
+        if (line.startsWith("+"))
+            return c.success(line);
+        if (line.startsWith("-"))
+            return c.danger(line);
+        return line;
+    });
+    if (truncated) {
+        styled.push(c.muted(`...${raw.length - kept.length} more diff lines`));
+    }
+    return Number.isFinite(width)
+        ? styled.map((l) => fit(l, width, c.glyph.ellipsis))
+        : styled;
+}

package/dist/render/index.js

@@ -3,32 +3,58 @@ import { PlainRenderer } from "./plain-renderer.js";
 import { attachResize } from "./resize.js";
 import { ScreenReaderRenderer } from "./screen-reader-renderer.js";
 import { TtyRenderer } from "./tty-renderer.js";
-export { detectCapabilities, detectReducedMotion, resolveColumns, DEFAULT_COLUMNS, } from "./capabilities.js";
+// Imported from the concrete modules (not `../tui/index.js`) to keep the
+// factory's runtime graph narrow — the TUI's app loop is not pulled in here.
+import { TuiRenderer } from "../tui/renderer.js";
+import { GitStatusCache } from "../tui/git-status.js";
+import { ToolVersions } from "../tui/tool-versions.js";
+import { supportsTui } from "../tui/supports.js";
+export { detectCapabilities, detectReducedMotion, resolveColumns, resolveRows, DEFAULT_COLUMNS, DEFAULT_ROWS, } from "./capabilities.js";
 export { attachResize, processResizeSignal, } from "./resize.js";
 export { fit, fitMiddle, reflow, stripAnsi, visibleWidth, kvStack, MIN_VALUE_COLS, } from "./layout.js";
 export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, fitStatusLine, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
 export { createFrameClock, inTransition, intervalFrameTimer, spinnerGlyph, FRAME_INTERVAL_MS, TRANSITION_TICKS, } from "./motion.js";
-export { renderActionPreview, PREVIEW_MAX_LINES } from "./diff.js";
+export { renderActionPreview, renderUnifiedDiff, PREVIEW_MAX_LINES, } from "./diff.js";
+export { changedSteps, planChecklist, statusMark, stepStatusLine, } from "./plan-view.js";
+export { formatDuration, testResultLines, MAX_LISTED_FAILURES, } from "./test-view.js";
 export { createStreamHighlighter, defaultLineHighlighter, } from "./highlight.js";
 export { PlainRenderer } from "./plain-renderer.js";
 export { ScreenReaderRenderer } from "./screen-reader-renderer.js";
 export { TtyRenderer } from "./tty-renderer.js";
 /**
- * Build the renderer for the detected environment (U.11 adds the first branch):
+ * Build the renderer for the detected environment (U.11 adds the screen-reader
+ * branch; P1 adds the TUI one):
  * - `screenReader` → the linear, worded {@link ScreenReaderRenderer}, regardless
  *   of cursor support (a screen-reader TTY must not get the live region);
+ * - else TUI requested *and* supported → the full-viewport {@link TuiRenderer};
  * - else cursor-safe → the managed-live-region {@link TtyRenderer} (static, no
  *   timer, when `reducedMotion`);
  * - else → the append-only {@link PlainRenderer} (pipes, CI, `TERM=dumb`).
  * Everything downstream talks to {@link StreamRenderer} and never re-probes.
  */
-export function createRenderer(out = process.stdout, err = process.stderr, env = process.env) {
-    const caps = detectCapabilities(out, env);
+export function createRenderer(out = process.stdout, err = process.stderr, env = process.env, opts = {}) {
+    const caps = detectCapabilities(out, env, opts.stdin);
     // Wire resize reactivity onto the one caps object before any surface reads
     // its width (U.12). A no-op for non-TTY streams; the live region subscribes.
     attachResize(caps, out, env);
     if (caps.screenReader)
         return new ScreenReaderRenderer(caps, out, err);
+    if (opts.tui && supportsTui(caps)) {
+        return new TuiRenderer(caps, out, {
+            headerRight: opts.headerRight,
+            // Constructed only on the TUI branch: the cache probes nothing until the
+            // renderer asks it to, so an unused one would still be a wasted object on
+            // every piped run.
+            ...(opts.gitCwd === undefined
+                ? {}
+                : { git: new GitStatusCache(opts.gitCwd) }),
+            ...(opts.provider === undefined ? {} : { provider: opts.provider }),
+            ...(opts.model === undefined ? {} : { model: opts.model }),
+            // Constructed, not started: `ToolVersions` probes nothing until the
+            // renderer paints the panel, so this costs an object and no subprocess.
+            tools: new ToolVersions(),
+        });
+    }
     return caps.cursor
         ? new TtyRenderer(caps, out)
         : new PlainRenderer(caps, out, err);

package/dist/render/plain-renderer.js

@@ -2,6 +2,8 @@ import { resolveTheme } from "../theme/index.js";
 import { createStreamPrinter } from "../cli/stream-print.js";
 import { renderActionPreview } from "./diff.js";
 import { ELAPSED_AFTER_MS, formatElapsed } from "./state.js";
+import { changedSteps, stepStatusLine } from "./plan-view.js";
+import { testResultLines } from "./test-view.js";
 /**
  * The append-only renderer for pipes, CI, and cursor-less terminals. Emits no
  * cursor-control sequences ever, and no color unless the capabilities say so
@@ -23,6 +25,8 @@ export class PlainRenderer {
     wroteInSegment = false;
     /** In-flight tool call (serial by contract) for the end-note duration. */
     toolStart = null;
+    /** Last plan snapshot committed, so `setPlan` prints only what changed. */
+    planSteps = [];
     constructor(caps, out, err) {
         this.caps = caps;
         this.out = out;
@@ -69,11 +73,43 @@ export class PlainRenderer {
             return;
     }
     progress(state) {
-        // The committed plan trail (C.31, via PromptIO) is the record in this
-        // medium; a live [i/n] prefix would just duplicate it line by line.
+        // `setPlan`'s committed trail is the record in this medium (C.31/P3); a
+        // live [i/n] prefix would just duplicate it line by line.
         if (state !== null)
             return;
     }
+    /**
+     * Commit one line per step whose status actually changed (P3). The whole list
+     * arrives on every transition, so without the diff this would reprint the
+     * entire plan once per step.
+     *
+     * `ScreenReaderRenderer` inherits this unchanged: the line is already a
+     * committed announcement, and its glyph table renders the status marks as
+     * words (`done 2. fix the assertion`), so there is nothing to special-case.
+     */
+    setPlan(steps) {
+        if (steps === null) {
+            this.planSteps = [];
+            return;
+        }
+        for (const step of changedSteps(this.planSteps, steps)) {
+            this.err.write(stepStatusLine(step, this.theme) + "\n");
+        }
+        this.planSteps = steps.map((s) => ({ ...s }));
+    }
+    /** Committed, to `err` with the rest of the chrome. */
+    /**
+     * Ignored: a served tier is standing state, not an event. Committing a line
+     * per request would be noise on an append-only surface, and the run's tier is
+     * already reported by `cruxy usage`.
+     */
+    servedRouting() {
+        // no-op
+    }
+    testResult(report) {
+        for (const line of testResultLines(report, this.theme))
+            this.err.write(line + "\n");
+    }
     toolLifecycle(event) {
         if (event.event === "start") {
             // Silent: the end note is the single durable line per call — a start

package/dist/render/plan-view.js

@@ -0,0 +1,108 @@
+import { fit } from "./layout.js";
+/**
+ * Rendering the executing plan (P3): the shared formatter behind
+ * {@link StreamRenderer.setPlan}, so the full-viewport checklist and the
+ * append-only trail draw the same step the same way.
+ *
+ * Pure data → string[], like `render/diff.ts` and `tui/layout.ts`. Meaning is
+ * carried by the glyph (○/◐/✓/✗), never by color alone, so NO_COLOR and
+ * screen-reader mode (whose glyph table words them) lose nothing.
+ */
+/** Status glyph for a step, colored when the theme colors. */
+export function statusMark(status, t) {
+    switch (status) {
+        case "pending":
+            return t.muted(t.glyph.pending);
+        case "running":
+            return t.accent(t.glyph.running);
+        case "done":
+            return t.success(t.glyph.success);
+        case "failed":
+            return t.danger(t.glyph.failure);
+    }
+}
+/** One step as a committed trail line: `✓ 2. fix the assertion`. */
+export function stepStatusLine(step, t) {
+    return `${statusMark(step.status, t)} ${t.strong(step.id + ".")} ${step.title}`;
+}
+/**
+ * The steps whose status differs between two snapshots — what an append-only
+ * medium must commit. `setPlan` re-sends the WHOLE list on every transition, so
+ * without this a trail renderer would reprint every step on every step.
+ *
+ * A step absent from `before` (a plan that grew, or the first call) counts as
+ * changed: its status has not been reported yet.
+ */
+export function changedSteps(before, after) {
+    const previous = new Map(before.map((s) => [s.id, s.status]));
+    return after.filter((s) => previous.get(s.id) !== s.status);
+}
+/** Index of the step a reader cares about: the running one, else the last
+ * finished one, so the window follows execution rather than pinning to the top. */
+function focusIndex(steps) {
+    const running = steps.findIndex((s) => s.status === "running");
+    if (running !== -1)
+        return running;
+    const lastSettled = steps.reduce((acc, s, i) => (s.status === "done" || s.status === "failed" ? i : acc), -1);
+    return lastSettled === -1 ? 0 : lastSettled;
+}
+/**
+ * The live checklist block, at most `maxRows` rows including its header.
+ *
+ * A plan longer than the room available is WINDOWED around the active step
+ * rather than truncated to its head: during execution the interesting rows are
+ * the ones near what is running. Hidden steps are counted in an explicit
+ * `↑ N more` / `↓ N more` marker — a silently clipped checklist would read as a
+ * complete one, which is exactly the lie the collapse markers in
+ * `render/diff.ts` exist to avoid.
+ */
+export function planChecklist(steps, t, maxRows = Infinity, width = Infinity) {
+    if (steps.length === 0)
+        return [];
+    const done = steps.filter((s) => s.status === "done").length;
+    const failed = steps.filter((s) => s.status === "failed").length;
+    const header = t.strong(`plan ${done}/${steps.length}${failed > 0 ? t.danger(` · ${failed} failed`) : ""}`);
+    const finish = (lines) => Number.isFinite(width)
+        ? lines.map((l) => fit(l, width, t.glyph.ellipsis))
+        : lines;
+    const more = (n, where) => t.muted(`${t.glyph.ellipsis} ${n} more ${where}`);
+    // The header always costs one row; `room` is what is left for steps AND any
+    // elision markers. Markers are part of the budget, not an overflow of it —
+    // getting that wrong is how a "max 2 rows" checklist renders 4.
+    const room = (Number.isFinite(maxRows) ? maxRows : Infinity) - 1;
+    if (room <= 0)
+        return finish([header]);
+    if (steps.length <= room)
+        return finish([header, ...steps.map((s) => stepStatusLine(s, t))]);
+    const centered = (size) => {
+        const start = Math.min(Math.max(0, focusIndex(steps) - Math.floor(size / 2)), steps.length - size);
+        return [start, start + size];
+    };
+    const markersFor = (start, end) => (start > 0 ? 1 : 0) + (end < steps.length ? 1 : 0);
+    // Take the largest window that still leaves room for the markers it actually
+    // needs. One marker is always needed here (something is elided by
+    // definition), so only two candidate sizes exist.
+    for (const size of [room - 1, room - 2]) {
+        if (size < 1)
+            continue;
+        const [start, end] = centered(size);
+        if (size + markersFor(start, end) > room)
+            continue;
+        return finish([
+            header,
+            ...(start > 0 ? [more(start, "above")] : []),
+            ...steps.slice(start, end).map((s) => stepStatusLine(s, t)),
+            ...(end < steps.length ? [more(steps.length - end, "below")] : []),
+        ]);
+    }
+    // Too tight for any window plus its markers. Keep the step that matters and
+    // one honest count, or — with a single row left — just the count. Never a
+    // silently clipped list.
+    return finish(room >= 2
+        ? [
+            header,
+            stepStatusLine(steps[focusIndex(steps)], t),
+            more(steps.length - 1, "hidden"),
+        ]
+        : [header, t.muted(`${t.glyph.ellipsis} ${steps.length} steps`)]);
+}

package/dist/render/resize.js

@@ -1,4 +1,4 @@
-import { resolveColumns } from "./capabilities.js";
+import { resolveColumns, resolveRows } from "./capabilities.js";
 /** The real signal: Node emits `SIGWINCH` on the process when a TTY resizes. */
 export const processResizeSignal = {
     on(listener) {
@@ -24,9 +24,14 @@ export function attachResize(caps, stream = process.stdout, env = process.env, s
     let off = null;
     const onSignal = () => {
         const next = resolveColumns(stream, env);
-        if (next === caps.width)
+        const nextRows = resolveRows(stream, env);
+        // Height moves independently of width — a vertical-only drag changes rows
+        // and not columns, and a full-viewport surface must still reflow for it.
+        // So both are refreshed, and either change notifies.
+        if (next === caps.width && nextRows === caps.height)
             return;
         caps.width = next; // the single source stays current — no second copy.
+        caps.height = nextRows;
         for (const l of [...listeners])
             l(next);
     };

package/dist/render/status-view.js

@@ -0,0 +1,66 @@
+import { fit } from "./layout.js";
+import { formatTokens } from "./state.js";
+/** `key  value`, aligned on a fixed gutter so the column is scannable. */
+function row(key, value, t) {
+    return `  ${t.muted(key.padEnd(11))} ${value}`;
+}
+/** The full `/status` block as lines to print. */
+export function sessionStatusLines(status, t, width = Infinity) {
+    const lines = [t.heading("status")];
+    lines.push(row("session", `${status.sessionId.slice(0, 8)} ${t.muted(`· ${status.turns} turn${status.turns === 1 ? "" : "s"}`)}`, t));
+    // The mode leads the safety half, and carries its description rather than its
+    // name alone. The objection that removed the auto-approve config flag was that
+    // it disarmed the gate with nothing on screen saying so; a status screen
+    // reporting "mode: full-auto" and no more would repeat that in miniature.
+    lines.push(row("mode", `${t.strong(status.mode)} ${t.muted(`— ${status.modeDescription}`)}`, t));
+    const model = status.model === undefined
+        ? t.muted(`${status.provider} (no cruxy tiers)`)
+        : status.servedTier === undefined || status.servedTier === status.model
+            ? `${status.provider}/${status.servedTier ?? status.model}`
+            : `${status.provider}/${status.model} ${t.glyph.arrow} ${status.servedTier}`;
+    lines.push(row("model", model, t));
+    if (status.context) {
+        const { used, total, compactAt } = status.context;
+        lines.push(row("context", `${t.strong(`~${formatTokens(used)} / ${formatTokens(total)} budget`)} ` +
+            t.muted(`· compacts above ~${formatTokens(compactAt)}`), t));
+    }
+    // A sandbox that is ON but whose runtime we cannot name is reported as on
+    // WITHOUT a name, rather than omitted — the safety-relevant half is that it
+    // is engaged at all.
+    lines.push(row("sandbox", status.sandboxEnabled
+        ? t.warning(status.sandboxRuntime ?? "on")
+        : t.muted("off — commands run on this host"), t));
+    lines.push(row("checkpoints", status.checkpoints
+        ? t.muted("on — `cruxy rollback` can undo a run's file changes")
+        : t.warning("off — file changes are not restorable"), t));
+    if (status.jobs) {
+        const { total, running, needingApproval } = status.jobs;
+        const detail = total === 0
+            ? t.muted("none this session")
+            : `${total} · ${running} running` +
+                (needingApproval > 0
+                    ? t.warning(` · ${needingApproval} awaiting approval`)
+                    : "");
+        lines.push(row("jobs", detail, t));
+    }
+    lines.push(row("tools", t.muted(`${status.tools} available to the model`), t));
+    // Roots last: one line each, so a multi-root session shows which repo each
+    // change lands in — the fact the startup banner states once and then loses.
+    lines.push("");
+    lines.push(t.strong(status.roots.length === 1 ? "root" : "roots"));
+    for (const r of status.roots) {
+        const mark = r.primary ? t.accent(t.glyph.pointer) : " ";
+        const git = r.branch === undefined
+            ? t.muted("not a git repo")
+            : `${t.strong(r.branch)} ${r.changed === undefined
+                ? ""
+                : r.changed > 0
+                    ? t.warning(`${r.changed} changed`)
+                    : t.success("clean")}`;
+        lines.push(`${mark} ${r.name.padEnd(12)} ${git}`);
+        lines.push(`  ${t.muted(r.path)}`);
+    }
+    return Number.isFinite(width)
+        ? lines.map((l) => fit(l, width, t.glyph.ellipsis))
+        : lines;
+}