@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/ui/layout/governance-roster.js

@@ -1,275 +0,0 @@
-/**
- * Roster geometry and cell text for the legion panel (governance-mode section 10.3).
- *
- * Pure and total: no Ink, no clock, no terminal. ASCII ONLY.
- *
- * WHY COMPUTED FIXED-WIDTH COLUMNS. Same lesson as `team-row.ts`, whose header records
- * it at length: a fixed-height parent makes Yoga size a flex column to its widest CHILD,
- * so a row placed by `flexGrow` stops short of the terminal and the cells to its right
- * lose their absolute offsets. Every column below therefore has a COMPUTED integer width
- * and exactly ONE column is elastic; it sits between the fixed cluster on its left and
- * the fixed `delta` cell on its right, so the score change always lands in the row's
- * last column whatever the activity text says.
- *
- * `columnPlan` is TOTAL: for any width (including 0 and 400) the widths never sum past
- * the width it was given. `governance-panel-layout.test.ts` runs it for every width.
- */
-import { statusMarkerCell, statusMarkerWidth } from '../team-status.js';
-import { GAUGE_CELLS, deltaCell, gaugeFilledCells, govChildStatus, labelTag, scoreText, scoreToneKey, segment, statusTone, } from '../governance-status.js';
-import { NOT_SCORED, ROLE_LABEL, STATE_WORD, WORKING_VERB, replacedByText, } from '../governance-copy.js';
-import { cellWidth, fitCells } from './cells.js';
-/** The elastic column keeps at least this many columns, else it is dropped (activity) or kept (wp). */
-const ELASTIC_MIN_CELLS = { activity: 12, wp: 6 };
-/** One leading margin column, drawn by the component. */
-export const PANEL_MARGIN_CELLS = 1;
-function columnSpecs(tier, markerCells) {
-    const marker = { key: 'marker', width: markerCells };
-    const delta = { key: 'delta', width: 7, align: 'right', drop: 2 };
-    switch (tier) {
-        case 'full':
-            return [
-                marker,
-                { key: 'id', width: 8 },
-                { key: 'role', width: 6, drop: 3 },
-                { key: 'state', width: 12 },
-                { key: 'gauge', width: GAUGE_CELLS + 1, drop: 5 },
-                { key: 'score', width: 5, align: 'right' },
-                { key: 'prov', width: 7, drop: 4 },
-                { key: 'tag', width: 8, drop: 6 },
-                { key: 'wp', width: 11 },
-                { key: 'activity', width: 0, elastic: true },
-                delta,
-            ];
-        case 'standard':
-            return [
-                marker,
-                { key: 'id', width: 8 },
-                { key: 'role', width: 6, drop: 3 },
-                { key: 'state', width: 12 },
-                { key: 'gauge', width: GAUGE_CELLS + 1, drop: 5 },
-                { key: 'score', width: 5, align: 'right' },
-                { key: 'prov', width: 7, drop: 4 },
-                { key: 'tag', width: 8, drop: 6 },
-                { key: 'wp', width: 0, elastic: true },
-                delta,
-            ];
-        default:
-            return [
-                marker,
-                { key: 'id', width: 8 },
-                { key: 'state', width: 12, drop: 3 },
-                { key: 'score', width: 5, align: 'right' },
-                { key: 'wp', width: 0, elastic: true },
-                delta,
-            ];
-    }
-}
-function fixedSum(specs) {
-    return specs.reduce((sum, spec) => sum + (spec.elastic ? 0 : spec.width), 0);
-}
-/** The column that gives way first: the highest `drop` rank, or -1 when none can. */
-function dropVictim(specs) {
-    let victim = -1;
-    let rank = 0;
-    specs.forEach((spec, index) => {
-        if (spec.drop !== undefined && spec.drop > rank) {
-            rank = spec.drop;
-            victim = index;
-        }
-    });
-    return victim;
-}
-/** Last-resort squeeze so the sum NEVER exceeds `inner`, from the right edge inward. */
-function squeeze(columns, inner) {
-    let over = columns.reduce((sum, column) => sum + column.width, 0) - inner;
-    for (let index = columns.length - 1; index >= 0 && over > 0; index -= 1) {
-        const column = columns[index];
-        const cut = Math.min(column.width, over);
-        column.width -= cut;
-        over -= cut;
-    }
-}
-/**
- * Give the activity column up and make the work-package cell the elastic one, which turns
- * a `full` row into a `standard` one without losing the single-elastic-column invariant.
- */
-function promoteWorkPackage(specs) {
-    return specs
-        .filter((spec) => spec.key !== 'activity')
-        .map((spec) => (spec.key === 'wp' ? { key: 'wp', width: 0, elastic: true } : spec));
-}
-/**
- * The row's columns for a tier at `inner` columns (the terminal width minus the margin).
- *
- * THE DROP LADDER IS THE SPECIFICATION, in the order the cells give way: the activity
- * text first (the only column whose loss costs nothing structural - the work-package cell
- * becomes the elastic one), then the tag, gauge, provisional, role and delta cells. The
- * elastic column keeps at least its floor; when even the fixed cluster does not fit,
- * `squeeze` trims from the right so the sum stays inside `inner` for any input.
- */
-export function columnPlan(tier, inner, markerCells) {
-    const width = Number.isFinite(inner) ? Math.max(0, Math.floor(inner)) : 0;
-    let specs = columnSpecs(tier, markerCells);
-    const floorOf = (spec) => spec?.key === 'activity' ? ELASTIC_MIN_CELLS.activity : ELASTIC_MIN_CELLS.wp;
-    for (;;) {
-        const elastic = specs.find((spec) => spec.elastic === true);
-        if (fixedSum(specs) + floorOf(elastic) <= width)
-            break;
-        if (elastic?.key === 'activity') {
-            specs = promoteWorkPackage(specs);
-            continue;
-        }
-        const victim = dropVictim(specs);
-        if (victim < 0)
-            break;
-        specs = specs.filter((_, index) => index !== victim);
-    }
-    const remaining = Math.max(0, width - fixedSum(specs));
-    const columns = specs.map((spec) => ({
-        key: spec.key,
-        width: spec.elastic ? remaining : spec.width,
-        elastic: spec.elastic === true,
-        align: spec.align ?? 'left',
-    }));
-    squeeze(columns, width);
-    return columns;
-}
-export function columnsWidth(columns) {
-    return columns.reduce((sum, column) => sum + column.width, 0);
-}
-const BLANK_TONE = 'muted';
-function textCell(column, text, tone, ellipsis, bold = false) {
-    const clipped = column.width === 0 ? '' : fitCells(text, column.width, ellipsis);
-    return {
-        key: column.key,
-        width: column.width,
-        elastic: column.elastic,
-        align: column.align,
-        segments: clipped === '' ? [] : [segment(clipped, tone, bold)],
-    };
-}
-function leading(text) {
-    return text === '' ? '' : ` ${text}`;
-}
-/** `not scored` replaces the gauge for the inspector (spec 5.1: never scored). */
-function gaugeCell(column, row, glyphs) {
-    if (row.confirmed === null)
-        return textCell(column, NOT_SCORED, 'muted', glyphs.ellipsis);
-    const filled = gaugeFilledCells(row.confirmed);
-    const bar = [
-        segment(glyphs.gaugeFull.repeat(filled), scoreToneKey(row.label)),
-        segment(glyphs.gaugeEmpty.repeat(GAUGE_CELLS - filled), 'border'),
-    ].filter((part) => part.text !== '');
-    return {
-        key: column.key,
-        width: column.width,
-        elastic: false,
-        align: 'left',
-        segments: bar,
-    };
-}
-function stateText(row) {
-    return row.state === 'working' ? WORKING_VERB[row.role] : STATE_WORD[row.state];
-}
-function rightAligned(column, text) {
-    return ' '.repeat(Math.max(0, column.width - cellWidth(text))) + text;
-}
-function scoreCell(column, row, ctx) {
-    const ell = ctx.glyphs.ellipsis;
-    if (row.confirmed === null)
-        return textCell(column, '', BLANK_TONE, ell);
-    const text = rightAligned(column, scoreText(row.confirmed));
-    return textCell(column, text, scoreToneKey(row.label), ell);
-}
-function deltaColumnCell(column, row, ctx) {
-    const delta = deltaCell(row, ctx.now, ctx.reducedMotion);
-    const text = delta.text === '' ? '' : rightAligned(column, delta.text);
-    return textCell(column, text, delta.tone, ctx.glyphs.ellipsis, delta.bold);
-}
-/** One builder per column: a table, so adding a column cannot raise a function's complexity. */
-const CELL_BUILDERS = {
-    marker: (column, row, ctx) => {
-        const status = govChildStatus(row.state);
-        const text = ` ${statusMarkerCell(status, ctx.glyphs)} `;
-        return textCell(column, text, statusTone(status), ctx.glyphs.ellipsis);
-    },
-    id: (column, row, ctx) => textCell(column, row.id, 'primary', ctx.glyphs.ellipsis),
-    role: (column, row, ctx) => textCell(column, ROLE_LABEL[row.role], 'muted', ctx.glyphs.ellipsis),
-    state: (column, row, ctx) => {
-        const tone = statusTone(govChildStatus(row.state));
-        return textCell(column, stateText(row), tone, ctx.glyphs.ellipsis);
-    },
-    gauge: (column, row, ctx) => gaugeCell(column, row, ctx.glyphs),
-    score: scoreCell,
-    prov: (column, row, ctx) => {
-        const text = row.provisional > 0 ? leading(`+${row.provisional}P`) : '';
-        return textCell(column, text, 'muted', ctx.glyphs.ellipsis);
-    },
-    tag: (column, row, ctx) => {
-        const text = leading(labelTag(row.label));
-        return textCell(column, text, scoreToneKey(row.label), ctx.glyphs.ellipsis, true);
-    },
-    wp: (column, row, ctx) => textCell(column, leading(row.wpId ?? '-'), 'text', ctx.glyphs.ellipsis),
-    activity: (column, row, ctx) => {
-        const text = leading(row.activity.replace(/\s+/g, ' ').trim());
-        return textCell(column, text, 'muted', ctx.glyphs.ellipsis);
-    },
-    delta: deltaColumnCell,
-    note: (column, _row, ctx) => textCell(column, '', BLANK_TONE, ctx.glyphs.ellipsis),
-};
-function cellFor(column, row, ctx) {
-    return CELL_BUILDERS[column.key](column, row, ctx);
-}
-/** Columns a replaced member's one-line note spans. */
-const NOTE_SPAN = new Set(['state', 'gauge', 'score', 'prov', 'tag']);
-/**
- * A replaced member: marker, id and role stay (so the row is recognisable), and one
- * muted note spans the state-through-tag cells. The note NAMES the successor, which is the
- * information the member's vanishing from the panel next phase would otherwise erase.
- */
-function eliminatedCells(columns, row, ctx) {
-    const cells = [];
-    let spanned = 0;
-    let spanColumn = null;
-    const flush = () => {
-        if (spanColumn === null)
-            return;
-        const merged = { ...spanColumn, key: 'note', width: spanned, align: 'left' };
-        const text = ` ${replacedByText(row.replacedBy)}`;
-        cells.push(textCell(merged, text, 'muted', ctx.glyphs.ellipsis));
-        spanColumn = null;
-        spanned = 0;
-    };
-    for (const column of columns) {
-        if (NOTE_SPAN.has(column.key)) {
-            spanColumn ??= column;
-            spanned += column.width;
-            continue;
-        }
-        flush();
-        const cell = cellFor(column, row, ctx);
-        const quiet = column.key === 'id' || column.key === 'role' || column.key === 'marker';
-        cells.push(quiet ? mute(cell) : blank(cell));
-    }
-    flush();
-    return cells;
-}
-function mute(cell) {
-    return { ...cell, segments: cell.segments.map((part) => ({ ...part, tone: 'muted' })) };
-}
-function blank(cell) {
-    return { ...cell, segments: [] };
-}
-/** One roster row's cells, text already clamped to its cell. */
-export function buildRosterLine(input) {
-    const { columns, row, glyphs, now, reducedMotion } = input;
-    const ctx = { glyphs, now, reducedMotion };
-    if (row.state === 'eliminated') {
-        return { key: row.id, kind: 'eliminated', cells: eliminatedCells(columns, row, ctx) };
-    }
-    return { key: row.id, kind: 'agent', cells: columns.map((column) => cellFor(column, row, ctx)) };
-}
-/** The marker cell's width in the current glyph tier: 1 + widest marker + 1. */
-export function markerCells(glyphs) {
-    return 1 + statusMarkerWidth(glyphs) + 1;
-}

package/dist/ui/layout/header-hints.d.ts

@@ -1,90 +0,0 @@
-/**
- * The right-hand hint budget for the header row
- * (tui-shortcut-drawer-and-task-summary §4.2).
- *
- * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
- *
- * THIS FILE USED TO BE A SIX-RUNG LADDER. `^L branch`, `^P prompts`, `^I Index`,
- * `^K switch kit`, `^G more` and the expanded variants competed for a width
- * budget, so what a user saw was not "my shortcuts" but "which clauses happen to
- * fit at this width" - and on an 80-column terminal that was three of six. The
- * requirement replaces the whole idea with ONE entry point (`ctrl+G more`) whose
- * panel lists every shortcut, so the ladder is gone and what remains is a
- * three-state single clause.
- *
- * WHY A PLANNER AND NOT A TERNARY IN THE JSX (R-0-4, unchanged): the header's
- * right side was once one hand-computed width constant, and every later addition
- * to it produced either a clipped hint or a pushed-out word mark with no test
- * able to see it - the only thing lost is trailing characters.
- */
-/**
- * Bounds for the hint budget.
- *
- * WHY THEY LIVE IN THIS FILE (R-21, accepted): `CLAUDE.md`'s general rule is that
- * structural bounds live in the subsystem's `limits.ts`, and `ui/layout/` has none
- * - `budget.ts` keeps `HINT_MIN_ROWS` beside its own module for the same reason.
- */
-export declare const HEADER_HINT_LIMITS: {
-    /**
-     * Cells the LEFT half of the header must keep.
-     *
-     * 24 = the 13-cell word mark plus at least 11 for `provider:model`, the
-     * directory and the key symbol. Lower than `status-layout`'s 34 because the top
-     * row has a brand to lose while the bottom row has a phase that must not
-     * disappear.
-     */
-    readonly minLeftCells: 24;
-    /**
-     * Blank cells between the header's left half and this hint column (defect 12).
-     *
-     * A SEPARATE CONCEPT FROM CLAUSE SPACING: this one separates the two HALVES of
-     * the row, and it is spent out of the same `columns` budget so the row still
-     * spans exactly the terminal width.
-     */
-    readonly separatorCells: 2;
-};
-/**
- * What the right-hand column says. THREE STATES, NO LADDER.
- *
- * `none`      - no overlay: `^G more`, the only shortcut hint the header teaches.
- * `shortcuts` - this panel is open: `^G close`, the key that closes it.
- * `other`     - some other overlay owns the keyboard: `Esc close`, which is true
- *               for every overlay and is the only key that works in all of them.
- */
-export type HeaderPanelState = 'none' | 'shortcuts' | 'other';
-export interface HeaderHintPlan {
-    /** The whole right-hand string, scroll chip included with its trailing spacing. */
-    text: string;
-    /** Total cells of the right column; `Header` sizes the left one from it. */
-    cells: number;
-    /** Cells taken by the scroll chip (0 when there is none). */
-    scrollCells: number;
-}
-/** The verbatim text of each state. Exported so a test can name it instead of guessing. */
-export declare const HEADER_HINTS: Readonly<Record<HeaderPanelState, string>>;
-/**
- * Plan the right-hand hint.
- *
- * NO WIDTH BRANCHING: the clause is always rendered. When the row cannot hold it
- * the LEFT half is what shrinks (to zero) and `overflow="hidden"` keeps that from
- * spilling - the pre-feature behaviour, which is what makes the header safe at 20
- * columns without a ladder. `headerHintFits` below exists only so the threshold
- * is documented and testable, not so the renderer can branch on it.
- */
-export declare function planHeaderHints(input: {
-    columns: number;
-    panel: HeaderPanelState;
-    scrolledLines: number;
-}): HeaderHintPlan;
-/**
- * Whether the row can hold the hint column without squeezing the left half below
- * `minLeftCells`.
- *
- * A FORMULA, NOT A TABLE OF MAGIC NUMBERS: `columns - minLeftCells -
- * separatorCells >= scrollCells + bodyCells`. Substituting the three states gives
- * 32 / 34 / 35 columns with no chip, plus up to 8 more for a saturated `^9999+ `.
- * v1 claimed "any width >= 35", which forgot the chip entirely.
- */
-export declare function headerHintFits(columns: number, panel: HeaderPanelState): boolean;
-/** The narrowest width at which each state fits with no scroll chip. */
-export declare function headerHintThreshold(panel: HeaderPanelState): number;

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

@@ -1,110 +0,0 @@
-/**
- * The right-hand hint budget for the header row
- * (tui-shortcut-drawer-and-task-summary §4.2).
- *
- * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
- *
- * THIS FILE USED TO BE A SIX-RUNG LADDER. `^L branch`, `^P prompts`, `^I Index`,
- * `^K switch kit`, `^G more` and the expanded variants competed for a width
- * budget, so what a user saw was not "my shortcuts" but "which clauses happen to
- * fit at this width" - and on an 80-column terminal that was three of six. The
- * requirement replaces the whole idea with ONE entry point (`ctrl+G more`) whose
- * panel lists every shortcut, so the ladder is gone and what remains is a
- * three-state single clause.
- *
- * WHY A PLANNER AND NOT A TERNARY IN THE JSX (R-0-4, unchanged): the header's
- * right side was once one hand-computed width constant, and every later addition
- * to it produced either a clipped hint or a pushed-out word mark with no test
- * able to see it - the only thing lost is trailing characters.
- */
-/**
- * Bounds for the hint budget.
- *
- * WHY THEY LIVE IN THIS FILE (R-21, accepted): `CLAUDE.md`'s general rule is that
- * structural bounds live in the subsystem's `limits.ts`, and `ui/layout/` has none
- * - `budget.ts` keeps `HINT_MIN_ROWS` beside its own module for the same reason.
- */
-export const HEADER_HINT_LIMITS = {
-    /**
-     * Cells the LEFT half of the header must keep.
-     *
-     * 24 = the 13-cell word mark plus at least 11 for `provider:model`, the
-     * directory and the key symbol. Lower than `status-layout`'s 34 because the top
-     * row has a brand to lose while the bottom row has a phase that must not
-     * disappear.
-     */
-    minLeftCells: 24,
-    /**
-     * Blank cells between the header's left half and this hint column (defect 12).
-     *
-     * A SEPARATE CONCEPT FROM CLAUSE SPACING: this one separates the two HALVES of
-     * the row, and it is spent out of the same `columns` budget so the row still
-     * spans exactly the terminal width.
-     */
-    separatorCells: 2,
-};
-/** The verbatim text of each state. Exported so a test can name it instead of guessing. */
-export const HEADER_HINTS = {
-    none: '^G more',
-    shortcuts: '^G close',
-    other: 'Esc close',
-};
-/** Above this, the chip stops counting and saturates (`^9999+`), as it always has. */
-const SCROLL_CHIP_MAX = 9999;
-/**
- * Plan the right-hand hint.
- *
- * NO WIDTH BRANCHING: the clause is always rendered. When the row cannot hold it
- * the LEFT half is what shrinks (to zero) and `overflow="hidden"` keeps that from
- * spilling - the pre-feature behaviour, which is what makes the header safe at 20
- * columns without a ladder. `headerHintFits` below exists only so the threshold
- * is documented and testable, not so the renderer can branch on it.
- */
-export function planHeaderHints(input) {
-    const columns = normalizeDimension(input.columns, 80);
-    const scrolledLines = Math.max(0, Math.floor(normalizeDimension(input.scrolledLines, 0)));
-    const overlayOpen = input.panel !== 'none';
-    const chip = scrollChip(scrolledLines, overlayOpen);
-    const body = HEADER_HINTS[input.panel] ?? HEADER_HINTS.none;
-    const text = chip.length > 0 ? `${chip}${body}` : body;
-    return { text, cells: text.length, scrollCells: chip.length };
-}
-/**
- * Whether the row can hold the hint column without squeezing the left half below
- * `minLeftCells`.
- *
- * A FORMULA, NOT A TABLE OF MAGIC NUMBERS: `columns - minLeftCells -
- * separatorCells >= scrollCells + bodyCells`. Substituting the three states gives
- * 32 / 34 / 35 columns with no chip, plus up to 8 more for a saturated `^9999+ `.
- * v1 claimed "any width >= 35", which forgot the chip entirely.
- */
-export function headerHintFits(columns, panel) {
-    const cols = normalizeDimension(columns, 80);
-    const plan = planHeaderHints({ columns: cols, panel, scrolledLines: 0 });
-    return cols - HEADER_HINT_LIMITS.minLeftCells - HEADER_HINT_LIMITS.separatorCells
-        >= plan.cells;
-}
-/** The narrowest width at which each state fits with no scroll chip. */
-export function headerHintThreshold(panel) {
-    return HEADER_HINTS[panel].length
-        + HEADER_HINT_LIMITS.minLeftCells
-        + HEADER_HINT_LIMITS.separatorCells;
-}
-/**
- * `^<n>` plus its trailing spacing, or `''`.
- *
- * THE SPACING IS PART OF THE CHIP, not something `Header` adds afterwards: with two
- * sources of spacing a reviewer has to read two files to answer "how wide is the
- * chip". One space while an overlay is open, two otherwise - copied byte for byte
- * from the expression the header already used.
- */
-function scrollChip(scrolledLines, overlayOpen) {
-    if (scrolledLines <= 0)
-        return '';
-    const label = scrolledLines > SCROLL_CHIP_MAX ? `^${SCROLL_CHIP_MAX}+` : `^${scrolledLines}`;
-    return label + (overlayOpen ? ' ' : '  ');
-}
-/** The `budget.ts::dimension()` rule, local because that helper is not exported. */
-function normalizeDimension(value, fallback) {
-    return Number.isFinite(value) && value >= 1 ? Math.floor(value) : fallback;
-}

package/dist/ui/layout/header-left.d.ts

@@ -1,115 +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.
- */
-export declare const HEADER_LEFT_LIMITS: {
-    /** The `AragonAgent` word mark, the same 13 `header-hints.ts` documents. */
-    readonly brandCells: 13;
-    /** Blank cells between two left clauses. */
-    readonly gapCells: 2;
-    /** The has-key symbol (1 cell) plus its gap, always reserved. */
-    readonly keyCells: 3;
-    /** Below this the model clause is dropped rather than rendered as `a...`. */
-    readonly modelMinCells: 8;
-    /** Below this the cwd clause is dropped. */
-    readonly cwdMinCells: 8;
-    /** Below this the summary is dropped instead of rendered as `...`. */
-    readonly 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.
-     */
-    readonly summaryGapCells: 4;
-};
-export interface HeaderLeftPlan {
-    text: {
-        model: string;
-        cwd: string;
-        summary: string;
-    };
-    cells: {
-        model: number;
-        cwd: number;
-        summary: number;
-    };
-    /**
-     * Why the summary cell is empty. `pending` is not a reason: a pending summary
-     * draws nothing at all, so the plan is indistinguishable from `empty` - which
-     * is exactly what removed the v1 layout jitter on the first submit.
-     */
-    summaryReason: 'ok' | 'empty' | 'narrow' | 'disabled';
-}
-export interface HeaderLeftInput {
-    /** Cells the header gives the left half (`columns - hintCells - separatorCells`). */
-    leftCells: number;
-    provider: string;
-    model: string;
-    cwd: string;
-    hasKey: boolean;
-    /** `null` while pending, empty or disabled - the planner never sees a placeholder. */
-    summary: {
-        text: string;
-        tone: 'model' | 'fallback';
-    } | null;
-    summaryEnabled: boolean;
-    ellipsis: string;
-}
-/** `provider:model`, the clause `Header` prints after the word mark. */
-export declare function modelClause(provider: string, model: string): string;
-/** The directory name, falling back to the whole path for a bare root. */
-export declare function cwdClause(cwd: string, basename: (path: string) => string): string;
-/**
- * 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 declare function planHeaderLeft(input: HeaderLeftInput): HeaderLeftPlan;
-/**
- * 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 declare function planHeaderLeftCells(plan: HeaderLeftPlan): number;
-/**
- * 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 declare const HEADER_LEFT_BASELINE: number;