@vincemakes/kiso-tui-cells 0.1.41

package/dist/approval-panel.d.ts

@@ -0,0 +1,109 @@
+/**
+ * W21 (the v8 approval round) — the approval panel: the bounded block
+ * that replaces the running tool's live window while a human-chain
+ * approval is pending (the v8 design §3.2). The panel is a VIEW only —
+ * the verdict mapping (bare No aborts, No+words continues, esc
+ * cancels, the allow-amend words ride the next turn) lives in the CLI,
+ * never here (the R3 chain ruling).
+ *
+ * The block's rows:
+ *  - the rule line — the why-asked line, ONE row (never a fold):
+ *    `<tool> needs approval — asked by <speaker> · <fix hint>`;
+ *  - the title — the toolTarget rendering, ONE row;
+ *  - the divider — "─ the full args — never truncated ─";
+ *  - the ALWAYS-verbose args (shell = the full command; edit/write =
+ *    the untruncated ± diff; other = the full JSON — nothing the human
+ *    is asked to approve is ever cut), FOLDED at W−2 and capped at
+ *    maxRows−6 with the "└ +N more rows" notice;
+ *  - the numbered options — "1 Yes / 2 Yes, don't ask again for <tool>
+ *    / 3 No" (the approval flavor) or "1 Yes / 3 No" (the simple
+ *    flavor — the trust gate, the uncertain resolutions);
+ *  - the affordance — the phase's key hint, ONE row;
+ *  - the └ corner.
+ * The single-row lines CUT (never fold — the block's height is its row
+ * count, the W20 discipline — the #checked throw demands it); the args
+ * FOLD (a bounded block's body — content folds, metadata cuts).
+ */
+export type PanelFlavor = "approval" | "simple";
+export type PanelPhase = "options" | "rule" | "amend";
+export type PanelSel = 0 | 1 | 2 | 3;
+/** The ALWAYS-verbose args (the panel's body): the untruncated diff
+ *  (edit/write), or the full text (shell = the command line, other =
+ *  the pretty-printed JSON). The CLI composes them UNTRUNCATED — the
+ *  panel renders the expanded diff path (diffBody(diff, W, true)). */
+export type PanelArgs = {
+    readonly kind: "diff";
+    readonly diff: import("./diff.js").DiffLine[] | null;
+} | {
+    readonly kind: "text";
+    readonly lines: readonly string[];
+};
+export interface PanelView {
+    /** The flavor — "approval" carries the option-2 rule ("Yes, don't
+     *  ask again"), "simple" (the trust gate, the uncertain resolutions)
+     *  carries only 1 Yes / 3 No. */
+    readonly flavor: PanelFlavor;
+    /** The tool name — the rule line's first word and the option-2
+     *  rule prefill (the approval flavor). */
+    readonly name: string;
+    /** The title — the toolTarget rendering ("edit examples/foo.ts"). */
+    readonly title: string;
+    /** The rule line's "asked by" — the first non-abstain extension
+     *  (the ask verdict's speaker). */
+    readonly speaker: string;
+    /** The fix hint per speaker (the v8 design §3.5 table). */
+    readonly hint?: string;
+    /** The options-phase status-left text — the CLI knows the context
+     *  ("▸ run paused", the trust gate's line). */
+    readonly statusText: string;
+    /** The ALWAYS-verbose args — the full command/content/diff. */
+    readonly args: PanelArgs;
+    /** The simple flavor's full rule line (the trust/uncertain
+     *  questions) — overrides the why-asked composition. */
+    readonly ruleOverride?: string;
+    /** The fallback question — the y/n text for the dock-less path
+     *  (a TTY without a dock, or a pipe). */
+    readonly fallbackQuestion: string;
+}
+export type PanelVerdict = {
+    readonly action: "allow";
+    readonly reason: string;
+} | {
+    readonly action: "allow-rule";
+    readonly rule: string;
+} | {
+    readonly action: "deny";
+    readonly reason: string;
+} | {
+    readonly action: "cancel";
+};
+/** The bound panel state the compositor reads — the editor owns the
+ *  phase/selection state machine and the key routing; the compositor
+ *  renders it (the block rows, the input lead, the status/hint). */
+export interface PanelState {
+    readonly view: PanelView;
+    readonly phase: PanelPhase;
+    readonly sel: PanelSel;
+}
+/** The block's rows — EXACTLY the preview's frame shape, the gutter at
+ *  the left edge (the preview's two-space mock indent is its own
+ *  styling; the real rows sit at column 1, like every tool cell).
+ *  maxRows caps the TOTAL (the args fold; the single-row lines cut). */
+export declare function panelBlockRows(view: PanelView, phase: PanelPhase, sel: PanelSel, W: number, maxRows: number): string[];
+/** The input row's lead for the panel's phase (the preview's chrome
+ *  rows): the digit leads bold, the rule/feedback leads dim. The rule
+ *  lead names the tool (the option-2 prefill), the amend lead the
+ *  denial/allowance feedback ("the words ride the verdict"). */
+export declare function panelLead(view: PanelView, phase: PanelPhase, sel: PanelSel): string;
+/** The lead's plain text — the editor's reflow width (the line must
+ *  fit the lead + the box's walls). */
+export declare function panelLeadPlain(view: PanelView, phase: PanelPhase, sel: PanelSel): string;
+export declare function panelLeadWidth(view: PanelView, phase: PanelPhase, sel: PanelSel): number;
+/** The status row's left text while the panel is up — the phase, not
+ *  the CLI's painting status (the compositor derives it from the panel
+ *  state; the "▸ run paused" etc. ride the options phase). */
+export declare function panelStatus(view: PanelView, phase: PanelPhase, sel: PanelSel): string;
+/** The status row's right-aligned hint while the panel is up — the
+ *  phase's keys. The approval flavor gains the tab-amend path; the
+ *  simple flavor (the trust/uncertain gates) never does. */
+export declare function panelAffordance(view: PanelView, phase: PanelPhase, sel: PanelSel): string;

package/dist/approval-panel.js

@@ -0,0 +1,144 @@
+/**
+ * W21 (the v8 approval round) — the approval panel: the bounded block
+ * that replaces the running tool's live window while a human-chain
+ * approval is pending (the v8 design §3.2). The panel is a VIEW only —
+ * the verdict mapping (bare No aborts, No+words continues, esc
+ * cancels, the allow-amend words ride the next turn) lives in the CLI,
+ * never here (the R3 chain ruling).
+ *
+ * The block's rows:
+ *  - the rule line — the why-asked line, ONE row (never a fold):
+ *    `<tool> needs approval — asked by <speaker> · <fix hint>`;
+ *  - the title — the toolTarget rendering, ONE row;
+ *  - the divider — "─ the full args — never truncated ─";
+ *  - the ALWAYS-verbose args (shell = the full command; edit/write =
+ *    the untruncated ± diff; other = the full JSON — nothing the human
+ *    is asked to approve is ever cut), FOLDED at W−2 and capped at
+ *    maxRows−6 with the "└ +N more rows" notice;
+ *  - the numbered options — "1 Yes / 2 Yes, don't ask again for <tool>
+ *    / 3 No" (the approval flavor) or "1 Yes / 3 No" (the simple
+ *    flavor — the trust gate, the uncertain resolutions);
+ *  - the affordance — the phase's key hint, ONE row;
+ *  - the └ corner.
+ * The single-row lines CUT (never fold — the block's height is its row
+ * count, the W20 discipline — the #checked throw demands it); the args
+ * FOLD (a bounded block's body — content folds, metadata cuts).
+ */
+import { displayWidth } from "./width.js";
+import { cutLine, diffBody, gutterFold, visibleWidth, widthCut } from "./components.js";
+import { escapeTerminal, palette } from "./render.js";
+/** The rule line's text — the why-asked line (the R3 chain): the tool
+ *  name, the first non-abstain speaker, the fix hint (the §3.5 table,
+ *  code-accented). The simple flavor carries the CLI's own question
+ *  text instead (the trust gate, the uncertain resolutions) — their
+ *  titles and args differ, the interaction is identical (§3.6). */
+function panelRuleText(view) {
+    const p = palette();
+    if (view.ruleOverride !== undefined)
+        return escapeTerminal(view.ruleOverride);
+    const hint = view.hint;
+    const base = `${p.bold}${escapeTerminal(view.name)}${p.reset} ${p.dim}needs approval — asked by${p.reset} ${p.bold}${escapeTerminal(view.speaker)}${p.reset}`;
+    return hint ? `${base}${p.dim} ·${p.reset} ${p.code}${escapeTerminal(hint)}${p.reset}` : base;
+}
+/** The numbered options row — "1 Yes  2 Yes, don't ask again for
+ *  <rule>  3 No" (approval) or "1 Yes  3 No" (simple). The row is a
+ *  pure SPAN: the block prepends the gutter (the invariant ① test
+ *  caught the double-gutter — the block and the row both emitted it).
+ *  The option-2 rule name is the ONLY cuttable span: the row's fixed
+ *  part (the 1/3 options + the separators + the option-2 prefix) is 45
+ *  cells, so the name fits W−45 and cuts with a "…" at W−46 (the
+ *  single-row discipline — the row never folds). */
+function panelOptionsRow(view, sel, W) {
+    const p = palette();
+    const o1 = sel === 1 ? `${p.bold} 1 Yes${p.reset}` : ` 1 Yes`;
+    const o3 = sel === 3 ? `${p.bold} 3 No${p.reset}` : ` 3 No`;
+    if (view.flavor === "simple")
+        return `${o1}  ${o3}`;
+    // the option-2 span: " 2 Yes, don't ask again for <name>" — the
+    // fixed part is 45 (the 1/3 options + the separators + the 28-cell
+    // prefix); the name cuts to W−46 + "…".
+    const name = escapeTerminal(view.name);
+    const budget = Math.max(1, W - 46);
+    const shown = visibleWidth(name) > Math.max(0, W - 45) ? `${widthCut(name, budget)}…` : name;
+    const o2 = sel === 2 ? `${p.bold} 2 Yes, don't ask again for ${shown}${p.reset}` : ` 2 Yes, don't ask again for ${shown}`;
+    return `${o1}  ${o2}  ${o3}`;
+}
+/** The block's rows — EXACTLY the preview's frame shape, the gutter at
+ *  the left edge (the preview's two-space mock indent is its own
+ *  styling; the real rows sit at column 1, like every tool cell).
+ *  maxRows caps the TOTAL (the args fold; the single-row lines cut). */
+export function panelBlockRows(view, phase, sel, W, maxRows) {
+    const p = palette();
+    const gutter = `${p.dim}│${p.reset} `;
+    const rows = [];
+    rows.push(`${gutter}${cutLine(panelRuleText(view), Math.max(1, W - 2))}`);
+    rows.push(`${gutter}${cutLine(`${p.bold}${escapeTerminal(view.title)}${p.reset}`, Math.max(1, W - 2))}`);
+    rows.push(`${cutLine(`${p.dim}─ the full args — never truncated ─${p.reset}`, Math.max(1, W - 2))}`);
+    // the args — the bounded block's body: fold, then cap. The └ cut is
+    // ONE row (the W20 discipline): when the args exceed the budget, one
+    // notice row carries the count and where the rest is (the event log).
+    const args = view.args.kind === "diff"
+        ? diffBody(view.args.diff, W, true) // the expanded path — never the tool cell's capped copy
+        : view.args.lines.flatMap((line) => gutterFold(`${p.dim}│${p.reset} `, escapeTerminal(line), W));
+    const argsBudget = Math.max(1, maxRows - 6);
+    let shown;
+    if (args.length > argsBudget) {
+        const kept = Math.max(0, argsBudget - 1);
+        const n = args.length - kept;
+        shown = [...args.slice(0, kept), cutLine(`${p.dim}└ +${n} more rows — the full args are in the event log${p.reset}`, Math.max(1, W - 2))];
+    }
+    else {
+        shown = args;
+    }
+    rows.push(...shown);
+    rows.push(`${gutter}${panelOptionsRow(view, sel, W)}`);
+    rows.push(`${gutter}${p.dim}${panelAffordance(view, phase, sel)}${p.reset}`);
+    rows.push(`${p.dim}└ ${p.reset}`);
+    return rows;
+}
+/** The input row's lead for the panel's phase (the preview's chrome
+ *  rows): the digit leads bold, the rule/feedback leads dim. The rule
+ *  lead names the tool (the option-2 prefill), the amend lead the
+ *  denial/allowance feedback ("the words ride the verdict"). */
+export function panelLead(view, phase, sel) {
+    const p = palette();
+    if (phase === "rule")
+        return `${p.dim}2 Yes, don't ask again for ${p.reset}`;
+    if (phase === "amend")
+        return `${p.dim}${sel === 3 ? "feedback (deny): " : "feedback (amend): "}${p.reset}`;
+    return `${p.bold}${view.flavor === "approval" ? "1-3> " : "1/3> "}${p.reset}`;
+}
+/** The lead's plain text — the editor's reflow width (the line must
+ *  fit the lead + the box's walls). */
+export function panelLeadPlain(view, phase, sel) {
+    if (phase === "rule")
+        return "2 Yes, don't ask again for ";
+    if (phase === "amend")
+        return sel === 3 ? "feedback (deny): " : "feedback (amend): ";
+    return view.flavor === "approval" ? "1-3> " : "1/3> ";
+}
+export function panelLeadWidth(view, phase, sel) {
+    return displayWidth(panelLeadPlain(view, phase, sel));
+}
+/** The status row's left text while the panel is up — the phase, not
+ *  the CLI's painting status (the compositor derives it from the panel
+ *  state; the "▸ run paused" etc. ride the options phase). */
+export function panelStatus(view, phase, sel) {
+    if (phase === "rule")
+        return "▸ rule input";
+    if (phase === "amend")
+        return sel === 3 ? "▸ deny · the words become the tool_result" : "▸ amend · the words ride the verdict";
+    return view.statusText;
+}
+/** The status row's right-aligned hint while the panel is up — the
+ *  phase's keys. The approval flavor gains the tab-amend path; the
+ *  simple flavor (the trust/uncertain gates) never does. */
+export function panelAffordance(view, phase, sel) {
+    if (phase === "rule")
+        return "enter commits · esc backs out";
+    if (phase === "amend")
+        return "enter sends";
+    if (view.flavor === "approval")
+        return sel === 0 ? "tab amend · esc cancel" : "enter sends · esc backs out";
+    return sel === 0 ? "esc cancel" : "enter sends";
+}

package/dist/components.d.ts

@@ -0,0 +1,298 @@
+/**
+ * TUI v6 (ADR-0046) — the components: EVERY screen line's renderer.
+ * Extracted to tui-cells (ADR-0043 Amendment 4): the cell renderer
+ * leaves the tui for the 9th package; the tui's shims re-export it.
+ *
+ * Each component turns one piece of state into display lines (SGR
+ * included, raw — the compositor writes them verbatim). The folding
+ * lives HERE: every line a component returns must fit the terminal
+ * width — the compositor's crash-on-violation invariant backs it up
+ * (a component that forgets to fold CRASHES with a diagnostic, never
+ * silently truncates — the crash is the contract, not a symptom).
+ *
+ * The fold is SGR-AWARE: a line whose bold/dim span would straddle a
+ * fold boundary closes the span at the break and reopens it on the
+ * next row — the #16b contract (no literal "[2m" fragments) survives
+ * folding. displayWidth/charWidth (width.ts) are the width primitives
+ * (untouched); render.ts supplies the original text (palette, escape,
+ * tint, fold wording).
+ */
+import { foldThinking, foldResult, renderToolSummary, type ResumeMeta } from "./render.js";
+/** The spinner glyphs, cycled by the compositor's on-demand tick. */
+export declare const SPINNER: string[];
+/** The frame context the compositor passes down — the pieces of time
+ *  that make a live render non-deterministic (the running tool's glyph
+ *  and elapsed). Everything else is a pure function of the cell. */
+export interface FrameCtx {
+    readonly spinnerI: number;
+    readonly now: number;
+    /** The terminal height (rows) — the banner cell's tier input (W1:
+     *  the tier table reads H, so a resize RE-TIERS instead of
+     *  re-folding frozen rows). */
+    readonly height: number;
+}
+/** ONE screen line a component emits (raw, SGR included). */
+export type RenderLine = string;
+/**
+ * The fold — split a display-width line into ≤W rows, preserving SGR
+ * spans across the break: a span open at the break closes (reset) at
+ * the row's end and reopens on the next row. The rows are what the
+ * terminal's own soft-wrap would have produced — except the compositor
+ * folds FIRST, so the terminal never reflows a component's line (the
+ * #17 merge class cannot reach committed content).
+ */
+export declare function foldLine(line: string, W: number): string[];
+/** The visible width of a rendered line (SGR stripped — the invariant
+ *  the compositor enforces on every emitted line). */
+export declare function visibleWidth(line: string): number;
+/** A component: render the display lines for one piece of state. */
+export interface Component {
+    render(width: number, ctx: FrameCtx): string[];
+}
+/** The W11 spacing formula — "a row gets one blank line above it when
+ *  the row is itself a block, or when the previous sibling was taller
+ *  than one row". One-row siblings pack tight; anything multi-row
+ *  breathes on both sides. The FIRST cell never gets the blank (it sits
+ *  at the body's top — the banner would otherwise start one row down).
+ *  `prev` is the previous sibling's OWN rows (raw — a cell's own blank
+ *  must never count toward its height). The blank is a JOIN artifact:
+ *  the cell's own render stays blank-free, so per-cell accounting
+ *  (heights, the fold cache) never sees a fake row. */
+export declare function bodySpacing(prev: readonly string[] | null, rows: readonly string[]): string[];
+/** The container — vertical concatenation with the W11 formula. No
+ *  component decides its own spacing: every blank in the body is the
+ *  container's. */
+export declare class Container implements Component {
+    private readonly children;
+    constructor(children: Component[]);
+    render(width: number, ctx: FrameCtx): string[];
+}
+export type BodyCell = {
+    kind: "user";
+    text: string;
+    done: true;
+    turn: number;
+} | {
+    kind: "thinking";
+    text: string;
+    done: boolean;
+    turn: number;
+} | {
+    kind: "tool";
+    name: string;
+    input: string;
+    /** W15: the FULL input JSON (pretty-printed) — the display
+     *  summary above is sliced at 60 chars; the expanded block's
+     *  "--- input ---" section mirrors /last and needs it all. */
+    inputFull: string;
+    childRoles: string[];
+    state: "pending" | "approval" | "running" | "done";
+    isError: boolean;
+    resultText: string;
+    diff: import("./diff.js").DiffLine[] | null;
+    added: number;
+    removed: number;
+    startedAt: number | null;
+    doneAt: number | null;
+    done: boolean;
+    /** W15: the live-region expand toggle — while the cell is live
+     *  the FULL body renders in place (the compositor owns those
+     *  rows and redraws them); a committed cell can never toggle
+     *  (history is never rewritten — ADR-0046). */
+    expanded: boolean;
+    /** W14: the turn boundary — the index of the turn record that
+     *  created this cell (the fold-hold's owner; −1 when no turn
+     *  exists yet — the pre-turn cells never hold). */
+    turn: number;
+    /** W13: the rolled-up group summary — set at COMMIT time when
+     *  the head of an N > 2 same-tool run renders the group (the
+     *  work order's claimed shape: "✓ read  5 files (2.4k lines,
+     *  1.1s)" + the target children). The members carry null — the
+     *  compositor's rolled-heads bookkeeping renders them []. */
+    rolled: null | {
+        count: number;
+        lines: number;
+        elapsed: string;
+        targets: string[];
+    };
+    /** W19: a DENIED call's reason (the CLI extracted it from the
+     *  result's "[Permission denied] " prefix, keyed on the "denied"
+     *  tag). Non-null renders the pinned row — the full call name,
+     *  the target, the reason in the W4 parentheses idiom, NO timing
+     *  metadata (the call never ran). */
+    reason: string | null;
+    /** A5: the approval verdict — the permission_decided event bound
+     *  into the cell (no free-standing `  approved` orphan row). The
+     *  settled head row aggregates name + status + decidedBy in ONE
+     *  row: a denied call's pinned row gains `· by <decidedBy>`; an
+     *  extension-approved call's settled row gains `· approved by
+     *  <decidedBy>` (the human approval needs no marker — the ⏸ →
+     *  spinner → ✓ sequence told the story). Null until a decision
+     *  lands (the auto-allowed calls never have one). */
+    verdict: {
+        decision: "approved" | "denied";
+        decidedBy?: string;
+        reason?: string;
+    } | null;
+} | {
+    kind: "text";
+    text: string;
+    done: boolean;
+} | {
+    kind: "notice";
+    text: string;
+    done: true;
+} | {
+    kind: "banner";
+    version: string;
+    extensionsText: string;
+    resume: ResumeMeta[];
+    done: true;
+} | {
+    kind: "raw";
+    lines: string[];
+    done: true;
+} | {
+    kind: "terminal";
+    label: string;
+    line: string;
+    done: true;
+} | {
+    kind: "checklist";
+    /** the model-authored header tail (parseChecklist's count line —
+     *  chat.ts). The compositor's fixed "task" prefix rides BEFORE it
+     *  (W20 naming ruling: never model-controlled). */
+    header: string;
+    items: {
+        text: string;
+        status: "pending" | "active" | "done";
+    }[];
+    /** W20: false while LIVE — the current turn's ONE in-place block
+     *  (the commit loop only takes done cells, so it stays in the
+     *  live region); true once SETTLED — endTurn committed it as the
+     *  turn's one recap block. */
+    done: boolean;
+    /** W20: the LIVE block's ctrl+r toggle (W15) — the capped form
+     *  flips to the full list in place. The settled render ignores
+     *  it (already full). */
+    expanded: boolean;
+    /** W20: the wall clock of the block's FIRST call — the settled
+     *  header's duration is clocked from here, compositor-side (the
+     *  CLI stays unchanged). */
+    startedAt: number;
+    /** W20: the run's duration at the settle — the `2h 14m` form. */
+    durationSeconds: number;
+    turn: number;
+};
+declare const TOOL_SUMMARY_MAX = 60;
+/** The component for one cell — the mapping table lives here so the
+ *  compositor stays a pure writer. */
+export declare function cellComponent(cell: BodyCell): Component;
+/** W22: the pending-queue chips — queued user lines pre-render above
+ *  the input row as the SAME UserMessage chip (undimmed: reverse video
+ *  inverts the CURRENT colours), the dim `□` gutter marking the queued
+ *  state (the gutter rides EVERY row — the gutterFold precedent: the
+ *  left edge alone distinguishes the states). Each chip folds at W−3
+ *  (the gutter's 2 cells), so a long line hard-folds INSIDE the chip
+ *  and invariant ① holds on the band. */
+export declare function pendingQueueRows(lines: readonly string[], W: number): string[];
+/** Fold a line's CONTENT at W−2 and prefix EVERY row with the gutter
+ *  (W2: a wrapped tool row keeps its state mark — the left edge alone
+ *  distinguishes the states at --plain; the UserMessage rail precedent,
+ *  v5 #16f). The gutter carries its own SGR (e.g. the bold ✓). W21:
+ *  exported for the approval panel's text args (the same │ gutter). */
+export declare function gutterFold(gutter: string, line: string, W: number): string[];
+/** A6: the tool-header variant — ONE cut row, never a fold. A wide
+ *  header (a long target path, a wordy denial reason) used to wrap
+ *  through foldLine — every wrapped row repeated the gutter, the
+ *  settled row grew past its previewed height. The header names the
+ *  call — the ellipsis marks the cut, the body below still carries the
+ *  full content. The budget: the gutter's own visible width + the
+ *  ellipsis ride the row (the invariant ① cap holds). */
+export declare function gutterCut(gutter: string, line: string, W: number): string[];
+/** W13 — the rollup opt-in table: which tools collapse, and the count
+ *  NOUN (read_file calls → "5 files", list_dir → "5 dirs", search_text
+ *  → "5 matches"). Only these tools opt in — a shell burst is never
+ *  rolled up (its rows carry meaning). The folded-turn line (W14) reuses
+ *  the plurals for its other-tool terms ("2 dirs", "1 match"). */
+export declare const ROLLUP_NOUN: Readonly<Record<string, string>>;
+/** W14 — the folded-turn line: a whole QUIET turn (no text), once it is
+ *  scrollback, becomes ONE line — the work order's claimed shape
+ *  (`▞ thought 19s · 5 reads · no edits`), the counts accumulated at
+ *  toolStart: read_file → "reads", edit_file → "edits", the other tools
+ *  as first-call-order terms (the ROLLUP_NOUN plurals when the tool opts
+ *  in, the verb + "s" otherwise).
+ *  A9 (ruling R2, mock A): the user chip rides the fold — the human's
+ *  words LEAD the one line, `▞ <chip> · thought 19s · 5 reads · no
+ *  edits` — the chip the SAME SGR-7 bracket as the live user row (#16f,
+ *  side pads included). The words take the fold's width budget: the
+ *  metadata terms survive (the W14 metadata rule — they give way LAST),
+ *  the words width-cut at the end with the honest "…" (never a silent
+ *  truncate — invariant ① holds on the ONE row by construction). */
+export declare function turnFold(t: {
+    words: string;
+    thoughtSeconds: number;
+    reads: number;
+    edits: number;
+    others: [string, number][];
+}, W: number): string[];
+/** The approval mini-diff (W7): capped at 12 folded rows — the head +
+ *  the named middle (the renderer cut — what was cut, how to expand) +
+ *  the tail. The rows are folded at the current width BEFORE the cap —
+ *  the R1 measured bug: truncateDiff capped at 40 ENTRIES while the
+ *  fold turned them into 73 SCREEN rows at W≤80 (a 44-row terminal's
+ *  content cap is H−4 = 40 — the approval force-committed a third of
+ *  the screen into scrollback inside one frame).
+ *  W17: the cap is a ROW budget at every width — the └ cut is ONE line
+ *  (a folded cut pushed the total past 12 at narrow widths), and below
+ *  a floor of 3 SOURCE lines visible the head/tail pair is noise (each
+ *  fragment a sliver of a long line): drop to the head only — the head
+ *  takes the whole budget — and the └ row carries the rest.
+ *  W21: exported for the approval panel — the expanded path renders
+ *  the approval's ALWAYS-verbose args (never the capped copy). */
+export declare function diffBody(diff: import("./diff.js").DiffLine[] | null, W: number, expanded?: boolean): string[];
+/** 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_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).
+ *  A line that fits (≤ W) passes through whole; an overflow cuts the
+ *  content at W−1 — the ellipsis's slot — and the ellipsis rides AFTER
+ *  the reset (post-reset — the PTY needles' convention). The cut row
+ *  never exceeds W (invariant ①). W21: exported for the approval
+ *  panel's single-row lines (the rule line, the title, the divider,
+ *  the options/affordance rows). */
+export declare function cutLine(line: string, W: number): string;
+/** 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;
+/** The status container's row: the status text (+ the tail) with the
+ *  right-aligned "/ commands · ↑ history" hint in the idle state —
+ *  the hint CUT FIRST when the width is short (the #16g rule); when
+ *  the STATUS ITSELF cannot fit, it cuts with a "…" — the last resort,
+ *  enforced by invariant ① (the old code let the status soft-wrap).
+ *  W21: the question param is gone — the old question slot retires; a
+ *  pending approval's status IS the panel's (the compositor derives
+ *  it from the bound panel state). */
+export declare function statusLine(status: string, tail: string, W: number, hint?: string): string;
+/** The display-width prefix of a plain (SGR-free) text. W21: exported
+ *  for the approval panel's option-2 rule-name cut. */
+export declare function widthCut(text: string, max: number): string;
+/** W6 — the box: the chrome's top rail. The two ╌ dotted rows become
+ *  a rounded box (the box already says "input lives here"); the rails
+ *  stay dim, the width is still the full W (the box is a rail with
+ *  corners — the menu/gap rows above and the status below are
+ *  untouched). */
+export declare function boxTop(W: number): string;
+/** W6 — the box: the chrome's bottom rail. */
+export declare function boxBottom(W: number): string;
+/** The terminal label + rhythm gap (the pipe path's v2c bytes — the
+ *  exact render the passthrough needs). */
+export declare function terminalPipe(label: string, statusLineText: string): string;
+/** The pipe-path pieces the passthrough reuses (byte-identical). */
+export { foldThinking, foldResult, renderToolSummary, TOOL_SUMMARY_MAX };