@vincemakes/kiso-tui 0.46.1 → 0.47.0

package/dist/session-picker.js

@@ -17,7 +17,7 @@
  */
 import { escapeTerminal, palette } from "./lines.js";
 import { selectionBar, visibleWidth, widthCut } from "./components.js";
-import { atEmbed, bandHeader, longestRun, AT_VISIBLE, atWindow } from "./at-picker.js";
+import { atEmbed, bandHeader, bandVisible, bandWindow, longestRun } from "./at-picker.js";
 /** The scope, as a pure function of the cards: CURRENT is the sessions
  *  whose recorded workspace IS the running one; a session with no recorded
  *  workspace is never "here" — unknown history is shown under ALL only. */
@@ -26,13 +26,17 @@ export function scopeSessions(cards, here, wantAll) {
     const unknown = cards.filter((c) => c.workspace === null || c.workspace === undefined).length;
     return { cards: wantAll ? cards : inHere, scope: { here, all: wantAll, inHere: inHere.length, total: cards.length, unknown } };
 }
-/** The band's title — the scope and both counts, and the key that flips it. */
-export function scopeTitle(scope) {
+/** The band's title — named after the command that opened it, then the
+ *  scope and its counts. Graphite P1 (owner, 2026-09-30): the key that
+ *  flips the scope moved to the key row, and a filter says how many of
+ *  the scope match. */
+export function scopeTitle(scope, filter = null) {
+    const match = filter === null ? null : `${filter.matches} of ${filter.of} match`;
     if (scope === null)
-        return "sessions";
-    return scope.all
-        ? `sessions \u00b7 all ${scope.total} \u00b7 tab this workspace (${scope.inHere})`
-        : `sessions \u00b7 this workspace ${scope.inHere} of ${scope.total} \u00b7 tab all`;
+        return match === null ? "resume" : `resume · ${match}`;
+    if (scope.all)
+        return `resume · every workspace · ${match ?? scope.total}`;
+    return `resume · this workspace · ${match ?? `${scope.inHere} of ${scope.total}`}`;
 }
 /** A workspace path as a person reads it: the home directory as `~`. */
 function tildePath(path) {
@@ -247,68 +251,277 @@ function rowSpans(card, budget, now, idCol, here = null) {
     }
     return { text, width: w };
 }
-/**
- * ONE picker row. The selection is a FULL-ROW reverse bar — the R1.5
- * ⑧ ruling's shape, shared with the @ picker and the user chip: a
- * two-cell marker in an eighty-column row is a selection you have to
- * hunt for.
+/*
+ * Graphite P1 — the /resume picker as a table (owner, 2026-09-30: option
+ * B, revision 2, after comparing it with the reference picker).
  *
- * The inner spans close with rvEnd inside the bar (never SGR 0, which
- * would punch a hole in it) — the same composition atRow uses.
+ * DECLARED CHANGES, each against the ruling it touches:
+ *  - The row is a TABLE: the title, then a state word, the age and the
+ *    turns in columns measured over every card in the scope (never the
+ *    filtered subset — the idColumn rule, kept), so the eye reads down a
+ *    column and nothing moves while the person types. The facts used to
+ *    trail the title and start at a different cell on every row.
+ *  - The state is a word only when it asks for attention. A finished
+ *    session says nothing; `interrupted` is blue (unfinished work, the
+ *    running card's colour), an ask or an uncertain side effect gold (it
+ *    waits for the person), a failed ending red. 0.40.1's "words, never
+ *    glyphs" stands — the quiet default is an empty cell, not a glyph.
+ *  - The row under the cursor OPENS into a second row that says the
+ *    whole note (sessionNote — one definition with `kiso sessions`), when
+ *    the session started, its profile, and its id where they fit. The
+ *    note used to be on every row; R2's "the id left the row" stands —
+ *    it is on the opened card only.
+ *  - 0.40.1's row counting the sessions with no workspace, above the
+ *    list, is folded into the key row's `tab N more elsewhere` (N counts
+ *    them with the rest). The default view still never falls back to
+ *    every workspace; under tab they are listed, marked `unknown`.
+ *  - The counter row joins the key row; the band shows eight sessions on
+ *    a terminal 30 rows or taller, five below (it showed five).
  */
-export function sessionRow(card, selected, W, now, idCol, here = null) {
+/** How many sessions the band shows: eight on a terminal 30 rows or
+ *  taller, five below (owner, 2026-09-30). */
+export function resumeVisible(height) {
+    return bandVisible(height); // Graphite P2: one window rule for every band
+}
+/** The window over the matches, with a scroll-off of one: while more lies
+ *  past an edge, the cursor stays a row inside it, so the edge row that
+ *  carries a more-mark is never the selected one. Stateless, like
+ *  bandWindow: the same (total, selected) always draws the same window. */
+export function resumeWindow(total, selected, visible) {
+    return bandWindow(total, selected, visible);
+}
+/** The row's state word — empty for the quiet default, a finished session. */
+export function sessionStateWord(card) {
+    switch (card.badge) {
+        case "interrupted":
+            return "interrupted";
+        case "ask":
+            return `${card.asks} ask${card.asks === 1 ? "" : "s"}`;
+        case "uncertain":
+            return `${card.uncertain} uncertain`;
+        case "completed":
+            return "";
+        default:
+            // failed (the outcome's own words) and unknown ("no summary")
+            return sessionNote(card);
+    }
+}
+/** The state's colour: blue for unfinished work, gold for what waits for
+ *  the person, red for a failed ending, dim for what is not known. Off a
+ *  known ground gold falls back to the warn tint and blue to none. */
+function stateTone(card) {
     const p = palette();
-    // both forms spend two cells of the width on their frame — the
-    // unselected row's indent, the bar's own leading/trailing cell — so
-    // the spans are built against the same budget either way and the
-    // selection cannot change the columns
-    const { text, width } = rowSpans(card, Math.max(0, W - 2), now, idCol, here);
-    if (!selected)
-        return `  ${text}`;
-    // R2: one bar, in one place — and with it §2.1's rule that dim never
-    // sits on the wash. The age/turns/note spans were dim INSIDE the bar,
-    // grey on grey, on the row the cursor was pointing at.
-    return selectionBar(text, width, W);
+    switch (card.badge) {
+        case "interrupted":
+            return p.blue;
+        case "ask":
+        case "uncertain":
+            return p.gold !== "" ? p.gold : p.warn;
+        case "failed":
+            return p.red;
+        case "completed":
+            return "";
+        default:
+            return p.dim;
+    }
+}
+/** Where a row is from, for the workspace column (every-workspace view
+ *  only): blank for this workspace, `unknown` for a session from before
+ *  workspaces were recorded, the last directory — or on a wide terminal
+ *  the path — for another. */
+function whereOf(card, here, wide) {
+    if (card.workspace === here)
+        return "";
+    if (card.workspace === null || card.workspace === undefined)
+        return "unknown";
+    return wide ? tildePath(card.workspace) : `…/${card.workspace.split("/").filter((x) => x !== "").at(-1) ?? ""}`;
+}
+/** A title fitted to its column: whole when it fits; otherwise cut by
+ *  CELLS (a CJK character is two) with an ellipsis — on a space when one
+ *  lies in the last two fifths, so a word is not halved needlessly. */
+function fitTitle(text, room) {
+    if (visibleWidth(text) <= room)
+        return text;
+    if (room <= 1)
+        return widthCut(text, Math.max(0, room));
+    let cut = widthCut(text, room - 1);
+    const sp = cut.lastIndexOf(" ");
+    if (sp > cut.length * 0.6)
+        cut = cut.slice(0, sp);
+    return `${cut.trimEnd()}…`;
 }
-/** The counter row — the SELECTION's 1-based place in the whole
- *  filtered list, which the visible window cannot tell the user. */
-export function sessionCounterRow(selected, total, W) {
+const TITLE_CAP = 60;
+const TITLE_FLOOR = 12;
+function resumeColumns(cards, W, now, where) {
+    const wide = W >= 110;
+    const width = (xs) => xs.reduce((m, x) => Math.max(m, visibleWidth(x)), 0);
+    const longest = Math.max(1, width(cards.map((c) => escapeTerminal(c.title ?? c.id))));
+    let parts = {
+        state: width(cards.map(sessionStateWord)),
+        where: where === null ? 0 : Math.min(wide ? 24 : 12, width(cards.map((c) => whereOf(c, where, wide)))),
+        age: width(cards.map((c) => sessionAge(c.updatedAt, now))),
+        turns: width(cards.map((c) => (c.turns === null ? "" : turnsOf(c.turns)))),
+    };
+    const avail = Math.max(0, W - 3); // the two-cell indent and one cell of right margin
+    const used = (x) => Object.values(x).reduce((s, v) => s + (v > 0 ? v + 2 : 0), 0);
+    const floor = Math.min(longest, TITLE_FLOOR);
+    for (const drop of ["turns", "where", "state", "age"]) {
+        if (floor + used(parts) <= avail)
+            break;
+        parts = { ...parts, [drop]: 0 };
+    }
+    const title = Math.max(0, Math.min(longest, TITLE_CAP, avail - used(parts)));
+    return { title, ...parts, table: 2 + title + used(parts) + 1 };
+}
+const turnsOf = (n) => `${n} turn${n === 1 ? "" : "s"}`;
+/** The title with the letters the filter matched in gold — what the
+ *  person typed, in the colour of what the person says. */
+function markMatches(title, query, base) {
+    const p = palette();
+    const hit = query === "" ? null : atEmbed(title.toLowerCase(), query.toLowerCase());
+    if (hit === null || hit.length === 0)
+        return base === "" ? title : `${base}${title}${p.reset}`;
+    const on = new Set(hit);
+    const gold = p.gold !== "" ? p.gold : p.warn;
+    let out = "";
+    let i = 0;
+    for (const ch of title) {
+        out += on.has(i) ? `${p.reset}${p.bold}${gold}${ch}${p.reset}${base}` : ch;
+        i += ch.length;
+    }
+    return `${base}${out}${p.reset}`;
+}
+/** ONE table row. Unselected it is indented two cells, or carries a dim
+ *  more-mark in column 0 (column 1 stays empty, so the mark never reads
+ *  as the title's first letter); selected it is the Graphite selection
+ *  bar with the title in bold, its text still starting in column 2. */
+function resumeRow(card, selected, cols, W, now, query, where, mark) {
+    const p = palette();
+    const title = fitTitle(escapeTerminal(card.title ?? card.id), cols.title);
+    let text = `${markMatches(title, query, selected ? p.bold : "")}${" ".repeat(cols.title - visibleWidth(title))}`;
+    if (cols.state > 0) {
+        const word = sessionStateWord(card);
+        const tone = stateTone(card);
+        text += `  ${word === "" || tone === "" ? word : `${tone}${word}${p.reset}`}${" ".repeat(cols.state - visibleWidth(word))}`;
+    }
+    if (cols.where > 0 && where !== null) {
+        const at = fitTitle(whereOf(card, where, W >= 110), cols.where);
+        text += `  ${p.dim}${at}${p.reset}${" ".repeat(cols.where - visibleWidth(at))}`;
+    }
+    if (cols.age > 0)
+        text += `  ${p.dim}${sessionAge(card.updatedAt, now).padStart(cols.age)}${p.reset}`;
+    if (cols.turns > 0)
+        text += `  ${p.dim}${(card.turns === null ? "" : turnsOf(card.turns)).padStart(cols.turns)}${p.reset}`;
+    const w = cols.table - 3;
+    if (selected)
+        return selectionBar(` ${text}`, w + 1, W);
+    return mark === null ? `  ${text}` : `${p.dim}${mark}${p.reset} ${text}`;
+}
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+/** When the session started, read from its id — the id IS the UTC stamp
+ *  it was made at (apps/cli session-id.ts) — in local time. Null for an
+ *  id that is not one. */
+export function sessionStarted(id) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})/.exec(id);
+    if (m === null)
+        return null;
+    const t = new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5]), Number(m[6])));
+    if (Number.isNaN(t.getTime()))
+        return null;
+    const two = (n) => String(n).padStart(2, "0");
+    return `${MONTHS[t.getMonth()]} ${t.getDate()} ${two(t.getHours())}:${two(t.getMinutes())}`;
+}
+/** The opened card's second row: the whole note (its state word in the
+ *  state's colour, the rest dim), then — while they fit — when it
+ *  started, its profile, where it is from (another workspace only), and
+ *  its id. On the selection bar, like the row above it. */
+function openedRow(card, W, where) {
+    const p = palette();
+    const room = Math.max(0, W - 3);
+    const note = sessionNote(card);
+    const dash = note.indexOf(" — ");
+    const head = widthCut(dash < 0 ? note : note.slice(0, dash), room);
+    const tone = stateTone(card);
+    let text = tone === "" ? head : `${tone}${head}${p.reset}`;
+    let w = visibleWidth(head);
+    const facts = [];
+    if (dash >= 0)
+        facts.push(note.slice(dash));
+    const started = sessionStarted(card.id);
+    if (started !== null)
+        facts.push(` · started ${started}`);
+    if (typeof card.profileName === "string" && card.profileName !== "")
+        facts.push(` · profile ${card.profileName}`);
+    if (where !== null && typeof card.workspace === "string" && card.workspace !== where)
+        facts.push(` · ${tildePath(card.workspace)}`);
+    if (card.title !== undefined && card.title !== card.id)
+        facts.push(` · ${card.id}`);
+    for (const f of facts) {
+        const cells = visibleWidth(escapeTerminal(f));
+        if (w + cells > room)
+            break;
+        text += `${p.dim}${escapeTerminal(f)}${p.reset}`;
+        w += cells;
+    }
+    return selectionBar(` ${text}`, w + 1, W);
+}
+/** The key row: what the keys do, then the selection's place in the whole
+ *  filtered list, aligned to the table's right edge. The keys give way
+ *  from the least needed — the scope's, then the arrows' — and enter and
+ *  esc stay while anything does. */
+function resumeKeyRow(state, W, table) {
     const p = palette();
-    return `${p.dim}${widthCut(total === 0 ? "  (0/0)" : `  (${selected + 1}/${total})`, W)}${p.reset}`;
+    const total = state.matches.length;
+    const count = total === 0 ? "0/0" : `${state.selected + 1}/${total}`;
+    const scope = state.scope ?? null;
+    const elsewhere = scope === null ? 0 : scope.total - scope.inHere;
+    const tab = scope === null ? null : scope.all ? "tab this workspace" : elsewhere > 0 ? `tab ${elsewhere} more elsewhere` : null;
+    const keys = ["↑↓ move", "⏎ resumes", tab, "esc"].filter((k) => k !== null);
+    const edge = Math.min(W, Math.max(table, visibleWidth(keys.join(" · ")) + count.length + 5));
+    const fits = (ks) => 2 + visibleWidth(ks.join(" · ")) + 2 + count.length + 1 <= edge;
+    let kept = keys;
+    for (const drop of [tab, "↑↓ move", "⏎ resumes", "esc"]) {
+        if (fits(kept))
+            break;
+        kept = kept.filter((k) => k !== drop);
+    }
+    const text = kept.join(" · ");
+    const gap = Math.max(1, edge - 1 - 2 - visibleWidth(text) - count.length);
+    return `${p.dim}${widthCut(`  ${text}${" ".repeat(gap)}${count}`, W)}${p.reset}`;
 }
+/** What the empty input says while the picker is up: typing there filters. */
+export const RESUME_FILTER_HINT = "filter by title or id";
 /**
- * The whole band: the `sessions` header (R1.5 ⑦(b) — a band names
- * itself or it reads as more scrollback), at most AT_VISIBLE windowed
- * rows, then the counter. Returned as plain strings for the menu-rows
- * channel, which already accounts them in chromeRows — the picker needs
- * no geometry of its own, which is the entire reason it rides that
- * channel.
+ * The whole band: the named hairline, the windowed table with the
+ * selected row opened, and the key row. Returned as plain strings for the
+ * menu-rows channel, which already accounts them in chromeRows — the
+ * picker needs no geometry of its own, which is the entire reason it
+ * rides that channel. `height` is the terminal's: it sets how many
+ * sessions show (resumeVisible).
  */
-export function sessionPickerRows(state, W, now) {
+export function sessionPickerRows(state, W, now, height = 24) {
+    const p = palette();
     const scope = state.scope ?? null;
-    const rows = [bandHeader(scopeTitle(scope), W)];
-    // 0.40.1: the sessions without a workspace, as ONE row under CURRENT —
-    // counted, never listed (tab shows them, labelled)
-    if (scope !== null && !scope.all && scope.unknown > 0) {
-        const p = palette();
-        rows.push(`${p.dim}${widthCut(`  ${scope.unknown} older session${scope.unknown === 1 ? "" : "s"} without a workspace \u00b7 tab all`, W)}${p.reset}`);
-    }
-    // a row is tagged with its workspace only when ALL is showing — under
-    // CURRENT every row is from here, and saying so eight times is noise
-    const here = scope !== null && scope.all ? scope.here : null;
-    const col = idColumn(state.cards);
+    const query = state.query ?? "";
+    const rows = [bandHeader(scopeTitle(scope, query === "" ? null : { matches: state.matches.length, of: state.cards.length }), W)];
+    // the workspace column shows only when every workspace is listed
+    const where = scope !== null && scope.all ? scope.here : null;
+    const cols = resumeColumns(state.cards, W, now, where);
     if (state.matches.length === 0) {
-        const p = palette();
-        // an empty CURRENT view says why, rather than an empty band
-        const empty = scope !== null && !scope.all && scope.inHere === 0 ? "  no session from this workspace yet" : "  no session matches";
-        rows.push(`${p.dim}${widthCut(empty, W)}${p.reset}`);
-        rows.push(sessionCounterRow(0, 0, W));
+        // an empty view says why, rather than an empty band
+        const empty = query !== "" ? `nothing matches “${escapeTerminal(query)}”` : scope !== null && !scope.all && scope.inHere === 0 ? "no session from this workspace yet" : "nothing to resume yet";
+        rows.push(`${p.dim}${widthCut(`  ${empty}`, W)}${p.reset}`);
+        rows.push(resumeKeyRow(state, W, cols.table));
         return rows;
     }
-    const { first, count } = atWindow(state.matches.length, state.selected, AT_VISIBLE);
-    for (let i = first; i < first + count; i += 1)
-        rows.push(sessionRow(state.matches[i], i === state.selected, W, now, col, here));
-    rows.push(sessionCounterRow(state.selected, state.matches.length, W));
+    const { first, count } = resumeWindow(state.matches.length, state.selected, resumeVisible(height));
+    for (let i = first; i < first + count; i += 1) {
+        const mark = i === first && first > 0 ? "↑" : i === first + count - 1 && first + count < state.matches.length ? "↓" : null;
+        rows.push(resumeRow(state.matches[i], i === state.selected, cols, W, now, query, where, mark));
+        if (i === state.selected)
+            rows.push(openedRow(state.matches[i], W, where));
+    }
+    rows.push(resumeKeyRow(state, W, cols.table));
     return rows;
 }
 /**

package/dist/status.d.ts

@@ -117,86 +117,17 @@ export interface RetryOnRow {
  *  counts against, what failed, and how long until it is tried. Whole
  *  seconds, rounded UP, so the row never says 0s while still waiting. */
 export declare function retrySegment(r: RetryOnRow): string;
-/** ADR-0058 (3e): the session's tasks, as the status rows count them. */
+/** ADR-0058 (3e, Amendment 8): the tasks kiso manages, as the status rows
+ *  count them. */
 export interface TaskCountsOnRow {
     /** running or starting */
     readonly running: number;
-    /** an outcome that cannot be known, not yet looked at in `/tasks` */
-    readonly unknown: number;
 }
-/** `● 2 tasks running · ◌ 1 unknown`, `◌ 1 task unknown` — or nothing.
- *  An unknown task is never hidden behind the panel: it is the one that
- *  needs the person most. */
+/** `● 2 tasks running` — or nothing. A task kiso lost track of is not a
+ *  second count here: it is an event, said once in the transcript
+ *  (Amendment 8). */
 export declare function tasksSegment(c: TaskCountsOnRow | undefined): string;
-export declare function runningStatus(glyph: string, since: number, outTokens: number | null, ctxRatio: number, tokPerSec?: number | null, W?: number, retry?: RetryOnRow | null, tasks?: TaskCountsOnRow, detachable?: boolean): string;
-/**
- * The COMPACTING row (W18): the covered rounds, the pre-call token
- * estimate, and the elapsed seconds — all knowable before the one summary
- * call returns, which has no fraction of its own. Moved here from an
- * inline template in dispatch (0.40.0) so it composes like every other
- * row and has a place for what the launch build adds to it.
- */
-export declare function compactingStatus(glyph: string, rounds: number, tokens: number, elapsedSeconds: number, W?: number, retry?: RetryOnRow | null, progress?: CompactingProgress | null): string;
-/**
- * TUI2-R1 (E) — the idle row's meter: what the session has SPENT, next
- * to what it has left.
- *
- * Both fields are optional and both are omitted when unknown, because
- * the row's job is to be true rather than complete:
- *
- *   - `cacheHitPct` is cacheRead / (fresh + cacheRead) — the E2
- *     denominator (the pinned sentence: it cannot exceed 100%). A
- *     session with no usage yet has no cache hit rate, and an
- *     unmeasured cache is NOT a 0% cache, so it renders nothing.
- *   - `costUsd` is the CANONICAL cost, which is null whenever the
- *     pricing table has no rate for the route. Null renders nothing.
- *     No rate table, no number — kiso does not invent a price.
- */
-export interface StatusMeter {
-    readonly cacheHitPct: number | null;
-    /** RETIRED from the row (the owner's 2026-08-23 directive): live
-     *  prices fluctuate and the canonical table is "an approximation,
-     *  not a bill" — a four-decimal figure on the status bar claimed a
-     *  precision the data never had. The canonical cost STAYS recorded
-     *  (trace ledger, /context); the field is kept so callers need not
-     *  change shape, and it renders NOTHING. */
-    readonly costUsd: number | null;
-    /** TPS-1 — the decode rate of the LAST settled call, carried into the
-     *  idle row so the figure a person watched during the turn is still
-     *  there when the turn ends. Null renders nothing (see `decodeRate`);
-     *  a new model binding starts with none, exactly as the cache figure
-     *  does (DF-0311-F1: an unmeasured binding has no measurement). */
-    readonly tokPerSec: number | null;
-}
-/**
- * The IDLE row: the approval tier as the CALLER names it, the /mode hint,
- * the model driving the session, the TUI2-R1 meter when there is one, and
- * the ctx estimate. Called without a meter — or with one that knows
- * nothing — the row is byte-identical to the pre-round row.
- *
- * DF-0330-F1 — THE DROP ORDER. `W` is the row's budget; given one, the row
- * gives ground in a fixed order rather than letting invariant ① cut its
- * end off. Found the hard way: at 100 columns the ` · N tok/s` segment
- * never appeared and at 140 it did, because the row was 102 columns wide
- * and the segment TPS-1 added sat last.
- *
- *   1. the MODEL ID is elided in its middle. It is the only segment that
- *      varies, it is the one that grew (the owner's is 35 columns of a
- *      90-column row), and eliding it gives the row back a budget instead
- *      of re-allocating a deficit;
- *   2. `/mode to switch` is dropped. It teaches a gesture; `/mode` and `?`
- *      still exist and the row is not the only place they are taught;
- *   3. the FACTS are never dropped and never cut — the tier, CH, the ctx
- *      estimate and the rate. A row that silently drops a measurement is
- *      the defect this rule exists to prevent.
- *
- * The elision is ON THE ROW only. `/model`, the session log and the trace
- * ledger all keep the id whole — the row is a view, never the record.
- *
- * No `W` means no dropping, which is what the callers that do not know
- * their width should get: today's row, unchanged.
- */
-export declare function idleStatus(tier: string, model: string, ctxRatio: number, meter?: StatusMeter, W?: number, floorOff?: boolean, tasks?: TaskCountsOnRow): string;
+export declare function compactingStatus(glyph: string, rounds: number, tokens: number, elapsedSeconds: number, W?: number, retry?: RetryOnRow | null, progress?: CompactingProgress | null, why?: string): string;
 /** TUI2-R1 (E) — the cache hit rate the status row shows, from the usage
  *  the CLI already tracks. The denominator is the TOTAL the model was
  *  given (fresh + cacheRead), which is the E2 ruling's own: cacheRead
@@ -206,3 +137,75 @@ export declare function cacheHitPct(usage: {
     in: number | null;
     cache: number | null;
 }): number | null;
+/**
+ * Graphite §8.9 — what the status bar says: the session and its health.
+ * The CLI keeps the state and hands this over; the compositor composes the
+ * row at paint time, because the drop order (§8.5) runs across both sides
+ * of the row and only the paint knows the width and the `ctrl+o` state.
+ */
+export interface BarInput {
+    /** The mode as the chip says it: `default`, `plan · read-only`, … */
+    readonly mode: string;
+    /** Full access (the old bypass) wears the failure colour (§8.9). */
+    readonly modeAlert?: boolean;
+    /** The main-sync round (owner, 2026-09-30): the don't-ask switch is on —
+     *  a second chip, gold (the person's standing choice), beside the tier's. */
+    readonly dontAsk?: boolean;
+    readonly floorOff: boolean;
+    readonly model: string;
+    /** The share of the window USED (0..1), and the compaction tiers as
+     *  shares of the same window; null when the window is not known. */
+    readonly ctx: {
+        readonly used: number;
+        readonly soft: number;
+        readonly hard: number;
+    } | null;
+    readonly tokPerSec: number | null;
+    /** The main-sync round (ADR-0058 3e): the session's tasks — running, and
+     *  unknown not yet looked at in `/tasks`. Absent or all zero, nothing. */
+    readonly tasks?: TaskCountsOnRow;
+    readonly branch: string | null;
+    readonly folder: string | null;
+}
+/** The ctx meter's width in cells (§8.9). */
+/**
+ * §8.9 — the ctx meter: ten `▆` cells with the used share filled, then the
+ * percentage used. Filled cells take `ink2` below the soft compaction tier,
+ * gold from the soft tier to the hard one, the failure colour past the hard
+ * tier; the empty cells are `track`. There is no marker inside the bar —
+ * the tier shows as colour only (owner, 2026-09-28). Off a known ground
+ * the colours carry nothing, so the meter is the percentage alone (§1.2:
+ * the fact survives without the colour). `ctx ?` when the window is not
+ * known.
+ */
+export declare function ctxMeter(ctx: BarInput["ctx"]): string;
+/**
+ * §8.9 — the status bar, composed for `W` cells. Left: the mode chip,
+ * `floor off`, `/mode to switch`, the model and its effort, the ctx meter,
+ * the decode rate. The cache share is the seal's (owner, 2026-09-29: every
+ * run's closing row already says it), not the bar's. Right: the branch, the folder, and the
+ * `ctrl+o` switch while a card has rows behind the key.
+ *
+ * §8.5 — what gives way, in order: the `ctrl+o` hint, the folder (the
+ * terminal title names it too), the branch, the model's middle, and last
+ * `/mode to switch` — the one place a newcomer meets modes. The facts
+ * never drop; past that the row is invariant ①'s to cut.
+ *
+ * On a known ground the chip is a surface and the segments are spaced; off
+ * one the head is today's `▸ <mode>` and the segments are joined with ` · `
+ * — the same facts, in words that survive without colour.
+ */
+export declare function statusBar(b: BarInput, W: number, expand: "expand all" | "collapse all" | null): string;
+/**
+ * §8.7 — the LIVE ROW's words for a running turn: `working` for the whole
+ * turn, whatever the model is doing (it never switches to "thinking" —
+ * what the model thinks is in the stream), the elapsed, the output tokens,
+ * the decode rate. A pending retry replaces it. The keys ride the row's
+ * right end.
+ */
+export declare function workingRow(glyph: string, since: number, outTokens: number | null, tokPerSec: number | null, W: number, retry?: RetryOnRow | null, detachable?: boolean): string;
+/** §8.7 — a live row: its mark in the mark column (column 0), its facts
+ *  from the content edge, its keys right-aligned; the keys give way from
+ *  the right when the row is short, the facts never (past them the row is
+ *  cut). */
+export declare function liveRow(facts: string, keys: readonly string[], W: number): string;