@aragon-agent/cli 0.6.43 → 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/LiveTail.d.ts

@@ -32,7 +32,9 @@
  * so a four-row first turn was pushed against the composer and every unused row sat ABOVE
  * the conversation. `tailAnchor` therefore sums the estimated height of exactly the
  * entries this frame renders and asks for `flex-start` while they fit - the conversation
- * is then written downwards from under the header, the way a terminal writes.
+ * is then written downwards from the region's top row, the way a terminal writes. (That row
+ * belongs to the band: `tui-header-leaks-into-scrollback` moved the identity row below the
+ * composer, so nothing sits between the newest printed row and the first row of the tail.)
  *
  * THE OVERFLOW FRAME STAYS `flex-end`, AND THAT IS THE OTHER HALF OF THE FIX.
  * `flex-start` PLUS `overflow="hidden"` clips the NEWEST rows (Ink's clip rectangle is

package/dist/ui/scrollback/budget.d.ts

@@ -12,15 +12,20 @@
  * and every row it did not ask for became `gap` - blank rows ABOVE the content, which
  * is what the user reported as "the app starts halfway down the screen" and as "a big
  * blank between the result and the running card". The band now takes the whole pool
- * (`fill`), so the region is `[header][band][composer][status]` top to bottom and
+ * (`fill`), so the region is `[band][composer][identity][status]` top to bottom and
  * `gap` cannot exist: `resolveCanvasLayout` is given `frameRows === capacity` and
  * derives `gap = 0` (see the spec's §5.5 proof, which is why the writer needs no
  * change at all).
  *
  * The composer, popup and status rows come from the SAME `buildFrameBudget` the
  * full-screen layout uses, so the two modes cannot disagree about how tall the
- * editor is. What differs is the top: the header is a real slot here (D3), and the
- * row it occupies is spent from the region, not from the printed transcript.
+ * editor is. What differs is the top: the identity row is a real slot here (D3), and
+ * the row it occupies is spent from the region, not from the printed transcript.
+ * THE COUNT IS ALL THIS MODULE OWNS, NOT THE POSITION: since
+ * `tui-header-leaks-into-scrollback` the identity row is drawn between the composer and
+ * the status group (`ScrollbackShell.tsx`), because region row 0 is necessarily the
+ * successor of the newest printed row and chrome there lands inside the conversation.
+ * Moving it changed no number below: it is still 1 row, still taken out of `remaining`.
  *
  * THIS IS THE ONLY CALL SITE OF `buildLiveBand` (I-8). `remaining` is computed here
  * once and handed to the band; an `App` that computed its own copy would make
@@ -58,9 +63,10 @@ export interface ScrollbackBudget {
     /** Terminal below the 40x12 floor: the region is a one-row placeholder. */
     inactive: boolean;
     /**
-     * The header slot, a real row inside the region (D3). 0 on a degraded frame: the
-     * placeholder draws no header, and reporting 1 there would break the row identity
-     * (I-F4) on exactly the frames `/perf` is read to explain.
+     * The identity slot, a real row inside the region (D3), drawn between the composer and
+     * the status group. 0 on a degraded frame: the placeholder draws no header, and
+     * reporting 1 there would break the row identity (I-F4) on exactly the frames `/perf` is
+     * read to explain.
      */
     headerRows: number;
     statusRows: 0 | 1 | 2;

package/dist/ui/scrollback/budget.js

@@ -12,15 +12,20 @@
  * and every row it did not ask for became `gap` - blank rows ABOVE the content, which
  * is what the user reported as "the app starts halfway down the screen" and as "a big
  * blank between the result and the running card". The band now takes the whole pool
- * (`fill`), so the region is `[header][band][composer][status]` top to bottom and
+ * (`fill`), so the region is `[band][composer][identity][status]` top to bottom and
  * `gap` cannot exist: `resolveCanvasLayout` is given `frameRows === capacity` and
  * derives `gap = 0` (see the spec's §5.5 proof, which is why the writer needs no
  * change at all).
  *
  * The composer, popup and status rows come from the SAME `buildFrameBudget` the
  * full-screen layout uses, so the two modes cannot disagree about how tall the
- * editor is. What differs is the top: the header is a real slot here (D3), and the
- * row it occupies is spent from the region, not from the printed transcript.
+ * editor is. What differs is the top: the identity row is a real slot here (D3), and
+ * the row it occupies is spent from the region, not from the printed transcript.
+ * THE COUNT IS ALL THIS MODULE OWNS, NOT THE POSITION: since
+ * `tui-header-leaks-into-scrollback` the identity row is drawn between the composer and
+ * the status group (`ScrollbackShell.tsx`), because region row 0 is necessarily the
+ * successor of the newest printed row and chrome there lands inside the conversation.
+ * Moving it changed no number below: it is still 1 row, still taken out of `remaining`.
  *
  * THIS IS THE ONLY CALL SITE OF `buildLiveBand` (I-8). `remaining` is computed here
  * once and handed to the band; an `App` that computed its own copy would make
@@ -56,9 +61,11 @@ export function buildScrollbackBudget(input) {
     }
     // D1 · H = C. `frameRows` is `rows - 1` by construction (`layout/budget.ts`), so the
     // region ends exactly on the row above the writer's parked cursor.
+    // The identity row is drawn at the BOTTOM now; it is still one row and still deducted
+    // here, which is why `liveRows`, `bandRows` and `previewRows` did not move with it.
     const headerRows = 1;
     const liveRows = Math.max(1, base.frameRows);
-    // The whole pool: everything between the header and the status line. Two independent
+    // The whole pool: everything above the composer slot. Two independent
     // derivations put its floor at 1, so `max(0, ...)` is defensive only:
     //  1. `composerSlotRows = 2 + clampDraftRows(rows, draftRows)` and
     //     `draftMaxRows(rows) = max(1, min(6, floor(rows / 4)))`, so on the narrowest

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/scrollback/tail-anchor.d.ts

@@ -7,7 +7,9 @@
  * `justifyContent="flex-end"` therefore pushed those four rows against the composer and
  * left every unused row ABOVE the conversation - the "the first reply starts at the
  * bottom of the screen" report. The answer is conditional anchoring: top while the
- * content fits, so the conversation is written downwards from under the header.
+ * content fits, so the conversation is written downwards from the region's top row
+ * (`tui-header-leaks-into-scrollback` took the identity row off that row and put it
+ * below the composer, so the first line of the band is now the first line of the screen).
  *
  * WHY THE FALLBACK IS `bottom` AND NOT THE OTHER WAY ROUND. `flex-start` inside an
  * `overflow="hidden"` box clips the NEWEST rows (Ink's clip rectangle is the box's
@@ -26,7 +28,8 @@
  * parameters and a unit test can drive it with any table it likes.
  */
 import type { Entry } from '../../agent/reducer.js';
-/** `top` = content grows down from the header; `bottom` = newest row hugs the composer. */
+/** `top` = content grows down from the region's top row; `bottom` = newest row hugs the
+ *  composer. */
 export type TailAnchor = 'top' | 'bottom';
 /**
  * Which alignment the live tail should use for the entries it is about to render.

package/dist/ui/scrollback/tail-anchor.js

@@ -7,7 +7,9 @@
  * `justifyContent="flex-end"` therefore pushed those four rows against the composer and
  * left every unused row ABOVE the conversation - the "the first reply starts at the
  * bottom of the screen" report. The answer is conditional anchoring: top while the
- * content fits, so the conversation is written downwards from under the header.
+ * content fits, so the conversation is written downwards from the region's top row
+ * (`tui-header-leaks-into-scrollback` took the identity row off that row and put it
+ * below the composer, so the first line of the band is now the first line of the screen).
  *
  * WHY THE FALLBACK IS `bottom` AND NOT THE OTHER WAY ROUND. `flex-start` inside an
  * `overflow="hidden"` box clips the NEWEST rows (Ink's clip rectangle is the box's