@aragon-agent/cli 0.6.46 → 0.6.48

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

@@ -1,253 +0,0 @@
-import stringWidth from 'string-width';
-import stripAnsi from 'strip-ansi';
-import { formatDuration } from '../../agent/usage.js';
-import { isGovernedModeValue, modeWord } from '../governance-status.js';
-import { interactionCopy as copy } from '../interaction-copy.js';
-export function cleanStatusText(text) {
-    // eslint-disable-next-line no-control-regex
-    return stripAnsi(text).replace(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/g, ' ').trim();
-}
-export function statusField(id, text, tone = 'muted') {
-    const clean = cleanStatusText(text);
-    return { id, text: clean, cells: stringWidth(clean), tone };
-}
-export function statusLinePlan(fields, separator = ' | ') {
-    const separatorCells = stringWidth(separator);
-    return { fields, separator, separatorCells,
-        cells: fields.reduce((sum, item) => sum + item.cells, 0) + Math.max(0, fields.length - 1) * separatorCells };
-}
-export function phaseLabels(input) {
-    if (input.waitingForConfirmation)
-        return copy.confirming;
-    if (input.stopping)
-        return copy.stopping;
-    if (input.compacting)
-        return copy.compacting;
-    if (input.retryActive)
-        return copy.retrying;
-    // A WAIT OUTRANKS THE TOOL NAME (long-task-jobs AC-28): `Running job_wait`
-    // answers "which tool", `Waiting on t3 (up to 30s)` answers "what am I waiting
-    // for and how long may it take", which is the question a user staring at a
-    // quiet terminal actually has. Both forms carry it - the short rung is
-    // truncated by width, not reworded.
-    if (input.wait) {
-        const label = `Waiting on ${cleanStatusText(input.wait.jobId)} ` +
-            `(up to ${Math.max(0, Math.round(input.wait.upToSeconds))}s)`;
-        return [label, label];
-    }
-    if (input.activeTool)
-        return [copy.tool[0], copy.tool[1] + ' ' + cleanStatusText(input.activeTool.name)];
-    if (input.phase === 'idle' && input.runOutcome && input.runOutcome !== 'none')
-        return copy[input.runOutcome];
-    if (input.phase === 'preparing-tool')
-        return copy.preparingTool;
-    return copy[input.phase];
-}
-export function validContext(context) {
-    return context.windowKnown && context.window > 0 &&
-        [context.occupied, context.window, context.pct, context.deltaTokens].every(n => Number.isFinite(n) && n >= 0);
-}
-function contextPercent(context) {
-    if (!validContext(context))
-        return '?';
-    const mark = context.source === 'estimate' || context.deltaTokens > 0 ? '~' : '';
-    return mark + (context.pct > 999 ? '>999' : Math.round(context.pct)) + '%';
-}
-/**
- * The words that ride on the gauge when auto-compaction has given up (C).
- *
- * IT RIDES ON THE GAUGE RATHER THAN OCCUPYING ITS OWN FIELD. "Auto-paused" is the
- * only fact that explains a stuck percentage, so the two belong in one field for
- * the same reason `/context` prints them on adjacent lines. A second field would
- * also be the first thing the width ladder drops, and this is precisely the state
- * that must survive a narrow terminal.
- *
- * `paused` at the tight rungs: the full phrase costs twelve cells the row does
- * not have at rung 3 and beyond, and dropping the fact entirely would be worse
- * than abbreviating it.
- */
-function pausedSuffix(full) {
-    return full ? ' auto-paused' : ' paused';
-}
-export function shortDuration(ms) {
-    if (!Number.isFinite(ms) || ms <= 0)
-        return '0s';
-    const seconds = Math.floor(ms / 1000);
-    if (seconds < 60)
-        return seconds + 's';
-    if (seconds < 3600)
-        return Math.floor(seconds / 60) + 'm' + String(seconds % 60).padStart(2, '0') + 's';
-    if (seconds < 86400)
-        return Math.floor(seconds / 3600) + 'h' + String(Math.floor(seconds / 60) % 60).padStart(2, '0') + 'm';
-    const days = Math.floor(seconds / 86400);
-    return days > 999 ? '>999d' : days + 'd';
-}
-function speedNumber(input) {
-    if (!input.speedKnown || input.phase === 'idle' || input.elapsedMs <= 500
-        || !Number.isFinite(input.tokPerSec) || input.tokPerSec < 0)
-        return '--';
-    const value = input.tokPerSec;
-    if (value > 99e6)
-        return '>99M';
-    if (value >= 999950)
-        return (value / 1e6).toFixed(1) + 'M';
-    if (value > 999)
-        return (value / 1000).toFixed(1) + 'k';
-    return String(Math.round(value));
-}
-function feedbackLabel(input, form) {
-    const feedback = input.feedback;
-    if (!feedback)
-        return undefined;
-    const error = feedback.kind === 'copy-error' || feedback.kind === 'copy-cleanup';
-    if (error && input.escapeAction === 'force-stop') {
-        return form === 'full' ? 'Copy err / Esc force' : form === 'tiny' ? 'E/F' : 'Err/EscF';
-    }
-    if (error && input.escapeAction === 'confirm-stop' && input.interruptPhase === 'armed') {
-        return form === 'full' ? 'Copy err / Esc stop' : form === 'tiny' ? 'E/S' : 'Err/EscS';
-    }
-    const labels = {
-        confirm: ['Awaiting confirmation', 'Ask', 'Ask'], stopping: ['Esc stop', 'EscS', 'EscS'],
-        'force-stop': ['Esc force', 'EscF', 'EscF'], exit: ['^C exit', '^Cexit', '^C'],
-        'clear-input': ['^C clear', '^Cclear', '^C'],
-        copying: ['Copying', 'Copy', 'Copy'], copied: ['Copied', 'Copied', 'Copy'],
-        'copy-sent': ['Copy sent', 'Sent', 'Sent'], 'copy-cleanup': ['Copy cleanup', 'Err', 'Err'],
-        'copy-error': ['Copy err', 'Err', 'Err'], notice: ['Notice', 'Notice', 'Note'],
-    };
-    return labels[feedback.kind][form === 'full' ? 0 : form === 'short' ? 1 : 2];
-}
-/**
- * Kinds that are NOTIFICATIONS, not a phase word (defect 8 / 9).
- *
- * A notification says "something happened". An ACTION kind (`confirm`,
- * `stopping`, `force-stop`, `exit`, `clear-input`, `copy-error`,
- * `copy-cleanup`) says what the NEXT key does - that IS the phase slot's job, so
- * those keep replacing it. Everything in this set gets its own field instead and
- * `phase` is never displaced: `Idle` / `Running` is the one thing this row must
- * always answer, and a notice that lands as a turn ends is exactly when a wrong
- * answer misleads the user about whether the agent is still working.
- */
-const NOTIFICATION_KINDS = new Set([
-    'notice', 'copied', 'copy-sent', 'copying',
-]);
-/**
- * The most cells a notification body may take on the primary row.
- *
- * The row is exactly one row high and measured, so the body is CLIPPED rather
- * than wrapped. 32 cells carries `Theme set to light.` or `Todo panel off.`
- * whole while leaving the phase word, the mode and the context gauge intact; a
- * longer message still has the details row, where it is rendered in full.
- */
-const FEEDBACK_TEXT_CELLS = 32;
-/**
- * Clip `text` to at most `cells` display columns, never splitting a wide glyph.
- *
- * Local rather than `interaction-hints.clipStatusText`: that module already
- * imports THIS one, and a cycle for a five-line guard is not worth it.
- */
-function clipFeedbackText(text, cells) {
-    const clean = cleanStatusText(text);
-    if (stringWidth(clean) <= cells)
-        return clean;
-    let clipped = '';
-    for (const char of clean) {
-        if (stringWidth(clipped + char) > cells)
-            break;
-        clipped += char;
-    }
-    return clipped;
-}
-const thinkingCodes = { off: 'O', minimal: 'N', low: 'L', medium: 'M', high: 'H', xhigh: 'X' };
-/**
- * The mode word for the primary row: full rungs name the mode with
- * `MODE_LABEL`, tight rungs keep only its first letter, and a deferred switch
- * renders `CUR>PENDING` in both tiers. `null` when the caller names no mode at
- * all, so callers and tests that predate the field keep a byte-identical plan.
- * The word must survive every width rung: the border color cannot be the only
- * mode signal the default view carries (plan-mode P1-6).
- */
-function modeFieldText(mode, pendingMode, full) {
-    if (!mode && !pendingMode)
-        return null;
-    const word = (value) => {
-        // `build` / `plan` answer exactly as before; the two governed postures are the only
-        // other values `modeWord` knows (`PG` is the short form of PLAN+GOVERN, since `P` is PLAN).
-        const known = modeWord(value, full);
-        if (known !== undefined)
-            return known;
-        return full ? value.toUpperCase() : (value[0] ?? '?').toUpperCase();
-    };
-    const current = word(mode || 'build');
-    return pendingMode ? `${current}>${word(pendingMode)}` : current;
-}
-/** Every field survives each width rung; only the redraw carrier is outside this plan. */
-export function planPrimaryStatusFields(input) {
-    const columns = Number.isFinite(input.columns) ? Math.floor(input.columns) : 80;
-    // GUARDED LIKE `columns` ABOVE, and for the same reason: `Math.max(0, NaN)`
-    // is `NaN`, which would make every `cells > budget` comparison false and
-    // silently pin this row at its widest rung - the opposite of reserving space.
-    const reserved = typeof input.reserveRight === 'number' && Number.isFinite(input.reserveRight)
-        ? Math.max(0, Math.floor(input.reserveRight))
-        : 0;
-    const budget = Math.max(0, columns - 1 - reserved);
-    const labels = phaseLabels(input);
-    const glyphText = cleanStatusText(input.spinner ?? '-');
-    const glyph = stringWidth(glyphText) === 1 ? glyphText : '-';
-    const code = thinkingCodes[input.thinkingLevel] ?? '?';
-    const pct = contextPercent(input.context);
-    const speed = speedNumber(input);
-    // THE RUN'S OWN URGENCY, and the notification's, are two different things
-    // (defect 9). `tone` keeps today's meaning for an ACTION kind (it colours the
-    // phase word); a notification is painted with its own level and leaves the
-    // phase word to describe the run - a copy error must not make `Idle` red.
-    const tone = input.feedback?.level === 'error' || input.runOutcome === 'failed'
-        ? 'error' : input.feedback?.level === 'warn' || input.waitingForConfirmation || input.stopping ? 'warning' : 'normal';
-    const notification = !!input.feedback && NOTIFICATION_KINDS.has(input.feedback.kind);
-    const phaseTone = notification
-        ? input.runOutcome === 'failed' ? 'error'
-            : input.waitingForConfirmation || input.stopping ? 'warning' : 'normal'
-        : tone;
-    const feedbackTone = input.feedback?.level === 'error' ? 'error'
-        : input.feedback?.level === 'warn' ? 'warning' : 'normal';
-    const build = (rung) => {
-        const full = rung === 0;
-        const form = full ? 'full' : rung >= 4 ? 'tiny' : 'short';
-        // THE BODY IS A FIELD OF ITS OWN (defect 8). The text has been in
-        // `feedback.text` all along; it only ever reached the screen on the SECOND
-        // status row, which is behind Ctrl+G and off by default. Rung 3 and tighter
-        // drop it: the ladder exists to keep the phase word, and a body that only fits
-        // by hiding `Running` would be the original defect back with extra steps.
-        const notice = notification && rung <= 2 && input.feedback
-            ? clipFeedbackText(input.feedback.text, FEEDBACK_TEXT_CELLS) : '';
-        const label = (notification ? undefined : feedbackLabel(input, form))
-            ?? (full ? labels[1] : rung >= 4 ? labels[0].slice(0, 4) : labels[0]);
-        const modeText = modeFieldText(input.mode, input.pendingMode, full);
-        // IMMEDIATELY AFTER `mode`, and kept at EVERY rung: both describe a state
-        // the USER armed, so the row's emphasis budget goes on them and nothing
-        // else (`accent`). It shortens to `T4` instead of disappearing because a
-        // chip that vanishes on a narrow terminal is indistinguishable from a
-        // disarmed session - the one question it exists to answer.
-        const forcedText = input.forcedTeam
-            ? (rung >= 3 ? `T${input.forcedTeam.count}` : `Team ${input.forcedTeam.count}`)
-            : null;
-        return statusLinePlan([
-            statusField('phase', glyph + (rung >= 5 ? '' : ' ') + label, phaseTone),
-            ...(notice ? [statusField('feedback', notice, feedbackTone)] : []),
-            ...(modeText
-                ? [statusField('mode', modeText, isGovernedModeValue(input.mode) || isGovernedModeValue(input.pendingMode) ? 'govern' : 'accent')]
-                : []),
-            ...(forcedText ? [statusField('forcedTeam', forcedText, 'accent')] : []),
-            statusField('context', (full ? 'Context ' : 'C') + pct
-                + (input.compactionPaused === true ? pausedSuffix(full) : '')),
-            statusField('thinking', full ? 'Think ' + (thinkingCodes[input.thinkingLevel] ? input.thinkingLevel : '?')
-                : (rung >= 2 ? '' : 'Th:') + code),
-            statusField('speed', speed + (full ? ' tok/s' : rung >= 3 ? '/s' : 't/s')),
-            statusField('elapsed', full && Number.isFinite(input.elapsedMs) && input.elapsedMs > 0
-                ? formatDuration(input.elapsedMs) : shortDuration(input.elapsedMs)),
-        ], full ? ' | ' : ' ');
-    };
-    let plan = build(0);
-    for (let rung = 1; plan.cells > budget && rung <= 5; rung++)
-        plan = build(rung);
-    return plan;
-}

package/dist/ui/layout/task-summary-cell.d.ts

@@ -1,61 +0,0 @@
-/**
- * The task-summary cell's decisions (tui-shortcut-drawer-and-task-summary §6.3).
- *
- * ASCII ONLY: `src/ui/**` is inside the glyph scanner's scope.
- *
- * WHY THIS IS A SEPARATE MODULE FROM `header-left.ts`: the planner answers "how
- * wide is the cell", this one answers "should there be a cell at all, and what is
- * in it". The second question is the trigger rule (D-7) and it has to be testable
- * without a renderer - `task-summary-app.test.tsx` pins "one call per session" by
- * calling THIS function, not by counting renders.
- *
- * THE TRIGGER IS NARROW ON PURPOSE. A header label is an identity strip, not a
- * live subtitle: refreshing it every turn would flicker, cost money, and teach the
- * user to distrust the one thing on the row that is not a status field.
- */
-/** Why no summary call was started. Every branch is a branch the tests can name. */
-export type TaskSummarySkipReason = 'already-set' | 'no-anchor' | 'not-user-initiated' | 'disabled' | 'pending';
-/**
- * D-7's trigger rule.
- *
- * FIVE INPUTS, ONE ANSWER. `userInitiated` is the second guard on the same fact
- * `submitMessage` already knows (`opts.userInitiated !== false`): an automatic
- * continuation is not a new task, and paying for a label for it would spend the
- * user's money to describe work they did not start.
- */
-export declare function shouldSummarize(input: {
-    anchor: string;
-    hasSummary: boolean;
-    pending: boolean;
-    enabled: boolean;
-    userInitiated: boolean;
-}): {
-    start: true;
-} | {
-    start: false;
-    reason: TaskSummarySkipReason;
-};
-/**
- * The drawer's `Task` section, flattened from the view state so the pure layout
- * module never learns what a `ViewState` is.
- */
-export declare function taskSectionFrom(input: {
-    view: {
-        text: string;
-        tone: 'model' | 'fallback';
-        reason: string | null;
-        by: string;
-        at: number;
-    } | null;
-    pending: boolean;
-    enabled: boolean;
-    now: number;
-}): {
-    text: string | null;
-    tone: 'model' | 'fallback' | null;
-    reason: string | null;
-    by: string;
-    ageMs: number | null;
-    enabled: boolean;
-    pending: boolean;
-};

package/dist/ui/layout/task-summary-cell.js

@@ -1,65 +0,0 @@
-/**
- * The task-summary cell's decisions (tui-shortcut-drawer-and-task-summary §6.3).
- *
- * ASCII ONLY: `src/ui/**` is inside the glyph scanner's scope.
- *
- * WHY THIS IS A SEPARATE MODULE FROM `header-left.ts`: the planner answers "how
- * wide is the cell", this one answers "should there be a cell at all, and what is
- * in it". The second question is the trigger rule (D-7) and it has to be testable
- * without a renderer - `task-summary-app.test.tsx` pins "one call per session" by
- * calling THIS function, not by counting renders.
- *
- * THE TRIGGER IS NARROW ON PURPOSE. A header label is an identity strip, not a
- * live subtitle: refreshing it every turn would flicker, cost money, and teach the
- * user to distrust the one thing on the row that is not a status field.
- */
-/**
- * D-7's trigger rule.
- *
- * FIVE INPUTS, ONE ANSWER. `userInitiated` is the second guard on the same fact
- * `submitMessage` already knows (`opts.userInitiated !== false`): an automatic
- * continuation is not a new task, and paying for a label for it would spend the
- * user's money to describe work they did not start.
- */
-export function shouldSummarize(input) {
-    // ORDER IS THE DOCUMENTED PRECEDENCE: a prompt that is not a task cannot start
-    // one even when everything else says yes, and an OFF feature must report the
-    // switch rather than a downstream reason the user cannot act on.
-    if (!input.enabled)
-        return { start: false, reason: 'disabled' };
-    if (input.anchor.trim().length === 0)
-        return { start: false, reason: 'no-anchor' };
-    if (input.hasSummary)
-        return { start: false, reason: 'already-set' };
-    if (input.pending)
-        return { start: false, reason: 'pending' };
-    // ITS OWN REASON, not `no-anchor`: an automatic continuation HAS an anchor, it is
-    // simply not a new task, and a skip reason a maintainer cannot trust is worse than
-    // no reason at all (review fix RF-3).
-    if (!input.userInitiated)
-        return { start: false, reason: 'not-user-initiated' };
-    return { start: true };
-}
-/**
- * The drawer's `Task` section, flattened from the view state so the pure layout
- * module never learns what a `ViewState` is.
- */
-export function taskSectionFrom(input) {
-    if (input.view === null) {
-        return {
-            text: null, tone: null, reason: null, by: '', ageMs: null,
-            enabled: input.enabled, pending: input.pending,
-        };
-    }
-    return {
-        text: input.view.text,
-        tone: input.view.tone,
-        reason: input.view.reason,
-        by: input.view.by,
-        // The age is computed from the view's own timestamp and the caller's clock,
-        // so the drawer never introduces a second one.
-        ageMs: input.now >= input.view.at ? input.now - input.view.at : null,
-        enabled: input.enabled,
-        pending: input.pending,
-    };
-}

package/dist/ui/layout/team-panel.d.ts

@@ -1,18 +0,0 @@
-import type { SubagentRun, TeamSnapshot } from '../../team/types.js';
-export interface TeamPanelLayout {
-    collapsed: boolean;
-    rowCount: number;
-    visible: SubagentRun[];
-    hiddenTotal: number;
-    hiddenRunning: number;
-}
-export interface TeamPanelLayoutInput {
-    snapshot: TeamSnapshot | null;
-    terminalRows: number;
-    availableRows: number;
-}
-/** Project actual roster rows, preserving three middle rows when expanded.
- * Invalid geometry becomes zero; legacy callers may pass positive Infinity
- * for an unlimited available-row budget. Does not throw or mutate the snapshot.
- */
-export declare function buildTeamPanelLayout(input: TeamPanelLayoutInput): TeamPanelLayout;

package/dist/ui/layout/team-panel.js

@@ -1,25 +0,0 @@
-import { TEAM_LIMITS } from '../../team/limits.js';
-import { selectPanelRows } from '../../team/panel-rows.js';
-import { TODO_LIMITS } from '../../todo/limits.js';
-/** Project actual roster rows, preserving three middle rows when expanded.
- * Invalid geometry becomes zero; legacy callers may pass positive Infinity
- * for an unlimited available-row budget. Does not throw or mutate the snapshot.
- */
-export function buildTeamPanelLayout(input) {
-    const available = input.availableRows === Infinity ? Infinity : nonNegativeInt(input.availableRows);
-    if (!input.snapshot || available < 1) {
-        return { collapsed: true, rowCount: 0, visible: [], hiddenTotal: 0, hiddenRunning: 0 };
-    }
-    const selection = selectPanelRows(input.snapshot.runs, TEAM_LIMITS.panelMaxRows);
-    const natural = 1 + selection.visible.length + Number(selection.hiddenTotal > 0)
-        + Number(Boolean(input.snapshot.lastMessage))
-        // The supervisor status line (subagent-overseer-v2 AC-5) occupies one
-        // row whenever any run carries an intervention badge.
-        + Number(input.snapshot.runs.some((run) => run.lastIntervention !== undefined));
-    const collapsed = nonNegativeInt(input.terminalRows) < TEAM_LIMITS.panelCollapseRows
-        || available - natural < TODO_LIMITS.panelMinRows;
-    return { ...selection, collapsed, rowCount: collapsed ? 1 : natural };
-}
-function nonNegativeInt(value) {
-    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
-}

package/dist/ui/layout/team-row.d.ts

@@ -1,139 +0,0 @@
-/**
- * Panel row geometry — the ONE authority for how a subagent row is measured and
- * what it says (tui-subagent-panel §4.2 / §6.1).
- *
- * WHY THIS FILE EXISTS. The roster used to place its right-hand columns by
- * `flexGrow`, and a fixed-height parent box makes Yoga stretch the column to its
- * widest CHILD instead of to the available width: on a 100-column terminal inside
- * the band slot the row measured 48 (spec §0.1, cases 3/4), so `grep  22.1s` sat
- * hard against the description and the right half of the row was blank. Flex
- * cannot fix that, because the number it needs - "how wide is this terminal" - is
- * not part of the layout it is given. So the widths are COMPUTED here, by a total
- * pure function, and the component only places fixed-width boxes at the offsets
- * this module names.
- *
- * THE FIVE CELLS, in drawing order:
- *
- *     marker(1+status+1) label(8) description(flex) gap(2) activity(n) clock(8)
- *
- * `description` is the ONLY flexible cell, and it is the one that absorbs every
- * width pressure - the same degradation discipline `StatusBar` documents for its
- * left cluster. The two right-hand cells are fixed and `flexShrink={0}`, so their
- * absolute offsets follow from `rowWidth = parentWidth` and the sum of the fixed
- * cells in front of them, and never from how a particular frame allocates slack.
- *
- * ASCII ONLY: `src/ui/**` is inside `glyphs.test.ts`'s static scan.
- *
- * THE ACTIVITY HELPERS LIVE HERE TOO (v2 implementation note, recorded in the
- * spec's "implementation findings"). `teamRowCells` has to compose the activity
- * text with the supervisor badge, which is what `activityWithBadge` already does;
- * leaving those in `TeamPanel.tsx` would make this module and the component
- * import each other. `TeamPanel` therefore RE-EXPORTS every symbol below, so the
- * existing import sites (three test files) keep their import path unchanged.
- */
-import type { OverseerAction, SubagentRun } from '../../team/types.js';
-import type { Glyphs } from '../glyphs.js';
-/** The clock cell: wide enough for `125m07s` (7) with one column of headroom. */
-export declare const TEAM_CLOCK_CELLS = 8;
-/** `run.label.padEnd(8).slice(0,8)` — unchanged from the row this replaces. */
-export declare const TEAM_LABEL_CELLS = 8;
-/** The two spaces in front of the activity cell. */
-export declare const TEAM_GAP_CELLS = 2;
-/**
- * The description column's floor: below this the row is unreadable, so the
- * activity cell gives way instead (`activityDropCols`).
- */
-export declare const TEAM_MIN_DESCRIPTION_CELLS = 12;
-export interface TeamRowGeometry {
-    marker: number;
-    label: number;
-    gap: number;
-    activity: number;
-    clock: number;
-    /** The description column's reserved MINIMUM; the real width comes from flex. */
-    minDescription: number;
-}
-/**
- * How many characters the activity cell may spend at this width.
- *
- * `TEAM_LIMITS.activityChars` is a STORAGE ceiling; a terminal has a COLUMN
- * budget, and the two are not the same number. Below
- * `TEAM_LIMITS.activityDropCols` the cell gives way ENTIRELY (returns 0) rather
- * than shrinking to its 12-character floor: at 40 columns those twelve characters
- * would push the description below its own floor, and "who is doing what" outranks
- * "what they are writing right now" exactly when there is room for one of them.
- * That is a semantic change to a shipped assertion (`activityBudget(40)` used to
- * return 12) and is recorded in the spec's §10 collateral table.
- *
- * `markerCells` defaults to the Unicode tier so the three existing single-argument
- * call sites keep compiling; the panel passes the real tier's width.
- */
-export declare function activityBudget(cols: number, markerCells?: number): number;
-/**
- * The row's cell widths. A TOTAL function: every cell is a non-negative integer
- * and the five of them never sum past `cols`, for any `cols >= 0` and either
- * glyph tier (I-3, `team-row-geometry.test.ts`'s property test).
- *
- * THE LADDER IS THE SPECIFICATION (§4.2.2), in the order the cells give way:
- *   1. a wide enough terminal gets the business budget;
- *   2. below `activityDropCols` the activity cell is 0;
- *   3. description still negative -> the gap goes;
- *   4. still negative -> the label shrinks to `max(3, cols - marker - clock)`;
- *   5. still negative -> the clock shrinks (`cols < marker + 3 + clock`);
- *   6. the residue (a terminal narrower than the marker itself) is clamped so the
- *      sum stays inside `cols` — unreachable on a real device, where native mode
- *      degrades to the placeholder below 40x12, but the function is total because
- *      the property test runs `cols = 1..400`.
- */
-export declare function teamRowGeometry(cols: number, glyphs: Glyphs): TeamRowGeometry;
-/**
- * The clock cell's text: this child's elapsed time, or empty when it never
- * started (a `queued` row has no clock to show, and `0ms` would be a lie).
- */
-export declare function teamClockText(run: SubagentRun, at: number): string;
-/** The past-tense word the supervisor badge and status line render. */
-export declare function interventionWord(action: OverseerAction): string;
-/**
- * The row's supervisor badge (subagent-overseer-v2 AC-5): what the supervisor
- * last did to THIS child and how long ago, e.g. `nudged 2m03s`.
- *
- * `lastIntervention.at` is ABSOLUTE epoch ms (R-P2-3), the same units as
- * `startedAt`, so this is one subtraction - no second clock convention.
- */
-export declare function overseerBadge(run: SubagentRun, at: number): string;
-/**
- * The middle cell: what this child is doing right now, in a few words.
- *
- * Two width policies, answering different questions. `wide` decides WHICH FACT to
- * show - a whole path or its basename, a whole command line or its program name -
- * mirroring `StatusBar`'s `statusCompactCols` degradation rather than inventing a
- * second threshold. `activityBudget(cols)` decides HOW MUCH OF IT FITS, and it is
- * a continuous function of width rather than a threshold, because the failure it
- * prevents - a row wider than the terminal - is continuous.
- */
-export declare function activityLine(run: SubagentRun, cols: number, markerCells?: number): string;
-/**
- * The activity cell WITH the badge composed in (AC-5 / risk table): the badge
- * rides the SAME allocation the prose uses, so a row can never grow past its
- * terminal; on a narrow terminal the badge degrades to the action word alone -
- * the who-acted fact outranks the what-they-are-doing tail exactly when there is
- * room for only one.
- */
-export declare function activityWithBadge(run: SubagentRun, cols: number, at: number, markerCells?: number): string;
-/** The five text fragments of one row, each already clamped to its cell's policy. */
-export interface TeamRowCells {
-    marker: string;
-    label: string;
-    description: string;
-    activity: string;
-    clock: string;
-}
-/**
- * The five text fragments of one row.
- *
- * The description is normalized here rather than in the component because
- * truncation preserves explicit newlines and the band reserves exactly ONE row
- * for a child: a description carrying a newline would make the row two rows tall
- * and every row below it would land one row lower than `band.teamRows` allows.
- */
-export declare function teamRowCells(run: SubagentRun, cols: number, at: number, glyphs: Glyphs): TeamRowCells;