@vincemakes/kiso-tui 0.39.2 → 0.40.0

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.0",
 	"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.0"
 	}
 }