@aragon-agent/cli 0.6.43 → 0.6.45

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

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

@@ -1,13 +1,13 @@
 import { formatCost, formatTokens, promptTokensOf } from '../../agent/usage.js';
 import { actionCandidates, clipStatusText, escapeClause } from '../interaction-hints.js';
-import { MODE_LABEL } from '../../agent/agent-mode.js';
+import { isGovernedModeValue, modeWord } from '../governance-status.js';
 import { statusField, statusLinePlan, validContext } from './status-layout.js';
 /**
  * Uppercase mode word for the details row, mirroring the primary row's field:
  * same vocabulary (`MODE_LABEL`), same `CUR>PENDING` deferred-switch shape.
  */
 function detailModeText(mode, pendingMode) {
-    const word = (value) => MODE_LABEL[value] ?? value.toUpperCase();
+    const word = (value) => modeWord(value, true) ?? value.toUpperCase();
     if (pendingMode)
         return `${word(mode || 'build')}>${word(pendingMode)}`;
     return word(mode || 'build');
@@ -41,7 +41,7 @@ export function planStatusDetail(input) {
     if (status.servicesActive?.live)
         add(statusField('services', 'Svc' + status.servicesActive.live));
     if (status.mode || status.pendingMode)
-        add(statusField('mode', detailModeText(status.mode, status.pendingMode), 'accent'));
+        add(statusField('mode', detailModeText(status.mode, status.pendingMode), isGovernedModeValue(status.mode) || isGovernedModeValue(status.pendingMode) ? 'govern' : 'accent'));
     if (validContext(status.context)) {
         const approximate = status.context.source === 'estimate' || status.context.deltaTokens > 0 ? '~' : '';
         add(statusField('context', 'Context ' + approximate + formatTokens(status.context.occupied)

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

@@ -117,8 +117,11 @@ export interface StatusField {
     id: string;
     text: string;
     cells: number;
-    /** 'accent' carries the mode word - the row's one always-on emphasis. */
-    tone: 'normal' | 'muted' | 'warning' | 'error' | 'accent';
+    /**
+     * 'accent' carries the mode word - the row's one always-on emphasis. 'govern' is the
+     * same slot while the posture is GOVERN / PLAN+GOVERN (`governAccent`, its own hue).
+     */
+    tone: 'normal' | 'muted' | 'warning' | 'error' | 'accent' | 'govern';
 }
 export interface StatusLinePlan {
     fields: readonly StatusField[];

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

@@ -1,7 +1,7 @@
 import stringWidth from 'string-width';
 import stripAnsi from 'strip-ansi';
 import { formatDuration } from '../../agent/usage.js';
-import { MODE_LABEL } from '../../agent/agent-mode.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
@@ -170,10 +170,12 @@ function modeFieldText(mode, pendingMode, full) {
     if (!mode && !pendingMode)
         return null;
     const word = (value) => {
-        const label = MODE_LABEL[value];
-        if (!label)
-            return full ? value.toUpperCase() : (value[0] ?? '?').toUpperCase();
-        return full ? label : label[0];
+        // `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;
@@ -231,7 +233,9 @@ export function planPrimaryStatusFields(input) {
         return statusLinePlan([
             statusField('phase', glyph + (rung >= 5 ? '' : ' ') + label, phaseTone),
             ...(notice ? [statusField('feedback', notice, feedbackTone)] : []),
-            ...(modeText ? [statusField('mode', modeText, 'accent')] : []),
+            ...(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) : '')),

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

@@ -33,6 +33,7 @@
  * through the mounted set and the measured heights back to the offset.
  */
 import stringWidth from 'string-width';
+import { governanceCardRows } from './governance-card.js';
 import { FAST_LIMITS } from '../../fast/limits.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
@@ -153,6 +154,11 @@ export function entryRevision(entry) {
          */
         case 'service':
             return `v${entry.status}.${entry.rowsSeen}.${entry.url ? 1 : 0}.${entry.exitCode ?? -1}.${entry.terminal ? 1 : 0}`;
+        // A governance card is IMMUTABLE once appended (it is a settled record), so its
+        // revision only has to tell two cards apart: the shape terms below are what decide
+        // its height (`governanceCardRows`), and they cannot change without a new entry.
+        case 'governance':
+            return `g${entry.card.rows.length}.${entry.card.notes.length}.${entry.card.headline.length}`;
         default:
             return 'x';
     }
@@ -402,6 +408,11 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
             const progress = entry.progress || entry.stalled ? SERVICE_PROGRESS_ROWS : 0;
             return separation + 1 + progress + url + tail;
         }
+        // EXACT, not an upper bound: every line of the card is `wrap="truncate"`, so its
+        // height is a function of its data alone (`layout/governance-card.ts`). It has to
+        // be added to BOTH of this file's switches - one alone yields scroll drift.
+        case 'governance':
+            return separation + governanceCardRows(entry.card);
         default:
             return separation + 1;
     }

package/dist/ui/overlays/GovernanceBoardOverlay.d.ts

@@ -0,0 +1,41 @@
+/**
+ * GovernanceBoardOverlay - the read-only `/gov board` overview
+ * (governance-mode section 10.5).
+ *
+ * ASCII ONLY: every symbol comes through `glyphs`.
+ *
+ * READ-ONLY IS THE SAFETY BOUNDARY, as for the Agents board: nothing here scores, rules
+ * or resolves anything. The only side effect is `e`, which asks the owner to copy the
+ * `board.md` path.
+ *
+ * `OverlayFrame` SELF-MANAGED MODE, with this file owning the window. The tab strip must
+ * stay put while the rows scroll, which the frame's controlled mode (it windows EVERY row
+ * it is given) cannot do; so the body is "one strip row + a window of rows" and the
+ * windowing is `sliceWindow` through `boardWindow`, the arithmetic the frame itself uses.
+ * `PgUp` / `PgDn` / the wheel arrive through `App`'s `controlled` overlay list as
+ * `scrollOffset`; Up/Down and Left/Right are this component's own keys, the same split the
+ * Agents board makes.
+ *
+ * NO `ink-spinner` and no motion prop (spinner-census): this is a reading surface.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import { type BoardTab, type GovernanceBoardData } from '../layout/governance-board.js';
+export interface GovernanceBoardOverlayProps {
+    /** The board's data, or null when there is no governed run to show. */
+    data: GovernanceBoardData | null;
+    /** The overlay's FRAME width (`App`'s `viewCols`). */
+    cols: number;
+    maxRows: number;
+    scrollOffset: number;
+    onScrollClamp: (offset: number) => void;
+    isActive: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+    /** `e`: copy the board file path. Absent = the key reports the path as unavailable. */
+    onCopyPath?: (path: string) => void;
+    onNotice?: (level: 'info' | 'warn', text: string) => void;
+    initialTab?: BoardTab;
+}
+export declare function GovernanceBoardOverlay({ data, cols, maxRows, scrollOffset, onScrollClamp, isActive, theme, caps, onCopyPath, onNotice, initialTab, }: GovernanceBoardOverlayProps): React.ReactElement;

package/dist/ui/overlays/GovernanceBoardOverlay.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * GovernanceBoardOverlay - the read-only `/gov board` overview
+ * (governance-mode section 10.5).
+ *
+ * ASCII ONLY: every symbol comes through `glyphs`.
+ *
+ * READ-ONLY IS THE SAFETY BOUNDARY, as for the Agents board: nothing here scores, rules
+ * or resolves anything. The only side effect is `e`, which asks the owner to copy the
+ * `board.md` path.
+ *
+ * `OverlayFrame` SELF-MANAGED MODE, with this file owning the window. The tab strip must
+ * stay put while the rows scroll, which the frame's controlled mode (it windows EVERY row
+ * it is given) cannot do; so the body is "one strip row + a window of rows" and the
+ * windowing is `sliceWindow` through `boardWindow`, the arithmetic the frame itself uses.
+ * `PgUp` / `PgDn` / the wheel arrive through `App`'s `controlled` overlay list as
+ * `scrollOffset`; Up/Down and Left/Right are this component's own keys, the same split the
+ * Agents board makes.
+ *
+ * NO `ink-spinner` and no motion prop (spinner-census): this is a reading surface.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame, overlayBodyRows } from '../layout/OverlayFrame.js';
+import { boardBodyRows, boardHint, boardPosition, boardWindow, buildGovernanceBoardLayout, stepTab, } from '../layout/governance-board.js';
+import { cellWidth } from '../layout/cells.js';
+import { GovernanceLine } from '../GovernanceRun.js';
+import { BOARD_COPIED, BOARD_NO_PATH, BOARD_TITLE } from '../governance-copy.js';
+/** `OverlayFrame`'s own breakpoint, mirrored so the chrome estimate cannot drift. */
+const FRAME_BORDERLESS_COLS = 48;
+export function GovernanceBoardOverlay({ data, cols, maxRows, scrollOffset, onScrollClamp, isActive, theme, caps, onCopyPath, onNotice, initialTab = 'roster', }) {
+    const glyphs = pickGlyphs(caps);
+    const [tab, setTab] = useState(initialTab);
+    // The frame spends 4 of `cols` on its border + padding (2 in the narrow rail form), so a
+    // board planned against the frame width would lose its last four columns to truncation.
+    const contentCols = Math.max(1, cols - (cols >= FRAME_BORDERLESS_COLS ? 4 : 2));
+    const layout = buildGovernanceBoardLayout({ cols: contentCols, tab, data, glyphs });
+    const height = boardBodyRows(overlayBodyRows(maxRows, cols));
+    const window = boardWindow(layout.lines.length, scrollOffset, height);
+    const position = boardPosition(window, glyphs);
+    useEffect(() => {
+        if (window.clamped !== scrollOffset)
+            onScrollClamp(window.clamped);
+    }, [window.clamped, scrollOffset, onScrollClamp]);
+    // The offset the NEXT key press starts from. A held Down key delivers several presses
+    // before React re-renders; stepping from the rendered value would turn three presses
+    // into one row of movement.
+    const offsetRef = useRef(window.clamped);
+    offsetRef.current = window.clamped;
+    useInput((input, key) => {
+        if (!isActive)
+            return;
+        if (key.leftArrow || key.rightArrow) {
+            setTab((current) => stepTab(current, key.rightArrow ? 1 : -1));
+            offsetRef.current = 0;
+            onScrollClamp(0);
+            return;
+        }
+        if (key.upArrow || key.downArrow) {
+            offsetRef.current = Math.max(0, offsetRef.current + (key.upArrow ? -1 : 1));
+            onScrollClamp(offsetRef.current);
+        }
+        else if (input === 'e' || input === 'E') {
+            const path = data?.boardPath ?? null;
+            if (path === null || onCopyPath === undefined) {
+                onNotice?.('warn', BOARD_NO_PATH);
+                return;
+            }
+            onCopyPath(path);
+            onNotice?.('info', BOARD_COPIED);
+        }
+    }, { isActive });
+    const visible = layout.lines.slice(window.start, window.start + window.visible);
+    return (_jsxs(OverlayFrame, { title: BOARD_TITLE, hint: boardHint(contentCols, glyphs), maxRows: maxRows, cols: cols, theme: theme, caps: caps, children: [_jsxs(Box, { flexDirection: "row", height: 1, flexShrink: 0, children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(GovernanceLine, { segments: layout.tabStrip.segments, theme: theme }) }), position !== '' && (_jsx(Box, { width: cellWidth(position) + 1, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { color: theme.muted, children: position }) }))] }), visible.map((line) => (_jsx(GovernanceLine, { segments: line.segments, theme: theme }, line.key)))] }));
+}

package/dist/ui/overlays/GovernanceSettingsPage.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Settings > Governance: eleven arrows-adjustable rows (governance-mode-v1-1 5, closing
+ * governance-mode IF-13).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THIS IS `TeamFanoutPage` WITH A DIFFERENT TABLE, ON PURPOSE. Every defence that page
+ * carries was paid for by a real defect, so each one is inherited verbatim:
+ *
+ *  - THE PAGE OWNS ONE PIECE OF STATE, its cursor. Every value comes from `props.view.rows`,
+ *    which `SettingsScreen` derives from the reducer; a second copy of the draft here could
+ *    disagree with the root page about what Ctrl+S is about to save.
+ *  - `Enter` TOGGLES THE SWITCH ROWS AND DOES NOTHING ON A NUMBER (R-P1-12). A stray Return
+ *    that silently changed a number is indistinguishable from a bug, and the arrow keys are
+ *    already the obvious control there.
+ *  - IT DOES NOT LISTEN FOR Ctrl+S, AND THE FOOTER SAYS SO (R-P1-13). `useRootSettingsInput`
+ *    gates its `useInput` on `state.page === 'root'`, so a subpage has no save listener at
+ *    all; a footer promising "Ctrl+S saves here" would be a lie the user acts on.
+ *
+ * THE RESTART NOTE IS THE ONE THING THIS PAGE ADDS. `enabled` is a REGISTRATION key: the tool
+ * array is fixed when the session is built, so flipping it here changes the file and the
+ * next launch, not this session. The note sits under that row so the consequence is read
+ * where the choice is made.
+ */
+import React from 'react';
+import { type ProfileFrameProps } from './ModelProfilePicker.js';
+import type { GovernanceSettingKey, GovernanceSettingRow } from './governance-settings.js';
+/** What the page may ask the screen to change. */
+export interface GovernanceSettingsAction {
+    type: 'governance-step';
+    key: GovernanceSettingKey;
+    delta: -1 | 1;
+}
+export interface GovernanceSettingsView {
+    /** Exactly eleven, in the fixed order the cursor indexes. */
+    rows: GovernanceSettingRow[];
+    error?: string;
+    /** Shown under the first row; `null` when the draft agrees with this session. */
+    restartNote: string | null;
+}
+interface GovernanceSettingsPageProps extends ProfileFrameProps {
+    view: GovernanceSettingsView;
+    dispatch: (action: GovernanceSettingsAction) => void;
+    /** Esc: back to the settings root. The draft is NOT discarded here. */
+    onBack: () => void;
+}
+export declare function GovernanceSettingsPage(props: GovernanceSettingsPageProps): React.ReactElement;
+export {};

package/dist/ui/overlays/GovernanceSettingsPage.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Settings > Governance: eleven arrows-adjustable rows (governance-mode-v1-1 5, closing
+ * governance-mode IF-13).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THIS IS `TeamFanoutPage` WITH A DIFFERENT TABLE, ON PURPOSE. Every defence that page
+ * carries was paid for by a real defect, so each one is inherited verbatim:
+ *
+ *  - THE PAGE OWNS ONE PIECE OF STATE, its cursor. Every value comes from `props.view.rows`,
+ *    which `SettingsScreen` derives from the reducer; a second copy of the draft here could
+ *    disagree with the root page about what Ctrl+S is about to save.
+ *  - `Enter` TOGGLES THE SWITCH ROWS AND DOES NOTHING ON A NUMBER (R-P1-12). A stray Return
+ *    that silently changed a number is indistinguishable from a bug, and the arrow keys are
+ *    already the obvious control there.
+ *  - IT DOES NOT LISTEN FOR Ctrl+S, AND THE FOOTER SAYS SO (R-P1-13). `useRootSettingsInput`
+ *    gates its `useInput` on `state.page === 'root'`, so a subpage has no save listener at
+ *    all; a footer promising "Ctrl+S saves here" would be a lie the user acts on.
+ *
+ * THE RESTART NOTE IS THE ONE THING THIS PAGE ADDS. `enabled` is a REGISTRATION key: the tool
+ * array is fixed when the session is built, so flipping it here changes the file and the
+ * next launch, not this session. The note sits under that row so the consequence is read
+ * where the choice is made.
+ */
+import { useState } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { clipProfileText, useProfileScroll } from './ModelProfilePicker.js';
+/** Matches the root page's `padEnd(18)` rows so the value column lines up (measured). */
+const LABEL_PAD = 18;
+/** The rows `Enter` flips, and nothing else (R-P1-12). */
+const TOGGLE_KEYS = new Set([
+    'enabled',
+    'shiftTab',
+    'panel',
+    'confirmCharter',
+]);
+export function GovernanceSettingsPage(props) {
+    const [index, setIndex] = useState(0);
+    const rows = props.view.rows;
+    const count = Math.max(1, rows.length);
+    const cursor = Math.min(index, count - 1);
+    const focused = rows[cursor];
+    const note = props.view.restartNote;
+    // The note is one extra LINE after row 0, so every later row sits one line lower.
+    const offset = useProfileScroll(props, cursor + (note !== null && cursor > 0 ? 1 : 0));
+    const nudge = (delta) => {
+        if (focused)
+            props.dispatch({ type: 'governance-step', key: focused.key, delta });
+    };
+    const handleKey = (key) => {
+        if (key.escape) {
+            props.onBack();
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            setIndex((cursor - 1 + count) % count);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            setIndex((cursor + 1) % count);
+            return;
+        }
+        if (key.leftArrow || key.rightArrow) {
+            nudge(key.leftArrow ? -1 : 1);
+            return;
+        }
+        // `Enter` toggles the switch rows and does NOTHING on a numeric or choice row.
+        if (key.return && focused && TOGGLE_KEYS.has(focused.key))
+            nudge(1);
+    };
+    useInput((_input, key) => {
+        if (props.isActive === false)
+            return;
+        handleKey(key);
+    });
+    const glyphs = pickGlyphs(props.caps);
+    const body = [];
+    rows.forEach((row, at) => {
+        const line = `${row.label.padEnd(LABEL_PAD)}${row.value}`;
+        body.push(_jsx(Text, { wrap: "truncate", color: at === cursor ? props.theme.accent : props.theme.muted, children: `${at === cursor ? glyphs.caret : ' '} ${clipProfileText(line, props.cols - 8)}` }, row.key));
+        if (at === 0 && note !== null) {
+            body.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: `  ${clipProfileText(note, props.cols - 8)}` }, "restart-note"));
+        }
+    });
+    // The hint explains the FOCUSED row: the range and the reason are the point of the page.
+    if (focused) {
+        body.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: clipProfileText(focused.hint, props.cols - 8) }, "hint"));
+    }
+    return _jsx(OverlayFrame, { ...props, rows: body, scrollOffset: offset, title: props.view.error ?? 'Governance', hint: "Arrows adjust. Esc goes back; Ctrl+S on the main page saves." });
+}