@aragon-agent/cli 0.6.38 → 0.6.40

package/dist/ui/layout/task-summary-cell.js

@@ -0,0 +1,65 @@
+/**
+ * The task-summary cell's decisions (tui-shortcut-drawer-and-task-summary §6.3).
+ *
+ * ASCII ONLY: `src/ui/**` is inside the glyph scanner's scope.
+ *
+ * WHY THIS IS A SEPARATE MODULE FROM `header-left.ts`: the planner answers "how
+ * wide is the cell", this one answers "should there be a cell at all, and what is
+ * in it". The second question is the trigger rule (D-7) and it has to be testable
+ * without a renderer - `task-summary-app.test.tsx` pins "one call per session" by
+ * calling THIS function, not by counting renders.
+ *
+ * THE TRIGGER IS NARROW ON PURPOSE. A header label is an identity strip, not a
+ * live subtitle: refreshing it every turn would flicker, cost money, and teach the
+ * user to distrust the one thing on the row that is not a status field.
+ */
+/**
+ * D-7's trigger rule.
+ *
+ * FIVE INPUTS, ONE ANSWER. `userInitiated` is the second guard on the same fact
+ * `submitMessage` already knows (`opts.userInitiated !== false`): an automatic
+ * continuation is not a new task, and paying for a label for it would spend the
+ * user's money to describe work they did not start.
+ */
+export function shouldSummarize(input) {
+    // ORDER IS THE DOCUMENTED PRECEDENCE: a prompt that is not a task cannot start
+    // one even when everything else says yes, and an OFF feature must report the
+    // switch rather than a downstream reason the user cannot act on.
+    if (!input.enabled)
+        return { start: false, reason: 'disabled' };
+    if (input.anchor.trim().length === 0)
+        return { start: false, reason: 'no-anchor' };
+    if (input.hasSummary)
+        return { start: false, reason: 'already-set' };
+    if (input.pending)
+        return { start: false, reason: 'pending' };
+    // ITS OWN REASON, not `no-anchor`: an automatic continuation HAS an anchor, it is
+    // simply not a new task, and a skip reason a maintainer cannot trust is worse than
+    // no reason at all (review fix RF-3).
+    if (!input.userInitiated)
+        return { start: false, reason: 'not-user-initiated' };
+    return { start: true };
+}
+/**
+ * The drawer's `Task` section, flattened from the view state so the pure layout
+ * module never learns what a `ViewState` is.
+ */
+export function taskSectionFrom(input) {
+    if (input.view === null) {
+        return {
+            text: null, tone: null, reason: null, by: '', ageMs: null,
+            enabled: input.enabled, pending: input.pending,
+        };
+    }
+    return {
+        text: input.view.text,
+        tone: input.view.tone,
+        reason: input.view.reason,
+        by: input.view.by,
+        // The age is computed from the view's own timestamp and the caller's clock,
+        // so the drawer never introduces a second one.
+        ageMs: input.now >= input.view.at ? input.now - input.view.at : null,
+        enabled: input.enabled,
+        pending: input.pending,
+    };
+}

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

@@ -13,5 +13,17 @@
 import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
+/**
+ * The key column of every binding row, EXPORTED so the drawer's drift guard can read
+ * the real table instead of scraping this file with a regex
+ * (tui-shortcut-drawer-and-task-summary D-8 / AC-5).
+ *
+ * A SOURCE SCRAPE WOULD PASS ON A COMMENT: the regex has no way to tell a key row
+ * from a legend row from a line inside a block comment, and the guard's whole job is
+ * to notice a row someone forgot.
+ */
+export declare function allKeyRows(times: string): [string, string][];
+/** The slash-command table's key column, for the same guard (commands are not keys). */
+export declare function allCommandRows(): [string, string][];
 /** Build the overlay's rows. Exported so `app.test.tsx` can count them. */
 export declare function helpRows(theme: Theme, caps: TermCapabilities, native?: boolean): React.ReactElement[];

package/dist/ui/overlays/HelpOverlay.js

@@ -20,7 +20,16 @@ function keyRows(times, native = false) {
         .map(([key, description]) => key === 'PgUp / PgDn' ? [key, 'Page through an open overlay'] : [key, description])
         .concat([['Scroll', 'Use your terminal (wheel, Shift+PgUp, scrollbar, search)']]);
 }
-function allKeyRows(times) {
+/**
+ * The key column of every binding row, EXPORTED so the drawer's drift guard can read
+ * the real table instead of scraping this file with a regex
+ * (tui-shortcut-drawer-and-task-summary D-8 / AC-5).
+ *
+ * A SOURCE SCRAPE WOULD PASS ON A COMMENT: the regex has no way to tell a key row
+ * from a legend row from a line inside a block comment, and the guard's whole job is
+ * to notice a row someone forgot.
+ */
+export function allKeyRows(times) {
     return [
         ['Enter', 'Submit (idle) / queue steering (running); re-pins to the newest output'],
         ['Alt+Enter / Shift+Enter', 'Newline when supported; the host may intercept either binding'],
@@ -57,7 +66,15 @@ function allKeyRows(times) {
         // went - and because `^K` is only advertised in the expanded header row.
         ['Ctrl+K', 'Agent kits: pick a preset for this session (see /kit)'],
         ['Alt+K', 'Delete from the cursor to the end of the line (was Ctrl+K)'],
-        ['Ctrl+G', 'Expand/collapse status details; disabled while an overlay is open'],
+        // Ctrl+G OPENED THE STATUS DETAIL ROW UNTIL THE DRAWER TOOK THE KEY
+        // (tui-shortcut-drawer-and-task-summary D-6). The detail row did not disappear,
+        // it moved to `d` inside this panel, and saying so here is the only place a
+        // user's muscle memory can find out.
+        ['Ctrl+G', 'Keyboard drawer: every shortcut, with keywords (d = status details)'],
+        // Ctrl+O WAS MISSING FROM THIS TABLE ENTIRELY while it worked in the app, which
+        // is exactly the gap the drawer's reverse drift guard exists to force closed: a
+        // key that only exists in the code is a key only its author knows.
+        ['Ctrl+O', 'Expand the newest tool output (native mode reprints it as a block)'],
         // The board's key is listed HERE and in the team table below: the roster shows
         // `ctrl+b` only on a terminal wide enough for the hint cell, and a key a user can
         // only learn from a wide terminal is a key the rest never discover (AC-18).
@@ -92,6 +109,12 @@ function allKeyRows(times) {
 }
 const COMMANDS = [
     ['/help', 'Show this help'],
+    // THE DRAWER'S COMMAND-SIDE ENTRY (tui-shortcut-drawer-and-task-summary §4.7).
+    // Listed here as well as behind Ctrl+G, because a key is unreachable in a script
+    // and `/keys` is how a paste or a screen reader gets to the same list.
+    ['/keys [query]', 'List every shortcut in the drawer; a query pre-filters it'],
+    ['/task', 'Show the header task summary: what it says, where it came from'],
+    ['/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)'],
@@ -172,6 +195,10 @@ const FAST_ROWS = [
     ['--fast / --no-fast', 'Start a session with the tier on or off (also ARAGON_FAST=1)'],
     ['<fast_review>', 'An automated second opinion from the fast model - advice, not the user'],
 ];
+/** The slash-command table's key column, for the same guard (commands are not keys). */
+export function allCommandRows() {
+    return COMMANDS;
+}
 /** Build the overlay's rows. Exported so `app.test.tsx` can count them. */
 export function helpRows(theme, caps, native = false) {
     const glyphs = pickGlyphs(caps);

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, fanoutSummary, teamFanoutValues } 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,11 @@ 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)), 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 +964,14 @@ function buildRootSettingsRows(props, view) {
             profiles: state.draft.profiles,
             hasKey: (id) => (props.apiKeys[id] ?? '').length > 0 })}${kitTag}`
         : subagentLine;
+    // THE FAN-OUT SUMMARY (subagent-fanout 3.4.4): a DERIVED row, like the three
+    // above it, and deliberately not a control - the numbers are adjusted on the
+    // page Enter opens, so the root row cannot change a value by accident.
+    const fanout = fanoutSummary(teamFanoutValues(state.draft));
     const lines = [`Main profile      ${mainValue}`,
         `Fast profile      ${fastValue}`,
         `Subagent model    ${subagentValue}`,
+        `Subagent fan-out  ${fanout}`,
         `Kit pack          ${kitPackRow(state)}`,
         `Manage profiles   ${library.entries.length} saved`,
         ...fields.map((item) => `${item.label.padEnd(18)}${item.key === 'apiKey'

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

@@ -0,0 +1,39 @@
+/**
+ * The keyboard drawer (tui-shortcut-drawer-and-task-summary §4.5).
+ *
+ * ASCII ONLY: `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * IT OWNS NO CHROME AND NO ARITHMETIC. `OverlayFrame` draws the frame, the
+ * window and the position indicator; `shortcut-panel-layout.ts` decides the
+ * columns, the rows and which window contains the cursor. This component adds two
+ * things and nothing else: its own key handling and the text-run colours. v1
+ * planned 260 lines that re-implemented the frame's windowing and clamping - a
+ * second source of truth for the one thing overlays have already been rewritten
+ * once to unify.
+ *
+ * IT DOES NOT REGISTER `Esc` AND DOES NOT TOUCH ANY `ctrl`/`meta` COMBINATION:
+ * `Esc` belongs to `App` (it closes every overlay and cancels the pending
+ * question/plan), and `Ctrl+G` is handled there too. Two listeners both acting on
+ * one byte is how a panel closes twice.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import { type ShortcutTaskSection } from '../layout/shortcut-panel-layout.js';
+export interface ShortcutPanelProps {
+    /** The terminal width, which is what `OverlayFrame` needs to pick its form. */
+    cols: number;
+    maxRows: number;
+    theme: Theme;
+    caps: TermCapabilities;
+    isActive: boolean;
+    native: boolean;
+    running: boolean;
+    /** `/keys <query>` pre-filter. */
+    query?: string;
+    task: ShortcutTaskSection;
+    detailsExpanded: boolean;
+    onToggleDetails(): void;
+    onRefresh(): void;
+}
+export declare function ShortcutPanel(props: ShortcutPanelProps): React.ReactElement;

package/dist/ui/overlays/ShortcutPanel.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The keyboard drawer (tui-shortcut-drawer-and-task-summary §4.5).
+ *
+ * ASCII ONLY: `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * IT OWNS NO CHROME AND NO ARITHMETIC. `OverlayFrame` draws the frame, the
+ * window and the position indicator; `shortcut-panel-layout.ts` decides the
+ * columns, the rows and which window contains the cursor. This component adds two
+ * things and nothing else: its own key handling and the text-run colours. v1
+ * planned 260 lines that re-implemented the frame's windowing and clamping - a
+ * second source of truth for the one thing overlays have already been rewritten
+ * once to unify.
+ *
+ * IT DOES NOT REGISTER `Esc` AND DOES NOT TOUCH ANY `ctrl`/`meta` COMBINATION:
+ * `Esc` belongs to `App` (it closes every overlay and cancels the pending
+ * question/plan), and `Ctrl+G` is handled there too. Two listeners both acting on
+ * one byte is how a panel closes twice.
+ */
+import { useMemo, useState } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame, overlayBodyRows, overlayPageSize } from '../layout/OverlayFrame.js';
+import { buildShortcutRows, shortcutPanelWidth, } from '../layout/shortcut-panel-layout.js';
+import { filterShortcuts, isAvailable, SHORTCUTS } from '../shortcuts.js';
+/** Colour per tone. `dim` is `muted` plus the dim attribute, never a second colour. */
+function toneOf(row, theme) {
+    if (row.tone === 'accent')
+        return { color: theme.accent };
+    if (row.tone === 'primary')
+        return { color: theme.primary };
+    if (row.tone === 'dim')
+        return { color: theme.muted, dimColor: true };
+    return { color: theme.muted };
+}
+export function ShortcutPanel(props) {
+    const { cols, maxRows, theme, caps, isActive, native, running } = props;
+    const glyphs = pickGlyphs(caps);
+    const [cursor, setCursor] = useState(0);
+    const entries = useMemo(() => filterShortcuts(SHORTCUTS, props.query ?? ''), [props.query]);
+    const bodyRows = overlayBodyRows(maxRows, cols);
+    const page = overlayPageSize(maxRows, cols);
+    const result = useMemo(() => buildShortcutRows({
+        cols,
+        rows: bodyRows,
+        cursor,
+        entries,
+        task: props.task,
+        entryAvailable: (entry) => isAvailable(entry, { native, running }),
+        unavailableReason: native ? 'this mode leaves it to the terminal' : 'a run is in flight',
+        glyphs: {
+            ellipsis: glyphs.ellipsis,
+            cursor: glyphs.cursor,
+            hrule: glyphs.hrule,
+            midDot: glyphs.midDot,
+        },
+    }), [cols, bodyRows, cursor, entries, props.task, native, running,
+        glyphs.ellipsis, glyphs.cursor, glyphs.hrule, glyphs.midDot]);
+    const last = Math.max(0, entries.length - 1);
+    useInput((input, key) => {
+        // `ctrl`/`meta` ARE NOT OURS: `Ctrl+G` closes this panel and `Ctrl+C` owns the
+        // exit ladder, both in `App`. Consuming them here would double-handle a byte.
+        if (key.ctrl || key.meta)
+            return;
+        if (key.upArrow || input === 'k') {
+            setCursor((value) => Math.max(0, value - 1));
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setCursor((value) => Math.min(last, value + 1));
+            return;
+        }
+        // PAGING MOVES THE CURSOR, one page minus one row of overlap - the same rule
+        // `overlayPageSize` uses for every other overlay, so a page turn keeps a row of
+        // context. An independent offset would let the selected row - and the detail
+        // line that explains it - slide off screen (P1-7).
+        if (key.pageUp) {
+            setCursor((value) => Math.max(0, value - Math.max(1, page - 1)));
+            return;
+        }
+        if (key.pageDown) {
+            setCursor((value) => Math.min(last, value + Math.max(1, page - 1)));
+            return;
+        }
+        if (input === 'd') {
+            props.onToggleDetails();
+            return;
+        }
+        if (input === 'r') {
+            props.onRefresh();
+        }
+    }, { isActive });
+    const rows = result.rows.map((row, index) => (_jsx(Text, { wrap: "truncate", ...toneOf(row, theme), children: row.text }, `${row.kind}-${row.entryId ?? 'x'}-${index}`)));
+    // THE `d` MARKER LIVES ON THE FRAME'S OWN TITLE LINE (D-6), which is chrome that is
+    // already paid for. It is spelled `d:on` / `d:off` rather than `details on|off`
+    // because the title row also carries the frame's position indicator (`v 1-13/37`,
+    // 13 cells) and the drawer's content is only 26 cells wide at 80 columns: the long
+    // form is truncated to `details...`, which is a marker that says nothing. The
+    // footer's `d details` clause names the key, so the pair reads as one sentence.
+    const title = `Keys  d:${props.detailsExpanded ? 'on' : 'off'}`;
+    return (_jsx(OverlayFrame, { title: title, hint: result.hint, maxRows: maxRows, cols: cols, width: shortcutPanelWidth(cols), align: "right", rows: rows, 
+        // THE WINDOW IS DERIVED FROM THE CURSOR, so the offset handed to the frame is
+        // a conclusion rather than state. `onScrollClamp` is deliberately not passed:
+        // there is nothing here that could drift out of step with it.
+        scrollOffset: result.window.start, theme: theme, caps: caps }));
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Settings > Team fan-out: three arrows-adjustable rows (subagent-fanout 3.4.3).
+ *
+ * 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).
+ *
+ * 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;
+}
+export declare function TeamFanoutPage(props: TeamFanoutPageProps): React.ReactElement;
+export {};

package/dist/ui/overlays/TeamFanoutPage.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Settings > Team fan-out: three arrows-adjustable rows (subagent-fanout 3.4.3).
+ *
+ * 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).
+ *
+ * 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. `Subagent fan-out` is 16 characters, so two spaces of padding are all it
+ * needs to line up with `Subagent model` - measured, not guessed.
+ */
+const LABEL_PAD = 18;
+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 Supervisor row and does NOTHING on a numeric row:
+        // a stray Return that silently changed a number is indistinguishable from a
+        // bug, and the arrow keys are already the obvious control.
+        if (key.return && focused?.field === 'overseer')
+            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: three
+    // 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 fan-out', hint: "Arrows adjust. Esc goes back; Ctrl+S on the main page saves." });
+}

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;

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,73 @@
+/**
+ * Settings > Team fan-out: the pure half of the page (subagent-fanout 3.4.2).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE PAGE WRITES THREE KEYS AND CANNOT BE MADE TO WRITE A FOURTH (D-17 /
+ * R-P0-1). `TeamFanoutPatch` is `Pick<TeamConfig, '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.
+ *
+ * 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 = '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, '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 three, 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.
+ */
+export declare function stepFanoutValue(current: TeamConfig, field: TeamFanoutField, delta: -1 | 1): Partial<TeamFanoutPatch>;
+/**
+ * The page's three rows.
+ *
+ * TWO HINTS CARRY A CONDITION THE DESIGN OWNS RATHER THAN DECORATION (R-1 / C-2):
+ * the default pool is now 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.
+ */
+export declare function fanoutRows(team: TeamConfig): TeamFanoutRow[];
+/** The one-line summary the settings root row prints for this page. */
+export declare function fanoutSummary(team: TeamConfig): string;