@aragon-agent/cli 0.6.23 → 0.6.25

package/dist/team/model.d.ts

@@ -0,0 +1,88 @@
+/**
+ * `resolveSubagentModel` — THE single authority on which model a team child
+ * runs (subagent-model-and-question-controls §3.3).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope.
+ *
+ * EVERY CONSUMER READS THE CHILD'S MODEL THROUGH THIS FUNCTION AND NOWHERE
+ * ELSE — `createSubagent`, the `task` report header, the settings root row and
+ * `/team model` — following the `resolveFastTier` precedent one directory over:
+ * four call sites each recomputing "which model do children run on?" from raw
+ * config keys is exactly how the report ends up naming a model the children
+ * silently fell back from.
+ *
+ * IT IS RE-RUN ON EVERY DISPATCH AND EVERY RENDER, NOT ONCE (rule 8 / RV-3 of
+ * the fast tier, inherited here): `team.model`, the fast tier and the profile
+ * library are all LIVE keys a settings save, `/fast off` or `/team model` can
+ * rewrite mid-session. A resolution captured at construction would be a
+ * resolution describing a session that no longer exists.
+ *
+ * A CHILD IS NEVER LEFT WITHOUT A MODEL (D-4). Every failure mode — fast tier
+ * off, profile deleted, profile key missing — degrades to the MAIN connection
+ * with a `fallbackReason`, so a dispatch cannot fail because its model setting
+ * went stale. The reason is disclosed, never swallowed: the report header and
+ * the settings summary line both render it.
+ */
+import type { ModelRef, ThinkingLevel } from '@aragon-agent/core';
+import type { ModelProfile, ModelRole } from '../config/model-profiles.js';
+import type { CliConfig } from '../config/schema.js';
+/** Which model children run on. `main` is the default and the historical behavior. */
+export type SubagentModelMode = 'main' | 'fast' | 'profile';
+/** Why a non-main request degraded to the main model (D-4 disclosure). */
+export type SubagentFallbackReason = 
+/** `team.model='fast'` but `resolveFastTier` is not ok (off, unconfigured, no key). */
+'fast_unavailable'
+/** `modelProfileId` is absent from the library (deleted, or never existed). */
+ | 'profile_missing'
+/** The entry exists but carries no key of its own and the shared layer has none. */
+ | 'profile_no_key';
+/** In-memory resolution; recomputed per dispatch/render, never persisted (§6.3). */
+export interface SubagentModelResolution {
+    /** The user's requested mode, verbatim from config (UI highlight reads this). */
+    mode: SubagentModelMode;
+    /** The mode actually in effect; `'main'` whenever a fallback fired. */
+    effective: SubagentModelMode;
+    /** The connection children will use. On fallback, exactly the main connection. */
+    ref: ModelRef;
+    /** main/profile take `config.thinkingLevel`; fast takes `config.fast.thinkingLevel`. */
+    thinkingLevel: ThinkingLevel;
+    /** The role controller key resolution uses: main/profile `'main'`, fast `'fast'`. */
+    keyRole: ModelRole;
+    /** The profile entry a `profile` request hit, dedicated key included; else null. */
+    profile: ModelProfile | null;
+    /** Present only when `effective !== mode`. */
+    fallbackReason?: SubagentFallbackReason;
+}
+/** The `AgentController.hasApiKey` shape, injected so there is one key resolver. */
+export type HasApiKey = (providerId: string, role?: ModelRole) => boolean;
+/** The lead-layer key resolver `resolveSubagentKey` falls back to. */
+export type SharedKeyResolver = (providerId: string, role: ModelRole) => string | undefined;
+/**
+ * Resolve the model every child of the NEXT dispatch will run on.
+ *
+ * Pure, synchronous, no IO — testable as a matrix over config fixtures.
+ *
+ * @param config The live effective config. Read fresh; never snapshot it.
+ * @param hasKey `AgentController.hasApiKey`, which already resolves the
+ *   config-file key, the provider environment variable and the one-shot
+ *   `--api-key` override. Injected rather than reimplemented for the reason
+ *   `resolveFastTier` records: a second key resolver is a second answer to
+ *   "why does it say no key?".
+ */
+export declare function resolveSubagentModel(config: CliConfig, hasKey: HasApiKey): SubagentModelResolution;
+/**
+ * The key a CHILD resolves for a provider, profile-aware (§3.3 / I-4).
+ *
+ * A profile's dedicated key is visible ONLY here: it never reaches env,
+ * `config.apiKeys` or a log line. While the resolution's profile is bound and
+ * the provider matches it, the entry key takes priority over the shared layer;
+ * every other provider (and every non-profile mode) resolves through the
+ * lead's own resolver at `resolution.keyRole` — which is what keeps a `fast`
+ * child entitled to the fast-role key and a `main` child to the main one.
+ *
+ * @param config The live config (carried for parity with the resolver pair).
+ * @param resolution A fresh `resolveSubagentModel` output.
+ * @param providerId The provider the child needs a key for.
+ * @param shared The lead-layer resolver (`controller.resolveKey`).
+ */
+export declare function resolveSubagentKey(config: CliConfig, resolution: SubagentModelResolution, providerId: string, shared: SharedKeyResolver): string | undefined;

package/dist/team/model.js

@@ -0,0 +1,136 @@
+/**
+ * `resolveSubagentModel` — THE single authority on which model a team child
+ * runs (subagent-model-and-question-controls §3.3).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope.
+ *
+ * EVERY CONSUMER READS THE CHILD'S MODEL THROUGH THIS FUNCTION AND NOWHERE
+ * ELSE — `createSubagent`, the `task` report header, the settings root row and
+ * `/team model` — following the `resolveFastTier` precedent one directory over:
+ * four call sites each recomputing "which model do children run on?" from raw
+ * config keys is exactly how the report ends up naming a model the children
+ * silently fell back from.
+ *
+ * IT IS RE-RUN ON EVERY DISPATCH AND EVERY RENDER, NOT ONCE (rule 8 / RV-3 of
+ * the fast tier, inherited here): `team.model`, the fast tier and the profile
+ * library are all LIVE keys a settings save, `/fast off` or `/team model` can
+ * rewrite mid-session. A resolution captured at construction would be a
+ * resolution describing a session that no longer exists.
+ *
+ * A CHILD IS NEVER LEFT WITHOUT A MODEL (D-4). Every failure mode — fast tier
+ * off, profile deleted, profile key missing — degrades to the MAIN connection
+ * with a `fallbackReason`, so a dispatch cannot fail because its model setting
+ * went stale. The reason is disclosed, never swallowed: the report header and
+ * the settings summary line both render it.
+ */
+import { resolveFastTier } from '../fast/resolve.js';
+function mainRef(config) {
+    return {
+        providerId: config.provider,
+        modelId: config.model,
+        ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+    };
+}
+function fallbackToMain(config, mode, fallbackReason) {
+    // THE ALWAYS-USABLE ANSWER (D-4): whatever the user asked for that could not
+    // resolve, the caller still gets a working connection — the same provider,
+    // model, base URL and thinking level the lead itself runs on.
+    return {
+        mode,
+        effective: 'main',
+        ref: mainRef(config),
+        thinkingLevel: config.thinkingLevel,
+        keyRole: 'main',
+        profile: null,
+        fallbackReason,
+    };
+}
+/**
+ * Resolve the model every child of the NEXT dispatch will run on.
+ *
+ * Pure, synchronous, no IO — testable as a matrix over config fixtures.
+ *
+ * @param config The live effective config. Read fresh; never snapshot it.
+ * @param hasKey `AgentController.hasApiKey`, which already resolves the
+ *   config-file key, the provider environment variable and the one-shot
+ *   `--api-key` override. Injected rather than reimplemented for the reason
+ *   `resolveFastTier` records: a second key resolver is a second answer to
+ *   "why does it say no key?".
+ */
+export function resolveSubagentModel(config, hasKey) {
+    // `clampTeamConfig` guarantees the enum on every read and write path, so the
+    // default `'main'` here is belt-and-braces rather than a real branch.
+    const mode = config.team.model ?? 'main';
+    if (mode === 'fast') {
+        const tier = resolveFastTier(config, hasKey);
+        if (tier.ok) {
+            return {
+                mode,
+                effective: 'fast',
+                ref: tier.ref,
+                thinkingLevel: config.fast.thinkingLevel,
+                keyRole: 'fast',
+                profile: null,
+            };
+        }
+        return fallbackToMain(config, mode, 'fast_unavailable');
+    }
+    if (mode === 'profile') {
+        // A missing library, a missing id and a dangling id are one outcome
+        // (D-4): degrade to main and say so. Reference EXISTENCE is deliberately
+        // not validated in `clampTeamConfig` — resolution is where it belongs.
+        const id = config.team.modelProfileId;
+        const entry = id
+            ? config.modelProfiles?.entries.find((candidate) => candidate.id === id)
+            : undefined;
+        if (!entry)
+            return fallbackToMain(config, mode, 'profile_missing');
+        // The dedicated entry key wins; without one the shared layer must have a
+        // key for the entry's provider, or the child could not authenticate at all.
+        if (!entry.apiKey && !hasKey(entry.provider, 'main')) {
+            return fallbackToMain(config, mode, 'profile_no_key');
+        }
+        return {
+            mode,
+            effective: 'profile',
+            ref: {
+                providerId: entry.provider,
+                modelId: entry.model,
+                ...(entry.baseUrl ? { baseUrl: entry.baseUrl } : {}),
+            },
+            thinkingLevel: config.thinkingLevel,
+            keyRole: 'main',
+            profile: entry,
+        };
+    }
+    return {
+        mode: 'main',
+        effective: 'main',
+        ref: mainRef(config),
+        thinkingLevel: config.thinkingLevel,
+        keyRole: 'main',
+        profile: null,
+    };
+}
+/**
+ * The key a CHILD resolves for a provider, profile-aware (§3.3 / I-4).
+ *
+ * A profile's dedicated key is visible ONLY here: it never reaches env,
+ * `config.apiKeys` or a log line. While the resolution's profile is bound and
+ * the provider matches it, the entry key takes priority over the shared layer;
+ * every other provider (and every non-profile mode) resolves through the
+ * lead's own resolver at `resolution.keyRole` — which is what keeps a `fast`
+ * child entitled to the fast-role key and a `main` child to the main one.
+ *
+ * @param config The live config (carried for parity with the resolver pair).
+ * @param resolution A fresh `resolveSubagentModel` output.
+ * @param providerId The provider the child needs a key for.
+ * @param shared The lead-layer resolver (`controller.resolveKey`).
+ */
+export function resolveSubagentKey(config, resolution, providerId, shared) {
+    void config; // parity parameter: the pair reads one config, the key does not need it
+    if (resolution.profile && providerId === resolution.ref.providerId) {
+        return resolution.profile.apiKey ?? shared(providerId, 'main');
+    }
+    return shared(providerId, resolution.keyRole);
+}

package/dist/team/report.d.ts

@@ -21,6 +21,7 @@
  * because of one HTTP 429.
  */
 import type { ModelCost } from '@aragon-agent/core';
+import type { SubagentModelResolution } from './model.js';
 import type { DispatchOutcome, SubagentRun } from './types.js';
 export interface ReportOptions {
     /** The lead's model cost table, so the header can state real spend (R-5).
@@ -37,6 +38,16 @@ export interface ReportOptions {
      * rule the fast tier already follows everywhere else).
      */
     fastCost?: ModelCost;
+    /**
+     * The dispatch-time subagent model resolution (subagent-model §3.4).
+     *
+     * ABSENT under the default `team.model: 'main'` mode is what keeps the
+     * parity report byte-identical (I-2): the disclosure line exists only when
+     * children did NOT run the main model, and a resolution that degraded
+     * (fast tier off, profile deleted, profile key missing) says so instead of
+     * silently renaming the model the children fell back to (D-4).
+     */
+    subagentModel?: SubagentModelResolution;
 }
 /**
  * Cut `text` to at most `maxBytes` WITHOUT splitting a UTF-8 sequence.

package/dist/team/report.js

@@ -106,8 +106,31 @@ function buildHeader(outcome, options) {
             `(${counts}) in ${formatDuration(durationMs)}.`
         : `Team dispatch: ${outcome.runs.length} of ${outcome.runs.length} subagents finished ` +
             `(${counts}) in ${formatDuration(durationMs)}.`);
+    // THE PRICE OF THE MODEL CHILDREN ACTUALLY RAN (subagent-model §3.4). The
+    // default main flow always supplies a table, so the ternary's last branch
+    // is the legacy byte-identical shape; an UNPRICED fast or profile child
+    // model says `pricing unknown` - unknown pricing is not zero pricing, and
+    // `$0.00` on a dispatch that is spending money is the C-11 / RV-4 lie.
+    const spend = options.cost
+        ? formatCost(computeCost(outcome.usage, options.cost))
+        : options.subagentModel && options.subagentModel.effective !== 'main'
+            ? 'pricing unknown'
+            : formatCost(computeCost(outcome.usage, options.cost));
     lines.push(`Tokens: in ${formatTokens(outcome.usage.inputTokens)}, out ` +
-        `${formatTokens(outcome.usage.outputTokens)}. Cost: ${formatCost(computeCost(outcome.usage, options.cost))}.`);
+        `${formatTokens(outcome.usage.outputTokens)}. Cost: ${spend}.`);
+    // THE MODEL DISCLOSURE LINE (D-4), immediately after the spend it explains.
+    // Rendered only when children did not run the main model, so the default
+    // report stays byte-identical (I-2) and a degraded request says WHICH mode
+    // was asked for and WHY it fell back rather than quietly renaming it.
+    const subagent = options.subagentModel;
+    if (subagent && subagent.effective !== 'main') {
+        lines.push(`Children ran on ${subagent.ref.providerId}:${subagent.ref.modelId} ` +
+            `(subagent model: ${subagent.effective}).`);
+    }
+    else if (subagent && subagent.fallbackReason) {
+        lines.push(`Subagent model ${subagent.mode} unavailable (${subagent.fallbackReason}); ` +
+            `children ran on the main model.`);
+    }
     for (const conflict of findFileConflicts(outcome.runs)) {
         const who = conflict.labels.map((l) => `"${l}"`).join(' and ');
         lines.push(`WARNING: agents ${who} both wrote ${conflict.path} - review before trusting either.`);

package/dist/team/subagent.js

@@ -18,6 +18,7 @@ import { createBuiltinTools } from '../tools/index.js';
 import { pickActivityArgs, sanitizeActivity } from './activity.js';
 import { TEAM_LIMITS, TEAM_SUBAGENT_TOOL_NAMES } from './limits.js';
 import { isRetryableStreamError } from './retry.js';
+import { resolveSubagentKey, resolveSubagentModel } from './model.js';
 import { makeTeamSend, makeTeamWait, withMailboxTail } from './comm-tools.js';
 import { buildSubagentBlock } from './prompt.js';
 /** The default factory: a real `Agent` from `@aragon-agent/core`. */
@@ -162,25 +163,34 @@ export function createSubagent(spec, deps, hooks) {
     let agentRef = null;
     const getAgent = () => agentRef;
     const tools = buildSubagentTools(spec, deps, getAgent);
-    // THE CHILD'S MODEL IS THE LEAD'S MODEL, READ FROM THE DISPATCH-TIME CONFIG
-    // (main-agent parity). Same provider, same model id, same base URL, same
-    // thinking level: a delegation is never a downgrade, and the only model a
-    // child may surprise its lead with is one a settings-screen edit made live
-    // between two dispatches.
+    // WHICH MODEL A CHILD RUNS IS A USER SETTING, RESOLVED FROM THE
+    // DISPATCH-TIME CONFIG through the one authority (subagent-model §3.4).
+    // `team.model: 'main'` - the default - is the historical main-agent parity
+    // exactly: same provider, model, base URL and thinking level as the lead.
+    // `'fast'` / `'profile'` are the user's explicit, visible, reversible cost
+    // switches, and EVERY failure mode (tier off, profile deleted, profile key
+    // missing) degrades back to the main connection with a disclosed reason
+    // rather than failing the dispatch (D-4). The MODEL itself still cannot
+    // choose: `normalizeSubagentSpecs` drops a stale `model` key (D-1).
     //
     // `maxTokens` inherits `deps.config.maxTokens` below - the same ambition the
-    // lead sends, clamped by the same adapter, so an inherited large value
-    // degrades to the right number rather than to an HTTP 400.
-    const resolved = {
-        ref: {
-            providerId: deps.config.provider,
-            modelId: deps.config.model,
-            ...(deps.config.baseUrl ? { baseUrl: deps.config.baseUrl } : {}),
-        },
-        thinkingLevel: deps.config.thinkingLevel,
-        role: 'main',
-    };
-    const model = resolved.ref;
+    // lead sends, clamped by Core's `resolveOutputTokens` against the CHILD
+    // model's own ceiling, so an inherited large value degrades to the right
+    // number rather than to an HTTP 400.
+    const resolution = resolveSubagentModel(deps.config, (id, role) => Boolean(deps.getApiKey(id, role)));
+    const model = resolution.ref;
+    // THE CHILD'S OWN KEY CLOSURE, PROFILE-AWARE (§3.3 / I-4). A bound profile's
+    // dedicated key is visible ONLY inside this closure - never in env, config
+    // `apiKeys` or a log line - while every other provider resolves through the
+    // lead's resolver at `resolution.keyRole`, which is what keeps a fast child
+    // entitled to the fast-role key and a main child to the main one.
+    const childGetApiKey = (id) => resolveSubagentKey(deps.config, resolution, id, (providerId, role) => deps.getApiKey(providerId, role));
+    // The boolean twin, for the child's compaction summarizer (V-4): the child's
+    // own resolution first, the lead layer by role second. Forwarding only
+    // `deps.getApiKey` would hide a profile-dedicated key from `resolveSummarizer`
+    // and silently disable the child's compaction - the exact gap the req-level
+    // resolvers on `ChildContextManagerRequest` exist to close.
+    const childHasKey = (id, role) => Boolean(childGetApiKey(id) ?? deps.getApiKey(id, role));
     // HOISTED TO A LOCAL, AND THAT IS WHAT MAKES W3 POSSIBLE AT ALL. This was built
     // INLINE inside the `agentFactory({...})` argument, so there was nothing for the
     // child manager's `getSystemPrompt` accessor to close over - and the accessor
@@ -216,7 +226,12 @@ export function createSubagent(spec, deps, hooks) {
     const contextManager = deps.contextManagerFor?.({
         label: spec.label,
         model,
-        role: resolved.role ?? 'main',
+        // keyRole (V-4): a fast child's summarizer resolves its main choice with
+        // role='fast', so a fast-only key is visible to it; profile keys reach it
+        // through the req-level resolvers below instead.
+        role: resolution.keyRole,
+        getApiKey: childGetApiKey,
+        hasKey: childHasKey,
         getMessages: () => agentRef?.state.messages ?? [],
         getSystemPrompt: () => systemPrompt,
         onCompacted: () => {
@@ -227,12 +242,13 @@ export function createSubagent(spec, deps, hooks) {
         systemPrompt,
         model,
         tools,
-        thinkingLevel: resolved.thinkingLevel,
+        thinkingLevel: resolution.thinkingLevel,
         // The LEAD's registry instance, REUSED (P2-2). It holds adapter state, and
         // constructing five of them per dispatch is pure waste.
         providerRegistry: deps.providerRegistry,
-        // The lead's closure, so a settings-screen key edit reaches children too.
-        getApiKey: (id) => deps.getApiKey(id, resolved.role ?? 'main'),
+        // The child's own profile-aware closure, so a settings-screen key edit
+        // reaches children too and a bound profile's key reaches ONLY them.
+        getApiKey: childGetApiKey,
         ...(deps.config.maxTokens !== undefined ? { maxTokens: deps.config.maxTokens } : {}),
         timeouts: {
             toolTimeout: deps.config.toolTimeoutMs,

package/dist/team/task-tool.d.ts

@@ -20,14 +20,17 @@
  * in the schema would behave differently depending on whether `ajv`, an OPTIONAL
  * dependency of core, happened to install.
  *
- * EVERY CHILD RUNS THE LEAD'S OWN MODEL (main-agent parity): same provider,
- * model, thinking level and token ambition, resolved from the LIVE config at
- * dispatch. There is no per-child `model` property and no cheap tier to pick -
- * a delegation is never a downgrade, and the fast tier reaches children the
- * same way it reaches the lead (compaction summaries, per-child reviews).
+ * WHICH MODEL A CHILD RUNS IS THE USER'S SETTING, NOT THE MODEL'S (D-1):
+ * `team.model` defaults to the lead's own connection (main-agent parity) and
+ * can name the fast tier or a profile; there is still no per-child `model`
+ * property, so a delegation is never a self-downgrade. Resolution lives in
+ * `team/model.ts` and is re-read from the LIVE config at every dispatch; the
+ * fast tier otherwise reaches children the way it reaches the lead
+ * (compaction summaries, per-child reviews).
  */
 import { type AgentTool } from '@aragon-agent/core';
 import type { ModelCost } from '@aragon-agent/core';
+import type { SubagentModelResolution } from './model.js';
 import type { TeamRuntime } from './runtime.js';
 export interface TaskToolDeps {
     runtime: TeamRuntime;
@@ -37,8 +40,24 @@ export interface TaskToolDeps {
     /** Whether a usable key exists for the active provider right now (P2-3). */
     hasApiKey: () => boolean;
     activeProvider: () => string;
-    /** The lead's cost table, so the report header states real spend (R-5). */
+    /**
+     * The cost table of the model children ACTUALLY run (subagent-model §3.4).
+     *
+     * The controller resolves `team.model` live and prices `modelCost` at the
+     * EFFECTIVE model's table: with the default `main` mode this is exactly the
+     * lead's own table, so the report's spend line is byte-identical to the
+     * parity behavior; with `fast` / `profile` it is that model's table, and an
+     * UNPRICED one yields `undefined` so the header says `pricing unknown`
+     * rather than fabricating `$0.00` (C-11 / RV-4).
+     */
     modelCost: () => ModelCost | undefined;
+    /**
+     * The dispatch-time subagent model resolution, for the report's disclosure
+     * line (D-4): rendered ONLY when children did not run the main model, and
+     * carrying the fallback reason when they could not. OPTIONAL so existing
+     * construction sites compile; absent simply omits the line.
+     */
+    subagentModel?: () => SubagentModelResolution;
     /**
      * The FAST tier's cost table, so the report's supervisor spend line states
      * real spend (subagent-overseer-v2 D-7 / R-P1-2). OPTIONAL and returning

package/dist/team/task-tool.js

@@ -20,11 +20,13 @@
  * in the schema would behave differently depending on whether `ajv`, an OPTIONAL
  * dependency of core, happened to install.
  *
- * EVERY CHILD RUNS THE LEAD'S OWN MODEL (main-agent parity): same provider,
- * model, thinking level and token ambition, resolved from the LIVE config at
- * dispatch. There is no per-child `model` property and no cheap tier to pick -
- * a delegation is never a downgrade, and the fast tier reaches children the
- * same way it reaches the lead (compaction summaries, per-child reviews).
+ * WHICH MODEL A CHILD RUNS IS THE USER'S SETTING, NOT THE MODEL'S (D-1):
+ * `team.model` defaults to the lead's own connection (main-agent parity) and
+ * can name the fast tier or a profile; there is still no per-child `model`
+ * property, so a delegation is never a self-downgrade. Resolution lives in
+ * `team/model.ts` and is re-read from the LIVE config at every dispatch; the
+ * fast tier otherwise reaches children the way it reaches the lead
+ * (compaction summaries, per-child reviews).
  */
 import { errorResult, textResult } from '@aragon-agent/core';
 import { TEAM_LIMITS } from './limits.js';
@@ -39,8 +41,9 @@ const TEAM_OFF_REFUSAL = 'Team mode is off for this session. Do this work yourse
  */
 const TASK_DESCRIPTION = 'Run several independent subagents in parallel and get one combined report. Each ' +
     'subagent is a fresh agent with the same tools and working directory but NO memory of ' +
-    'this conversation - its prompt must be self-contained. Each runs on the same model ' +
-    'you are running on. Use this when a task splits ' +
+    'this conversation - its prompt must be self-contained. Each runs on the model the ' +
+    'user configured for subagents (the main model by default). Use this when a task ' +
+    'splits ' +
     'into 2 or more parts that do not depend on each other\'s output, especially reading or ' +
     'searching several areas at once. Do NOT use it when one part needs another part\'s ' +
     'result (do those yourself, in order), when two parts would edit the same file, or for ' +
@@ -120,13 +123,16 @@ export function createTaskTool(deps) {
             //    A cancellation or a partial result rendered as a tool FAILURE invites
             //    the model to retry the whole fan-out, which is the most expensive
             //    possible reaction (the same reasoning as `ask_user`'s cancelled
-            //    shape, and D-14 one level up). Every child ran the lead's own model,
-            //    so the lead's cost table is the one honest price for the total.
+            //    shape, and D-14 one level up). `modelCost` is priced at the model
+            //    children ACTUALLY ran - the lead's own table under the default
+            //    `main` mode - so the total stays one honest price.
             const cost = deps.modelCost();
             const fastCost = deps.fastModelCost?.();
+            const subagentModel = deps.subagentModel?.();
             return textResult(buildDispatchReport(outcome, {
                 ...(cost ? { cost } : {}),
                 ...(fastCost ? { fastCost } : {}),
+                ...(subagentModel ? { subagentModel } : {}),
             }));
         },
     };

package/dist/todo/types.d.ts

@@ -42,9 +42,11 @@ export interface TodoSnapshot {
 /**
  * Why a list went away.
  *
- *   `user`  - `/todo clear`, or `/clear`. Both are an explicit user instruction,
- *             which is I-2's standing exception; neither touches `messages`.
- *   `reset` - `/reset`, or a `/resume` whose file carried no list (§3.13).
+ *   `user`  - `/todo clear`, or `/clear screen` (the screen-only form). Both are
+ *             an explicit user instruction, which is I-2's standing exception;
+ *             neither touches `messages`.
+ *   `reset` - `/clear` (or its alias `/reset`) through `clearMessages()`, or a
+ *             `/resume` whose file carried no list (§3.13).
  *   `turn`  - a new TUI task started, or a legacy caller began a turn after
  *             every item was completed.
  *   `stale` - unfinished, and unwritten for more than `TODO_LIMITS.staleTurns`

package/dist/ui/App.js

@@ -55,6 +55,7 @@ import { publishExitSnapshot } from './exit-snapshot.js';
 import { OverlayFrame } from './layout/OverlayFrame.js';
 import { helpRows } from './overlays/HelpOverlay.js';
 import { ModelPicker } from './overlays/ModelPicker.js';
+import { createModelProbe } from '../agent/model-probe.js';
 import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, } from './overlays/SettingsScreen.js';
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
 import { QuestionOverlay } from './overlays/QuestionOverlay.js';
@@ -1388,6 +1389,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         requestCopy: copyCoordinator.requestCopy,
         controller,
         state: stateRef.current,
+        // THE ARCHIVE'S ONLY WAY TO SEE THE SCREEN (P0-1 / §3.7), and a thunk for a
+        // reason `state` above illustrates: `state` is a snapshot of this render,
+        // while `/clear` interrupts a run and then waits for it to unwind, so the last
+        // tool cards of the abandoned run are appended AFTER the command starts. A
+        // value here would archive the screen minus the part the user was watching.
+        transcriptEntries: () => stateRef.current.entries,
         dispatch: (action) => {
             if (action.type === 'resetConversation' || action.type === 'restoreEntries') {
                 metrics.current = createRunMetrics();
@@ -1535,12 +1542,25 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     };
     submitRef.current = submitMessage;
     const executeSlashInput = async (raw) => {
-        const switchWhileBusy = controller.isCompactionBusy?.()
-            && /^\s*\/(clear|reset|resume)(?:\s|$)/.test(raw);
-        if (switchWhileBusy) {
+        // A CONVERSATION SWITCH OWNS THE QUEUE FOR THE WHOLE COMMAND (B-6 / §3.7).
+        //
+        // The guard used to be raised only when a compaction happened to be busy,
+        // which left the one window this feature is about unwatched: `/clear` on an
+        // IDLE session took the flag nowhere, and `drainCompactionQueue` was still
+        // free to `continue()` a message queued in the previous conversation into
+        // the one the user had just started. Whether there is work to cancel is a
+        // separate question, so the two are now separate values: `switching` decides
+        // the lock, `switchWhileBusy` decides the cancellation.
+        //
+        // `/resume` is still refused mid-run by `handleSubmit` below, so for it the
+        // lock only ever matters while idle - that is the minimum this invariant
+        // asks for, not a contradiction.
+        const switching = /^\s*\/(clear|reset|resume)(?:\s|$)/.test(raw);
+        const switchWhileBusy = switching && Boolean(controller.isCompactionBusy?.());
+        if (switching)
             switchingConversation.current = true;
+        if (switchWhileBusy)
             await controller.cancelCompaction();
-        }
         // Retain a recoverable command before any asynchronous handler can fail.
         const safe = redactText(raw, getSecrets());
         recordPrompt(safe);
@@ -1553,7 +1573,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             notify('error', `Command failed: ${redactText(reason, getSecrets())}\nInput: ${safe}`);
         }
         finally {
-            if (switchWhileBusy) {
+            if (switching) {
                 switchingConversation.current = false;
                 drainCompactionQueue.current();
             }
@@ -1563,7 +1583,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         const trimmed = raw.trimStart();
         const slash = trimmed.startsWith('/') && !trimmed.startsWith('//');
         if (slash && (interactionPhase.current === 'running' || controller.isRunning()) &&
-            /^\/(reset|resume)(?:\s|$)/.test(trimmed)) {
+            /^\/resume(?:\s|$)/.test(trimmed)) {
             return { accepted: false,
                 reason: 'Interrupt the current run before switching conversations.' };
         }
@@ -2050,6 +2070,18 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const overlay = state.overlay;
     const settingsDraft = useMemo(() => overlay === 'settings'
         ? controller.createModelSettingsDraft() : undefined, [controller, overlay]);
+    // ONE PROBE PER APP (model-profile-connection-test 5 row 9): the port needs the
+    // controller's provider registry, which the overlay has no business owning.
+    // Built only while the settings overlay is open, so no other screen pays for it.
+    const probe = useMemo(() => {
+        if (overlay !== 'settings')
+            return undefined;
+        // A test double or an embedded host may predate this port; absent means the
+        // two probe rows read `(unavailable)` rather than the screen crashing.
+        if (typeof controller.getProviderRegistry !== 'function')
+            return undefined;
+        return createModelProbe({ registry: controller.getProviderRegistry() });
+    }, [controller, overlay]);
     const hasKey = controller.hasApiKey();
     const empty = state.entries.length === 0;
     // RENDER SCOPE, so the chip and the composer hint agree with what the Ctrl+C
@@ -2144,13 +2176,18 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // `auto`, not an empty string: an empty field reads as "unset", which
             // is indistinguishable from AUTO and is not a state this can be in.
             maxTokens: cfg.maxTokens ? String(cfg.maxTokens) : 'auto',
+            // BOTH HALVES, seeded AND read back (§6.3): the sibling comment above
+            // records what omitting either one costs. `auto` mirrors the row's
+            // empty-field reading; a bound Main profile hides the row entirely
+            // and the profile editor seeds from the entry instead.
+            contextWindow: cfg.contextWindow === null ? 'auto' : String(cfg.contextWindow),
             apiKey: '',
             logLevel: cfg.log.level,
             // The four fast rows, seeded through the pure mapper so the screen and
             // the save handler cannot disagree about what `(inherit)` means.
             ...fastSettingsFrom(cfg.fast),
             ...compactionSettingsFrom(cfg.compaction),
-        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, draft: settingsDraft, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
+        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, draft: settingsDraft, probe: probe, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
         // Read from `cfg` (render scope, re-read every frame), so `/retry off`
         // while the screen is open shows the new value on the next paint.
         retrySummary: cfg.retry.enabled && cfg.retry.maxRetries > 0 ? String(cfg.retry.maxRetries) : 'off' })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { isActive: !tooSmall, state: confirmState, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { isActive: !tooSmall, questions: humanRequest.questions, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }) })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { isActive: !tooSmall, plan: humanRequest.plan, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;

package/dist/ui/entries/CompactionCard.d.ts

@@ -14,10 +14,11 @@
  * kind — without it the card renders a hint that does nothing and expands an
  * older tool card instead (C-15 / P1-8 / AC-21).
  *
- * EVERY STRING DESCRIBES THE HISTORY, NEVER THE SCREEN (§6.4 / P2-9). `/clear`
- * empties the transcript view but not `messages`, so this card can legitimately
- * report "112 -> 9 messages" with nine visible rows above it. Nothing here says
- * "above" or "earlier in this transcript".
+ * EVERY STRING DESCRIBES THE HISTORY, NEVER THE SCREEN (§6.4 / P2-9).
+ * `/clear screen` empties the transcript view but not `messages`, so this card
+ * can legitimately report a message count the visible rows do not add up to.
+ * Nothing here says "above" or "earlier in this transcript". `/clear` itself is
+ * the conversation boundary now: it drops the history and this card with it.
  */
 import React from 'react';
 import type { Theme } from '../theme.js';

package/dist/ui/entries/CompactionCard.js

@@ -15,10 +15,11 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
  * kind — without it the card renders a hint that does nothing and expands an
  * older tool card instead (C-15 / P1-8 / AC-21).
  *
- * EVERY STRING DESCRIBES THE HISTORY, NEVER THE SCREEN (§6.4 / P2-9). `/clear`
- * empties the transcript view but not `messages`, so this card can legitimately
- * report "112 -> 9 messages" with nine visible rows above it. Nothing here says
- * "above" or "earlier in this transcript".
+ * EVERY STRING DESCRIBES THE HISTORY, NEVER THE SCREEN (§6.4 / P2-9).
+ * `/clear screen` empties the transcript view but not `messages`, so this card
+ * can legitimately report a message count the visible rows do not add up to.
+ * Nothing here says "above" or "earlier in this transcript". `/clear` itself is
+ * the conversation boundary now: it drops the history and this card with it.
  */
 import React from 'react';
 import { Box, Text } from 'ink';