@vincemakes/kiso-tui 0.39.1 → 0.40.0

package/dist/pick-input.js

@@ -18,12 +18,16 @@
  * through the host.
  */
 import { AT_VISIBLE } from "./at-picker.js";
-import { sessionFilter } from "./session-picker.js";
+import { scopeSessions, sessionFilter } from "./session-picker.js";
 export class PickInput {
     host;
     #cards = null;
     #commit = null;
     #sel = 0;
+    /** 0.40.0: the running workspace (undefined = an unscoped picker), and
+     *  whether the person flipped to ALL. */
+    #here = undefined;
+    #all = false;
     constructor(host) {
         this.host = host;
     }
@@ -34,10 +38,12 @@ export class PickInput {
      *  (the buffer becomes the filter query) and `onPick` receives the
      *  chosen id — or null when the human leaves without picking, which
      *  is a first-class outcome and not an error. */
-    begin(cards, onPick) {
+    begin(cards, onPick, here) {
         this.#cards = cards;
         this.#commit = onPick;
         this.#sel = 0;
+        this.#here = here;
+        this.#all = false;
         this.host.syncMouse();
         this.host.clear();
         this.host.reflow();
@@ -51,15 +57,35 @@ export class PickInput {
     state() {
         if (this.#cards === null)
             return null;
-        const cards = this.#cards();
+        // 0.40.0: the filter runs INSIDE the scope — typing narrows what the
+        // title says is showing, never reaches past it
+        const scoped = this.#here === undefined ? null : scopeSessions(this.#cards(), this.#here, this.#all);
+        const cards = scoped === null ? this.#cards() : scoped.cards;
         const matches = sessionFilter(cards, this.host.line());
-        return { cards, matches, selected: Math.max(0, Math.min(this.#sel, matches.length - 1)) };
+        return { cards, matches, selected: Math.max(0, Math.min(this.#sel, matches.length - 1)), scope: scoped?.scope ?? null };
+    }
+    /** 0.40.0 — tab flips CURRENT ↔ ALL. The filter owns every printable
+     *  key (the buffer IS the query), so the toggle cannot be one. True when
+     *  the picker owned the key. */
+    toggleScope() {
+        const view = this.state();
+        if (view === null || view.scope === null || view.scope === undefined)
+            return false;
+        this.#all = !this.#all;
+        this.#sel = 0;
+        this.host.reflow();
+        this.host.render();
+        return true;
     }
     /** The band's height estimate: the header + the windowed rows (or
      *  the one "no match" row) + the counter. */
     rows() {
         const view = this.state();
-        return view === null ? 0 : Math.min(Math.max(view.matches.length, 1), AT_VISIBLE) + 2;
+        if (view === null)
+            return 0;
+        // 0.40.1: + the unknown-workspace row, when CURRENT shows it
+        const unknownRow = view.scope != null && !view.scope.all && view.scope.unknown > 0 ? 1 : 0;
+        return Math.min(Math.max(view.matches.length, 1), AT_VISIBLE) + 2 + unknownRow;
     }
     /** ↑↓: the selection walks the matches and stops at both ends. True
      *  when the picker owned the key (the caller renders). */
@@ -78,6 +104,8 @@ export class PickInput {
         this.#cards = null;
         this.#commit = null;
         this.#sel = 0;
+        this.#here = undefined;
+        this.#all = false;
         this.host.syncMouse();
         this.host.clear();
         this.host.reflow();

package/dist/session-picker.d.ts

@@ -2,20 +2,12 @@
  * TUI2-R2 slices ①–③ — the session picker's PURE half: the durability
  * badge, the row, the band, and the filter.
  *
- * The badge is the round's whole argument. kiso's claim is that a
- * session survives kill -9 and resumes from its durable prefix; until
- * now that claim was a sentence in a README. A badge per row makes it a
- * thing you can SEE before you pick: this one completed, this one was
- * cut mid-run and will resume exactly, this one is holding a question
- * for you.
- *
- * The vocabulary (the palette's functional set — no new colour):
- *
- *   ✓ green   the run's terminal event says completed
- *   ✗ red     the terminal says anything else
- *   ▌ bold    no terminal event — interrupted mid-run
- *   ? warn    the uncertain ledger is not empty (overrides ▌)
- *   ◌ dim     a permission request nobody has answered
+ * The row's STATE is the round's whole argument. kiso's claim is that a
+ * session survives kill -9 and resumes from its durable prefix; the note
+ * column makes it a thing you can READ before you pick: this one completed,
+ * this one was cut mid-run and will resume exactly, this one is holding a
+ * question for you. (0.40.1, owner's ruling: words, never glyphs — the
+ * ✓ ✗ ▌ ? ◌ column that stood here said nothing the words did not.)
  *
  * Purity, as everywhere in this package: the cards are DATA the CLI
  * projects (session-cards.ts) and this module turns them into bytes. It
@@ -32,21 +24,46 @@ export interface SessionCardView {
      *  a caller that has not got one still renders — the row simply
      *  carries no title, which is where this picker started. */
     readonly title?: string;
-    readonly badge: "uncertain" | "ask" | "interrupted" | "completed" | "failed";
-    readonly turns: number;
+    readonly badge: "uncertain" | "ask" | "interrupted" | "completed" | "failed" | "unknown";
+    /** null when unknown — the row then says nothing about turns */
+    readonly turns: number | null;
     readonly updatedAt: number;
     readonly uncertain: number;
     readonly asks: number;
     readonly outcome: string | null;
+    /** 0.40.0: the realpath the session STARTED in, from its profile; null
+     *  when unknown (a legacy session). Absent = the caller did not say. */
+    readonly workspace?: string | null;
+    /** 0.40.0: the config profile its latest revision names, for a dim tag. */
+    readonly profileName?: string | null;
+    /** 0.40.0: its project was inferred by the one-time migration, never
+     *  recorded — the row says so. */
+    readonly inferred?: boolean;
 }
-/** The glyph per state — one cell each, so the badge column never
- *  shifts the id column (a column that moves per row reads as damage). */
-export declare const BADGE_GLYPH: Readonly<Record<SessionCardView["badge"], string>>;
-/** The badge, styled. The colour IS the meaning here (the mono
- *  discipline's three functional exceptions), so NO_COLOR degrades to
- *  the glyph alone — which is why the glyphs are distinct shapes and
- *  not three coloured dots. */
-export declare function sessionBadge(badge: SessionCardView["badge"]): string;
+/** 0.40.0 — which sessions the picker shows. `here` is the running
+ *  workspace's realpath; `all` is the person's choice; `unknown` counts
+ *  the sessions with no recorded workspace (0.40.1), which the default view
+ *  hides behind one header row.
+ *
+ *  0.40.1 (owner's ruling): the default view NEVER falls back to all. The
+ *  fallback made every directory list every older session — 118 of them —
+ *  which is the view the scope exists to prevent. */
+export interface PickScopeState {
+    readonly here: string;
+    readonly all: boolean;
+    readonly inHere: number;
+    readonly total: number;
+    readonly unknown: number;
+}
+/** 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. */
+export declare function scopeSessions(cards: readonly SessionCardView[], here: string, wantAll: boolean): {
+    readonly cards: readonly SessionCardView[];
+    readonly scope: PickScopeState;
+};
+/** The band's title — the scope and both counts, and the key that flips it. */
+export declare function scopeTitle(scope: PickScopeState | null): string;
 /**
  * What the row SAYS about the state. The interrupted note is the
  * product's promise stated in the place the promise matters: the run
@@ -100,7 +117,7 @@ export declare function sessionFilter(cards: readonly SessionCardView[], query:
  * The inner spans close with rvEnd inside the bar (never SGR 0, which
  * would punch a hole in it) — the same composition atRow uses.
  */
-export declare function sessionRow(card: SessionCardView, selected: boolean, W: number, now: number, idCol: number): string;
+export declare function sessionRow(card: SessionCardView, selected: boolean, W: number, now: number, idCol: number, here?: string | null): string;
 /** The counter row — the SELECTION's 1-based place in the whole
  *  filtered list, which the visible window cannot tell the user. */
 export declare function sessionCounterRow(selected: number, total: number, W: number): string;
@@ -110,6 +127,8 @@ export interface SessionPickState {
     readonly cards: readonly SessionCardView[];
     readonly matches: readonly SessionCardView[];
     readonly selected: number;
+    /** 0.40.0: null when the picker was opened without a workspace. */
+    readonly scope?: PickScopeState | null;
 }
 /**
  * The whole band: the `sessions` header (R1.5 ⑦(b) — a band names
@@ -137,7 +156,16 @@ export declare function sessionPickerRows(state: SessionPickState, W: number, no
  * id goes LAST and dim — present for the hand that needs it, out of the
  * way of the eye that does not.
  */
-export declare function sessionListRow(card: SessionCardView, W: number, now: number, idCol: number): string;
+export declare function sessionListRow(card: SessionCardView, W: number, now: number, idCol: number, here?: string | null): string;
 /** Slice ③ — the listing's last line: the count, and the one thing the
  *  user can do next. */
 export declare function sessionListFooter(count: number, W: number): string;
+/** 0.40.1 — the `kiso sessions` TTY listing's line for the sessions with no
+ *  recorded workspace: counted, never listed, and the flag that lists them.
+ *  Empty when there are none. */
+export declare function sessionListUnknownLine(unknown: number, W: number): string;
+/** 0.40.0 — the `kiso sessions` TTY listing's FIRST line: which sessions
+ *  follow, and both counts. The listing never falls back the way the
+ *  picker does: a listing that says "0 of 5 from this workspace" and how
+ *  to see the rest is already the honest answer. */
+export declare function sessionListHeader(inHere: number, total: number, all: boolean, W: number): string;

package/dist/session-picker.js

@@ -2,20 +2,12 @@
  * TUI2-R2 slices ①–③ — the session picker's PURE half: the durability
  * badge, the row, the band, and the filter.
  *
- * The badge is the round's whole argument. kiso's claim is that a
- * session survives kill -9 and resumes from its durable prefix; until
- * now that claim was a sentence in a README. A badge per row makes it a
- * thing you can SEE before you pick: this one completed, this one was
- * cut mid-run and will resume exactly, this one is holding a question
- * for you.
- *
- * The vocabulary (the palette's functional set — no new colour):
- *
- *   ✓ green   the run's terminal event says completed
- *   ✗ red     the terminal says anything else
- *   ▌ bold    no terminal event — interrupted mid-run
- *   ? warn    the uncertain ledger is not empty (overrides ▌)
- *   ◌ dim     a permission request nobody has answered
+ * The row's STATE is the round's whole argument. kiso's claim is that a
+ * session survives kill -9 and resumes from its durable prefix; the note
+ * column makes it a thing you can READ before you pick: this one completed,
+ * this one was cut mid-run and will resume exactly, this one is holding a
+ * question for you. (0.40.1, owner's ruling: words, never glyphs — the
+ * ✓ ✗ ▌ ? ◌ column that stood here said nothing the words did not.)
  *
  * Purity, as everywhere in this package: the cards are DATA the CLI
  * projects (session-cards.ts) and this module turns them into bytes. It
@@ -26,31 +18,53 @@
 import { escapeTerminal, palette } from "./lines.js";
 import { selectionBar, visibleWidth, widthCut } from "./components.js";
 import { atEmbed, bandHeader, longestRun, AT_VISIBLE, atWindow } from "./at-picker.js";
-/** The glyph per state — one cell each, so the badge column never
- *  shifts the id column (a column that moves per row reads as damage). */
-export const BADGE_GLYPH = {
-    completed: "✓", // ✓
-    failed: "✗", // ✗
-    interrupted: "▌", // ▌ — the input brick: this session is mid-sentence
-    uncertain: "?",
-    ask: "◌", // ◌ — the dotted circle: a question with no answer in it yet
-};
-/** The badge, styled. The colour IS the meaning here (the mono
- *  discipline's three functional exceptions), so NO_COLOR degrades to
- *  the glyph alone — which is why the glyphs are distinct shapes and
- *  not three coloured dots. */
-export function sessionBadge(badge) {
-    const p = palette();
-    const g = BADGE_GLYPH[badge];
-    if (badge === "completed")
-        return `${p.green}${g}${p.reset}`;
-    if (badge === "failed")
-        return `${p.red}${g}${p.reset}`;
-    if (badge === "interrupted")
-        return `${p.bold}${g}${p.reset}`;
-    if (badge === "uncertain")
-        return `${p.warn}${g}${p.reset}`;
-    return `${p.dim}${g}${p.reset}`;
+/** 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. */
+export function scopeSessions(cards, here, wantAll) {
+    const inHere = cards.filter((c) => c.workspace === here);
+    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) {
+    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`;
+}
+/** A workspace path as a person reads it: the home directory as `~`. */
+function tildePath(path) {
+    const home = process.env.HOME;
+    return home !== undefined && home !== "" && (path === home || path.startsWith(`${home}/`)) ? `~${path.slice(home.length)}` : path;
+}
+/** 0.40.0 — the row's dim tags: the profile the session last ran under,
+ *  and — only when the row is from ANOTHER workspace than `here` — where
+ *  it came from. `here === null` means the listing is not scoped at all,
+ *  so no row is foreign.
+ *
+ *  Fitted to `room`, degrading by the DC-2 rule (drop or shorten a whole
+ *  part, never cut one mid-word): the full path, then `…/<last dir>`, then
+ *  the path alone without the profile, then nothing. An inferred row keeps
+ *  its "inferred" mark longest. */
+function fitTags(card, here, room) {
+    const profile = typeof card.profileName === "string" && card.profileName !== "" ? card.profileName : null;
+    const foreign = here !== null && card.workspace !== undefined && card.workspace !== here;
+    const where = !foreign ? null : card.workspace === null || card.workspace === undefined ? "workspace unknown" : tildePath(card.workspace);
+    const short = where === null || card.workspace === null || card.workspace === undefined ? where : `\u2026/${card.workspace.split("/").filter((x) => x !== "").at(-1) ?? ""}`;
+    const join = (parts) => {
+        const kept = parts.filter((x) => x !== null);
+        return kept.length === 0 ? "" : ` \u00b7 ${kept.join(" \u00b7 ")}`;
+    };
+    // 0.40.0: an inferred project is a guess, and the row never presents a
+    // guess as a record; the mark outlives the profile when room is short
+    const mark = card.inferred === true ? "inferred" : null;
+    for (const candidate of [join([profile, where, mark]), join([profile, short, mark]), join([short, mark]), join([profile, mark]), join([mark]), join([profile])]) {
+        if (candidate !== "" && visibleWidth(candidate) <= room)
+            return candidate;
+    }
+    return "";
 }
 /**
  * What the row SAYS about the state. The interrupted note is the
@@ -73,6 +87,10 @@ export function sessionNote(card) {
             return "interrupted mid-run — resumes exactly";
         case "completed":
             return "completed clean";
+        case "unknown":
+            // 0.40.0 dogfood: no summary, or a log that could not be read —
+            // said, never guessed
+            return card.outcome ?? "no summary";
         default:
             return card.outcome === null || card.outcome === "error" ? "failed" : card.outcome.replaceAll("_", " ");
     }
@@ -173,7 +191,7 @@ export function sessionFilter(cards, query) {
  *  executions"), so an actionable row keeps saying so. */
 const TITLE_MAX = 44;
 const NOTE_RESERVE = 22;
-function rowSpans(card, budget, now, idCol) {
+function rowSpans(card, budget, now, idCol, here = null) {
     const p = palette();
     let text = "";
     let w = 0;
@@ -185,12 +203,9 @@ function rowSpans(card, budget, now, idCol) {
         text += styled;
         w += cells;
     };
-    // the badge: one glyph + one space, styled as a unit (the glyph's own
-    // SGR spans make it unmeasurable by `put`'s plain/styled pair)
-    if (w + 2 <= budget) {
-        text += `${sessionBadge(card.badge)} `;
-        w += 2;
-    }
+    // 0.40.1 (owner's ruling): NO status glyph. The ✓ ✗ ▌ ? ◌ column is
+    // gone; the state is a WORD, in the note column (sessionNote), where it
+    // already said everything the glyph did.
     // R2 (owner, 2026-08-27) — the TITLE LEADS and the id is gone.
     //
     // The id was four characters of machine identity sitting in the column
@@ -212,8 +227,17 @@ function rowSpans(card, budget, now, idCol) {
         if (cut !== "")
             put(cut, `${p.bold}${cut}${p.reset}`);
     }
-    const meta = `  ${sessionAge(card.updatedAt, now)} · ${card.turns} turn${card.turns === 1 ? "" : "s"}`;
+    const meta = `  ${sessionAge(card.updatedAt, now)}${card.turns === null ? "" : ` · ${card.turns} turn${card.turns === 1 ? "" : "s"}`}`;
     put(meta, `${p.dim}${meta}${p.reset}`);
+    // 0.40.0: the tags are their OWN span, after the meta and before the
+    // note, and they give way first — a long workspace path must never take
+    // the age and the turn count down with it, nor the note's reserve.
+    // the note is what the person acts on ("needs your verdict"), so it keeps
+    // its WHOLE width — a tag that cut it would trade an action for a label
+    const noteCells = sessionNote(card) === "" ? 0 : visibleWidth(sessionNote(card)) + 3;
+    const tags = fitTags(card, here, Math.max(0, budget - w - noteCells));
+    if (tags !== "")
+        put(tags, `${p.dim}${tags}${p.reset}`);
     const note = widthCut(sessionNote(card), Math.max(0, budget - w - 3));
     if (note !== "") {
         // the ? note carries the warn tint — the row's own words are what
@@ -232,13 +256,13 @@ function rowSpans(card, budget, now, idCol) {
  * The inner spans close with rvEnd inside the bar (never SGR 0, which
  * would punch a hole in it) — the same composition atRow uses.
  */
-export function sessionRow(card, selected, W, now, idCol) {
+export function sessionRow(card, selected, W, now, idCol, here = null) {
     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);
+    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
@@ -261,17 +285,29 @@ export function sessionCounterRow(selected, total, W) {
  * channel.
  */
 export function sessionPickerRows(state, W, now) {
-    const rows = [bandHeader("sessions", W)];
+    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);
     if (state.matches.length === 0) {
         const p = palette();
-        rows.push(`${p.dim}${widthCut("  no session matches", W)}${p.reset}`);
+        // 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));
         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));
+        rows.push(sessionRow(state.matches[i], i === state.selected, W, now, col, here));
     rows.push(sessionCounterRow(state.selected, state.matches.length, W));
     return rows;
 }
@@ -292,10 +328,10 @@ export function sessionPickerRows(state, W, now) {
  * id goes LAST and dim — present for the hand that needs it, out of the
  * way of the eye that does not.
  */
-export function sessionListRow(card, W, now, idCol) {
+export function sessionListRow(card, W, now, idCol, here = null) {
     const p = palette();
     const tail = `  ${card.id}`;
-    const { text, width } = rowSpans(card, Math.max(1, W - visibleWidth(tail)), now, idCol);
+    const { text, width } = rowSpans(card, Math.max(1, W - visibleWidth(tail)), now, idCol, here);
     if (width + visibleWidth(tail) > W)
         return text; // a terminal too narrow for both keeps the words
     return `${text}${p.dim}${tail}${p.reset}`;
@@ -306,3 +342,22 @@ export function sessionListFooter(count, W) {
     const p = palette();
     return `${p.dim}${widthCut(`${count} session${count === 1 ? "" : "s"} · kiso resume picks interactively`, W)}${p.reset}`;
 }
+/** 0.40.1 — the `kiso sessions` TTY listing's line for the sessions with no
+ *  recorded workspace: counted, never listed, and the flag that lists them.
+ *  Empty when there are none. */
+export function sessionListUnknownLine(unknown, W) {
+    if (unknown === 0)
+        return "";
+    const p = palette();
+    return `${p.dim}${widthCut(`${unknown} older session${unknown === 1 ? "" : "s"} without a workspace \u00b7 --all`, W)}${p.reset}`;
+}
+/** 0.40.0 — the `kiso sessions` TTY listing's FIRST line: which sessions
+ *  follow, and both counts. The listing never falls back the way the
+ *  picker does: a listing that says "0 of 5 from this workspace" and how
+ *  to see the rest is already the honest answer. */
+export function sessionListHeader(inHere, total, all, W) {
+    const p = palette();
+    const plural = (n) => `${n} session${n === 1 ? "" : "s"}`;
+    const text = all ? `all ${plural(total)}` : `${inHere} of ${plural(total)} from this workspace \u00b7 --all lists every one`;
+    return `${p.dim}${widthCut(text, W)}${p.reset}`;
+}

package/dist/status.d.ts

@@ -21,6 +21,14 @@
  * deliberate exception: the running row's interrupt hint, which KC2 §2
  * widens to name the new gesture.
  */
+/** 0.40.0 — the compacting row's bar: output produced so far against the
+ *  summary call's output budget (text AND reasoning — see the runtime's
+ *  SummaryProgress), and whether reasoning was billed without streaming. */
+export interface CompactingProgress {
+    readonly produced: number;
+    readonly budget: number | null;
+    readonly reasoningUnseen: boolean;
+}
 /**
  * R3 (design §5.2) — the working glyph family is the TWINKLE, and the
  * CLI's 200ms spinner walks it exactly as it walked the four quadrant
@@ -55,6 +63,37 @@ export declare const STATUS_GLYPHS: readonly ["✧", "✦", "✶", "✸", "✺",
  * the same reason.
  */
 export declare function decodeRate(outputTokens: number | null, elapsedMs: number): number | null;
+/**
+ * THE ROW SEAM (0.40.0). One composer for every status row.
+ *
+ * Three rows grew their own string-building — the running row, the idle
+ * row, and the compacting row inline in dispatch — and three features of
+ * the launch build want to add to them at once (a retry state, a mode
+ * and floor indicator, a compaction progress bar). Each splicing its own
+ * segment into its own template is how a row ends up with two of its
+ * facts cut by invariant ① at 80 columns, because nobody decided what
+ * gives way first. So the decision is made HERE, once, and every row is
+ * a list of typed segments:
+ *
+ *   - `fact`  — a measurement or a state (the tier, ctx, a rate, a retry
+ *               count). NEVER dropped and never cut; a row that silently
+ *               drops a measurement is the defect DF-0330-F1 fixed;
+ *   - `hint`  — teaches a gesture (`esc stop`, `/mode to switch`). Dropped
+ *               first, from the END, because the row is not the only
+ *               place a gesture is taught;
+ *   - `label` — a name that may be ELIDED in its middle (the model id),
+ *               tried before any hint is dropped, because eliding gives
+ *               the row its budget back instead of re-allocating a deficit.
+ *
+ * The first entry is the row's HEAD and is never touched. Everything is
+ * joined with ` · `. With no `W` the row is the full composition — every
+ * caller that does not know its width gets exactly the row it had.
+ */
+export interface RowSegment {
+    readonly text: string;
+    readonly kind: "fact" | "hint" | "label";
+}
+export declare function composeRow(head: string, segments: readonly (RowSegment | null | undefined)[], W?: number): string;
 /**
  * The RUNNING row: the rotating glyph, the wall seconds since `since`
  * (never below 1 — a run that just started still reads "1s", so the row
@@ -65,7 +104,28 @@ export declare function decodeRate(outputTokens: number | null, elapsedMs: numbe
  * — stop, and do THIS instead. The row is where the gesture is taught,
  * because it is on screen exactly when the gesture is useful.
  */
-export declare function runningStatus(glyph: string, since: number, outTokens: number | null, ctxRatio: number, tokPerSec?: number | null): string;
+/** ADR-0005 Amendment 2 — a retry the kernel is waiting on, as the row
+ *  shows it. `remainingMs` is how much of the wait is left; at or below
+ *  zero the attempt is in flight and the countdown is gone. */
+export interface RetryOnRow {
+    readonly attempt: number;
+    readonly maxRetries: number;
+    readonly code: string;
+    readonly remainingMs: number;
+}
+/** `retrying 3/10 · network · 4s` — ONE fact: the attempt, the budget it
+ *  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;
+export declare function runningStatus(glyph: string, since: number, outTokens: number | null, ctxRatio: number, tokPerSec?: number | null, W?: number, retry?: RetryOnRow | null): 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.
@@ -125,7 +185,7 @@ export interface StatusMeter {
  * 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): string;
+export declare function idleStatus(tier: string, model: string, ctxRatio: number, meter?: StatusMeter, W?: number, floorOff?: boolean): 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