@aragon-agent/cli 0.6.43 → 0.6.45

package/dist/ui/GovernancePanel.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * GovernancePanel - the legion panel (governance-mode section 10.3).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`, through the layout.
+ *
+ * THIS COMPONENT ONLY COLOURS AND PLACES. Every decision - which tier, which columns, how
+ * wide, what each cell says, which row is hidden - was made by
+ * `layout/governance-panel.ts`, and the `layout` prop is REQUIRED: `App` builds it once to
+ * learn the panel's height (the native band and the TODO rail both budget against it) and
+ * hands the very same object here, so the number that decides whether the panel mounts is
+ * the number it is drawn from. A panel that re-planned itself could draw a taller tier than
+ * the one the band reserved, and the band clips the overflow in silence.
+ *
+ * IT REPLACES `TeamPanel` WHILE A GOVERNED STAGE RUNS (D-17), it does not stack with it:
+ * the repo has been bitten by a "double roster" once (tui-subagent-double-roster), and a
+ * governed dispatch is the one case where two live rosters would be the same children
+ * listed twice.
+ *
+ * NO `ink-spinner` HERE, on purpose. While a governed stage runs the lead's turn is
+ * running, the activity row owns the one spinner (single-spinner-while-running), and every
+ * panel is handed the widened reduced-motion signal anyway - an animation here would never
+ * play. The working marker is `statusGlyph(...)`, and `reducedMotion` is the USER's
+ * preference: it only decides whether a score change flashes for four seconds or stays put.
+ *
+ * COLUMNS ARE FIXED-WIDTH BOXES with exactly one elastic cell (`governance-roster.ts`), the
+ * lesson `TeamPanel` records at length: a flex-grown column under a fixed-height parent
+ * stretches to its widest child and the cells to its right lose their offsets.
+ */
+import { useRef } from 'react';
+import { Box, Text } from 'ink';
+import { pickGlyphs } from './glyphs.js';
+import { trackEliminated } from './governance-status.js';
+import { GovernanceLine } from './GovernanceRun.js';
+import { PANEL_MARGIN_CELLS, } from './layout/governance-roster.js';
+/**
+ * The first-seen-eliminated map, kept across snapshots so a replaced member shows its
+ * `replaced by ...` note for exactly one phase. Reset when the run changes or ends.
+ *
+ * A ref written during render is acceptable here because the write is idempotent
+ * (`trackEliminated` returns the same object when nothing is new) and no other component
+ * reads the ref - `App` reads only the returned value.
+ */
+export function useEliminatedSince(snapshot) {
+    const ref = useRef({ runId: null, since: {} });
+    if (snapshot === null) {
+        if (ref.current.runId !== null)
+            ref.current = { runId: null, since: {} };
+        return ref.current.since;
+    }
+    const base = ref.current.runId === snapshot.runId ? ref.current.since : {};
+    ref.current = { runId: snapshot.runId, since: trackEliminated(base, snapshot) };
+    return ref.current.since;
+}
+function Margin() {
+    return (_jsx(Box, { width: PANEL_MARGIN_CELLS, flexShrink: 0, children: _jsx(Text, { children: " " }) }));
+}
+function LineView({ line, theme }) {
+    return (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Margin, {}), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(GovernanceLine, { segments: line.left, theme: theme }) }), line.rightCells > 0 && (_jsx(Box, { width: line.rightCells, flexShrink: 0, justifyContent: "flex-end", children: _jsx(GovernanceLine, { segments: line.right, theme: theme }) }))] }));
+}
+function CellView({ cell, theme }) {
+    const content = _jsx(GovernanceLine, { segments: cell.segments, theme: theme });
+    if (cell.elastic) {
+        return _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: content });
+    }
+    return (_jsx(Box, { width: cell.width, flexShrink: 0, overflow: "hidden", justifyContent: cell.align === 'right' ? 'flex-end' : 'flex-start', children: content }));
+}
+function RosterView({ line, theme }) {
+    return (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Margin, {}), line.cells.map((cell) => (_jsx(CellView, { cell: cell, theme: theme }, cell.key)))] }));
+}
+export function GovernancePanel({ layout, theme, caps }) {
+    if (layout.height === 0 || layout.header === null)
+        return null;
+    const glyphs = pickGlyphs(caps);
+    const rule = layout.ruleCells > 0 ? (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Margin, {}), _jsx(Text, { wrap: "truncate", color: theme.border, children: glyphs.hrule.repeat(layout.ruleCells) })] })) : null;
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", flexShrink: 0, children: [_jsx(LineView, { line: layout.header, theme: theme }), layout.pipeline !== null && _jsx(LineView, { line: layout.pipeline, theme: theme }), rule, layout.rosterRows.map((line) => (_jsx(RosterView, { line: line, theme: theme }, line.key))), layout.overflow !== null && (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Margin, {}), _jsx(Text, { wrap: "truncate", color: theme.muted, children: layout.overflow })] })), rule, layout.ticker.map((line, index) => (_jsx(LineView, { line: line, theme: theme }, `ticker-${index}`)))] }));
+}

package/dist/ui/GovernanceRun.d.ts

@@ -0,0 +1,18 @@
+/**
+ * GovernanceRun - paints one `Segment[]` run: the single place a governance layout's
+ * semantic tones become Ink colours.
+ *
+ * ASCII ONLY. The panel, the card and the board all draw the same `Segment` vocabulary,
+ * and three private copies of this loop is how their bold / tone handling drifts apart.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import { type Segment } from './governance-status.js';
+export interface GovernanceRunProps {
+    segments: readonly Segment[];
+    theme: Theme;
+}
+/** The segments as nested `Text`; the CALLER owns wrapping and truncation. */
+export declare function GovernanceRun({ segments, theme }: GovernanceRunProps): React.ReactElement;
+/** One display row: the run inside a `wrap="truncate"` `Text`, so it can never wrap. */
+export declare function GovernanceLine({ segments, theme }: GovernanceRunProps): React.ReactElement;

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

@@ -11,7 +11,7 @@
  * off its `clearTerminal` branch (that branch fires at `outputHeight >= rows` and
  * contains `ESC[3J`, which erases the user's scrollback).
  *
- * Top to bottom: [header][overlay | panel band][composer][status][details].
+ * Top to bottom: [overlay | panel band][composer][identity][status][details].
  *
  * THE PANEL BAND IS THE PART NATIVE MODE WAS MISSING
  * (release-gate-and-native-panels §6.1). A fixed frame can put a rail beside the
@@ -40,11 +40,39 @@
  * content would make the region taller than `budget.liveRows`, and a frame as tall as
  * the terminal makes Ink erase the user's scrollback.
  *
+ * THE IDENTITY ROW IS A BOTTOM SLOT, NOT THE FIRST ONE
+ * (tui-header-leaks-into-scrollback, plan A-prime). It is still `budget.headerRows` tall
+ * and still spent out of the region's pool - only its ORDER changed:
+ *  - position is not cosmetic here, it is the whole defect. The writer lays the canvas out
+ *    as `[gap][content][region]` and only CONTENT rows ever scroll out (`canvas.ts`), so
+ *    region row 0 is by construction the successor of the newest row in the terminal's
+ *    scrollback. A tall reply gives way at the top (`overflow-print.ts`: head printed,
+ *    tail on screen), so chrome parked on row 0 is read BETWEEN two rows of the SAME
+ *    answer: the user's report is the word mark, `provider:model`, `cwd`, the key and
+ *    `^G more` appearing in the middle of a finished reply.
+ *  - the bottom slots have no such property: nothing below the band is ever printed or
+ *    scrolled, so `[composer][identity][status][details]` stays outside the conversation
+ *    for a reply of any length. That band is also the one the writer protects on purpose
+ *    (I-B17: give way at the TOP, because the composer and the status line are the two
+ *    rows the human is interacting with).
+ *  - the two surrounding slots are NOT interchangeable. Above the composer would also
+ *    dodge the seam, but it would break the promise that the newest line hugs the input
+ *    box (`canvas.ts`, `tail-anchor.ts`); below the status group would split the
+ *    `[status][details]` pair, and "the status is the screen's last row" is its own
+ *    invariant (`tui-duplicate-status-row`); inside the band's row pool would change
+ *    `previewRows`, and no budget number may move for this fix.
+ *  - `app` mode (`layout/AppShell.tsx`) deliberately keeps its header on TOP, so the two
+ *    modes do NOT agree and must not be "unified": there the header sits above a viewport
+ *    that scrolls itself, so there is no print channel and no seam to leak into.
+ *  - `headerRows` is still produced by `buildScrollbackBudget` alone (still 1, still
+ *    subtracted from `remaining`), so `liveRows`, `bandRows`, `previewRows` and `railCols`
+ *    are unchanged: a row ORDER change, not a row BUDGET change.
+ *  - the row is still NOT printed into the scrollback: at `H = rows - 1` any printed row
+ *    is pushed off the screen by the next frame, so "print the header" would mean "the
+ *    header is never visible".
+ *
  * THE BAND'S PREVIEW BOX IS TOP-ALIGNED; THE OTHER SLOTS ARE FIXED
  * (D3 / D4 / I-F7; tui-first-reply-bottom-aligned, plan A-prime):
- *  - `header` is the fixed 1-row slot at the very top. It is NOT printed into the
- *    scrollback any more: at `H = rows - 1` any printed row is pushed off the screen by
- *    the next frame, so "print the header" would mean "the header is never visible".
  *  - the band's preview box is TOP-aligned unconditionally, which is why the alignment is
  *    no longer a function of `opener`. `opener` is a 12-row card in a 24-row column, so
  *    bottom-aligning it left 12 blank rows in the upper half of the screen - the original
@@ -71,9 +99,9 @@ import type { ScrollbackBudget } from './scrollback/budget.js';
 export interface ScrollbackShellProps {
     budget: ScrollbackBudget;
     /**
-     * REQUIRED: the one-row slot at the top of the region, `budget.headerRows` tall.
-     * Required rather than optional for the reason `budget` and `band` are - a frame
-     * that forgot it would render a header-less screen with nothing to catch it.
+     * REQUIRED: the identity row, `budget.headerRows` tall, drawn BETWEEN the composer and
+     * the status group. Required rather than optional for the reason `budget` and `band` are
+     * - a frame that forgot it would render a header-less screen with nothing to catch it.
      */
     header: React.ReactNode;
     /** Shown instead of the band when an overlay is open. */

package/dist/ui/ScrollbackShell.js

@@ -22,5 +22,5 @@ export function ScrollbackShell({ budget, header, overlay, liveTailLines, opener
     const top = band.reason === 'overlay' ? (_jsx(Box, { flexDirection: "column", height: budget.overlayRows, flexShrink: 0, overflow: "hidden", children: overlay })) : band.bandRows > 0 ? (
     // ROW REGION ABOVE, FULL-WIDTH ROSTER BELOW (tui-subagent-panel §4.1.2 / D-2).
     _jsxs(Box, { flexDirection: "column", height: band.bandRows, flexShrink: 0, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "row", height: rowRegion, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", width: budget.previewCols, height: rowRegion, flexShrink: 0, overflow: "hidden", children: band.previewRows > 0 && (_jsx(Box, { flexDirection: "column", height: band.previewRows, flexShrink: 0, justifyContent: "flex-start", overflow: "hidden", children: leftColumn ?? tailLines.map((line, index) => (_jsx(Text, { wrap: "truncate", color: theme.muted, children: line }, index))) })) }), band.railRows > 0 && (_jsx(Box, { height: band.railRows, width: band.railCols, flexShrink: 0, overflow: "hidden", children: rail }))] }), band.teamRows > 0 && (_jsx(Box, { width: width, height: band.teamRows, flexShrink: 0, overflow: "hidden", children: team }))] })) : null;
-    return (_jsxs(Box, { flexDirection: "column", height: budget.liveRows, width: width, overflow: "hidden", flexShrink: 0, children: [budget.headerRows > 0 && (_jsx(Box, { height: budget.headerRows, flexShrink: 0, overflow: "hidden", children: header })), top, _jsx(Box, { flexDirection: "column", height: budget.composerSlotRows, justifyContent: "flex-end", flexShrink: 0, overflow: "hidden", children: composer }), _jsx(Box, { height: budget.statusRows > 0 ? 1 : 0, flexShrink: 0, overflow: "hidden", children: status }), budget.statusRows === 2 && (_jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: details }))] }));
+    return (_jsxs(Box, { flexDirection: "column", height: budget.liveRows, width: width, overflow: "hidden", flexShrink: 0, children: [top, _jsx(Box, { flexDirection: "column", height: budget.composerSlotRows, justifyContent: "flex-end", flexShrink: 0, overflow: "hidden", children: composer }), budget.headerRows > 0 && (_jsx(Box, { height: budget.headerRows, flexShrink: 0, overflow: "hidden", children: header })), _jsx(Box, { height: budget.statusRows > 0 ? 1 : 0, flexShrink: 0, overflow: "hidden", children: status }), budget.statusRows === 2 && (_jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: details }))] }));
 }

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

@@ -12,6 +12,7 @@ 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';
@@ -118,6 +119,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/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',
+};