@vincemakes/kiso-tui 0.39.2 → 0.40.1

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

package/dist/status.js

@@ -22,6 +22,9 @@
  * widens to name the new gesture.
  */
 import { kUnit } from "./lines.js";
+import { meterGlyphs } from "./context-ledger.js";
+/** The compacting row's bar width — short: it shares a row. */
+const BAR_ON_ROW = 6;
 import { elapsedLabel } from "@vincemakes/kiso-tui-cells";
 import { TWINKLE } from "@vincemakes/kiso-tui-cells/render";
 import { displayWidth } from "@vincemakes/kiso-tui-cells/width";
@@ -85,31 +88,88 @@ export function decodeRate(outputTokens, elapsedMs) {
     const rate = Math.round(outputTokens / (elapsedMs / 1000));
     return rate > 0 ? rate : null;
 }
-/**
- * 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
- * never claims a turn took no time), the streamed output tokens once the
- * count is known, the interrupt hints, and the live ctx estimate.
- *
- * KC2 §2: the hint names BOTH gestures. Esc still stops; alt+⏎ redirects
- * — 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 function runningStatus(glyph, since, outTokens, ctxRatio, tokPerSec = null) {
+export function composeRow(head, segments, W) {
+    const present = segments.filter((x) => x != null && x.text !== "");
+    const join = (xs) => [head, ...xs.map((x) => x.text)].join(" · ");
+    const full = join(present);
+    if (W === undefined || displayWidth(full) <= W)
+        return full;
+    // 1. elide every label in its middle
+    let row = present.map((x) => (x.kind === "label" ? { ...x, text: elideMiddle(x.text, LABEL_ON_ROW) } : x));
+    if (displayWidth(join(row)) <= W)
+        return join(row);
+    // 2. drop hints from the end, one at a time
+    for (let i = row.length - 1; i >= 0; i -= 1) {
+        if (row[i].kind !== "hint")
+            continue;
+        row = [...row.slice(0, i), ...row.slice(i + 1)];
+        if (displayWidth(join(row)) <= W)
+            return join(row);
+    }
+    // 3. facts are never dropped: past this point the row is over budget,
+    //    and it is invariant ①'s to cut — which it will do to the LAST
+    //    segment, so the order of facts is the order of their importance.
+    return join(row);
+}
+/** `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 function retrySegment(r) {
+    const head = `retrying ${r.attempt}/${r.maxRetries} · ${r.code}`;
+    return r.remainingMs > 0 ? `${head} · ${Math.ceil(r.remainingMs / 1000)}s` : head;
+}
+export function runningStatus(glyph, since, outTokens, ctxRatio, tokPerSec = null, W, retry) {
     const out = outTokens !== null ? ` ↓ ${kUnit(outTokens)} tokens` : "";
-    // TPS-1: after each call SETTLES within the turn, between the tokens
-    // segment and the stop hint. The default is null and that is the honest
-    // rule spelled as a default — the recovery flow has no per-call timing
-    // state, so its row says nothing rather than guessing.
-    const rate = tokPerSec !== null ? ` · ${tokPerSec} tok/s` : "";
     const seconds = Math.max(1, Math.round((Date.now() - since) / 1000));
-    return `${glyph} working ${elapsedLabel(seconds)}${out}${rate} · esc stop · alt+⏎ redirect · ${ctxSegment(ctxRatio)}`;
+    return composeRow(`${glyph} working ${elapsedLabel(seconds)}${out}`, [
+        // ADR-0005 Amendment 2: a pending retry is a FACT and sits first — it
+        // is the one thing on the row that explains why nothing is arriving,
+        // and a retry budget of minutes with nothing on screen reads as a
+        // hung session.
+        retry != null ? { kind: "fact", text: retrySegment(retry) } : null,
+        // TPS-1: after each call SETTLES within the turn, between the tokens
+        // segment and the stop hint. The default is null and that is the
+        // honest rule spelled as a default — the recovery flow has no
+        // per-call timing state, so its row says nothing rather than guessing.
+        tokPerSec !== null ? { kind: "fact", text: `${tokPerSec} tok/s` } : null,
+        { kind: "hint", text: "esc stop" },
+        { kind: "hint", text: "alt+⏎ redirect" },
+        { kind: "fact", text: ctxSegment(ctxRatio) },
+    ], W);
+}
+/**
+ * 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 function compactingStatus(glyph, rounds, tokens, elapsedSeconds, W, retry, progress) {
+    // 0.40.0: with a budget to measure against, the covered size and the bar
+    // are ONE fact — what went in, and how much of the output budget has
+    // come out. Without a budget the row keeps the covered size alone: the
+    // bar never invents a denominator.
+    const covered = progress != null && progress.budget !== null && progress.budget > 0
+        ? `~${kUnit(tokens)} \u2192 ${meterGlyphs(progress.produced / progress.budget, BAR_ON_ROW)} ${kUnit(progress.produced)}/${kUnit(progress.budget)}`
+        : `~${kUnit(tokens)} tokens`;
+    return composeRow(`${glyph} compacting`, [
+        { kind: "fact", text: `${rounds} rounds` },
+        { kind: "fact", text: covered },
+        // why the figure jumped when the usage landed — a HINT, so a narrow
+        // row gives it up before the bar, the seconds or the retry
+        progress?.reasoningUnseen === true && progress.budget !== null ? { kind: "hint", text: "incl. unstreamed reasoning" } : null,
+        { kind: "fact", text: `${Math.max(0, elapsedSeconds)}s` },
+        // ADR-0005 Amendment 2: the summary call retries under the kernel's
+        // policy, and a retry here is the same fact it is on the running row.
+        retry != null ? { kind: "fact", text: retrySegment(retry) } : null,
+    ], W);
 }
-/** DF-0330-F1 — how far the model id may be squeezed on the ROW. Twenty
- *  visible columns keeps a head and a tail: `deepseek-v…s-on-0910` still
- *  says which binding is driving, and the tail is where the parts that
- *  distinguish one id from its neighbours live (`-flash`, `-0910`). */
-const MODEL_ON_ROW = 20;
+/** DF-0330-F1 — how far a LABEL may be squeezed on the ROW; the model id
+ *  is the one there is. Twenty visible columns keeps a head and a tail:
+ *  `deepseek-v…s-on-0910` still says which binding is driving, and the
+ *  tail is where the parts that distinguish one id from its neighbours
+ *  live (`-flash`, `-0910`). Read by `composeRow`. */
+const LABEL_ON_ROW = 20;
 /** Elide in the MIDDLE, keeping the head and the tail. A string already
  *  within budget is returned untouched, so this is a no-op for every
  *  ordinary model name.
@@ -169,27 +229,19 @@ function elideMiddle(text, max) {
  * No `W` means no dropping, which is what the callers that do not know
  * their width should get: today's row, unchanged.
  */
-export function idleStatus(tier, model, ctxRatio, meter, W) {
-    const compose = (label, hint) => {
-        const parts = [`▸ ${tier}`];
-        if (hint)
-            parts.push("/mode to switch");
-        parts.push(label);
-        if (meter?.cacheHitPct != null)
-            parts.push(`CH ${Math.round(meter.cacheHitPct)}%`);
+export function idleStatus(tier, model, ctxRatio, meter, W, floorOff = false) {
+    return composeRow(`▸ ${tier}`, [
+        // 0.40.0: the catastrophe floor is on by default and says nothing;
+        // OFF is the state worth seeing, and a fact beside the tier it
+        // changes the meaning of.
+        floorOff ? { kind: "fact", text: "floor off" } : null,
+        { kind: "hint", text: "/mode to switch" },
+        { kind: "label", text: model },
+        meter?.cacheHitPct != null ? { kind: "fact", text: `CH ${Math.round(meter.cacheHitPct)}%` } : null,
         // costUsd deliberately NOT rendered — see StatusMeter.costUsd.
-        parts.push(ctxSegment(ctxRatio));
-        if (meter?.tokPerSec != null)
-            parts.push(`${meter.tokPerSec} tok/s`); // TPS-1: last, after the ctx estimate
-        return parts.join(" · ");
-    };
-    const full = compose(model, true);
-    if (W === undefined || displayWidth(full) <= W)
-        return full;
-    const squeezed = compose(elideMiddle(model, MODEL_ON_ROW), true);
-    if (displayWidth(squeezed) <= W)
-        return squeezed;
-    return compose(elideMiddle(model, MODEL_ON_ROW), false);
+        { kind: "fact", text: ctxSegment(ctxRatio) },
+        meter?.tokPerSec != null ? { kind: "fact", text: `${meter.tokPerSec} tok/s` } : null, // TPS-1: last, after the ctx estimate
+    ], W);
 }
 /** 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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.39.2",
+	"version": "0.40.1",
 	"description": "kiso tui \u2014 the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.39.2"
+		"@vincemakes/kiso-tui-cells": "0.40.1"
 	}
 }