@aragon-agent/cli 0.6.39 → 0.6.42

package/dist/agent/reducer.js

@@ -1134,12 +1134,11 @@ export function viewReducer(state, action) {
         case 'fastTier':
             return { ...state, fast: action.snapshot };
         // --- Context compaction (context-auto-compaction §5.5) ----------------
-        // NOT A TOTAL FUNCTION OVER COMPACTION ATTEMPTS (quiet-noop §3.1). A
-        // `pressure` compaction that declines before calling a model or changing the
-        // history dispatches NOTHING - no `compactionStart`, no `compactionEnd`, no
-        // entry - exactly as a checkpoint below the threshold dispatches nothing.
-        // Counting cards here counts compactions that RAN, never checkpoints that
-        // fired; `/compact status` and the diagnostic log are where the attempts are.
+        // THE TRANSCRIPT NOW CARRIES ONE CARD PER ATTEMPT (context-compaction-never-
+        // fires C). Before this change a declined `pressure` checkpoint dispatched
+        // NOTHING, which is what made "95 % and nothing happens" unreportable: the
+        // feature was trying, failing and saying nothing. The flood the old rule
+        // feared is bounded by `maxPerRun` / `stuckLimit` in `compaction/limits.ts`.
         case 'compactionStart': {
             const { id, seq } = nextId(state);
             let entries = state.entries;
@@ -1189,6 +1188,7 @@ export function viewReducer(state, action) {
                 tokensAfter: 0,
                 model: action.model,
                 startedAt: Date.now(),
+                phase: 'planning',
                 live: true,
             };
             return {
@@ -1217,6 +1217,16 @@ export function viewReducer(state, action) {
                     ...(record.tailRelief ? { tailRelief: record.tailRelief } : {}),
                     ...(record.decision ? { decision: record.decision } : {}),
                     ...(record.memoryVersion ? { memoryVersion: record.memoryVersion } : {}),
+                    ...(record.keepRelaxed ? { keepRelaxed: record.keepRelaxed } : {}),
+                    ...(record.retainedTurns !== undefined
+                        ? { retainedTurns: record.retainedTurns } : {}),
+                    ...(record.retainedMessages !== undefined
+                        ? { retainedMessages: record.retainedMessages } : {}),
+                    ...(record.retainedMessages !== undefined
+                        ? { retainedMessages: record.retainedMessages } : {}),
+                    ...(record.keepRecentTurnsUsed !== undefined
+                        ? { keepRecentTurnsUsed: record.keepRecentTurnsUsed } : {}),
+                    ...(record.elidedMessages ? { elidedMessages: record.elidedMessages } : {}),
                     model: record.model,
                     durationMs: record.durationMs,
                     // SETTLED. `Transcript`'s boundary is monotonic, so a card that
@@ -1253,12 +1263,30 @@ export function viewReducer(state, action) {
                 ...(record.tailRelief ? { tailRelief: record.tailRelief } : {}),
                 ...(record.decision ? { decision: record.decision } : {}),
                 ...(record.memoryVersion ? { memoryVersion: record.memoryVersion } : {}),
+                ...(record.keepRelaxed ? { keepRelaxed: record.keepRelaxed } : {}),
+                ...(record.retainedTurns !== undefined ? { retainedTurns: record.retainedTurns } : {}),
+                ...(record.keepRecentTurnsUsed !== undefined
+                    ? { keepRecentTurnsUsed: record.keepRecentTurnsUsed } : {}),
+                ...(record.elidedMessages ? { elidedMessages: record.elidedMessages } : {}),
                 model: record.model,
                 durationMs: record.durationMs,
                 live: false,
             };
             return { ...state, seq, ...appendEntry(state, state.entries, entry) };
         }
+        case 'compactionPhase': {
+            // THE LIVE CARD'S STAGE, AND NOTHING ELSE. It must not open a card (a phase
+            // can arrive for an entry that a fast settle already closed) and must not
+            // resurrect a settled one: `live` is left untouched, so a late phase on a
+            // settled card changes nothing the renderer shows.
+            if (!state.compactionEntryId)
+                return state;
+            const phase = action.phase;
+            return {
+                ...state,
+                entries: mapEntry(state.entries, state.compactionEntryId, (e) => e.kind === 'compaction' && e.live ? { ...e, phase } : e),
+            };
+        }
         case 'compactionUsage':
             // `usageTotal` AND NOTHING ELSE, exactly as `teamUsage` and `fastUsage`. In
             // particular NOT `context`: that gauge shows the LEAD's context

package/dist/agent/skill-triage-prompt.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The `<skill_triage>` system-prompt block (skill-triage-and-unbounded-ask §4.2.3).
+ *
+ * WHY A PROTOCOL BLOCK AT ALL. The capability this feature fixes already existed:
+ * the Level 1 catalog is in every prompt, `skill(name)` loads a body, and
+ * `README.md` has claimed since the Skills feature landed that "the model decides
+ * on its own whether a task matches a skill". What was missing is any instruction
+ * that the decision has to HAPPEN, before the work rather than after it. The
+ * catalog's own opening paragraph is a STATEMENT ("if a task matches one, call the
+ * skill tool"), not a step in an order of operations, and a statement the model
+ * has read forty times is the one it skims.
+ *
+ * WHY IT IS THIS SHORT. The protocol is paid for on EVERY LLM request: the system
+ * prompt is re-sent each time and nothing in this repository uses provider-side
+ * prefix caching. An earlier draft carried a 1.9 KB version whose second half
+ * repeated the disclosure ladder that `<available_skills>` already states three
+ * lines above it. Repeating a rule is not emphasis, it is noise — and noise about
+ * a rule teaches the model that these blocks are skimmable. Measured size of the
+ * block below is 1273 bytes; `skill-triage-prompt.test.ts` asserts the ceiling of
+ * 1500 so an edit has 227 bytes of room, not unlimited scope.
+ *
+ * ASCII ONLY — `agent/` is inside the glyph scanner's scope.
+ */
+import type { SkillCandidate } from '../skills/triage.js';
+/** Bump when the wording changes, so a transcript can be dated. */
+export declare const SKILL_TRIAGE_BLOCK_VERSION = "v1-2026-10-26";
+export interface SkillTriageBlockOptions {
+    /** This turn's candidates, best first. Empty is normal and renders no data block. */
+    candidates: SkillCandidate[];
+}
+/**
+ * Protocol first, candidates second — in that order, always.
+ *
+ * The order is the meaning: the protocol says what to do, the data block says with
+ * what. Reversing them would put a list of suggestions above the rules for reading
+ * it, which is how a suggestion turns into an instruction.
+ */
+export declare function buildSkillTriageBlock(options: SkillTriageBlockOptions): string;
+/** Byte size of the protocol half, for the budget assertion in the tests. */
+export declare function skillTriageProtocolBytes(): number;
+/** The ceiling the protocol half must stay under, in bytes. */
+export declare const SKILL_TRIAGE_PROTOCOL_MAX_BYTES: number;

package/dist/agent/skill-triage-prompt.js

@@ -0,0 +1,74 @@
+/**
+ * The `<skill_triage>` system-prompt block (skill-triage-and-unbounded-ask §4.2.3).
+ *
+ * WHY A PROTOCOL BLOCK AT ALL. The capability this feature fixes already existed:
+ * the Level 1 catalog is in every prompt, `skill(name)` loads a body, and
+ * `README.md` has claimed since the Skills feature landed that "the model decides
+ * on its own whether a task matches a skill". What was missing is any instruction
+ * that the decision has to HAPPEN, before the work rather than after it. The
+ * catalog's own opening paragraph is a STATEMENT ("if a task matches one, call the
+ * skill tool"), not a step in an order of operations, and a statement the model
+ * has read forty times is the one it skims.
+ *
+ * WHY IT IS THIS SHORT. The protocol is paid for on EVERY LLM request: the system
+ * prompt is re-sent each time and nothing in this repository uses provider-side
+ * prefix caching. An earlier draft carried a 1.9 KB version whose second half
+ * repeated the disclosure ladder that `<available_skills>` already states three
+ * lines above it. Repeating a rule is not emphasis, it is noise — and noise about
+ * a rule teaches the model that these blocks are skimmable. Measured size of the
+ * block below is 1273 bytes; `skill-triage-prompt.test.ts` asserts the ceiling of
+ * 1500 so an edit has 227 bytes of room, not unlimited scope.
+ *
+ * ASCII ONLY — `agent/` is inside the glyph scanner's scope.
+ */
+import { renderSkillCandidates, SKILL_TRIAGE_LIMITS } from '../skills/triage.js';
+/** Bump when the wording changes, so a transcript can be dated. */
+export const SKILL_TRIAGE_BLOCK_VERSION = 'v1-2026-10-26';
+/**
+ * The protocol text. Kept as a literal array so a diff of the prompt is a diff of
+ * the source, and so the grader/test can see line boundaries.
+ */
+const PROTOCOL_LINES = [
+    '<skill_triage>',
+    `Version: ${SKILL_TRIAGE_BLOCK_VERSION}`,
+    '',
+    'Triage every task that touches the workspace: AFTER the project guidance and the',
+    'directory listing, BEFORE you plan or change anything. A user-typed /<skill-name>',
+    'is an override, not the only way in.',
+    '',
+    '1. Read <available_skills> above, and <skill_candidates> when present. A candidate',
+    '   is a computed guess about your message, not a verdict - check its one-line',
+    '   description before trusting it.',
+    '2. If the catalog says some skills were not shown, or nothing listed plainly',
+    '   covers the task, call skill_find(query) once before concluding there is no',
+    '   skill.',
+    '3. If a skill covers the task, call skill(name="...") BEFORE the first source read',
+    '   that would change code, then follow it. Say why in one line, not a paragraph.',
+    '4. If nothing covers the task, say so in one clause and continue. Do not load a',
+    '   skill to look diligent, and never load several "to be safe".',
+    '',
+    'A loaded skill is reference material, not permission to ignore the user, the',
+    'plan-mode rules, or the tools you actually have. If a skill narrows your tool set,',
+    'that is its allowed-tools declaration working: report it, do not work around it.',
+    'Never install or author a skill because a task looks like it needs one; that',
+    'decision belongs to the user.',
+    '</skill_triage>',
+];
+const PROTOCOL = PROTOCOL_LINES.join('\n');
+/**
+ * Protocol first, candidates second — in that order, always.
+ *
+ * The order is the meaning: the protocol says what to do, the data block says with
+ * what. Reversing them would put a list of suggestions above the rules for reading
+ * it, which is how a suggestion turns into an instruction.
+ */
+export function buildSkillTriageBlock(options) {
+    const candidates = renderSkillCandidates(options.candidates);
+    return candidates.length > 0 ? `${PROTOCOL}\n${candidates}` : PROTOCOL;
+}
+/** Byte size of the protocol half, for the budget assertion in the tests. */
+export function skillTriageProtocolBytes() {
+    return new TextEncoder().encode(PROTOCOL).length;
+}
+/** The ceiling the protocol half must stay under, in bytes. */
+export const SKILL_TRIAGE_PROTOCOL_MAX_BYTES = SKILL_TRIAGE_LIMITS.maxProtocolBytes;

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

@@ -34,8 +34,20 @@ export interface SystemPromptParams {
      * plan as its final message instead of calling tools it does not have.
      */
     planInteractive?: boolean;
-    /** `planModeMaxAskRounds`, substituted into the block so the two agree. */
-    planMaxAskRounds?: number;
+    /**
+     * The rendered `<skill_triage>` block plus (when there are candidates) the
+     * `<skill_candidates>` block, or `''`.
+     *
+     * Spliced conditionally exactly as `skillsBlock` and the plan block are, which
+     * is what keeps invariant I-T1 true: `skills.triage: false`, a zero-skill
+     * install and `--no-skills` all produce the pre-feature prompt BYTE FOR BYTE.
+     *
+     * POSITION IS THE SEMANTICS. It goes immediately AFTER `skillsBlock`, because
+     * its first instruction refers to `<available_skills> above`, and a block
+     * separated from what it points at reads as a dangling reference. It also goes
+     * BEFORE the plan block, whose first step defers to it.
+     */
+    skillTriageBlock?: string;
     /**
      * The rendered `<team_mode>` block for a LEAD with team mode on, or `''`.
      *
@@ -44,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

@@ -33,12 +33,13 @@ export function buildSystemPrompt(params) {
     const skillsBlock = params.skillsBlock ?? '';
     const hasSkills = skillsBlock.length > 0;
     const planBlock = params.agentMode === 'plan'
-        ? buildPlanModeBlock({
-            interactive: params.planInteractive !== false,
-            maxAskRounds: params.planMaxAskRounds ?? 4,
-        })
+        ? buildPlanModeBlock({ interactive: params.planInteractive !== false })
         : '';
+    // `''` when the caller has no candidates or the feature is off — which is what
+    // 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 ?? '';
@@ -61,8 +62,15 @@ export function buildSystemPrompt(params) {
         '',
         buildProjectGuidanceBlock(),
         ...(hasSkills ? ['', skillsBlock] : []),
+        // AFTER <available_skills> (it refers to it as "above") and BEFORE <plan_mode>
+        // (whose step 1 defers to it). Conditional like every other optional block.
+        ...(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/cli.js

@@ -29,7 +29,7 @@ import { COMPACTION_CONFIG_SET_KEYS, FAST_CONFIG_SET_KEYS, LOG_CONFIG_SET_KEYS,
 import { attachAgentEvents, attachTeamEvents, installLogging, setScreenRestore, setSignalTerminator, } from './logging/install.js';
 import { getLogger } from './logging/logger.js';
 import { runLogsCommand } from './logging/cli-commands.js';
-import { ADAPTER_PROVIDERS, clampDensity, clampTheme, clampThinkingLevel, clampAskRounds, clampHumanTimeout, clampSkillsIntegrity, clampSkillsToolPolicy, clampContextWindow, clampMaxRenderInterval, clampScrollMode, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAdapterProvider, isAutoToken, parseMaxTokensInput, DEFAULT_MAX_RENDER_INTERVAL_MS, DEFAULT_MAX_TOKENS, DEFAULT_PLAN_HUMAN_TIMEOUT_MS, DEFAULT_PLAN_MAX_ASK_ROUNDS, DEFAULT_SCROLL_MODE, DEFAULT_SCROLL_RESUME_MS, DEFAULT_SKILLS_CONFIG, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from './config/schema.js';
+import { ADAPTER_PROVIDERS, clampDensity, clampTheme, clampThinkingLevel, clampHumanTimeout, clampSkillsIntegrity, clampSkillsToolPolicy, clampContextWindow, clampMaxRenderInterval, clampScrollMode, clampScrollResumeMs, clampTranscriptRetain, clampTranscriptWindow, coercePositiveInt, isAdapterProvider, isAutoToken, parseMaxTokensInput, RETIRED_CONFIG_KEYS, DEFAULT_MAX_RENDER_INTERVAL_MS, DEFAULT_MAX_TOKENS, DEFAULT_PLAN_HUMAN_TIMEOUT_MS, DEFAULT_SCROLL_MODE, DEFAULT_SCROLL_RESUME_MS, DEFAULT_SKILLS_CONFIG, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from './config/schema.js';
 import { makeGetApiKey } from './config/load.js';
 import { AgentController, DENY_ALL_APPROVAL } from './agent/controller.js';
 import { runSkillsCommand } from './skills/cli-commands.js';
@@ -1559,7 +1559,6 @@ const CONFIG_SET_KEYS = new Set([
     'scrollResumeMs',
     'historyEnabled',
     'planModeDefault',
-    'planModeMaxAskRounds',
     'planModeHumanTimeoutMs',
     // Dotted keys route into the nested `skills` object; see the switch below.
     'skills.enabled',
@@ -1569,6 +1568,7 @@ const CONFIG_SET_KEYS = new Set([
     'skills.integrity',
     'skills.usageTracking',
     'skills.toolPolicy',
+    'skills.triage',
     // `log.*` keys are handled by `applyLogConfigSet` below, NOT by the switch:
     // that switch is already past this package's complexity ceiling.
     ...LOG_CONFIG_SET_KEYS,
@@ -1660,6 +1660,18 @@ function runConfigSet(key, value) {
     }
 }
 function runConfigSetValue(key, value) {
+    // RETIRED KEYS ARE REFUSED BY NAME, BEFORE THE UNKNOWN-KEY CHECK. Falling
+    // through to `Unknown config key` would be technically true and practically
+    // useless: a script that has run `config set planModeMaxAskRounds 5` for months
+    // needs to be told what happened to it, not that it never existed. Exit 2 for
+    // the same reason a bad value is 2 — the caller's argument is wrong, the file
+    // is not.
+    const retired = RETIRED_CONFIG_KEYS[key];
+    if (retired !== undefined) {
+        process.stderr.write(`"${key}" was removed: ${retired}\n`);
+        process.exitCode = 2;
+        return;
+    }
     if (!CONFIG_SET_KEYS.has(key)) {
         process.stderr.write(`Unknown config key "${key}". Known keys: ${[...CONFIG_SET_KEYS].join(', ')}.\n`);
         process.exitCode = 2;
@@ -1852,9 +1864,6 @@ function runConfigSetValue(key, value) {
         case 'planModeDefault':
             patch.planModeDefault = value === 'true' || value === '1';
             break;
-        case 'planModeMaxAskRounds':
-            patch.planModeMaxAskRounds = clampAskRounds(value, DEFAULT_PLAN_MAX_ASK_ROUNDS);
-            break;
         case 'planModeHumanTimeoutMs':
             patch.planModeHumanTimeoutMs = clampHumanTimeout(value, DEFAULT_PLAN_HUMAN_TIMEOUT_MS);
             break;
@@ -1893,6 +1902,13 @@ function runConfigSetValue(key, value) {
                 toolPolicy: clampSkillsToolPolicy(value, DEFAULT_SKILLS_CONFIG.toolPolicy),
             };
             break;
+        // The triage master switch. `false` restores the pre-feature prompt BYTE FOR
+        // BYTE (invariant I-T1), which is the reason it is a key rather than a flag.
+        case 'skills.triage':
+            patch.skills = {
+                triage: value === 'true' || value === '1',
+            };
+            break;
     }
     updatePersistedConfig(patch);
     process.stdout.write(`Set ${key} = ${value}\n`);

package/dist/commands/builtins.js

@@ -21,12 +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
@@ -107,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;
 /**
@@ -412,8 +355,10 @@ const COMMANDS = [
             if (arg === 'status') {
                 const s = ctx.controller.getPlanStatus();
                 const pending = s.pending ? ` (pending ${MODE_LABEL[s.pending]} after this run)` : '';
-                ctx.notify('info', `Mode: ${MODE_LABEL[s.effective]}${pending}. ` +
-                    `Ask rounds used: ${s.askRoundsUsed}/${s.maxAskRounds}.`);
+                // NO ROUND COUNT. The old line ended with `Ask rounds used: 3/4.`, which
+                // told the user their agent was rationing questions - a limit that no
+                // longer exists. Nothing replaced it: "0 of unlimited" is noise.
+                ctx.notify('info', `Mode: ${MODE_LABEL[s.effective]}${pending}.`);
                 return;
             }
             if (arg.length > 0 && arg !== 'on' && arg !== 'off') {
@@ -425,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 | ' +
@@ -1508,6 +1333,19 @@ export function registerBuiltinCommands(registry) {
     // The read-only subagent board (tui-subagent-panel §6.4). Same shape again: the
     // body is `commands/agents-command.ts` and the registration is this one line.
     registerAgentsCommand(registry);
+    // `/subagent` (subagent-fanout 3.5). REGISTERED UNCONDITIONALLY, like `/prompts`
+    // 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.
@@ -1522,7 +1360,12 @@ export function registerBuiltinCommands(registry) {
  * `registry.get(name)` instead, because that is the only check that stays
  * correct when commands are registered dynamically (§7.1 / P1-2).
  */
-export const BUILTIN_COMMAND_NAMES = ['queue', 'prompts', 'agents', 'keys', 'task',
+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,
         ...(c.aliases ?? []),