@aragon-agent/cli 0.6.16 → 0.6.17

package/dist/team/runtime.js

@@ -65,10 +65,7 @@ export class TeamRuntime {
     // -------------------------------------------------------------------------
     // Dispatch
     // -------------------------------------------------------------------------
-    async dispatch(specs, requested, signal, 
-    /** Carried through from the normalizer so the report can state it (§3.4 /
-     *  R-6). Optional, so every existing caller compiles unchanged. */
-    extra = {}) {
+    async dispatch(specs, requested, signal) {
         this.counter += 1;
         const dispatchId = `d${this.counter}`;
         const config = this.deps.getConfig();
@@ -131,7 +128,7 @@ export class TeamRuntime {
             confirmTools: config.confirmTools,
             ...(this.deps.humanQueue ? { humanQueue: this.deps.humanQueue } : {}),
             agentFactory: this.deps.agentFactory ?? defaultSubagentFactory,
-            ...(this.deps.resolveTier ? { resolveTier: this.deps.resolveTier } : {}),
+            ...(this.deps.review ? { review: this.deps.review } : {}),
             // Site two of two, and the omission is silent in the same way the policy
             // one above is: declaring it on `TeamRuntimeDeps` and forgetting this line
             // type-checks and forwards nothing, so every child would quietly run with
@@ -147,11 +144,7 @@ export class TeamRuntime {
         // show the child its brief twice.
         const makeHandle = (spec) => createSubagent(spec, subDeps, {
             onUpdate: (run) => this.publish(dispatchId, run),
-            // `tier` rides along so `App.tsx` can pick the RIGHT cost table for this
-            // event rather than always using the lead's (§3.6 / R-7). Taken from the
-            // SPEC, which the normalizer already downgraded when the tier was
-            // unavailable, so it names the model that actually billed.
-            onUsage: (label, usage) => this.emit({ type: 'usage', dispatchId, label, usage, tier: spec.tier }),
+            onUsage: (label, usage) => this.emit({ type: 'usage', dispatchId, label, usage }),
         });
         // ASSIGNMENT, not a declaration: a `const` here would shadow the `let` above
         // the bus, `canSend` would see the empty array forever, and every peer would
@@ -179,7 +172,15 @@ export class TeamRuntime {
         // so the override only bites because `task` listens to `ctx.signal` — and a
         // second, independent timer means a signal that never arrives still ends the
         // dispatch.
-        this.dispatchTimer = setTimeout(() => this.abortAll(), team.dispatchTimeoutMs);
+        //
+        // `0` MEANS NO CEILING (main-agent parity): the dispatch lasts as long as
+        // its slowest child and only an Esc ends it early. The lead's idle
+        // watchdog is paused for the whole dispatch either way, exactly as it is
+        // for the lead's own long turns.
+        this.dispatchTimer =
+            team.dispatchTimeoutMs > 0
+                ? setTimeout(() => this.abortAll(), team.dispatchTimeoutMs)
+                : null;
         const runCtx = {
             dispatchId,
             handles,
@@ -195,24 +196,13 @@ export class TeamRuntime {
         signal?.removeEventListener('abort', onAbort);
         for (const handle of handles)
             handle.unsubscribe();
-        // SUMMED PER TIER (fast-model-tier §3.4 / R-7). One total priced at the
-        // lead's table would over-report a Haiku child under a Sonnet lead by
-        // roughly an order of magnitude — and the whole justification for delegating
-        // to a cheaper model is a number in the report this feeds.
-        // `main` IS THE COMPLEMENT OF `fast`, not an equality test. `SubagentRun.tier`
-        // is populated by `createSubagent` from the spec, but a hand-built run in a
-        // test — or a run restored from a session file written before this field
-        // existed — has it `undefined`, and `=== 'main'` would silently drop that
-        // child's spend from the total. Under-reporting is the one failure this
-        // split exists to prevent, so the default direction has to be "counted".
-        const sumTier = (tier) => handles
-            .filter((h) => (tier === 'fast' ? h.run.tier === 'fast' : h.run.tier !== 'fast'))
-            .reduce((acc, h) => ({
+        // ONE TOTAL, AT THE LEAD'S TABLE. Every child runs the lead's own model
+        // (main-agent parity), so there is exactly one tier to sum and one price to
+        // sum it at; a split would be two answers to one question.
+        const usage = handles.reduce((acc, h) => ({
             inputTokens: acc.inputTokens + h.run.usage.inputTokens,
             outputTokens: acc.outputTokens + h.run.usage.outputTokens,
         }), { inputTokens: 0, outputTokens: 0 });
-        const fastUsage = sumTier('fast');
-        const ranFast = handles.some((h) => h.run.tier === 'fast');
         const outcome = {
             dispatchId,
             runs: handles.map((h) => ({ ...h.run, filesTouched: [...h.run.filesTouched] })),
@@ -221,11 +211,7 @@ export class TeamRuntime {
             endedAt: Date.now(),
             aborted: this.aborted,
             leadMail: bus.leadMail(),
-            usage: sumTier('main'),
-            // ABSENT when no fast child ran, which is what keeps a default session's
-            // outcome shape byte-identical to the pre-feature one.
-            ...(ranFast ? { fastUsage } : {}),
-            ...(extra.downgraded ? { downgraded: extra.downgraded } : {}),
+            usage,
         };
         this.live = [];
         this.bus = null;
@@ -262,14 +248,23 @@ export class TeamRuntime {
         for (let attempt = 0;; attempt += 1) {
             const handle = handles[index];
             const { run, agent } = handle;
+            // ABORTS GO THROUGH THE HANDLE (never `agent.abort()` directly): the
+            // handle sets the synchronous `abortRequested` flag the child's fast
+            // reviewer reads as its never-steer-into-a-requested-abort fact.
             run.phase = 'starting';
             run.startedAt = Date.now();
             this.publish(dispatchId, run);
+            // `subagentTimeoutMs: 0` MEANS NO CEILING (main-agent parity): no timer
+            // is armed and `timedOut` can never become true. A wedged child is still
+            // ended by its OWN idle watchdog, which is the exact ceiling the lead
+            // runs under.
             let timedOut = false;
-            const timer = setTimeout(() => {
-                timedOut = true;
-                agent.abort();
-            }, subagentTimeoutMs);
+            const timer = subagentTimeoutMs > 0
+                ? setTimeout(() => {
+                    timedOut = true;
+                    handle.abort();
+                }, subagentTimeoutMs)
+                : null;
             try {
                 await agent.prompt(handle.spec.prompt);
             }
@@ -281,7 +276,8 @@ export class TeamRuntime {
                 run.error = err instanceof Error ? err.message : String(err);
             }
             finally {
-                clearTimeout(timer);
+                if (timer)
+                    clearTimeout(timer);
             }
             // THE TWO ABORT EXCLUSIONS THAT MAKE THE PREDICATE SAFE. Every abort in
             // this system reaches the provider as an aborted fetch, and `core` marks
@@ -319,7 +315,7 @@ export class TeamRuntime {
         const retries = (handle.run.retries ?? 0) + 1;
         handle.unsubscribe();
         try {
-            handle.agent.abort();
+            handle.abort();
         }
         catch {
             // Already gone; this must not stop the retry.
@@ -346,7 +342,7 @@ export class TeamRuntime {
         if (this.aborted) {
             run.phase = 'aborted';
         }
-        else if (timedOut) {
+        else if (timedOut && subagentTimeoutMs > 0) {
             run.phase = 'failed';
             run.error = run.error ?? `subagent exceeded ${Math.round(subagentTimeoutMs / 1000)}s`;
         }
@@ -398,7 +394,7 @@ export class TeamRuntime {
         this.aborted = true;
         for (const handle of this.live) {
             try {
-                handle.agent.abort();
+                handle.abort();
             }
             catch {
                 // A child that is already gone must not stop the others being aborted.

package/dist/team/subagent.d.ts

@@ -11,12 +11,12 @@
  * omission has a reason that is a correctness boundary rather than caution.
  */
 import type { ModelRole } from '../config/model-profiles.js';
-import { type AgentConfig, type AgentEvent, type AgentTool, type Message, type ModelRef, type ProviderRegistry, type SkillRegistry, type ThinkingLevel, type TokenUsage, type ToolPolicyDecision, type ToolPolicyVerdict } from '@aragon-agent/core';
+import { type AgentConfig, type AgentEvent, type AgentTool, type Message, type ProviderRegistry, type SkillRegistry, type TokenUsage, type ToolPolicyDecision, type ToolPolicyVerdict } from '@aragon-agent/core';
 import type { AgentMode } from '../agent/agent-mode.js';
 import type { ChildContextManagerProvider } from '../compaction/child.js';
 import type { CliConfig } from '../config/schema.js';
 import type { ToolPermission } from '../exec/permission.js';
-import type { FastTierName } from '../fast/types.js';
+import type { ChildReviewProvider } from './child-reviewer.js';
 import { TeamBus } from './bus.js';
 import type { TeamHumanQueue, WatchdogPausable } from './human-queue.js';
 import type { SubagentRun, SubagentSpec } from './types.js';
@@ -31,6 +31,10 @@ export interface SubagentAgentLike extends WatchdogPausable {
     prompt(text: string): Promise<void>;
     abort(): void;
     subscribe(listener: (event: AgentEvent) => void): () => void;
+    /** Steering surface for the child's own fast reviewer (core `Agent.steer`). */
+    steer(text: string): void;
+    /** Queued-block hygiene on abort, again mirroring the lead (D-21). */
+    clearAllQueues(): void;
     /**
      * The child's live history, for its own context manager
      * (context-auto-compaction-hardening §3.4.3 / W3).
@@ -95,23 +99,11 @@ export interface SubagentDeps {
     humanQueue?: TeamHumanQueue;
     agentFactory: SubagentAgentFactory;
     /**
-     * Which model and thinking level a tier runs on (fast-model-tier §3.4).
-     *
-     * OPTIONAL, defaulting to the session's own model, so every existing caller
-     * and test compiles unchanged and a `--no-fast` session builds children
-     * exactly as it always did.
-     *
-     * `resolveTier('fast')` RETURNS THE MAIN TIER when the fast tier is not
-     * available, which is what makes the two guards agree BY CONSTRUCTION: the
-     * normalizer can never produce a `tier: 'fast'` spec this factory would
-     * refuse, and this factory can never build a child against a `ModelRef` the
-     * tier stopped resolving twenty minutes ago (RV-3 / R-14).
+     * Per-child fast review (main-agent parity): the controller's shared
+     * provider, built on the lead's `FastWiring`. ABSENT means the session
+     * has no fast wiring, and the child is then exactly what it always was.
      */
-    resolveTier?: (tier: FastTierName) => {
-        ref: ModelRef;
-        thinkingLevel: ThinkingLevel;
-        role?: ModelRole;
-    };
+    review?: ChildReviewProvider;
     /**
      * Build this child its own context manager
      * (context-auto-compaction-hardening §3.4.3 / W3).
@@ -134,6 +126,14 @@ export interface SubagentHandle {
     run: SubagentRun;
     agent: SubagentAgentLike;
     tools: AgentTool[];
+    /**
+     * THE HANDLE-LEVEL ABORT, and the only one `TeamRuntime` may call. It sets a
+     * synchronous `abortRequested` flag BEFORE `agent.abort()`, which is what the
+     * child's fast reviewer reads as its guard-1 fact: an Esc or a dispatch stop
+     * must be visible to the reviewer in the same tick it happens, or the
+     * reviewer steers a `<fast_review>` block into a run that is already dying.
+     */
+    abort: () => void;
     unsubscribe: () => void;
 }
 /**

package/dist/team/subagent.js

@@ -13,6 +13,7 @@
 import { Agent, createSkillFindTool, } from '@aragon-agent/core';
 import { formatStreamError } from '../agent/reducer.js';
 import { buildSystemPrompt } from '../agent/system-prompt.js';
+import { buildFastBlock } from '../fast/prompt.js';
 import { createBuiltinTools } from '../tools/index.js';
 import { pickActivityArgs, sanitizeActivity } from './activity.js';
 import { TEAM_LIMITS, TEAM_SUBAGENT_TOOL_NAMES } from './limits.js';
@@ -40,11 +41,17 @@ function assistantText(message) {
  * the security boundary here, so it has to be directly checkable.
  */
 export function buildSubagentTools(spec, deps, getAgent) {
+    // `team_wait`'s ceiling is the STRUCTURAL clamp when the child itself has no
+    // wall clock (`subagentTimeoutMs: 0`): a peer wait must stay bounded even when
+    // the child's run is not, or one forgotten wait would hold a slot forever.
+    const subagentTimeoutMs = deps.config.team.subagentTimeoutMs;
     const commTools = [
         makeTeamSend(deps.bus, spec.label),
         makeTeamWait(deps.bus, spec.label, {
             getAgent,
-            maxWaitMs: deps.config.team.subagentTimeoutMs,
+            maxWaitMs: subagentTimeoutMs > 0
+                ? subagentTimeoutMs
+                : TEAM_LIMITS.waitMaxSeconds * 1000,
         }),
     ];
     const tools = createBuiltinTools({
@@ -141,9 +148,6 @@ export function createSubagent(spec, deps, hooks) {
     const run = {
         label: spec.label,
         description: spec.description,
-        // FROM THE SPEC, which the normalizer already downgraded when the tier was
-        // unavailable — so this is what RAN, not what was asked for (§3.4).
-        tier: spec.tier,
         phase: 'queued',
         turns: 0,
         toolCalls: 0,
@@ -158,37 +162,38 @@ export function createSubagent(spec, deps, hooks) {
     let agentRef = null;
     const getAgent = () => agentRef;
     const tools = buildSubagentTools(spec, deps, getAgent);
-    // THE TWO HARDCODED CONFIG READS THAT USED TO LIVE HERE NOW ROUTE THROUGH ONE
-    // RESOLVER (fast-model-tier §3.4). The fallback reproduces them exactly, so a
-    // caller that passes no `resolveTier` builds a byte-identical child.
+    // 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.
     //
-    // `thinkingLevel` is PER TIER and defaults to `'off'` for the fast tier
-    // (D-13): a "fast" model asked to think for 32 768 tokens is not fast, and
-    // inheriting the session's `xhigh` into a mechanical file-scan child would be
-    // the most expensive possible reading of the word.
-    //
-    // `maxTokens` is deliberately NOT per tier (RV-15). A child inherits
-    // `deps.config.maxTokens` below, which is an ambition sized for the main
-    // model; the adapter clamps it down to whatever the fast model actually
-    // accepts (`llm/provider.ts:44-52`), so a large inherited value degrades to
-    // the right number rather than to an HTTP 400.
-    const resolved = deps.resolveTier
-        ? deps.resolveTier(spec.tier)
-        : {
-            ref: {
-                providerId: deps.config.provider,
-                modelId: deps.config.model,
-                ...(deps.config.baseUrl ? { baseUrl: deps.config.baseUrl } : {}),
-            },
-            thinkingLevel: deps.config.thinkingLevel,
-            role: 'main',
-        };
+    // `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;
     // 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
     // cannot read it back off the agent, because `SubagentAgentLike` is narrowed to
     // `state.messages` on purpose.
+    // THE SAME `<fast_tier>` BLOCK THE LEAD GETS, spliced only when this child
+    // will actually have a reviewer. The gating expression is written against
+    // `deps.review` here and the reviewer is built from the SAME predicate
+    // below, so the prompt can never advertise a capability the child lacks -
+    // and a child with a reviewer is never surprised by its first injection.
+    const fastBlock = deps.review !== undefined && deps.review.active()
+        ? buildFastBlock({ model: deps.review.modelId(), review: true })
+        : '';
     const systemPrompt = buildSystemPrompt({
         cwd: deps.getCwd(),
         tools,
@@ -203,6 +208,7 @@ export function createSubagent(spec, deps, hooks) {
             description: spec.description,
             peers: deps.bus.peersOf(spec.label),
         }),
+        ...(fastBlock ? { fastBlock } : {}),
     });
     // LAZY ACCESSORS OVER `agentRef`, WHICH IS ASSIGNED AFTER THIS RETURNS. A
     // non-lazy read here is `undefined` at construction and the child's estimate
@@ -244,6 +250,27 @@ export function createSubagent(spec, deps, hooks) {
         ...(contextManager ? { contextManager } : {}),
     });
     agentRef = agent;
+    // PER-CHILD FAST REVIEW (main-agent parity). GATED ON THE PROVIDER'S OWN
+    // LIVE PREDICATE, read once here so the prompt and the reviewer CANNOT
+    // DISAGREE about whether the child has one: a child told about
+    // `<fast_review>` blocks must be a child that actually receives them, and a
+    // child with a reviewer must have been told. `abortRequested` is the flag
+    // `handle.abort()` sets (see `SubagentHandle`); the reviewer reads it as its
+    // never-steer-into-a-requested-abort fact.
+    let abortRequested = false;
+    const reviewLive = deps.review !== undefined && deps.review.active() === true;
+    const reviewer = reviewLive
+        ? deps.review?.create({
+            label: spec.label,
+            goal: spec.description,
+            agent,
+            isRunning: () => run.phase === 'starting' ||
+                run.phase === 'thinking' ||
+                run.phase === 'tool' ||
+                run.phase === 'waiting',
+            isAbortRequested: () => abortRequested,
+        })
+        : undefined;
     let lastEmit = 0;
     let lastPhase = run.phase;
     /**
@@ -325,8 +352,16 @@ export function createSubagent(spec, deps, hooks) {
                 // an aborted run, which the report renders as partial rather than lost.
                 if (text.length > 0)
                     run.summary = text;
-                if (run.turns >= deps.config.team.maxTurnsPerSubagent) {
+                // `0` MEANS NO CAP (main-agent parity): the lead has no turn ceiling
+                // either, and a child that needs forty turns for a forty-turn job is
+                // not runaway - it is working.
+                const turnCap = deps.config.team.maxTurnsPerSubagent;
+                if (turnCap > 0 && run.turns >= turnCap) {
                     run.truncated = true;
+                    // THE FLAG FIRST, exactly like `handle.abort()`: the child's
+                    // reviewer reads `abortRequested` as its guard-1 fact, and a
+                    // turn-cap stop must be visible to it in the same tick.
+                    abortRequested = true;
                     agent.abort();
                 }
                 break;
@@ -404,5 +439,20 @@ export function createSubagent(spec, deps, hooks) {
         }
         emit();
     });
-    return { spec, run, agent, tools, unsubscribe };
+    return {
+        spec,
+        run,
+        agent,
+        tools,
+        // THE HANDLE-LEVEL ABORT (see `SubagentHandle`): the flag first, then the
+        // agent, so the reviewer's guard observes the request in the same tick.
+        abort: () => {
+            abortRequested = true;
+            agent.abort();
+        },
+        unsubscribe: () => {
+            reviewer?.dispose();
+            unsubscribe();
+        },
+    };
 }

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

@@ -19,6 +19,12 @@
  * `normalizeSubagentSpecs`, which is deterministic and unit-tested. `maxItems`
  * 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).
  */
 import { type AgentTool } from '@aragon-agent/core';
 import type { ModelCost } from '@aragon-agent/core';
@@ -27,38 +33,12 @@ export interface TaskToolDeps {
     runtime: TeamRuntime;
     /** Read LIVE, never cached: `/team off` flips this, it does not unregister. */
     isTeamEnabled: () => boolean;
-    /**
-     * Whether the fast tier was resolvable AT CONSTRUCTION (fast-model-tier §3.3 /
-     * C-2).
-     *
-     * DECIDED ONCE, because the tool array is built once and must never be
-     * rebuilt: `Agent.setTools()` mutates the live `ToolRegistry`, and
-     * `submit_plan` flips the session mode from INSIDE a tool execution. So the
-     * `model` property either exists in this schema for the whole session or never
-     * does — and with it absent, `TASK_DESCRIPTION` and the schema are
-     * BYTE-IDENTICAL to the pre-feature build (AC-3).
-     *
-     * Optional so every existing construction site and test compiles unchanged.
-     */
-    fastRegistered?: boolean;
-    /**
-     * Whether `model:"fast"` is honoured RIGHT NOW. Read LIVE, at dispatch time
-     * (RV-3) — the tier can stop resolving mid-session, and a downgrade is the
-     * honest observable either way.
-     */
-    fastAvailable?: () => boolean;
     maxSubagents: () => number;
     /** 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). */
     modelCost: () => ModelCost | undefined;
-    /** The FAST model's cost table (fast-model-tier §3.4). Absent when the tier is
-     *  off, which is what leaves the report byte-identical. */
-    fastModelCost?: () => ModelCost | undefined;
-    /** Whether the static price table has never heard of the fast model (C-11 /
-     *  RV-4). `unknown` is rendered as unknown, NEVER as `$0.00`. */
-    fastPricingUnknown?: () => boolean;
     /**
      * Run the dispatch with the LEAD's idle watchdog paused, `try/finally` inside.
      *

package/dist/team/task-tool.js

@@ -19,6 +19,12 @@
  * `normalizeSubagentSpecs`, which is deterministic and unit-tested. `maxItems`
  * 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).
  */
 import { errorResult, textResult } from '@aragon-agent/core';
 import { TEAM_LIMITS } from './limits.js';
@@ -33,7 +39,8 @@ 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. Use this when a task splits ' +
+    'this conversation - its prompt must be self-contained. Each runs on the same model ' +
+    'you are running on. 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 ' +
@@ -41,37 +48,11 @@ const TASK_DESCRIPTION = 'Run several independent subagents in parallel and get
     'cannot ask the user anything. Give each a description of at most ' +
     `${TEAM_LIMITS.descriptionChars} characters and a complete prompt. Extra entries beyond the ` +
     'configured maximum are dropped, so keep within it.';
-/**
- * The one sentence appended when the fast tier exists (fast-model-tier §4.1).
- *
- * WHEN to use a tier is POLICY and lives here and in `<fast_tier>`, where the
- * model actually reads it; the `enum` below is SHAPE and lives in the schema.
- * That split is what keeps behaviour the same whether or not `ajv` — an OPTIONAL
- * dependency of core — happened to install (C-8).
- */
-const TASK_FAST_SENTENCE = ' Set model:"fast" on a subagent whose job is bulk reading, searching or summarizing; ' +
-    'leave it out for work that needs judgement.';
-/**
- * NOT `as const`: `AgentTool.parameters` is a `JSONSchema7`, whose `enum` is a
- * MUTABLE `unknown[]`, and a readonly tuple is not assignable to it.
- */
-const SUBAGENT_MODEL_PROPERTY = {
-    type: 'string',
-    enum: ['main', 'fast'],
-    default: 'main',
-    description: 'Which tier runs this subagent. "fast" is a cheaper, quicker model - use it for ' +
-        'mechanical, high-volume work (reading or searching many files, summarizing long ' +
-        'output, mechanical edits). Keep "main" for design, tricky debugging, and anything ' +
-        'that must be right the first time.',
-};
 export function createTaskTool(deps) {
-    const fastRegistered = deps.fastRegistered === true;
     return {
         name: 'task',
         label: 'Dispatch subagents',
-        // BYTE-IDENTICAL WITHOUT THE TIER (AC-3): concatenation is conditional, so a
-        // default session's description is the exact string it always was.
-        description: fastRegistered ? `${TASK_DESCRIPTION}${TASK_FAST_SENTENCE}` : TASK_DESCRIPTION,
+        description: TASK_DESCRIPTION,
         parameters: {
             type: 'object',
             properties: {
@@ -99,11 +80,6 @@ export function createTaskTool(deps) {
                                 default: false,
                                 description: 'Refuse all writes and shell for this subagent.',
                             },
-                            // Spread rather than a `?:` property, so with the tier off the
-                            // object has exactly the four keys it always had — `undefined`
-                            // survives `JSON.stringify` as an absent key but not as an
-                            // identical object, and AC-3 is asserted on the schema itself.
-                            ...(fastRegistered ? { model: SUBAGENT_MODEL_PROPERTY } : {}),
                         },
                         required: ['description', 'prompt'],
                     },
@@ -131,31 +107,21 @@ export function createTaskTool(deps) {
                     'yourself, or ask the user to set a key.');
             }
             // 4. Repair, never reject. Zero survivors is the single hard failure.
-            //    `fastAvailable` is read HERE, at dispatch time, not captured at
-            //    construction (RV-3): the tier can stop resolving mid-session, and the
-            //    normalizer and the subagent factory must agree about that at the same
-            //    instant or a child gets built against a provider with no key.
-            const { specs, requested, downgraded } = normalizeSubagentSpecs(params.subagents, deps.maxSubagents(), { fastAvailable: deps.fastAvailable?.() === true });
+            const { specs, requested } = normalizeSubagentSpecs(params.subagents, deps.maxSubagents());
             if (specs.length === 0) {
                 return errorResult('No usable subagent specs: each needs a description and a prompt.');
             }
             // 5. Pause the lead's watchdog for the whole dispatch (I-3).
-            const outcome = await deps.withPausedWatchdog(() => deps.runtime.dispatch(specs, requested, ctx.signal, { downgraded }));
+            const outcome = await deps.withPausedWatchdog(() => deps.runtime.dispatch(specs, requested, ctx.signal));
             // 6. ALWAYS A NON-ERROR RESULT, abort and all-children-failed included.
             //    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).
-            //    TWO COST TABLES (§3.4 / R-7). Summing fast-tier tokens at the lead's
-            //    price is not a rounding error: for a Haiku child under a Sonnet lead
-            //    it over-reports by roughly an order of magnitude, and the whole
-            //    justification for the feature is a number in this report.
+            //    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.
             const cost = deps.modelCost();
-            const fastCost = deps.fastModelCost?.();
             return textResult(buildDispatchReport(outcome, {
                 ...(cost ? { cost } : {}),
-                ...(fastCost ? { fastCost } : {}),
-                ...(deps.fastPricingUnknown?.() ? { fastPricingUnknown: true } : {}),
             }));
         },
     };

package/dist/team/types.d.ts

@@ -11,7 +11,6 @@
  * changes ZERO files under `packages/core/` (AC-12).
  */
 import type { TokenUsage } from '@aragon-agent/core';
-import type { FastTierName } from '../fast/types.js';
 import type { ActivityArgs } from './activity.js';
 /** One normalized delegation request. Produced only by `normalizeSubagentSpecs`. */
 export interface SubagentSpec {
@@ -27,34 +26,12 @@ export interface SubagentSpec {
      * permission than the session it was spawned from.
      */
     readOnly: boolean;
-    /**
-     * Which model runs this child (fast-model-tier §3.4).
-     *
-     * THE WIRE NAME IS `model` AND THE INTERNAL NAME IS `tier`, on purpose: a
-     * model expects to see `model:"fast"`, while `SubagentSpec.model` would read
-     * as a model ID at every call site in this package.
-     *
-     * DELEGATION IS A MODEL CHOICE, NEVER A PERMISSION BOUNDARY (D-15 / I-4). A
-     * fast child gets the same tools, the same `--confirm` gate, the same
-     * plan-mode gate and the same skills ceiling as any other; only the model
-     * differs. Restricting a fast child's tools would look like security, would
-     * not be, and would make the report's `[fast]` rows mean two different things.
-     */
-    tier: FastTierName;
 }
 export type SubagentPhase = 'queued' | 'starting' | 'thinking' | 'tool' | 'waiting' | 'done' | 'failed' | 'aborted';
 /** Live, mutable record of one child. Projected into the UI and the report. */
 export interface SubagentRun {
     label: string;
     description: string;
-    /**
-     * The tier this child actually ran on (fast-model-tier §3.4).
-     *
-     * WHAT RAN, NOT WHAT WAS ASKED FOR. A spec the normalizer downgraded arrives
-     * here as `'main'`, which is what makes the report's `[fast]` annotation and
-     * its second cost table agree with the bill.
-     */
-    tier: FastTierName;
     phase: SubagentPhase;
     startedAt?: number;
     endedAt?: number;
@@ -192,26 +169,11 @@ export interface DispatchOutcome {
     /** Messages addressed to `lead`; surfaced in their own report section. */
     leadMail: TeamMessage[];
     /**
-     * Summed across MAIN-TIER children. Real spend; it must reach the status bar
-     * (§3.9).
-     *
-     * THE MEANING NARROWED WHEN THE FAST TIER LANDED, and the split is not a
-     * rounding concern: a Haiku child under a Sonnet lead priced at the lead's
-     * table over-reports by roughly an order of magnitude, and the entire
-     * justification for delegating is a number in this report (R-7).
+     * Summed across all children. Real spend; it must reach the status bar
+     * (§3.9). Every child runs the LEAD's model (main-agent parity), so one
+     * total priced at the lead's table is the honest accounting.
      */
     usage: TokenUsage;
-    /** Summed across FAST-TIER children. Absent when none ran, which is what
-     *  keeps a pre-feature dispatch's report byte-identical. */
-    fastUsage?: TokenUsage;
-    /**
-     * Specs that asked for `model:"fast"` and ran on `main` anyway (§3.4 / R-6).
-     *
-     * REPORTED, NEVER SILENT. A silent downgrade means the model asked for a cheap
-     * child, got an expensive one, and has no way to learn that its cost model is
-     * wrong.
-     */
-    downgraded?: number;
 }
 /**
  * What the UI renders: a cheap immutable projection, rebuilt per event.
@@ -246,7 +208,6 @@ export type TeamEvent = {
     dispatchId: string;
     label: string;
     usage: TokenUsage;
-    tier: FastTierName;
 } | {
     type: 'message';
     dispatchId: string;