@aragon-agent/cli 0.6.23 → 0.6.25

package/dist/commands/builtins.js

@@ -16,9 +16,12 @@ import { buildContinuationMessage } from '../todo/follow-through.js';
 import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
 import { loadSession, resolveSessionPath, saveSession } from '../session/persist.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 { perfCommand } from './perf.js';
 import { runCompactCommand } from '../compaction/command.js';
+import { runClearCommand } from './clear-command.js';
 import { runContextCommand } from '../compaction/context-command.js';
 /**
  * `/fast status` — THE GUARANTEED REPORTING SURFACE for the tier (§4.4 / R-8).
@@ -90,6 +93,66 @@ 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}).`);
+}
 function formatFastStatus(controller) {
     const status = controller.getFastStatus();
     const cfg = controller.getFastConfig();
@@ -254,7 +317,7 @@ const COMMANDS = [
     },
     {
         name: 'team',
-        description: 'Team subagents: status | on | off | max <n> | overseer on|off',
+        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).
@@ -275,6 +338,12 @@ const COMMANDS = [
             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.
@@ -284,6 +353,7 @@ const COMMANDS = [
             }
             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()
@@ -293,9 +363,20 @@ const COMMANDS = [
                 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)'}.${roster}`);
+                    `${cfg.overseer ? ' (never kills; checks the fast tier each tick)' : ' (legacy hard timeouts)'}.` +
+                    `\nSubagent model: ${subagent}` +
+                    `${roster}`);
                 return;
             }
             if (verb === 'on' || verb === 'off') {
@@ -332,6 +413,10 @@ const COMMANDS = [
                 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');
@@ -347,7 +432,7 @@ const COMMANDS = [
                 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].`);
+            ctx.notify('warn', `Unknown argument "${verb}" - use /team [status|on|off|max <n>|overseer on|off|model main|fast|<profile-name>].`);
         },
     },
     {
@@ -873,44 +958,23 @@ const COMMANDS = [
         },
     },
     {
+        // REGISTRATION ONLY. The body lives in `commands/clear-command.ts`: this file
+        // is already past the 1000-line guideline, and `/clear` is no longer a
+        // two-line projection reset - it interrupts a run, waits for it, archives the
+        // conversation and then clears (clear-command-context-reset D-8).
         name: 'clear',
-        description: 'Clear the visible transcript and the todo panel',
-        run: (ctx) => {
-            // A USER OVERRIDE OF A PROJECTION, the same class as `/todo clear`, so it
-            // reuses reason `'user'`; I-2 and its standing exception are stated on
-            // `TodoStore`. Clearing the STORE and not merely the view mirror is what
-            // keeps `/save`, `/todo status|continue` and follow-through agreeing with
-            // the screen — they read the store directly. `messages` is untouched:
-            // clearing the conversation is still `/reset` alone.
-            //
-            // DELIBERATELY WITHOUT `/todo clear`'s two guards: an `isRunning()` refusal
-            // would leave `/clear` unable to clear even the transcript mid-run, and an
-            // early return on an empty list would skip the dispatch below entirely.
-            // Clearing an empty store is already silent — it emits into a reducer
-            // branch that writes two fields that are both already at their defaults.
-            //
-            // Bounded side effect: the emptied store re-arms `todo_write`'s "a fresh
-            // plan has at least two items" gate, so a model that shrinks a plan to one
-            // item right after a mid-run `/clear` gets the refusal text and retries.
-            ctx.controller.clearTodos();
-            ctx.dispatch({ type: 'clearTranscript' });
-        },
+        description: 'Start a new conversation; "/clear screen" only clears the screen',
+        run: runClearCommand,
     },
     {
+        // ALIAS BY DESIGN (D-2), AND THIS IS THE WHOLE FIX. Until this change `/clear`
+        // cleared the screen while `/reset` cleared the session, so the command a
+        // user reaches for in a long conversation was the one that kept the history.
+        // One implementation makes that drift structurally impossible rather than
+        // merely fixed: there is no second body left to diverge.
         name: 'reset',
-        description: 'Start a new conversation',
-        run: (ctx) => {
-            if (ctx.controller.isRunning()) {
-                ctx.notify('warn', 'Cannot reset while the agent is running. Wait for it to stop.');
-                return;
-            }
-            ctx.controller.clearMessages();
-            ctx.controller.clearAllQueues();
-            ctx.dispatch({ type: 'resetConversation' });
-            ctx.toast('info', 'Started a new conversation.');
-            if (ctx.state.pendingSteering.length)
-                ctx.notify('warn', `\u5df2\u53d6\u6d88 ${ctx.state.pendingSteering.length} \u6761\u672a\u63a5\u6536\u6d88\u606f`);
-        },
+        description: 'Alias of /clear',
+        run: runClearCommand,
     },
     {
         name: 'cwd',

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

@@ -0,0 +1,27 @@
+/**
+ * `/clear` - start a new conversation - plus its `/reset` alias and the
+ * `/clear screen` form that keeps the old "just wipe the screen" meaning
+ * (clear-command-context-reset §3.5 / D-1 / D-2 / D-3).
+ *
+ * ASCII ONLY: `src/commands/**` is inside `glyphs.test.ts::inScope`. The one
+ * localized string below is written with `\u` escapes for that reason, exactly
+ * as the `/reset` body it replaces did.
+ *
+ * WHY THE BODY LIVES HERE AND THE REGISTRATION STAYS IN `builtins.ts`: the same
+ * reason `/compact` and `/context` do (D-8). `builtins.ts` is 1511 lines against
+ * `CLAUDE.md`'s 1000-line cap, and this command is no longer a two-line
+ * projection reset - it interrupts a run, waits for it, archives a conversation
+ * and then clears. A two-line edit belongs inline; this does not.
+ *
+ * THE COMMAND'S ONLY JOB IS SEQUENCING AND SPEAKING. Every state change happens
+ * on the controller port (`AgentController.resetConversation`, which delegates
+ * the ORDER to `agent/conversation-reset.ts`), and every word the user reads is
+ * decided here, in one place, in the exact order they will read it.
+ */
+import type { CommandContext } from './registry.js';
+/**
+ * Run `/clear` or `/reset`. Both registry entries point HERE (D-2), which is
+ * what stops the two from drifting back into "one clears the screen, one clears
+ * the session" - the drift that produced the defect this feature fixes.
+ */
+export declare function runClearCommand(ctx: CommandContext): Promise<void>;

package/dist/commands/clear-command.js

@@ -0,0 +1,107 @@
+/**
+ * `/clear` - start a new conversation - plus its `/reset` alias and the
+ * `/clear screen` form that keeps the old "just wipe the screen" meaning
+ * (clear-command-context-reset §3.5 / D-1 / D-2 / D-3).
+ *
+ * ASCII ONLY: `src/commands/**` is inside `glyphs.test.ts::inScope`. The one
+ * localized string below is written with `\u` escapes for that reason, exactly
+ * as the `/reset` body it replaces did.
+ *
+ * WHY THE BODY LIVES HERE AND THE REGISTRATION STAYS IN `builtins.ts`: the same
+ * reason `/compact` and `/context` do (D-8). `builtins.ts` is 1511 lines against
+ * `CLAUDE.md`'s 1000-line cap, and this command is no longer a two-line
+ * projection reset - it interrupts a run, waits for it, archives a conversation
+ * and then clears. A two-line edit belongs inline; this does not.
+ *
+ * THE COMMAND'S ONLY JOB IS SEQUENCING AND SPEAKING. Every state change happens
+ * on the controller port (`AgentController.resetConversation`, which delegates
+ * the ORDER to `agent/conversation-reset.ts`), and every word the user reads is
+ * decided here, in one place, in the exact order they will read it.
+ */
+import { getLogger } from '../logging/logger.js';
+/** The toast a successful clear shows. Pinned verbatim by an existing test. */
+const CLEARED_TOAST = 'Started a new conversation.';
+/**
+ * Run `/clear` or `/reset`. Both registry entries point HERE (D-2), which is
+ * what stops the two from drifting back into "one clears the screen, one clears
+ * the session" - the drift that produced the defect this feature fixes.
+ */
+export async function runClearCommand(ctx) {
+    const verb = ctx.args.trim().toLowerCase();
+    if (verb === 'screen') {
+        // The old behaviour, byte for byte (I-3): silent, transcript plus the todo
+        // panel, history untouched.
+        clearScreenOnly(ctx);
+        return;
+    }
+    if (verb !== '') {
+        // Rejected rather than ignored. A command that silently accepts and
+        // discards an argument is a surface that lies about what it understood.
+        ctx.notify('warn', `Unknown argument "${ctx.args.trim()}" - use /clear [screen].`);
+        return;
+    }
+    // READ BEFORE CLEARING (P1-2 / I-9). `clearAllQueues()` empties
+    // `pendingUserSteering`, so a count taken afterwards is always zero - and a
+    // notice that says "0 messages cancelled" is worse than no notice at all.
+    const cancelled = ctx.state.pendingSteering.length;
+    const result = await ctx.controller.resetConversation({
+        interrupt: true,
+        // A THUNK, NOT A VALUE (P0-1 / §3.3). `ctx.state` is the view as of command
+        // entry, and the archive happens AFTER the interrupted engine unwinds - so
+        // the last tool cards of the abandoned run are written to the transcript in
+        // between. A value captured here would archive everything except the part
+        // the user was looking at when they typed the command.
+        readTranscript: () => ctx.transcriptEntries?.() ?? ctx.state.entries,
+    });
+    if (!result.ok) {
+        // ZERO SIDE EFFECTS (I-4), and a trace (P1-5). The user gets one sentence
+        // naming the next action; the log gets the reason, because "my /clear did
+        // nothing" is otherwise unanswerable after the fact.
+        getLogger().warn('agent', 'clear_still_running', { reason: result.reason });
+        ctx.notify('warn', result.message);
+        return;
+    }
+    // THE VIEW GOES LAST (B-5 / §3.3). `App`'s dispatch wrapper zeroes the run
+    // metrics, the interaction phase and the scroll anchor on this action, so
+    // dispatching it after the engine has settled is what makes "cleared" mean
+    // "nothing is still writing into it".
+    ctx.dispatch({ type: 'resetConversation' });
+    // THE ONE CONSUMER OF `messagesCleared` (P2-1). It cannot join the toast:
+    // `clear-command-todo.test.ts` pins that string verbatim, and a count nobody
+    // asked for is noise in the one place the user reads confirmations.
+    getLogger().info('agent', 'conversation_cleared', {
+        messagesCleared: result.messagesCleared,
+        interrupted: result.interrupted,
+    });
+    ctx.toast('info', CLEARED_TOAST);
+    // REINSTATED FROM THE OLD `/reset` (P1-1 / C-3). Dropping it would silently
+    // delete a user-visible acknowledgement that already existed and was already
+    // pinned by test.
+    if (cancelled) {
+        ctx.notify('warn', `\u5df2\u53d6\u6d88 ${cancelled} \u6761\u672a\u63a5\u6536\u6d88\u606f`);
+    }
+    if (result.archivedPath) {
+        // A PATH RATHER THAN A PROMISE: the user can copy it, and `/resume` accepts
+        // an absolute path. "Archived" with no way to find the file is a reassurance,
+        // not a recovery.
+        ctx.notify('info', `Previous conversation archived: ${result.archivedPath} (/resume <path> to restore)`);
+    }
+}
+/**
+ * Today's `/clear`, unchanged and silent (D-3 / I-3).
+ *
+ * Kept as a real form rather than as a separate command because "clear the
+ * screen" and "clear the conversation" are two different intentions, and a user
+ * who wants the first must not have to risk the second. It also gives
+ * `clearTranscript` a live dispatcher: `CLAUDE.md` forbids orphaned actions, and
+ * this was the last one that would have had none.
+ */
+function clearScreenOnly(ctx) {
+    // A USER OVERRIDE OF A PROJECTION, the same class as `/todo clear`, so it
+    // reuses reason `'user'`; the distinction against `clearMessages()`'s `'reset'`
+    // is recorded on `TodoStore`. Clearing the STORE and not merely the view
+    // mirror is what keeps `/save`, `/todo status|continue` and follow-through
+    // agreeing with the screen - they read the store directly.
+    ctx.controller.clearTodos();
+    ctx.dispatch({ type: 'clearTranscript' });
+}

package/dist/commands/registry.d.ts

@@ -6,7 +6,7 @@ import type { SubmitMessageOptions } from '../agent/prompt-options.js';
 import type { CopyRequest, CopyRequestResult } from '../ui/clipboard-task.js';
 import type { AgentController } from '../agent/controller.js';
 import type { AgentMode } from '../agent/agent-mode.js';
-import type { NoticeLevel, Overlay, ToastLevel, ViewAction, ViewState } from '../agent/reducer.js';
+import type { Entry, NoticeLevel, Overlay, ToastLevel, ViewAction, ViewState } from '../agent/reducer.js';
 import type { PersistedConfig } from '../config/schema.js';
 import type { FollowThroughBudget } from '../todo/follow-through.js';
 import type { UpdateCommandPort } from '../update/types.js';
@@ -108,6 +108,25 @@ export interface CommandContext {
      * stream is handed over directly.
      */
     writeForeign?: (text: string) => void;
+    /**
+     * The LIVE transcript rows, for `/clear`'s archive (clear-command-context-reset
+     * P0-1 / §3.5).
+     *
+     * A THUNK, AND THAT IS THE WHOLE POINT. The `state` field above is a snapshot
+     * of `ViewState` taken when the command started; `/clear` interrupts a run and
+     * then waits for the engine to unwind, so the last tool cards of that run are
+     * written to the transcript AFTER `state` was captured. Reading `state.entries`
+     * would archive everything except the part the user was just looking at.
+     *
+     * OPTIONAL, like `followBudget` / `update` / `mouse`: every existing
+     * `CommandContext` fixture in this package builds the object by literal, and a
+     * required field would break all of them at compile time for a feature none of
+     * them are about. Absent means the archive degrades to history-only.
+     *
+     * `Entry` arrives as a TYPE-ONLY import so this module keeps its runtime shape
+     * (the same rule the `update/types.js` import above follows).
+     */
+    transcriptEntries?: () => Entry[];
 }
 /** What `/mouse` can see and do. Read at command time, never captured. */
 export interface MouseCommandPort {

package/dist/compaction/child.d.ts

@@ -56,6 +56,21 @@ export interface ChildCompactionDeps {
 export interface ChildContextManagerRequest {
     role?: ModelRole;
     label: string;
+    /**
+     * REQ-LEVEL key resolvers, preferred over the lead's (V-4).
+     *
+     * `wiring.ts::childFactory` injects the LEAD layer's `getApiKey`/`hasKey`,
+     * which cannot see a fast-only key (`role='fast'` only) or a profile's
+     * dedicated key (it exists only inside the entry). `Compactor.resolveSummarizer`
+     * gates its main choice on `hasKey(provider, role)` and reads the call key
+     * through `getApiKey`, so without these a `team.model: fast/profile` child
+     * whose only key lives in one of those places would have its compaction
+     * SILENTLY DISABLED - the summarizer resolves to null and nobody says why.
+     * `subagent.ts` passes the same profile-aware closures the child's own
+     * `Agent` gets; ABSENT keeps today's behavior byte for byte (matrix 24).
+     */
+    getApiKey?: (providerId: string, role?: ModelRole) => string | undefined;
+    hasKey?: (providerId: string, role?: ModelRole) => boolean;
     /**
      * The model the child actually runs on.
      *

package/dist/compaction/child.js

@@ -65,6 +65,10 @@ export function createChildContextManager(req, deps) {
             baseUrl: req.model.baseUrl,
             // The lead's manual limit describes its connection, not every worker.
             contextWindow: sameConnection ? base.contextWindow : null,
+            // THE ORIGIN FOLLOWS THE VALUE through the same gate, honoring the iff
+            // contract (value null => origin undefined): a child on a different
+            // connection inherits neither the number nor its provenance.
+            contextWindowOrigin: sameConnection ? base.contextWindowOrigin : undefined,
             // NO POLICY OVERLAY (main-agent parity): `keepRecentTurns`, `onFailure`,
             // `useFastTier` and `archive` are read LIVE from the base config, so the
             // child compacts under exactly the policy the lead compacts under. A
@@ -81,15 +85,22 @@ export function createChildContextManager(req, deps) {
             return source === undefined ? deps.isPricedModel(req.model) : source !== 'fallback';
         },
         getWindowOverride: () => childConfig().contextWindow,
+        getWindowOverrideOrigin: () => childConfig().contextWindowOrigin,
     });
     let overflowNotified = false;
+    // REQ-LEVEL RESOLVERS WIN (V-4), and the fallback is the lead layer - so a
+    // request built without them behaves exactly as before, while one built by
+    // `subagent.ts` under `team.model: fast/profile` lets the summarizer see
+    // the same keys the child itself authenticates with.
+    const hasKey = req.hasKey ?? deps.hasKey;
+    const getApiKey = req.getApiKey ?? deps.getApiKey;
     const compactor = new Compactor({
         getConfig: childConfig,
         meter,
         mainRole: req.role ?? 'main',
-        resolveFastCandidate: () => resolveFastTier(deps.getConfig(), deps.hasKey),
-        hasKey: deps.hasKey,
-        getApiKey: deps.getApiKey,
+        resolveFastCandidate: () => resolveFastTier(deps.getConfig(), hasKey),
+        hasKey,
+        getApiKey,
         getModelInfoFor: deps.getModelInfoFor,
         isPricedModel: deps.isPricedModel,
         getMessages: req.getMessages,

package/dist/compaction/compactor.js

@@ -403,6 +403,7 @@ export class Compactor {
                 return source === undefined ? this.deps.isPricedModel(this.mainRef()) : source !== 'fallback';
             },
             getWindowOverride: () => this.deps.getConfig().contextWindow,
+            getWindowOverrideOrigin: () => this.deps.getConfig().contextWindowOrigin,
         });
         return this.ownMeter;
     }

package/dist/compaction/context-command.js

@@ -87,7 +87,16 @@ function occupancyLine(usage) {
  */
 function windowLine(usage) {
     if (usage.windowOverridden) {
-        return `${usage.window}   from contextWindow configuration (overrides API, model table, and model-windows.json)`;
+        // THREE NAMED SURFACES (profile-context-window §6.2). `undefined` falls
+        // into the config branch ON PURPOSE: that string is what every pre-feature
+        // test asserts, and a meter built without the origin dep must report
+        // byte-identically (invariant 6).
+        const named = usage.windowOverrideOrigin === 'profile'
+            ? 'from your model profile'
+            : usage.windowOverrideOrigin === 'env'
+                ? 'from ARAGON_CONTEXT_WINDOW'
+                : 'from contextWindow configuration';
+        return `${usage.window}   ${named} (overrides API, model table, and model-windows.json)`;
     }
     if (!usage.windowKnown) {
         return (`UNKNOWN - no verified model limit; internal fallback budget ${usage.window}; ` +

package/dist/compaction/meter.d.ts

@@ -28,6 +28,7 @@
  * `current()` carries a structural belt for a missed invalidation site.
  */
 import type { AgentEvent, Message, ModelInfo, TokenUsage } from '@aragon-agent/core';
+import type { ContextWindowOrigin } from '../config/schema.js';
 import type { ContextUsageSnapshot, Pressure } from './types.js';
 /**
  * How long a scheduled publish waits.
@@ -62,6 +63,14 @@ export interface ContextMeterDeps {
      * measurement, so a live settings edit moves the denominator without a relaunch.
      */
     getWindowOverride(): number | null;
+    /**
+     * WHERE the override above came from, read live beside it
+     * (profile-context-window §6.1). Optional so every existing construction
+     * site stays untouched: a meter built without it reports an overridden
+     * window with origin `undefined`, and `/context` falls back to its
+     * pre-feature "from contextWindow configuration" wording byte-for-byte.
+     */
+    getWindowOverrideOrigin?(): ContextWindowOrigin | undefined;
     getRequestVersion?(): number;
 }
 export type ContextUsageListener = (usage: ContextUsageSnapshot) => void;

package/dist/compaction/meter.js

@@ -63,6 +63,9 @@ export function toContextUsage(p) {
         deltaTokens: p.deltaTokens,
         windowKnown: p.windowKnown,
         windowOverridden: p.windowOverridden,
+        ...(p.windowOverrideOrigin !== undefined
+            ? { windowOverrideOrigin: p.windowOverrideOrigin }
+            : {}),
     };
 }
 /** The reading a meter with nothing measured yet reports. */
@@ -426,6 +429,10 @@ export class ContextMeter {
             window.contextWindow !== last?.contextWindow ||
             window.windowKnown !== last?.windowKnown ||
             window.windowOverridden !== last?.windowOverridden ||
+            // ORIGIN IS PART OF THE DIRTY CHECK: a save that keeps the same number
+            // but moves it from the legacy key to the bound profile would otherwise
+            // leave `/context` naming the old source until the next measurement.
+            window.windowOverrideOrigin !== last?.windowOverrideOrigin ||
             this.deps.getModelInfo().contextWindowSource !== last?.windowSource)
             this.dirty = true;
     }
@@ -451,6 +458,9 @@ export class ContextMeter {
             windowSource: this.deps.getModelInfo().contextWindowSource,
             windowKnown: window.windowKnown,
             windowOverridden: window.windowOverridden,
+            ...(window.windowOverrideOrigin !== undefined
+                ? { windowOverrideOrigin: window.windowOverrideOrigin }
+                : {}),
             ...(this.estimateOffset !== undefined ? { estimateOffset: this.estimateOffset } : {}),
             ...(this.measuredPrefixLength !== undefined
                 ? { measuredPrefixLength: this.measuredPrefixLength }
@@ -469,7 +479,12 @@ export class ContextMeter {
     resolveWindow() {
         const override = this.deps.getWindowOverride();
         if (override !== null && Number.isFinite(override) && override > 0) {
-            return { contextWindow: override, windowKnown: true, windowOverridden: true };
+            // ORIGIN ONLY RIDES THE OVERRIDE BRANCH: the AUTO branch names its own
+            // source through `getModelInfo().contextWindowSource`, and the two must
+            // never both claim the denominator (profile-context-window §6.1).
+            const origin = this.deps.getWindowOverrideOrigin?.();
+            return { contextWindow: override, windowKnown: true, windowOverridden: true,
+                ...(origin !== undefined ? { windowOverrideOrigin: origin } : {}) };
         }
         return {
             contextWindow: this.deps.getModelInfo().contextWindow,

package/dist/compaction/pressure.d.ts

@@ -93,6 +93,13 @@ export interface PressureInput {
      * construction site is unchanged and the arithmetic below is untouched.
      */
     windowOverridden?: boolean;
+    /**
+     * Which override surface supplied `contextWindow` (profile-context-window).
+     * PURE PASS-THROUGH like `windowOverridden` - the arithmetic below never
+     * reads it; it only travels with the number so `/context` can name the
+     * source honestly.
+     */
+    windowOverrideOrigin?: Pressure['windowOverrideOrigin'];
     /** Carried from the last `turn_end`; applied to every ESTIMATED figure. */
     estimateOffset?: number;
     /**

package/dist/compaction/pressure.js

@@ -174,6 +174,11 @@ export function computePressure(input) {
         // context-usage-gauge-accuracy; the flag only travels with the number so
         // `/context` can name the denominator's source (I-6).
         windowOverridden: input.windowOverridden ?? false,
+        // CONDITIONAL SPREAD: with no origin there is no KEY, keeping a
+        // feature-off Pressure byte-identical to the pre-feature one (I-6).
+        ...(input.windowOverrideOrigin !== undefined
+            ? { windowOverrideOrigin: input.windowOverrideOrigin }
+            : {}),
         ...(input.estimateOffset !== undefined ? { estimateOffset: input.estimateOffset } : {}),
         deltaTokens,
     };

package/dist/compaction/types.d.ts

@@ -20,6 +20,7 @@
  * possible change.
  */
 import type { ModelRef, TokenUsage } from '@aragon-agent/core';
+import type { ContextWindowOrigin } from '../config/schema.js';
 /** Billing belongs to the actual call, including fallback and late responses. */
 export interface CompactionBilling {
     modelRef?: ModelRef;
@@ -92,6 +93,14 @@ export interface Pressure {
      * one being wrong is exactly the case that most needs to be visible.
      */
     windowOverridden: boolean;
+    /**
+     * WHICH override surface supplied the denominator (profile-context-window
+     * §5.2): env / legacy top-level key / the profile bound as Main. Optional
+     * and PURE PASS-THROUGH - present only when `windowOverridden` is true, and
+     * `undefined` there means "config", the pre-feature answer. The arithmetic
+     * never reads it; only `/context`'s window line does.
+     */
+    windowOverrideOrigin?: ContextWindowOrigin;
     /**
      * `occupiedTokens(lastUsage) - estimateOf(the history that produced it)`,
      * clamped to `>= 0`, or `undefined` before the first `turn_end`.
@@ -150,6 +159,8 @@ export interface ContextUsageSnapshot {
     windowKnown: boolean;
     /** Whether the denominator came from the user's `contextWindow` (I-6). */
     windowOverridden: boolean;
+    /** Which override surface named the denominator; see `Pressure` (pass-through). */
+    windowOverrideOrigin?: ContextWindowOrigin;
 }
 /** One compaction, in whatever state it reached. Rendered by `CompactionCard`. */
 export interface CompactionRecord {

package/dist/compaction/wiring.js

@@ -105,6 +105,7 @@ export class CompactionWiring {
                         return source === undefined ? deps.isPricedModel(this.mainRef()) : source !== 'fallback';
                     },
                     getWindowOverride: () => deps.getConfig().contextWindow,
+                    getWindowOverrideOrigin: () => deps.getConfig().contextWindowOrigin,
                 });
         this.compactor = new Compactor({
             getConfig: deps.getConfig,

package/dist/config/cli-commands.d.ts

@@ -20,7 +20,7 @@ export declare const LOG_CONFIG_SET_KEYS: readonly ["log.level", "log.toFile", "
  * switch falls through every case, writes nothing, and still prints
  * `Set team.enabled = false`.
  */
-export declare const TEAM_CONFIG_SET_KEYS: readonly ["team.enabled", "team.maxSubagents", "team.maxConcurrent", "team.subagentTimeoutMs", "team.dispatchTimeoutMs", "team.maxTurnsPerSubagent", "team.overseer", "team.overseerIntervalMs"];
+export declare const TEAM_CONFIG_SET_KEYS: readonly ["team.enabled", "team.maxSubagents", "team.maxConcurrent", "team.subagentTimeoutMs", "team.dispatchTimeoutMs", "team.maxTurnsPerSubagent", "team.overseer", "team.overseerIntervalMs", "team.model", "team.modelProfileId"];
 /**
  * Config keys under `retry.` that `aragon config set` accepts
  * (llm-api-retry-backoff §8.2).

package/dist/config/cli-commands.js

@@ -45,6 +45,8 @@ export const TEAM_CONFIG_SET_KEYS = [
     'team.maxTurnsPerSubagent',
     'team.overseer',
     'team.overseerIntervalMs',
+    'team.model',
+    'team.modelProfileId',
 ];
 /**
  * Config keys under `retry.` that `aragon config set` accepts
@@ -205,6 +207,16 @@ export function applyTeamConfigSet(key, value) {
             return patch({ overseer: isTrue(value) });
         case 'team.overseerIntervalMs':
             return patch(clampOne('overseerIntervalMs'));
+        // The subagent-model keys (subagent-model-and-question-controls V-3):
+        // without these two cases `aragon config set team.model fast` is refused
+        // with "Unknown config key" while `config list` shows the key one command
+        // over - the exact gap COMPACTION_CONFIG_SET_KEYS records at length.
+        // Both route through `clampTeamConfig` like every other key here: a typo'd
+        // mode resolves to 'main' and a bad id is nulled, never rejected.
+        case 'team.model':
+            return patch(clampOne('model'));
+        case 'team.modelProfileId':
+            return patch(clampOne('modelProfileId'));
         default:
             return null;
     }