@vincemakes/kiso-tui 0.32.1 → 0.33.0

package/dist/editor.js

@@ -1107,6 +1107,37 @@ export class Editor {
                     continue;
                 }
             }
+            // DC-62 — ONE RULE, at the top of the chain: inside a paste a
+            // control byte is CONTENT OR NOTHING, never a gesture.
+            //
+            // DC-58 guarded three branches (0x07, 0x14, 0x0f) and stated the
+            // rule generally; the rule was right and the placement was not.
+            // Every other claimed control byte still ran: a pasted backspace
+            // ate the text typed BEFORE the paste, a pasted 0x15 emptied the
+            // buffer, a pasted 0x1a rewound it — and a pasted 0x03 or 0x04
+            // fired the exit callbacks, so a paste could end the session.
+            // `#insert` only COLLECTS what reaches it, so none of these ever
+            // reached the collection; they acted instead.
+            //
+            // Nothing rather than content, because that is what the chain
+            // already does with an UNCLAIMED control byte (`c < " "` discards
+            // it), and a paste should not be the one place where 0x15 becomes
+            // visible text. Three bytes are let through to branches that
+            // already know about `#pasting` and treat them as content: CR and
+            // LF become a newline, TAB stays a tab (DC-55). ESC is let
+            // through because the parser must still see `ESC[201~` to END the
+            // paste — swallow that and the editor never leaves paste mode.
+            //
+            // The three DC-58 guards are retired into this: one rule, not
+            // twelve, and the next control byte someone claims is covered
+            // without anyone remembering to guard it.
+            if (this.#pasting && c !== undefined && c !== "\x1b" && c !== "\x0d" && c !== "\x0a" && c !== "\t") {
+                const code = c.codePointAt(0);
+                if (code < 0x20 || code === 0x7f) {
+                    i += 1;
+                    continue;
+                }
+            }
             if (this.#panelInput.up()) {
                 // S5: the panel answers PARSED keys — a bare Esc, an Enter, a
                 // Tab, a character — and says how many bytes it took, or null
@@ -1172,6 +1203,19 @@ export class Editor {
                         i += seqLen; // intermediates: a report kiso did not ask for — skipped whole
                         continue;
                     }
+                    // DC-62b: inside a paste the ONLY ESC-led gesture is the paste
+                    // end. DC-62's rule passes ESC through so the parser can still
+                    // see `ESC[201~`, and everything else ESC-led rode through with
+                    // it: a pasted `ESC[3~` forward-deleted the text after the
+                    // cursor. A complete CSI that is not the paste end is skipped
+                    // WHOLE — neither content nor gesture, the same answer the C0
+                    // rule gives. The incomplete case above is untouched: a CSI
+                    // split across two feeds still parks, or a paste arriving in
+                    // pieces would lose its end.
+                    if (this.#pasting && !(m[1] === "201" && m[3] === "~")) {
+                        i += seqLen;
+                        continue;
+                    }
                     // TMUX-F1 ②: a BURST of identical arrows in ONE read is a wheel,
                     // not a hand. Apple Terminal turns wheel and trackpad scrolling
                     // into arrow keys for an alternate-screen app (tmux's client is
@@ -1211,9 +1255,74 @@ export class Editor {
                         this.#pending = tail; // incomplete OSC — wait for more
                         break;
                     }
-                    this.#oscCb?.(rest.slice(1, end.index));
+                    // DC-62b: a pasted OSC is not a terminal report. A shell's
+                    // PROMPT_COMMAND writes `ESC]0;title BEL` on every prompt, so
+                    // it is in any captured log a human might paste — and it was
+                    // reaching the ground-probe reply handler, which is DC-7's
+                    // rule inverted: kiso must not read the human's data as the
+                    // terminal's answer either. Skipped to its terminator.
+                    if (!this.#pasting)
+                        this.#oscCb?.(rest.slice(1, end.index));
                     i += 1 + end.index + end[0].length;
                 }
+                else if (this.#pasting && rest === "") {
+                    // DC-62c: a lone trailing ESC inside a paste is HELD, not
+                    // consumed — parked in `#pending` the way an incomplete CSI
+                    // parks, so the next feed resolves it.
+                    //
+                    // Measured: with the paste-end marker split immediately after
+                    // its ESC byte (the chunk ends on the bare ESC, the next
+                    // begins `[201~`), the marker was missed, `#pasting` never
+                    // cleared, and THE COMPOSER WENT DEAF — every later keystroke
+                    // collected, nothing on screen, until some intact `ESC[201~`
+                    // arrived and flushed the lot. The TMUX-F1 shape, and it
+                    // predates DC-62b: byte-identical on the editor before it.
+                    //
+                    // The hold is free HERE and nowhere else. CA-4 rules that a
+                    // bare Esc fires at once rather than waiting for a possible
+                    // CSI, because its immediacy is what a hold would spend — esc
+                    // interrupts a run. Inside a paste, after DC-62b, a bare ESC
+                    // already does nothing at all, so there is no promptness to
+                    // spend and nothing to protect. Outside a paste CA-4 is
+                    // untouched, and a gate pins that so this is not widened.
+                    //
+                    // KNOWN RESIDUAL, the mirror at the paste START: a lone
+                    // trailing ESC OUTSIDE a paste followed by `[200~body` in the
+                    // next chunk fires the bare esc, and the body arrives as
+                    // keystrokes, control bytes and all. That one cannot be fixed
+                    // without holding the ESC exactly where CA-4 says not to, so
+                    // it stays — same rarity argument, a terminal writes each
+                    // marker in one write. A real log showing it makes it a
+                    // finding of its own.
+                    this.#pending = text.slice(i);
+                    break;
+                }
+                else if (this.#pasting) {
+                    // DC-62b: inside a paste, the CSI arm above has already let
+                    // `ESC[201~` through and skipped every other complete CSI, and
+                    // the OSC arm has skipped its report. Everything ESC-led that
+                    // reaches here is a gesture the human did not make: a bare ESC
+                    // fires the escape callbacks (interrupting a running turn), a
+                    // double ESC is the redirect, and `ESC(B` — a charset reset,
+                    // in any captured terminal log — took the same road.
+                    //
+                    // ONE BYTE: the ESC is nothing and what follows is content.
+                    //
+                    // Not because the rest cannot be parsed — an ECMA-48 nF
+                    // escape is deterministic (ESC, intermediates 0x20–0x2F, one
+                    // final 0x30–0x7E), so `ESC(B` and `ESC=` COULD be consumed
+                    // whole. The reason is smaller and still enough: beside CSI
+                    // and OSC these forms are rare in pasted logs, the C0 rule
+                    // already gives the shape "nothing, not content", and the two
+                    // failure modes are not equal — `(B` left visible is
+                    // recoverable by the human, text eaten by a misread is not.
+                    //
+                    // KNOWN RESIDUAL: a pasted nF escape leaves its intermediates
+                    // and its final as text. Named here rather than implied,
+                    // because the next reader deserves the cost and not only the
+                    // choice.
+                    i += 1;
+                }
                 else if (rest.startsWith("O")) {
                     i += 3; // SS3 (function keys) — ignored
                 }
@@ -1411,6 +1520,11 @@ export class Editor {
                 if (file !== null && file !== "") {
                     // REL-0152-D16: the capsule goes in the buffer, the file
                     // goes beside it. See #attachments.
+                    //
+                    // DC-61: and it is an archive point, for the same reason
+                    // the bracketed-paste path is — this inserts a token the
+                    // human did not type, so one ctrl+z has to take it back.
+                    this.#checkpoint();
                     this.#attachSeq += 1;
                     this.#attachments.set(this.#attachSeq, file);
                     for (const ch of `[Image #${this.#attachSeq}]`)
@@ -1419,15 +1533,21 @@ export class Editor {
                 }
                 i += 1;
             }
-            else if (c === "\x0f" && !this.#pasting) {
-                // DC-58 (0.32.1): this branch and the two below take `!#pasting`,
-                // the guard tab and CR already had — inside a paste a control byte
-                // is content or nothing, never a gesture. Unguarded, a pasted BEL
-                // opened $VISUAL mid-paste and the rest of the body went to that
-                // child's stdin: DC-7's rule from the third side (a byte from a
-                // paste is data the human handed over, as a reply's byte is the
-                // terminal's). Unclaimed control bytes were discarded already;
-                // now the claimed ones fall to the same discard while pasting.
+            else if (c === "\x0f") {
+                // DC-58 (0.32.1) guarded THIS branch and the two below with
+                // `!#pasting`, the guard tab and CR already had: unguarded, a
+                // pasted BEL opened $VISUAL mid-paste and the rest of the body
+                // went to that child's stdin — DC-7's rule from the third side (a
+                // byte from a paste is data the human handed over, as a reply's
+                // byte is the terminal's).
+                //
+                // DC-62 (0.32.2) RETIRED those three guards into one rule at the
+                // top of the byte loop, because the same question asked of every
+                // other branch found the same answer: a pasted backspace ate the
+                // text typed before the paste, and a pasted 0x03 fired the exit
+                // callback. There is no per-branch guard here any more — look at
+                // the top of the loop, not at this line, for why a control byte
+                // inside a paste reaches nothing.
                 //
                 // W15: the expand key — rides the chain like a command, the
                 // editor just forwards it.
@@ -1445,7 +1565,7 @@ export class Editor {
                     cb();
                 i += 1;
             }
-            else if (c === "\x14" && !this.#pasting) {
+            else if (c === "\x14") {
                 // §2.3 — ctrl+t folds the committed thinking blocks, and
                 // folds them back. `\x14` was unbound across the tree
                 // (checked before the round), and it is the key the
@@ -1458,7 +1578,7 @@ export class Editor {
                     cb();
                 i += 1;
             }
-            else if (c === "\x07" && !this.#pasting) {
+            else if (c === "\x07") {
                 // §2.4 — ctrl+g opens $VISUAL / $EDITOR on the composer.
                 //
                 // 0x07 is BEL, which is also the terminator a terminal puts
@@ -2146,6 +2266,19 @@ export class Editor {
         if (this.#historyIdx !== null)
             this.#historyIdx = null;
         this.#queuePopMode = false;
+        // DC-61: a paste is an ARCHIVE POINT. UD-1's invariant was written
+        // around destructive gestures — no gesture may discard more than one
+        // code point without a checkpoint — and a paste discards nothing, so
+        // it never took one. The loss arrived from the other side: ctrl+z
+        // after a paste did nothing, or reached an OLDER checkpoint and threw
+        // away the paste plus everything typed since it in one press.
+        //
+        // It sits here, after the image branch has either returned or filled
+        // `run`, so both shapes are covered by one call and the
+        // nothing-happened case (an empty paste with no clipboard image)
+        // still takes no checkpoint — a phantom entry would make ctrl+z a
+        // press the human has to repeat.
+        this.#checkpoint();
         const pasted = _a.#textOf(run);
         const lines = pasted.split("\n").length;
         const small = lines < _a.#PASTE_LINES && run.length < _a.#PASTE_CHARS;

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export { Container, foldLine, foldWords, visibleWidth, SPINNER, type Component,
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, type MenuItem, } from "./editor.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, currentGround, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type PathResolver, type RecapStats, type ResumeMeta, type RenderInput, type RenderResult, type RunUsage, } from "./lines.js";
 export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";
-export { STATUS_GLYPHS, cacheHitPct, idleStatus, runningStatus, type StatusMeter } from "./status.js";
+export { STATUS_GLYPHS, cacheHitPct, decodeRate, idleStatus, runningStatus, type StatusMeter } from "./status.js";
 export { contextRows, contextUnavailableRows, type ContextLedger } from "./context-ledger.js";
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, verifyOfferView, type TrustArtifact } from "./strings.js";
 export { AT_CAP, AT_SKIP, AT_VISIBLE, atEmbed, atFilter, atPanelRows, atWindow, bandHeader, longestRun, type AtItem, type AtMatch } from "./at-picker.js";

package/dist/index.js

@@ -19,7 +19,7 @@ export { bannerLines, COLOR_OFF, COLOR_ON, currentGround, setGround, escapeTermi
 export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";
 // KC2 §5: the status rows' formatters — the CLI keeps the state and the
 // repaint, the terminal layer owns what the row says.
-export { STATUS_GLYPHS, cacheHitPct, idleStatus, runningStatus } from "./status.js";
+export { STATUS_GLYPHS, cacheHitPct, decodeRate, idleStatus, runningStatus } from "./status.js";
 // TUI2-R1 (E): /context's attribution rows — a pure function of the
 // counts the trace sidecar already records (the CLI reads, this renders).
 export { contextRows, contextUnavailableRows } from "./context-ledger.js";

package/dist/lines.js

@@ -13,7 +13,7 @@
  * the event renderers (renderEvent, the status line, the recap, the
  * session line).
  */
-import { escapeTerminal, foldResult, foldThinking, kUnit, palette } from "@vincemakes/kiso-tui-cells/render";
+import { echoText, escapeTerminal, foldResult, foldThinking, kUnit, palette } from "@vincemakes/kiso-tui-cells/render";
 import { foldTerms, widthCut } from "@vincemakes/kiso-tui-cells/components";
 import { visibleWidth } from "@vincemakes/kiso-tui-cells/width";
 export * from "@vincemakes/kiso-tui-cells/render";
@@ -60,7 +60,7 @@ export function renderEvent(ev, prevThinking = false, resolvePath = (p) => p) {
         case "tool_execution_failed":
             return { text: `${p.red}  failed: ${escapeTerminal(ev.error.slice(0, 160))}${p.reset}\n`, newline: true, prompt: false };
         case "tool_result": {
-            const content = typeof ev.content === "string" ? ev.content : ev.content.map((b) => (b.type === "text" ? b.text : "(image)")).join("");
+            const content = echoText(ev.content); // DC-60: one projection, shared with the live echo
             return {
                 // v2b: the echo truncates at 160 chars + a /last hint — the
                 // full content stays in the event stream.

package/dist/status.d.ts

@@ -36,6 +36,25 @@
  * Glyphs only, no colour: intact under NO_COLOR and on any ground.
  */
 export declare const STATUS_GLYPHS: readonly ["✧", "✦", "✶", "✸", "✺", "✸", "✦"];
+/**
+ * TPS-1 — the settled DECODE rate of one model call: its output tokens
+ * over the seconds from the call's first streamed event to its usage
+ * event. TTFT is excluded on purpose; this is the speed of the text
+ * arriving, which is what "tokens per second" means to the person
+ * watching it.
+ *
+ * The null rule, and every branch of it is the same principle: a number
+ * on this row is a MEASUREMENT or it is absent. No output count (the
+ * provider reported no usage) is not a zero. Under half a second of
+ * decoding is a sample too short to divide by. A non-positive elapsed is
+ * a clock, not a rate. And a call that decoded NOTHING has no rate to
+ * report: `0 tok/s` would read as a measured speed and it is not one — it
+ * is the absence of output, which the transcript already shows. The
+ * condition is on the RENDERED INTEGER rather than on the token count, so
+ * a slow trickle that rounds to the same `0` reaches the same absence for
+ * the same reason.
+ */
+export declare function decodeRate(outputTokens: number | null, elapsedMs: number): number | 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
@@ -46,7 +65,7 @@ export declare const STATUS_GLYPHS: readonly ["✧", "✦", "✶", "✸", "✺",
  * — 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): string;
+export declare function runningStatus(glyph: string, since: number, outTokens: number | null, ctxRatio: number, tokPerSec?: number | null): string;
 /**
  * TUI2-R1 (E) — the idle row's meter: what the session has SPENT, next
  * to what it has left.
@@ -71,12 +90,42 @@ export interface StatusMeter {
      *  (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. */
-export declare function idleStatus(tier: string, model: string, ctxRatio: number, meter?: StatusMeter): string;
+/**
+ * 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): 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

@@ -23,6 +23,7 @@
  */
 import { kUnit } from "./lines.js";
 import { TWINKLE } from "@vincemakes/kiso-tui-cells/render";
+import { displayWidth } from "@vincemakes/kiso-tui-cells/width";
 /**
  * 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
@@ -45,6 +46,32 @@ export const STATUS_GLYPHS = TWINKLE;
 function ctxLeft(ratio) {
     return Number.isFinite(ratio) ? Math.round((1 - ratio) * 100) : null;
 }
+/**
+ * TPS-1 — the settled DECODE rate of one model call: its output tokens
+ * over the seconds from the call's first streamed event to its usage
+ * event. TTFT is excluded on purpose; this is the speed of the text
+ * arriving, which is what "tokens per second" means to the person
+ * watching it.
+ *
+ * The null rule, and every branch of it is the same principle: a number
+ * on this row is a MEASUREMENT or it is absent. No output count (the
+ * provider reported no usage) is not a zero. Under half a second of
+ * decoding is a sample too short to divide by. A non-positive elapsed is
+ * a clock, not a rate. And a call that decoded NOTHING has no rate to
+ * report: `0 tok/s` would read as a measured speed and it is not one — it
+ * is the absence of output, which the transcript already shows. The
+ * condition is on the RENDERED INTEGER rather than on the token count, so
+ * a slow trickle that rounds to the same `0` reaches the same absence for
+ * the same reason.
+ */
+export function decodeRate(outputTokens, elapsedMs) {
+    if (outputTokens === null)
+        return null;
+    if (!Number.isFinite(elapsedMs) || elapsedMs < 500)
+        return null;
+    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
@@ -55,22 +82,101 @@ function ctxLeft(ratio) {
  * — 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) {
+export function runningStatus(glyph, since, outTokens, ctxRatio, tokPerSec = null) {
     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 ${seconds}s${out} · esc stop · alt+⏎ redirect · ctx left ~${ctxLeft(ctxRatio)}%`;
+    return `${glyph} working ${seconds}s${out}${rate} · esc stop · alt+⏎ redirect · ctx left ~${ctxLeft(ctxRatio)}%`;
+}
+/** 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;
+/** 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.
+ *
+ *  Budgeted in DISPLAY COLUMNS, not code points. A first version sliced
+ *  code points and a wide-character id came out at 28 columns while the
+ *  function claimed 20 — which would have put the row straight back over
+ *  its budget and handed it to invariant ①'s cut, the exact defect this
+ *  whole change exists to prevent. No such model id exists today; the
+ *  guarantee should not depend on that staying true. */
+function elideMiddle(text, max) {
+    if (displayWidth(text) <= max)
+        return text;
+    const chars = [...text];
+    const room = max - 1; // the ellipsis costs one column
+    const headBudget = Math.ceil(room / 2);
+    let head = "";
+    for (const c of chars) {
+        if (displayWidth(head + c) > headBudget)
+            break;
+        head += c;
+    }
+    let tail = "";
+    const tailBudget = room - displayWidth(head);
+    for (let i = chars.length - 1; i >= 0; i -= 1) {
+        if (displayWidth(chars[i] + tail) > tailBudget)
+            break;
+        tail = chars[i] + tail;
+    }
+    return `${head}…${tail}`;
 }
-/** 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. */
-export function idleStatus(tier, model, ctxRatio, meter) {
-    const parts = [`▸ ${tier}`, "/mode to switch", model];
-    if (meter?.cacheHitPct != null)
-        parts.push(`CH ${Math.round(meter.cacheHitPct)}%`);
-    // costUsd deliberately NOT rendered — see StatusMeter.costUsd.
-    parts.push(`ctx left ~${ctxLeft(ctxRatio)}%`);
-    return parts.join(" · ");
+/**
+ * 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 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)}%`);
+        // costUsd deliberately NOT rendered — see StatusMeter.costUsd.
+        parts.push(`ctx left ~${ctxLeft(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);
 }
 /** 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.32.1",
+	"version": "0.33.0",
 	"description": "kiso tui — 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.32.1"
+		"@vincemakes/kiso-tui-cells": "0.33.0"
 	}
 }