@aragon-agent/cli 0.6.44 → 0.6.45

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,

package/dist/ui/palettes.d.ts

@@ -71,6 +71,17 @@ export interface Palette {
         fg: string;
         bg: string;
     };
+    /**
+     * The GOVERN / PLAN+GOVERN posture badge, the legion panel title and the status chip
+     * (governance-mode section 10.7).
+     *
+     * A hue of its own, pinned by `palettes.test.ts`: >= 4.5:1 against THIS palette's own
+     * surface and >= 30 degrees away from the six semantic hues it must never be confused
+     * with (`primary`, `accent`, `user`, `toolDone`, `noticeWarn`, `noticeError`) - the
+     * last four because governance score gains and losses are drawn in `toolDone` /
+     * `noticeError` right beside it. The numbers below are the measured starting points.
+     */
+    governAccent: string;
 }
 /**
  * The reference dark background these palettes are contrast-checked against.
@@ -79,6 +90,12 @@ export interface Palette {
  * text unreadable.
  */
 export declare const DARK_SURFACE = "#1c1917";
+/**
+ * The reference background of the `LIGHT` palette. `LIGHT` text is dark-on-light, so
+ * contrast-checking it against `DARK_SURFACE` would pass a pair that is unreadable in
+ * the only place it is ever used (the same trap `selectionBg` documents).
+ */
+export declare const LIGHT_SURFACE = "#ffffff";
 /** Terracotta + amber over warm neutrals — the v0.4.0 default. */
 export declare const WARM: Palette;
 /** The v0.3.0 palette, renamed. Reachable via `--theme cool` / `theme: "dark"`. */

package/dist/ui/palettes.js

@@ -18,6 +18,12 @@
  * text unreadable.
  */
 export const DARK_SURFACE = '#1c1917';
+/**
+ * The reference background of the `LIGHT` palette. `LIGHT` text is dark-on-light, so
+ * contrast-checking it against `DARK_SURFACE` would pass a pair that is unreadable in
+ * the only place it is ever used (the same trap `selectionBg` documents).
+ */
+export const LIGHT_SURFACE = '#ffffff';
 /** Terracotta + amber over warm neutrals — the v0.4.0 default. */
 export const WARM = {
     primary: '#d08c60',
@@ -46,6 +52,7 @@ export const WARM = {
     diff: { add: '#7fb08a', remove: '#cf6b5c', meta: '#d08c60', context: '#a2968a' },
     toast: { info: '#d08c60', warn: '#c9a227', error: '#cf6b5c', success: '#7fb08a' },
     chip: { fg: '#1c1917', bg: '#d08c60' },
+    governAccent: '#B79CED',
 };
 /** The v0.3.0 palette, renamed. Reachable via `--theme cool` / `theme: "dark"`. */
 export const COOL = {
@@ -75,6 +82,7 @@ export const COOL = {
     diff: { add: '#9ece6a', remove: '#f7768e', meta: '#7aa2f7', context: '#7a86b8' },
     toast: { info: '#7aa2f7', warn: '#e0af68', error: '#f7768e', success: '#9ece6a' },
     chip: { fg: '#1a1b26', bg: '#7aa2f7' },
+    governAccent: '#73DACA',
 };
 export const LIGHT = {
     primary: '#2959aa',
@@ -103,6 +111,7 @@ export const LIGHT = {
     diff: { add: '#2e7d32', remove: '#c62828', meta: '#2959aa', context: '#6b7280' },
     toast: { info: '#2959aa', warn: '#b5730f', error: '#c62828', success: '#2e7d32' },
     chip: { fg: '#ffffff', bg: '#2959aa' },
+    governAccent: '#A8327A',
 };
 /**
  * Resolve a theme name to its palette.

package/dist/ui/scrollback/live-preview.js

@@ -95,6 +95,8 @@ function entryRows(entry, input) {
             return [fit(firstLine(entry.text), cols)];
         case 'service':
             return [];
+        case 'governance':
+            return [fit(`Governance: ${entry.card.title}`, cols)];
         default: {
             const exhaustive = entry;
             return exhaustive;

package/dist/ui/scrollback/settled-boundary.js

@@ -61,6 +61,9 @@ export function isEntryStable(entry, runActive, isTail) {
         case 'service':
             // Only the terminal record is ever a candidate; `isExcluded` filters the rest.
             return entry.terminal === true;
+        case 'governance':
+            // A settlement card is appended once, already complete.
+            return true;
         default: {
             const exhaustive = entry;
             return exhaustive;

package/dist/ui/shortcuts.js

@@ -84,11 +84,11 @@ export const SHORTCUTS = [
     },
     {
         id: 'shift-tab', keys: 'Shift+Tab', keyword: 'plan mode', group: 'run', availability: 'always',
-        detail: 'Toggles BUILD and PLAN; writes are refused and the agent only investigates.',
+        detail: 'Cycles BUILD / PLAN / GOVERN / PLAN+GOVERN. PLAN refuses writes; GOVERN runs a governed team.',
     },
     {
         id: 'ctrl-n', keys: 'Ctrl+N', keyword: 'plan mode', group: 'run', availability: 'always',
-        detail: 'The same toggle, for Windows consoles that cannot deliver Shift+Tab.',
+        detail: 'The same cycle (BUILD / PLAN / GOVERN / PLAN+GOVERN), for consoles that cannot deliver Shift+Tab.',
     },
     {
         id: 'ctrl-t', keys: 'Ctrl+T', keyword: 'thinking', group: 'run', availability: 'always',

package/dist/ui/theme.d.ts

@@ -84,6 +84,13 @@ export interface Theme {
         fg: Color;
         bg: Color;
     };
+    /**
+     * The GOVERN posture colour (governance-mode section 10.7). Hex above ansi-256 and
+     * `undefined` at level 0 like every other token, but PINNED to `magenta` at 16 colours
+     * instead of the nearest-ANSI search: that search lands COOL's teal on cyan, which is
+     * `user`'s colour, and the badge exists to be unmistakable.
+     */
+    governAccent: Color;
 }
 export declare function getTheme(name: ThemeName, caps: TermCapabilities): Theme;
 export {};

package/dist/ui/theme.js

@@ -123,6 +123,7 @@ export function getTheme(name, caps) {
             success: d(palette.toast.success),
         },
         chip: { fg: d(palette.chip.fg), bg: d(palette.chip.bg) },
+        governAccent: level === 1 ? 'magenta' : d(palette.governAccent),
     };
     cache.set(key, theme);
     return theme;

package/dist/ui/transcript-text.js

@@ -2,6 +2,7 @@ import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../age
 import { formatRetryLine } from '../agent/retry-view.js';
 import { childStatus, outcomePhrase, rosterCounts, statusMarkerCell } from './team-status.js';
 import { expandTabs } from './display-tab.js';
+import { governanceCardLines } from './layout/governance-card.js';
 const DEFAULT_MAX_ENTRIES = 200;
 const CONTINUATION_INDENT = '  ';
 const TOOL_INDENT = '  ';
@@ -195,6 +196,14 @@ function renderEntry(entry, glyphs) {
                     `${entry.status}${where}${code}`.trimEnd(),
             ];
         }
+        case 'governance': {
+            // A settlement card is the record of what a governed run decided and scored; an
+            // exported transcript that omitted it would be unaccountable for the run (the
+            // argument the `team`, `retry` and `fast` cases make in their own words). Same
+            // lines as the card, without colour.
+            const lines = governanceCardLines(entry.card, glyphs);
+            return lines.map((line, index) => `${TOOL_INDENT}${index === 0 ? glyphs.teamAgent : ' '} ${line}`.trimEnd());
+        }
         case 'notice': {
             const glyph = entry.level === 'error'
                 ? glyphs.error

package/dist/ui/use-wheel-routing.js

@@ -118,7 +118,9 @@ export function useWheelRouting(options) {
                 // The Agents board (tui-subagent-panel §6.5). Missing this line makes the
                 // wheel fall through to the transcript BEHIND the open board, which reads
                 // as a frozen list and a jumping transcript at the same time.
-                || overlay === 'agents';
+                || overlay === 'agents'
+                // The governance board pages through `overlayScroll` too (governance-mode 10.5).
+                || overlay === 'governance';
             if (!controlled)
                 return;
             // D-3: the row is not consulted here either. Behind an overlay the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.44",
+  "version": "0.6.45",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.56",
+    "@aragon-agent/core": "^0.2.57",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",