@aragon-agent/cli 0.6.40 → 0.6.43

package/dist/commands/subagent-command.d.ts

@@ -1,25 +1,30 @@
 /**
- * `/subagent` — force the next turn to fan out into a parallel team
- * (subagent-fanout 3.5 / 5.2).
+ * `/subagent`: a DEPRECATED ALIAS of `/team` (team-command-forced-dispatch
+ * §3.10 / D-12 / I-8).
  *
  * ASCII ONLY: `src/commands/**` is inside `glyphs.test.ts::inScope`.
  *
- * WHAT THIS COMMAND IS AND IS NOT (D-8 / D-9 / D-10). It does not dispatch: it
- * parses the user's intent, refuses honestly when forcing cannot work, prints
- * ONE line saying what will happen next, and submits a normal user turn. The
- * lead then calls `task` on the one dispatch path that already exists, so Esc,
- * the watchdog pause, the report, spend accounting and the concurrency lock all
- * keep working without a second implementation. The consequence the user must
- * be told about is that forcing is INSTRUCTION-LEVEL: the notice says "the next
- * turn dispatches them", never "N subagents started".
+ * WHY IT STILL EXISTS. It shipped, it is in five places in the README, and it is
+ * in the muscle memory of everyone who used the forced fan-out before `/team`
+ * grew its meaning. Removing the name would be a breaking change that buys
+ * nothing the alias does not buy for one `toast`.
  *
- * THE GUARD ORDER IS A CONTRACT (R-P1-10 / R-P1-11): status -> capability ->
- * parse. A `--no-team` session typing `/subagent -n x` is told the session has
- * no team capability, because a syntax hint would send them to fix the one thing
- * that is not wrong.
+ * WHY IT HAS NO BODY. `subagent-fanout-and-forced-dispatch` implemented the
+ * whole grammar - control words, two ceilings, four parse errors, plan-mode
+ * disclosure - and every one of those bytes is now `/team`'s. A second copy here
+ * would drift on the first refinement, and the drift would be invisible: both
+ * commands would keep working, one of them would quietly be the old one. The
+ * file therefore holds ONE delegation and one line of deprecation text, and
+ * `subagent-command.test.ts` asserts both (I-8).
  */
 import type { CommandContext, CommandRegistry } from './registry.js';
-/** The command body; `registerSubagentCommand` is the only registration site. */
+/**
+ * Run `/team`, having first said out loud that this is the same thing.
+ *
+ * THE TOAST COMES FIRST ON PURPOSE: it is one ephemeral line above whatever
+ * `/team` prints, so the sequence reads "you used the old name; here is the
+ * answer" rather than a full answer followed by a correction nobody notices.
+ */
 export declare function runSubagentCommand(ctx: CommandContext): void;
-/** Registered from `builtins.ts` with one line, next to every other subsystem. */
+/** Registered from `builtins.ts`: the name, and nothing else, lives here. */
 export declare function registerSubagentCommand(registry: CommandRegistry): void;

package/dist/commands/subagent-command.js

@@ -1,242 +1,39 @@
 /**
- * `/subagent` — force the next turn to fan out into a parallel team
- * (subagent-fanout 3.5 / 5.2).
+ * `/subagent`: a DEPRECATED ALIAS of `/team` (team-command-forced-dispatch
+ * §3.10 / D-12 / I-8).
  *
  * ASCII ONLY: `src/commands/**` is inside `glyphs.test.ts::inScope`.
  *
- * WHAT THIS COMMAND IS AND IS NOT (D-8 / D-9 / D-10). It does not dispatch: it
- * parses the user's intent, refuses honestly when forcing cannot work, prints
- * ONE line saying what will happen next, and submits a normal user turn. The
- * lead then calls `task` on the one dispatch path that already exists, so Esc,
- * the watchdog pause, the report, spend accounting and the concurrency lock all
- * keep working without a second implementation. The consequence the user must
- * be told about is that forcing is INSTRUCTION-LEVEL: the notice says "the next
- * turn dispatches them", never "N subagents started".
+ * WHY IT STILL EXISTS. It shipped, it is in five places in the README, and it is
+ * in the muscle memory of everyone who used the forced fan-out before `/team`
+ * grew its meaning. Removing the name would be a breaking change that buys
+ * nothing the alias does not buy for one `toast`.
  *
- * THE GUARD ORDER IS A CONTRACT (R-P1-10 / R-P1-11): status -> capability ->
- * parse. A `--no-team` session typing `/subagent -n x` is told the session has
- * no team capability, because a syntax hint would send them to fix the one thing
- * that is not wrong.
+ * WHY IT HAS NO BODY. `subagent-fanout-and-forced-dispatch` implemented the
+ * whole grammar - control words, two ceilings, four parse errors, plan-mode
+ * disclosure - and every one of those bytes is now `/team`'s. A second copy here
+ * would drift on the first refinement, and the drift would be invisible: both
+ * commands would keep working, one of them would quietly be the old one. The
+ * file therefore holds ONE delegation and one line of deprecation text, and
+ * `subagent-command.test.ts` asserts both (I-8).
  */
-import { buildForcedDirective, parseSubagentArgs } from '../team/forced-dispatch.js';
-import { subagentModelSummary } from '../ui/overlays/model-profile-state.js';
+import { runTeamCommand } from './team-command.js';
 /**
- * The default count when the user names none (D-11).
+ * Run `/team`, having first said out loud that this is the same thing.
  *
- * FOUR, not `maxSubagents`: `<team_mode>` tells the model two to four is usually
- * enough, so "force one dispatch" must not silently become the most expensive
- * call the session can make. The status line advertises the real ceiling so the
- * user who wants the widest fan-out knows which flag to add.
+ * THE TOAST COMES FIRST ON PURPOSE: it is one ephemeral line above whatever
+ * `/team` prints, so the sequence reads "you used the old name; here is the
+ * answer" rather than a full answer followed by a correction nobody notices.
  */
-const DEFAULT_FORCED_COUNT = 4;
-/** `off (--no-team)` / `off` / `on`: the three states the status line tells apart. */
-function teamState(ctx) {
-    if (!ctx.controller.isTeamRegistered())
-        return 'off (--no-team)';
-    return ctx.controller.isTeamEnabled() ? 'on' : 'off';
-}
-/** The subagent model line, phrased by the same authority `/team status` uses. */
-function modelLine(ctx) {
-    const config = ctx.controller.getConfig();
-    const team = ctx.controller.getTeamConfig();
-    const fast = config.fast;
-    return subagentModelSummary({
-        mode: team.model,
-        modelProfileId: team.modelProfileId,
-        mainConnection: `${config.provider}:${config.model}`,
-        fastConnection: fast.enabled && fast.model
-            ? `${fast.provider || config.provider}:${fast.model}` : null,
-        profiles: config.modelProfiles,
-        hasKey: (id) => ctx.controller.hasApiKey(id),
-    });
-}
-/**
- * The no-argument answer: five lines, honest in every session state.
- *
- * IT RUNS BEFORE EVERY GUARD (R-P1-11). "How wide can I go?" is a question, not
- * a request, and a question deserves an answer even in a `--no-team` session -
- * which is exactly where the user is most likely to ask it.
- */
-function reportStatus(ctx) {
-    const team = ctx.controller.getTeamConfig();
-    const max = team.maxSubagents;
-    // The bracket's bounds are the LIVE width, never a literal: at capacity 2 this
-    // line has to read `<2-2>`, or the status line teaches a flag that arrives
-    // narrowed every time.
-    const low = Math.min(2, max);
-    const lines = [
-        `Forced fan-out: /subagent [-n <${low}-${max}>] [--parts a,b,c] [--read-only] <brief>`,
-        `Capacity: ${max} per dispatch, ${team.maxConcurrent} at once `
-            + '(team.maxSubagents / team.maxConcurrent)',
-        `Subagent model: ${modelLine(ctx)}`,
-        `Supervisor: ${team.overseer ? 'on' : 'off'}. Team mode: ${teamState(ctx)}.`,
-    ];
-    // Disclosed, never refused (R-P2-6): plan mode may remove `task` from this
-    // turn's tool array, and a user who is told so will not read the silence as a
-    // broken command.
-    if (ctx.controller.getAgentMode() === 'plan') {
-        lines.push('Plan mode is on: the task tool may be unavailable this turn.');
-    }
-    ctx.notify('info', lines.join('\n'));
-}
-/**
- * Guard 5's sentence. The provider is named because "no API key" alone leaves
- * the user guessing which of their configured providers is the empty one.
- */
-function reportMissingKey(ctx, team) {
-    const config = ctx.controller.getConfig();
-    const resolution = ctx.controller.subagentModelResolution();
-    const provider = resolution.effective === 'main'
-        ? config.provider : resolution.ref.providerId;
-    const note = team.model === 'fast' && !ctx.controller.hasApiKey(undefined, 'fast')
-        ? ' Fast tier has no key either; children will fail and the report will say so.'
-        : '';
-    ctx.notify('warn', `No API key for ${provider}. Set one with /settings or an environment variable.${note}`);
-}
-/** The five capability refusals, in the fixed order 3.5.3 records. */
-function refused(ctx, team) {
-    if (!ctx.controller.isTeamRegistered()) {
-        ctx.notify('warn', 'Team mode is off for this session (started with --no-team). '
-            + 'Restart without --no-team to use /subagent.');
-        return true;
-    }
-    if (!ctx.controller.isTeamEnabled()) {
-        ctx.notify('warn', 'Team mode is off. Run /team on, then /subagent again.');
-        return true;
-    }
-    // The team lock and the lead's turn are separate refusals for one reason: both
-    // would collide with `task`'s own BUSY_REFUSAL, and the user would see a failed
-    // tool card instead of a sentence explaining why nothing ran.
-    if (ctx.controller.isTeamBusy()) {
-        ctx.notify('warn', 'A team dispatch is already running. '
-            + 'Wait for its report, or press Esc to stop it.');
-        return true;
-    }
-    if (ctx.controller.isRunning()) {
-        ctx.notify('warn', 'A turn is in progress. Press Esc to stop it, then run /subagent again.');
-        return true;
-    }
-    if (!ctx.controller.hasApiKey()) {
-        reportMissingKey(ctx, team);
-        return true;
-    }
-    return false;
-}
-/** The four parse failures, each with the one sentence that fixes it. */
-function reportParseError(ctx, parsed) {
-    if (parsed.error === 'count') {
-        ctx.notify('warn', '/subagent: -n needs a number of 1 or more, e.g. -n 4.');
-        return;
-    }
-    if (parsed.error === 'conflict') {
-        ctx.notify('warn', '/subagent: use -n or --parts, not both.');
-        return;
-    }
-    if (parsed.error === 'flag') {
-        ctx.notify('warn', `/subagent: unknown option "${parsed.token ?? ''}". Try /subagent for usage.`);
-        return;
-    }
-    ctx.notify('warn', '/subagent <brief> - describe the work; add -n <count> to fix the fan-out.');
-}
-/**
- * Narrow the parsed intent against the LIVE width.
- *
- * TWO CEILINGS, IN THIS ORDER (R-P1-3): the structural `forcedPartsMax` bounds
- * what one argument may carry (the parser already applied it), and the policy
- * `maxSubagents` bounds what this session may dispatch - which only this layer
- * can apply, because only it can read the live config.
- */
-function planForced(args, team) {
-    const max = team.maxSubagents;
-    if (args.parts.length > 0) {
-        // A PARTS LIST STARTS WITH A CHILD PER SURVIVING PART, and `requested` is the
-        // number the user TYPED - not the structural 8 the parser already applied.
-        // Quoting the post-truncation count made the old notice tell a user who asked
-        // for eleven parts that they had asked for eight (R-4: the notice and the
-        // directive must both name the user's number).
-        const parts = args.parts.slice(0, max);
-        return {
-            brief: args.brief,
-            parts,
-            partsAdmitted: args.parts.length,
-            partsRequested: args.partsRequested,
-            requested: args.partsRequested,
-            count: parts.length,
-            readOnly: args.readOnly,
-        };
-    }
-    const requested = args.count ?? Math.min(DEFAULT_FORCED_COUNT, max);
-    return {
-        brief: args.brief,
-        parts: [],
-        partsAdmitted: 0,
-        partsRequested: 0,
-        requested,
-        count: Math.max(1, Math.min(requested, max)),
-        readOnly: args.readOnly,
-    };
-}
-/** The one line that says what the NEXT turn will do - a plan, not a result. */
-function planNotice(planned, team) {
-    const noun = planned.count === 1 ? 'subagent' : 'subagents';
-    const head = `Forcing a fan-out of ${planned.count} ${noun}`;
-    const followUp = `${head} (max ${team.maxSubagents}) - the next turn dispatches them. `
-        + 'Esc stops the turn.';
-    // TWO CEILINGS, TWO SENTENCES. `forcedPartsMax` bounds what one argument may
-    // carry and `team.maxSubagents` bounds what may be dispatched; naming the wrong
-    // one sends the user to change a number that is not the reason.
-    if (planned.parts.length > 0) {
-        if (planned.parts.length < planned.partsAdmitted) {
-            return `${head} (asked for ${planned.partsRequested} parts; `
-                + `team.maxSubagents is ${team.maxSubagents}).`;
-        }
-        if (planned.partsAdmitted < planned.partsRequested) {
-            return `${head} (asked for ${planned.partsRequested} parts, `
-                + `the first ${planned.parts.length} are used).`;
-        }
-        return followUp;
-    }
-    if (planned.requested > planned.count) {
-        return `${head} (asked for ${planned.requested}; `
-            + `team.maxSubagents is ${team.maxSubagents}).`;
-    }
-    return followUp;
-}
-/** The command body; `registerSubagentCommand` is the only registration site. */
 export function runSubagentCommand(ctx) {
-    if (ctx.args.trim().length === 0) {
-        reportStatus(ctx);
-        return;
-    }
-    const team = ctx.controller.getTeamConfig();
-    if (refused(ctx, team))
-        return;
-    const parsed = parseSubagentArgs(ctx.args);
-    if (!parsed.ok) {
-        reportParseError(ctx, parsed);
-        return;
-    }
-    const planned = planForced(parsed.args, team);
-    const directive = buildForcedDirective({
-        brief: planned.brief,
-        count: planned.count,
-        readOnly: planned.readOnly,
-        parts: planned.parts,
-        maxSubagents: team.maxSubagents,
-        clamped: planned.requested > planned.count,
-        requested: planned.requested,
-        planMode: ctx.controller.getAgentMode() === 'plan',
-    });
-    ctx.notify('info', planNotice(planned, team));
-    // `userInitiated: false`: a directive the user did not type belongs in neither
-    // the prompt history nor the hint-fade counter (todo-plan-followthrough C-12).
-    ctx.submit(directive, { userInitiated: false });
+    ctx.toast('info', '/subagent is now /team - same arguments.');
+    runTeamCommand(ctx);
 }
-/** Registered from `builtins.ts` with one line, next to every other subsystem. */
+/** Registered from `builtins.ts`: the name, and nothing else, lives here. */
 export function registerSubagentCommand(registry) {
     registry.register({
         name: 'subagent',
-        description: 'Force the next turn to fan out into a parallel team',
+        description: 'Deprecated alias of /team - same arguments',
         run: (ctx) => { runSubagentCommand(ctx); },
     });
 }

package/dist/commands/team-command.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `/team`: force the session into team mode and start work, or leave it
+ * (team-command-forced-dispatch §3.3 / §3.4 / §5.1).
+ *
+ * ASCII ONLY: `src/commands/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHAT THIS COMMAND IS. `/team <brief>` parses the user's intent, ARMS a
+ * session-level forced mode and submits ONE normal user turn. The lead analyses
+ * and plans that turn and then has to call `task` - three layers say so: the
+ * directive it is handed, the `<forced_team_mode>` block in every later system
+ * prompt, and the mechanical gate in `ui/App.tsx` that nudges once if a whole
+ * turn went by without a dispatch. This command never dispatches itself (I-1):
+ * Esc, the watchdog, the report, spend accounting and the concurrency lock all
+ * stay on the one path that already has them.
+ *
+ * WHAT IT IS NOT ANY MORE. It used to be the CONFIG command - `status | on | off
+ * | max <n> | overseer on|off | model <name>`. All five verbs now live in the
+ * settings screen (`Settings > Team`, plus the root `Subagent model` row), and
+ * this command writes not one byte of `config.json` (I-4). The reason is the one
+ * the requirement names: a command that both changes configuration and starts
+ * work leaves the user unable to predict what it did. `on` and `off` survive as
+ * SESSION CONTROL words - a mode needs enter, leave and report - and they never
+ * persist; the settings screen is the only persistent writer (I-4 / D-11).
+ *
+ * THE GUARD ORDER IS A CONTRACT (§3.4, R-P1-10 / R-P1-11) and it is not
+ * alphabetical:
+ *
+ *   status (no guard)   - "what is on?" is a question, answerable even in a
+ *                         `--no-team` session, which is where users ask it.
+ *   off   (no guard)    - leaving is always possible, even mid-dispatch.
+ *   registered?         - a `--no-team` session cannot grow the tool (I-7).
+ *   enabled?            - NOT a refusal: it is turned on for this session
+ *                         (D-5), because "start now" must not detour through a
+ *                         settings screen. Nothing is persisted.
+ *   not busy / idle     - two separate sentences, because both would otherwise
+ *                         surface as `task`'s own refusal card.
+ *   key present?        - names the missing provider.
+ *   on                  - arm only; the next message dispatches.
+ *
+ * EVERY `armForcedTeam()` / `disarmForcedTeam()` CALL SITE BELOW IS FOLLOWED BY A
+ * `ctx.notify` / `ctx.toast` IN THE SAME BRANCH (P1-6 / AC-28), because arming
+ * itself produces no `AgentEvent` and therefore no render: without the notice the
+ * `Team 4` chip would wait for an unrelated state change before appearing.
+ */
+import type { CommandContext, CommandRegistry } from './registry.js';
+/** The command body; `registerTeamCommand` is the only registration site. */
+export declare function runTeamCommand(ctx: CommandContext): void;
+/** Registered from `builtins.ts` with one line, next to every other subsystem. */
+export declare function registerTeamCommand(registry: CommandRegistry): void;

package/dist/commands/team-command.js

@@ -0,0 +1,259 @@
+/**
+ * `/team`: force the session into team mode and start work, or leave it
+ * (team-command-forced-dispatch §3.3 / §3.4 / §5.1).
+ *
+ * ASCII ONLY: `src/commands/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHAT THIS COMMAND IS. `/team <brief>` parses the user's intent, ARMS a
+ * session-level forced mode and submits ONE normal user turn. The lead analyses
+ * and plans that turn and then has to call `task` - three layers say so: the
+ * directive it is handed, the `<forced_team_mode>` block in every later system
+ * prompt, and the mechanical gate in `ui/App.tsx` that nudges once if a whole
+ * turn went by without a dispatch. This command never dispatches itself (I-1):
+ * Esc, the watchdog, the report, spend accounting and the concurrency lock all
+ * stay on the one path that already has them.
+ *
+ * WHAT IT IS NOT ANY MORE. It used to be the CONFIG command - `status | on | off
+ * | max <n> | overseer on|off | model <name>`. All five verbs now live in the
+ * settings screen (`Settings > Team`, plus the root `Subagent model` row), and
+ * this command writes not one byte of `config.json` (I-4). The reason is the one
+ * the requirement names: a command that both changes configuration and starts
+ * work leaves the user unable to predict what it did. `on` and `off` survive as
+ * SESSION CONTROL words - a mode needs enter, leave and report - and they never
+ * persist; the settings screen is the only persistent writer (I-4 / D-11).
+ *
+ * THE GUARD ORDER IS A CONTRACT (§3.4, R-P1-10 / R-P1-11) and it is not
+ * alphabetical:
+ *
+ *   status (no guard)   - "what is on?" is a question, answerable even in a
+ *                         `--no-team` session, which is where users ask it.
+ *   off   (no guard)    - leaving is always possible, even mid-dispatch.
+ *   registered?         - a `--no-team` session cannot grow the tool (I-7).
+ *   enabled?            - NOT a refusal: it is turned on for this session
+ *                         (D-5), because "start now" must not detour through a
+ *                         settings screen. Nothing is persisted.
+ *   not busy / idle     - two separate sentences, because both would otherwise
+ *                         surface as `task`'s own refusal card.
+ *   key present?        - names the missing provider.
+ *   on                  - arm only; the next message dispatches.
+ *
+ * EVERY `armForcedTeam()` / `disarmForcedTeam()` CALL SITE BELOW IS FOLLOWED BY A
+ * `ctx.notify` / `ctx.toast` IN THE SAME BRANCH (P1-6 / AC-28), because arming
+ * itself produces no `AgentEvent` and therefore no render: without the notice the
+ * `Team 4` chip would wait for an unrelated state change before appearing.
+ */
+import { buildForcedDirective } from '../team/forced-dispatch.js';
+import { DEFAULT_FORCED_COUNT, planForced, planNotice, readTeamIntent, } from '../team/forced-mode.js';
+import { subagentModelSummary } from '../ui/overlays/model-profile-state.js';
+/**
+ * The subagent model line, phrased by the same authority the settings root row
+ * uses (`subagentModelSummary`), fed the six inputs only this layer can gather.
+ *
+ * IT IS A FUNCTION AND NOT AN INLINE CALL because the six inputs are exactly
+ * what a second copy gets wrong, and the settings root row feeds the same
+ * authority (`subagentModelSummary`) the same six - which is what keeps the two
+ * surfaces from describing one setting differently.
+ */
+function modelLine(ctx) {
+    const config = ctx.controller.getConfig();
+    const team = ctx.controller.getTeamConfig();
+    const fast = config.fast;
+    return subagentModelSummary({
+        mode: team.model,
+        modelProfileId: team.modelProfileId,
+        mainConnection: `${config.provider}:${config.model}`,
+        fastConnection: fast.enabled && fast.model
+            ? `${fast.provider || config.provider}:${fast.model}` : null,
+        profiles: config.modelProfiles,
+        hasKey: (id) => ctx.controller.hasApiKey(id),
+    });
+}
+/**
+ * The no-argument answer: five lines, honest in every session state (§5.1).
+ *
+ * IT RUNS BEFORE EVERY GUARD. "How do I use this?" is a question, not a request,
+ * and it is answerable in a `--no-team` session - which is exactly where the user
+ * most needs the answer.
+ */
+function reportStatus(ctx) {
+    const team = ctx.controller.getTeamConfig();
+    const forced = ctx.controller.getForcedTeam();
+    const registered = ctx.controller.isTeamRegistered();
+    const lines = [
+        forced
+            ? `Forced team mode: on, ${forced.count} subagents per turn.`
+            : 'Forced team mode: off.',
+        registered
+            ? `Team: ${ctx.controller.isTeamEnabled() ? 'on' : 'off'}; `
+                + `${team.maxSubagents} per dispatch, ${team.maxConcurrent} at once; `
+                + `supervisor ${team.overseer ? 'on' : 'off'}.`
+            : 'Team: off for this session (started with --no-team); /team cannot dispatch.',
+        `Subagent model: ${modelLine(ctx)}`,
+        'Usage: /team <brief> arms it and starts now; /team off leaves it.',
+        'Settings > Team has the persistent switches (mode, width, supervisor).',
+    ];
+    // DISCLOSED, NEVER REFUSED (§5.1 third degraded form): plan mode narrows what a
+    // child may do, and a user who is told so will not read the restraint as a bug.
+    if (forced && ctx.controller.getAgentMode() === 'plan') {
+        lines.push('Plan mode is on: dispatch read-only research, then submit_plan.');
+    }
+    ctx.notify('info', lines.join('\n'));
+}
+/**
+ * Guard 5's sentence. The provider is named because "no API key" alone leaves the
+ * user guessing which of their configured providers is the empty one.
+ */
+function reportMissingKey(ctx, team) {
+    const config = ctx.controller.getConfig();
+    const resolution = ctx.controller.subagentModelResolution();
+    const provider = resolution.effective === 'main'
+        ? config.provider : resolution.ref.providerId;
+    const note = team.model === 'fast' && !ctx.controller.hasApiKey(undefined, 'fast')
+        ? ' Fast tier has no key either; children will fail and the report will say so.'
+        : '';
+    ctx.notify('warn', `No API key for ${provider}. Set one with /settings or an environment variable.${note}`);
+}
+/**
+ * The capability guards, in §3.4's exact order: registered -> enabled -> busy ->
+ * running -> key.
+ *
+ * RETURNS `true` WHEN THE CALLER MAY CONTINUE. Step 5 is the one place a guard
+ * becomes an ACTION (D-5) and it sits at its documented position rather than at
+ * the end for a behavioural reason: the user's own sentence is "start now", so
+ * the switch is turned on before any sentence about *why we cannot* is composed.
+ * The action is still followed by a notice in the same branch (P1-6 / AC-28),
+ * because `setTeamEnabled()` rebuilds the prompt and produces no `AgentEvent`, so
+ * without it the `Team N` chip would wait for an unrelated render.
+ */
+function passGuards(ctx, team) {
+    if (!ctx.controller.isTeamRegistered()) {
+        ctx.notify('warn', 'Team mode is off for this session (started with --no-team). '
+            + 'Restart without --no-team to use /team.');
+        return false;
+    }
+    // STEP 5, THE ONE GUARD THAT IS NOT A REFUSAL: "start now" must not detour
+    // through a settings screen. Nothing is persisted here (I-4) - `Settings >
+    // Team` stays the only persistent writer.
+    if (!ctx.controller.isTeamEnabled()) {
+        ctx.controller.setTeamEnabled(true);
+        ctx.notify('info', 'Team mode was off; turned on for this session (Settings > Team saves it).');
+    }
+    // The team lock and the lead's turn are separate refusals for one reason: both
+    // would collide with `task`'s own BUSY_REFUSAL, and the user would see a failed
+    // tool card instead of a sentence explaining why nothing ran.
+    if (ctx.controller.isTeamBusy()) {
+        ctx.notify('warn', 'A team dispatch is already running. '
+            + 'Wait for its report, or press Esc to stop it.');
+        return false;
+    }
+    if (ctx.controller.isRunning()) {
+        ctx.notify('warn', 'A turn is in progress. Press Esc to stop it, then run /team again.');
+        return false;
+    }
+    if (!ctx.controller.hasApiKey()) {
+        reportMissingKey(ctx, team);
+        return false;
+    }
+    return true;
+}
+/** The four parse failures, each with the one sentence that fixes it. */
+function reportParseError(ctx, intent) {
+    if (intent.error === 'count') {
+        ctx.notify('warn', '/team: -n needs a number of 1 or more, e.g. -n 4.');
+        return;
+    }
+    if (intent.error === 'conflict') {
+        ctx.notify('warn', '/team: use -n or --parts, not both.');
+        return;
+    }
+    if (intent.error === 'flag') {
+        ctx.notify('warn', `/team: unknown option "${intent.token ?? ''}". Try /team for usage.`);
+        return;
+    }
+    ctx.notify('warn', '/team <brief> - describe the work; add -n <count> to fix the fan-out.');
+}
+/**
+ * `/team off`: disarm the session, and say plainly that the CAPABILITY was not
+ * touched.
+ *
+ * THE SECOND HALF OF THE SENTENCE IS THE POINT (D-2 / D-11): with the switch
+ * moved to settings, "off" can only ever mean "this conversation stops being
+ * forced". A user who reads it as "team mode is now disabled everywhere" would
+ * next find `/team` still working tomorrow, and no test would describe that as a
+ * defect because no single surface would be wrong.
+ */
+function leaveForcedMode(ctx) {
+    if (!ctx.controller.getForcedTeam()) {
+        // IDEMPOTENT, and it says so rather than reporting a change it did not make.
+        ctx.notify('info', 'Forced team mode was not on.');
+        return;
+    }
+    ctx.controller.disarmForcedTeam();
+    ctx.notify('info', 'Forced team mode off. Team capability unchanged (Settings > Team).');
+}
+/** `/team on`: arm with the default count and stop there - no turn is submitted. */
+function enterForcedMode(ctx) {
+    if (!passGuards(ctx, ctx.controller.getTeamConfig()))
+        return;
+    const adopted = ctx.controller.armForcedTeam(DEFAULT_FORCED_COUNT);
+    ctx.notify('info', `Forced team mode on: ${adopted} subagents per turn. `
+        + 'Your next message dispatches.');
+}
+/** `/team [-n n|--parts a,b] [--read-only] <brief>`: arm and submit in one act. */
+function armAndSubmit(ctx, intent) {
+    const team = ctx.controller.getTeamConfig();
+    if (!passGuards(ctx, team))
+        return;
+    const planned = planForced(intent.args, team);
+    // ARMED BEFORE THE TURN IS SUBMITTED, and with the SAME narrowed number the
+    // directive names: the later turns reuse this count, so the first turn and the
+    // rest of the session cannot disagree about how wide the fan-out is (D-7).
+    ctx.controller.armForcedTeam(planned.count);
+    ctx.notify('info', planNotice(planned, team));
+    const directive = buildForcedDirective({
+        brief: planned.brief,
+        count: planned.count,
+        readOnly: planned.readOnly,
+        parts: planned.parts,
+        maxSubagents: team.maxSubagents,
+        clamped: planned.requested > planned.count,
+        requested: planned.requested,
+        planMode: ctx.controller.getAgentMode() === 'plan',
+    });
+    // `userInitiated: false`: a directive the user did not type belongs in neither
+    // the prompt history nor the hint-fade counter (todo-plan-followthrough C-12).
+    ctx.submit(directive, { userInitiated: false });
+}
+/** The command body; `registerTeamCommand` is the only registration site. */
+export function runTeamCommand(ctx) {
+    const intent = readTeamIntent(ctx.args);
+    if (intent.kind === 'status') {
+        reportStatus(ctx);
+        return;
+    }
+    if (intent.kind === 'off') {
+        leaveForcedMode(ctx);
+        return;
+    }
+    if (intent.kind === 'on') {
+        enterForcedMode(ctx);
+        return;
+    }
+    if (intent.kind === 'error') {
+        // PARSED BEFORE THE CAPABILITY GUARDS, unlike `on` / `<brief>`. A syntax hint
+        // is the answer to a syntax mistake in ANY session: sending a `--no-team` user
+        // to fix their flags first would send them to repair the one thing that is
+        // not broken.
+        reportParseError(ctx, intent);
+        return;
+    }
+    armAndSubmit(ctx, intent);
+}
+/** Registered from `builtins.ts` with one line, next to every other subsystem. */
+export function registerTeamCommand(registry) {
+    registry.register({
+        name: 'team',
+        description: 'Force team mode and start now: /team <brief>; /team [on|off|status]',
+        run: (ctx) => { runTeamCommand(ctx); },
+    });
+}

package/dist/config/model-kits.d.ts

@@ -70,7 +70,8 @@ export declare const KIT_LIMITS: {
  * exactly as it is for `team.modelProfileId` (`schema.ts` clampTeamConfig):
  * `createModelProfileState` blanks the whole settings page when validation
  * fails, so promoting "a hand-edited file left one dangling id" into "the page
- * and `/team model` are both dead" is a wildly disproportionate blast radius.
+ * and the `Subagent model` row are both dead" is a wildly disproportionate blast
+ * radius.
  *
  * `duplicate_name` is deliberately NOT a code: two kits may share a name
  * (§6.6), and `/kit use` disambiguates with an `#id` prefix.

package/dist/config/store.js

@@ -273,8 +273,9 @@ export function mergePersistedConfig(current, patch) {
         // replace the whole section and quietly revert `maxFiles`, `previewChars`
         // and — worst of all — `redactSecrets`.
         log: clampLogConfig({ ...current.log, ...(patch.log ?? {}) }),
-        // The fourth section, and it needs the merge for the same reason: `/team max
-        // 4` sends `{ team: { maxSubagents: 4 } }`, which a shallow spread would
+        // The fourth section, and it needs the merge for the same reason: the settings
+        // `Max subagents` row sends `{ team: { maxSubagents: 4 } }`, which a shallow
+        // spread would
         // turn into "changing the fan-out width silently reverted every timeout".
         team: clampTeamConfig({ ...current.team, ...(patch.team ?? {}) }),
         // The fifth section, and its omission is the worst of the five (P0-1):