@aragon-agent/cli 0.6.40 → 0.6.43

package/dist/agent/controller.d.ts

@@ -25,6 +25,7 @@ import type { ToolPermission } from '../exec/permission.js';
 import { type ToolOutputListener } from '../tools/tool-output-store.js';
 import type { FilePatch } from '../tools/patch.js';
 import type { SubagentModelResolution } from '../team/model.js';
+import type { ForcedTeamState } from '../team/forced-mode.js';
 import type { TeamEvent, TeamSnapshot } from '../team/types.js';
 import { ProcSupervisor } from '../proc/supervisor.js';
 import type { ProcEventListener, ServiceSnapshot } from '../proc/types.js';
@@ -295,8 +296,8 @@ export declare class AgentController {
     /** Static: whether this session could ever render a question overlay. */
     private readonly planInteractive;
     private readonly teamRegistered;
-    private teamEnabled;
     private readonly teamRuntime;
+    private forcedTeam;
     private readonly todoRegistered;
     private todoEnabled;
     private readonly todos;
@@ -704,17 +705,47 @@ export declare class AgentController {
     withHumanWait<T>(fn: () => Promise<T>): Promise<T>;
     /** Whether `task` is in `this.tools`. Fixed at construction; see the fields. */
     isTeamRegistered(): boolean;
-    /** Whether `task` will actually dispatch. Flipped live by `/team on|off`. */
+    /**
+     * Whether `task` will actually dispatch - a DERIVED value.
+     *
+     * One truth (`config.team.enabled`) plus one immutable snapshot
+     * (`teamRegistered`). The previous version read a private copy that `/team
+     * on|off` hand-synchronised, which worked only while that command was the sole
+     * writer; the settings screen writes the config directly, so the copy would
+     * have kept saying `on` (P1-4 / AC-25).
+     */
     isTeamEnabled(): boolean;
     /**
      * Flip the live switch and re-render the prompt.
      *
+     * THE NAME IS KEPT (three call sites plus the settings path) but the body is
+     * one write: `setTeamConfig()` already clamps, bumps the revision and rebuilds,
+     * so there is no second place where a half-applied state can exist.
+     *
      * Turning it ON in a session that started with `--no-team` deliberately does
      * NOT register the tool (D-17): the array is immutable, and advertising an
      * unregistered tool is the dead end P0-2 is about. `/team` reports that
      * honestly by checking `isTeamRegistered()` first.
      */
     setTeamEnabled(enabled: boolean): void;
+    /**
+     * Arm forced team mode for this session (team-command-forced-dispatch §3.5).
+     *
+     * Returns the count actually adopted. The clamp is `[1, team.maxSubagents]`:
+     * `0`, a negative and a fraction are refused by the parser upstream (`-n 0` is
+     * a syntax error, not a clamp), so this is the boundary check of a value that
+     * crossed a module line - which is the one place `CLAUDE.md` asks for it, not a
+     * second validation of the same input.
+     *
+     * THE COUNT IS FROZEN for the rest of the session: `/team -n 2 <brief>` then a
+     * plain message keeps two children per turn, so the user's one expressed intent
+     * does not silently widen back to four.
+     */
+    armForcedTeam(count: number): number;
+    /** Disarm. IDEMPOTENT: disarming an unarmed session rewrites nothing. */
+    disarmForcedTeam(): void;
+    /** The armed state, read at render time by the chip and by `/team`'s status. */
+    getForcedTeam(): ForcedTeamState | null;
     getTeamConfig(): TeamConfig;
     /**
      * Adopt a new team config for this session and re-render the prompt (the block
@@ -728,8 +759,8 @@ export declare class AgentController {
      * One authority for the `task` report's disclosure line and its price
      * table: both read through here, so the header can never name one model
      * while pricing another. Re-resolved on every call for the reason
-     * `resolveFastTier` records - `/fast off`, a settings save and `/team model`
-     * all rewrite the inputs mid-session.
+     * `resolveFastTier` records - `/fast off`, a settings save and the `Subagent
+     * model` row all rewrite the inputs mid-session.
      */
     subagentModelResolution(): SubagentModelResolution;
     /** Refused mid-dispatch by `/team`; half a dispatch under two ceilings is not
@@ -771,7 +802,7 @@ export declare class AgentController {
      * THIS EXISTS BECAUSE `persistConfig` DOES NOT TOUCH THE RUNTIME (P1-2 /
      * AC-38). `App` reads `controller.getConfig()` on every render, and that
      * returns THIS object; the App's `persistConfig` only writes the file. So
-     * `/todo panel off` must call both, exactly as `/team max` does — with only
+     * `/todo panel off` must call both, exactly as settings' `Team` page does — with
      * the persist call the command reports success and changes nothing until the
      * next launch.
      *

package/dist/agent/controller.js

@@ -21,6 +21,9 @@ import { createFastOverseerProvider } from '../team/overseer.js';
 import { createTaskTool } from '../team/task-tool.js';
 import { resolveSubagentModel } from '../team/model.js';
 import { buildTeamBlock } from '../team/prompt.js';
+// THE THIRD LAYER's prompt half (team-command-forced-dispatch §3.6): spliced
+// after `<team_mode>` and before the subagent block, only while armed.
+import { buildForcedTeamBlock } from '../team/forced-prompt.js';
 import { buildFastBlock } from '../fast/prompt.js';
 import { ProcSupervisor } from '../proc/supervisor.js';
 import { buildBackgroundJobsBlock, buildBackgroundServicesBlock } from '../proc/prompt.js';
@@ -172,18 +175,32 @@ export class AgentController {
     // immutable for the life of the session (see the note in the constructor),
     // so `/team on` in a session started with `--no-team` CANNOT add it.
     //
-    // `teamEnabled` is live. `/team off` flips it, which makes `task` refuse
-    // through its own guard and drops `<team_mode>` from the next prompt rebuild
-    // — `rebuildSystemPrompt()` IS a live path, unlike the tool array.
+    // The LIVE switch is NOT a second field (team-command-forced-dispatch §3.5 /
+    // P1-4). It used to be one — `teamEnabled`, flipped by `/team on|off` and
+    // hand-synchronised with `config.team.enabled` — which was a second truth
+    // waiting to separate. The moment the settings screen grew a `Team mode` row,
+    // `applyModelSettingsSnapshot()` replaced `this.config` WITHOUT touching that
+    // copy, and the screen would have said `on` while `task` still answered
+    // TEAM_OFF_REFUSAL. `isTeamEnabled()` is now one derivation over
+    // `config.team.enabled`, and `setTeamEnabled()` is one write to it.
     //
-    // Conflating them is P0-2: the prompt would advertise a tool that was never
-    // registered, every call would come back "unknown tool", and the model would
-    // have no way to discover why (D-17 / R-18).
+    // Conflating the two flags was P0-2 in the original feature: the prompt would
+    // advertise a tool that was never registered, every call would come back
+    // "unknown tool", and the model would have no way to discover why (D-17 / R-18).
     // -----------------------------------------------------------------------
     teamRegistered;
-    teamEnabled;
     teamRuntime;
     // -----------------------------------------------------------------------
+    // Forced team mode (team-command-forced-dispatch §3.5 / D-4).
+    //
+    // SESSION STATE, NEVER PERSISTED: `null` means "not armed". `/team <brief>`
+    // and `/team on` set it, `/team off` clears it, and the process exiting is the
+    // third way it ends. It is not a `config.json` key on purpose — a persisted
+    // "always force a fan-out" would be inherited by `aragon exec` and by every
+    // launch after one experiment, at four children a turn (D-4 / AC-24).
+    // -----------------------------------------------------------------------
+    forcedTeam = null;
+    // -----------------------------------------------------------------------
     // Todo planning (todo-plan-execution §3.6a) — THE SAME TWO FLAGS, FOR THE
     // SAME REASON.
     //
@@ -426,8 +443,10 @@ export class AgentController {
         const fastTier = resolveFastTier(config, (id, role) => this.hasApiKey(id, role));
         const fastRegistered = fastTier.ok;
         // --- Team mode ---------------------------------------------------------
+        // ONE FLAG HERE (team-command-forced-dispatch P1-4): this is the IMMUTABLE
+        // snapshot of "is `task` in this.tools at all". The live switch is
+        // `config.team.enabled`, read through `isTeamEnabled()` — no second copy.
         this.teamRegistered = config.team.enabled;
-        this.teamEnabled = config.team.enabled;
         this.teamRuntime = this.teamRegistered
             ? new TeamRuntime({
                 getConfig: () => this.config,
@@ -711,7 +730,10 @@ export class AgentController {
                     createTaskTool({
                         runtime: this.teamRuntime,
                         // Read LIVE: `/team off` flips the flag, it cannot unregister.
-                        isTeamEnabled: () => this.teamEnabled,
+                        // THROUGH THE METHOD, not the config: one derivation, so the
+                        // task tool, `<team_mode>` and the settings screen can never
+                        // disagree about whether this session may dispatch (P1-4).
+                        isTeamEnabled: () => this.isTeamEnabled(),
                         maxSubagents: () => this.config.team.maxSubagents,
                         hasApiKey: () => this.hasApiKey(),
                         activeProvider: () => this.config.provider,
@@ -878,18 +900,15 @@ export class AgentController {
                     // executor's timeout is cooperative, so an override is inert for any
                     // tool that does not listen (I-2).
                     //
-                    // `dispatchTimeoutMs: 0` (the default) reaches the executor as an
-                    // override of `0` = NO TIMER AT ALL: the dispatch lasts as long as its
-                    // slowest child, and only an Esc ends it early (main-agent parity).
-                    // D-4, THE SECOND ARMING SITE: the runtime arms its own dispatch
-                    // timer under the same gate, because the executor timeout being
-                    // cooperative means this override must never be the ONLY ceiling.
-                    // With the supervisor gate open the ceiling disarms HERE too, so
-                    // team.overseer can never leave two kill paths alive behind one
-                    // config. Read once at construction, exactly as before.
-                    ...(this.teamRegistered
-                        ? { task: config.team.overseer ? 0 : config.team.dispatchTimeoutMs }
-                        : {}),
+                    // ALWAYS `0` = NO EXECUTOR TIMER, and the override itself must stay:
+                    // deleting it would drop `task` back onto the executor's default tool
+                    // timeout and kill every long fan-out at that default. The dispatch
+                    // ceiling lives in ONE place, `TeamRuntime.dispatch()`, which re-reads
+                    // `team.overseer` / `team.dispatchTimeoutMs` on every dispatch. The
+                    // executor's table is frozen at construction, so a ceiling armed here
+                    // outlived a mid-session `Settings > Team` switch to the supervisor
+                    // and killed the dispatch the supervisor was meant to look after.
+                    ...(this.teamRegistered ? { task: 0 } : {}),
                 },
             },
         });
@@ -1056,16 +1075,31 @@ export class AgentController {
             skillTriageBlock: triageBlock,
             agentMode: this.effectiveMode,
             planInteractive: this.planInteractive,
-            // BOTH flags, and both are required (§4.5). `teamRegistered` false means
-            // there is no `task` tool to advertise; `teamEnabled` false means the user
-            // turned it off for this session. Advertising in either case would
-            // describe a capability the model does not have.
-            teamBlock: this.teamRegistered && this.teamEnabled
+            // BOTH halves, and both are required (§4.5). `teamRegistered` false means
+            // there is no `task` tool to advertise; `config.team.enabled` false means
+            // the user turned the capability off (in settings — the only writer).
+            // Advertising in either case would describe a capability the model does not
+            // have. Read through the field rather than `this.isTeamEnabled()` so the
+            // sentence and the code agree, as the two flags always have here (P1-4).
+            teamBlock: this.teamRegistered && this.config.team.enabled
                 ? buildTeamBlock({
                     maxSubagents: config.team.maxSubagents,
                     maxConcurrent: config.team.maxConcurrent,
                 })
                 : '',
+            // THE THIRD LAYER (team-command-forced-dispatch §3.6): "you MUST dispatch"
+            // on top of `<team_mode>`'s "you may". THREE conditions and all three are
+            // load-bearing - armed for this session, the tool actually registered, and
+            // the capability still on. The last two are `<team_mode>`'s own pair, so a
+            // session can never be told to use a tool the prompt above it does not
+            // mention. Empty everywhere else, which is what keeps I-2 (byte-identical
+            // prompt) true for every session that never types `/team`.
+            forcedTeamBlock: this.forcedTeam && this.teamRegistered && this.config.team.enabled
+                ? buildForcedTeamBlock({
+                    count: this.forcedTeam.count,
+                    planMode: this.effectiveMode === 'plan',
+                })
+                : '',
             // BOTH FLAGS, exactly as team mode uses both, and for the identical
             // reason: `todoRegistered` false means there is no `todo_write` to
             // advertise, `todoEnabled` false means the user turned it off for this
@@ -1723,22 +1757,67 @@ export class AgentController {
     isTeamRegistered() {
         return this.teamRegistered;
     }
-    /** Whether `task` will actually dispatch. Flipped live by `/team on|off`. */
+    /**
+     * Whether `task` will actually dispatch - a DERIVED value.
+     *
+     * One truth (`config.team.enabled`) plus one immutable snapshot
+     * (`teamRegistered`). The previous version read a private copy that `/team
+     * on|off` hand-synchronised, which worked only while that command was the sole
+     * writer; the settings screen writes the config directly, so the copy would
+     * have kept saying `on` (P1-4 / AC-25).
+     */
     isTeamEnabled() {
-        return this.teamEnabled;
+        return this.teamRegistered && this.config.team.enabled;
     }
     /**
      * Flip the live switch and re-render the prompt.
      *
+     * THE NAME IS KEPT (three call sites plus the settings path) but the body is
+     * one write: `setTeamConfig()` already clamps, bumps the revision and rebuilds,
+     * so there is no second place where a half-applied state can exist.
+     *
      * Turning it ON in a session that started with `--no-team` deliberately does
      * NOT register the tool (D-17): the array is immutable, and advertising an
      * unregistered tool is the dead end P0-2 is about. `/team` reports that
      * honestly by checking `isTeamRegistered()` first.
      */
     setTeamEnabled(enabled) {
-        this.advanceSettingsRevision();
-        this.teamEnabled = enabled;
+        this.setTeamConfig({ enabled });
+    }
+    /**
+     * Arm forced team mode for this session (team-command-forced-dispatch §3.5).
+     *
+     * Returns the count actually adopted. The clamp is `[1, team.maxSubagents]`:
+     * `0`, a negative and a fraction are refused by the parser upstream (`-n 0` is
+     * a syntax error, not a clamp), so this is the boundary check of a value that
+     * crossed a module line - which is the one place `CLAUDE.md` asks for it, not a
+     * second validation of the same input.
+     *
+     * THE COUNT IS FROZEN for the rest of the session: `/team -n 2 <brief>` then a
+     * plain message keeps two children per turn, so the user's one expressed intent
+     * does not silently widen back to four.
+     */
+    armForcedTeam(count) {
+        const ceiling = Math.max(1, this.config.team.maxSubagents);
+        const adopted = Math.max(1, Math.min(Math.floor(count), ceiling));
+        this.forcedTeam = { count: adopted };
+        // RE-RENDER: the `<forced_team_mode>` block has to be in the very next
+        // request, and `rebuildSystemPrompt()` is the live path that does it (it is
+        // also why the command body prints a notice: this produces no AgentEvent, so
+        // without one React would not repaint the `Team N` chip - P1-6).
         this.rebuildSystemPrompt();
+        return adopted;
+    }
+    /** Disarm. IDEMPOTENT: disarming an unarmed session rewrites nothing. */
+    disarmForcedTeam() {
+        if (!this.forcedTeam)
+            return;
+        this.forcedTeam = null;
+        this.rebuildSystemPrompt();
+    }
+    /** The armed state, read at render time by the chip and by `/team`'s status. */
+    getForcedTeam() {
+        return this.forcedTeam;
     }
     getTeamConfig() {
         return this.config.team;
@@ -1761,8 +1840,8 @@ export class AgentController {
      * One authority for the `task` report's disclosure line and its price
      * table: both read through here, so the header can never name one model
      * while pricing another. Re-resolved on every call for the reason
-     * `resolveFastTier` records - `/fast off`, a settings save and `/team model`
-     * all rewrite the inputs mid-session.
+     * `resolveFastTier` records - `/fast off`, a settings save and the `Subagent
+     * model` row all rewrite the inputs mid-session.
      */
     subagentModelResolution() {
         return resolveSubagentModel(this.config, (id, role) => this.hasApiKey(id, role));
@@ -1847,7 +1926,7 @@ export class AgentController {
      * THIS EXISTS BECAUSE `persistConfig` DOES NOT TOUCH THE RUNTIME (P1-2 /
      * AC-38). `App` reads `controller.getConfig()` on every render, and that
      * returns THIS object; the App's `persistConfig` only writes the file. So
-     * `/todo panel off` must call both, exactly as `/team max` does — with only
+     * `/todo panel off` must call both, exactly as settings' `Team` page does — with
      * the persist call the command reports success and changes nothing until the
      * next launch.
      *

package/dist/agent/headless.js

@@ -6,6 +6,7 @@
  */
 import { formatCost, formatTokens, formatDuration, computeCost } from './usage.js';
 import { formatStreamError } from './reducer.js';
+import { runDurationMs } from '../team/report.js';
 import { derivePlanPhase } from '../todo/acceptance.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
 /** Run a single prompt headlessly and resolve with the process exit code. */
@@ -99,19 +100,22 @@ export async function runHeadless(controller, prompt, options = {}) {
         if (quiet)
             return;
         if (event.type === 'dispatch_start') {
+            // Labels default to a1, a2... on every dispatch, so "once only" is per dispatch.
+            started.clear();
+            finished.clear();
             err.write(`\n[team] dispatch ${event.specs.length} subagents\n`);
             return;
         }
         if (event.type === 'agent_update') {
             const { run } = event;
-            if (run.phase !== 'queued' && !started.has(run.label)) {
+            if (run.startedAt !== undefined && !started.has(run.label)) {
                 started.add(run.label);
                 err.write(`[team] ${run.label} start "${run.description}"\n`);
             }
             const terminal = run.phase === 'done' || run.phase === 'failed' || run.phase === 'aborted';
             if (terminal && !finished.has(run.label)) {
                 finished.add(run.label);
-                const ms = Math.max(0, (run.endedAt ?? 0) - (run.startedAt ?? 0));
+                const ms = runDurationMs(run);
                 const verdict = run.phase === 'done' && !run.error ? 'ok' : run.phase;
                 err.write(`[team] ${run.label} ${verdict} ${formatDuration(ms)} ${run.toolCalls} tools\n`);
             }

package/dist/agent/system-prompt.d.ts

@@ -56,6 +56,25 @@ export interface SystemPromptParams {
      * produce the pre-team prompt BYTE FOR BYTE.
      */
     teamBlock?: string;
+    /**
+     * The rendered `<forced_team_mode>` block while the session is ARMED, or `''`
+     * (team-command-forced-dispatch §3.6 / I-2).
+     *
+     * A SEPARATE PARAMETER FROM `teamBlock`, not a sentence appended to it: that
+     * block says the lead MAY dispatch, this one says it MUST, and merging them
+     * would make the obligation inseparable from the permission - so an ordinary
+     * team session would start inheriting the forced tone, and switching `/team
+     * off` could only be done by rebuilding the team block itself.
+     *
+     * SPLICED AFTER `teamBlock` (it is the tightening of it) and BEFORE
+     * `subagentBlock` (a child must never read it: children have no `task` tool, so
+     * the block would order a call that cannot succeed - the same reason
+     * `system-prompt.ts:68` gives for keeping the two role blocks apart).
+     *
+     * Absent or `''` keeps the prompt BYTE-IDENTICAL to the pre-feature output,
+     * which is what I-2 asserts for every session that never types `/team`.
+     */
+    forcedTeamBlock?: string;
     /**
      * The rendered `<subagent_role>` block for a CHILD, or `''`.
      *

package/dist/agent/system-prompt.js

@@ -39,6 +39,7 @@ export function buildSystemPrompt(params) {
     // keeps this block's absence byte-identical to the pre-feature prompt (I-T1).
     const skillTriageBlock = params.skillTriageBlock ?? '';
     const teamBlock = params.teamBlock ?? '';
+    const forcedTeamBlock = params.forcedTeamBlock ?? '';
     const subagentBlock = params.subagentBlock ?? '';
     const todoBlock = params.todoBlock ?? '';
     const fastBlock = params.fastBlock ?? '';
@@ -66,6 +67,10 @@ export function buildSystemPrompt(params) {
         ...(skillTriageBlock ? ['', skillTriageBlock] : []),
         ...(planBlock ? ['', planBlock] : []),
         ...(teamBlock ? ['', teamBlock] : []),
+        // IMMEDIATELY AFTER `<team_mode>`: "can" then "must". BEFORE the subagent
+        // block, because a child reading an order to dispatch would be ordered to use
+        // a tool it does not have (§3.6).
+        ...(forcedTeamBlock ? ['', forcedTeamBlock] : []),
         ...(subagentBlock ? ['', subagentBlock] : []),
         ...(todoBlock ? ['', todoBlock] : []),
         ...(fastBlock ? ['', fastBlock] : []),

package/dist/commands/builtins.js

@@ -21,13 +21,15 @@ import { applyRestoredSession } from '../session/startup-session.js';
 import { runSessionCommand } from './session-command.js';
 import { runBranchCommand } from './branch-command.js';
 import { getLogger } from '../logging/logger.js';
-import { resolveFastTier } from '../fast/resolve.js';
-import { subagentModelSummary } from '../ui/overlays/model-profile-state.js';
 import { registerQueueCommand } from './queue-command.js';
 import { registerPromptCommands } from '../prompts/command.js';
 import { registerKitCommand } from './kit-command.js';
 import { registerAgentsCommand } from './agents-command.js';
 import { registerSubagentCommand } from './subagent-command.js';
+// `/team` (team-command-forced-dispatch §3.10). The BODY is `commands/team-command.ts`
+// and this pair of lines is the whole registration; the `team` entry that used to
+// live in `COMMANDS` above was a CONFIG command and now lives in `Settings > Team`.
+import { registerTeamCommand } from './team-command.js';
 // THE DRAWER AND THE HEADER LABEL (tui-shortcut-drawer-and-task-summary §4.7):
 // two single-purpose commands in their own modules, registered from here. Both are
 // UNCONDITIONAL, even with `taskSummary.enabled=false`, because they are the only
@@ -108,66 +110,6 @@ function formatUpdateStatus(port, override) {
     lines.push(`  next      ${next ? new Date(next).toLocaleTimeString() : 'not scheduled'}`);
     return lines.join('\n');
 }
-/**
- * `/team model [main|fast|<profile-name>]` (subagent-model §3.6 / 5.2).
- *
- * The user-owned switch's command-line surface. `main` and `fast` are verbs
- * compared case-insensitively; a NAME is matched EXACTLY, case and all,
- * against the library - the same identity the picker shows - and a miss lists
- * the names that would work rather than failing silently. The summary reuses
- * the exact wording the settings root row renders, so the two surfaces can
- * never describe the same setting differently.
- */
-function runTeamModelCommand(ctx, subject) {
-    const controller = ctx.controller;
-    const config = controller.getConfig();
-    const tier = resolveFastTier(config, (id, role) => controller.hasApiKey(id, role));
-    const summary = subagentModelSummary({
-        mode: config.team.model,
-        modelProfileId: config.team.modelProfileId,
-        mainConnection: `${config.provider}:${config.model}`,
-        fastConnection: tier.ok ? `${tier.ref.providerId}:${tier.ref.modelId}` : null,
-        profiles: config.modelProfiles,
-        hasKey: (id) => controller.hasApiKey(id),
-    });
-    if (!subject) {
-        // The status readout: mode + the connection actually in effect + the
-        // disclosed reason when the request had to fall back (D-4).
-        const resolution = controller.subagentModelResolution();
-        const note = resolution.fallbackReason
-            ? ` Unavailable (${resolution.fallbackReason}); children run on the main model.`
-            : resolution.effective === 'main'
-                ? ''
-                : ` Children run on ${resolution.ref.providerId}:${resolution.ref.modelId}.`;
-        ctx.notify('info', `Subagent model: ${summary}.${note}`);
-        return;
-    }
-    if (subject.toLowerCase() === 'main' || subject.toLowerCase() === 'fast') {
-        const mode = subject.toLowerCase();
-        const applied = controller.setTeamConfig({ model: mode });
-        ctx.persistConfig({ team: { model: applied.model } });
-        if (mode === 'fast' && !tier.ok) {
-            ctx.notify('warn', 'The fast tier is not available now; subagents will fall back to the main model.');
-        }
-        ctx.toast('success', `Subagent model: ${mode === 'main' ? 'same as main' : 'fast tier'}.`);
-        return;
-    }
-    const entries = config.modelProfiles?.entries ?? [];
-    const matches = entries.filter((entry) => entry.name === subject);
-    if (matches.length === 0) {
-        const names = entries.slice(0, 8).map((entry) => entry.name);
-        ctx.notify('warn', `No profile named "${subject}".`
-            + (names.length ? ` Available: ${names.join(', ')}` : ' Create one in /settings first.'));
-        return;
-    }
-    const entry = matches[0];
-    const disambiguation = matches.length > 1 ? ` (#${entry.id.slice(0, 8)})` : '';
-    const applied = controller.setTeamConfig({ model: 'profile', modelProfileId: entry.id });
-    const teamPatch = { model: applied.model,
-        modelProfileId: applied.modelProfileId };
-    ctx.persistConfig({ team: teamPatch });
-    ctx.toast('success', `Subagent model: ${entry.name}${disambiguation} (${entry.provider}:${entry.model}).`);
-}
 /** Rows `/todo status` prints before it says how many it did not. */
 const ACCEPT_STATUS_ROWS = 8;
 /**
@@ -428,126 +370,6 @@ const COMMANDS = [
             ctx.applyAgentMode(target);
         },
     },
-    {
-        name: 'team',
-        description: 'Team subagents: status | on | off | max <n> | overseer on|off | model [main|fast|<profile-name>]',
-        /**
-         * `/team on` CANNOT turn team mode on in a session that started without it,
-         * and this command must not pretend otherwise (§4.5 / D-17 / P0-2).
-         *
-         * `controller.ts` builds the tool array ONCE and its own comment forbids
-         * rebuilding it: `Agent.setTools()` mutates the live `ToolRegistry`, and
-         * `submit_plan` flips the session mode from INSIDE a tool execution, so a
-         * rebuild at that moment would mutate the registry mid-iteration. But
-         * `rebuildSystemPrompt()` IS a live path — so the naive reading of `/team on`
-         * (flip a flag, re-splice `<team_mode>`) produces a session where the model
-         * is told it has a `task` tool that was never registered. Every call comes
-         * back "unknown tool", and the model has no way to discover why.
-         *
-         * So the answer splits by what was decided at construction, and the honest
-         * branch — persist it, say the session is unchanged — is the whole point.
-         */
-        run: (ctx) => {
-            const arg = ctx.args.trim().toLowerCase();
-            const [verb, value] = arg.split(/\s+/, 2);
-            const controller = ctx.controller;
-            // RAW TOKENS, KEPT BESIDE THE LOWERCASED PAIR (V-2): `model` matches a
-            // profile NAME case-sensitively - like the picker and the library -
-            // and the whole-args toLowerCase() above would have made
-            // `/team model MyProfile` silently unmatchable. Only the VERB token is
-            // compared through the lowercased pair.
-            const rawTokens = ctx.args.trim().split(/\s+/).filter((token) => token.length > 0);
-            // Refused mid-dispatch for the reason `/reload` already records: half a
-            // dispatch under one ceiling and half under another produces a result
-            // nothing can afterwards explain.
-            if (verb && verb !== 'status' && controller.isTeamBusy()) {
-                ctx.notify('warn', 'Cannot change team settings mid-dispatch.');
-                return;
-            }
-            if (!verb || verb === 'status') {
-                const cfg = controller.getTeamConfig();
-                const config = controller.getConfig();
-                const state = !controller.isTeamRegistered()
-                    ? 'off for this session (started with --no-team)'
-                    : controller.isTeamEnabled()
-                        ? 'on'
-                        : 'off';
-                const snapshot = controller.getTeamSnapshot();
-                const roster = snapshot
-                    ? `\nRunning: ${snapshot.runs.map((r) => `${r.label} (${r.phase})`).join(', ')}`
-                    : '';
-                const tier = resolveFastTier(controller.getConfig(), (id, role) => controller.hasApiKey(id, role));
-                const subagent = subagentModelSummary({
-                    mode: cfg.model,
-                    modelProfileId: cfg.modelProfileId,
-                    mainConnection: `${config.provider}:${config.model}`,
-                    fastConnection: tier.ok ? `${tier.ref.providerId}:${tier.ref.modelId}` : null,
-                    profiles: config.modelProfiles,
-                    hasKey: (id) => controller.hasApiKey(id),
-                });
-                ctx.notify('info', `Team mode: ${state}. Max subagents: ${cfg.maxSubagents}, ` +
-                    `concurrent: ${cfg.maxConcurrent}, supervisor: ${cfg.overseer ? 'on' : 'off'}` +
-                    `${cfg.overseer ? ' (never kills; checks the fast tier each tick)' : ' (legacy hard timeouts)'}.` +
-                    `\nSubagent model: ${subagent}` +
-                    `${roster}`);
-                return;
-            }
-            if (verb === 'on' || verb === 'off') {
-                const enabled = verb === 'on';
-                // A PARTIAL `team` section, safe only because `updatePersistedConfig`
-                // deep-merges it — the same contract `/skills disable` relies on.
-                ctx.persistConfig({ team: { enabled } });
-                if (!controller.isTeamRegistered()) {
-                    // The bottom-right cell of §4.5's table. It is honest, it is one
-                    // sentence, and it keeps AC-11 intact: a `--no-team` session never
-                    // grows a wrapper or an entry, whatever the user types afterwards.
-                    ctx.notify('info', enabled
-                        ? 'Team mode is off for this session (started with --no-team). Saved for next launch.'
-                        : 'Team mode is already off for this session. Saved for next launch.');
-                    return;
-                }
-                controller.setTeamEnabled(enabled);
-                ctx.toast('success', `Team mode ${enabled ? 'on' : 'off'}.`);
-                return;
-            }
-            if (verb === 'max') {
-                const n = Number.parseInt(value ?? '', 10);
-                if (!Number.isFinite(n) || n <= 0) {
-                    ctx.notify('warn', 'Usage: /team max <n>');
-                    return;
-                }
-                // Clamped by `setTeamConfig` and again on the persist path, so a value
-                // above the requirement's ceiling can reach neither the runtime nor the
-                // file (R-g).
-                const applied = controller.setTeamConfig({ maxSubagents: n });
-                ctx.persistConfig({
-                    team: { maxSubagents: applied.maxSubagents },
-                });
-                ctx.toast('success', `Max subagents set to ${applied.maxSubagents}.`);
-                return;
-            }
-            if (verb === 'model') {
-                runTeamModelCommand(ctx, rawTokens[1]);
-                return;
-            }
-            if (verb === 'overseer') {
-                if (value !== 'on' && value !== 'off') {
-                    ctx.notify('warn', 'Usage: /team overseer on|off');
-                    return;
-                }
-                // Read LIVE per dispatch by the runtime, so no rebuild is needed - the
-                // same reason this command does not touch the tool array (its own header
-                // comment). Clamped by `setTeamConfig` and again on the persist path.
-                const applied = controller.setTeamConfig({ overseer: value === 'on' });
-                ctx.persistConfig({
-                    team: { overseer: applied.overseer },
-                });
-                ctx.toast('success', `Dispatch supervisor ${applied.overseer ? 'on' : 'off'}.`);
-                return;
-            }
-            ctx.notify('warn', `Unknown argument "${verb}" - use /team [status|on|off|max <n>|overseer on|off|model main|fast|<profile-name>].`);
-        },
-    },
     {
         name: 'fast',
         description: 'Fast model tier: status | on | off | model <id> | provider <id> | same | ' +
@@ -1515,7 +1337,15 @@ export function registerBuiltinCommands(registry) {
     // and for the same reason: a `--no-team` session must still be able to ask the
     // command why it cannot force anything (I-7 / AC-15) - so registering it may
     // not read config, build a connection or send a request.
+    // It is now a DEPRECATED ALIAS of `/team` (team-command-forced-dispatch D-12):
+    // same implementation, one extra toast, no second grammar.
     registerSubagentCommand(registry);
+    // `/team` (team-command-forced-dispatch §3.10). Registered HERE rather than from
+    // `COMMANDS` because the entry that used to sit in that array was the config
+    // command (`status | on | off | max n | overseer | model`) - those four verbs
+    // now live in the settings screen, and this command is the ACT: arm forced mode
+    // and start work. Unconditional, for the reason `/subagent` above records.
+    registerTeamCommand(registry);
     // The keyboard drawer (`Ctrl+G` / `/keys`) and the task label (`/task`). Two
     // registrations, no new mechanism: `/keys` sets the panel's pre-filter and opens
     // the same overlay `Ctrl+G` opens, and `/task` reports what the header cell says.
@@ -1531,6 +1361,10 @@ export function registerBuiltinCommands(registry) {
  * correct when commands are registered dynamically (§7.1 / P1-2).
  */
 export const BUILTIN_COMMAND_NAMES = ['queue', 'prompts', 'agents', 'subagent',
+    // `team` is listed here because it is no longer in `COMMANDS` (it moved to
+    // `commands/team-command.ts`), and this array is the documentation/tests surface
+    // for every built-in name - the `flatMap` below only sees `COMMANDS`.
+    'team',
     'keys', 'task',
     ...COMMANDS.flatMap((c) => [
         c.name,