@aragon-agent/cli 0.6.39 → 0.6.40

package/dist/tools/plan-tools.js

@@ -25,18 +25,25 @@ const NO_INTERACTIVE_USER = 'No interactive user is attached (-p/--print mode).
     'state your assumptions explicitly and continue.';
 const NO_INTERACTIVE_REVIEWER = 'No interactive reviewer is attached. Emit the full plan as your final answer ' +
     'in markdown instead.';
-function roundCapRefusal(used) {
-    return (`You have already asked ${used} rounds of questions (the configured maximum). ` +
-        'Proceed with your best assumptions and state them in the plan.');
-}
 // ---------------------------------------------------------------------------
 // ask_user
 // ---------------------------------------------------------------------------
 const ASK_USER_DESCRIPTION = 'Ask the user 1-5 multiple-choice questions when a decision would change the work. ' +
-    'Give each question a stable id, a header of at most 12 characters, and 2-4 options; ' +
-    'exactly one option must set recommended:true, with the reason in its description. ' +
-    'Extra questions or options beyond these limits are dropped, so keep within them. ' +
-    'Do not ask anything you could answer by reading the workspace.';
+    'There is no limit on how many rounds you ask: call this as many times as the work ' +
+    'needs, one batch at a time. Give each question a stable id, a header of at most 12 ' +
+    'characters, and 2-4 options; exactly one option must set recommended:true, with the ' +
+    'reason in its description. Extra questions or options beyond the per-call limits are ' +
+    'dropped, so keep each round inside them. Do not ask anything you could answer by ' +
+    'reading the workspace, and never re-ask a question this turn already answered.';
+/**
+ * The de-duplication notice, as a NON-error result.
+ *
+ * `textResult`, not `errorResult`: a tool failure invites the model to retry the
+ * same call, and its only possible outcome is the same refusal. This is the same
+ * reasoning as the cancellation path below.
+ */
+const DUPLICATE_ROUND_RESULT = 'You already asked this exact set of questions in this turn and the user answered. ' +
+    'Use those answers; if you need something else, ask a different question.';
 function makeAskUser(opts) {
     return {
         name: 'ask_user',
@@ -91,9 +98,10 @@ function makeAskUser(opts) {
             if (questions.length === 0) {
                 return errorResult('No usable questions: each needs 2-4 distinct options.');
             }
-            const ticket = opts.takeAskRound();
-            if (!ticket.ok)
-                return errorResult(roundCapRefusal(ticket.used));
+            // BEFORE the wait: a set the user has already answered must not open an
+            // overlay a second time. Read-only — nothing is recorded here.
+            if (opts.hasAnsweredQuestions(questions))
+                return textResult(DUPLICATE_ROUND_RESULT);
             const response = await opts.withHumanWait(() => opts.gate.request({ kind: 'questions', questions }, ctx.signal));
             // `null` covers cancel, unmount, abort AND timeout. From the model's point
             // of view an unanswered question and an abandoned one are the same
@@ -102,12 +110,11 @@ function makeAskUser(opts) {
             // invites a retry loop.
             const cancelled = response === null || response.kind !== 'answers' || response.cancelled;
             const answers = response !== null && response.kind === 'answers' ? response.answers : [];
-            return textResult(formatAnswersResult({
-                answers,
-                cancelled,
-                roundsUsed: ticket.used,
-                roundsRemaining: ticket.remaining,
-            }, questions.length));
+            // AFTER the answer, and only for a real answer. A cancelled round leaves
+            // the set askable: mis-touch must not cost the user information.
+            if (!cancelled)
+                opts.noteAnsweredQuestions(questions);
+            return textResult(formatAnswersResult({ answers, cancelled }, questions.length));
         },
     };
 }

package/dist/ui/App.js

@@ -1014,6 +1014,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     // correct value (P0-1).
                     dispatch({ type: 'compactionEnd', record: event.record });
                     break;
+                case 'phase':
+                    // THE STAGE LINE ON THE LIVE CARD (context-compaction-never-fires C).
+                    // Dispatch is unconditional; the reducer is what ignores a phase that
+                    // arrives for a card the settle has already closed.
+                    dispatch({ type: 'compactionPhase', index: event.index, phase: event.phase });
+                    break;
                 case 'usage': {
                     // Compaction spend is REAL SPEND at the SUMMARIZER's price (§6.4 /
                     // AC-15), which may be neither the lead's nor the fast tier's — so the
@@ -3153,7 +3159,14 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             ? { todoActive: { done: state.todos.doneCount, total: state.todos.total } }
             : {}), ...(acceptanceActive ? { acceptanceActive } : {}), ...(liveServices > 0 ? { servicesActive: { live: liveServices } } : {}), ...(state.fast?.live ? { fastActive: { inFlight: state.fast.inFlight } } : {}), 
         // Manual compaction starts before its next snapshot is published.
-        compactionActive: { inFlight: statusInput.compacting ?? false }, ...(controller.isCompactionEnabled()
+        // THE AUTO-PAUSED CHIP RIDES HERE AND NOWHERE ELSE (never-fires C /
+        // analysis 3.3.1): `selfDisabled` used to live only in `/compact status`,
+        // a command nobody types while the gauge sits at 95 %. `StatusBar` plans
+        // the primary row from its own props, so a second copy of the flag on
+        // `statusInput` would be a field nothing renders - and a fact with two
+        // sources is a fact that drifts.
+        compactionActive: { inFlight: statusInput.compacting ?? false,
+            selfDisabled: state.compaction?.selfDisabled === true }, ...(controller.isCompactionEnabled()
             ? {
                 gaugeMarks: {
                     warn: cfg.compaction.warnThreshold * 100,

package/dist/ui/StatusBar.d.ts

@@ -92,6 +92,7 @@ export interface StatusBarProps {
     };
     compactionActive?: {
         inFlight: boolean;
+        selfDisabled?: boolean;
     };
     gaugeMarks?: {
         warn: number;

package/dist/ui/StatusBar.js

@@ -39,6 +39,7 @@ export function StatusBar(props) {
         interruptPhase: props.interruptPhase,
         waitingForConfirmation: props.waitingForConfirmation, stopping: props.stopping,
         compacting: props.compactionActive?.inFlight, retryActive: props.retryActive,
+        compactionPaused: props.compactionActive?.selfDisabled === true,
         mode: props.agentMode, pendingMode: props.pendingAgentMode, servicesActive: props.servicesActive,
         teamActive: props.teamActive, todoActive: props.todoActive,
         ...(props.acceptanceActive ? { acceptanceActive: props.acceptanceActive } : {}),

package/dist/ui/Transcript.js

@@ -137,7 +137,7 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
         case 'fast':
             return frame(entry.status === 'failed' ? glyphs.toolError : glyphs.teamAgent, fastCardColor(entry.status, theme), _jsx(FastCard, { reviewIndex: entry.reviewIndex, model: entry.model, status: entry.status, text: entry.text, detail: entry.detail, turn: entry.turn, durationMs: entry.durationMs, live: entry.live, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'compaction':
-            return frame(entry.applied || entry.live ? glyphs.compaction : glyphs.toolError, compactionCardColor(entry, theme), _jsx(CompactionCard, { index: entry.index, decision: entry.decision, memoryVersion: entry.memoryVersion, trigger: entry.trigger, mode: entry.mode, applied: entry.applied, reason: entry.reason, messagesBefore: entry.messagesBefore, messagesAfter: entry.messagesAfter, tokensBefore: entry.tokensBefore, tokensAfter: entry.tokensAfter, summary: entry.summary, model: entry.model, durationMs: entry.durationMs, tailRelief: entry.tailRelief, 
+            return frame(entry.applied || entry.live ? glyphs.compaction : glyphs.toolError, compactionCardColor(entry, theme), _jsx(CompactionCard, { index: entry.index, decision: entry.decision, memoryVersion: entry.memoryVersion, trigger: entry.trigger, mode: entry.mode, applied: entry.applied, reason: entry.reason, messagesBefore: entry.messagesBefore, messagesAfter: entry.messagesAfter, tokensBefore: entry.tokensBefore, tokensAfter: entry.tokensAfter, summary: entry.summary, model: entry.model, durationMs: entry.durationMs, tailRelief: entry.tailRelief, phase: entry.phase, keepRelaxed: entry.keepRelaxed, retainedTurns: entry.retainedTurns, retainedMessages: entry.retainedMessages, keepRecentTurnsUsed: entry.keepRecentTurnsUsed, elidedMessages: entry.elidedMessages, 
                 // ONLY WHILE LIVE, and only when the clock has ticked at least once:
                 // `nowSec` is `undefined` until then, and a settled card must keep
                 // rendering `durationMs` rather than a figure that would drift.

package/dist/ui/entries/CompactionCard.d.ts

@@ -23,7 +23,7 @@
 import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
-import type { CompactionDecision, CompactionMode, CompactionUiTrigger } from '../../compaction/types.js';
+import type { CompactionDecision, CompactionMode, CompactionPhase, CompactionUiTrigger } from '../../compaction/types.js';
 export interface CompactionCardProps {
     decision?: CompactionDecision;
     memoryVersion?: 2;
@@ -39,6 +39,16 @@ export interface CompactionCardProps {
     summary?: string;
     model: string;
     durationMs?: number;
+    /** The live card's stage, so "compacting" also says WHAT (never-fires C). */
+    phase?: CompactionPhase;
+    /** Set when this cut existed only because `keepRecentTurns` was relaxed (B). */
+    keepRelaxed?: boolean;
+    retainedTurns?: number;
+    /** Messages the relaxed cut left verbatim, which is not the same as turns. */
+    retainedMessages?: number;
+    keepRecentTurnsUsed?: number;
+    /** Messages the digest left out and therefore cannot be quoted (A1). */
+    elidedMessages?: number;
     /**
      * Wall-clock since the card opened, LIVE ONLY
      * (context-auto-compaction-hardening §3.6 / W5).

package/dist/ui/entries/CompactionCard.js

@@ -28,6 +28,7 @@ import { pickGlyphs } from '../glyphs.js';
 import { railBorderProps } from '../layout/Gutter.js';
 import { formatDuration, formatTokens } from '../../agent/usage.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
+import { compactionPhaseLabel, compactionReasonLine } from '../../compaction/reason-text.js';
 /**
  * The card's colour.
  *
@@ -56,12 +57,19 @@ function headline(props, arrow, dot) {
         // second 45 this was the only changing information on the card, and there was
         // none.
         const elapsed = props.elapsedMs === undefined ? '' : `${dot}${formatDuration(props.elapsedMs)}`;
+        // THE STAGE, NOT JUST "COMPACTING" (never-fires C). Planning and digesting run
+        // before any model call, and a user watching a card for twenty seconds cannot
+        // tell "thinking hard" from "stuck in a gate" without it.
+        const stage = props.phase === undefined ? '' : `${dot}${compactionPhaseLabel(props.phase)}`;
         return props.model
-            ? `compacting context #${index}${dot}${props.model}${elapsed}`
-            : `compacting context #${index}${elapsed}`;
+            ? `compacting context #${index}${dot}${props.model}${stage}${elapsed}`
+            : `compacting context #${index}${stage}${elapsed}`;
     }
     if (!props.applied || props.tokensAfter >= props.tokensBefore) {
-        const why = props.reason ? `: ${props.reason}` : '';
+        // THE REASON IN WORDS (never-fires C). `digest_budget_exceeded: $.digest` was
+        // a code the user could not act on; `compactionReasonLine` renders the same
+        // fact as a clause plus, where there is one, the remedy.
+        const why = props.reason ? `: ${compactionReasonLine(props.reason)}` : '';
         return `context not compacted #${index}${why}`;
     }
     const messages = `${props.messagesBefore} ${arrow} ${props.messagesAfter} messages`;
@@ -87,8 +95,15 @@ function headline(props, arrow, dot) {
  */
 function detailLine(props) {
     if (props.live) {
+        // THE ESCAPE, NOT THE STAGE (never-fires C, as corrected in review): the live
+        // headline already carries the stage, and a two-line card that names it twice
+        // is the one-fact-one-surface rule this file keeps having to restore. With no
+        // model resolved there is no call to cancel, so the whole line goes - the same
+        // rule the settled branch applies.
         if (!props.model)
             return '';
+        if (props.phase !== undefined)
+            return 'esc to cancel';
         return `summarizing with ${props.model} - esc to cancel`;
     }
     if (!props.applied || props.tokensAfter >= props.tokensBefore)
@@ -104,6 +119,50 @@ function detailLine(props) {
     const via = props.trigger === 'overflow' ? ' after a context overflow' : '';
     return `summarized ${dropped} messages with ${props.model}${via}`;
 }
+/**
+ * The relaxation disclosure (never-fires B).
+ *
+ * `planCompaction`'s second pass trades "the last N user turns are verbatim" for
+ * "a cut exists at all". That trade must be readable, because the difference
+ * between the two compactions is exactly what the user asked for: the tail is the
+ * part they care most about keeping word for word.
+ */
+function relaxedLine(props) {
+    if (props.live || !props.applied || props.keepRelaxed !== true)
+        return '';
+    const turns = props.retainedTurns ?? 0;
+    const wanted = props.keepRecentTurnsUsed;
+    const messages = props.retainedMessages;
+    // THE TAIL IS MESSAGES, NOT TURNS (review). The dominant relaxed shape is one
+    // prompt plus a hundred tool calls, so `retainedTurns` is 0 while forty messages
+    // were kept verbatim: a line reading "kept 0 recent turns" would report a total
+    // loss that did not happen. Whenever the count is available it leads, and the
+    // turn arithmetic follows as the explanation rather than as the headline.
+    if (messages !== undefined && wanted !== undefined) {
+        return `kept the last ${messages} messages - ${turns} of the ${wanted} requested turns, ` +
+            'since this run had too few user turns';
+    }
+    if (messages !== undefined)
+        return `kept the last ${messages} messages verbatim`;
+    return wanted === undefined
+        ? `kept the last ${turns} turns - this run had too few user turns to keep more`
+        : `kept ${turns} of the ${wanted} requested turns - this run had too few user turns`;
+}
+/**
+ * The digest-elision disclosure (never-fires A1).
+ *
+ * The digest never rejects for length any more; it keeps the first and last
+ * entries verbatim and elides the middle. The elided messages cannot be quoted by
+ * the summarizer, so the card says so rather than presenting a summary as if it
+ * had seen everything.
+ */
+function elidedLine(props) {
+    const n = props.elidedMessages ?? 0;
+    if (props.live || n <= 0)
+        return '';
+    return `elided ${n} ${n === 1 ? 'message' : 'messages'} from the summary input - ` +
+        'the middle is summarized without them';
+}
 /**
  * The relief disclosure, on a settled card that ALSO summarized.
  *
@@ -139,6 +198,8 @@ function CompactionCardImpl(props) {
     const head = headline(props, glyphs.arrowRight, dot);
     const detail = detailLine(props);
     const relief = reliefLine(props);
+    const relaxed = relaxedLine(props);
+    const elided = elidedLine(props);
     const showMemory = props.memoryVersion !== 2 || expanded === true;
     const rows = summary && showMemory ? summaryRows(summary, expanded === true) : [];
     const totalRows = summary ? summary.split('\n').filter((l) => l.trim().length > 0).length : 0;
@@ -150,7 +211,7 @@ function CompactionCardImpl(props) {
     // the whole run, losing the status colour along with the motion.
     const animate = live && reducedMotion !== true && caps.unicode;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.accent, bold: true, children: props.trigger === 'manual' ? 'Manual compaction' : props.trigger === 'overflow'
-                            ? 'Overflow: threshold reached' : 'Automatic: threshold reached' }), _jsxs(Text, { color: live ? color : theme.muted, wrap: caps.unicode ? 'truncate' : 'wrap', children: [animate ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), ' '] })) : live ? (`${glyphs.spinnerStill} `) : (''), head] })] }), props.memoryVersion === 2 && (_jsxs(Text, { color: theme.muted, children: ["Task memory v2", expanded ? '' : ' (ctrl+o to expand)'] })), detail.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: color, wrap: caps.unicode ? 'truncate' : 'wrap', children: detail }) })), relief.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.noticeWarn, children: relief }) })), rows.length > 0 && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [rows.map((line, index) => (_jsx(Text, { color: theme.primary, children: line }, index))), hidden > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " +", hidden, " more lines (ctrl+o to expand)"] })), hidden === 0 && expanded === true && totalRows > COMPACTION_LIMITS.cardTextRows && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " ctrl+o to collapse"] }))] }))] }));
+                            ? 'Overflow: threshold reached' : 'Automatic: threshold reached' }), _jsxs(Text, { color: live ? color : theme.muted, wrap: caps.unicode ? 'truncate' : 'wrap', children: [animate ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), ' '] })) : live ? (`${glyphs.spinnerStill} `) : (''), head] })] }), props.memoryVersion === 2 && (_jsxs(Text, { color: theme.muted, children: ["Task memory v2", expanded ? '' : ' (ctrl+o to expand)'] })), detail.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: color, wrap: caps.unicode ? 'truncate' : 'wrap', children: detail }) })), relief.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.noticeWarn, children: relief }) })), relaxed.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.muted, children: relaxed }) })), elided.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.muted, children: elided }) })), rows.length > 0 && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [rows.map((line, index) => (_jsx(Text, { color: theme.primary, children: line }, index))), hidden > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " +", hidden, " more lines (ctrl+o to expand)"] })), hidden === 0 && expanded === true && totalRows > COMPACTION_LIMITS.cardTextRows && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " ctrl+o to collapse"] }))] }))] }));
 }
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).

package/dist/ui/layout/status-layout.d.ts

@@ -31,6 +31,16 @@ export interface StatusLayoutInput {
     spinner?: string;
     waitingForConfirmation?: boolean;
     stopping?: boolean;
+    /**
+     * Auto-compaction paused itself after repeated no-progress attempts
+     * (context-compaction-never-fires C).
+     *
+     * A SEPARATE FIELD FROM `compacting`, and it renders as a SUFFIX on the context
+     * gauge rather than as a phase word: the fact belongs next to the percentage it
+     * explains ("Context 95% auto-paused"), and the phase slot must keep answering
+     * "is the agent running".
+     */
+    compactionPaused?: boolean;
     compacting?: boolean;
     retryActive?: {
         attempt: number;

package/dist/ui/layout/status-layout.js

@@ -53,6 +53,22 @@ function contextPercent(context) {
     const mark = context.source === 'estimate' || context.deltaTokens > 0 ? '~' : '';
     return mark + (context.pct > 999 ? '>999' : Math.round(context.pct)) + '%';
 }
+/**
+ * The words that ride on the gauge when auto-compaction has given up (C).
+ *
+ * IT RIDES ON THE GAUGE RATHER THAN OCCUPYING ITS OWN FIELD. "Auto-paused" is the
+ * only fact that explains a stuck percentage, so the two belong in one field for
+ * the same reason `/context` prints them on adjacent lines. A second field would
+ * also be the first thing the width ladder drops, and this is precisely the state
+ * that must survive a narrow terminal.
+ *
+ * `paused` at the tight rungs: the full phrase costs twelve cells the row does
+ * not have at rung 3 and beyond, and dropping the fact entirely would be worse
+ * than abbreviating it.
+ */
+function pausedSuffix(full) {
+    return full ? ' auto-paused' : ' paused';
+}
 export function shortDuration(ms) {
     if (!Number.isFinite(ms) || ms <= 0)
         return '0s';
@@ -208,7 +224,8 @@ export function planPrimaryStatusFields(input) {
             statusField('phase', glyph + (rung >= 5 ? '' : ' ') + label, phaseTone),
             ...(notice ? [statusField('feedback', notice, feedbackTone)] : []),
             ...(modeText ? [statusField('mode', modeText, 'accent')] : []),
-            statusField('context', (full ? 'Context ' : 'C') + pct),
+            statusField('context', (full ? 'Context ' : 'C') + pct
+                + (input.compactionPaused === true ? pausedSuffix(full) : '')),
             statusField('thinking', full ? 'Think ' + (thinkingCodes[input.thinkingLevel] ? input.thinkingLevel : '?')
                 : (rung >= 2 ? '' : 'Th:') + code),
             statusField('speed', speed + (full ? ' tok/s' : rung >= 3 ? '/s' : 't/s')),

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/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,