@aragon-agent/cli 0.6.44 → 0.6.46

package/dist/ui/overlays/GovernanceBoardOverlay.js

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

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

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

package/dist/ui/overlays/GovernanceSettingsPage.js

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

package/dist/ui/overlays/HelpOverlay.js

@@ -47,7 +47,7 @@ export function allKeyRows(times) {
         // product's word for transcript line offset (the header chip and the row below),
         // so abbreviating the mode fallback would put two meanings of `^` on one screen
         // (quick-prompt-library D-1 / P1-7).
-        ['Shift+Tab / Ctrl+N', 'Toggle plan mode (same as /plan)'],
+        ['Shift+Tab / Ctrl+N', 'Cycle BUILD / PLAN / GOVERN / PLAN+GOVERN (/plan and /gov pick one)'],
         ['Ctrl+P', 'Quick prompt library: manage, create, reorder, pick'],
         // The ladder clears a draft first (ctrl-c-clear-draft-exit):
         // with a draft x2 clears the input and x3 exits; an empty input
@@ -117,7 +117,8 @@ const COMMANDS = [
     ['/task refresh', 'Regenerate the header task summary from the last prompt'],
     ['/model', 'Open the model picker'],
     ['/settings', 'Open the settings screen'],
-    ['/plan [on|off|status]', 'Toggle plan mode (same as Shift+Tab)'],
+    ['/plan [on|off|status]', 'Toggle plan mode (leaves GOVERN)'],
+    ['/gov [on|plan|off|board|status]', 'Governed team: enter, leave, the board, the run status'],
     ['/theme <name>', 'auto | warm | cool | light'],
     ['/thinking <level>', 'Set thinking level'],
     ['/max-tokens [n|auto]', 'Output token cap; no argument reports the effective one'],
@@ -165,7 +166,7 @@ const SKILL_ROWS = [
     ['skill / skill_install', 'Tools the model uses to load and install skills'],
 ];
 const PLAN_ROWS = [
-    ['Shift+Tab / /plan', 'Switch between BUILD (do it now) and PLAN (research first)'],
+    ['Shift+Tab / /plan', 'Switch BUILD (do it now) and PLAN (research first); Shift+Tab also cycles GOVERN'],
     // A ROW OF ITS OWN, not a third name on the line above: the reader who needs
     // this one is the reader whose `Shift+Tab` does nothing, and what they need is
     // the reason, not another synonym. Listing the key in both places instead just

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

@@ -26,6 +26,14 @@ interface QuestionOverlayProps {
     theme: Theme;
     caps: TermCapabilities;
     onSubmit: (answers: Answer[]) => void;
+    /**
+     * PLAN+GOVERN interview progress (governance-mode 9 / 10.6). Present only in that
+     * posture; absent leaves the title byte-identical to the pre-governance overlay.
+     */
+    interview?: {
+        round: number;
+        required: number;
+    };
 }
-export declare function QuestionOverlay({ isActive, questions, maxRows, cols, theme, caps, onSubmit, }: QuestionOverlayProps): React.ReactElement;
+export declare function QuestionOverlay({ isActive, questions, maxRows, cols, theme, caps, onSubmit, interview, }: QuestionOverlayProps): React.ReactElement;
 export {};

package/dist/ui/overlays/QuestionOverlay.js

@@ -22,6 +22,7 @@ import { wrapToRows } from '../layout/wrap-rows.js';
 import { OverlayFrame, overlayBodyRows } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
 import { stripEnterFrames } from '../enter-frames.js';
+import { interviewChipText } from '../governance-status.js';
 /** Which option index each question starts on: the recommended one. */
 function initialCursors(questions) {
     return questions.map((q) => Math.max(0, q.options.findIndex((o) => o.recommended)));
@@ -32,7 +33,7 @@ function initialSelections(questions) {
         return new Set(recommended >= 0 ? [recommended] : [0]);
     });
 }
-export function QuestionOverlay({ isActive = true, questions, maxRows, cols, theme, caps, onSubmit, }) {
+export function QuestionOverlay({ isActive = true, questions, maxRows, cols, theme, caps, onSubmit, interview, }) {
     const glyphs = pickGlyphs(caps);
     const [step, setStep] = useState(0);
     const [phase, setPhase] = useState('choosing');
@@ -215,6 +216,7 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
     });
     const title = phase === 'review' ? 'Review your answers' : 'Clarify the request';
     const position = phase === 'review' ? '' : `  ${step + 1}/${questions.length}`;
+    const interviewChip = interview ? `  ${interviewChipText(interview.round, interview.required)}` : '';
     const hint = phase === 'typingOther'
         ? `type your answer ${glyphs.midDot} ${glyphs.enterKey} commit ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`
         : phase === 'review'
@@ -252,5 +254,5 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
     const shortHint = phase === 'typingOther' ? 'Enter commit | Left back | Esc cancel'
         : phase === 'review' ? 'Enter submit | Left back | Esc cancel'
             : '^v choose Space select Enter next Esc';
-    return _jsx(OverlayFrame, { title: `${title}${position}`, hint: cols <= 48 ? shortHint : hint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, rows: rowTexts.map((line, index) => _jsx(Text, { wrap: "truncate", children: line || ' ' }, index)), scrollOffset: offset, onScrollClamp: setOffset });
+    return _jsx(OverlayFrame, { title: `${title}${position}${interviewChip}`, hint: cols <= 48 ? shortHint : hint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, rows: rowTexts.map((line, index) => _jsx(Text, { wrap: "truncate", children: line || ' ' }, index)), scrollOffset: offset, onScrollClamp: setOffset });
 }

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

@@ -146,6 +146,13 @@ interface SettingsScreenProps {
      * literal, and absent honestly means "unknown, so do not disclose".
      */
     teamRegistered?: boolean;
+    /**
+     * Whether the governance tools were registered when this session started
+     * (governance-mode-v1-1 5.2). Same contract as `teamRegistered`: a CONSTRUCTION-TIME
+     * snapshot, OPTIONAL, and `undefined` means "not disclosed" so no note is shown. It is
+     * what lets the page say `applies next launch` when the draft's `enabled` disagrees.
+     */
+    governanceRegistered?: boolean;
 }
 /**
  * The derived, non-editable line under the five fast rows — the sibling of

package/dist/ui/overlays/SettingsScreen.js

@@ -29,6 +29,8 @@ import { KitEditor } from './KitEditor.js';
 import { KitManager } from './KitManager.js';
 import { TeamFanoutPage } from './TeamFanoutPage.js';
 import { fanoutRows, teamFanoutValues, teamSummary } from './team-fanout-state.js';
+import { GovernanceSettingsPage } from './GovernanceSettingsPage.js';
+import { draftGovernance, governanceRestartNote, governanceSettingRows, governanceSummary, } from './governance-settings.js';
 import { heldSlots, kitManagerRows, kitPackRow, kitReducer } from './kit-settings-state.js';
 /**
  * THE ROOT PAGE'S ROW INDEXES, AS NAMES (subagent-model V-5).
@@ -42,7 +44,7 @@ import { heldSlots, kitManagerRows, kitPackRow, kitReducer } from './kit-setting
  * fifth of these and the "five offsets agreed by accident" defect does not need
  * a sequel. Order here IS the render order.
  */
-const ROOT_ROWS = ['main', 'fast', 'subagent', 'team', 'kit', 'manage'];
+const ROOT_ROWS = ['main', 'fast', 'subagent', 'team', 'governance', 'kit', 'manage'];
 const ROOT_MAIN = ROOT_ROWS.indexOf('main');
 const ROOT_FAST = ROOT_ROWS.indexOf('fast');
 const ROOT_SUBAGENT = ROOT_ROWS.indexOf('subagent');
@@ -51,6 +53,9 @@ const ROOT_SUBAGENT = ROOT_ROWS.indexOf('subagent');
 // one decision, and splitting them across the page would make the pair harder to
 // keep consistent than the pair of numbers inside it.
 const ROOT_TEAM = ROOT_ROWS.indexOf('team');
+// Governance (governance-mode-v1-1 5.2) sits right under Team: both decide the SHAPE of the
+// team, and the row is an index into this list like every other, never a typed number.
+const ROOT_GOVERNANCE = ROOT_ROWS.indexOf('governance');
 const ROOT_KIT = ROOT_ROWS.indexOf('kit');
 const ROOT_MANAGE = ROOT_ROWS.indexOf('manage');
 const ROOT_FIRST_FIELD = ROOT_ROWS.length;
@@ -693,6 +698,12 @@ function activateRootSetting(props, view) {
         // `team-fanout-page.test.tsx` asserts that Enter on this row saves nothing.
         dispatch({ type: 'page', page: 'team' });
     }
+    else if (index === ROOT_GOVERNANCE) {
+        // SAME RULE AS THE TEAM BRANCH ABOVE, and the same cost of getting it wrong: this MUST
+        // stay above the fallback `else`, which is `saveProfileSettings`. A misplaced branch
+        // compiles and silently commits the whole draft when Enter opens the page.
+        dispatch({ type: 'page', page: 'governance' });
+    }
     else if (index === ROOT_KIT) {
         // The fifth root row opens the manager, not a picker: kits are data the user
         // owns here, and `ctrl+K` is where they are CONSUMED (agent-model-kits §4.5).
@@ -858,6 +869,14 @@ function renderProfileSubpage(props, view) {
                 rows: fanoutRows(teamFanoutValues(state.draft), props.teamRegistered),
                 error: state.error,
             }, dispatch: dispatch, onBack: () => dispatch({ type: 'page', page: 'root' }) });
+    if (state.page === 'governance') {
+        const config = draftGovernance(state.draft);
+        return _jsx(GovernanceSettingsPage, { ...props, view: {
+                rows: governanceSettingRows(config),
+                error: state.error,
+                restartNote: governanceRestartNote(config.enabled, props.governanceRegistered),
+            }, dispatch: dispatch, onBack: () => dispatch({ type: 'page', page: 'root' }) });
+    }
     // THE KIT PAGES (agent-model-kits §4.5). They are dispatched BEFORE the profile
     // pages because `'kit-slot'` RENDERS a profile picker while belonging to the
     // kit editor - the page name, not the component, decides where the user is.
@@ -982,6 +1001,7 @@ function buildRootSettingsRows(props, view) {
         // four values, only two of which are about fan-out width. `padEnd(18)` is
         // unchanged, so the value column still lines up with `Subagent model`.
         `Team              ${summary}`,
+        `Governance        ${governanceSummary(draftGovernance(state.draft))}`,
         `Kit pack          ${kitPackRow(state)}`,
         `Manage profiles   ${library.entries.length} saved`,
         ...fields.map((item) => `${item.label.padEnd(18)}${item.key === 'apiKey'

package/dist/ui/overlays/governance-settings.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Settings > Governance: the pure half of the page (governance-mode 11.1).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * FIELD DEFINITIONS AND THE ARROW-KEY STEP, NOTHING ELSE. `SettingsScreen.tsx` is far past
+ * the size limit, so the page lists its rows from here and adds wiring only, mirroring
+ * `team-fanout-state.ts`. Every value a step produces goes back through
+ * `clampGovernanceConfig`, so the page, `config set` and a hand-edited `config.json` can
+ * never disagree about a range.
+ *
+ * THE PAGE MAY WRITE THE ELEVEN POLICY KEYS AND NOTHING ELSE. The structural bounds
+ * (`GOV_LIMITS`) are not settings: a number a user can tune past what the store and the
+ * panel can carry is not a preference, it is a crash.
+ */
+import { type GovernanceConfig } from '../../config/governance-config.js';
+import type { ModelSettingsDraft } from '../../config/model-profile-store.js';
+export type GovernanceSettingKey = keyof GovernanceConfig;
+export type GovernanceSettingKind = 'toggle' | 'number' | 'choice';
+export interface GovernanceSettingDef {
+    key: GovernanceSettingKey;
+    /** At most 17 columns: the page pads labels to 18, like the Team page. */
+    label: string;
+    /** One line, at most 60 columns: WHY this setting, not a restatement of the label. */
+    description: string;
+    kind: GovernanceSettingKind;
+    /** Inclusive; numbers only. Read from the clamp, never repeated here. */
+    range?: {
+        min: number;
+        max: number;
+    };
+    /** Arrow-key increment; numbers only. */
+    step?: number;
+    /** Cycle order; choices only. */
+    choices?: readonly string[];
+}
+/** The rows in cursor order. The switch is first: the rest describe what it turns on. */
+export declare const GOVERNANCE_SETTING_DEFS: readonly GovernanceSettingDef[];
+export interface GovernanceSettingRow {
+    key: GovernanceSettingKey;
+    label: string;
+    /** The value as the page prints it (`'on'` / `'3'` / `'unlimited'`). */
+    value: string;
+    /** Description plus the range, one line. */
+    hint: string;
+}
+/** The page's rows for the CLAMPED section, so the screen shows what would be saved. */
+export declare function governanceSettingRows(values: unknown): GovernanceSettingRow[];
+/**
+ * The PATCH FRAGMENT for one arrow press, for a section the screen already shows
+ * (`current`). Exactly one key, so a step can never carry a second one into the draft.
+ * Toggles flip on either arrow, as on the Team page: a direction means nothing for two
+ * states. An unknown key yields an empty patch rather than throwing.
+ */
+export declare function stepGovernanceSetting(current: unknown, key: GovernanceSettingKey, delta: -1 | 1): Partial<GovernanceConfig>;
+/**
+ * The governance section this draft would save: the patch over the disk baseline, then the
+ * clamp (governance-mode-v1-1 5.2). Same order as `teamFanoutValues`, and the clamp is not
+ * cosmetic: it is what makes the number on screen the number `Ctrl+S` writes, whatever a
+ * hand-edited `config.json` or an old patch carried.
+ */
+export declare function draftGovernance(draft: ModelSettingsDraft): GovernanceConfig;
+/**
+ * The one-line summary the settings root row prints. A DERIVED row, never a control: the
+ * values change on the page Enter opens, so the root row cannot be moved by a stray arrow.
+ * `off` alone when the switch is off, because the numbers then describe a capability that
+ * is not there (the `teamSummary` rule).
+ */
+export declare function governanceSummary(config: GovernanceConfig): string;
+export type GovernanceRestartNote = string | null;
+/**
+ * Whether saving the `enabled` switch would not take effect in THIS session. The tool array
+ * is immutable after construction (v1 D-22), so a draft that disagrees with what was
+ * registered at launch only applies next launch, and the page says so rather than letting a
+ * user believe a toggle summoned `gov_run` into the running session. `undefined` means the
+ * host did not say, and the page then discloses nothing (every fixture builds props by
+ * literal).
+ */
+export declare function governanceRestartNote(enabledInDraft: boolean, registeredAtLaunch: boolean | undefined): GovernanceRestartNote;

package/dist/ui/overlays/governance-settings.js

@@ -0,0 +1,140 @@
+/**
+ * Settings > Governance: the pure half of the page (governance-mode 11.1).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * FIELD DEFINITIONS AND THE ARROW-KEY STEP, NOTHING ELSE. `SettingsScreen.tsx` is far past
+ * the size limit, so the page lists its rows from here and adds wiring only, mirroring
+ * `team-fanout-state.ts`. Every value a step produces goes back through
+ * `clampGovernanceConfig`, so the page, `config set` and a hand-edited `config.json` can
+ * never disagree about a range.
+ *
+ * THE PAGE MAY WRITE THE ELEVEN POLICY KEYS AND NOTHING ELSE. The structural bounds
+ * (`GOV_LIMITS`) are not settings: a number a user can tune past what the store and the
+ * panel can carry is not a preference, it is a crash.
+ */
+import { clampGovernanceConfig, governanceRangeOf, } from '../../config/governance-config.js';
+import { PROFILE_IDS } from '../../governance/types.js';
+function numeric(key, label, description, step = 1) {
+    return { key, label, description, kind: 'number', range: governanceRangeOf(key), step };
+}
+/** The rows in cursor order. The switch is first: the rest describe what it turns on. */
+export const GOVERNANCE_SETTING_DEFS = [
+    { key: 'enabled', label: 'Governance', kind: 'toggle',
+        description: 'Off removes it entirely. Turning it on needs a restart.' },
+    { key: 'shiftTab', label: 'Shift+Tab cycle', kind: 'toggle',
+        description: 'Off keeps Shift+Tab on BUILD/PLAN; /gov still works.' },
+    { key: 'panel', label: 'Legion panel', kind: 'toggle',
+        description: 'Off shows the status chip only, no panel.' },
+    { key: 'profile', label: 'Profile', kind: 'choice', choices: PROFILE_IDS,
+        description: 'Domain wording for the roles and their checklists.' },
+    numeric('maxWorkPackages', 'Work packages', 'Most work packages one run may define.'),
+    numeric('maxPhases', 'Phases', 'Most dev/review/test rounds one run may take.'),
+    numeric('maxRework', 'Rework rounds', 'Rework rounds per work package before escalation.'),
+    numeric('maxFixCycles', 'Fix cycles', 'Fix cycles per phase after integration fails.'),
+    numeric('minAskRounds', 'Ask rounds', 'Questions PLAN+GOVERN asks before a plan is allowed.'),
+    numeric('budgetTokens', 'Token budget', 'Per-run token ceiling; 0 means unlimited.', 100_000),
+    { key: 'confirmCharter', label: 'Confirm charter', kind: 'toggle',
+        description: 'On asks you to approve the run plan before any dispatch.' },
+];
+function formatValue(def, config) {
+    const value = config[def.key];
+    if (def.kind === 'toggle')
+        return value ? 'on' : 'off';
+    if (def.key === 'budgetTokens')
+        return value === 0 ? 'unlimited' : String(value);
+    return String(value);
+}
+function formatHint(def) {
+    if (def.range === undefined)
+        return def.description;
+    return `${def.description} (${def.range.min}-${def.range.max})`;
+}
+/** The page's rows for the CLAMPED section, so the screen shows what would be saved. */
+export function governanceSettingRows(values) {
+    const config = clampGovernanceConfig(values);
+    return GOVERNANCE_SETTING_DEFS.map((def) => ({
+        key: def.key,
+        label: def.label,
+        value: formatValue(def, config),
+        hint: formatHint(def),
+    }));
+}
+function stepNumber(config, def, delta) {
+    const key = def.key;
+    // NO WRAPAROUND: a form control is not a ring, and Left at the floor jumping to the
+    // ceiling would be a way to raise a limit while trying to lower it. The clamp does it.
+    const next = clampGovernanceConfig({ ...config, [key]: config[key] + delta * (def.step ?? 1) });
+    return { [key]: next[key] };
+}
+function stepChoice(config, def, delta) {
+    const choices = def.choices ?? [];
+    const at = choices.indexOf(String(config[def.key]));
+    const next = choices[(at + delta + choices.length) % choices.length];
+    // Through the clamp, so a choice list that ever drifts from the clamp's vocabulary cannot
+    // write a value the read path would silently repair.
+    const stored = clampGovernanceConfig({ ...config, [def.key]: next })[def.key];
+    return { [def.key]: stored };
+}
+/**
+ * The PATCH FRAGMENT for one arrow press, for a section the screen already shows
+ * (`current`). Exactly one key, so a step can never carry a second one into the draft.
+ * Toggles flip on either arrow, as on the Team page: a direction means nothing for two
+ * states. An unknown key yields an empty patch rather than throwing.
+ */
+export function stepGovernanceSetting(current, key, delta) {
+    const config = clampGovernanceConfig(current);
+    const def = GOVERNANCE_SETTING_DEFS.find((candidate) => candidate.key === key);
+    if (def === undefined)
+        return {};
+    if (def.kind === 'toggle')
+        return { [key]: !config[key] };
+    return def.kind === 'number' ? stepNumber(config, def, delta) : stepChoice(config, def, delta);
+}
+/**
+ * The governance section this draft would save: the patch over the disk baseline, then the
+ * clamp (governance-mode-v1-1 5.2). Same order as `teamFanoutValues`, and the clamp is not
+ * cosmetic: it is what makes the number on screen the number `Ctrl+S` writes, whatever a
+ * hand-edited `config.json` or an old patch carried.
+ */
+export function draftGovernance(draft) {
+    return clampGovernanceConfig({ ...draft.baseline.governance, ...draft.patch.governance });
+}
+/** `0` is unlimited; otherwise a compact figure (`500k`, `1.2M`). */
+function budgetText(tokens) {
+    if (tokens <= 0)
+        return 'unlimited';
+    if (tokens >= 1_000_000)
+        return `${Number((tokens / 1_000_000).toFixed(1))}M`;
+    return `${Math.round(tokens / 1_000)}k`;
+}
+/**
+ * The one-line summary the settings root row prints. A DERIVED row, never a control: the
+ * values change on the page Enter opens, so the root row cannot be moved by a stray arrow.
+ * `off` alone when the switch is off, because the numbers then describe a capability that
+ * is not there (the `teamSummary` rule).
+ */
+export function governanceSummary(config) {
+    if (!config.enabled)
+        return 'off';
+    return [
+        'on',
+        `${config.maxWorkPackages} WP`,
+        `${config.maxPhases} phases`,
+        `rework ${config.maxRework}`,
+        `budget ${budgetText(config.budgetTokens)}`,
+    ].join(' | ');
+}
+/**
+ * Whether saving the `enabled` switch would not take effect in THIS session. The tool array
+ * is immutable after construction (v1 D-22), so a draft that disagrees with what was
+ * registered at launch only applies next launch, and the page says so rather than letting a
+ * user believe a toggle summoned `gov_run` into the running session. `undefined` means the
+ * host did not say, and the page then discloses nothing (every fixture builds props by
+ * literal).
+ */
+export function governanceRestartNote(enabledInDraft, registeredAtLaunch) {
+    if (registeredAtLaunch === undefined || enabledInDraft === registeredAtLaunch)
+        return null;
+    return 'Governance is registered at launch; this change applies next launch.';
+}

package/dist/ui/overlays/model-profile-state.d.ts

@@ -4,7 +4,8 @@ import type { ModelSettingsDraft } from '../../config/model-profile-store.js';
 import type { SubagentModelMode } from '../../team/model.js';
 import type { KitDraft } from './kit-settings-state.js';
 import { type TeamFanoutField } from './team-fanout-state.js';
-export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm' | 'kits' | 'kit-edit' | 'kit-slot' | 'kit-delete' | 'team';
+import { type GovernanceSettingKey } from './governance-settings.js';
+export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm' | 'kits' | 'kit-edit' | 'kit-slot' | 'kit-delete' | 'team' | 'governance';
 /**
  * `'team'` is the fan-out page (subagent-fanout D-5), and it is a PAGE rather
  * than three more fields on the root page for a measurable reason: the root page
@@ -118,6 +119,10 @@ export type ModelProfileAction = {
     type: 'team-fanout';
     field: TeamFanoutField;
     delta: -1 | 1;
+} | {
+    type: 'governance-step';
+    key: GovernanceSettingKey;
+    delta: -1 | 1;
 };
 /** Keep the original secret separate from the empty replacement field. */
 export declare function createProfileEditor(profile: ModelProfile): ProfileEditorDraft;

package/dist/ui/overlays/model-profile-state.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { emptyModelProfiles, duplicateModelProfile, normalizeModelProfiles, validateModelProfiles } from '../../config/model-profiles.js';
 import { parseContextWindowInput } from '../../config/schema.js';
 import { stepFanoutValue, teamFanoutValues } from './team-fanout-state.js';
+import { draftGovernance, stepGovernanceSetting } from './governance-settings.js';
 /** The picker's built-in `Fast tier model` row; never a profile id on disk. */
 export const SUBAGENT_FAST_ROW_ID = '__fast__';
 /** Keep the original secret separate from the empty replacement field. */
@@ -233,6 +234,15 @@ export function modelProfileReducer(state, action) {
                 draft: { ...state.draft,
                     patch: { ...state.draft.patch, team: { ...state.draft.patch.team, ...step } } } };
         }
+        case 'governance-step': {
+            // THE FRAGMENT IS THE ONLY THING WRITTEN, as for `team-fanout`: `stepGovernanceSetting`
+            // returns exactly one key, clamped, from the value the screen is showing
+            // (`draftGovernance`), so a step can never drag a second key into the patch.
+            const step = stepGovernanceSetting(draftGovernance(state.draft), action.key, action.delta);
+            return { ...state, dirty: true, error: undefined,
+                draft: { ...state.draft, patch: { ...state.draft.patch,
+                        governance: { ...state.draft.patch.governance, ...step } } } };
+        }
         case 'duplicate': {
             if (library.entries.length >= 200)
                 return { ...state,