@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/layout/header-left.js

@@ -1,206 +0,0 @@
-/**
- * The header's LEFT half budget (tui-shortcut-drawer-and-task-summary §4.3).
- *
- * ASCII ONLY: `src/ui/**` is inside the glyph scanner's scope.
- *
- * WHY A PLANNER (the same argument `header-hints.ts` makes one file over): the
- * left half used to be a `<Text wrap="truncate">` over four clauses with no
- * clause-level arithmetic anywhere, so the only thing that ever decided what got
- * cut was the terminal. Adding a fifth clause - the task summary - to that shape
- * produces a header where the summary silently eats the directory name on an
- * 80-column terminal and NO ASSERTION WOULD SEE IT, because losing trailing
- * characters is invisible to a snapshot test.
- *
- * THE PRIORITY ORDER IS THE DESIGN: brand, then `provider:model`, then cwd, then
- * the summary, with the key symbol reserved up front. The summary is the only
- * clause that is allowed to disappear entirely - it is the newest and the least
- * load-bearing (D-2) - and it is dropped rather than rendered as `...`, because a
- * cell holding three dots spends eight columns to say nothing.
- */
-import { cellWidth, fitCells } from './cells.js';
-import { TASK_SUMMARY_LIMITS } from '../../fast/limits.js';
-export const HEADER_LEFT_LIMITS = {
-    /** The `AragonAgent` word mark, the same 13 `header-hints.ts` documents. */
-    brandCells: 13,
-    /** Blank cells between two left clauses. */
-    gapCells: 2,
-    /** The has-key symbol (1 cell) plus its gap, always reserved. */
-    keyCells: 3,
-    /** Below this the model clause is dropped rather than rendered as `a...`. */
-    modelMinCells: 8,
-    /** Below this the cwd clause is dropped. */
-    cwdMinCells: 8,
-    /** Below this the summary is dropped instead of rendered as `...`. */
-    summaryMinCells: 8,
-    /**
-     * The separator that belongs to the SUMMARY rather than to the general gap:
-     * two spaces, the mid dot and one space. It is reserved together with the label
-     * so a summary can never be drawn without its dot, or the dot without it.
-     */
-    summaryGapCells: 4,
-};
-/** `provider:model`, the clause `Header` prints after the word mark. */
-export function modelClause(provider, model) {
-    return `${provider}:${model}`;
-}
-/** The directory name, falling back to the whole path for a bare root. */
-export function cwdClause(cwd, basename) {
-    return basename(cwd) || cwd;
-}
-/**
- * Allocate the left half.
- *
- * THE ORDER OF THE FOUR STEPS IS THE PRIORITY (D-2):
- *  1. reserve the word mark, its gap and the key symbol - they are never cut;
- *  2. `provider:model`, down to `modelMinCells`, then dropped;
- *  3. cwd, down to `cwdMinCells`, then dropped;
- *  4. the summary, capped at `TASK_SUMMARY_LIMITS.maxCells`, dropped below
- *     `summaryMinCells` and reported as `narrow`.
- *
- * THE LADDER IS EXPLICIT RATHER THAN GREEDY, and that is a correction to v2's
- * algorithm, which funded the summary out of the reserved budget and could therefore
- * show a label on a row where the model name had already been dropped. Four
- * presence sets are tried from most to least complete; within a set the LAST clause
- * gives way first, each only down to its own minimum. The first set that fits wins.
- *
- * Every returned text already MEASURES its reported width, so `Header` renders
- * cells rather than hoping for them.
- */
-export function planHeaderLeft(input) {
-    const leftCells = Number.isFinite(input.leftCells) ? Math.max(0, Math.floor(input.leftCells)) : 0;
-    const empty = {
-        text: { model: '', cwd: '', summary: '' },
-        cells: { model: 0, cwd: 0, summary: 0 },
-        summaryReason: input.summaryEnabled ? 'empty' : 'disabled',
-    };
-    const gap = HEADER_LEFT_LIMITS.gapCells;
-    // Everything the planner never touches, taken off the top so no later step can
-    // borrow from it.
-    // `keyCells` already contains the gap before the symbol, so this is the whole fixed
-    // cost and every clause below pays its own gap.
-    const budget = leftCells - HEADER_LEFT_LIMITS.brandCells - HEADER_LEFT_LIMITS.keyCells;
-    if (budget <= 0) {
-        return {
-            ...empty,
-            summaryReason: input.summaryEnabled
-                ? (input.summary === null ? 'empty' : 'narrow')
-                : 'disabled',
-        };
-    }
-    const model = modelClause(input.provider, input.model);
-    const summaryText = input.summary?.text ?? '';
-    const wantsSummary = input.summaryEnabled && input.summary !== null;
-    /** Desired width and the floor this clause may be cut to. */
-    const clause = (text, floor) => ({
-        want: cellWidth(text),
-        floor: Math.min(cellWidth(text), floor),
-    });
-    const modelWanted = clause(model, HEADER_LEFT_LIMITS.modelMinCells);
-    const cwdWanted = clause(input.cwd, HEADER_LEFT_LIMITS.cwdMinCells);
-    const summaryWanted = {
-        want: Math.min(cellWidth(summaryText), TASK_SUMMARY_LIMITS.maxCells),
-        // A label is never shown below its minimum: a three-cell label is a fragment,
-        // not a label, and the cell is dropped instead.
-        floor: HEADER_LEFT_LIMITS.summaryMinCells,
-    };
-    const sets = [
-        ['model', 'cwd', ...(wantsSummary ? ['summary'] : [])],
-        ['model', 'cwd'],
-        ['model'],
-        [],
-    ];
-    const wanted = { model: modelWanted, cwd: cwdWanted, summary: summaryWanted };
-    for (const set of sets) {
-        const assigned = fitClauses(set, wanted, budget, gap);
-        if (assigned === null)
-            continue;
-        const modelCells = assigned.model ?? 0;
-        const cwdCells = assigned.cwd ?? 0;
-        const summaryCells = assigned.summary ?? 0;
-        let summaryReason = 'empty';
-        if (!input.summaryEnabled)
-            summaryReason = 'disabled';
-        else if (input.summary === null)
-            summaryReason = 'empty';
-        else if (summaryCells === 0)
-            summaryReason = 'narrow';
-        else
-            summaryReason = 'ok';
-        return {
-            text: {
-                model: modelCells > 0 ? fitCells(model, modelCells, input.ellipsis) : '',
-                cwd: cwdCells > 0 ? fitCells(input.cwd, cwdCells, input.ellipsis) : '',
-                summary: summaryCells > 0 ? fitCells(summaryText, summaryCells, input.ellipsis) : '',
-            },
-            cells: { model: modelCells, cwd: cwdCells, summary: summaryCells },
-            summaryReason,
-        };
-    }
-    return empty;
-}
-/**
- * Fit one presence set into `budget`, cutting from the LAST clause inward.
- *
- * Returns `null` when the set cannot fit even at every clause's floor, which is the
- * signal to try the next (smaller) set. `null` rather than a partial result because
- * "the summary was dropped" and "the summary does not fit" must be the same fact to
- * the caller, and only the set composition may express it.
- */
-function fitClauses(set, wanted, budget, gap) {
-    const widths = { model: 0, cwd: 0, summary: 0 };
-    let cost = 0;
-    for (const key of set) {
-        widths[key] = wanted[key].want;
-        // EVERY CLAUSE PAYS ITS OWN SEPARATOR, including the first: the row renders
-        // `word mark, gap, clause, gap, clause, gap, key`, so a one-clause plan still
-        // spends a gap on each side of that clause.
-        cost += (key === 'summary' ? HEADER_LEFT_LIMITS.summaryGapCells : gap)
-            + wanted[key].want;
-    }
-    let excess = cost - budget;
-    for (let index = set.length - 1; index >= 0 && excess > 0; index -= 1) {
-        const key = set[index];
-        const room = widths[key] - wanted[key].floor;
-        if (room <= 0)
-            continue;
-        const cut = Math.min(room, excess);
-        widths[key] -= cut;
-        excess -= cut;
-    }
-    return excess > 0 ? null : widths;
-}
-/**
- * Cells the plan actually spends, for the row invariant:
- * `brand + gap + model + gap + cwd + gap + summary + key <= leftCells`.
- *
- * Exported so `header-left.test.ts` can assert the inequality against the SAME
- * arithmetic the renderer uses instead of re-deriving it in the test (which is how
- * the two drift apart).
- */
-export function planHeaderLeftCells(plan) {
-    const { gapCells, brandCells, keyCells, summaryGapCells } = HEADER_LEFT_LIMITS;
-    // The word mark and the key symbol are always drawn; every clause pays its own gap.
-    // The gap before the key is INSIDE `keyCells`, so it is counted once here and never
-    // again after a clause - the double count that made a one-clause plan read two cells
-    // wider than it renders.
-    let cells = brandCells + keyCells;
-    if (plan.cells.model > 0)
-        cells += gapCells + plan.cells.model;
-    if (plan.cells.cwd > 0)
-        cells += gapCells + plan.cells.cwd;
-    // The summary's separator carries the dot, so it is wider than the general gap.
-    if (plan.cells.summary > 0)
-        cells += summaryGapCells + plan.cells.summary;
-    return cells;
-}
-/**
- * The fixed cells a plan needs before any clause can appear: the word mark plus the
- * key symbol and its gap.
- *
- * Below this the row does not "spend too much", it simply cannot show a clause - the
- * renderer truncates the overflow and `Header`'s own `wrap="truncate"` keeps that from
- * spilling. Stating it as a constant keeps the invariant in the tests honest:
- * `planHeaderLeftCells(plan) <= max(leftCells, HEADER_LEFT_BASELINE)`.
- */
-export const HEADER_LEFT_BASELINE = HEADER_LEFT_LIMITS.brandCells
-    + HEADER_LEFT_LIMITS.keyCells;

package/dist/ui/layout/invocation-card.d.ts

@@ -1,41 +0,0 @@
-/**
- * Invocation card layout (tui-invocation-cards section 3.7): what a `user` entry that
- * carries an `invocation` says, as pure data. No Ink, no React. ASCII ONLY.
- *
- * THE CARD'S HEIGHT IS A FUNCTION OF ITS DATA AND THE USABLE WIDTH (I-4).
- * `InvocationCard.tsx` renders exactly the rows `invocationCardRows` counts, and both
- * read `INVOCATION_LIMITS` plus the one `invocationInputText` below - an estimate that
- * disagrees with the painter is permanent, because an over-estimated entry is never
- * mounted and so never measured (see `virtual-window.ts`).
- */
-import type { InvocationCard } from '../../agent/invocation-card.js';
-import type { Glyphs } from '../glyphs.js';
-/** Colour slots the component maps onto the theme; kept local so this file needs no `Theme`. */
-export type InvocationTone = 'label' | 'name' | 'muted';
-export interface InvocationSegment {
-    text: string;
-    tone: InvocationTone;
-    bold: boolean;
-}
-/**
- * The header row, already fitted to `usable` columns (RV-10). Narrow terminals drop
- * facts from the right WHOLE before anything else is cut; only when the identity alone
- * is too wide is the name shortened. Ink's `wrap="truncate"` stays on the row as a
- * backstop, but it is never what produces the visible ellipsis.
- */
-export declare function invocationHeaderSegments(card: InvocationCard, glyphs: Glyphs, usable: number): InvocationSegment[];
-/** The text painted for `input`: tabs expanded per line, the same rule `UserEntry` follows. */
-export declare function invocationInputText(card: InvocationCard): string;
-/** Singular/plural for the hidden-characters tail. */
-export declare function invocationHiddenText(card: InvocationCard, glyphs: Glyphs): string;
-/**
- * Rows the card occupies at `usable` columns. `wrappedRows` is injected by the caller
- * (`virtual-window.ts` owns the one wrapping rule) so this file stays import-cycle free.
- */
-export declare function invocationCardRows(card: InvocationCard, usable: number, wrappedRows: (text: string, usable: number) => number): number;
-/**
- * The lines the exit replay / export prints UNDER the command line (section 2.4):
- * a bracketed fact line, and the disclosure note when there is one. Plain ASCII
- * separators - the replay is pasted into issues and must survive any terminal.
- */
-export declare function invocationCardLines(card: InvocationCard): string[];

package/dist/ui/layout/invocation-card.js

@@ -1,91 +0,0 @@
-/**
- * Invocation card layout (tui-invocation-cards section 3.7): what a `user` entry that
- * carries an `invocation` says, as pure data. No Ink, no React. ASCII ONLY.
- *
- * THE CARD'S HEIGHT IS A FUNCTION OF ITS DATA AND THE USABLE WIDTH (I-4).
- * `InvocationCard.tsx` renders exactly the rows `invocationCardRows` counts, and both
- * read `INVOCATION_LIMITS` plus the one `invocationInputText` below - an estimate that
- * disagrees with the painter is permanent, because an over-estimated entry is never
- * mounted and so never measured (see `virtual-window.ts`).
- */
-import { expandTabs } from '../display-tab.js';
-import { cellWidth, fitCells } from './cells.js';
-/** Two spaces between the identity (`skill . pdf-forms`) and the facts. */
-const FACT_GAP = '  ';
-function seg(text, tone, bold = false) {
-    return { text, tone, bold };
-}
-function segmentsWidth(segments) {
-    return segments.reduce((sum, part) => sum + cellWidth(part.text), 0);
-}
-function identitySegments(card, glyphs, name) {
-    const parts = [seg(card.variant, 'label', true)];
-    if (name !== '')
-        parts.push(seg(` ${glyphs.midDot} `, 'muted'), seg(name, 'name', true));
-    return parts;
-}
-function factSegments(facts, glyphs) {
-    if (facts.length === 0)
-        return [];
-    const parts = [seg(FACT_GAP, 'muted')];
-    facts.forEach((fact, index) => {
-        if (index > 0)
-            parts.push(seg(` ${glyphs.midDot} `, 'muted'));
-        parts.push(seg(fact, 'muted'));
-    });
-    return parts;
-}
-/**
- * The header row, already fitted to `usable` columns (RV-10). Narrow terminals drop
- * facts from the right WHOLE before anything else is cut; only when the identity alone
- * is too wide is the name shortened. Ink's `wrap="truncate"` stays on the row as a
- * backstop, but it is never what produces the visible ellipsis.
- */
-export function invocationHeaderSegments(card, glyphs, usable) {
-    const width = Math.max(1, Math.floor(usable));
-    for (let kept = card.facts.length; kept >= 0; kept -= 1) {
-        const candidate = [
-            ...identitySegments(card, glyphs, card.name),
-            ...factSegments(card.facts.slice(0, kept), glyphs),
-        ];
-        if (segmentsWidth(candidate) <= width)
-            return candidate;
-    }
-    const head = identitySegments(card, glyphs, '');
-    const room = width - segmentsWidth(head) - cellWidth(` ${glyphs.midDot} `);
-    if (card.name !== '' && room > 1) {
-        return identitySegments(card, glyphs, fitCells(card.name, room, glyphs.ellipsis));
-    }
-    return [seg(fitCells(card.variant, width, glyphs.ellipsis), 'label', true)];
-}
-/** The text painted for `input`: tabs expanded per line, the same rule `UserEntry` follows. */
-export function invocationInputText(card) {
-    return card.input.split('\n').map((line) => expandTabs(line)).join('\n');
-}
-/** Singular/plural for the hidden-characters tail. */
-export function invocationHiddenText(card, glyphs) {
-    const unit = card.inputHidden === 1 ? 'char' : 'chars';
-    return `${glyphs.ellipsis} +${card.inputHidden} ${unit} not shown`;
-}
-/**
- * Rows the card occupies at `usable` columns. `wrappedRows` is injected by the caller
- * (`virtual-window.ts` owns the one wrapping rule) so this file stays import-cycle free.
- */
-export function invocationCardRows(card, usable, wrappedRows) {
-    const inputRows = card.input === '' ? 0 : wrappedRows(invocationInputText(card), usable);
-    return 1 + inputRows + (card.inputHidden > 0 ? 1 : 0) + (card.note ? 1 : 0);
-}
-const REPLAY_INDENT = '    ';
-/**
- * The lines the exit replay / export prints UNDER the command line (section 2.4):
- * a bracketed fact line, and the disclosure note when there is one. Plain ASCII
- * separators - the replay is pasted into issues and must survive any terminal.
- */
-export function invocationCardLines(card) {
-    const identity = card.name === '' ? card.variant : `${card.variant} ${card.name}`;
-    const detail = card.facts.length === 0 ? identity : `${identity} ${card.facts.join(' - ')}`;
-    const lines = [`${REPLAY_INDENT}[${detail}]`];
-    if (card.note)
-        lines.push(`${REPLAY_INDENT}${card.note}`);
-    return lines;
-}

package/dist/ui/layout/kit-chip.d.ts

@@ -1,50 +0,0 @@
-/**
- * The status bar's kit chip: pure width planning, no JSX
- * (agent-model-kits §4.8 / D-12).
- *
- * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
- *
- * WHY A PLANNER, AND WHY IT IS THE SAME SHAPE AS `session-chip.ts`: the status
- * row is measured cell by cell, and anything appended "just to the right" eats
- * `phase` - the one field a user needs while a run is in flight. The chip
- * therefore competes for the SAME budget as every other field, and the rung that
- * survives is computed rather than hand-tuned.
- *
- * ONE COMPARISON, NOT A THRESHOLD TABLE: `columns - (cells + gap) >=
- * minStatusCells`. The width table in the spec is what that comparison WORKS
- * OUT TO. `minStatusCells` is deliberately the same 34 as the session chip's -
- * both answer "how much room must the left half keep", and two numbers for one
- * question is how a "fit" and a "don't fit" end up disagreeing.
- */
-export declare const KIT_CHIP_LIMITS: {
-    /** Blank cells between the chip and the field run. */
-    readonly gapCells: 2;
-    /** The floor the left half must keep; asserted equal to the session chip's. */
-    readonly minStatusCells: 34;
-    /** Below this the `kit` label is dropped before the name is shortened. */
-    readonly labelMinCols: 72;
-    /** The shortest unique prefix worth showing; below it the chip hides. */
-    readonly minNameChars: 4;
-};
-export interface KitChipPlan {
-    visible: boolean;
-    text: string;
-    cells: number;
-    gap: number;
-}
-export interface KitChipInput {
-    columns: number;
-    /**
-     * The kit in effect, or absent/null when there is none.
-     *
-     * ABSENT IS NOT EMPTY: with no kit the plan is hidden and the row's output is
-     * byte-identical to the pre-feature build (I-9).
-     */
-    kit?: {
-        name: string;
-        modified: boolean;
-        otherNames: readonly string[];
-    } | null | undefined;
-}
-/** Plan the chip for `columns` and this session's kit. */
-export declare function planKitChip(input: KitChipInput): KitChipPlan;

package/dist/ui/layout/kit-chip.js

@@ -1,81 +0,0 @@
-/**
- * The status bar's kit chip: pure width planning, no JSX
- * (agent-model-kits §4.8 / D-12).
- *
- * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
- *
- * WHY A PLANNER, AND WHY IT IS THE SAME SHAPE AS `session-chip.ts`: the status
- * row is measured cell by cell, and anything appended "just to the right" eats
- * `phase` - the one field a user needs while a run is in flight. The chip
- * therefore competes for the SAME budget as every other field, and the rung that
- * survives is computed rather than hand-tuned.
- *
- * ONE COMPARISON, NOT A THRESHOLD TABLE: `columns - (cells + gap) >=
- * minStatusCells`. The width table in the spec is what that comparison WORKS
- * OUT TO. `minStatusCells` is deliberately the same 34 as the session chip's -
- * both answer "how much room must the left half keep", and two numbers for one
- * question is how a "fit" and a "don't fit" end up disagreeing.
- */
-import stringWidth from 'string-width';
-export const KIT_CHIP_LIMITS = {
-    /** Blank cells between the chip and the field run. */
-    gapCells: 2,
-    /** The floor the left half must keep; asserted equal to the session chip's. */
-    minStatusCells: 34,
-    /** Below this the `kit` label is dropped before the name is shortened. */
-    labelMinCols: 72,
-    /** The shortest unique prefix worth showing; below it the chip hides. */
-    minNameChars: 4,
-};
-const HIDDEN = { visible: false, text: '', cells: 0, gap: 0 };
-/** The shortest prefix of `name` that no sibling name also starts with. */
-function uniqueLength(name, others) {
-    const points = [...name];
-    const start = Math.min(KIT_CHIP_LIMITS.minNameChars, points.length);
-    const shared = (length) => {
-        const prefix = points.slice(0, length).join('');
-        return others.some((other) => [...other].slice(0, length).join('') === prefix);
-    };
-    let length = start;
-    while (length < points.length && shared(length))
-        length += 1;
-    return Math.max(length, start);
-}
-/** Plan the chip for `columns` and this session's kit. */
-export function planKitChip(input) {
-    const kit = input.kit;
-    if (!kit)
-        return HIDDEN;
-    const name = kit.name.trim();
-    if (!name)
-        return HIDDEN;
-    const columns = Number.isFinite(input.columns) ? Math.floor(input.columns) : 80;
-    const gap = KIT_CHIP_LIMITS.gapCells;
-    const fits = (text) => columns - (stringWidth(text) + gap) >= KIT_CHIP_LIMITS.minStatusCells;
-    const mark = kit.modified ? '~' : '';
-    const plan = (text) => ({ visible: true, text, cells: stringWidth(text), gap });
-    // Widest rung first, then drop the label, then shorten the name, then hide.
-    // THE ORDER IS THE DECISION: a reader cares WHICH kit is in effect before they
-    // care that it is a kit, so the name is the last thing to go.
-    //
-    // `KIT_CHIP_LIMITS.labelMinCols` NEEDS NO BRANCH: a labelled rung is 45 cells
-    // for a 40-character name, so `fits` already rejects it below ~81 columns. The
-    // constant is the documented intent (labels belong to wide rows), measured
-    // rather than hard-coded into the ladder.
-    const points = [...name];
-    const shortest = uniqueLength(name, kit.otherNames);
-    const rungs = [];
-    if (kit.modified)
-        rungs.push(`kit ${name}~`);
-    rungs.push(`kit ${name}`);
-    if (kit.modified)
-        rungs.push(`${name}~`);
-    rungs.push(name);
-    for (let length = points.length - 1; length >= shortest; length -= 1) {
-        rungs.push(`${points.slice(0, length).join('')}${mark}`);
-    }
-    for (const text of rungs)
-        if (fits(text))
-            return plan(text);
-    return HIDDEN;
-}

package/dist/ui/layout/overlay-window.d.ts

@@ -1,43 +0,0 @@
-/**
- * Overlay windowing (spec §4.4) — pure arithmetic for `OverlayFrame`.
- *
- * Overlays used to be dropped into `<Box overflow="hidden">` with no scrolling
- * and no indication that anything had been cut: `/help` needs 29 rows, a 30-row
- * terminal gave it 15, and everything from `/clear` downward was simply invisible.
- *
- * This does NOT reuse `ScrollViewport`. That component owns its offset in its own
- * state as a deliberate single-source-of-truth decision, so routing an overlay
- * through the same instance would leave the transcript parked at the overlay's
- * offset after closing. Overlay content is finite and already in memory, so
- * slicing an array is both cheaper and free of a second `measureElement` loop.
- */
-export interface OverlayWindow {
-    /** First visible index. */
-    start: number;
-    /** How many rows are visible. */
-    visible: number;
-    total: number;
-    /** The requested offset after clamping — feed this back to keep state sane. */
-    clamped: number;
-}
-/**
- * Slice `total` single-row items to a `height`-row window at `offset`.
- *
- * Guarantees for every input, including negative / absurd offsets and
- * non-finite heights: `0 <= start` and `start + visible <= total` (A-2).
- */
-export declare function sliceWindow(total: number, offset: number, height: number): OverlayWindow;
-/**
- * Visible-row budget for a self-managed (mode B) overlay list — i.e. the `limit`
- * handed to `ink-select-input` in the model picker.
- *
- * A pure function rather than an inline expression because the test stack only
- * returns rendered strings: there is no way to read a child's props back, so the
- * only way to pin this behaviour (A-11) is to test the arithmetic directly.
- *
- * The 5 rows subtracted are the frame's own chrome: title, footer, the top and
- * bottom border, and the frame's `marginTop` — which is spent out of the same
- * budget, so leaving it out pushes the bottom border past the viewport where
- * `overflow: hidden` silently eats it.
- */
-export declare function overlayListLimit(maxRows: number): number;

package/dist/ui/layout/overlay-window.js

@@ -1,51 +0,0 @@
-/**
- * Overlay windowing (spec §4.4) — pure arithmetic for `OverlayFrame`.
- *
- * Overlays used to be dropped into `<Box overflow="hidden">` with no scrolling
- * and no indication that anything had been cut: `/help` needs 29 rows, a 30-row
- * terminal gave it 15, and everything from `/clear` downward was simply invisible.
- *
- * This does NOT reuse `ScrollViewport`. That component owns its offset in its own
- * state as a deliberate single-source-of-truth decision, so routing an overlay
- * through the same instance would leave the transcript parked at the overlay's
- * offset after closing. Overlay content is finite and already in memory, so
- * slicing an array is both cheaper and free of a second `measureElement` loop.
- */
-/**
- * Slice `total` single-row items to a `height`-row window at `offset`.
- *
- * Guarantees for every input, including negative / absurd offsets and
- * non-finite heights: `0 <= start` and `start + visible <= total` (A-2).
- */
-export function sliceWindow(total, offset, height) {
-    const t = Number.isFinite(total) ? Math.max(0, Math.floor(total)) : 0;
-    const h = Number.isFinite(height) ? Math.max(0, Math.floor(height)) : t;
-    const visible = Math.min(t, h);
-    const maxOffset = Math.max(0, t - visible);
-    const raw = Number.isFinite(offset) ? Math.floor(offset) : 0;
-    const clamped = Math.min(maxOffset, Math.max(0, raw));
-    return { start: clamped, visible, total: t, clamped };
-}
-/** Smallest list window worth showing before scrolling stops helping. */
-const MIN_LIST_LIMIT = 3;
-/** Beyond this a picker is a scroll problem, not a list problem. */
-const MAX_LIST_LIMIT = 20;
-/**
- * Visible-row budget for a self-managed (mode B) overlay list — i.e. the `limit`
- * handed to `ink-select-input` in the model picker.
- *
- * A pure function rather than an inline expression because the test stack only
- * returns rendered strings: there is no way to read a child's props back, so the
- * only way to pin this behaviour (A-11) is to test the arithmetic directly.
- *
- * The 5 rows subtracted are the frame's own chrome: title, footer, the top and
- * bottom border, and the frame's `marginTop` — which is spent out of the same
- * budget, so leaving it out pushes the bottom border past the viewport where
- * `overflow: hidden` silently eats it.
- */
-export function overlayListLimit(maxRows) {
-    if (!Number.isFinite(maxRows))
-        return MAX_LIST_LIMIT;
-    const usable = Math.floor(maxRows) - 5;
-    return Math.min(MAX_LIST_LIMIT, Math.max(MIN_LIST_LIMIT, usable));
-}

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

@@ -1,19 +0,0 @@
-import type { PendingSteering } from '../../agent/queued-messages.js';
-export interface QueueLayoutInput {
-    pending: readonly PendingSteering[];
-    columns: number;
-    terminalRows: number;
-    availableRows: number;
-    paused: boolean;
-}
-export interface QueueLayout {
-    rows: number;
-    title: string;
-    items: readonly {
-        queueId: string;
-        label: string;
-    }[];
-    hiddenCount: number;
-}
-/** One allocation drives both footer measurement and rendered rows. */
-export declare function buildQueueLayout(input: QueueLayoutInput): QueueLayout;

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

@@ -1,26 +0,0 @@
-import stringWidth from 'string-width';
-import { queueSummary, truncateSummary } from '../QueueStatusRow.js';
-/** One allocation drives both footer measurement and rendered rows. */
-export function buildQueueLayout(input) {
-    const count = input.pending.length;
-    const limit = Math.max(0, Math.min(input.terminalRows >= 20 ? 4 : 2, Math.floor(input.availableRows)));
-    if (!count || !limit)
-        return { rows: 0, title: '', items: [], hiddenCount: count };
-    const shown = Math.min(count, Math.max(1, limit - 1));
-    const items = input.pending.slice(0, shown).map((item, index) => {
-        const prefix = `${index + 1}. `;
-        const lines = item.text.split(/\r\n|[\r\n]/).length;
-        const suffix = lines > 1 ? ` (+${lines - 1} lines)` : '';
-        return { queueId: item.queueId, label: prefix + truncateSummary(queueSummary(item.text), Math.max(0, input.columns - stringWidth(prefix + suffix)), '...') + suffix };
-    });
-    const hiddenCount = count - items.length;
-    const paused = input.paused ? ' paused' : '';
-    const hidden = hiddenCount ? ` +${hiddenCount} more` : '';
-    const title = `Queue: ${count} pending${paused}${hidden} /queue`;
-    if (limit === 1)
-        return { rows: 1,
-            title: truncateSummary(`Queue ${count} /queue ${items[0].label}`, input.columns, '...'),
-            items, hiddenCount: count - items.length };
-    return { rows: 1 + items.length, title: stringWidth(title) <= input.columns
-            ? title : `Queue ${count} /queue`, items, hiddenCount };
-}

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

@@ -1,7 +0,0 @@
-export declare const TODO_RAIL_MIN_COLS = 14;
-export declare const TODO_RAIL_MAX_COLS = 36;
-export declare const TODO_TRANSCRIPT_MIN_COLS = 62;
-export declare const TODO_RAIL_MIN_TOTAL_COLS: number;
-export declare const TODO_RAIL_INDEX_MIN_COLS = 22;
-/** Return a non-decreasing rail width; invalid or narrow terminals have no rail. */
-export declare function todoRailWidth(cols: number): number;

package/dist/ui/layout/rail.js

@@ -1,16 +0,0 @@
-/** Responsive TODO rail widths, measured in terminal columns including chrome. */
-const RAIL_FRACTION = 0.15;
-export const TODO_RAIL_MIN_COLS = 14;
-export const TODO_RAIL_MAX_COLS = 36;
-export const TODO_TRANSCRIPT_MIN_COLS = 62;
-export const TODO_RAIL_MIN_TOTAL_COLS = TODO_TRANSCRIPT_MIN_COLS + TODO_RAIL_MIN_COLS;
-export const TODO_RAIL_INDEX_MIN_COLS = 22;
-/** Return a non-decreasing rail width; invalid or narrow terminals have no rail. */
-export function todoRailWidth(cols) {
-    if (!Number.isFinite(cols))
-        return 0;
-    const columns = Math.floor(cols);
-    if (columns < TODO_RAIL_MIN_TOTAL_COLS)
-        return 0;
-    return Math.min(TODO_RAIL_MAX_COLS, Math.max(TODO_RAIL_MIN_COLS, Math.round(columns * RAIL_FRACTION)));
-}

package/dist/ui/layout/scroll-indicator.d.ts

@@ -1,27 +0,0 @@
-/**
- * Scroll-thumb geometry (mouse-wheel-region-routing §4.8) — pure, React-free.
- *
- * Wheel scrolling without a position indicator is a half-finished affordance:
- * the user learns THAT they moved but not HOW FAR or how much is left. The
- * status bar's `↑N` answers neither.
- *
- * OFFSET COUNTS FROM THE BOTTOM, exactly as `scroll.ts` documents — `0` is
- * pinned to the newest output and `overflow` is parked at the very top. The
- * rows hidden ABOVE are therefore `overflow - offset`, and that inversion is
- * precisely what gets done by accident, so it is computed here once and named.
- */
-export interface ThumbRange {
-    /** 0-based row of the thumb's first row, within the viewport. */
-    start: number;
-    /** Thumb height in rows; always >= 1 when a range is returned. */
-    size: number;
-}
-/**
- * Where the thumb sits, or `null` when the content fits and there is nothing to
- * indicate.
- *
- * `size` never rounds to zero: a 10-row window over a 5000-row transcript still
- * gets a one-row thumb, because an indicator that vanishes at exactly the
- * moment the transcript is longest is worse than no indicator at all.
- */
-export declare function thumbRange(viewportRows: number, contentRows: number, offsetFromBottom: number, reserveTravel?: boolean): ThumbRange | null;