@vincemakes/kiso-tui 0.1.38 → 0.1.40

package/dist/components.d.ts

@@ -145,7 +145,7 @@ export type BodyCell = {
 } | {
     kind: "checklist";
     /** the model-authored header tail (parseChecklist's count line —
-     *  chat.ts). The compositor's fixed "todo" prefix rides BEFORE it
+     *  chat.ts). The compositor's fixed "task" prefix rides BEFORE it
      *  (W20 naming ruling: never model-controlled). */
     header: string;
     items: {
@@ -191,13 +191,13 @@ export declare function turnFold(t: {
     edits: number;
     others: [string, number][];
 }): string[];
-/** W20 — the todo block's fixed-window height: the whole live block
+/** W20 — the task block's fixed-window height: the whole live block
  *  (header + rows) in POST-FOLD screen rows at EVERY width: the header,
  *  the active row, up to 2 pending, the overflow-pending fold, the
  *  done-collapse. Every live row CUTS at W (never folds) — the block's
  *  height is its row count. */
-export declare const CAP_TODO_LIVE = 6;
-/** W20 — the settled block's duration, the `2h 14m` form (the todo
+export declare const CAP_TASK_LIVE = 6;
+/** W20 — the settled block's duration, the `2h 14m` form (the task
  *  narrative's long-horizon idiom): minutes+seconds under an hour,
  *  hours+minutes past it. */
 export declare function formatDuration(totalSeconds: number): string;

package/dist/components.js

@@ -167,19 +167,20 @@ export function cellComponent(cell) {
     }
 }
 /**
- * The user message — the left rail (bright-white BOLD ▍ per row, the
- * v4.1 design) + the W16 inset chip. The chip folds the text at W−6
- * (the rail + the indent + the side pads), then pads EVERY row to the
- * longest row's DISPLAY width + one space each side, indented two: the
- * block is only as wide as what was said (never the full-width band —
- * a short message like /think would paint a bar across the terminal).
- * The padding is by cells (charWidth is the width authority), so a CJK
- * row pads by width, never by chars, and the chip never overruns its
- * fold. SGR 7 closed with SGR 27 — never SGR 0, the chip composes
- * with a surrounding span — and NEVER dim: reverse video inverts the
- * CURRENT colours, so dimmed text would invert into a dimmed block
- * with no contrast. The ▍ rail stays: SGR is an emphasis on top, the
- * rail is the structural fallback that survives a pipe.
+ * The user message — the W16 inset chip ALONE (the 2026-08-09 ruling:
+ * the ▍ rail and the indent are retired — the rail's stated pipe
+ * fallback was theoretical redundancy: the CLI's pipe path is the
+ * line-mode "you>" form and never renders UserMessage). The chip folds
+ * the text at W−2 (the side pads), then pads EVERY row to the longest
+ * row's DISPLAY width + one space each side, flush left: the block is
+ * only as wide as what was said (never the full-width band — a short
+ * message like /think would paint a bar across the terminal). The
+ * padding is by cells (charWidth is the width authority), so a CJK row
+ * pads by width, never by chars, and the chip never overruns its fold.
+ * SGR 7 closed with SGR 27 — never SGR 0, the chip composes with a
+ * surrounding span — and NEVER dim: reverse video inverts the CURRENT
+ * colours, so dimmed text would invert into a dimmed block with no
+ * contrast.
  */
 class UserMessage {
     cell;
@@ -188,18 +189,17 @@ class UserMessage {
     }
     render(W, _ctx) {
         const p = palette();
-        const rail = `${p.bold}▍${p.reset} `;
-        const chipW = Math.max(1, W - 6);
+        const chipW = Math.max(1, W - 2);
         const rows = [];
         for (const para of this.cell.text.split("\n")) {
             const folded = foldLine(escapeTerminal(para), chipW);
             const inner = Math.max(...folded.map((r) => displayWidth(r)));
             for (const row of folded) {
                 const pad = inner - displayWidth(row);
-                rows.push(`${rail}  ${p.rv} ${row}${" ".repeat(pad)} ${p.rvEnd}`);
+                rows.push(`${p.rv} ${row}${" ".repeat(pad)} ${p.rvEnd}`);
             }
         }
-        return rows.length > 0 ? rows : [rail.trimEnd()];
+        return rows;
     }
 }
 /** The thinking fold — one dim line, width-capped so the /think suffix
@@ -718,12 +718,12 @@ class Banner {
         return rows.map((r) => `${p.dim}${r}${p.reset}`);
     }
 }
-/** W20 — the todo block's fixed-window height: the whole live block
+/** W20 — the task block's fixed-window height: the whole live block
  *  (header + rows) in POST-FOLD screen rows at EVERY width: the header,
  *  the active row, up to 2 pending, the overflow-pending fold, the
  *  done-collapse. Every live row CUTS at W (never folds) — the block's
  *  height is its row count. */
-export const CAP_TODO_LIVE = 6;
+export const CAP_TASK_LIVE = 6;
 /** W20 — the live block's fixed-window row cut: an SGR-aware ONE-ROW
  *  truncation (foldLine wraps; a wrapped row would break the height
  *  cap — every live row is exactly one screen row at every width).
@@ -752,7 +752,7 @@ function cutLine(line, W) {
     }
     return `${out}\x1b[0m…`;
 }
-/** W20 — the settled block's duration, the `2h 14m` form (the todo
+/** W20 — the settled block's duration, the `2h 14m` form (the task
  *  narrative's long-horizon idiom): minutes+seconds under an hour,
  *  hours+minutes past it. */
 export function formatDuration(totalSeconds) {
@@ -763,16 +763,16 @@ export function formatDuration(totalSeconds) {
     return m < 60 ? `${m}m ${s % 60}s` : `${Math.floor(m / 60)}h ${m % 60}m`;
 }
 /**
- * W20 — the todo checklist as STATE: ONE live block that redraws in
+ * W20 — the task checklist as STATE: ONE live block that redraws in
  * place (the current turn's in-place updates), settling at the turn's
- * end as ONE recap block. LIVE (done:false): the fixed "todo" prefix +
+ * end as ONE recap block. LIVE (done:false): the fixed "task" prefix +
  * the compositor-derived counts (the model tail rides AFTER — never
  * model-controlled), the active item first with ▸ (the menu's "the
  * current one"), pending next (≤2), the done items COLLAPSED behind the
  * W10 cut family `└ +N done · ctrl+r`, overflow pending behind
  * `└ +N more · ctrl+r` — every row cut at W so the cap holds at every
  * width. ctrl+r (W15) toggles the full list in place (expanded). SETTLED
- * (done:true): the recap idiom `todo done · N items · <duration>` + the
+ * (done:true): the recap idiom `task done · N items · <duration>` + the
  * FULL final item list in the checklist's existing shape (▖/□/▣ —
  * indented two, the glyph leads, no │ gutter).
  */
@@ -790,8 +790,8 @@ class Checklist {
         const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
         const tail = this.cell.header === "" ? "" : ` · ${this.cell.header}`;
         const fixed = done
-            ? `todo done · ${plural(items.length, "item")} · ${formatDuration(durationSeconds)}`
-            : `todo · ${plural(items.length, "item")} · ${active.length} active · ${doneCount} done`;
+            ? `task done · ${plural(items.length, "item")} · ${formatDuration(durationSeconds)}`
+            : `task · ${plural(items.length, "item")} · ${active.length} active · ${doneCount} done`;
         const header = `${p.bold}▞${p.reset} ${escapeTerminal(fixed + tail)}`;
         // the FULL-list forms: SETTLED — the durable record (the fold is
         // fine — committed content wraps naturally) — and the LIVE ctrl+r
@@ -811,7 +811,7 @@ class Checklist {
         }
         // LIVE — the fixed window: the header + the item rows CUT at W
         // (one screen row each — the block's height is its row count,
-        // CAP_TODO_LIVE, at every width). The cut is the momentary view;
+        // CAP_TASK_LIVE, at every width). The cut is the momentary view;
         // the settle (and the ctrl+r toggle) show everything.
         const itemRows = [];
         if (active.length > 0)

package/dist/compositor.d.ts

@@ -94,12 +94,12 @@ export declare class Body {
     endTurn(thoughtSeconds: number): void;
     terminal(label: string, statusLineText: string): void;
     notice(text: string): void;
-    /** W20 — the todo checklist as STATE, not events: the FIRST call of a
+    /** W20 — the task checklist as STATE, not events: the FIRST call of a
      *  turn creates the ONE live block (done:false — the commit loop only
      *  takes done cells, so it stays in the live region); later calls of
      *  the SAME turn MUTATE that block in place — same position, same
      *  height, zero committed rows (the W8 fixed-window rule generalised
-     *  to state). An unchanged whole-table replace (the todo extension's
+     *  to state). An unchanged whole-table replace (the task extension's
      *  idempotent shape) is a no-op — no mark, no frame. The block commits
      *  ONCE at the turn's end (endTurn); the next turn's first call starts
      *  a fresh block — one settled block per turn that touched the list,

package/dist/compositor.js

@@ -52,10 +52,10 @@ export const CURSOR_MARKER = "\x1b_[kiso-cur]\x1b\\";
 const FRAME_MS = 16; // state changes coalesce to ≥16ms frames
 const SPINNER_MS = 200; // the spinner cadence — a ONE-SHOT re-armed on demand
 const CHROME_ROWS = 4; // box top + input + box bottom + status — the design §03 chrome (V6-3; the box is W6)
-/** W20 — the whole-table-replace comparison: the live todo block only
- *  redraws when the items actually changed (the todo extension's
+/** W20 — the whole-table-replace comparison: the live task block only
+ *  redraws when the items actually changed (the task extension's
  *  idempotent shape — an unchanged replace is a no-op, no frame). */
-function sameTodo(a, b) {
+function sameTask(a, b) {
     return a.length === b.length && a.every((x, i) => x.text === b[i].text && x.status === b[i].status);
 }
 /** The one compositor — implements the Body façade AND the Dock chrome
@@ -318,8 +318,8 @@ export class Body {
             return;
         turn.ended = true;
         turn.thoughtSeconds = thoughtSeconds;
-        // W20: the turn's live todo block settles HERE — the ONE recap
-        // block for the turn (`todo done · N items · <duration>`, the
+        // W20: the turn's live task block settles HERE — the ONE recap
+        // block for the turn ("`task done · N items · <duration>", the
         // duration clocked compositor-side from the block's first call —
         // the CLI stays unchanged). A turn that never touched the list has
         // no live block — nothing settles. Newest-first: the live block is
@@ -371,12 +371,12 @@ export class Body {
         this.#cells.push({ kind: "notice", text, done: true });
         this.#mark();
     }
-    /** W20 — the todo checklist as STATE, not events: the FIRST call of a
+    /** W20 — the task checklist as STATE, not events: the FIRST call of a
      *  turn creates the ONE live block (done:false — the commit loop only
      *  takes done cells, so it stays in the live region); later calls of
      *  the SAME turn MUTATE that block in place — same position, same
      *  height, zero committed rows (the W8 fixed-window rule generalised
-     *  to state). An unchanged whole-table replace (the todo extension's
+     *  to state). An unchanged whole-table replace (the task extension's
      *  idempotent shape) is a no-op — no mark, no frame. The block commits
      *  ONCE at the turn's end (endTurn); the next turn's first call starts
      *  a fresh block — one settled block per turn that touched the list,
@@ -398,7 +398,7 @@ export class Body {
         const turn = this.#turns.length - 1;
         const last = this.#cells[this.#cells.length - 1];
         if (last !== undefined && last.kind === "checklist" && !last.done && last.turn === turn) {
-            if (!sameTodo(last.items, items)) {
+            if (!sameTask(last.items, items)) {
                 Object.assign(last, { header, items });
                 this.#mark();
             }
@@ -478,7 +478,7 @@ export class Body {
                 this.#mark();
                 return { kind: "toggled" };
             }
-            // W20: the LIVE todo block toggles in place too — the capped
+            // W20: the LIVE task block toggles in place too — the capped
             // form flips to the full list (the "done-collapse expands
             // under ctrl+r" claim). The SETTLED block is already full —
             // no toggle, and its rows carry no affordance, so it never

package/dist/render.d.ts

@@ -11,8 +11,9 @@
  * v2a — the palette, centralized (no hard-coded codes elsewhere); v5
  * (TUI v5 #16e, the v4.1 design): the decorative blue (38;5;75) is
  * RETIRED — the identity accents (the you> prompt, the banner tagline,
- * ✓ marks, slash-command names, the ▍ user rail, the input brick) are
- * bright-white BOLD (SGR 1); `code` is the content semantic tint for
+ * ✓ marks, slash-command names, the input brick) are bright-white BOLD
+ * (SGR 1); the user message is the SGR-7 chip (the 2026-08-09 ruling
+ * retired the ▍ rail); `code` is the content semantic tint for
  * inline code spans in assistant text (256-color 110 — the cube color
  * nearest the design's #8fb4d8); red for errors, dim for metadata,
  * green for the diff additions. NO_COLOR set, or a non-TTY output →
@@ -246,6 +247,10 @@ export interface RecapStats {
     readonly tools: number;
     readonly edits: number;
     readonly usage: RunUsage;
+    /** R-C item 4: the per-turn cache miss (min(prevIn, in) − cacheRead),
+     *  passed only when above the noise floor — the re-sent-uncached
+     *  prefix. Absent → the recap bytes stay the historical form. */
+    readonly missed?: number;
     readonly ctxLeftPct: number | null;
     /** W19 — the mode the turn ran under. Under "plan" the recap becomes
      *  the way-forward row (the claimed shape): a plan turn's currency is

package/dist/render.js

@@ -413,7 +413,8 @@ export function renderRecap(s) {
         if (seg !== "")
             parts.push(seg);
         if (s.usage.cache !== null && s.usage.in !== null && s.usage.in > 0) {
-            parts.push(`cache ${Math.round((s.usage.cache / s.usage.in) * 100)}%`);
+            const hit = `cache ${Math.round((s.usage.cache / s.usage.in) * 100)}%`;
+            parts.push(s.missed !== undefined && s.missed > 0 ? `${hit} · miss ${kUnit(s.missed)}` : hit);
         }
     }
     if (s.ctxLeftPct !== null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "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",