@aragon-agent/cli 0.6.44 → 0.6.46

package/dist/ui/GovernanceRun.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { toneColor } from './governance-status.js';
+/** The segments as nested `Text`; the CALLER owns wrapping and truncation. */
+export function GovernanceRun({ segments, theme }) {
+    return (_jsx(_Fragment, { children: segments.map((part, index) => (_jsx(Text, { color: toneColor(part.tone, theme), ...(part.bold ? { bold: true } : {}), children: part.text }, index))) }));
+}
+/** One display row: the run inside a `wrap="truncate"` `Text`, so it can never wrap. */
+export function GovernanceLine({ segments, theme }) {
+    return (_jsx(Text, { wrap: "truncate", children: _jsx(GovernanceRun, { segments: segments, theme: theme }) }));
+}

package/dist/ui/StatusBar.d.ts

@@ -5,6 +5,8 @@ import type { TermCapabilities } from './capabilities.js';
 import type { UsageTotal } from '../agent/reducer.js';
 import type { ContextUsageSnapshot } from '../compaction/types.js';
 import type { AgentMode } from '../agent/agent-mode.js';
+import type { GovernanceSnapshot } from '../governance/types.js';
+import type { Posture } from '../governance/posture.js';
 import type { PendingSteering } from '../agent/queued-messages.js';
 import { type RunPhase } from './layout/status-layout.js';
 import type { EscapeAction, StatusFeedback } from './status-feedback.js';
@@ -63,8 +65,19 @@ export interface StatusBarProps {
         modified: boolean;
         otherNames: readonly string[];
     } | null;
-    agentMode?: AgentMode;
-    pendingAgentMode?: AgentMode | null;
+    /**
+     * The mode word's source. A `Posture` is also accepted (governance-mode 10.2): its
+     * governed members render as `GOVERN` / `PLAN+GOVERN` in the governance hue, and
+     * `build` / `plan` render exactly as the `AgentMode` of the same name always did.
+     */
+    agentMode?: AgentMode | Posture;
+    pendingAgentMode?: AgentMode | Posture | null;
+    /**
+     * The live governed-run snapshot, or absent. Drives the governance chip
+     * (`GOV p2/3 REVIEW`); absent plans a hidden chip, which keeps this row byte-identical
+     * to the pre-governance build.
+     */
+    governance?: GovernanceSnapshot | null;
     /**
      * Forced team mode is armed, with the count it was armed with
      * (team-command-forced-dispatch §3.8 / D-9). ABSENT = not armed, and every

package/dist/ui/StatusBar.js

@@ -3,10 +3,12 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import React from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from './glyphs.js';
+import { planGovernanceChip } from './layout/governance-chip.js';
 import { liveSpinner } from './ActivityLine.js';
 import { planPrimaryStatusFields } from './layout/status-layout.js';
 import { planSessionChip } from './layout/session-chip.js';
 import { planKitChip } from './layout/kit-chip.js';
+import { toneColor } from './governance-status.js';
 /** An invisible leading byte change forces Ink to repaint on Ctrl+L. */
 const redrawChar = (nonce) => nonce % 2 ? String.fromCharCode(0x00a0) : ' ';
 export function StatusBar(props) {
@@ -28,8 +30,12 @@ export function StatusBar(props) {
     // byte-identical to the build before the feature (I-9).
     const kit = planKitChip({ columns: cols - chipCells, kit: props.kit });
     const kitCells = kit.visible ? kit.cells + kit.gap : 0;
+    // THE GOVERNANCE CHIP IS PLANNED THIRD, out of what the other two left, by the same
+    // comparison (the left half keeps its 34-cell floor). Hidden without a live run.
+    const govern = planGovernanceChip({ columns: cols - chipCells - kitCells, snapshot: props.governance });
+    const governCells = govern.visible ? govern.cells + govern.gap : 0;
     const plan = planPrimaryStatusFields({
-        reserveRight: chipCells + kitCells,
+        reserveRight: chipCells + kitCells + governCells,
         columns: cols, phase, pendingCount: props.pendingSteering?.length ?? 0,
         context: props.context, usageTotal: props.usageTotal,
         thinkingLevel: props.thinkingLevel, elapsedMs: props.elapsedMs, tokPerSec: props.tokPerSec,
@@ -48,8 +54,8 @@ export function StatusBar(props) {
     });
     const tones = { normal: props.theme.primary, muted: props.theme.muted,
         warning: props.theme.noticeWarn, error: props.theme.noticeError,
-        accent: props.theme.accent };
-    return _jsxs(Box, { width: cols, height: 1, flexShrink: 0, flexDirection: "row", overflow: "hidden", children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { children: redrawChar(props.redrawNonce ?? 0) }) }), _jsx(Box, { width: Math.max(0, cols - 1 - chipCells - kitCells), flexShrink: 0, flexDirection: "row", overflow: "hidden", children: plan.fields.map((item, index) => _jsxs(React.Fragment, { children: [index > 0 && _jsx(Box, { width: plan.separatorCells, flexShrink: 0, children: _jsx(Text, { color: props.theme.muted, children: plan.separator }) }), _jsx(Box, { width: item.cells, flexShrink: 0, children: _jsx(Text, { color: tones[item.tone], wrap: "truncate", children: item.id === 'phase' && active
+        accent: props.theme.accent, govern: props.theme.governAccent };
+    return _jsxs(Box, { width: cols, height: 1, flexShrink: 0, flexDirection: "row", overflow: "hidden", children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { children: redrawChar(props.redrawNonce ?? 0) }) }), _jsx(Box, { width: Math.max(0, cols - 1 - chipCells - kitCells - governCells), flexShrink: 0, flexDirection: "row", overflow: "hidden", children: plan.fields.map((item, index) => _jsxs(React.Fragment, { children: [index > 0 && _jsx(Box, { width: plan.separatorCells, flexShrink: 0, children: _jsx(Text, { color: props.theme.muted, children: plan.separator }) }), _jsx(Box, { width: item.cells, flexShrink: 0, children: _jsx(Text, { color: tones[item.tone], wrap: "truncate", children: item.id === 'phase' && active
                                     ? _jsxs(_Fragment, { children: [spinner ?? glyph, item.text.slice(glyph.length)] })
-                                    : item.text }) })] }, item.id)) }), kit.visible && _jsx(Box, { width: kitCells, flexShrink: 0, justifyContent: "flex-end", overflow: "hidden", children: _jsx(Text, { color: props.theme.muted, wrap: "truncate", children: kit.text }) }), chip.visible && _jsx(Box, { width: chipCells, flexShrink: 0, justifyContent: "flex-end", overflow: "hidden", children: _jsx(Text, { color: props.theme.muted, wrap: "truncate", children: chip.text }) })] });
+                                    : item.text }) })] }, item.id)) }), govern.visible && _jsx(Box, { width: governCells, flexShrink: 0, justifyContent: "flex-end", overflow: "hidden", children: _jsx(Text, { color: toneColor(govern.tone, props.theme), wrap: "truncate", bold: true, children: govern.text }) }), kit.visible && _jsx(Box, { width: kitCells, flexShrink: 0, justifyContent: "flex-end", overflow: "hidden", children: _jsx(Text, { color: props.theme.muted, wrap: "truncate", children: kit.text }) }), chip.visible && _jsx(Box, { width: chipCells, flexShrink: 0, justifyContent: "flex-end", overflow: "hidden", children: _jsx(Text, { color: props.theme.muted, wrap: "truncate", children: chip.text }) })] });
 }

package/dist/ui/Transcript.js

@@ -8,10 +8,12 @@ import { pickGlyphs, toolGlyph } from './glyphs.js';
 import { separationRows } from './density.js';
 import { EntryFrame } from './entries/EntryFrame.js';
 import { UserEntry } from './entries/UserEntry.js';
+import { InvocationCard } from './entries/InvocationCard.js';
 import { QueuedEntry } from './entries/QueuedEntry.js';
 import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
 import { TeamCard, teamCardColor } from './entries/TeamCard.js';
+import { GovernanceCard, governanceCardColor } from './entries/GovernanceCard.js';
 import { isLiveTeamCard, rosterCounts } from './team-status.js';
 import { TodoCard, todoCardColor } from './entries/TodoCard.js';
 import { RetryCard, retryCardColor } from './entries/RetryCard.js';
@@ -77,7 +79,9 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
     const frame = (glyph, color, children) => (_jsx(EntryFrame, { glyph: glyph, color: color, continuation: glyphs.railVertical, separation: separation, spacerColor: theme.border, children: children }));
     switch (entry.kind) {
         case 'user':
-            return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
+            return frame(glyphs.user, theme.user, entry.invocation
+                ? _jsx(InvocationCard, { card: entry.invocation, theme: theme, caps: caps })
+                : _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
         case 'queued':
             // `theme.muted`: quieter than a user message, louder than a notice --
             // the row exists to be noticed UNTIL it is accepted, then rewritten in
@@ -118,6 +122,8 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
                 return null;
             return frame(glyphs.teamAgent, teamCardColor(rosterCounts(entry.runs), entry.active, entry.aborted, theme), _jsx(TeamCard, { requested: entry.requested, runs: entry.runs, aborted: entry.aborted, durationMs: entry.durationMs, active: entry.active, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps, nowSec: nowSecFor(entry, nowSec) }));
         }
+        case 'governance':
+            return frame(glyphs.teamAgent, governanceCardColor(entry.card, theme), _jsx(GovernanceCard, { card: entry.card, theme: theme, caps: caps }));
         case 'todo':
             return frame(toolGlyph(glyphs, 'todo_write'), todoCardColor(entry.doneCount, entry.total, entry.live, theme), _jsx(TodoCard, { items: entry.items, doneCount: entry.doneCount, total: entry.total, acceptance: entry.acceptance ?? null, live: entry.live, interrupted: entry.interrupted, theme: theme, caps: caps }));
         case 'retry':

package/dist/ui/entries/GovernanceCard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * GovernanceCard - the settlement card for a `kind: 'governance'` entry
+ * (governance-mode section 10.4).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`, through the layout.
+ *
+ * It renders inside the `EntryFrame` that `Transcript.tsx` supplies, so the left rail is
+ * the card's frame - no second box drawn inside the rail. (The spec sketches a
+ * rounded box; nested inside the gutter rail it would be two frames for one thing, and the
+ * rail already carries the tone colour. Recorded as a deliberate deviation.)
+ *
+ * EVERY LINE TRUNCATES, none wraps, so the card's height is a function of its data alone
+ * (`governanceCardRows`) and `virtual-window.ts::estimateEntryRows` is exact rather than an
+ * upper bound. A narrow terminal therefore degrades by truncation to one plain line per
+ * agent without any width-dependent branch here.
+ */
+import React from 'react';
+import type { GovernanceCardData } from '../../governance/types.js';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+export interface GovernanceCardProps {
+    card: GovernanceCardData;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/** The rail colour: the card's verdict, resolved like every other governance tone. */
+export declare function governanceCardColor(card: GovernanceCardData, theme: Theme): string | undefined;
+declare function GovernanceCardImpl({ card, theme, caps }: GovernanceCardProps): React.ReactElement;
+export declare const GovernanceCard: React.MemoExoticComponent<typeof GovernanceCardImpl>;
+export {};

package/dist/ui/entries/GovernanceCard.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * GovernanceCard - the settlement card for a `kind: 'governance'` entry
+ * (governance-mode section 10.4).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`, through the layout.
+ *
+ * It renders inside the `EntryFrame` that `Transcript.tsx` supplies, so the left rail is
+ * the card's frame - no second box drawn inside the rail. (The spec sketches a
+ * rounded box; nested inside the gutter rail it would be two frames for one thing, and the
+ * rail already carries the tone colour. Recorded as a deliberate deviation.)
+ *
+ * EVERY LINE TRUNCATES, none wraps, so the card's height is a function of its data alone
+ * (`governanceCardRows`) and `virtual-window.ts::estimateEntryRows` is exact rather than an
+ * upper bound. A narrow terminal therefore degrades by truncation to one plain line per
+ * agent without any width-dependent branch here.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { toneColor } from '../governance-status.js';
+import { GovernanceLine, GovernanceRun } from '../GovernanceRun.js';
+import { buildGovernanceCardLayout, cardTone } from '../layout/governance-card.js';
+/** The rail colour: the card's verdict, resolved like every other governance tone. */
+export function governanceCardColor(card, theme) {
+    return toneColor(cardTone(card), theme);
+}
+function GovernanceCardImpl({ card, theme, caps }) {
+    const layout = buildGovernanceCardLayout(card, pickGlyphs(caps));
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(GovernanceLine, { segments: layout.title, theme: theme }), layout.headline && (_jsx(GovernanceLine, { segments: layout.headline, theme: theme })), layout.tableHeader && (_jsx(Text, { wrap: "truncate", children: layout.tableHeader.map((cell, index) => (_jsx(GovernanceRun, { segments: cell, theme: theme }, index))) })), layout.rows.map((row) => (_jsx(Text, { wrap: "truncate", children: row.cells.map((cell, index) => (_jsx(GovernanceRun, { segments: cell, theme: theme }, index))) }, row.key))), layout.notes && _jsx(GovernanceLine, { segments: layout.notes, theme: theme })] }));
+}
+export const GovernanceCard = React.memo(GovernanceCardImpl);

package/dist/ui/entries/InvocationCard.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Render a `user` entry that carries an invocation card (tui-invocation-cards).
+ *
+ * Like `UserEntry`, this renders CONTENT only: the role glyph, rail and spacing belong
+ * to `EntryFrame`, so the card stays "the user's turn" for density, turn counting and
+ * the settled boundary. The header text comes from `invocationHeaderSegments` and is
+ * never assembled here (RV-10); the row count it implies is `invocationCardRows`.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { InvocationCard as InvocationCardData } from '../../agent/invocation-card.js';
+declare function InvocationCardImpl({ card, theme, caps, }: {
+    card: InvocationCardData;
+    theme: Theme;
+    caps: TermCapabilities;
+}): React.ReactElement;
+/** Default comparator: `mapEntry` preserves identity for untouched entries (L2 / R3). */
+export declare const InvocationCard: React.MemoExoticComponent<typeof InvocationCardImpl>;
+export {};

package/dist/ui/entries/InvocationCard.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Render a `user` entry that carries an invocation card (tui-invocation-cards).
+ *
+ * Like `UserEntry`, this renders CONTENT only: the role glyph, rail and spacing belong
+ * to `EntryFrame`, so the card stays "the user's turn" for density, turn counting and
+ * the settled boundary. The header text comes from `invocationHeaderSegments` and is
+ * never assembled here (RV-10); the row count it implies is `invocationCardRows`.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { invocationHeaderSegments, invocationHiddenText, invocationInputText, } from '../layout/invocation-card.js';
+import { GUTTER_WIDTH } from '../layout/Gutter.js';
+import { useTerminalSize } from '../layout/useTerminalSize.js';
+import { fitCells } from '../layout/cells.js';
+function toneColor(tone, theme) {
+    if (tone === 'label')
+        return theme.accent;
+    if (tone === 'name')
+        return theme.user;
+    return theme.muted;
+}
+function InvocationCardImpl({ card, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const { cols } = useTerminalSize();
+    const usable = Math.max(1, cols - GUTTER_WIDTH);
+    const header = invocationHeaderSegments(card, glyphs, usable);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { wrap: "truncate", children: header.map((part, index) => (_jsx(Text, { color: toneColor(part.tone, theme), bold: part.bold, children: part.text }, index))) }), card.input !== '' && _jsx(Text, { color: theme.user, children: invocationInputText(card) }), card.inputHidden > 0 && (_jsx(Text, { color: theme.muted, wrap: "truncate", children: invocationHiddenText(card, glyphs) })), card.note !== undefined && card.note !== '' && (_jsx(Text, { color: theme.muted, wrap: "truncate", children: fitCells(card.note, usable, glyphs.ellipsis) }))] }));
+}
+/** Default comparator: `mapEntry` preserves identity for untouched entries (L2 / R3). */
+export const InvocationCard = React.memo(InvocationCardImpl);

package/dist/ui/governance-copy.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Governance TUI copy: every user-visible English phrase of the legion panel, the chip,
+ * the settlement card and the `/gov board` overlay (governance-mode section 10.6).
+ *
+ * ASCII ONLY (`src/ui/**` is glyph-scanned). Phrases that need a symbol take it as a
+ * template parameter from `pickGlyphs(caps)` instead of spelling it.
+ *
+ * WHY THIS LIVES IN `ui/` AND NOT IN `governance/copy.ts`: the engine author owns that
+ * file and it carries the model-facing and notice wording. This module holds the strings
+ * only the TUI draws, so the two cannot collide while both are being written. When
+ * `governance/copy.ts` lands, a phrase that appears in both belongs THERE and this file
+ * re-exports it - the unit tests pin these strings, so the move is a compile error and
+ * not a silent fork.
+ */
+import type { GovAgentState, GovRole, PipelineStepKey } from '../governance/types.js';
+export declare const GOV_TITLE = "GOVERN";
+/** One word for each pipeline step, as printed in the step strip. */
+export declare const PIPELINE_LABEL: Readonly<Record<PipelineStepKey, string>>;
+/** The role word in the roster's role column. */
+export declare const ROLE_LABEL: Readonly<Record<GovRole, string>>;
+/** What a `working` agent is doing, by role: the row says WHAT, the marker says THAT. */
+export declare const WORKING_VERB: Readonly<Record<GovRole, string>>;
+/** The state column's word for every non-working state. */
+export declare const STATE_WORD: Readonly<Record<Exclude<GovAgentState, 'working'>, string>>;
+export declare const NOT_SCORED = "not scored";
+export declare const MORE_HINT = "(/gov board)";
+export declare const PANEL_LEDGER_LABEL = "ledger";
+export declare const PANEL_HEALTH_LABEL = "health";
+export declare const PANEL_TOKEN_UNIT = "tok";
+export declare const PANEL_BOARD_HINT = "/gov board";
+export declare const STATUS_WORD: {
+    readonly pausing: "pausing";
+    readonly paused: "paused";
+    readonly escalated: "escalated";
+    readonly abandoned: "abandoned";
+    readonly closed: "closed";
+};
+/** `pausing after REVIEW`: a `/gov pause` is waiting for the running stage to finish. */
+export declare function pausingText(stage: string): string;
+/** `replaced by dev2-r1` (the glyph in front comes from the roster marker). */
+export declare function replacedByText(successor: string | null): string;
+export declare function moreText(hidden: number): string;
+export declare function workingCountText(count: number): string;
+export declare function phaseText(phase: number, phaseCount: number): string;
+export declare function phaseLongText(phase: number, phaseCount: number): string;
+/** Board tab names, in tab order. */
+export declare const BOARD_TAB_LABEL: {
+    readonly roster: "Roster";
+    readonly work: "Work packages";
+    readonly ledger: "Ledger";
+    readonly claims: "Claims";
+};
+export declare const BOARD_TITLE = "Governance board";
+export declare const BOARD_EMPTY: {
+    readonly noRun: "No governed run yet. Use /gov or Shift+Tab to enter GOVERN.";
+    readonly roster: "No agents yet.";
+    readonly work: "No work packages recorded for this view.";
+    readonly ledger: "No ledger entries yet.";
+    readonly claims: "No claims or escalations.";
+};
+export declare const BOARD_COPIED = "Copied the board file path";
+export declare const BOARD_NO_PATH = "No board file path is available yet";
+export declare const CARD_TITLE = "Governance";
+export declare const CARD_COLUMNS: {
+    readonly id: "id";
+    readonly role: "role";
+    readonly confirmed: "confirmed";
+    readonly delta: "delta";
+};

package/dist/ui/governance-copy.js

@@ -0,0 +1,104 @@
+/**
+ * Governance TUI copy: every user-visible English phrase of the legion panel, the chip,
+ * the settlement card and the `/gov board` overlay (governance-mode section 10.6).
+ *
+ * ASCII ONLY (`src/ui/**` is glyph-scanned). Phrases that need a symbol take it as a
+ * template parameter from `pickGlyphs(caps)` instead of spelling it.
+ *
+ * WHY THIS LIVES IN `ui/` AND NOT IN `governance/copy.ts`: the engine author owns that
+ * file and it carries the model-facing and notice wording. This module holds the strings
+ * only the TUI draws, so the two cannot collide while both are being written. When
+ * `governance/copy.ts` lands, a phrase that appears in both belongs THERE and this file
+ * re-exports it - the unit tests pin these strings, so the move is a compile error and
+ * not a silent fork.
+ */
+export const GOV_TITLE = 'GOVERN';
+/** One word for each pipeline step, as printed in the step strip. */
+export const PIPELINE_LABEL = {
+    intake: 'INTAKE',
+    dev: 'DEV',
+    review: 'REVIEW',
+    test: 'TEST',
+    settle: 'SETTLE',
+    integrate: 'INTEGRATE',
+    fix: 'FIX',
+};
+/** The role word in the roster's role column. */
+export const ROLE_LABEL = {
+    DEV: 'DEV',
+    REV: 'REV',
+    TEST: 'TEST',
+    INSP: 'INSP',
+};
+/** What a `working` agent is doing, by role: the row says WHAT, the marker says THAT. */
+export const WORKING_VERB = {
+    DEV: 'coding',
+    REV: 'reviewing',
+    TEST: 'testing',
+    INSP: 'checking',
+};
+/** The state column's word for every non-working state. */
+export const STATE_WORD = {
+    queued: 'queued',
+    submitted: 'submitted',
+    idle: 'idle',
+    failed: 'failed',
+    eliminated: 'replaced',
+};
+export const NOT_SCORED = 'not scored';
+export const MORE_HINT = '(/gov board)';
+export const PANEL_LEDGER_LABEL = 'ledger';
+export const PANEL_HEALTH_LABEL = 'health';
+export const PANEL_TOKEN_UNIT = 'tok';
+export const PANEL_BOARD_HINT = '/gov board';
+export const STATUS_WORD = {
+    pausing: 'pausing',
+    paused: 'paused',
+    escalated: 'escalated',
+    abandoned: 'abandoned',
+    closed: 'closed',
+};
+/** `pausing after REVIEW`: a `/gov pause` is waiting for the running stage to finish. */
+export function pausingText(stage) {
+    return stage === '' ? STATUS_WORD.pausing : `${STATUS_WORD.pausing} after ${stage}`;
+}
+/** `replaced by dev2-r1` (the glyph in front comes from the roster marker). */
+export function replacedByText(successor) {
+    return successor === null ? 'replaced' : `replaced by ${successor}`;
+}
+export function moreText(hidden) {
+    return `+${hidden} more ${MORE_HINT}`;
+}
+export function workingCountText(count) {
+    return `${count} working`;
+}
+export function phaseText(phase, phaseCount) {
+    return `p${phase}/${phaseCount}`;
+}
+export function phaseLongText(phase, phaseCount) {
+    return `phase ${phase}/${phaseCount}`;
+}
+/** Board tab names, in tab order. */
+export const BOARD_TAB_LABEL = {
+    roster: 'Roster',
+    work: 'Work packages',
+    ledger: 'Ledger',
+    claims: 'Claims',
+};
+export const BOARD_TITLE = 'Governance board';
+export const BOARD_EMPTY = {
+    noRun: 'No governed run yet. Use /gov or Shift+Tab to enter GOVERN.',
+    roster: 'No agents yet.',
+    work: 'No work packages recorded for this view.',
+    ledger: 'No ledger entries yet.',
+    claims: 'No claims or escalations.',
+};
+export const BOARD_COPIED = 'Copied the board file path';
+export const BOARD_NO_PATH = 'No board file path is available yet';
+export const CARD_TITLE = 'Governance';
+export const CARD_COLUMNS = {
+    id: 'id',
+    role: 'role',
+    confirmed: 'confirmed',
+    delta: 'delta',
+};

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

@@ -0,0 +1,145 @@
+/**
+ * Governance status: snapshot -> display derivations (governance-mode section 10.3).
+ *
+ * Pure: no Ink, no clock (callers inject `now`), no I/O. ASCII ONLY.
+ *
+ * WHAT LIVES HERE AND WHAT DOES NOT. The panel, the chip, the card and the board each
+ * need the same few JUDGEMENTS - which colour a score label gets, whether a score change
+ * is still inside its emphasis window, which pipeline step is current, what an agent's
+ * state looks like to `team-status.ts`. Putting each judgement here once is the same
+ * discipline `team-status.ts` records: the roster, the card and the chip used to disagree
+ * about what "running" looked like because nine files each answered it.
+ *
+ * COLOUR IS A SEMANTIC KEY, NOT A THEME FIELD. The layout modules emit `Tone` values and
+ * the components resolve them through `toneColor`, so a layout test never needs a `Theme`
+ * and a theme change never touches a layout.
+ */
+import type { GovAgentState, GovernanceSnapshot, RosterRow, RunStatus, StageKind } from '../governance/types.js';
+import type { ChildStatus } from './team-status.js';
+import type { Theme } from './theme.js';
+/** Semantic colour slots shared by every governance surface. */
+export type Tone = 'text' | 'muted' | 'hint' | 'border' | 'primary' | 'govern' | 'ok' | 'warn' | 'error' | 'pending' | 'running';
+/** Resolve a tone against a theme. The ONLY place a `Tone` becomes a colour. */
+export declare function toneColor(tone: Tone, theme: Theme): string | undefined;
+/** A run of text in one tone: the unit every layout line is made of. */
+export interface Segment {
+    text: string;
+    tone: Tone;
+    bold?: boolean;
+}
+export declare function segment(text: string, tone: Tone, bold?: boolean): Segment;
+export declare function govChildStatus(state: GovAgentState): ChildStatus;
+export declare function statusTone(status: ChildStatus): Tone;
+/** How a standing label reads on screen. */
+export type ScoreTone = 'ok' | 'warn' | 'danger' | 'muted';
+export declare function scoreTone(label: RosterRow['label']): ScoreTone;
+export declare function scoreToneKey(label: RosterRow['label']): Tone;
+/** The short word for a label in the roster's tag column; `NORMAL` says nothing. */
+export declare function labelTag(label: RosterRow['label']): string;
+/** Scored agents start here; the gauge is full at this value. */
+export declare const GAUGE_FULL_SCORE: 100;
+export declare const GAUGE_CELLS = 10;
+/**
+ * Filled cells of the 10-cell score gauge: `round(confirmed / 100 * 10)` clamped to
+ * [0, 10] (spec 10.3). Non-finite input draws an empty bar rather than throwing - the
+ * gauge is decoration over a number that is printed beside it.
+ */
+export declare function gaugeFilledCells(confirmed: number): number;
+/** `115+` when the score is over the starting value, otherwise the plain number. */
+export declare function scoreText(confirmed: number): string;
+/** How long a score change stays emphasised on its row. */
+export declare const DELTA_EMPHASIS_MS = 4000;
+export interface DeltaCell {
+    /** `+10` / `-20`, or '' when the row has nothing to say. */
+    text: string;
+    tone: Tone;
+    bold: boolean;
+}
+/** Signed delta text; a provisional gain carries the `P` suffix (`+15P`). */
+export declare function signedDeltaText(delta: number, provisional: boolean): string;
+/**
+ * The emphasised delta of a row.
+ *
+ * Motion allowed: bold + coloured for `DELTA_EMPHASIS_MS` after the change, then gone.
+ * Reduced motion: nothing is time-windowed, so nothing flashes - the delta stays, plain,
+ * until the engine replaces or clears `lastDelta` at the next phase (spec 10.3 "the
+ * increment text is kept until the next phase"). A zero delta says nothing in either mode.
+ */
+export declare function deltaCell(row: RosterRow, now: number, reducedMotion: boolean): DeltaCell;
+/** The display modes of the legion panel (spec 10.3 mount rules). */
+export type GovernancePanelMode = 'none' | 'run-strip' | 'panel';
+/**
+ * Mount rule (D-17): a running stage -> the full panel (which REPLACES the team roster);
+ * a live run between stages -> the two-line strip; no run, a closed run or an abandoned
+ * run -> nothing at all (zero rows, zero layout shift).
+ */
+export declare function governancePanelMode(snapshot: GovernanceSnapshot | null): GovernancePanelMode;
+/** Which component owns the bottom transient region's live roster. */
+export type LiveRosterSurface = 'governance' | 'team' | 'none';
+/**
+ * EXACTLY ONE LIVE ROSTER (D-17 / AC-25). A running governed stage owns the region even
+ * though the same children are also in `state.team` (the reducer still writes it for
+ * `/agents`); between stages the two-line strip shows only when no dispatch is live; with
+ * no live governed run the team roster behaves exactly as it always did.
+ */
+export declare function liveRosterSurface(snapshot: GovernanceSnapshot | null, teamLive: boolean): LiveRosterSurface;
+export declare function isFinishedRun(status: RunStatus): boolean;
+/** Agents currently doing something: the minimal tier's "4 working". */
+export declare function workingCount(snapshot: GovernanceSnapshot): number;
+/** Display position in the pipeline: the active step's key, or the stage, or null. */
+export declare function activeStepKey(snapshot: GovernanceSnapshot): StageKind | null;
+/** Tokens spent by the governed team (spec 8.5: team tokens, never the session total). */
+export declare function teamTokens(snapshot: GovernanceSnapshot): number;
+/**
+ * Budget readout for the chip's `$` hint: 'none' without a budget, 'warn' from 80%,
+ * 'over' from 100% (spec 8.5). Only budgets > 0 are budgets.
+ */
+export declare function budgetState(snapshot: GovernanceSnapshot): 'none' | 'ok' | 'warn' | 'over';
+/** Short run id for the header: the last five alphanumerics, so ids that share a prefix differ. */
+export declare function shortRunId(runId: string): string;
+/** Phase at which each eliminated id was FIRST seen eliminated. */
+export type EliminatedSince = Readonly<Record<string, number>>;
+/**
+ * Fold a snapshot into the first-seen-eliminated map.
+ *
+ * WHY THE PANEL KEEPS THIS ITSELF: `RosterRow` carries no "eliminated in phase N" field,
+ * and the board still needs the full roster from the same snapshot, so the engine cannot
+ * simply drop the row. A member that disappears from the map's keys (never happens) or
+ * that was never seen eliminated is treated as "eliminated now" by `isRetired`. Returns
+ * the SAME object when nothing changed so React memo / ref comparisons stay cheap.
+ */
+export declare function trackEliminated(previous: EliminatedSince, snapshot: GovernanceSnapshot): EliminatedSince;
+/**
+ * True when an eliminated member's one visible phase is over: it was first seen in an
+ * earlier phase than the one now displayed.
+ */
+export declare function isRetired(row: RosterRow, phase: number, since: EliminatedSince): boolean;
+/**
+ * Roster order: DEV -> REV -> TEST -> INSP, active members before eliminated ones, then
+ * by generation and id so `dev2` precedes its successor `dev2-r1` and the order is total
+ * (a stable roster does not reshuffle between snapshots).
+ */
+export declare function sortRoster(roster: readonly RosterRow[]): RosterRow[];
+/**
+ * `PLAN+GOVERN  interview round 2/2+` while rounds are still owed, and `... 2/2 OK` once
+ * the minimum is met (governance-mode 10.6). The trailing `+` reads "at least this many":
+ * the model may ask more rounds than the minimum.
+ */
+export declare function interviewChipText(round: number, required: number): string;
+/**
+ * A `/gov pause` is waiting for the running stage to finish (governance-mode-v1-1 6.4).
+ * Only meaningful while the run is still `executing`: once it is `paused` the request has
+ * been redeemed, and an `escalated` run drops it.
+ */
+export declare function isPausePending(snapshot: GovernanceSnapshot): boolean;
+/** True for the two governed postures, given a mode OR posture value as a string. */
+export declare function isGovernedModeValue(value: string | null | undefined): boolean;
+/**
+ * The status row's word for a mode OR a posture. `MODE_LABEL` answers for `build` /
+ * `plan` (so the byte-identical pre-governance output is preserved); the two governed
+ * postures are the only values that reach the second table.
+ *
+ * Short form: the first letter, except `plan_govern` which is `PG` - `P` is already PLAN
+ * and a status row that cannot tell them apart has defeated the badge.
+ */
+export declare function modeWord(value: string, full: boolean): string | undefined;