@aragon-agent/cli 0.6.44 → 0.6.46

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/invocation-card.d.ts

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

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

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

package/dist/ui/layout/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,12 +33,14 @@
  * 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';
 import { expandTabs } from '../display-tab.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
 import { isLiveTeamCard } from '../team-status.js';
+import { invocationCardRows } from './invocation-card.js';
 export const VIRTUAL_LIMITS = {
     /**
      * Entries kept mounted on each side of the visible band.
@@ -67,8 +69,12 @@ export const VIRTUAL_LIMITS = {
  */
 export function entryRevision(entry) {
     switch (entry.kind) {
+        // A card's shape is fixed at creation; the suffix only tells "card" from "plain" (and
+        // the three row-bearing parts), which is what makes a `queued -> user` rewrite re-measure.
         case 'user':
-            return 'u';
+            return entry.invocation
+                ? `i${entry.invocation.input.length}.${entry.invocation.inputHidden > 0 ? 1 : 0}.${entry.invocation.note ? 1 : 0}`
+                : 'u';
         case 'notice':
             return 'n';
         // `thinkingMs` is O(1) and it CHANGES THE ROW: sealing the clock turns
@@ -153,6 +159,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';
     }
@@ -253,6 +264,11 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
     const separation = density === 'comfortable' ? 1 : 0;
     switch (entry.kind) {
         case 'user':
+            // A CARD HAS ITS OWN, BOUNDED HEIGHT (tui-invocation-cards I-4): the same
+            // `invocationCardRows` the painter is built from, never the command line's wrapped rows.
+            if (entry.invocation) {
+                return separation + invocationCardRows(entry.invocation, usable, wrappedRows);
+            }
             // MIRRORS `UserEntry`'s RENDER CAP (+1 for the `... +N more lines` tail).
             // THESE TWO NUMBERS ARE ONE NUMBER (I-13). Capping the renderer alone
             // would leave this function believing a 5 000-line message is 5 000 rows
@@ -402,6 +418,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;