@vincemakes/kiso-tui-cells 0.24.4 → 0.25.0

package/dist/components.d.ts

@@ -376,22 +376,6 @@ export declare const CAP_PREVIEW = 5;
 /** The rows a card costs besides its window: two pads, the head, two
  *  blanks and the status row. Below this there is no card (DC-43). */
 export declare const CARD_CHROME = 6;
-/**
- * 0.24.2 ③ — the appended expansion, as a CARD.
- *
- * `ctrl+o` used to append bare ground under a `✦` — the turn recap's own
- * mark, one symbol for two meanings (§4.1) — in a page where every other
- * piece of machine work is a card. And it lands after the recap, so the
- * only tie to the call it came from was that mark's sentence.
- *
- * The card's head row names the call, which is the tie, so the mark is
- * not needed for it. The body is the WHOLE result: an expansion that
- * capped would be no expansion.
- *
- * Expanding IN PLACE is a different problem — committed rows are final
- * (§7.1) — and it waits for route B (DC-50).
- */
-export declare function expandedCard(verb: string, target: string, meta: string, sections: readonly string[], outcome: string, W: number): string[];
 /** 0.24.2 ② — the live region's `thinking…` placeholder: dim italic at
  *  column 2, no glyph, the SAME shape a thinking paragraph takes so that
  *  whatever arrives replaces it in place. Never committed — see the

package/dist/components.js

@@ -771,15 +771,6 @@ class ToolExecution {
             // a pipe with the colour stripped. A failure keeps its colour
             // AND its words — see settledMeta.
             const body = toolBlockParts(c, W, ctx).rows;
-            if (body.length > 0 && c.expanded) {
-                // An EXPANDED block is already showing everything, and its own
-                // footer ("ctrl+o collapses") is what closes it. Giving it an
-                // outcome row as well would put two closing rows on one block
-                // and move the metadata off a head row every width gate pins.
-                // It takes the SURFACE and nothing else.
-                const head = c.isError ? `  ${p.red}${text}${p.reset}` : `  ${text}`;
-                return slabBlock(appendSuffix(head, expandSuffix(hidden, W - visibleWidth(head))), body, null, W);
-            }
             if (body.length > 0) {
                 // R13 — THE CARD, when there is something to preview: the head
                 // row names the call, the preview sits inside, and the outcome
@@ -804,8 +795,34 @@ class ToolExecution {
                 // what happened and how long it took — is never cut open.
                 const join = (...xs) => xs.filter((x) => x !== "").join(" · ");
                 const attr = approvedBy.replace(/^ · /, "");
-                const words = pickTier([join(meta, counted, `${elapsed}s`, attr), join(meta, counted, `${elapsed}s`), join(meta, `${elapsed}s`), meta], W - visibleWidth(noteIndent()));
-                const outcome = c.isError ? `${p.red}${words}${p.reset}` : words;
+                // DC-50 / R14: the key is RESERVED (§7.5), so its width comes
+                // out of the budget BEFORE the tiers are picked — not
+                // appended after, which is what the first build did and
+                // which let a narrow row cut the affordance off entirely.
+                // The tier ladder is what gives way; the key never is.
+                const keySuffix = c.expanded ? ` · ${COLLAPSE_ROW}` : "";
+                const words = pickTier([join(meta, counted, `${elapsed}s`, attr), join(meta, counted, `${elapsed}s`), join(meta, `${elapsed}s`), meta], W - visibleWidth(noteIndent()) - keySuffix.length);
+                // DC-50 / R14 — ONE CARD, ONE SKELETON, expanded or not.
+                //
+                // The expanded card used to take a DIFFERENT shape: its head
+                // row carried the outcome inline (`shell npm test · exit 0 ·
+                // 40 lines · 0.1s`), it had no outcome row at all, and the
+                // `ctrl+o collapses` affordance was a row of its own at the
+                // end of the body. That was defensible while an expanded card
+                // was rare — reachable only for a live or approval-parked
+                // cell — and it stopped being defensible the moment ctrl+o
+                // became a switch that expands EVERY settled card at once: a
+                // page where the same call has two skeletons depending on a
+                // global toggle is the instability this round is named for.
+                //
+                // So both states are pad · head · blank · body · blank ·
+                // outcome · pad. The head row says WHAT was run and nothing
+                // else; the outcome row says what happened, how much, how
+                // long — and carries the affordance, because the affordance
+                // is a fact about this card's state and the outcome row is
+                // where this card's facts live.
+                const withKey = `${words}${keySuffix}`;
+                const outcome = c.isError ? `${p.red}${withKey}${p.reset}` : withKey;
                 return slabBlock(head, body, outcome, W);
             }
             // R13 — nothing to preview: the SAME card, three rows, with the
@@ -1570,30 +1587,20 @@ function slabBlock(head, body, outcome, W) {
         return [...top, slabRow("", W)];
     return [...top, slabRow("", W), ...noteRow(outcome, W, "body").map((r) => slabRow(r, W)), slabRow("", W)];
 }
-/**
- * 0.24.2 ③ — the appended expansion, as a CARD.
+/*
+ * RETIRED (DC-50 / R14, 2026-09-05) — `expandedCard`.
  *
- * `ctrl+o` used to append bare ground under a `✦` — the turn recap's own
- * mark, one symbol for two meanings (§4.1) — in a page where every other
- * piece of machine work is a card. And it lands after the recap, so the
- * only tie to the call it came from was that mark's sentence.
+ * It drew the APPENDED block the old ctrl+o produced: a card printed far
+ * below the call it belonged to, which is why its head row had to carry
+ * `expanded · N turns back` and why its body carried section headers
+ * around the raw input and output. All of that was addressing — a way
+ * for a copy to say which original it was a copy of.
  *
- * The card's head row names the call, which is the tie, so the mark is
- * not needed for it. The body is the WHOLE result: an expansion that
- * capped would be no expansion.
- *
- * Expanding IN PLACE is a different problem — committed rows are final
- * (§7.1) — and it waits for route B (DC-50).
+ * DC-50 removes the copy. An expanded card is the ordinary `toolCard`
+ * with `expanded` set, rendered where the call stands, so nothing needs
+ * to say where it came from. Its shape is gated in
+ * `r13-rhythm-surface.test.ts`.
  */
-export function expandedCard(verb, target, meta, sections, outcome, W) {
-    const p = palette();
-    const head = cutLine(`  ${verb} ${p.bold}${escapeTerminal(target)}${p.reset}${slabPaints() ? p.washDim : p.dim} · ${escapeTerminal(meta)}${slabPaints() ? p.washDimEnd : p.reset}`, W);
-    const body = [];
-    for (const raw of sections)
-        for (const row of blockRows(raw, W, slabPaints() ? "body" : "dim"))
-            body.push(row);
-    return slabBlock(head, body, outcome, W);
-}
 /** 0.24.2 ② — the live region's `thinking…` placeholder: dim italic at
  *  column 2, no glyph, the SAME shape a thinking paragraph takes so that
  *  whatever arrives replaces it in place. Never committed — see the
@@ -1687,7 +1694,13 @@ function toolBlockParts(c, W, ctx) {
     // rides a block that HAS rows — an expanded delegate whose summary
     // marker is missing renders nothing, and a lone footer under a head
     // row would be an affordance for an empty block.
-    if (c.expanded && rows.length > 0)
+    //
+    // DC-50 / R14: a SETTLED card carries the affordance on its OUTCOME
+    // row instead, so that both states have one skeleton. This footer is
+    // for the states that have no outcome row to carry it — a card parked
+    // for approval, or one still running that was expanded before it
+    // settled.
+    if (c.expanded && rows.length > 0 && c.state !== "done")
         rows.push(...foldLine(`${p.dim}${noteIndent()}${COLLAPSE_ROW}${p.reset}`, W));
     // R9 P2: `└` opens a block that has no surface. Inside a slab the
     // surface IS the container, and a corner in it is §1.3's empty mark

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui-cells",
-	"version": "0.24.4",
+	"version": "0.25.0",
 	"description": "kiso tui-cells — the components cell renderer (components, diff, width, the render slice). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",