@vincemakes/kiso-tui 0.46.1 → 0.47.0

package/dist/status.js

@@ -22,12 +22,12 @@
  * widens to name the new gesture.
  */
 import { kUnit } from "./lines.js";
-import { meterGlyphs } from "./context-ledger.js";
+import { meterCells, 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";
+import { TWINKLE, cutLine, palette } from "@vincemakes/kiso-tui-cells/render";
+import { displayWidth, visibleWidth } 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
@@ -43,25 +43,6 @@ import { displayWidth } from "@vincemakes/kiso-tui-cells/width";
  * Glyphs only, no colour: intact under NO_COLOR and on any ground.
  */
 export const STATUS_GLYPHS = TWINKLE;
-/**
- * The ~ctx estimate as the whole-percent LEFT, or `ctx ?` when there is no
- * window to divide by.
- *
- * A percentage needs a denominator. When the model's context window is not
- * KNOWN — the registry records null for it, nobody set one in the profile,
- * no env — there is no denominator, and this row's rule is the same as
- * every other number on it: a measurement, or nothing. It used to print
- * `ctx left ~null%`, which at least did not invent a figure; `ctx ?` says
- * the same thing to a reader.
- *
- * The failure this replaces is worse than either: the window fell back to
- * a hardcoded 200,000 and the row printed a confident `ctx left ~82%`
- * against a number nobody had measured. A reader had no way to tell that
- * percentage from one computed against a real window.
- */
-function ctxSegment(ratio) {
-    return Number.isFinite(ratio) ? `ctx left ~${Math.round((1 - ratio) * 100)}%` : "ctx ?";
-}
 /**
  * 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
@@ -91,19 +72,22 @@ export function decodeRate(outputTokens, elapsedMs) {
 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(" · ");
+    // the compaction round: a fact may carry colour (the progress cells), and
+    // its codes take no cells — measured without them, a plain row as before
+    const width = (t) => displayWidth(t.replace(/\x1b\[[0-9;]*m/g, ""));
     const full = join(present);
-    if (W === undefined || displayWidth(full) <= W)
+    if (W === undefined || width(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)
+    if (width(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)
+        if (width(join(row)) <= W)
             return join(row);
     }
     // 3. facts are never dropped: past this point the row is over budget,
@@ -118,44 +102,13 @@ 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;
 }
-/** `● 2 tasks running · ◌ 1 unknown`, `◌ 1 task unknown` — or nothing.
- *  An unknown task is never hidden behind the panel: it is the one that
- *  needs the person most. */
+/** `● 2 tasks running` — or nothing. A task kiso lost track of is not a
+ *  second count here: it is an event, said once in the transcript
+ *  (Amendment 8). */
 export function tasksSegment(c) {
-    if (c === undefined)
+    if (c === undefined || c.running <= 0)
         return "";
-    const n = (k, word) => `${k} ${word}${k === 1 ? "" : "s"}`;
-    if (c.running > 0 && c.unknown > 0)
-        return `● ${n(c.running, "task")} running · ◌ ${c.unknown} unknown`;
-    if (c.running > 0)
-        return `● ${n(c.running, "task")} running`;
-    if (c.unknown > 0)
-        return `◌ ${n(c.unknown, "task")} unknown`;
-    return "";
-}
-export function runningStatus(glyph, since, outTokens, ctxRatio, tokPerSec = null, W, retry, 
-// 3e: the session's tasks, and whether a running command can be moved
-// to the background now (the row teaches ctrl+b exactly then)
-tasks, detachable = false) {
-    const out = outTokens !== null ? ` ↓ ${kUnit(outTokens)} tokens` : "";
-    const seconds = Math.max(1, Math.round((Date.now() - since) / 1000));
-    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: "fact", text: tasksSegment(tasks) },
-        { kind: "hint", text: "esc stop" },
-        detachable ? { kind: "hint", text: "ctrl+b background" } : null,
-        { kind: "hint", text: "alt+⏎ redirect" },
-        { kind: "fact", text: ctxSegment(ctxRatio) },
-    ], W);
+    return `● ${c.running} task${c.running === 1 ? "" : "s"} running`;
 }
 /**
  * The COMPACTING row (W18): the covered rounds, the pre-call token
@@ -164,16 +117,32 @@ tasks, detachable = false) {
  * 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) {
+/** The compaction round (owner, 2026-10-06) — the summary's progress in
+ *  the bar's own cells (§8.9's ctx meter, `meterCells`): `▆` filled in
+ *  `ink2`, the rest in the track colour. `▰▱` drew tiny in Menlo and
+ *  retired from the bar; off a known ground there are no colours to tell
+ *  filled from empty, so the glyphs carry it there. */
+function progressCells(ratio, cells) {
+    const p = palette();
+    if (p.track === "")
+        return meterGlyphs(ratio, cells);
+    const filled = Math.max(0, Math.min(cells, Math.round((Number.isFinite(ratio) ? ratio : 0) * cells)));
+    return `${p.ink2}${"\u2586".repeat(filled)}${p.track}${"\u2586".repeat(cells - filled)}${p.fgEnd}`;
+}
+export function compactingStatus(glyph, rounds, tokens, elapsedSeconds, W, retry, progress, why) {
     // 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)} \u2192 ${progressCells(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` },
+        // Graphite §8.7 (R3b, G7): why it is compacting — `manual` for
+        // /compact, `auto` past the configured threshold — first, a fact
+        why !== undefined && why !== "" ? { kind: "fact", text: why } : null,
+        // the compaction round: one round is a round
+        { kind: "fact", text: `${rounds} round${rounds === 1 ? "" : "s"}` },
         { 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
@@ -221,50 +190,6 @@ function elideMiddle(text, max) {
     }
     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.
- *
- * 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, floorOff = false, tasks) {
-    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,
-        // 3e: work still going on (or gone unknown) after the turn ended
-        { kind: "fact", text: tasksSegment(tasks) },
-        { 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.
-        { 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
  *  given (fresh + cacheRead), which is the E2 ruling's own: cacheRead
@@ -278,3 +203,152 @@ export function cacheHitPct(usage) {
     const total = fresh + cached;
     return total > 0 ? (cached / total) * 100 : null;
 }
+/** The ctx meter's width in cells (§8.9). */
+/**
+ * §8.9 — the ctx meter: ten `▆` cells with the used share filled, then the
+ * percentage used. Filled cells take `ink2` below the soft compaction tier,
+ * gold from the soft tier to the hard one, the failure colour past the hard
+ * tier; the empty cells are `track`. There is no marker inside the bar —
+ * the tier shows as colour only (owner, 2026-09-28). Off a known ground
+ * the colours carry nothing, so the meter is the percentage alone (§1.2:
+ * the fact survives without the colour). `ctx ?` when the window is not
+ * known.
+ */
+export function ctxMeter(ctx) {
+    if (ctx === null || !Number.isFinite(ctx.used))
+        return "ctx ?";
+    const used = Math.max(0, ctx.used);
+    const pct = `${Math.round(used * 100)}%`;
+    const p = palette();
+    if (p.track === "")
+        return `ctx ${pct}`;
+    // the cells follow the percentage SHOWN: `ctx 0%` is an empty meter,
+    // and from 1% at least one cell is filled (owner, 2026-09-29 — a lit
+    // cell beside `0%` read as a contradiction); one rule with /context's
+    return `${p.dim}ctx${p.reset} ${meterCells(used, ctx.soft, ctx.hard)} ${p.dim}${pct}${p.reset}`;
+}
+/**
+ * §8.9 — the status bar, composed for `W` cells. Left: the mode chip,
+ * `floor off`, `/mode to switch`, the model and its effort, the ctx meter,
+ * the decode rate. The cache share is the seal's (owner, 2026-09-29: every
+ * run's closing row already says it), not the bar's. Right: the branch, the folder, and the
+ * `ctrl+o` switch while a card has rows behind the key.
+ *
+ * §8.5 — what gives way, in order: the `ctrl+o` hint, the folder (the
+ * terminal title names it too), the branch, the model's middle, and last
+ * `/mode to switch` — the one place a newcomer meets modes. The facts
+ * never drop; past that the row is invariant ①'s to cut.
+ *
+ * On a known ground the chip is a surface and the segments are spaced; off
+ * one the head is today's `▸ <mode>` and the segments are joined with ` · `
+ * — the same facts, in words that survive without colour.
+ */
+export function statusBar(b, W, expand) {
+    const p = palette();
+    const painted = p.washDone !== "";
+    const sep = painted ? "  " : " · ";
+    const tierChip = painted ? `${b.modeAlert === true ? p.fail : ""}${p.washDone} ${b.mode} ${p.washEnd}${b.modeAlert === true ? p.fgEnd : ""}` : `▸ ${b.mode}`;
+    // the switch is not a tier, so it is not in the tier's chip: a chip of its
+    // own, never dropped — it changes what kiso does as much as the tier does
+    const chip = b.dontAsk !== true ? tierChip : painted ? `${tierChip}  ${p.gold}${p.washDone} don't ask ${p.washEnd}${p.fgEnd}` : `${tierChip} · don't ask`;
+    const fail = (s) => (painted ? `${p.fail}${s}${p.fgEnd}` : s);
+    const dim = (s) => `${p.dim}${s}${p.reset}`;
+    // the bar's words are quiet (§1.2: grey chrome); off a known ground each
+    // side is ONE dim span — the shape the status row always had
+    const quiet = (s) => (painted ? dim(s) : s);
+    // drop: 0 = never; otherwise the order it gives way in (1 first)
+    const left = [
+        b.floorOff ? { text: fail("floor off"), drop: 0 } : null,
+        // the main-sync round (ADR-0058 3e, §8.9): the session's tasks, right
+        // after the mode as 0.46.0's status row has them (owner, 2026-10-06): a
+        // FACT, which never gives way — `●` in the machine's blue (running), `◌`
+        // in gold (an outcome nobody can know is the one that needs the
+        // person, §4); the words quiet like the rest of the bar
+        tasksSegment(b.tasks) === "" ? null : { text: painted ? tasksOnBar(b.tasks) : tasksSegment(b.tasks), drop: 0 },
+        { text: quiet("/mode to switch"), drop: 4 },
+        { text: b.model, drop: 0 },
+        { text: ctxMeter(b.ctx), drop: 0 },
+        b.tokPerSec !== null ? { text: quiet(`${b.tokPerSec} tok/s`), drop: 0 } : null,
+    ];
+    const right = [
+        b.branch !== null ? { text: painted ? `${p.blue}${b.branch}${p.fgEnd}` : b.branch, drop: 3 } : null,
+        b.folder !== null ? { text: quiet(b.folder), drop: 2 } : null,
+        expand !== null ? { text: quiet(`ctrl+o ${expand}`), drop: 1 } : null,
+    ];
+    let model = b.model;
+    const compose = (dropped) => {
+        const l = left.filter((x) => x !== null && (x.drop === 0 || x.drop > dropped)).map((x) => (x.text === b.model ? quiet(model) : x.text));
+        const r = right.filter((x) => x !== null && (x.drop === 0 || x.drop > dropped)).map((x) => x.text);
+        const lt = painted ? [chip, ...l].join(sep) : dim([chip, ...l].join(sep));
+        if (r.length === 0)
+            return lt;
+        const rt = painted ? r.join("  ") : dim(r.join("  "));
+        const gap = W - visibleWidth(lt) - visibleWidth(rt);
+        return gap >= 2 ? `${lt}${" ".repeat(gap)}${rt}` : `${lt}  ${rt}`;
+    };
+    const fits = (row) => visibleWidth(row) <= W;
+    let row = "";
+    for (const level of [0, 1, 2, 3]) {
+        row = compose(level);
+        if (fits(row))
+            return row;
+    }
+    // the model's middle gives way before `/mode to switch` does (DF-0330-F1)
+    model = elideMiddle(b.model, LABEL_ON_ROW);
+    for (const level of [3, 4]) {
+        row = compose(level);
+        if (fits(row))
+            return row;
+    }
+    return cutLine(row, W);
+}
+/** The bar's task segment, painted: the mark coloured, the words dim.
+ *  The main sync (0.46.2, Amendment 8): the gold `◌ N unknown` beside it
+ *  retired — a task kiso lost track of is said once in the transcript, a
+ *  TASK row, not counted on the bar ("running" beside "may be running"
+ *  read as a contradiction to the owner). */
+function tasksOnBar(c) {
+    const p = palette();
+    return c.running > 0 ? `${p.blue}\u25cf${p.fgEnd} ${p.dim}${c.running} task${c.running === 1 ? "" : "s"} running${p.reset}` : "";
+}
+/**
+ * §8.7 — the LIVE ROW's words for a running turn: `working` for the whole
+ * turn, whatever the model is doing (it never switches to "thinking" —
+ * what the model thinks is in the stream), the elapsed, the output tokens,
+ * the decode rate. A pending retry replaces it. The keys ride the row's
+ * right end.
+ */
+export function workingRow(glyph, since, outTokens, tokPerSec, W, retry, detachable = false) {
+    // a pending retry REPLACES `working` while it lasts (§8.7): it is the one
+    // thing that explains why nothing is arriving (ADR-0005 Amendment 2),
+    // and its countdown is the row's pulse — whole seconds, rounded up, so
+    // it never says 0s while still waiting
+    if (retry != null) {
+        const wait = retry.remainingMs > 0 ? ` · next try in ${Math.ceil(retry.remainingMs / 1000)}s` : "";
+        return liveRow(`↻ retrying ${retry.attempt}/${retry.maxRetries} · ${retry.code}${wait}`, ["esc gives up"], W);
+    }
+    const out = outTokens !== null ? ` · ↓ ${kUnit(outTokens)}` : "";
+    const seconds = Math.max(1, Math.round((Date.now() - since) / 1000));
+    const facts = [`${glyph} working ${elapsedLabel(seconds)}${out}`, ...(tokPerSec !== null ? [`${tokPerSec} tok/s`] : [])].join(" · ");
+    // the main-sync round (ADR-0058 3e): ctrl+b exactly while a running
+    // command can be moved to the background — it gives way after esc
+    if (detachable)
+        return liveRow(facts, ["esc stop \u00b7 ctrl+b background \u00b7 \u23ce steer \u00b7 alt+\u23ce redirect", "esc stop \u00b7 ctrl+b background \u00b7 \u23ce steer", "esc stop \u00b7 ctrl+b background", "esc stop"], W);
+    return liveRow(facts, ["esc stop · ⏎ steer · alt+⏎ redirect", "esc stop · ⏎ steer", "esc stop"], W);
+}
+/** §8.7 — a live row: its mark in the mark column (column 0), its facts
+ *  from the content edge, its keys right-aligned; the keys give way from
+ *  the right when the row is short, the facts never (past them the row is
+ *  cut). */
+export function liveRow(facts, keys, W) {
+    const p = palette();
+    const lead = facts;
+    for (const k of [...keys, ""]) {
+        if (k === "")
+            return visibleWidth(lead) <= W ? lead : cutLine(lead, W);
+        const gap = W - visibleWidth(lead) - visibleWidth(k);
+        if (gap >= 2)
+            return `${lead}${" ".repeat(gap)}${p.dim}${k}${p.reset}`;
+    }
+    return cutLine(lead, W);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.46.1",
+	"version": "0.47.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.46.1"
+		"@vincemakes/kiso-tui-cells": "0.47.0"
 	}
 }