@aragon-agent/cli 0.6.44 → 0.6.46

package/dist/ui/App.js

@@ -16,7 +16,7 @@ import { computeCost } from '../agent/usage.js';
 import { parseMaxTokensInput, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from '../config/schema.js';
 import { updatePersistedConfig } from '../config/store.js';
 import { appendPrompt, loadPromptHistory } from '../config/prompt-history.js';
-import { bumpSubmitCount, setMouseNoticeVersion, setPromptKeyNoticeVersion, setScrollModeNoticeVersion, setVtInputNoticeVersion, } from '../config/ui-state.js';
+import { bumpSubmitCount, getGovernanceIntroSeen, setGovernanceIntroSeen, setMouseNoticeVersion, setPromptKeyNoticeVersion, setScrollModeNoticeVersion, setVtInputNoticeVersion, } from '../config/ui-state.js';
 import { getLogger } from '../logging/logger.js';
 import { isTerminalStatus } from '../proc/types.js';
 import { getSecrets } from '../logging/secret-registry.js';
@@ -33,6 +33,13 @@ import { Composer } from './Composer.js';
 import { StatusBar } from './StatusBar.js';
 import { secondsLeft } from '../agent/retry-view.js';
 import { TeamPanel } from './TeamPanel.js';
+import { GovernancePanel, useEliminatedSince } from './GovernancePanel.js';
+import { GovernanceBoardOverlay } from './overlays/GovernanceBoardOverlay.js';
+import { governancePanelMode, liveRosterSurface } from './governance-status.js';
+import { buildGovernancePanelLayout } from './layout/governance-panel.js';
+import { boardDataFromRun, boardDataFromSnapshot, } from './layout/governance-board.js';
+import { isGovernancePosture, nextPosture, splitPosture, } from '../governance/posture.js';
+import { GOVERN_INTRO_NOTICE, PLAN_APPROVED_TOAST, PLAN_GOVERN_INTRO_NOTICE, posturePendingToast, postureAppliedToast, stageRunningToast, } from '../governance/copy.js';
 import { TodoPanel } from './TodoPanel.js';
 import { BottomStatusRow } from './BottomStatusRow.js';
 // Only the updater's pure visibility predicate enters the status detail plan.
@@ -85,10 +92,11 @@ import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, } from './ove
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
 import { QuestionOverlay } from './overlays/QuestionOverlay.js';
 import { PlanReviewOverlay } from './overlays/PlanReviewOverlay.js';
-import { CommandRegistry, runSlashInput } from '../commands/registry.js';
+import { CommandRegistry, parseSlashInput, runSlashInput, } from '../commands/registry.js';
+import { buildInvocationCard, invocationCardsEnabled } from '../agent/invocation-card.js';
 import { registerBuiltinCommands } from '../commands/builtins.js';
 import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js';
-import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
+import { MODE_TOGGLE_KEYS } from '../agent/agent-mode.js';
 import { createClipboardCoordinator } from './clipboard-task.js';
 import { QueuePanel } from './QueuePanel.js';
 import { QueueOverlay } from './overlays/QueueOverlay.js';
@@ -140,6 +148,16 @@ export function resolveSettingsMaxTokens(raw, previous) {
         toast: ['warn', 'Max tokens must be a number or "auto".'],
     };
 }
+/**
+ * The `/gov board` overlay's data: the full run when the controller can supply it (all four
+ * tabs), else the snapshot alone (the Work packages and Claims tabs then say they are empty).
+ */
+function governanceBoardData(controller, snapshot) {
+    if (snapshot === null)
+        return null;
+    const input = controller.getGovernanceBoardInput?.();
+    return input ? boardDataFromRun({ snapshot, ...input }) : boardDataFromSnapshot(snapshot);
+}
 /** Services in a non-terminal state, from the live snapshot map. */
 function liveServiceCount(services) {
     let n = 0;
@@ -354,6 +372,9 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const reducedMotion = cfg.reducedMotion ?? false;
     const stateRef = useRef(state);
     stateRef.current = state;
+    // The first-seen-eliminated map for the legion panel (a replaced member shows for one
+    // phase). A hook, so it is called unconditionally here and read further down.
+    const eliminatedSince = useEliminatedSince(state.governance);
     /**
      * The task label's two guards (tui-shortcut-drawer-and-task-summary D-10).
      *
@@ -826,14 +847,22 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     submitRef.current(gate.message, { userInitiated: false, todoPolicy: 'continue' });
                 }, FORCED_NUDGE_GRACE_MS);
             }
-            // A deferred `plan -> build` becomes real here and nowhere else (§3.2).
-            const applied = controller.applyPendingMode();
+            // A deferred `plan -> build` (or any posture change that waited for a governed
+            // stage, governance-mode D-23) becomes real here and nowhere else (§3.2).
+            const applied = controller.applyPendingPosture();
             if (applied) {
-                dispatch({ type: 'setAgentMode', mode: applied.effective, pending: null });
+                const split = splitPosture(applied.effective);
+                dispatch({
+                    type: 'setAgentMode',
+                    mode: split.mode,
+                    pending: null,
+                    posture: applied.effective,
+                    pendingPosture: applied.pending,
+                });
                 dispatch({
                     type: 'pushToast',
                     level: 'info',
-                    text: `${MODE_LABEL[applied.effective]} mode.`,
+                    text: postureAppliedToast(applied.effective),
                 });
             }
         });
@@ -965,6 +994,25 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             controller.dispose();
         };
     }, [controller]);
+    // --- Governance event stream (governance-mode 8.6 / 14.4). --------------
+    //
+    // ANOTHER CLI-LOCAL SUBSCRIPTION, for the reason the team one records: `GovernanceEvent`
+    // is deliberately not a member of core's `AgentEvent` union. The wiring throttles the
+    // chatty updates; this effect only folds snapshots into the view, appends the four kinds
+    // of settlement card (charter, phase, escalation, final) and clears the live snapshot when
+    // the run ends. A no-op unsubscribe when governance was not registered.
+    useEffect(() => {
+        return controller.subscribeGovernance((event) => {
+            dispatch({ type: 'govSnapshot', snapshot: event.snapshot });
+            const card = event.type === 'run_started' || event.type === 'stage_ended' ? event.card
+                : event.type === 'escalation' || event.type === 'run_closed' ? event.card
+                    : null;
+            if (card)
+                dispatch({ type: 'governanceCard', card });
+            if (event.type === 'run_closed')
+                dispatch({ type: 'govEnd' });
+        });
+    }, [controller]);
     // --- Todo event stream (todo-plan-execution §3.8 / §5.2). --------------
     //
     // A THIRD SUBSCRIPTION, for the reason the team one records: `TodoEvent` is
@@ -1386,7 +1434,14 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // reducer's `'build'` seed would render one wrong frame without this.
     useEffect(() => {
         const current = controller.getAgentMode();
-        dispatch({ type: 'setAgentMode', mode: current, pending: null });
+        const posture = controller.getPostureState();
+        dispatch({
+            type: 'setAgentMode',
+            mode: current,
+            pending: null,
+            posture: posture.effective,
+            pendingPosture: posture.pending,
+        });
     }, [controller]);
     // --- Let the controller drive command-list rebuilds. -------------------
     useEffect(() => {
@@ -1776,19 +1831,50 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
      * what was requested: dispatching the request is the one way to make the badge
      * claim a permission the gate will not honour.
      */
-    const applyMode = (next, opts = {}) => {
-        const applied = controller.setAgentMode(next, opts.force ? { force: true } : {});
-        dispatch({ type: 'setAgentMode', mode: applied.effective, pending: applied.pending });
+    const applyPosture = (next, opts = {}) => {
+        const applied = controller.setPosture(next, opts.force ? { force: true } : {});
+        const split = splitPosture(applied.effective);
+        // THE ADOPTED VALUES, all four in one dispatch (governance-mode 4.3).
+        dispatch({
+            type: 'setAgentMode',
+            mode: split.mode,
+            pending: applied.pending ? splitPosture(applied.pending).mode : null,
+            posture: applied.effective,
+            pendingPosture: applied.pending,
+        });
         if (opts.silent)
             return applied;
         if (applied.pending) {
-            toast('info', `${MODE_LABEL[applied.pending]} mode applies after this run.`);
+            toast('info', controller.isGovernanceStageRunning()
+                ? stageRunningToast(applied.pending)
+                : posturePendingToast(applied.pending));
         }
         else {
-            toast('info', `${MODE_LABEL[applied.effective]} mode.`);
+            toast('info', postureAppliedToast(applied.effective));
+            // One-time, across launches: what GOVERN means (governance-mode 4.3).
+            if (isGovernancePosture(applied.effective) && !getGovernanceIntroSeen()) {
+                setGovernanceIntroSeen(true);
+                dispatch({
+                    type: 'notice',
+                    level: 'info',
+                    text: applied.effective === 'plan_govern' ? PLAN_GOVERN_INTRO_NOTICE : GOVERN_INTRO_NOTICE,
+                });
+            }
         }
         return applied;
     };
+    /**
+     * The gate-mode view of the same write path, for `/plan`: a plain `plan` / `build`
+     * request names a classic posture, so it CLEARS governance (an explicit command beats
+     * an implicit carry-over, governance-mode 4.2).
+     */
+    const applyMode = (next, opts = {}) => {
+        const applied = applyPosture(next, opts);
+        return {
+            effective: splitPosture(applied.effective).mode,
+            pending: applied.pending ? splitPosture(applied.pending).mode : null,
+        };
+    };
     /**
      * Cancel any in-flight label call and make its result unadoptable.
      *
@@ -1857,8 +1943,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             dispatch({ type: 'taskSummaryReady', view: outcome.view });
         });
     };
+    const invocationCardsOn = invocationCardsEnabled();
     const makeCtx = (args) => ({
         args,
+        invocationCards: invocationCardsOn,
         requestCopy: copyCoordinator.requestCopy,
         controller,
         state: stateRef.current,
@@ -1971,6 +2059,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         },
         refreshSkills: () => setSkillsNonce((n) => n + 1),
         applyAgentMode: applyMode,
+        applyPosture: (next, opts) => applyPosture(next, opts ?? {}),
         // Read at command time, so `/todo status` reports the live count rather than
         // whatever it was when this context was built.
         followBudget: budgetRef.current,
@@ -2035,10 +2124,17 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // must be the one that runs, whichever branch it takes.
         cancelFollowThrough();
         cancelConfirmation();
+        // THE ONE PLACE A CARD IS BUILT (tui-invocation-cards I-3 / I-6): redact -> normalise ->
+        // limit, with the same redactor the `Command:` echo uses. `message` below is the model's
+        // input and is never touched; the card only replaces what the TRANSCRIPT shows.
+        const card = invocationCardsOn && opts.invocation
+            ? buildInvocationCard(opts.invocation, (text) => redactText(text, getSecrets()))
+            : undefined;
+        const shown = card?.commandLine ?? message;
         if (interactionPhase.current === 'running' || controller.isCompactionBusy?.()) {
             try {
                 const queueId = controller.queueUserMessage(message);
-                dispatch({ type: 'steerQueued', queueId, text: message });
+                dispatch({ type: 'steerQueued', queueId, text: shown, ...(card ? { invocation: card } : {}) });
                 return { accepted: true };
             }
             catch (error) {
@@ -2057,7 +2153,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // the user has learned, so suppressing the fade is correct rather than
         // incidental — which is why the parameter is named for the CAUSE (P2-8).
         if (opts.userInitiated !== false) {
-            recordPrompt(message);
+            // A card's command line was already recorded by `executeSlashInput`; the payload
+            // behind it must never reach the up-arrow history (I-9: the gate is unchanged).
+            if (!card)
+                recordPrompt(message);
             // THE ONE PLACE THE NUDGE BUDGET IS REFILLED (P0-2 / I-10). Same predicate
             // as `recordPrompt`, and for the same reason: the question is "did a human
             // ask for this?", and only a human may hand the gate another attempt. A
@@ -2068,7 +2167,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // Mirrors where the reducer clears its own copies, in the same action
         // (C-11): a new turn's end reason must not inherit the previous one's.
         endReasonRef.current = { aborted: false, errored: false };
-        dispatch({ type: 'submit', text: message });
+        dispatch({ type: 'submit', text: shown, ...(card ? { invocation: card } : {}) });
         const pre = controller.preflight();
         if (!pre.ok) {
             dispatch({ type: 'runError' });
@@ -2088,7 +2187,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // model call that describes a turn nobody ran; and below, in the queueing
         // branch, the message is steering rather than a new task.
         if (opts.userInitiated !== false)
-            ensureTaskSummary(message);
+            ensureTaskSummary(shown);
         void controller.prompt(message, { todoPolicy: opts.todoPolicy ?? 'new-task' }).then((outcome) => {
             if (!mounted.current || sequence !== submissionSequence.current)
                 return;
@@ -2127,7 +2226,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // Retain a recoverable command before any asynchronous handler can fail.
         const safe = redactText(raw, getSecrets());
         recordPrompt(safe);
-        notify('info', `Command: ${safe}`);
+        // The echo is suppressed BEFORE the command runs and never deleted afterwards: printed
+        // scrollback rows cannot be rewritten (I-5). The predicate is the command's own (I-8).
+        const parsed = parseSlashInput(raw);
+        const rendersCard = invocationCardsOn && parsed !== null
+            && registry.get(parsed.name)?.rendersInvocationCard?.(parsed.args) === true;
+        if (!rendersCard)
+            notify('info', `Command: ${safe}`);
         try {
             await runSlashInput(registry, raw, makeCtx);
         }
@@ -2275,8 +2380,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // here would read `'plan'` and the badge would lag by a frame. Writing it
             // first through the same single path makes the tool's call an idempotent
             // no-op and keeps the mirror exact (§3.1 / R-P7).
-            applyMode('build', { force: true, silent: true });
-            toast('success', 'Plan approved. Implementing.');
+            // PLAN+GOVERN hands over to the team instead of implementing: the same single write
+            // path, with governance kept on (governance-mode 9.2).
+            const governed = controller.getPosture() === 'plan_govern';
+            applyPosture(governed ? 'govern' : 'build', { force: true, silent: true });
+            toast('success', governed ? PLAN_APPROVED_TOAST : 'Plan approved. Implementing.');
         }
         else {
             toast('info', 'Revision requested.');
@@ -2593,6 +2701,9 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                 // The Agents board pages through `overlayScroll` too, but keeps Up/Down for its
                 // CHILD CURSOR - the same trade `settings` makes with its field cursor.
                 || overlay === 'agents'
+                // The governance board (governance-mode 10.5): without this line a PgDn in the
+                // board falls through to the transcript behind it.
+                || overlay === 'governance'
                 // The prompt surfaces page themselves through `overlayScroll` too
                 // (quick-prompt-library appendix B-1). Without them a `PgDn` in the list does
                 // nothing and the wheel falls through to the transcript behind it.
@@ -2630,7 +2741,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         if ((key.tab && key.shift) || (key.ctrl && (input === 'n' || input === 'N'))) {
             if (stateRef.current.overlay)
                 return;
-            applyMode(nextMode(controller.getAgentMode()));
+            // The cycle's basis is `pending ?? effective`: with a change already waiting, a second
+            // press must advance from it, or it would hold on the same target (governance-mode 4.1).
+            const postureNow = controller.getPostureState();
+            applyPosture(nextPosture(postureNow.pending ?? postureNow.effective, controller.getPostureCycle()));
             return;
         }
         // Moved off Ctrl+L by D-1, because Ctrl+L is the branch key now.
@@ -2945,10 +3059,32 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             ? Math.max(0, viewportBudget - 1)
             : Math.max(0, viewportBudget - composerBaseRows - queueLayout.rows - 1),
     });
+    // THE LEGION PANEL REPLACES THE TEAM ROSTER while a governed stage runs (D-17, AC-25):
+    // one live roster, never two. Between stages it is a two-line run strip, and it yields to
+    // a non-governed dispatch if one is somehow live. Its height feeds the same two budgets
+    // the roster's does, so the band and the rail never learn a second number.
+    // PLAN+GOVERN's interview chip on the question overlay (governance-mode 9.3).
+    const interviewState = state.posture === 'plan_govern' ? controller.getGovernanceInterview?.() : null;
+    const interviewProps = interviewState
+        ? { interview: { round: interviewState.answered, required: interviewState.required } }
+        : {};
+    const governanceMode = governancePanelMode(state.governance);
+    const governanceLayout = state.governance !== null
+        && liveRosterSurface(state.governance, state.team !== null) === 'governance'
+        ? buildGovernancePanelLayout({
+            cols: native ? Math.max(1, cols - 1) : baseRail.contentCols, rows,
+            snapshot: state.governance, glyphs, reducedMotion, now: Date.now(),
+            mode: governanceMode === 'panel' ? 'panel' : 'run-strip', eliminatedSince,
+            availableRows: native
+                ? Math.max(0, viewportBudget - 1)
+                : Math.max(0, viewportBudget - composerBaseRows - queueLayout.rows - 1),
+        })
+        : null;
+    const teamPanelRows = governanceLayout ? governanceLayout.height : teamLayout.rowCount;
     const railLayout = buildTodoRailLayout({
         cols: cols - 1, panelEnabled: cfg.todo.panel, overlayOpen: false,
         itemCount: state.todos?.items.length ?? 0, viewportBudget,
-        teamRows: teamLayout.rowCount, queueRows: queueLayout.rows, popupRows: 0, composerBaseRows,
+        teamRows: teamPanelRows, queueRows: queueLayout.rows, popupRows: 0, composerBaseRows,
     });
     const { visible: railVisible, width: railWidth, rows: railRows, contentCols } = railLayout;
     // The FULL-SCREEN rail only: native mode draws its rail inside the live region's
@@ -2983,7 +3119,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // second time (`buildTeamPanelLayout` stays the single authority).
         itemCount: state.todos?.items.length ?? 0,
         panelEnabled: cfg.todo.panel,
-        teamRowsNatural: teamLayout.rowCount,
+        teamRowsNatural: teamPanelRows,
         // The top give-way measures a window entry's height, and an expanded tool card is a
         // different height from a collapsed one - a forgotten value would print rows the region
         // is not drawing.
@@ -3079,14 +3215,16 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // mounted with `{...props}` and an undeclared prop arrives as
         // `undefined`. A construction-time snapshot, so reading it per frame is
         // honest (I-7).
-        teamRegistered: controller.isTeamRegistered(), probe: probe, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
+        teamRegistered: controller.isTeamRegistered(), governanceRegistered: controller.isGovernanceRegistered(), probe: probe, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
         // Read from `cfg` (render scope, re-read every frame), so `/retry off`
         // while the screen is open shows the new value on the next paint.
         retrySummary: cfg.retry.enabled && cfg.retry.maxRetries > 0 ? String(cfg.retry.maxRetries) : 'off' })) : overlay === 'agents' ? (
     // THE BRANCH AND THE `Overlay` MEMBER SHIP TOGETHER (R-11): a missing branch is not
     // a type error, it is a SILENT BLANK FRAME, because `active={overlay === null}` has
     // already disabled the transcript underneath.
-    _jsx(AgentsBoardOverlay, { team: state.team, entries: state.entries, cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, isActive: !tooSmall, native: native, theme: theme, caps: caps })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { isActive: !tooSmall, state: confirmState, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { isActive: !tooSmall, questions: humanRequest.questions, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }) })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { isActive: !tooSmall, plan: humanRequest.plan, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;
+    _jsx(AgentsBoardOverlay, { team: state.team, entries: state.entries, cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, isActive: !tooSmall, native: native, theme: theme, caps: caps })) : overlay === 'governance' ? (
+    // THE BRANCH AND THE `Overlay` MEMBER SHIP TOGETHER (R-11), like `agents` above.
+    _jsx(GovernanceBoardOverlay, { data: governanceBoardData(controller, state.governance), cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, isActive: !tooSmall, theme: theme, caps: caps, onCopyPath: (path) => { void copyCoordinator.requestCopy({ text: path, lines: 1 }); }, onNotice: toast })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { isActive: !tooSmall, state: confirmState, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { isActive: !tooSmall, questions: humanRequest.questions, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }), ...interviewProps })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { isActive: !tooSmall, plan: humanRequest.plan, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;
     const density = cfg.density;
     const transcriptWindow = cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW;
     // The fixed status bar remains visible underneath every overlay and toast.
@@ -3207,7 +3345,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         stopping: interruptGesture.current.phase === 'stopping',
         interruptPhase: interruptGesture.current.phase,
         compacting: compactionLive || !!state.compaction?.inFlight,
-        mode: state.agentMode, pendingMode: state.pendingAgentMode,
+        mode: state.posture, pendingMode: state.pendingPosture,
         servicesActive: { live: liveServices }, ecoRung: governor.rung,
         // THE STATUS-DETAIL ROW COUNTS LIKE THE ROSTER AND THE CHIP (A-1): this was the
         // last inline phase filter, left behind when the StatusBar chip converged, and it
@@ -3227,11 +3365,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             selectionPending: selectionController?.hasPendingSelection() ?? false,
             copyInFlight: copyState.busy, copyCleanupPending: copyState.cleanupPending,
             hasDraft: hasDraftRef.current, services: liveServices,
-            hintsEnabled: cfg.hints, modeToggleKey,
+            hintsEnabled: cfg.hints, modeToggleKey, governed: isGovernancePosture(state.posture),
+            ...(state.governance?.pauseRequested === true ? { govPausePending: true } : {}),
             interruptPhase: interruptGesture.current.phase,
             updateAvailable: !!updateSnapshot && shouldRenderUpdateLine(updateSnapshot) } });
-    const composer = (_jsx(Composer, { deleteDisambiguated: terminal?.deleteDisambiguated ?? false, onCompletionContextChange: setCompletion, cols: frameBudget.composerCols, terminalRows: rows, statusExpanded: statusExpanded, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: false, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: frameBudget.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onDraftRows: onDraftRows, onDraftPresence: onDraftPresence, draftClearNonce: draftClearNonce, ...(draftFill ? { draftFill } : {}), insertMode: cfg.prompts?.insertMode ?? 'insert', onNotice: notify, theme: theme, caps: caps, onSubmit: handleSubmit, onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
-    const team = state.team ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: contentCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
+    const composer = (_jsx(Composer, { deleteDisambiguated: terminal?.deleteDisambiguated ?? false, onCompletionContextChange: setCompletion, cols: frameBudget.composerCols, terminalRows: rows, statusExpanded: statusExpanded, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: false, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, posture: state.posture, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: frameBudget.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onDraftRows: onDraftRows, onDraftPresence: onDraftPresence, draftClearNonce: draftClearNonce, ...(draftFill ? { draftFill } : {}), insertMode: cfg.prompts?.insertMode ?? 'insert', onNotice: notify, theme: theme, caps: caps, onSubmit: handleSubmit, onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
+    const team = governanceLayout ? (_jsx(GovernancePanel, { layout: governanceLayout, theme: theme, caps: caps })) : state.team ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: contentCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     // --- Native panel band (release-gate-and-native-panels §6.3/§6.4) -------------
     //
     // SEPARATE NODES, NOT THE TWO ABOVE (RV-P1-7). Those carry `cols={contentCols}` for
@@ -3252,7 +3391,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // out against `previewCols` would stop its clock one rail short of the screen's edge.
     // `teamRowGeometry` is continuous in `cols`, so the number that decides whether the
     // panel mounts IS the number it lays out against.
-    const nativeTeam = state.team && nativeBand ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: nativeBandCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
+    const nativeTeam = governanceLayout && nativeBand ? (_jsx(GovernancePanel, { layout: governanceLayout, theme: theme, caps: caps })) : state.team && nativeBand ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: nativeBandCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const rail = fullscreenRailVisible && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: running, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const viewport = (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: overlayNode, footer: _jsxs(_Fragment, { children: [team, _jsx(QueuePanel, { layout: queueLayout, theme: theme })] }), rail: rail, scrollbar: terminal?.scrollbar, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, onGeometryChange: onGeometryChange, geometryKey: `${rows}:${cols}:${viewportBudget}:${frameBudget.composerSlotRows}:${frameBudget.statusRows}:${contentCols}:${overlay}:${tooSmall}`, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: transcriptEntries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] }));
     const detailsNode = _jsx(BottomStatusRow, { plan: details, columns: viewCols, theme: theme });
@@ -3264,7 +3403,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // partially stale. The window and its `known` flag now travel INSIDE
         // it, resolved by the meter - which is what makes the user's
         // `contextWindow` override reach the bar.
-        context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ...(forcedTeam ? { forcedTeam } : {}), ecoRung: governor.rung, ...(state.team
+        context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.posture, pendingAgentMode: state.pendingPosture, governance: state.governance, ...(forcedTeam ? { forcedTeam } : {}), ecoRung: governor.rung, ...(state.team
             ? {
                 // `rosterCounts`, NOT a fourth inline phase filter (A-1): the chip and
                 // the roster header above it must never disagree.

package/dist/ui/BottomStatusRow.js

@@ -4,6 +4,6 @@ import React from 'react';
 import { Box, Text } from 'ink';
 export function BottomStatusRow({ plan, columns, theme }) {
     const tones = { normal: theme.primary, muted: theme.muted, warning: theme.noticeWarn, error: theme.noticeError,
-        accent: theme.accent };
+        accent: theme.accent, govern: theme.governAccent };
     return _jsxs(Box, { height: 1, width: columns, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { children: " " }) }), plan.fields.map((field, index) => _jsxs(React.Fragment, { children: [index > 0 && _jsx(Box, { width: plan.separatorCells, flexShrink: 0, children: _jsx(Text, { color: theme.muted, children: plan.separator }) }), _jsx(Box, { width: field.cells, flexShrink: 0, children: _jsx(Text, { wrap: "truncate", color: tones[field.tone], children: field.text }) })] }, field.id))] });
 }

package/dist/ui/Composer.d.ts

@@ -44,6 +44,12 @@ export interface ComposerProps {
     hintsEnabled: boolean;
     /** Mirror of the controller's effective mode; drives the border. */
     agentMode: AgentMode;
+    /**
+     * The adopted posture (governance-mode 10.2). A governed one paints the idle/draft
+     * border in `governAccent`, the same slot PLAN uses `accent` for. Absent = the
+     * pre-governance border logic, unchanged.
+     */
+    posture?: string;
     /** Compatibility prop; the global action row names the effective mode key. */
     modeToggleKey?: string;
     popupMaxRows?: number;
@@ -105,5 +111,5 @@ declare function hintText(opts: {
 }): string;
 /** Compatibility export for existing hint contract tests. */
 export declare const hintTextForTest: typeof hintText;
-export declare function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, draftFill, insertMode, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+export declare function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, posture, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, draftFill, insertMode, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
 export {};

package/dist/ui/Composer.js

@@ -5,6 +5,7 @@ import { Box } from 'ink';
 import { HINT_FADE_AFTER } from '../config/schema.js';
 import { PromptInput } from './PromptInput.js';
 import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
+import { isGovernedModeValue } from './governance-status.js';
 /** Legacy helper retained for consumers and contract tests; not rendered by Composer. */
 export function runningHintClauses(opts) {
     const { glyphs, services } = opts;
@@ -36,7 +37,7 @@ function hintText(opts) {
 }
 /** Compatibility export for existing hint contract tests. */
 export const hintTextForTest = hintText;
-export function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, draftFill, insertMode, onNotice, theme, caps, onSubmit, onHelp, }) {
+export function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, posture, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, draftFill, insertMode, onNotice, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => {
         setHasDraft(next.hasDraft);
@@ -52,10 +53,12 @@ export function Composer({ deleteDisambiguated, onCompletionContextChange, cols,
         ? theme.toolPending
         : running
             ? theme.toolRunning
-            : agentMode === 'plan'
-                ? theme.accent
-                : hasDraft
-                    ? theme.focusBorder ?? theme.primary
-                    : theme.idleBorder ?? theme.border;
+            : isGovernedModeValue(posture)
+                ? theme.governAccent
+                : agentMode === 'plan'
+                    ? theme.accent
+                    : hasDraft
+                        ? theme.focusBorder ?? theme.primary
+                        : theme.idleBorder ?? theme.border;
     return (_jsx(Box, { ref: measureRef, width: cols, flexDirection: "column", flexShrink: 0, children: _jsx(PromptInput, { deleteDisambiguated: deleteDisambiguated, onCompletionContextChange: onCompletionContextChange, cols: cols, terminalRows: terminalRows, statusExpanded: statusExpanded, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, borderColor: borderColor, onDraftChange: onDraftChange, draftClearNonce: draftClearNonce, draftFill: draftFill, insertMode: insertMode, onNotice: onNotice }) }));
 }

package/dist/ui/GovernancePanel.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 React from 'react';
+import type { GovernanceSnapshot } from '../governance/types.js';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+import { type EliminatedSince } from './governance-status.js';
+import type { GovernancePanelLayout } from './layout/governance-panel.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 declare function useEliminatedSince(snapshot: GovernanceSnapshot | null): EliminatedSince;
+export interface GovernancePanelProps {
+    /** Built by `buildGovernancePanelLayout`; the SAME object `App` read the height from. */
+    layout: GovernancePanelLayout;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+export declare function GovernancePanel({ layout, theme, caps }: GovernancePanelProps): React.ReactElement | null;

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;