@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/layout/cells.js

@@ -1,156 +0,0 @@
-/**
- * Display-width cell arithmetic (tui-subagent-panel §5 #1).
- *
- * EVERY FUNCTION HERE IS PURE AND TOTAL: no Ink, no clock, no terminal, and no
- * input that throws. The panel row and the Agents board both need to place text
- * in a FIXED number of terminal columns, and `padEnd` cannot do that: it counts
- * code units while a terminal counts cells, so a CJK description padded with
- * `padEnd` overflows its box by one column per wide character and pushes the
- * next cell off the row. That is exactly the defect this round removes from the
- * roster, one layer down.
- *
- * ASCII ONLY: `src/ui/**` is inside `glyphs.test.ts`'s static scan, so the
- * ellipsis and any other symbol a caller wants must be passed IN (the board
- * hands over `glyphs.ellipsis`), never spelled here.
- */
-import stringWidth from 'string-width';
-/** Invalid geometry becomes zero, exactly like the layout modules' `nonNegativeInt`. */
-function nonNegativeInt(value) {
-    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}
-/** Display columns a string occupies, or 0 for a non-string (defensive at the edge only). */
-export function cellWidth(text) {
-    if (typeof text !== 'string' || text.length === 0)
-        return 0;
-    return stringWidth(text);
-}
-/**
- * Cut `text` to at most `cells` display columns, marking the cut with `ellipsis`.
- *
- * THE ELLIPSIS IS PART OF THE BUDGET, not an extra column: a caller that asks for
- * 8 cells gets a string that MEASURES 8, which is what makes a fixed-width cell
- * a cell rather than a hope. When the budget cannot hold the ellipsis plus one
- * character, the string is hard-cut instead - a marker wider than the cell it
- * marks is the one outcome worse than no marker.
- *
- * Wide characters are never split: a surrogate pair or a double-width glyph that
- * does not fit is dropped whole, so the result can measure one column less than
- * asked but never one more.
- */
-export function fitCells(text, cells, ellipsis = '...') {
-    const budget = nonNegativeInt(cells);
-    if (budget === 0)
-        return '';
-    if (cellWidth(text) <= budget)
-        return text;
-    const mark = cellWidth(ellipsis) < budget ? ellipsis : '';
-    const room = budget - cellWidth(mark);
-    let out = '';
-    let used = 0;
-    // `Array.from` iterates by CODE POINT, so a surrogate pair is one step and can
-    // never be cut in half by this loop.
-    for (const char of Array.from(text)) {
-        const width = cellWidth(char);
-        if (used + width > room)
-            break;
-        out += char;
-        used += width;
-    }
-    return `${out}${mark}`;
-}
-/**
- * Pad `text` to exactly `cells` columns (or leave it alone when it already
- * measures at least that).
- *
- * NOT `padEnd`: see this file's header. A padded cell is what keeps the next
- * column at a stable offset, which is the whole point of the panel's table.
- */
-export function padCells(text, cells) {
-    const budget = nonNegativeInt(cells);
-    const width = cellWidth(text);
-    if (width >= budget)
-        return text;
-    return `${text}${' '.repeat(budget - width)}`;
-}
-/** `fitCells` then `padCells`: the result ALWAYS measures exactly `cells`. */
-export function alignRightCells(text, cells, ellipsis = '...') {
-    const budget = nonNegativeInt(cells);
-    return padCells(fitCells(text, budget, ellipsis), budget);
-}
-/**
- * Fold `text` into at most `maxRows` lines of at most `cells` columns each.
- *
- * BREAKS AT SPACES, HARD-CUTS ONLY WHEN A SINGLE TOKEN CANNOT FIT: a word that is
- * wider than the column is the one case where an honest over-long token beats a
- * line of nothing, so it is cut rather than pushed to a line that still cannot
- * hold it. The last allowed line, when text remains, carries the `(+N lines)`
- * tail so the reader learns that the section was truncated instead of believing
- * the prose ended mid-sentence.
- *
- * Pure and total: `cells <= 0` or `maxRows <= 0` yields no lines, and the caller
- * decides what an empty section means (the board omits it).
- */
-export function wrapCells(text, cells, maxRows, ellipsis = '...') {
-    const width = nonNegativeInt(cells);
-    const limit = nonNegativeInt(maxRows);
-    const flat = (text ?? '').replace(/\s+/g, ' ').trim();
-    if (width === 0 || limit === 0 || flat.length === 0) {
-        return { lines: [], dropped: flat.length === 0 ? 0 : limit === 0 ? 1 : 0 };
-    }
-    const lines = [];
-    let rest = flat;
-    while (rest.length > 0) {
-        if (cellWidth(rest) <= width) {
-            lines.push(rest);
-            rest = '';
-            break;
-        }
-        const cut = breakCells(rest, width);
-        lines.push(cut.line);
-        rest = cut.rest;
-    }
-    if (lines.length <= limit)
-        return { lines, dropped: 0 };
-    const kept = lines.slice(0, limit);
-    const dropped = lines.length - limit;
-    const tail = `(+${dropped} lines)`;
-    // THE ANNOUNCEMENT IS RESERVED, not appended and then truncated away: a reader who
-    // sees prose stop mid-sentence with no marker reads it as the end of the fact, which
-    // is exactly the wrong conclusion. When the column is too narrow to hold the marker
-    // at all, the line is simply cut - the caller's section is unusable at that width.
-    const tailCells = cellWidth(tail) + 1;
-    const last = kept[limit - 1] ?? '';
-    kept[limit - 1] = tailCells < width
-        ? `${fitCells(last, width - tailCells, ellipsis)} ${tail}`
-        : fitCells(last, width, ellipsis);
-    return { lines: kept, dropped };
-}
-/**
- * The longest prefix of `text` that fits `width` columns, preferring a space.
- *
- * Returns the consumed line and what is left, so the caller's loop is one
- * assignment per iteration and the "one function does one thing" rule holds.
- */
-function breakCells(text, width) {
-    let used = 0;
-    let taken = 0;
-    let lastSpace = -1;
-    for (const char of Array.from(text)) {
-        const charWidth = cellWidth(char);
-        if (used + charWidth > width)
-            break;
-        used += charWidth;
-        taken += char.length;
-        if (char === ' ')
-            lastSpace = taken;
-    }
-    // A single token wider than the column: hard-cut it rather than emit nothing.
-    if (taken === 0) {
-        const first = Array.from(text)[0] ?? '';
-        return { line: fitCells(first, width), rest: text.slice(first.length) };
-    }
-    if (lastSpace > 0) {
-        return { line: text.slice(0, lastSpace).trimEnd(), rest: text.slice(lastSpace).trimStart() };
-    }
-    return { line: text.slice(0, taken), rest: text.slice(taken).trimStart() };
-}

package/dist/ui/layout/document-layout.d.ts

@@ -1,13 +0,0 @@
-export interface DocumentLayoutInput {
-    viewportRows: number;
-    bodyRows: number;
-    footerRows: number;
-}
-export interface DocumentLayout {
-    viewportRows: number;
-    paddingRows: number;
-    contentRows: number;
-    trailingContentRows: number;
-}
-/** Allocate the shared document, filling short sessions before the panels. */
-export declare function buildDocumentLayout(input: DocumentLayoutInput): DocumentLayout;

package/dist/ui/layout/document-layout.js

@@ -1,10 +0,0 @@
-/** Allocate the shared document, filling short sessions before the panels. */
-export function buildDocumentLayout(input) {
-    const count = (n) => Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
-    const viewportRows = count(input.viewportRows);
-    const body = count(input.bodyRows);
-    const footer = count(input.footerRows);
-    const paddingRows = Math.max(0, viewportRows - body - footer);
-    return { viewportRows, paddingRows, contentRows: body + paddingRows + footer,
-        trailingContentRows: paddingRows + footer };
-}

package/dist/ui/layout/follow-state.d.ts

@@ -1,138 +0,0 @@
-/**
- * Follow rules for the self-drawn viewport (tui-selection-and-scroll-follow
- * §4.3). PURE, React-free, unit-tested — the shape `scroll.ts`,
- * `virtual-window.ts` and `frame-differ.ts` all already use.
- *
- * It lives here rather than inside `ScrollViewport` because
- * `ink-testing-library`'s stdout stub reports no height, so a MOUNTED viewport
- * measures `content === viewport`, `overflowLines === 0`, and neither rule below
- * ever engages (`__tests__/render-at-width.ts`, and `transcript-virtual.test.tsx`
- * records the same limitation and the same workaround). A state machine that can
- * only be exercised through a box the test cannot size is a state machine with
- * no tests (P1-10).
- *
- * ═══════════════════════════════════════════════════════════════════════════
- * NOTHING IN THIS FILE MAY READ A MEASUREMENT (AC-17, and it is a `grep`).
- *
- * The gate is a `grep` for the name of Ink's element-measuring helper returning
- * NOTHING from this file, so that name is deliberately left unspelled here and
- * below, even where writing it would read more directly. A grep a COMMENT can
- * trip is a grep whoever runs it learns to ignore, and then the import it exists
- * to catch walks straight past it — the same reason `glyphs.test.ts` strips
- * comments before judging a line.
- *
- * The transcript's MEASURED CONTENT HEIGHT — what `ScrollViewport` reads out of
- * Ink's layout for the inner box — is the height of everything the transcript is
- * currently drawing, and FOUR different things move it — only one of which is
- * "the agent produced output":
- *
- *   1. rows appended at the tail                        <- Rule A must react
- *   2. an entry ABOVE the reading position changing     <- must NOT move
- *      height (Ctrl+T, Ctrl+O, a first real measurement
- *      of an entry that stood on an estimate)
- *   3. the scroll horizon dropping entries off the      <- must NOT move
- *      FRONT (`Transcript.tsx`, `entries.slice(-size)`)
- *   4. a re-wrap after a resize                         <- must NOT move
- *
- * For (2) and (3) `virtual-window.ts`'s invariant V-4 is explicit: counting the
- * offset FROM THE BOTTOM makes an above-the-viewport height change
- * self-compensating, and that is what buys virtualisation its "no
- * scroll-anchoring compensation pass required". Reacting to total content growth
- * would make Rule A that compensation pass, applied to changes that never needed
- * compensating — and it would additionally make (3) look like new output and arm
- * the idle timer on a transcript that produced nothing, the exact failure G6
- * exists to prevent.
- *
- * There is a second, sharper reason. `selectWindow` TAKES `offset` AS AN INPUT,
- * so the mounted set — and therefore which entries are measured rather than
- * estimated — is a function of the offset. An offset that is in turn a function
- * of the measured height closes a loop: offset -> mounted set -> measured
- * heights -> content height -> offset. The loop is broken by the INPUT rather
- * than by a convergence argument: `advanceTailRows` reads the height table and
- * never the geometry context (P0-1 / D-13).
- * ═══════════════════════════════════════════════════════════════════════════
- */
-export interface FollowInput {
-    /** Current RENDERED (already clamped) offset — see the caller's P1-9 note. */
-    offset: number;
-    overflowLines: number;
-    /** Signed: rows appended at (or removed from) the tail since the last frame. */
-    tailDelta: number;
-    layoutTailDelta?: number;
-    /** True while a selection drag holds the viewport (§4.4). */
-    hold: boolean;
-    newLinesWhilePaused: number;
-}
-export interface FollowOutput {
-    offset: number;
-    newLinesWhilePaused: number;
-}
-/**
- * Rule A. When rows are appended AT THE TAIL while the user is not pinned to the
- * bottom, grow the offset by the same amount: `shiftUp = overflowLines - offset`
- * is then constant and the rows on screen do not move.
- *
- * SIGNED, NOT GROWTH-ONLY (I-7). A tail SHRINK is rows that no longer exist
- * below the reading position, so shrinking the offset by the same amount is what
- * keeps the screen still — and it is self-correcting when the source of the
- * delta was an upper-bound height estimate that a later measurement brings down
- * (`estimateEntryRows` is deliberately an upper bound). An unsigned rule
- * over-counts once and never finds its way back.
- */
-export declare function reduceFollow(input: FollowInput): FollowOutput;
-export interface ResumeInput {
-    /** `scrollResumeMs`; `0` (or anything non-finite) disables auto-resume. */
-    resumeMs: number;
-    offset: number;
-    newLinesWhilePaused: number;
-    hold: boolean;
-}
-/**
- * Rule B's three conditions, and they are three rather than one on purpose:
- *
- *  1. `offset > 0`   — there is somewhere to return FROM;
- *  2. `newLines > 0` — something arrived that is worth returning TO. THIS IS
- *     G6: a user reading a FINISHED transcript is never yanked to the bottom,
- *     which is the new bug that a timing-only rule would ship wearing the fix's
- *     clothes (D-3);
- *  3. `!hold`        — no selection drag is in progress (§4.4).
- *
- * AC-9 rides on the first line: with `scrollResumeMs: 0` this returns `false`
- * before anything else is considered, so no timer is ever created.
- */
-export declare function shouldArmResume(input: ResumeInput): boolean;
-/**
- * What the transcript publishes through a ref written during render.
- *
- * `lastHeight` is not decoration: §4.3.1a defines the per-frame delta as "heights
- * of entries after the previously-last entry PLUS the delta of that entry's own
- * height (a streaming entry grows in place)", and the second term cannot be
- * computed without remembering what that height was.
- */
-export interface TailState {
-    /** Monotonic-ish cumulative count of rows produced at the tail. Signed deltas. */
-    rows: number;
-    /** Identity anchor — the last entry's id when this state was written. */
-    lastId: string | null;
-    /** That entry's height when this state was written. */
-    lastHeight: number;
-}
-export interface TailSink {
-    current: TailState;
-}
-export declare function emptyTailState(): TailState;
-/**
- * Advance the tail counter by one frame.
- *
- * `ids` are the entries the transcript is drawing, in order; `heightOf(index)`
- * is the transcript's own per-entry height table (measured where it exists, an
- * upper-bound estimate where it does not). NO GEOMETRY IS READ HERE, which is
- * what breaks P0-1's loop by construction.
- *
- * RE-ANCHORING CONTRIBUTES ZERO (R-11). When the scroll horizon drops the entry
- * this counter was anchored on, the anchor is simply moved to the new last entry
- * and the frame contributes a delta of 0. Losing one frame of anchoring is a row
- * of drift at worst; treating a FRONT-DROP as tail motion is a visible jump, and
- * an unbounded one.
- */
-export declare function advanceTailRows(prev: TailState, ids: readonly string[], heightOf: (index: number) => number): TailState;

package/dist/ui/layout/follow-state.js

@@ -1,148 +0,0 @@
-/**
- * Follow rules for the self-drawn viewport (tui-selection-and-scroll-follow
- * §4.3). PURE, React-free, unit-tested — the shape `scroll.ts`,
- * `virtual-window.ts` and `frame-differ.ts` all already use.
- *
- * It lives here rather than inside `ScrollViewport` because
- * `ink-testing-library`'s stdout stub reports no height, so a MOUNTED viewport
- * measures `content === viewport`, `overflowLines === 0`, and neither rule below
- * ever engages (`__tests__/render-at-width.ts`, and `transcript-virtual.test.tsx`
- * records the same limitation and the same workaround). A state machine that can
- * only be exercised through a box the test cannot size is a state machine with
- * no tests (P1-10).
- *
- * ═══════════════════════════════════════════════════════════════════════════
- * NOTHING IN THIS FILE MAY READ A MEASUREMENT (AC-17, and it is a `grep`).
- *
- * The gate is a `grep` for the name of Ink's element-measuring helper returning
- * NOTHING from this file, so that name is deliberately left unspelled here and
- * below, even where writing it would read more directly. A grep a COMMENT can
- * trip is a grep whoever runs it learns to ignore, and then the import it exists
- * to catch walks straight past it — the same reason `glyphs.test.ts` strips
- * comments before judging a line.
- *
- * The transcript's MEASURED CONTENT HEIGHT — what `ScrollViewport` reads out of
- * Ink's layout for the inner box — is the height of everything the transcript is
- * currently drawing, and FOUR different things move it — only one of which is
- * "the agent produced output":
- *
- *   1. rows appended at the tail                        <- Rule A must react
- *   2. an entry ABOVE the reading position changing     <- must NOT move
- *      height (Ctrl+T, Ctrl+O, a first real measurement
- *      of an entry that stood on an estimate)
- *   3. the scroll horizon dropping entries off the      <- must NOT move
- *      FRONT (`Transcript.tsx`, `entries.slice(-size)`)
- *   4. a re-wrap after a resize                         <- must NOT move
- *
- * For (2) and (3) `virtual-window.ts`'s invariant V-4 is explicit: counting the
- * offset FROM THE BOTTOM makes an above-the-viewport height change
- * self-compensating, and that is what buys virtualisation its "no
- * scroll-anchoring compensation pass required". Reacting to total content growth
- * would make Rule A that compensation pass, applied to changes that never needed
- * compensating — and it would additionally make (3) look like new output and arm
- * the idle timer on a transcript that produced nothing, the exact failure G6
- * exists to prevent.
- *
- * There is a second, sharper reason. `selectWindow` TAKES `offset` AS AN INPUT,
- * so the mounted set — and therefore which entries are measured rather than
- * estimated — is a function of the offset. An offset that is in turn a function
- * of the measured height closes a loop: offset -> mounted set -> measured
- * heights -> content height -> offset. The loop is broken by the INPUT rather
- * than by a convergence argument: `advanceTailRows` reads the height table and
- * never the geometry context (P0-1 / D-13).
- * ═══════════════════════════════════════════════════════════════════════════
- */
-import { clampScroll } from './scroll.js';
-/**
- * Rule A. When rows are appended AT THE TAIL while the user is not pinned to the
- * bottom, grow the offset by the same amount: `shiftUp = overflowLines - offset`
- * is then constant and the rows on screen do not move.
- *
- * SIGNED, NOT GROWTH-ONLY (I-7). A tail SHRINK is rows that no longer exist
- * below the reading position, so shrinking the offset by the same amount is what
- * keeps the screen still — and it is self-correcting when the source of the
- * delta was an upper-bound height estimate that a later measurement brings down
- * (`estimateEntryRows` is deliberately an upper bound). An unsigned rule
- * over-counts once and never finds its way back.
- */
-export function reduceFollow(input) {
-    const { offset, overflowLines, tailDelta, hold } = input;
-    // Pinned and not holding: anchoring is free — `offset` stays 0 and the
-    // existing arithmetic keeps showing the tail. `hold` LIFTS the precondition
-    // because a drag that starts while pinned must still freeze the rows under the
-    // pointer (S3), and freezing means the pin becomes an anchor for the duration
-    // of the drag (T-20).
-    if (offset === 0 && !hold)
-        return { offset, newLinesWhilePaused: 0 };
-    const next = clampScroll(offset + tailDelta + (input.layoutTailDelta ?? 0), overflowLines);
-    return {
-        offset: next,
-        // Only real arrivals arm the resume timer, and reaching the bottom by ANY
-        // route resets the count (Rule B condition 2 / G6). Expressing the reset
-        // here is what keeps it one rule rather than two.
-        newLinesWhilePaused: next === 0 ? 0 : Math.max(0, input.newLinesWhilePaused + tailDelta),
-    };
-}
-/**
- * Rule B's three conditions, and they are three rather than one on purpose:
- *
- *  1. `offset > 0`   — there is somewhere to return FROM;
- *  2. `newLines > 0` — something arrived that is worth returning TO. THIS IS
- *     G6: a user reading a FINISHED transcript is never yanked to the bottom,
- *     which is the new bug that a timing-only rule would ship wearing the fix's
- *     clothes (D-3);
- *  3. `!hold`        — no selection drag is in progress (§4.4).
- *
- * AC-9 rides on the first line: with `scrollResumeMs: 0` this returns `false`
- * before anything else is considered, so no timer is ever created.
- */
-export function shouldArmResume(input) {
-    if (!Number.isFinite(input.resumeMs) || input.resumeMs <= 0)
-        return false;
-    if (input.offset <= 0)
-        return false;
-    if (input.newLinesWhilePaused <= 0)
-        return false;
-    if (input.hold)
-        return false;
-    return true;
-}
-export function emptyTailState() {
-    return { rows: 0, lastId: null, lastHeight: 0 };
-}
-/**
- * Advance the tail counter by one frame.
- *
- * `ids` are the entries the transcript is drawing, in order; `heightOf(index)`
- * is the transcript's own per-entry height table (measured where it exists, an
- * upper-bound estimate where it does not). NO GEOMETRY IS READ HERE, which is
- * what breaks P0-1's loop by construction.
- *
- * RE-ANCHORING CONTRIBUTES ZERO (R-11). When the scroll horizon drops the entry
- * this counter was anchored on, the anchor is simply moved to the new last entry
- * and the frame contributes a delta of 0. Losing one frame of anchoring is a row
- * of drift at worst; treating a FRONT-DROP as tail motion is a visible jump, and
- * an unbounded one.
- */
-export function advanceTailRows(prev, ids, heightOf) {
-    if (ids.length === 0)
-        return { rows: prev.rows, lastId: null, lastHeight: 0 };
-    const lastIndex = ids.length - 1;
-    const lastId = ids[lastIndex];
-    const lastHeight = heightOf(lastIndex);
-    if (prev.lastId === null) {
-        // First frame: there is no "before", so there is no delta to attribute.
-        return { rows: prev.rows, lastId, lastHeight };
-    }
-    const anchor = ids.lastIndexOf(prev.lastId);
-    if (anchor === -1) {
-        // The anchor is gone (horizon front-drop, `/clear`, `/reset`, `/resume`).
-        return { rows: prev.rows, lastId, lastHeight };
-    }
-    // The anchor entry may have grown in place (a streaming tail entry), and
-    // everything after it is new. Both terms are signed.
-    let delta = heightOf(anchor) - prev.lastHeight;
-    for (let i = anchor + 1; i <= lastIndex; i += 1)
-        delta += heightOf(i);
-    return { rows: prev.rows + delta, lastId, lastHeight };
-}

package/dist/ui/layout/frame.d.ts

@@ -1,36 +0,0 @@
-/**
- * Frame geometry + render-mode decision (spec §4.1 / §4.2).
- *
- * Two pure functions with zero React dependency so the load-bearing invariant
- * I-1 (`frameHeight(r) < r`) can be pinned by a unit test rather than by hope.
- */
-/** Below this many rows a full-screen frame has no usable viewport left. */
-export declare const MIN_FULLSCREEN_ROWS = 12;
-/** Below this many columns the chrome (composer + status bar) cannot line-wrap sanely. */
-export declare const MIN_FULLSCREEN_COLS = 40;
-/** Used when `stdout.rows` is missing (pipes, test stubs, some PTYs). */
-export declare const FALLBACK_ROWS = 24;
-/** Used when `stdout.columns` is missing. */
-export declare const FALLBACK_COLS = 80;
-/**
- * Frame height. MUST stay strictly below `rows`:
- *  - `>= rows` hits ink.js:121, which drops incremental `eraseLines` updates and
- *    writes `clearTerminal + <all Static history> + output` on EVERY frame —
- *    30×/s under a 33 ms streaming window, with write amplification that grows
- *    monotonically with the session;
- *  - `== rows` lets the trailing '\n' log-update appends scroll the buffer by one
- *    line, so `eraseLines(previousLineCount)` drifts and the frame slowly eats
- *    the content above it.
- * `frame.test.ts` asserts `frameHeight(r) < r` for every r in [1, 200].
- *
- * The lower clamp is 0 — NEVER `MIN_FULLSCREEN_ROWS - 1` (returns 11 for
- * rows ∈ [1, 11], i.e. `>= rows`: precisely the clearTerminal disaster this
- * function exists to prevent) and NEVER 1 either, because `Math.max(1, r - 1)`
- * returns 1 for r = 1 and `1 >= 1` violates the invariant all the same. That
- * range IS reachable: §4.11 keeps the alt-screen and renders a "terminal too
- * small" placeholder when a resize drops below MIN_FULLSCREEN_ROWS, so a user
- * dragging their window down lands in it. The placeholder takes its height from
- * this same function. A 0-height frame renders nothing, which on a 1-row
- * terminal is strictly better than a per-frame full-screen repaint.
- */
-export declare function frameHeight(rows: number | undefined): number;

package/dist/ui/layout/frame.js

@@ -1,39 +0,0 @@
-/**
- * Frame geometry + render-mode decision (spec §4.1 / §4.2).
- *
- * Two pure functions with zero React dependency so the load-bearing invariant
- * I-1 (`frameHeight(r) < r`) can be pinned by a unit test rather than by hope.
- */
-/** Below this many rows a full-screen frame has no usable viewport left. */
-export const MIN_FULLSCREEN_ROWS = 12;
-/** Below this many columns the chrome (composer + status bar) cannot line-wrap sanely. */
-export const MIN_FULLSCREEN_COLS = 40;
-/** Used when `stdout.rows` is missing (pipes, test stubs, some PTYs). */
-export const FALLBACK_ROWS = 24;
-/** Used when `stdout.columns` is missing. */
-export const FALLBACK_COLS = 80;
-/**
- * Frame height. MUST stay strictly below `rows`:
- *  - `>= rows` hits ink.js:121, which drops incremental `eraseLines` updates and
- *    writes `clearTerminal + <all Static history> + output` on EVERY frame —
- *    30×/s under a 33 ms streaming window, with write amplification that grows
- *    monotonically with the session;
- *  - `== rows` lets the trailing '\n' log-update appends scroll the buffer by one
- *    line, so `eraseLines(previousLineCount)` drifts and the frame slowly eats
- *    the content above it.
- * `frame.test.ts` asserts `frameHeight(r) < r` for every r in [1, 200].
- *
- * The lower clamp is 0 — NEVER `MIN_FULLSCREEN_ROWS - 1` (returns 11 for
- * rows ∈ [1, 11], i.e. `>= rows`: precisely the clearTerminal disaster this
- * function exists to prevent) and NEVER 1 either, because `Math.max(1, r - 1)`
- * returns 1 for r = 1 and `1 >= 1` violates the invariant all the same. That
- * range IS reachable: §4.11 keeps the alt-screen and renders a "terminal too
- * small" placeholder when a resize drops below MIN_FULLSCREEN_ROWS, so a user
- * dragging their window down lands in it. The placeholder takes its height from
- * this same function. A 0-height frame renders nothing, which on a 1-row
- * terminal is strictly better than a per-frame full-screen repaint.
- */
-export function frameHeight(rows) {
-    const r = rows && rows > 0 ? rows : FALLBACK_ROWS;
-    return Math.max(0, r - 1);
-}

package/dist/ui/layout/governance-board.d.ts

@@ -1,121 +0,0 @@
-/**
- * The `/gov board` overlay's model and geometry (governance-mode section 10.5): the tab
- * model, the data adapters, the row builders and the scroll arithmetic - every decision
- * the overlay makes, in pure code.
- *
- * Pure and total: no Ink, no clock (`now` is not even needed: rows carry sequence
- * numbers, not times), no I/O. ASCII ONLY.
- *
- * TWO DATA SOURCES, ONE SHAPE. The live `GovernanceSnapshot` knows the roster and the
- * ticker; the work-package matrix, the full ledger and the claims live in `RunState` /
- * `LedgerState`. `GovernanceBoardData` is the UI's own flat projection of all of it, with
- * two builders: `boardDataFromSnapshot` (what the renderer always has) and
- * `boardDataFromRun` (what the wiring can supply). A board built from the snapshot alone
- * still reads correctly - the tabs it cannot fill say so instead of going blank.
- *
- * EVERY ROW IS ONE TERMINAL ROW. Rows are `Segment[]` rendered `wrap="truncate"`, so
- * scrolling is arithmetic on a list length (`sliceWindow`), never a re-measure.
- */
-import type { GovernanceSnapshot, LedgerState, RunState, WorkPackage } from '../../governance/types.js';
-import type { Glyphs } from '../glyphs.js';
-import { type Segment } from '../governance-status.js';
-export type BoardTab = 'roster' | 'work' | 'ledger' | 'claims';
-export declare const BOARD_TABS: readonly BoardTab[];
-/** Terminals narrower than this get the single-column form with a `1/4` pager. */
-export declare const BOARD_NARROW_COLS = 80;
-/** Recent ledger lines shown under each identity on the roster tab (spec 10.5). */
-export declare const BOARD_RECENT_PER_AGENT = 5;
-/** Ledger rows kept in the projection, newest first. */
-export declare const BOARD_LEDGER_MAX = 200;
-/** The tab `delta` steps away, wrapping at both ends. */
-export declare function stepTab(tab: BoardTab, delta: number): BoardTab;
-export declare function tabIndex(tab: BoardTab): number;
-export interface BoardLedgerRow {
-    seq: number;
-    agentId: string;
-    code: string;
-    delta: number;
-    provisional: boolean;
-    /** `engine` / `inspector:insp`; '' when the source does not say. */
-    by: string;
-    reason: string;
-    evidence: string;
-    capped: boolean;
-}
-export interface BoardWorkPackage {
-    id: string;
-    title: string;
-    status: WorkPackage['status'];
-    reworkCount: number;
-    assignee: string;
-    reviewer: string;
-    tester: string;
-    fileCount: number;
-    blockedAt: string;
-}
-export interface BoardClaimRow {
-    id: string;
-    kind: 'claim' | 'escalation';
-    status: string;
-    /** `missed_by_review`, `wp_rework_cap`, ... */
-    detail: string;
-    /** Who is involved: `dev1 -> rev2` for a claim, the WP / phase for an escalation. */
-    subject: string;
-    text: string;
-}
-export interface GovernanceBoardData {
-    snapshot: GovernanceSnapshot;
-    workPackages: BoardWorkPackage[];
-    ledger: BoardLedgerRow[];
-    claims: BoardClaimRow[];
-    /** Absolute path of `board.md`, for the `e` key; null when unknown. */
-    boardPath: string | null;
-}
-/** What the renderer always has: the live snapshot. WPs and claims stay empty. */
-export declare function boardDataFromSnapshot(snapshot: GovernanceSnapshot, boardPath?: string | null): GovernanceBoardData;
-export interface BoardDataInput {
-    snapshot: GovernanceSnapshot;
-    run: RunState;
-    ledger: LedgerState;
-    boardPath?: string | null;
-}
-/** The full projection, for a wiring that can read the run and the ledger. */
-export declare function boardDataFromRun(input: BoardDataInput): GovernanceBoardData;
-export interface BoardLine {
-    key: string;
-    segments: Segment[];
-}
-export interface BoardTabStrip {
-    segments: Segment[];
-    /** `1/4` in the narrow form, `''` in the wide one. */
-    pager: string;
-}
-export declare function buildTabStrip(tab: BoardTab, data: GovernanceBoardData, narrow: boolean, glyphs: Glyphs): BoardTabStrip;
-export interface GovernanceBoardInput {
-    /** Overlay CONTENT width (the frame's chrome already subtracted). */
-    cols: number;
-    tab: BoardTab;
-    data: GovernanceBoardData | null;
-    glyphs: Glyphs;
-}
-export interface GovernanceBoardLayout {
-    narrow: boolean;
-    tabStrip: BoardTabStrip;
-    /** Every row of the active tab; the overlay windows them. */
-    lines: BoardLine[];
-}
-export declare function buildGovernanceBoardLayout(input: GovernanceBoardInput): GovernanceBoardLayout;
-/** Body rows left for content once the tab strip has taken one of the frame's rows. */
-export declare function boardBodyRows(frameBodyRows: number): number;
-export interface BoardWindow {
-    start: number;
-    visible: number;
-    total: number;
-    /** The offset after clamping: feed it back so the owner's counter cannot run away. */
-    clamped: number;
-}
-export declare function boardWindow(total: number, offset: number, height: number): BoardWindow;
-/** Position text for the footer, e.g. `3-14/40`; '' when everything fits. */
-export declare function boardPosition(window: BoardWindow, glyphs: Glyphs): string;
-/** Footer hint, shortened to the width the frame can print on one row. */
-export declare function boardHint(cols: number, glyphs: Glyphs): string;