@aragon-agent/cli 0.6.39 → 0.6.42

package/dist/ui/overlays/SettingsScreen.js

@@ -27,6 +27,8 @@ import { canProbe, editorProbeTarget, visibleProbeViews } from './model-probe-vi
 import { createModelProfileState, createCustomProfile, modelProfileReducer, profileUsers, draftTeam, draftSubagentProfileId, subagentModelSummary, subagentSelectedId, SUBAGENT_FAST_ROW_ID } from './model-profile-state.js';
 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 { heldSlots, kitManagerRows, kitPackRow, kitReducer } from './kit-settings-state.js';
 /**
  * THE ROOT PAGE'S ROW INDEXES, AS NAMES (subagent-model V-5).
@@ -40,10 +42,15 @@ 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', 'kit', 'manage'];
+const ROOT_ROWS = ['main', 'fast', 'subagent', 'team', 'kit', 'manage'];
 const ROOT_MAIN = ROOT_ROWS.indexOf('main');
 const ROOT_FAST = ROOT_ROWS.indexOf('fast');
 const ROOT_SUBAGENT = ROOT_ROWS.indexOf('subagent');
+// The fan-out page (subagent-fanout D-5). It is FOURTH, directly under the model
+// row it complements: "which model children run on" and "how many children" are
+// 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');
 const ROOT_KIT = ROOT_ROWS.indexOf('kit');
 const ROOT_MANAGE = ROOT_ROWS.indexOf('manage');
 const ROOT_FIRST_FIELD = ROOT_ROWS.length;
@@ -583,9 +590,9 @@ function useProfileSettingsState(props) {
             && ['provider', 'model', 'baseUrl', 'contextWindow', 'apiKey'].includes(item.key)),
         ...FIELDS.filter((item) => library.fastId === null
             && ['fastModel', 'fastProvider'].includes(item.key)), ...PROFILE_FIELDS];
-    // SEVEN FIXED ROWS now (Main, Fast, SUBAGENT, Kit pack, Manage, Save, Reload)
-    // around the `fields` block - derived from ROOT_ROWS so the count and the
-    // offsets cannot drift apart (see those constants).
+    // EIGHT FIXED ROWS now (Main, Fast, Subagent model, Subagent fan-out, Kit pack,
+    // Manage, Save, Reload) around the `fields` block - derived from ROOT_ROWS so
+    // the count and the offsets cannot drift apart (see those constants).
     const count = fields.length + ROOT_ROWS.length + 2;
     const field = fields[index - ROOT_FIRST_FIELD];
     const readError = state.draft.readError;
@@ -679,8 +686,15 @@ function activateRootSetting(props, view) {
         // `draft.patch.team` rather than a `${role}Id` library key.
         dispatch({ type: 'page', page: 'picker', role: 'subagent' });
     }
+    else if (index === ROOT_TEAM) {
+        // MUST STAY ABOVE THE FALLBACK `else` BELOW, WHICH IS `saveProfileSettings`
+        // (R-P1-8). A missing or mis-derived constant here does not fail to compile:
+        // pressing Enter on this row would silently COMMIT the whole draft, so
+        // `team-fanout-page.test.tsx` asserts that Enter on this row saves nothing.
+        dispatch({ type: 'page', page: 'team' });
+    }
     else if (index === ROOT_KIT) {
-        // The fourth root row opens the manager, not a picker: kits are data the user
+        // 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).
         dispatch({ type: 'page', page: 'kits' });
     }
@@ -836,6 +850,14 @@ function fastTierUnavailable(props, view) {
 }
 function renderProfileSubpage(props, view) {
     const { state, library, dispatch, setConfirmIndex } = view;
+    // THE FAN-OUT PAGE (subagent-fanout 3.4.4). Placed before the picker branch
+    // because that branch is the unconditional fallback; the page name is unique,
+    // so its position among the others is arbitrary.
+    if (state.page === 'team')
+        return _jsx(TeamFanoutPage, { ...props, view: {
+                rows: fanoutRows(teamFanoutValues(state.draft), props.teamRegistered),
+                error: state.error,
+            }, 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.
@@ -945,9 +967,21 @@ function buildRootSettingsRows(props, view) {
             profiles: state.draft.profiles,
             hasKey: (id) => (props.apiKeys[id] ?? '').length > 0 })}${kitTag}`
         : subagentLine;
+    // THE TEAM SUMMARY (subagent-fanout 3.4.4, renamed by
+    // team-command-forced-dispatch §3.9): a DERIVED row, like the three above it,
+    // and deliberately not a control - the values are adjusted on the page Enter
+    // opens, so the root row cannot change one by accident. It now summarises the
+    // WHOLE section, switch included, because `Team mode` is one of those values
+    // and a summary that always printed numbers would describe a capability the
+    // user may have just switched off.
+    const summary = teamSummary(teamFanoutValues(state.draft));
     const lines = [`Main profile      ${mainValue}`,
         `Fast profile      ${fastValue}`,
         `Subagent model    ${subagentValue}`,
+        // `Team`, not `Subagent fan-out`: the row heads a page that now owns
+        // 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}`,
         `Kit pack          ${kitPackRow(state)}`,
         `Manage profiles   ${library.entries.length} saved`,
         ...fields.map((item) => `${item.label.padEnd(18)}${item.key === 'apiKey'

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

@@ -0,0 +1,51 @@
+/**
+ * Settings > Team: four arrows-adjustable rows (subagent-fanout 3.4.3, extended
+ * by team-command-forced-dispatch §3.9).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE PAGE OWNS ONE PIECE OF STATE: its cursor. Every value comes from
+ * `props.view.rows`, which `SettingsScreen` derives from the reducer state - so
+ * this page cannot hold a second copy of the draft and then disagree with the
+ * root page about what is about to be saved (the discipline
+ * `model-profile-state.ts` records at its own head).
+ *
+ * FOUR ROWS, NOT THREE: `Team mode` moved here from `/team on|off`, because a
+ * command that both configures and executes leaves the user unable to predict
+ * what it did. The switch is the FIRST row - the other three describe a capability
+ * it turns on.
+ *
+ * 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 - the kit page included. A footer
+ * promising "Ctrl+S saves here" would therefore be a lie the user acts on. The
+ * honest instruction is the one already in their fingers: Esc back, Ctrl+S on the
+ * main page.
+ */
+import React from 'react';
+import { type ProfileFrameProps } from './ModelProfilePicker.js';
+import type { TeamFanoutField, TeamFanoutView } from './team-fanout-state.js';
+/** What the page may ask the screen to change. */
+export interface TeamFanoutAction {
+    type: 'team-fanout';
+    field: TeamFanoutField;
+    delta: -1 | 1;
+}
+interface TeamFanoutPageProps extends ProfileFrameProps {
+    view: TeamFanoutView;
+    dispatch: (action: TeamFanoutAction) => void;
+    /** Esc: back to the settings root. The draft is NOT discarded here. */
+    onBack: () => void;
+    /**
+     * Whether `task` is in this SESSION's tool list (`--no-team` is the false case).
+     *
+     * OPTIONAL, like every other pass-through on this screen: fixtures build
+     * `ProfileFrameProps` by literal, and "absent" honestly means "not disclosed"
+     * rather than "registered". When it is `false` and the draft says `on`, the
+     * `Team mode` row reads `on (next launch)` - the tool array is immutable, so
+     * that is the truth about what saving will achieve (I-7 / AC-9).
+     */
+    teamRegistered?: boolean;
+}
+export declare function TeamFanoutPage(props: TeamFanoutPageProps): React.ReactElement;
+export {};

package/dist/ui/overlays/TeamFanoutPage.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Settings > Team: four arrows-adjustable rows (subagent-fanout 3.4.3, extended
+ * by team-command-forced-dispatch §3.9).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE PAGE OWNS ONE PIECE OF STATE: its cursor. Every value comes from
+ * `props.view.rows`, which `SettingsScreen` derives from the reducer state - so
+ * this page cannot hold a second copy of the draft and then disagree with the
+ * root page about what is about to be saved (the discipline
+ * `model-profile-state.ts` records at its own head).
+ *
+ * FOUR ROWS, NOT THREE: `Team mode` moved here from `/team on|off`, because a
+ * command that both configures and executes leaves the user unable to predict
+ * what it did. The switch is the FIRST row - the other three describe a capability
+ * it turns on.
+ *
+ * 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 - the kit page included. A footer
+ * promising "Ctrl+S saves here" would therefore be a lie the user acts on. The
+ * honest instruction is the one already in their fingers: Esc back, Ctrl+S on the
+ * main page.
+ */
+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';
+/**
+ * Label column, matching the root page's `padEnd(18)` rows above and below this
+ * one. `Team mode` is 9 characters and `Max subagents` is 13, so 18 keeps the
+ * value column aligned with `Subagent model` on the root page - measured, not
+ * guessed.
+ */
+const LABEL_PAD = 18;
+/**
+ * The two rows `Enter` toggles, and nothing else (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.
+ */
+const TOGGLE_FIELDS = new Set(['enabled', 'overseer']);
+export function TeamFanoutPage(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 offset = useProfileScroll(props, cursor);
+    const nudge = (delta) => {
+        if (!focused)
+            return;
+        props.dispatch({ type: 'team-fanout', field: focused.field, delta });
+    };
+    useInput((_input, key) => {
+        if (props.isActive === false)
+            return;
+        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 two boolean rows and does NOTHING on a numeric row.
+        if (key.return && focused && TOGGLE_FIELDS.has(focused.field))
+            nudge(1);
+    });
+    const lines = rows.map((row) => `${row.label.padEnd(LABEL_PAD)}${row.value}`);
+    const glyphs = pickGlyphs(props.caps);
+    const body = lines.map((line, at) => (_jsx(Text, { wrap: "truncate", color: at === cursor ? props.theme.accent : props.theme.muted, children: `${at === cursor ? glyphs.caret : ' '} ${clipProfileText(line, props.cols - 8)}` }, at)));
+    // The hint explains the FOCUSED row rather than decorating the frame: numbers
+    // whose meaning is not obvious ("per dispatch" versus "at once") are the reason
+    // this page exists at all.
+    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 ?? 'Team', hint: "Arrows adjust. Esc goes back; Ctrl+S on the main page saves." });
+}

package/dist/ui/overlays/kit-settings-state.js

@@ -232,8 +232,9 @@ export function kitPackRow(state) {
         const partial = session.held.length < 3;
         const held = partial ? `: ${session.held.join('+')}` : '';
         // THE SAME `~` THE CHIP SHOWS (D-12): dropping a slot is only ONE way to
-        // drift. The other is a connection that `/model`, `/fast` or `/team model`
-        // rewrote after the kit was applied, and a row that stayed silent about that
+        // drift. The other is a connection that `/model`, `/fast` or the settings
+        // `Subagent model` row rewrote after the kit was applied, and a row that
+        // stayed silent about that
         // would disagree with the status bar about the same session.
         const drift = liveDrift(state, session) ? '~' : '';
         return `${sessionKit.name}  [session${held}]${drift}${defaultClause}`;

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

@@ -3,7 +3,14 @@ import type { AgentKit } from '../../config/model-kits.js';
 import type { ModelSettingsDraft } from '../../config/model-profile-store.js';
 import type { SubagentModelMode } from '../../team/model.js';
 import type { KitDraft } from './kit-settings-state.js';
-export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm' | 'kits' | 'kit-edit' | 'kit-slot' | 'kit-delete';
+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';
+/**
+ * `'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
+ * already scrolls on a 24-row terminal, and three arrows-adjustable rows would
+ * push `Save` and `Reload` off the first screen on every machine.
+ */
 /**
  * Which role a PROFILE PICKER page is choosing for.
  *
@@ -100,6 +107,17 @@ export type ModelProfileAction = {
 } | {
     type: 'reload';
     draft: ModelSettingsDraft;
+}
+/**
+ * One arrow press on the fan-out page (subagent-fanout 3.4.2).
+ *
+ * The reducer, not the page, owns the write: the page holds a cursor and
+ * nothing else, so there is exactly one place a draft can change.
+ */
+ | {
+    type: 'team-fanout';
+    field: TeamFanoutField;
+    delta: -1 | 1;
 };
 /** Keep the original secret separate from the empty replacement field. */
 export declare function createProfileEditor(profile: ModelProfile): ProfileEditorDraft;
@@ -128,7 +146,7 @@ export declare function draftTeam(draft: ModelSettingsDraft): {
 export declare function draftSubagentProfileId(draft: ModelSettingsDraft): string | null;
 /** The projected picker selection for the subagent role (6.2). */
 export declare function subagentSelectedId(draft: ModelSettingsDraft): string | null;
-/** What the settings root row and `/team model` show for the current mode. */
+/** What the settings root row and `/team`'s status lines show for the current mode. */
 export interface SubagentModelSummaryInput {
     mode: SubagentModelMode;
     modelProfileId: string | null;

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

@@ -1,6 +1,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';
 /** 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. */
@@ -221,6 +222,17 @@ export function modelProfileReducer(state, action) {
         }
         case 'cancel-editor': return { ...state, editor: undefined, page: state.returnPage,
             error: undefined };
+        case 'team-fanout': {
+            // THE FRAGMENT IS THE ONLY THING WRITTEN (D-17 / R-P0-1). `stepFanoutValue`
+            // returns `Partial<TeamFanoutPatch>`, so `model` and `modelProfileId` - the
+            // two keys `releasedSlots` reads as "the user re-decided the subagent slot" -
+            // cannot enter the patch from here. `teamFanoutValues` is the CLAMPED view
+            // (R-P0-2), so a step starts from the number the user is looking at.
+            const step = stepFanoutValue(teamFanoutValues(state.draft), action.field, action.delta);
+            return { ...state, dirty: true, error: undefined,
+                draft: { ...state.draft,
+                    patch: { ...state.draft.patch, team: { ...state.draft.patch.team, ...step } } } };
+        }
         case 'duplicate': {
             if (library.entries.length >= 200)
                 return { ...state,

package/dist/ui/overlays/team-fanout-state.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Settings > Team: the pure half of the page (subagent-fanout 3.4.2, extended by
+ * team-command-forced-dispatch §3.9).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE PAGE WRITES FOUR KEYS AND CANNOT BE MADE TO WRITE A FIFTH (D-17 / R-P0-1).
+ * `TeamFanoutPatch` is `Pick<TeamConfig, 'enabled' | 'maxSubagents' |
+ * 'maxConcurrent' | 'overseer'>`, and `stepFanoutValue` returns
+ * `Partial<TeamFanoutPatch>`: a width adjustment therefore CANNOT carry `model`
+ * or `modelProfileId` into `draft.patch.team`. That matters because
+ * `releasedSlots` reads those two keys as "the user re-decided the subagent
+ * slot", so a page that returned the whole section would silently release the
+ * model a session kit had just installed - and no test would notice, because
+ * every value on screen would still be right.
+ *
+ * FOUR KEYS BECAUSE `enabled` MOVED HERE (team-command-forced-dispatch D-3): the
+ * team switch used to be reachable only as `/team on|off`, which also wrote
+ * `config.json`. The switch belongs on the same page as width, concurrency and
+ * supervision - they are four faces of one decision - and `/team` is now the ACT
+ * ("arm this session"), never a configuration write (I-4).
+ *
+ * EVERYTHING HERE IS A PURE FUNCTION over the draft. The page owns exactly one
+ * piece of state (its cursor); values come from the reducer, which is the same
+ * discipline the rest of this screen follows.
+ */
+import type { TeamConfig } from '../../config/schema.js';
+import type { ModelSettingsDraft } from '../../config/model-profile-store.js';
+export type TeamFanoutField = 'enabled' | 'maxSubagents' | 'maxConcurrent' | 'overseer';
+/**
+ * THE ONLY KEYS THIS PAGE MAY WRITE (R-P0-1).
+ *
+ * Not `Partial<TeamConfig>`: a fragment that could carry `model` would make a
+ * width adjustment read as a model decision at save time.
+ */
+export type TeamFanoutPatch = Pick<TeamConfig, 'enabled' | 'maxSubagents' | 'maxConcurrent' | 'overseer'>;
+export interface TeamFanoutRow {
+    field: TeamFanoutField;
+    label: string;
+    /** The value as the page prints it (`'8'` / `'on'`). */
+    value: string;
+    /** One line, <= 60 columns: WHY this number, not a restatement of the label. */
+    hint: string;
+}
+export interface TeamFanoutView {
+    /** Exactly four, in the fixed order the cursor indexes. */
+    rows: TeamFanoutRow[];
+    error?: string;
+}
+/**
+ * The CLAMPED team section this draft would save (R-P0-2), for display only.
+ *
+ * THE CLAMP IS NOT COSMETIC. Without it a patch carrying only
+ * `maxSubagents: 6` renders "6 per dispatch, 8 at once" on top of an 8-wide
+ * baseline, while `mergePersistedConfig` clamps the same patch to 6/6 on the way
+ * to disk - so the screen and the file disagree, and every arrow key makes the
+ * user reconcile them by hand.
+ */
+export declare function teamFanoutValues(draft: ModelSettingsDraft): TeamConfig;
+/**
+ * The PATCH FRAGMENT for one arrow press, clamped exactly like `clampTeamConfig`.
+ *
+ * `current` must be the value the screen actually shows (`teamFanoutValues`), so
+ * a step always starts from a number the user can see.
+ *
+ * NO WRAPAROUND: a form control is not a ring, and `Left` at 1 jumping to 10
+ * would be a way to widen a dispatch while trying to narrow it.
+ *
+ * EVERY MEMBER IS HANDLED EXPLICITLY AND THE TAIL IS `never` (P0-1). The old
+ * body was three `if`s with the `maxSubagents` branch as the FALLTHROUGH, so
+ * adding `'enabled'` to the union compiled cleanly and made the new `Team mode`
+ * row adjust `Max subagents` instead - every number on screen self-consistent,
+ * no test red, and the user's intent to switch the team OFF arrived as a wider
+ * fan-out. The `never` assignment below turns that class of mistake into a
+ * compile error, which is the only place it can be caught cheaply.
+ */
+export declare function stepFanoutValue(current: TeamConfig, field: TeamFanoutField, delta: -1 | 1): Partial<TeamFanoutPatch>;
+/**
+ * The page's four rows, in cursor order.
+ *
+ * `Team mode` IS FIRST because it is the premise of the other three: with `task`
+ * out of the tool list there is no width to configure and no supervisor to run,
+ * and a page that listed the numbers first would invite the user to tune a
+ * capability they had switched off.
+ *
+ * TWO HINTS CARRY A CONDITION THE DESIGN OWNS RATHER THAN DECORATION (R-1 / C-2):
+ * the default pool is 8, which is 8 simultaneous streams against one API key, and
+ * the honest mitigation for an HTTP 429 storm is "lower this number" - said HERE,
+ * where the number is, not only in a risk table nobody reads.
+ *
+ * `teamRegistered === false` (a `--no-team` session) changes TWO things on the
+ * `enabled` row and nothing else: `on (next launch)` because the tool array is
+ * immutable (I-7), and a hint that says why. Absent means "not disclosed",
+ * which every existing fixture relies on.
+ */
+export declare function fanoutRows(team: TeamConfig, teamRegistered?: boolean): TeamFanoutRow[];
+/**
+ * The one-line summary the settings root row prints for this page.
+ *
+ * `off - no subagents` rather than the numbers, because with the capability off
+ * the numbers describe nothing the user can spend. This replaced
+ * `fanoutSummary()` outright instead of living beside it: two summary functions
+ * over one page is two authorities for one line, and the root row would sooner or
+ * later disagree with the page it summarises.
+ */
+export declare function teamSummary(team: TeamConfig): string;

package/dist/ui/overlays/team-fanout-state.js

@@ -0,0 +1,155 @@
+/**
+ * Settings > Team: the pure half of the page (subagent-fanout 3.4.2, extended by
+ * team-command-forced-dispatch §3.9).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE PAGE WRITES FOUR KEYS AND CANNOT BE MADE TO WRITE A FIFTH (D-17 / R-P0-1).
+ * `TeamFanoutPatch` is `Pick<TeamConfig, 'enabled' | 'maxSubagents' |
+ * 'maxConcurrent' | 'overseer'>`, and `stepFanoutValue` returns
+ * `Partial<TeamFanoutPatch>`: a width adjustment therefore CANNOT carry `model`
+ * or `modelProfileId` into `draft.patch.team`. That matters because
+ * `releasedSlots` reads those two keys as "the user re-decided the subagent
+ * slot", so a page that returned the whole section would silently release the
+ * model a session kit had just installed - and no test would notice, because
+ * every value on screen would still be right.
+ *
+ * FOUR KEYS BECAUSE `enabled` MOVED HERE (team-command-forced-dispatch D-3): the
+ * team switch used to be reachable only as `/team on|off`, which also wrote
+ * `config.json`. The switch belongs on the same page as width, concurrency and
+ * supervision - they are four faces of one decision - and `/team` is now the ACT
+ * ("arm this session"), never a configuration write (I-4).
+ *
+ * EVERYTHING HERE IS A PURE FUNCTION over the draft. The page owns exactly one
+ * piece of state (its cursor); values come from the reducer, which is the same
+ * discipline the rest of this screen follows.
+ */
+import { clampTeamConfig, HARD_MAX_SUBAGENTS } from '../../config/schema.js';
+function clampInt(value, min, max) {
+    return Math.max(min, Math.min(max, Math.floor(value)));
+}
+/**
+ * The CLAMPED team section this draft would save (R-P0-2), for display only.
+ *
+ * THE CLAMP IS NOT COSMETIC. Without it a patch carrying only
+ * `maxSubagents: 6` renders "6 per dispatch, 8 at once" on top of an 8-wide
+ * baseline, while `mergePersistedConfig` clamps the same patch to 6/6 on the way
+ * to disk - so the screen and the file disagree, and every arrow key makes the
+ * user reconcile them by hand.
+ */
+export function teamFanoutValues(draft) {
+    return clampTeamConfig({ ...draft.baseline.team, ...draft.patch.team });
+}
+/**
+ * The PATCH FRAGMENT for one arrow press, clamped exactly like `clampTeamConfig`.
+ *
+ * `current` must be the value the screen actually shows (`teamFanoutValues`), so
+ * a step always starts from a number the user can see.
+ *
+ * NO WRAPAROUND: a form control is not a ring, and `Left` at 1 jumping to 10
+ * would be a way to widen a dispatch while trying to narrow it.
+ *
+ * EVERY MEMBER IS HANDLED EXPLICITLY AND THE TAIL IS `never` (P0-1). The old
+ * body was three `if`s with the `maxSubagents` branch as the FALLTHROUGH, so
+ * adding `'enabled'` to the union compiled cleanly and made the new `Team mode`
+ * row adjust `Max subagents` instead - every number on screen self-consistent,
+ * no test red, and the user's intent to switch the team OFF arrived as a wider
+ * fan-out. The `never` assignment below turns that class of mistake into a
+ * compile error, which is the only place it can be caught cheaply.
+ */
+export function stepFanoutValue(current, field, delta) {
+    if (field === 'enabled') {
+        // Both arrows toggle: `Team mode` has two states, and a direction has no
+        // meaning beyond "the user pressed an arrow" (the `Supervisor` rule below).
+        return { enabled: !current.enabled };
+    }
+    if (field === 'overseer') {
+        return { overseer: !current.overseer };
+    }
+    if (field === 'maxConcurrent') {
+        const ceiling = Math.min(HARD_MAX_SUBAGENTS, current.maxSubagents);
+        return { maxConcurrent: clampInt(current.maxConcurrent + delta, 1, ceiling) };
+    }
+    if (field === 'maxSubagents') {
+        const next = clampInt(current.maxSubagents + delta, 1, HARD_MAX_SUBAGENTS);
+        // THE FOLLOW-DOWN IS WRITTEN INTO THE PATCH (R-P1-9), not just rendered: a
+        // narrower population cannot keep a wider pool, but a DISPLAY-only correction
+        // would snap back the moment the user widened again, so "the change I just
+        // made" would not stick - the exact complaint this design exists to answer.
+        return current.maxConcurrent > next
+            ? { maxSubagents: next, maxConcurrent: next }
+            : { maxSubagents: next };
+    }
+    // THE EXHAUSTIVE GUARD IS THE POINT (P0-1): a new member of `TeamFanoutField`
+    // must fail to COMPILE here, not silently fall through to `maxSubagents`.
+    //
+    // IT SITS AFTER EVERY BRANCH RETURNS, not before the last one. §3.9's snippet
+    // shows it above the `maxSubagents` branch, where TypeScript rejects the file
+    // outright (`'maxSubagents' is not assignable to 'never'`) - the intent
+    // survives, the position does not.
+    const _exhaustive = field;
+    return _exhaustive;
+}
+/**
+ * The page's four rows, in cursor order.
+ *
+ * `Team mode` IS FIRST because it is the premise of the other three: with `task`
+ * out of the tool list there is no width to configure and no supervisor to run,
+ * and a page that listed the numbers first would invite the user to tune a
+ * capability they had switched off.
+ *
+ * TWO HINTS CARRY A CONDITION THE DESIGN OWNS RATHER THAN DECORATION (R-1 / C-2):
+ * the default pool is 8, which is 8 simultaneous streams against one API key, and
+ * the honest mitigation for an HTTP 429 storm is "lower this number" - said HERE,
+ * where the number is, not only in a risk table nobody reads.
+ *
+ * `teamRegistered === false` (a `--no-team` session) changes TWO things on the
+ * `enabled` row and nothing else: `on (next launch)` because the tool array is
+ * immutable (I-7), and a hint that says why. Absent means "not disclosed",
+ * which every existing fixture relies on.
+ */
+export function fanoutRows(team, teamRegistered) {
+    const blocked = teamRegistered === false && team.enabled;
+    return [
+        {
+            field: 'enabled',
+            label: 'Team mode',
+            value: blocked ? 'on (next launch)' : team.enabled ? 'on' : 'off',
+            hint: blocked
+                ? '--no-team session: the task tool cannot be added live'
+                : 'off: no task tool next launch; this session may lack it',
+        },
+        {
+            field: 'maxSubagents',
+            label: 'Max subagents',
+            value: String(team.maxSubagents),
+            hint: `children per dispatch; ${HARD_MAX_SUBAGENTS} is the hard ceiling`,
+        },
+        {
+            field: 'maxConcurrent',
+            label: 'Run at once',
+            value: String(team.maxConcurrent),
+            hint: 'provider limits: lower this if you see rate-limit errors',
+        },
+        {
+            field: 'overseer',
+            label: 'Supervisor',
+            value: team.overseer ? 'on' : 'off',
+            hint: 'checks stalled children; never kills them',
+        },
+    ];
+}
+/**
+ * The one-line summary the settings root row prints for this page.
+ *
+ * `off - no subagents` rather than the numbers, because with the capability off
+ * the numbers describe nothing the user can spend. This replaced
+ * `fanoutSummary()` outright instead of living beside it: two summary functions
+ * over one page is two authorities for one line, and the root row would sooner or
+ * later disagree with the page it summarises.
+ */
+export function teamSummary(team) {
+    if (!team.enabled)
+        return 'off - no subagents';
+    return `${team.maxSubagents} per dispatch, ${team.maxConcurrent} at once`;
+}