@aragon-agent/cli 0.6.40 → 0.6.43

package/dist/ui/App.js

@@ -50,6 +50,12 @@ import { acceptanceChip, acceptanceRung, buildTodoRailLayout } from './layout/to
 import { buildTeamPanelLayout } from './layout/team-panel.js';
 import { isLiveTeamCard, lastTeamEntry, rosterCounts } from './team-status.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
+// THE THIRD LAYER OF FORCED TEAM MODE (team-command-forced-dispatch §3.7): the
+// decision and its two strings live in a pure module, so `App` gains wiring and
+// no policy. Imported beside the todo decision it shares one timer with.
+import { decideForcedDispatch, FORCED_NUDGE_NOTICE } from '../team/dispatch-gate.js';
+import { FORCED_NUDGE_GRACE_MS } from '../team/limits.js';
+import { priceTeamUsage } from '../team/model.js';
 import { useTerminalSize } from './layout/useTerminalSize.js';
 import { useHeightStore } from './use-height-store.js';
 import { useRenderGovernor } from './use-render-governor.js';
@@ -435,6 +441,32 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const updateToastPushed = useRef(false);
     const budgetRef = useRef(emptyBudget());
     const followTimer = useRef(null);
+    /**
+     * The forced-dispatch gate's three counters (team-command-forced-dispatch
+     * §3.7). REFS, for the reason the follow-through block above records: every
+     * field added to `ViewState` is a field `restoreEntries`, `/clear`, `/reset`
+     * and the session round-trip each have to have an opinion about, and none of
+     * them has an opinion about a counter that lives for one turn.
+     *
+     * `toolsUsed` and `dispatchAttempted` are cleared at `agent_start`; `nudges`
+     * is NOT - see its own comment.
+     */
+    const toolsUsedRef = useRef(0);
+    const dispatchAttemptedRef = useRef(false);
+    /**
+     * Fallback nudges spent. CLEARED BY A USER SUBMIT, NEVER BY `agent_start`
+     * (P0-2 / I-10).
+     *
+     * The nudge itself starts a NEW TURN, so a reset at `agent_start` would zero
+     * this counter at the top of every continuation and "at most one per turn"
+     * would become "one per turn, forever" - an unbounded loop of N-child
+     * dispatches that only ever fires while the model is being disobedient, which
+     * is precisely the state no manual test reproduces. The one reset lives in
+     * `submitMessage` under `opts.userInitiated !== false`, beside the
+     * `recordPrompt` call that answers the same question ("did a human ask for
+     * this?").
+     */
+    const nudgesRef = useRef(0);
     /** True while the run in flight was started by the grace timer, not the user. */
     const autoContinuationRef = useRef(false);
     /**
@@ -526,8 +558,8 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
      * Disarm an armed continuation. Idempotent; NEVER touches the budget — a
      * cancelled continuation was never issued, so it must not be charged (AC-18).
      *
-     * Three callers and there must be no fourth: `Esc` in the idle branch, the
-     * first line of `submitMessage`, and the subscription effect's cleanup.
+     * ONE SLOT: `Esc`, `submitMessage`, the reset/restore port, the effect cleanup
+     * and both follow-through arms (todo, then the gate) all cancel before arming.
      */
     const cancelFollowThrough = useCallback(() => {
         if (followTimer.current) {
@@ -639,6 +671,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             if (event.type === 'agent_start') {
                 interactionPhase.current = 'running';
                 manualMetrics.current = createRunMetrics();
+                // THE TWO PER-TURN COUNTERS ONLY (I-10). `nudgesRef` is deliberately
+                // absent: a nudge continuation arrives here too, and clearing it would
+                // delete the bound that keeps a disobedient model from looping.
+                toolsUsedRef.current = 0;
+                dispatchAttemptedRef.current = false;
             }
             if (event.type === 'agent_end') {
                 interactionPhase.current = 'idle';
@@ -654,6 +691,17 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                 if (action.type === 'notice' && action.level === 'error') {
                     endReasonRef.current.errored = true;
                 }
+                // THE GATE'S TWO FACTS, counted where the reducer's own actions already
+                // flow (no second subscription to keep in step). `toolExecStart` carries
+                // the tool NAME, so a `task` call that was REFUSED - team off, dispatch
+                // busy, no key - still counts as an attempt (P1-7): the upstream already
+                // said no, and urging a re-dispatch would reproduce that refusal one
+                // turn later.
+                if (action.type === 'toolExecStart') {
+                    toolsUsedRef.current += 1;
+                    if (action.toolName === 'task')
+                        dispatchAttemptedRef.current = true;
+                }
                 if (action.type === 'textDelta' || action.type === 'thinkingDelta') {
                     pending.current.push(action);
                     if (!flushTimer.current) {
@@ -688,13 +736,36 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             const todos = controller.getTodoSnapshot();
             budgetRef.current = advanceBudget(budgetRef.current, todos, autoContinuationRef.current);
             autoContinuationRef.current = false;
-            const decision = decideFollowThrough({
-                mode: controller.getTodoConfig().followThrough,
-                snapshot: todos,
+            // --- Forced-dispatch gate (team-command-forced-dispatch §3.7). --------
+            //
+            // THE THIRD LAYER, AND THE ONLY MECHANICAL ONE: if a whole turn went by
+            // with tools used and nothing dispatched, ask ONCE for a dispatch. It is
+            // computed BEFORE the todo decision and DOWN-GRADES that decision to
+            // `none` rather than returning early (P0-3 / I-9): the two statements below
+            // - the `endReasonRef` reset and `applyPendingMode()` - belong to EVERY
+            // turn, and a `return` here would silently defer a pending `plan -> build`
+            // by a whole turn and carry `errored` into the next one. It also keeps
+            // `cancelFollowThrough()`'s callers at three: the gate reuses the timer
+            // instead of adding a fourth canceller.
+            const forced = controller.getForcedTeam();
+            const gate = decideForcedDispatch({
+                armed: forced !== null,
+                count: forced?.count ?? 0,
+                dispatchAttempted: dispatchAttemptedRef.current,
+                toolsUsed: toolsUsedRef.current,
+                nudgesUsed: nudgesRef.current,
                 runEnd: { ...endReasonRef.current },
-                budget: budgetRef.current,
-                interactive: true,
             });
+            const gated = gate.kind === 'nudge' && forced !== null;
+            const decision = gated
+                ? { kind: 'none' }
+                : decideFollowThrough({
+                    mode: controller.getTodoConfig().followThrough,
+                    snapshot: todos,
+                    runEnd: { ...endReasonRef.current },
+                    budget: budgetRef.current,
+                    interactive: true,
+                });
             endReasonRef.current = { aborted: false, errored: false };
             if (decision.kind === 'notify') {
                 dispatch({ type: 'notice', level: decision.level, text: decision.text });
@@ -739,6 +810,22 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     submitRef.current(decision.message, { userInitiated: false, todoPolicy: 'continue' });
                 }, decision.graceMs);
             }
+            // THE GATE'S OWN CONTINUATION: after the todo branch (which it has
+            // already silenced) and BEFORE `applyPendingMode()`, on the SAME timer and
+            // with the same re-checks. `level: 'warn'` and not `'error'` - the error
+            // level sets `endReasonRef.errored`, which would make the next turn's gate
+            // read "the run failed" and switch itself off for the rest of the session.
+            if (gated && gate.kind === 'nudge') {
+                nudgesRef.current += 1;
+                dispatch({ type: 'notice', level: 'warn', text: FORCED_NUDGE_NOTICE });
+                cancelFollowThrough(); // I-9 / I-3: at most one armed continuation, ever
+                followTimer.current = setTimeout(() => {
+                    followTimer.current = null;
+                    if (controller.isRunning() || controller.isCompactionBusy?.())
+                        return;
+                    submitRef.current(gate.message, { userInitiated: false, todoPolicy: 'continue' });
+                }, FORCED_NUDGE_GRACE_MS);
+            }
             // A deferred `plan -> build` becomes real here and nowhere else (§3.2).
             const applied = controller.applyPendingMode();
             if (applied) {
@@ -843,21 +930,34 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     // handler above records): this effect's dependency list never changes,
                     // so it closes over the `cfg` object of the render it mounted in, and
                     // `setModel` builds a NEW one.
-                    const live = controller.getConfig();
-                    // Every child runs the lead's own model (main-agent parity), so the
-                    // lead's live connection IS the tier that billed.
-                    const ref = { providerId: live.provider, modelId: live.model };
-                    // Unknown pricing contributes ZERO rather than a fabricated figure
-                    // (C-11 / RV-4); `/fast status` and the dispatch report say `unknown`.
-                    const costDelta = controller.isPricedModel(ref)
-                        ? computeCost(event.usage, controller.getModelInfoFor(ref).cost)
-                        : 0;
+                    //
+                    // PRICED AT THE MODEL THE CHILDREN RAN (`team.model`), through the same
+                    // resolution the dispatch report prices with: under `fast` / `profile` the
+                    // lead's table would over-report by up to an order of magnitude, and an
+                    // unpriced child model must read as unknown (ZERO here), not as the lead's.
+                    const costDelta = priceTeamUsage(controller.subagentModelResolution(), event.usage, {
+                        mainCost: controller.getModelInfo().cost,
+                        isPriced: (ref) => controller.isPricedModel(ref),
+                        costFor: (ref) => controller.getModelInfoFor(ref).cost,
+                    });
                     dispatch({ type: 'teamUsage', usage: event.usage, costDelta });
                     break;
                 }
-                case 'dispatch_end':
+                case 'dispatch_end': {
+                    // The supervisor's own calls never emit a usage event (they go through the fast
+                    // registry directly), so their spend reaches the readout HERE, once per
+                    // dispatch, at the fast tier's price - the same channel review spend uses.
+                    const spend = event.outcome.overseerUsage;
+                    if (spend !== undefined && (spend.inputTokens > 0 || spend.outputTokens > 0)) {
+                        const tier = controller.getFastStatus().tier;
+                        const costDelta = tier.ok && controller.isPricedModel(tier.ref)
+                            ? computeCost(spend, controller.getModelInfoFor(tier.ref).cost)
+                            : 0;
+                        dispatch({ type: 'fastUsage', usage: spend, costDelta });
+                    }
                     dispatch({ type: 'teamEnd', outcome: event.outcome });
                     break;
+                }
             }
         });
         return () => {
@@ -1956,8 +2056,15 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // composer's hint fade. An auto-continuation demonstrates nothing about what
         // the user has learned, so suppressing the fade is correct rather than
         // incidental — which is why the parameter is named for the CAUSE (P2-8).
-        if (opts.userInitiated !== false)
+        if (opts.userInitiated !== false) {
             recordPrompt(message);
+            // THE ONE PLACE THE NUDGE BUDGET IS REFILLED (P0-2 / I-10). Same predicate
+            // as `recordPrompt`, and for the same reason: the question is "did a human
+            // ask for this?", and only a human may hand the gate another attempt. A
+            // nudge continuation arrives here with `userInitiated: false`, so it cannot
+            // refill its own budget.
+            nudgesRef.current = 0;
+        }
         // Mirrors where the reducer clears its own copies, in the same action
         // (C-11): a new turn's end reason must not inherit the previous one's.
         endReasonRef.current = { aborted: false, errored: false };
@@ -2966,7 +3073,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // the save handler cannot disagree about what `(inherit)` means.
             ...fastSettingsFrom(cfg.fast),
             ...compactionSettingsFrom(cfg.compaction),
-        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, draft: settingsDraft, probe: probe, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
+        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, draft: settingsDraft, 
+        // THE MISSING LINK (P1-5): without it the `Team` page cannot render
+        // `on (next launch)` for a `--no-team` session, because the subpage is
+        // mounted with `{...props}` and an undeclared prop arrives as
+        // `undefined`. A construction-time snapshot, so reading it per frame is
+        // honest (I-7).
+        teamRegistered: controller.isTeamRegistered(), probe: probe, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
         // Read from `cfg` (render scope, re-read every frame), so `/retry off`
         // while the screen is open shows the new value on the next paint.
         retrySummary: cfg.retry.enabled && cfg.retry.maxRetries > 0 ? String(cfg.retry.maxRetries) : 'off' })) : overlay === 'agents' ? (
@@ -3076,6 +3189,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         railRows: native ? (nativeBudget?.band.railRows ?? 0) : (fullscreenRailVisible ? railRows : 0),
         width: native ? (nativeBudget?.band.railCols ?? 0) : railWidth,
     });
+    // THE FORCED-MODE CHIP'S SOURCE (team-command-forced-dispatch §3.8 / D-9),
+    // read from the controller on every frame: `armForcedTeam()` writes no
+    // `ViewState`, so a mirror would have to be kept in step by hand - which is the
+    // double-truth this design deletes elsewhere. It is handed to `StatusBar`, which
+    // plans the primary row from its own props (a copy on `statusInput` above would
+    // be a field nothing renders).
+    const forcedTeam = controller.getForcedTeam();
     const statusInput = {
         columns: viewCols, phase: state.runPhase, pendingCount: state.pendingSteering.length,
         context: state.context, usageTotal: state.usageTotal, thinkingLevel: cfg.thinkingLevel,
@@ -3144,7 +3264,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // partially stale. The window and its `known` flag now travel INSIDE
         // it, resolved by the meter - which is what makes the user's
         // `contextWindow` override reach the bar.
-        context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ecoRung: governor.rung, ...(state.team
+        context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ...(forcedTeam ? { forcedTeam } : {}), ecoRung: governor.rung, ...(state.team
             ? {
                 // `rosterCounts`, NOT a fourth inline phase filter (A-1): the chip and
                 // the roster header above it must never disagree.

package/dist/ui/StatusBar.d.ts

@@ -65,6 +65,20 @@ export interface StatusBarProps {
     } | null;
     agentMode?: AgentMode;
     pendingAgentMode?: AgentMode | null;
+    /**
+     * Forced team mode is armed, with the count it was armed with
+     * (team-command-forced-dispatch §3.8 / D-9). ABSENT = not armed, and every
+     * existing caller renders the row it always did.
+     *
+     * IT RIDES THIS COMPONENT'S PROPS AND NOT THE APP'S `statusInput`, by the rule
+     * the `compactionActive` chip records where `App` builds it: this component
+     * plans the primary row from its OWN props, so a chip left on `statusInput`
+     * would be a field nothing renders - which is exactly how the only persistently
+     * visible signal of `/team` (D-9) can ship without ever appearing on screen.
+     */
+    forcedTeam?: {
+        count: number;
+    };
     teamActive?: {
         running: number;
         total: number;

package/dist/ui/StatusBar.js

@@ -41,6 +41,7 @@ export function StatusBar(props) {
         compacting: props.compactionActive?.inFlight, retryActive: props.retryActive,
         compactionPaused: props.compactionActive?.selfDisabled === true,
         mode: props.agentMode, pendingMode: props.pendingAgentMode, servicesActive: props.servicesActive,
+        ...(props.forcedTeam ? { forcedTeam: props.forcedTeam } : {}),
         teamActive: props.teamActive, todoActive: props.todoActive,
         ...(props.acceptanceActive ? { acceptanceActive: props.acceptanceActive } : {}),
         ecoRung: props.ecoRung, fastActive: props.fastActive, scrolledLines: props.scrolledLines,

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

@@ -53,6 +53,23 @@ export interface StatusLayoutInput {
     servicesActive?: {
         live: number;
     };
+    /**
+     * Forced team mode is ARMED, with the fan-out count it was armed with
+     * (team-command-forced-dispatch §3.8 / D-9).
+     *
+     * THE ONLY PERSISTENTLY VISIBLE SIGNAL that `/team` happened. The directive is
+     * one turn, the prompt block is invisible, and the panel only appears while a
+     * dispatch runs - so without this chip the answer to "why is my agent
+     * dispatching?" is "remember what you typed". It is read at RENDER time from
+     * `controller.getForcedTeam()`, never mirrored into `ViewState`: a mirror is a
+     * second copy that can disagree, the exact defect §2.4 is about.
+     *
+     * ABSENT means "not armed" and keeps every existing caller's plan BYTE-
+     * IDENTICAL (the same discipline `reserveRight` records below).
+     */
+    forcedTeam?: {
+        count: number;
+    };
     teamActive?: {
         running: number;
         total: number;

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

@@ -220,10 +220,19 @@ export function planPrimaryStatusFields(input) {
         const label = (notification ? undefined : feedbackLabel(input, form))
             ?? (full ? labels[1] : rung >= 4 ? labels[0].slice(0, 4) : labels[0]);
         const modeText = modeFieldText(input.mode, input.pendingMode, full);
+        // IMMEDIATELY AFTER `mode`, and kept at EVERY rung: both describe a state
+        // the USER armed, so the row's emphasis budget goes on them and nothing
+        // else (`accent`). It shortens to `T4` instead of disappearing because a
+        // chip that vanishes on a narrow terminal is indistinguishable from a
+        // disarmed session - the one question it exists to answer.
+        const forcedText = input.forcedTeam
+            ? (rung >= 3 ? `T${input.forcedTeam.count}` : `Team ${input.forcedTeam.count}`)
+            : null;
         return statusLinePlan([
             statusField('phase', glyph + (rung >= 5 ? '' : ' ') + label, phaseTone),
             ...(notice ? [statusField('feedback', notice, feedbackTone)] : []),
             ...(modeText ? [statusField('mode', modeText, 'accent')] : []),
+            ...(forcedText ? [statusField('forcedTeam', forcedText, 'accent')] : []),
             statusField('context', (full ? 'Context ' : 'C') + pct
                 + (input.compactionPaused === true ? pausedSuffix(full) : '')),
             statusField('thinking', full ? 'Think ' + (thinkingCodes[input.thinkingLevel] ? input.thinkingLevel : '?')

package/dist/ui/overlays/HelpOverlay.js

@@ -121,7 +121,7 @@ const COMMANDS = [
     ['/theme <name>', 'auto | warm | cool | light'],
     ['/thinking <level>', 'Set thinking level'],
     ['/max-tokens [n|auto]', 'Output token cap; no argument reports the effective one'],
-    ['/team [on|off|max n]', 'Team subagents: status, switch, fan-out width'],
+    ['/team [on|off|<brief>]', 'Force team mode and start now: /team <brief> fans out'],
     ['/fast [on|off|model|review]', 'Fast model tier: status, switch, model, review cadence'],
     ['/kit [list|use <name>]', 'Agent kits: what is in effect, list them, use one for this session'],
     [
@@ -179,12 +179,16 @@ const PLAN_ROWS = [
 ];
 const TEAM_ROWS = [
     ['task', 'The tool the agent uses to run 2-5 subagents in parallel'],
-    ['/team', 'Status: on/off, max subagents, and the live roster'],
-    ['/team on | off', 'Switch team mode for this session (and save it)'],
-    ['/team max <n>', 'Fan-out width, 1-10 (5 by default)'],
+    ['/team <brief>', 'Force it: arms forced mode and starts that work as a turn'],
+    ['/team on | off', 'Arm it without starting, or leave it; the capability is untouched'],
+    ['/team', 'Report the forced state, capacity, the model, and where to change it'],
+    ['-n <n> / --parts a,b', 'Fix the fan-out, or name the split (narrowing is disclosed)'],
+    ['--read-only', 'Every child refuses writes and shell, for research-only fan-outs'],
+    ['Team 4  (T4)', 'The status-bar chip - only while the session is armed'],
     ['--team / --no-team', 'Start a session with team mode on or off (also ARAGON_TEAM=0)'],
     ['team_send / team_wait', 'How subagents message each other; 6 each, one every 15s'],
     ['Ctrl+B / /agents', 'The board: every child, its full facts, its 24-event timeline'],
+    ['Settings > Team', 'Team mode, width (1-10, 8 by default), concurrency, supervisor'],
 ];
 const FAST_ROWS = [
     ['/fast', 'Status: on/off, the model, the cadence, and this session\'s totals'],

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

@@ -132,6 +132,20 @@ interface SettingsScreenProps {
      * screen. Absent = omit the row entirely.
      */
     retrySummary?: string;
+    /**
+     * Whether `task` is in this SESSION's tool list, for the `Team` page's
+     * `on (next launch)` disclosure (team-command-forced-dispatch §3.9 / P1-5).
+     *
+     * WITHOUT THIS LINK THE DISCLOSURE CANNOT RENDER. The page is mounted with
+     * `{...props}`, so a prop the screen does not declare reaches it as `undefined`
+     * and `--no-team` users are silently told their saved `on` took effect. The
+     * value is a CONSTRUCTION-TIME snapshot (`--no-team` cannot be undone), which is
+     * why reading it every frame does not conflict with I-7.
+     *
+     * OPTIONAL, like `probe` / `retrySummary` above: every fixture builds this by
+     * literal, and absent honestly means "unknown, so do not disclose".
+     */
+    teamRegistered?: boolean;
 }
 /**
  * The derived, non-editable line under the five fast rows — the sibling of

package/dist/ui/overlays/SettingsScreen.js

@@ -28,7 +28,7 @@ import { createModelProfileState, createCustomProfile, modelProfileReducer, prof
 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 { 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).
@@ -854,7 +854,10 @@ function renderProfileSubpage(props, view) {
     // 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' }) });
+        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.
@@ -964,14 +967,21 @@ 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));
+    // 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}`,
-        `Subagent fan-out  ${fanout}`,
+        // `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

@@ -1,5 +1,6 @@
 /**
- * Settings > Team fan-out: three arrows-adjustable rows (subagent-fanout 3.4.3).
+ * 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`.
  *
@@ -9,6 +10,11 @@
  * 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
@@ -30,6 +36,16 @@ interface TeamFanoutPageProps extends ProfileFrameProps {
     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

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 /**
- * Settings > Team fan-out: three arrows-adjustable rows (subagent-fanout 3.4.3).
+ * 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`.
  *
@@ -10,6 +11,11 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * 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
@@ -24,10 +30,18 @@ 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.
+ * 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;
@@ -59,20 +73,18 @@ export function TeamFanoutPage(props) {
             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')
+        // `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: three
-    // numbers whose meaning is not obvious ("per dispatch" versus "at once") are
-    // the reason this page exists at all.
+    // 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 fan-out', hint: "Arrows adjust. Esc goes back; Ctrl+S on the main page saves." });
+    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

@@ -146,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;