@aragon-agent/cli 0.6.39 → 0.6.42

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';
@@ -45,12 +48,14 @@ import { TodoStore } from '../todo/store.js';
 import { createTodoTool } from '../todo/todo-tool.js';
 import { buildTodoBlock } from '../todo/prompt.js';
 import { createPlanTools } from '../tools/plan-tools.js';
-import { DENY_ALL_HUMAN_INPUT } from '../tools/human-input.js';
+import { ASK_GUARD_LIMITS, DENY_ALL_HUMAN_INPUT, questionFingerprint, } from '../tools/human-input.js';
 import { getLogger } from '../logging/logger.js';
 import { createNodeSkillHost } from '../skills/node-host.js';
 import { SkillService } from '../skills/service.js';
 import { createSkillTools } from '../skills/tools.js';
+import { SKILL_TRIAGE_LIMITS } from '../skills/triage.js';
 import { buildSystemPrompt } from './system-prompt.js';
+import { buildSkillTriageBlock } from './skill-triage-prompt.js';
 import { resetConversationWith, } from './conversation-reset.js';
 import { archiveClearedConversation, } from '../session/clear-archive.js';
 /**
@@ -92,6 +97,28 @@ export class AgentController {
     skills;
     skillsEnabled;
     onSkillsChanged;
+    // -----------------------------------------------------------------------
+    // Skill triage (skill-triage-and-unbounded-ask §4.2.5) — PER-TURN state.
+    //
+    // Every field here is written in `prepareUserTurn` and cleared on `agent_end`,
+    // because a stale candidate set in the prompt is worse than no candidate set:
+    // it points the model at a skill chosen for a task it is no longer doing.
+    // -----------------------------------------------------------------------
+    /**
+     * This turn's routing result, or `null` when triage is off or nothing scored.
+     *
+     * It also carries the task it was computed for (`SkillRoutingReport.task`), so
+     * there is no separate copy of the turn's text to keep in step with it.
+     */
+    turnRouting = null;
+    /** The previous turn's routing, for `/skills route` with no argument. */
+    lastSkillRouting = null;
+    /** Did this turn call `skill(name)` successfully? The only proof of adoption. */
+    skillLoadedThisTurn = false;
+    /** Tool calls this turn, EXCLUDING `skill` / `skill_find` (see §4.2.7). */
+    toolCallsThisTurn = 0;
+    /** Skills already reported as "not loaded" — a session says it once (I-T5). */
+    skillTriageNoticed = new Set();
     /** Mutable session cwd — tools resolve relative paths against this. */
     cwd;
     /**
@@ -124,7 +151,20 @@ export class AgentController {
     // -----------------------------------------------------------------------
     effectiveMode;
     pendingMode = null;
-    askRounds = 0;
+    /**
+     * Fingerprints of the question SETS the user ANSWERED in this turn. Bounded,
+     * and the bound is storage hygiene rather than a refusal rule — see
+     * `ASK_GUARD_LIMITS`.
+     *
+     * Replaces a numeric round counter that capped `ask_user` at four calls. There
+     * is no cap now; the only thing this prevents is the same batch of questions
+     * being put to the user twice, which is noise rather than information.
+     *
+     * Cleared in `prepareUserTurn` for a NEW turn only. A steer continuation is the
+     * same turn — clearing there would disable the guard exactly when a long turn
+     * most needs it (§4.1.6).
+     */
+    askedFingerprints = new Set();
     /** Static: whether this session could ever render a question overlay. */
     planInteractive;
     // -----------------------------------------------------------------------
@@ -135,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.
     //
@@ -389,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,
@@ -491,7 +547,12 @@ export class AgentController {
         this.jobsRegistered = config.jobs.enabled && config.bash.background;
         this.jobMirror =
             this.jobsRegistered && config.jobs.persistLog
-                ? new JobLogMirror({ root: () => join(getHomeRoot(), 'jobs', this.jobSessionTag) })
+                ? new JobLogMirror({
+                    root: () => join(getHomeRoot(), 'jobs', this.jobSessionTag),
+                    // NAMED, NOT DERIVED. The mirror sweeps only this directory; the session
+                    // tagging above is what keeps its own run out of the sweep's reach.
+                    jobsRoot: () => join(getHomeRoot(), 'jobs'),
+                })
                 : undefined;
         this.procs = new ProcSupervisor({
             readyTimeoutMs: () => this.config.bash.readyTimeoutMs,
@@ -585,7 +646,13 @@ export class AgentController {
             // (or 11 with skills) it is today.
             planTools: createPlanTools({
                 gate: humanInput,
-                takeAskRound: () => this.takeAskRound(),
+                // TWO CALLBACKS, AND THE SPLIT IS LOAD-BEARING (§4.1.2). One
+                // read-and-write accessor could only be called before the question
+                // (recording an answer nobody gave, which makes "a cancelled round stays
+                // askable" impossible) or after it (which cannot stop a repeat). The guard
+                // is "read before, write only after a real answer".
+                hasAnsweredQuestions: (questions) => this.hasAnswered(questions),
+                noteAnsweredQuestions: (questions) => this.noteAnswered(questions),
                 withHumanWait: (fn) => this.withHumanWait(fn),
                 onPlanApproved: () => this.setAgentMode('build', { force: true }),
             }),
@@ -663,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,
@@ -909,6 +979,17 @@ export class AgentController {
                 this.activeToolCalls += 1;
             if (event.type === 'tool_execution_end') {
                 this.activeToolCalls = Math.max(0, this.activeToolCalls - 1);
+                // The ONLY proof a skill was adopted is a successful `skill` call. Reading
+                // the model's prose for a skill name would be a heuristic; this is a fact
+                // the executor already reports.
+                if (event.toolName === 'skill' && event.isError !== true)
+                    this.skillLoadedThisTurn = true;
+                // `skill` / `skill_find` do not count as "work done": the notice below is
+                // for a turn that changed something without reading its skill, and a turn
+                // that ONLY searched for a skill is a turn that already tried.
+                if (event.toolName !== 'skill' && event.toolName !== 'skill_find') {
+                    this.toolCallsThisTurn += 1;
+                }
                 // THE ONE PUSH SITE. A notice that could not be pushed here is picked up
                 // by the next tool result (the pull channel) or by the next user turn
                 // (the fill channel), so nothing is lost by declining.
@@ -925,6 +1006,9 @@ export class AgentController {
                 // required: `turn_start` covers the next turn of the same run, and this
                 // covers a run that ended with a notice stranded in the queue.
                 this.jobRelay?.requeueUndelivered();
+                // AFTER the requeue, so a turn that ends with a stranded notice still gets
+                // its feedback line. Order between the two is otherwise irrelevant.
+                this.maybeReportSkillTriage();
             }
         });
         if (this.fast) {
@@ -973,23 +1057,52 @@ export class AgentController {
         const tier = resolveFastTier(config, (id, role) => !!makeGetApiKey(config, role)(id));
         const fastAvailable = config === this.config ? this.fast?.available() === true
             : this.fast?.isRegistered() && config.fast.enabled && tier.ok;
+        const skillsCatalog = this.skillsEnabled ? this.skills.catalogBlock() : '';
+        // READ LIVE FROM THE SERVICE, never `config.skills` (§4.2.5 / R-12).
+        // `SkillService.updateConfig` replaces the SERVICE's own config object, so
+        // `this.config.skills` goes stale the moment `/skills triage off` runs — and a
+        // stale read would leave the block in the prompt until the next launch, which
+        // looks exactly like a broken switch. Same discipline as `/todo off`.
+        const triageOn = this.skillsEnabled && this.skills.getConfig().triage === true;
+        // An empty catalog means there is nothing to triage against, so the block is
+        // absent rather than present-and-useless (I-T1 / AC-T18).
+        const triageBlock = triageOn && skillsCatalog.length > 0
+            ? buildSkillTriageBlock({ candidates: this.turnRouting?.candidates ?? [] })
+            : '';
         return buildSystemPrompt({
             cwd: this.cwd,
             tools: this.tools,
-            skillsBlock: this.skillsEnabled ? this.skills.catalogBlock() + this.skills.alwaysBlock() : '',
+            skillsBlock: this.skillsEnabled ? skillsCatalog + this.skills.alwaysBlock() : '',
+            // Immediately after the catalog it refers to, before the plan block whose
+            // first step defers to it (§4.2.4).
+            skillTriageBlock: triageBlock,
             agentMode: this.effectiveMode,
             planInteractive: this.planInteractive,
-            planMaxAskRounds: config.planModeMaxAskRounds,
-            // 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
@@ -1183,7 +1296,7 @@ export class AgentController {
     }
     /** Prepare before clearing the plan, then enter the engine without yielding. */
     async startPrompt(text, options, request) {
-        this.prepareUserTurn(text);
+        this.prepareUserTurn(text, { steering: false });
         if (request !== this.startupSequence) {
             return { status: 'not-started', reason: 'cancelled' };
         }
@@ -1212,10 +1325,39 @@ export class AgentController {
         // failure AC-25 exists to prevent.
         this.jobRelay?.flushForTurn();
     }
-    prepareUserTurn(text) {
+    /**
+     * THE BOUNDARY OF ONE TURN — and there are TWO call sites, which is the reason
+     * this takes an explicit flag instead of resetting everything unconditionally.
+     *
+     * `startPrompt` passes `{ steering: false }`: the user typed something new, so
+     * this really is a new turn. `continue()` passes `{ steering: true }` with the
+     * CONCATENATED queued steering text, which resumes the SAME turn.
+     *
+     * A steer continuation must not re-triage (the candidates would change mid-turn,
+     * and rebuilding the prompt aborts an idle compaction for no gain) and must not
+     * clear the answered-question guard (a long turn interrupted by one steer is
+     * exactly when a repeat question is most likely). Hence per-turn state is
+     * initialised in ONE branch.
+     *
+     * `steering` is REQUIRED and positional-second so each call site states which
+     * kind of turn it is starting, rather than letting a default make "new turn" the
+     * thoughtless option.
+     */
+    prepareUserTurn(text, options) {
         if (this.skillsEnabled)
             this.skills.beginUserTurn();
-        this.askRounds = 0;
+        if (!options.steering) {
+            this.askedFingerprints.clear();
+            this.turnRouting = this.skillsEnabled ? this.skills.triage(text) : null;
+            this.skillLoadedThisTurn = false;
+            this.toolCallsThisTurn = 0;
+            // BEFORE the engine is entered, because `runAgentLoop` captures the system
+            // prompt BY VALUE on its way in — a rebuild after `agent.prompt()` would be
+            // one turn late. This is also why steer does not rebuild: `continue()` runs
+            // while the loop already holds its snapshot, so the cost would be an idle
+            // compaction aborted for a prompt nothing has read yet (§4.2.5).
+            this.rebuildSystemPrompt();
+        }
         this.fast?.setGoal(text);
     }
     /** Cancel pending startup as well as any engine run already in progress. */
@@ -1393,7 +1535,7 @@ export class AgentController {
         }
         if (this.pendingUserSteering.size > 0) {
             const request = ++this.startupSequence;
-            this.prepareUserTurn([...this.pendingUserSteering.values()].join('\n\n'));
+            this.prepareUserTurn([...this.pendingUserSteering.values()].join('\n\n'), { steering: true });
             if (request !== this.startupSequence) {
                 return { status: 'not-started', reason: 'cancelled' };
             }
@@ -1494,18 +1636,90 @@ export class AgentController {
         return {
             effective: this.effectiveMode,
             pending: this.pendingMode,
-            askRoundsUsed: this.askRounds,
-            maxAskRounds: this.config.planModeMaxAskRounds,
         };
     }
-    /** Spend one `ask_user` round. Called from the tool, never from the UI. */
-    takeAskRound() {
-        const max = this.config.planModeMaxAskRounds;
-        if (this.askRounds >= max) {
-            return { ok: false, used: this.askRounds, remaining: 0, max };
+    /**
+     * READ-ONLY guard probe, called by `ask_user` BEFORE it opens the overlay.
+     *
+     * No side effect of any kind: a check that also writes cannot be placed before
+     * the question without recording an answer that has not happened yet, and the
+     * "a cancelled round stays askable" rule would then be unimplementable.
+     */
+    hasAnswered(questions) {
+        return this.askedFingerprints.has(questionFingerprint(questions));
+    }
+    /**
+     * Record an ANSWERED question set, called by `ask_user` after a real answer.
+     *
+     * Evicts the oldest entry past `ASK_GUARD_LIMITS.maxRemembered`. That eviction
+     * is memory hygiene and NOT a refusal rule — a bounded rejection would be the
+     * deleted round cap wearing a bigger number.
+     */
+    noteAnswered(questions) {
+        this.askedFingerprints.add(questionFingerprint(questions));
+        while (this.askedFingerprints.size > ASK_GUARD_LIMITS.maxRemembered) {
+            const oldest = this.askedFingerprints.values().next();
+            if (oldest.done === true)
+                break;
+            this.askedFingerprints.delete(oldest.value);
+        }
+    }
+    /** `/skills route` with no argument: the LAST turn's real routing result. */
+    getSkillRouting() {
+        return this.lastSkillRouting;
+    }
+    /**
+     * One line when a confidently-matched skill was NOT loaded — and silence every
+     * other time (D-8).
+     *
+     * THE DISCIPLINE IS "SILENT ON SUCCESS, VISIBLE ON FAILURE". Announcing the
+     * candidates every turn would be ignored by the third day; announcing nothing
+     * ever would make the whole feature unfalsifiable. "A skill covered this task,
+     * you did the work anyway, and you never opened it" is precisely the failure this
+     * feature exists to fix, so it is the one case that speaks — and it names the
+     * command that explains it.
+     *
+     * SEVEN CONDITIONS, and the first one is the one that is easy to get wrong.
+     *
+     * 0. This turn was NOT aborted and NOT ended by an error.
+     *    `agent_end` is emitted unconditionally from a `finally` block in
+     *    `core/src/engine/agent.ts` and its payload carries no reason, no `aborted`
+     *    and no `error` field — so "did this turn finish normally?" has to be read
+     *    from this class's own state. `stopEngine()` sets `abortRequested` before it
+     *    calls `agent.abort()` and `agent_start` clears it, which makes it an exact
+     *    answer. Without this condition an Esc mis-touch would produce a line
+     *    criticising the model for not loading a skill: commentary in response to an
+     *    interruption.
+     *
+     * Conditions 5 and 0 are not redundant: 0 decides what counts as the end of a
+     * turn, 5 decides whether the turn did any work. With only 5, a tool call made
+     * before an abort would still trigger the notice.
+     */
+    maybeReportSkillTriage() {
+        const routing = this.turnRouting;
+        const best = routing?.candidates[0];
+        const shouldReport = this.abortRequested === false &&
+            this.skillsEnabled &&
+            this.skills.getConfig().triage === true &&
+            routing !== null &&
+            best !== undefined &&
+            best.score >= SKILL_TRIAGE_LIMITS.confidentScore &&
+            this.skillLoadedThisTurn === false &&
+            this.toolCallsThisTurn >= 1 &&
+            !this.skillTriageNoticed.has(best.name);
+        if (shouldReport && best !== undefined) {
+            this.skillTriageNoticed.add(best.name);
+            this.notifyHostFn?.('info', `No skill was loaded; the closest installed match was "${best.name}". ` +
+                'Run /skills route to see why.');
         }
-        this.askRounds += 1;
-        return { ok: true, used: this.askRounds, remaining: max - this.askRounds, max };
+        // The routing result outlives the turn so `/skills route` can explain it; the
+        // candidates themselves must not, or the next `rebuildSystemPrompt()` would
+        // resurrect a set computed for a task that is over.
+        if (routing !== null)
+            this.lastSkillRouting = routing;
+        this.turnRouting = null;
+        this.skillLoadedThisTurn = false;
+        this.toolCallsThisTurn = 0;
     }
     /**
      * Run `fn` with the idle watchdog paused.
@@ -1546,22 +1760,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;
@@ -1584,8 +1843,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));
@@ -1670,7 +1929,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/model-profile-settings.js

@@ -97,8 +97,19 @@ export function releasedSlots(draft) {
             || hasConnectionPatch(draft.patch, role))
             released.add(role);
     }
-    if (draft.patch.team !== undefined)
+    // ONLY A MODEL BINDING DECISION RELEASES THE SLOT (subagent-fanout D-7). The
+    // fan-out width and the supervisor live in the SAME `team` section but are not
+    // the kit's business: `{ maxSubagents: 6 }` used to hit the old
+    // `patch.team !== undefined` test, so narrowing the fan-out from the settings
+    // screen silently dropped the subagent model a session kit had installed for
+    // this session - with every value on screen still correct.
+    //
+    // `'model' in patch`, not `patch.model !== undefined`: an explicit
+    // `model: undefined` still means "this transaction spoke about the model".
+    const teamPatch = draft.patch.team;
+    if (teamPatch && ('model' in teamPatch || 'modelProfileId' in teamPatch)) {
         released.add('subagent');
+    }
     return [...released].filter((slot) => held.includes(slot));
 }
 /** The session kit as it stands AFTER this transaction's explicit decisions. */

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

@@ -8,11 +8,9 @@
  * ASCII ONLY — `agent/` is inside the glyph scanner's scope.
  */
 /** Bump when the wording changes, so a transcript can be dated. */
-export declare const PLAN_MODE_BLOCK_VERSION = "v2-2026-10-08";
+export declare const PLAN_MODE_BLOCK_VERSION = "v3-2026-10-26";
 export interface PlanModeBlockOptions {
     /** False under `-p` / piped stdin: no overlay can be rendered, so no tools. */
     interactive: boolean;
-    /** `planModeMaxAskRounds`; substituted into the guidance so the two agree. */
-    maxAskRounds: number;
 }
 export declare function buildPlanModeBlock(options: PlanModeBlockOptions): string;

package/dist/agent/plan-prompt.js

@@ -8,7 +8,7 @@
  * ASCII ONLY — `agent/` is inside the glyph scanner's scope.
  */
 /** Bump when the wording changes, so a transcript can be dated. */
-export const PLAN_MODE_BLOCK_VERSION = 'v2-2026-10-08';
+export const PLAN_MODE_BLOCK_VERSION = 'v3-2026-10-26';
 /**
  * The closing paragraph of the interactive block.
  *
@@ -42,13 +42,18 @@ const HEADLESS_PARAGRAPH = [
     '  write the finished plan as your final message in markdown.',
 ].join('\n');
 export function buildPlanModeBlock(options) {
-    const { interactive, maxAskRounds } = options;
+    const { interactive } = options;
+    // NO ROUND COUNT APPEARS HERE, and none may be reintroduced: the number used
+    // to be substituted from `planModeMaxAskRounds`, which meant the prompt itself
+    // told the model it would run out. "3-5 questions" was also wrong against a
+    // schema and normalizer that both accept 1-5; correcting it here is one line.
     const askStep = interactive
         ? [
             '2. If a decision would change the work and you cannot settle it by reading, call',
-            '   ask_user with 3-5 multiple-choice questions in ONE call. Mark exactly one',
-            `   option recommended:true and put the reason in its description. You may ask up`,
-            `   to ${maxAskRounds} rounds; each round costs the user time, so make them count.`,
+            '   ask_user with 1-5 multiple-choice questions in ONE call. Mark exactly one option',
+            '   recommended:true and put the reason in its description. There is NO round limit -',
+            '   ask as many rounds as the work needs - but each round costs the user time, so batch',
+            '   the questions and skip anything the workspace already answers.',
         ]
         : [
             '2. If a decision would change the work and you cannot settle it by reading, state',
@@ -76,8 +81,9 @@ export function buildPlanModeBlock(options) {
         '',
         'Work in this order:',
         '1. Follow the project-guidance protocol: read applicable guidance and index navigation',
-        '   before any source search or read. Then inspect the real code with read_file,',
-        '   list_dir, glob, grep and relevant skills. Never plan against unread structure.',
+        '   before any source search or read. Then run the skill triage described above and load',
+        '   any skill that covers this task, BEFORE inspecting the real code with read_file,',
+        '   list_dir, glob and grep. Never plan against unread structure.',
         ...askStep,
         ...submitStep,
         '',

package/dist/agent/reducer.d.ts

@@ -15,7 +15,7 @@ import type { AgentEvent, ModelCost, ToolResult, TokenUsage } from '@aragon-agen
 import type { AgentMode } from './agent-mode.js';
 import type { DispatchOutcome, SubagentRun, SubagentSpec, TeamSnapshot } from '../team/types.js';
 import type { FastReview, FastSnapshot } from '../fast/types.js';
-import type { CompactionMode, CompactionRecord, CompactionSnapshot, CompactionUiTrigger, ContextUsageSnapshot } from '../compaction/types.js';
+import type { CompactionMode, CompactionPhase, CompactionRecord, CompactionSnapshot, CompactionUiTrigger, ContextUsageSnapshot } from '../compaction/types.js';
 import type { AcceptanceSnapshot, TodoItem, TodoSnapshot } from '../todo/types.js';
 import type { JobKind, ServiceSnapshot, ServiceStatus } from '../proc/types.js';
 import type { RetryPhase } from './retry-view.js';
@@ -237,6 +237,22 @@ export type Entry = {
         messages: number;
         charsRemoved: number;
     };
+    /**
+     * The stage the LIVE card is in (context-compaction-never-fires C).
+     *
+     * Absent on a settled card and on every card written before this field
+     * existed, which is why the renderer treats it as optional and falls back to
+     * the old `summarizing with <model>` line.
+     */
+    phase?: CompactionPhase;
+    /** Set when the cut relaxed `keepRecentTurns` to exist at all (B). */
+    keepRelaxed?: boolean;
+    retainedTurns?: number;
+    /** Messages the relaxed cut left verbatim - the number the card states. */
+    retainedMessages?: number;
+    keepRecentTurnsUsed?: number;
+    /** Messages the digest left out, so they cannot be quoted (A1). */
+    elidedMessages?: number;
     live: boolean;
 } | {
     id: string;
@@ -683,6 +699,18 @@ export type ViewAction = {
     type: 'compactionEnd';
     record: CompactionRecord;
 }
+/**
+ * The live card's stage (context-compaction-never-fires C).
+ *
+ * Its own action rather than a field on `compactionStart` because the phases
+ * arrive AFTER it, one per step, and because a phase must be able to land on a
+ * card that a previous attempt already settled into the same entry id.
+ */
+ | {
+    type: 'compactionPhase';
+    index: number;
+    phase: CompactionPhase;
+}
 /**
  * Compaction spend.
  *