@aragon-agent/cli 0.6.34 → 0.6.36

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

@@ -49,6 +49,34 @@ export const HEADER_HINT_LIMITS = {
 /** The verbatim clause text (spec 3.8, appendix A). */
 const BRANCH_CLAUSE = { collapsed: '^L branch', expanded: '^L new branch' };
 const INDEX_CLAUSE = { collapsed: '^I Index', expanded: '^I build index' };
+/**
+ * THE KIT CLAUSE HAS NO COLLAPSED FORM (agent-model-kits D-11).
+ *
+ * The requirement says the `ctrl+k` hint appears AFTER `ctrl+G`; the collapsed
+ * row is the narrowest budget in the header, and `^K` is a low-frequency action.
+ * Spending 13 columns of the everyday row on it would push `provider:model`
+ * leftward on every launch for a key pressed twice a session.
+ */
+const KIT_CLAUSE = { expanded: '^K switch kit' };
+/**
+ * THE PROMPT LIBRARY KEY HAS EXACTLY ONE FORM, AND IT IS THE SHORT ONE
+ * (quick-prompt-library D-15).
+ *
+ * `^P` is a REQUIREMENT (the user must be able to see that `ctrl+P` exists), and
+ * the collapsed row is where that requirement is met. The expanded row's job is to
+ * reveal MORE keys than the collapsed one, so inserting a 17-cell
+ * `^P prompt library` before `^I` there would trade `^I` and `^K` away on an
+ * 80-column terminal - a user who pressed `^G` asking for more would be shown less.
+ *
+ * The second thing this constant's position encodes is an explicit REVISION of the
+ * `RV-P1-2` ordering constraint for the COLLAPSED ladder: `^P` sits before `^I`
+ * there, so `^I Index` now appears from 66 columns instead of 54. That is a
+ * deliberate, documented loss: `^I` is a once-per-project action and `^P` is the
+ * entry point this feature is about. The expanded ladder keeps its full existing
+ * order, so `RV-P1-2` still holds there and `^I` never disappears from a row where
+ * it used to fit.
+ */
+const PROMPTS_CLAUSE = '^P prompts';
 const DETAIL_CLAUSE = { collapsed: '^G more', expanded: '^G less' };
 /** L3 gives the key name and nothing else: discoverability at the last width. */
 const BRANCH_KEY_ONLY = '^L';
@@ -60,8 +88,9 @@ const SCROLL_CHIP_MAX = 9999;
 /**
  * Plan the right-hand hints.
  *
- * The four inputs are exactly the props `Header` already receives - the call site
- * does not change, only the arithmetic behind it (spec 3.11 step 5).
+ * The inputs are the props `Header` receives plus the two switches that decide which
+ * clauses exist at all - the call site does not change, only the arithmetic behind it
+ * (spec 3.11 step 5).
  */
 export function planHeaderHints(input) {
     // NORMALISED HERE, NOT TRUSTED (R-14). `Header` defaults to 80, but a test or a
@@ -77,7 +106,7 @@ export function planHeaderHints(input) {
         const detail = input.statusExpanded ? DETAILS_ON : DETAILS_OFF;
         return buildPlan([{ id: 'detail', text: detail }], scrollCells, true);
     }
-    const ladder = ladderFor(input.statusExpanded);
+    const ladder = ladderFor(input.statusExpanded, input.kitHint !== false, input.promptsHint !== false);
     // THE SEPARATOR IS SPENT OUT OF THE SAME ROW (defect 12): left half + gap + this
     // column have to add up to `columns`, so the gap comes off the budget instead of
     // being assumed free.
@@ -94,8 +123,18 @@ export function planHeaderHints(input) {
     // shrinks (to zero), and `overflow="hidden"` keeps that from overflowing.
     return buildPlan(ladder[ladder.length - 1] ?? [], scrollCells, false);
 }
-/** The four rungs, widest first. Built per call because the widths are text-derived. */
-function ladderFor(statusExpanded) {
+/**
+ * The rungs, widest first. Built per call because the widths are text-derived.
+ *
+ * THE EXPANDED ORDER `branch -> index -> kit -> detail` IS A REGRESSION
+ * CONSTRAINT, NOT A PREFERENCE (RV-P1-2). With `kit` AFTER `index`, rungs E2,
+ * E4, E5 and E6 are exactly today's four expanded rungs, so every existing
+ * width assertion for 48-78 columns keeps its old answer and `^I` never
+ * disappears from a row where it used to fit. Putting `^K` first would have cost
+ * `^I` everything from 64 to 78 columns - a permanent loss, paid for a
+ * low-frequency key.
+ */
+function ladderFor(statusExpanded, kitHint, promptsHint) {
     const branch = {
         id: 'branch',
         text: statusExpanded ? BRANCH_CLAUSE.expanded : BRANCH_CLAUSE.collapsed,
@@ -108,12 +147,39 @@ function ladderFor(statusExpanded) {
         id: 'detail',
         text: statusExpanded ? DETAIL_CLAUSE.expanded : DETAIL_CLAUSE.collapsed,
     };
-    return [
+    const branchKey = { id: 'branch', text: BRANCH_KEY_ONLY };
+    const prompts = { id: 'prompts', text: PROMPTS_CLAUSE };
+    const kit = { id: 'kit', text: KIT_CLAUSE.expanded };
+    // THE LADDERS ARE WRITTEN WITH EVERY CLAUSE IN PLACE AND THEN FILTERED, rather
+    // than branched per width. Two independently written tables drift: the day one of
+    // them gains a rung, the `prompts.hint=false` / `kitHint=false` degradations stop
+    // being "the same row minus that clause" and nothing would notice. Filtering a
+    // single table makes that property structural.
+    const keep = (clause) => (promptsHint || clause.id !== 'prompts') && (kitHint || clause.id !== 'kit');
+    // COLLAPSED (six rungs). `^P prompts` sits between the branch and the index, and
+    // the third rung is where `^L` loses its label in favour of `^P` - see the note
+    // on `PROMPTS_CLAUSE` above for the revision of `RV-P1-2` this encodes.
+    const collapsed = [
+        [branch, prompts, index, detail],
+        [branch, prompts, detail],
+        [branchKey, prompts, detail],
+        [branch, detail],
+        [branchKey, detail],
+        [detail],
+    ];
+    // EXPANDED (seven rungs). `^P` appears in the WIDEST rung only, and AFTER `^K`,
+    // so E2..E7 - the rungs that decide what a 34..90 column terminal shows - are
+    // byte-identical to the pre-feature answers.
+    const expanded = [
+        [branch, index, kit, prompts, detail],
+        [branch, index, kit, detail],
         [branch, index, detail],
+        [branch, kit, detail],
         [branch, detail],
-        [{ id: 'branch', text: BRANCH_KEY_ONLY }, detail],
+        [branchKey, detail],
         [detail],
     ];
+    return (statusExpanded ? expanded : collapsed).map((rung) => rung.filter(keep));
 }
 /**
  * Compose the final string. The chip carries its OWN trailing spacing and is the

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

@@ -0,0 +1,50 @@
+/**
+ * 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

@@ -0,0 +1,81 @@
+/**
+ * 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/status-detail-layout.js

@@ -55,6 +55,15 @@ export function planStatusDetail(input) {
         add(statusField('team', 'Team ' + status.teamActive.running + '/' + status.teamActive.total));
     if (status.todoActive)
         add(statusField('todo', 'Todo ' + status.todoActive.done + '/' + status.todoActive.total));
+    // AFTER `todo`, AND THE ORDER IS THE PRIORITY (D-12): `add()` only appends while
+    // the whole row still fits, so a later field is dropped FIRST. `Todo 3/7` is the
+    // more important of the two numbers, so it goes first and survives the narrower
+    // terminal; `Accept 2/5` degrades before it.
+    if (status.acceptanceActive) {
+        const acceptance = status.acceptanceActive;
+        add(statusField('acceptance', 'Accept ' + acceptance.checked + '/' + acceptance.total
+            + (acceptance.failed > 0 ? ' !' + acceptance.failed : ''), acceptance.failed > 0 ? 'error' : 'normal'));
+    }
     add(statusField('model', input.provider + ':' + input.model));
     if (status.fastActive)
         add(statusField('fast', 'Fast' + (status.fastActive.inFlight ? ' active' : '')));

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

@@ -51,6 +51,19 @@ export interface StatusLayoutInput {
         done: number;
         total: number;
     };
+    /**
+     * The acceptance counter (todo-acceptance-criteria §6.11).
+     *
+     * A FALLBACK, exactly like `todoActive`: present only when the rail is NOT already
+     * reporting the number, because printing `2/5` twice in one row is the defect
+     * RV-P2-4 records. Whether it is present is decided by `acceptanceChip()` in
+     * `ui/layout/todo-layout.ts`, which owns "what did the rail actually draw".
+     */
+    acceptanceActive?: {
+        checked: number;
+        total: number;
+        failed: number;
+    };
     ecoRung?: number;
     fastActive?: {
         inFlight: boolean;

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

@@ -0,0 +1,139 @@
+/**
+ * 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;

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

@@ -0,0 +1,246 @@
+/**
+ * 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 { describeToolActivity, sanitizeActivity } from '../../team/activity.js';
+import { TEAM_LIMITS } from '../../team/limits.js';
+import { formatDuration } from '../../agent/usage.js';
+import { fitCells } from './cells.js';
+import { childElapsedMs, childStatus, statusMarkerCell, statusMarkerWidth } from '../team-status.js';
+/** The clock cell: wide enough for `125m07s` (7) with one column of headroom. */
+export const TEAM_CLOCK_CELLS = 8;
+/** `run.label.padEnd(8).slice(0,8)` — unchanged from the row this replaces. */
+export const TEAM_LABEL_CELLS = 8;
+/** The two spaces in front of the activity cell. */
+export 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 const TEAM_MIN_DESCRIPTION_CELLS = 12;
+/**
+ * The concession to code units vs terminal columns, inherited verbatim from the
+ * `WIDE_CHAR_ALLOWANCE` comment on the row this replaces: this budget is
+ * denominated in code units while the terminal is denominated in columns, and CJK
+ * and emoji occupy two columns per unit, so the budget is halved against the
+ * reserve rather than spent to the last cell. Erring small costs a few characters
+ * of prose; erring large costs the clock column.
+ */
+const WIDE_CHAR_ALLOWANCE = 2;
+/** The marker cell of the Unicode tier, used as the default by callers that pass no tier. */
+const DEFAULT_MARKER_CELLS = 3;
+function nonNegativeInt(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+/**
+ * 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 function activityBudget(cols, markerCells = DEFAULT_MARKER_CELLS) {
+    if (!Number.isFinite(cols) || cols < TEAM_LIMITS.activityDropCols)
+        return 0;
+    const fixed = markerCells + TEAM_LABEL_CELLS + TEAM_GAP_CELLS + TEAM_CLOCK_CELLS
+        + TEAM_MIN_DESCRIPTION_CELLS;
+    const spare = Math.floor((cols - fixed) / WIDE_CHAR_ALLOWANCE);
+    return Math.max(TEAM_LIMITS.activityMinChars, Math.min(TEAM_LIMITS.activityChars, spare));
+}
+/**
+ * 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 function teamRowGeometry(cols, glyphs) {
+    const width = nonNegativeInt(cols);
+    const markerCells = 1 + statusMarkerWidth(glyphs) + 1;
+    const cells = {
+        marker: Math.min(markerCells, width),
+        label: TEAM_LABEL_CELLS,
+        gap: TEAM_GAP_CELLS,
+        activity: activityBudget(width, markerCells),
+        clock: TEAM_CLOCK_CELLS,
+        minDescription: TEAM_MIN_DESCRIPTION_CELLS,
+    };
+    const sum = () => cells.marker + cells.label + cells.gap + cells.activity + cells.clock;
+    if (sum() > width)
+        cells.gap = 0;
+    if (sum() > width)
+        cells.label = Math.max(3, width - cells.marker - cells.clock);
+    if (sum() > width)
+        cells.clock = Math.max(0, Math.min(TEAM_CLOCK_CELLS, width - cells.marker - cells.label));
+    if (sum() > width)
+        cells.label = Math.max(0, Math.min(cells.label, width - cells.marker));
+    cells.minDescription = sum() >= width ? 0 : TEAM_MIN_DESCRIPTION_CELLS;
+    return cells;
+}
+/**
+ * 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 function teamClockText(run, at) {
+    return run.startedAt === undefined ? '' : formatDuration(childElapsedMs(run, at));
+}
+/** The past-tense word the supervisor badge and status line render. */
+export function interventionWord(action) {
+    switch (action) {
+        case 'nudge':
+            return 'nudged';
+        case 'replace':
+            return 'replaced';
+        case 'abandon':
+            return 'abandoned';
+        default:
+            return 'waited';
+    }
+}
+/**
+ * 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 function overseerBadge(run, at) {
+    const last = run.lastIntervention;
+    if (last === undefined)
+        return '';
+    return `${interventionWord(last.action)} ${formatDuration(Math.max(0, at - last.at))}`;
+}
+/**
+ * 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 function activityLine(run, cols, markerCells) {
+    const wide = cols >= TEAM_LIMITS.activityWideCols;
+    const budget = activityBudget(cols, markerCells);
+    switch (run.phase) {
+        case 'queued':
+            return 'queued';
+        case 'starting':
+            // The one row that legitimately restarts its clock, saying why (P2-4):
+            // F-2 ranks the running group by `startedAt` and a retry re-stamps it.
+            return run.retries ? 'starting (retry)' : 'starting';
+        case 'thinking':
+            // Clamped AT RENDER, against this terminal's budget. `run.activity` was
+            // clamped at STORE against `activityChars`; that is a ceiling, not a fit.
+            return run.activity ? `writing: ${sanitizeActivity(run.activity, budget)}` : 'thinking';
+        case 'tool':
+        case 'waiting':
+            return run.lastTool
+                ? sanitizeActivity(describeToolActivity(run.lastTool, run.activityArgs, wide), budget)
+                : run.phase === 'waiting'
+                    ? 'waiting for mail'
+                    : 'tool';
+        case 'done':
+            // `compacted N` ON THE SETTLED ROW ONLY (hardening §3.4.4 / W3). A running
+            // row is already competing for `activityBudget(cols)` with the child's own
+            // prose, and a marker that displaces what the child is DOING right now
+            // buys nothing - the dispatch report carries the same fact for good.
+            return run.compactions
+                ? `done  ${run.turns} turns  compacted ${run.compactions}`
+                : `done  ${run.turns} turns`;
+        case 'failed':
+            return 'failed';
+        case 'aborted':
+            return 'aborted';
+    }
+}
+/**
+ * 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 function activityWithBadge(run, cols, at, markerCells) {
+    const last = run.lastIntervention;
+    if (last === undefined)
+        return activityLine(run, cols, markerCells);
+    const badge = overseerBadge(run, at);
+    if (cols < TEAM_LIMITS.activityWideCols)
+        return interventionWord(last.action);
+    return sanitizeActivity(`${badge}; ${activityLine(run, cols, markerCells)}`, activityBudget(cols, markerCells));
+}
+/**
+ * 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 function teamRowCells(run, cols, at, glyphs) {
+    const geometry = teamRowGeometry(cols, glyphs);
+    // THE TEXT IS CLAMPED TO THE SAME WIDTH THE GEOMETRY ALLOCATED, so a cell's content
+    // measures no more than its box. `activityWithBadge` already clamps to the business
+    // budget; this is the belt-and-braces that also covers the two cases the budget alone
+    // cannot express - a ZERO-width cell (below `activityDropCols`, where the answer is
+    // "no activity column at all", not "a nine-character word in a zero-column box") and
+    // a wide character straddling the edge.
+    const activity = geometry.activity === 0
+        ? ''
+        : fitCells(activityWithBadge(run, cols, at, geometry.marker), geometry.activity, glyphs.ellipsis);
+    return {
+        marker: statusMarkerCell(childStatus(run), glyphs),
+        label: run.label.padEnd(TEAM_LABEL_CELLS).slice(0, TEAM_LABEL_CELLS),
+        description: run.description.replace(/\s+/g, ' '),
+        activity,
+        clock: teamClockText(run, at),
+    };
+}