@aragon-agent/cli 0.6.16 → 0.6.17

package/dist/fast/wiring.js

@@ -7,8 +7,8 @@
  * THIS CLASS EXISTS FOR A BUDGET REASON, NOT AN AESTHETIC ONE (C-12 / RV-5).
  * `CLAUDE.md` caps a source file at 1000 lines and `controller.ts` was at 960
  * before this feature, which handed it nine new responsibilities. `FastWiring`
- * owns the flag pair, the tier cache, the reviewer's lifetime and the
- * `resolveTier` closure; `AgentController` keeps one field and four thin
+ * owns the flag pair, the tier cache, the reviewer's lifetime and the shared
+ * fail-fast review transport; `AgentController` keeps one field and four thin
  * forwarders. It is still CLI-local and still holds no `ui/` import.
  *
  * TWO FLAGS AND ONE LIVE PREDICATE (§3.3), which is the shape every optional
@@ -64,7 +64,6 @@ export function offFastStatus() {
             // `budgetReached` is CARRIED and callers must never re-derive it.
             reviewBudget: 0,
             budgetReached: false,
-            delegated: 0,
             usage: { inputTokens: 0, outputTokens: 0 },
             pricingUnknown: false,
             inFlight: false,
@@ -86,7 +85,6 @@ export class FastWiring {
     tier;
     /** Warned once per TRANSITION, so a broken tier does not shout every turn. */
     lastReportedReason = null;
-    delegated = 0;
     constructor(deps) {
         this.deps = deps;
         this.tier = resolveFastTier(deps.getConfig(), deps.hasKey);
@@ -168,26 +166,15 @@ export class FastWiring {
      * §3.3's live predicate. THE THIRD TERM IS THE POINT - see the header.
      *
      * `FastReviewer.isSelfDisabled()` is DELIBERATELY NOT a fourth term. Folding
-     * it in would look tidier and would break something else: `delegationAvailable()`
-     * is `available() && config.fast.delegate === true`, so three consecutive
-     * REVIEW failures would silently switch DELEGATION off as well - turning a
-     * diagnostic signal into a behaviour change for every user. The two facts are
-     * reported separately on `FastSnapshot` instead (`live` / `selfDisabled`).
+     * it in would look tidier and would break something else: per-child reviewers
+     * gate on `available()` too, so three consecutive REVIEW failures would
+     * silently stop every child's reviews as well - turning a diagnostic signal
+     * into a behaviour change for every dispatch. The two facts are reported
+     * separately on `FastSnapshot` instead (`live` / `selfDisabled`).
      */
     available() {
         return this.registered && this.enabled && this.tier.ok;
     }
-    /**
-     * Whether `model: "fast"` on `task` is honoured right now.
-     *
-     * Evaluated AT DISPATCH TIME, never snapshot (§3.4 / RV-3). `fast.delegate:
-     * false` and "the tier stopped resolving twenty minutes ago" are the same
-     * observable to the model - a downgrade, counted and reported - which is the
-     * honest reading of both.
-     */
-    delegationAvailable() {
-        return this.available() && this.deps.getConfig().fast.delegate === true;
-    }
     setEnabled(enabled) {
         this.enabled = enabled;
         this.deps.onPromptChanged();
@@ -233,40 +220,23 @@ export class FastWiring {
         return describeFastTierProblem(this.tier, fastProviderOf(this.deps.getConfig()));
     }
     // -----------------------------------------------------------------------
-    // Tier resolution for subagents (§3.4)
+    // The tier's transport, shared with per-child reviewers (§3.4)
     // -----------------------------------------------------------------------
-    /**
-     * The `ModelRef` and thinking level one subagent tier runs on.
-     *
-     * `'fast'` FALLS BACK TO MAIN when delegation is not available, so 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 no longer resolves (RV-3).
-     */
-    resolveTier(tier) {
-        const config = this.deps.getConfig();
-        if (tier === 'fast' && this.delegationAvailable() && this.tier.ok) {
-            return { ref: this.tier.ref, thinkingLevel: this.tier.thinkingLevel, role: 'fast' };
-        }
-        return {
-            ref: {
-                providerId: config.provider,
-                modelId: config.model,
-                ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
-            },
-            thinkingLevel: config.thinkingLevel,
-            role: 'main',
-        };
-    }
-    /** The resolved fast `ModelRef`, or `null` - for per-tier cost lookup (§3.6). */
+    /** The resolved fast `ModelRef`, or `null` - for cost lookups (§3.6). */
     fastRef() {
         return this.tier.ok ? this.tier.ref : null;
     }
-    /** Count fast-tier children so `/fast status` can answer "is this saving me
-     *  anything?" — the aggregate on the status bar cannot. */
-    noteDelegated(count) {
-        if (count > 0)
-            this.delegated += count;
+    /**
+     * The fail-fast review transport, exposed so PER-CHILD reviewers share ONE
+     * registry instead of building one each - the same adapter-state reuse
+     * argument `TeamRuntime` makes about the lead's `ProviderRegistry`.
+     *
+     * Lazy: a session that never reviews allocates nothing (I-2). The retry
+     * policy is `FAST_RETRY_POLICY`, deliberately not the user's `retry` config
+     * - see `getFastRegistry()` for the reason.
+     */
+    completeViaFastRegistry(providerId, request) {
+        return this.getFastRegistry().complete(providerId, request);
     }
     // -----------------------------------------------------------------------
     // Reviewer lifetime
@@ -302,7 +272,6 @@ export class FastWiring {
             reviews: this.reviewer.reviewCount(),
             reviewBudget: this.reviewer.budgetLimit(),
             budgetReached: this.reviewer.isBudgetReached(),
-            delegated: this.delegated,
             usage: this.reviewer.sessionUsage(),
             // UNKNOWN PRICING IS NOT ZERO PRICING (C-11 / RV-4). The fast tier is
             // precisely where an unrecognised model id is likely, and rendering it as

package/dist/session/validate-session.js

@@ -128,7 +128,9 @@ const todo = shape({
 });
 const subagent = shape({
     label: string, description: string,
-    // Old team archives predate tier; renderers already treat absence as main.
+    // OPTIONAL IN BOTH DIRECTIONS: sessions written since main-agent parity
+    // have no tier at all, and older archives may carry `main` or `fast` from
+    // the removed per-child fast dispatch. Renderers treat absence as main.
     tier: optional(enumeration('main', 'fast')),
     phase: enumeration('queued', 'starting', 'thinking', 'tool', 'waiting', 'done', 'failed', 'aborted'),
     startedAt: optional(number), endedAt: optional(number), turns: number, toolCalls: number,

package/dist/team/child-reviewer.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Per-child fast review (main-agent parity).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope
+ * (`glyphs.test.ts`), so no literal in this tree may hold a non-ASCII byte.
+ *
+ * THE LEAD HAS A FAST REVIEWER; A CHILD NOW HAS ONE TOO. The requirement is
+ * that "when the main agent pulls up subagents, all subagents are as capable as
+ * the main agent", and the fast/slow cooperation is part of what the main agent
+ * has: a cheap second model periodically critiques the run and steers a
+ * `<fast_review>` block into the conversation. A child runs the lead's own
+ * model, and this module gives that run the same second opinion.
+ *
+ * WHAT IS SHARED, AND WHAT IS PER CHILD:
+ *   - SHARED: the tier resolution (`resolveFastTier` on the LIVE config), the
+ *     fail-fast review transport (`FastWiring.completeViaFastRegistry` - one
+ *     lazy registry for the whole session, the same adapter-state reuse
+ *     argument `TeamRuntime` makes about the lead's `ProviderRegistry`), and
+ *     the `fast.*` policy keys. A `/fast off` mid-dispatch therefore stops
+ *     child reviews at the same instant it stops the lead's.
+ *   - PER CHILD: one `FastReviewer` instance, its own turn-frame ring, its own
+ *     session budget, its own goal (the spec's description).
+ *
+ * THE REVIEWER'S PROTOCOL IS UNCHANGED, AND THAT IS THE POINT. `FastReviewer`
+ * steers from exactly one place (the `tool_execution_end` that brings the batch
+ * to zero), never steers into a requested abort, and proves delivery at the
+ * next `turn_start`. The two guards need host-side facts, and a child supplies
+ * them differently than the lead:
+ *
+ *   - `userSteerCount` is ALWAYS ZERO: no human can steer a child. That makes
+ *     the reviewer's `clearAllQueues` provably safe by construction (D-21).
+ *   - `isAbortRequested` comes from the HANDLE-level abort flag that
+ *     `TeamRuntime` sets BEFORE calling `agent.abort()`. Reading the agent
+ *     alone is not enough: an Esc lands as `abortAll()`, and without the flag
+ *     the reviewer would race the abort it was told about.
+ *   - `emit` and `notify` LOG INSTEAD OF RENDERING. A child has no transcript
+ *     card and no status chip; the team panel row and the dispatch report are
+ *     where a child's internals belong, and review spend is bounded by the
+ *     same `fast.reviewMaxPerSession` budget the lead obeys.
+ */
+import type { AgentEvent, AssistantMessage, LLMRequest } from '@aragon-agent/core';
+import type { ModelRole } from '../config/model-profiles.js';
+import type { CliConfig } from '../config/schema.js';
+/**
+ * The slice of a child `Agent` the reviewer needs beyond what
+ * `SubagentAgentLike` already carries. Core's `Agent` satisfies this with its
+ * own `steer` / `clearAllQueues`; a test stub satisfies it the same way.
+ */
+export interface ChildReviewerAgent {
+    subscribe(listener: (event: AgentEvent) => void): () => void;
+    steer(text: string): void;
+    clearAllQueues(): void;
+}
+/** Everything one child reviewer needs to know about its child. */
+export interface ChildReviewerRequest {
+    label: string;
+    /** The spec's description: the goal the critique judges the run against. */
+    goal: string;
+    agent: ChildReviewerAgent;
+    /** A live phase, not a terminal one - the lead's `isRunning` equivalent. */
+    isRunning: () => boolean;
+    /** Set by the HANDLE-level abort, synchronously before `agent.abort()`. */
+    isAbortRequested: () => boolean;
+}
+/** Everything the reviewer needs from the session, all of it shared. */
+export interface ChildReviewerDeps {
+    /** Read LIVE on every call - a mid-dispatch `/fast off` must reach children. */
+    getConfig: () => CliConfig;
+    hasKey: (providerId: string, role?: ModelRole) => boolean;
+    getApiKey: (providerId: string, role?: ModelRole) => string | undefined;
+    /** `FastWiring.completeViaFastRegistry` - the shared fail-fast transport. */
+    complete: (providerId: string, request: LLMRequest) => Promise<AssistantMessage>;
+    /** `FastWiring.available()` - registered AND enabled AND resolving. */
+    available: () => boolean;
+}
+export interface ChildReviewerHandle {
+    dispose(): void;
+}
+/**
+ * What the controller hands `subagent.ts`, so a child's reviewer is built from
+ * the lead's own wiring rather than a second tier resolver.
+ *
+ * `active` AND `create` ARE SEPARATE ON PURPOSE: the child's system prompt
+ * must be composed BEFORE the agent exists, and `create` needs the agent. The
+ * two must answer the same question at the same instant, so both derive from
+ * `FastWiring.available() && config.fast.review` and the caller reads `active`
+ * once per child.
+ */
+export interface ChildReviewProvider {
+    /** Whether per-child review is live RIGHT NOW (tier live AND `fast.review`). */
+    active: () => boolean;
+    /** The resolved fast model id, for the child's `<fast_tier>` prompt block. */
+    modelId: () => string;
+    /** Build one reviewer for a child; `undefined` when not active. */
+    create: (req: ChildReviewerRequest) => ChildReviewerHandle | undefined;
+}
+/**
+ * Build one reviewer for one child, or `undefined` when the session has no
+ * live review to give it.
+ *
+ * `undefined` RATHER THAN A NO-OP REVIEWER, for the same reason
+ * `createChildContextManager` declines: the caller then wires nothing at all,
+ * and a session with the fast tier off builds the child it always built.
+ */
+export declare function createChildReviewer(req: ChildReviewerRequest, deps: ChildReviewerDeps): ChildReviewerHandle | undefined;

package/dist/team/child-reviewer.js

@@ -0,0 +1,117 @@
+/**
+ * Per-child fast review (main-agent parity).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope
+ * (`glyphs.test.ts`), so no literal in this tree may hold a non-ASCII byte.
+ *
+ * THE LEAD HAS A FAST REVIEWER; A CHILD NOW HAS ONE TOO. The requirement is
+ * that "when the main agent pulls up subagents, all subagents are as capable as
+ * the main agent", and the fast/slow cooperation is part of what the main agent
+ * has: a cheap second model periodically critiques the run and steers a
+ * `<fast_review>` block into the conversation. A child runs the lead's own
+ * model, and this module gives that run the same second opinion.
+ *
+ * WHAT IS SHARED, AND WHAT IS PER CHILD:
+ *   - SHARED: the tier resolution (`resolveFastTier` on the LIVE config), the
+ *     fail-fast review transport (`FastWiring.completeViaFastRegistry` - one
+ *     lazy registry for the whole session, the same adapter-state reuse
+ *     argument `TeamRuntime` makes about the lead's `ProviderRegistry`), and
+ *     the `fast.*` policy keys. A `/fast off` mid-dispatch therefore stops
+ *     child reviews at the same instant it stops the lead's.
+ *   - PER CHILD: one `FastReviewer` instance, its own turn-frame ring, its own
+ *     session budget, its own goal (the spec's description).
+ *
+ * THE REVIEWER'S PROTOCOL IS UNCHANGED, AND THAT IS THE POINT. `FastReviewer`
+ * steers from exactly one place (the `tool_execution_end` that brings the batch
+ * to zero), never steers into a requested abort, and proves delivery at the
+ * next `turn_start`. The two guards need host-side facts, and a child supplies
+ * them differently than the lead:
+ *
+ *   - `userSteerCount` is ALWAYS ZERO: no human can steer a child. That makes
+ *     the reviewer's `clearAllQueues` provably safe by construction (D-21).
+ *   - `isAbortRequested` comes from the HANDLE-level abort flag that
+ *     `TeamRuntime` sets BEFORE calling `agent.abort()`. Reading the agent
+ *     alone is not enough: an Esc lands as `abortAll()`, and without the flag
+ *     the reviewer would race the abort it was told about.
+ *   - `emit` and `notify` LOG INSTEAD OF RENDERING. A child has no transcript
+ *     card and no status chip; the team panel row and the dispatch report are
+ *     where a child's internals belong, and review spend is bounded by the
+ *     same `fast.reviewMaxPerSession` budget the lead obeys.
+ */
+import { getLogger } from '../logging/logger.js';
+import { resolveFastTier } from '../fast/resolve.js';
+import { FastReviewer } from '../fast/reviewer.js';
+/**
+ * A snapshot for the reviewer's self-disable announcement. The lead's
+ * `FastWiring.snapshot()` builds the same shape from its own reviewer; a child
+ * has no wiring, so this builds it from the reviewer the module itself holds.
+ *
+ * `pricingUnknown` is FALSE because the child reviewer never prices anything:
+ * it logs counts, not currency, and an unpriced model id therefore cannot lie
+ * here the way it can on the lead's status line (C-11).
+ */
+function buildSnapshot(reviewer, tier) {
+    return {
+        live: tier.ok,
+        selfDisabled: reviewer?.isSelfDisabled() ?? false,
+        model: tier.ok ? tier.ref.modelId : '',
+        sameAsMain: tier.ok ? tier.sameAsMain : false,
+        reviews: reviewer?.reviewCount() ?? 0,
+        reviewBudget: reviewer?.budgetLimit() ?? 0,
+        budgetReached: reviewer?.isBudgetReached() ?? false,
+        usage: reviewer?.sessionUsage() ?? { inputTokens: 0, outputTokens: 0 },
+        pricingUnknown: false,
+        inFlight: reviewer?.isReviewInFlight() ?? false,
+    };
+}
+/**
+ * Build one reviewer for one child, or `undefined` when the session has no
+ * live review to give it.
+ *
+ * `undefined` RATHER THAN A NO-OP REVIEWER, for the same reason
+ * `createChildContextManager` declines: the caller then wires nothing at all,
+ * and a session with the fast tier off builds the child it always built.
+ */
+export function createChildReviewer(req, deps) {
+    // GATED ON THE SAME THREE FACTS THE LEAD'S REVIEWER IS: the wiring is live
+    // (`available()`), the policy allows reviews (`fast.review`), and the tier
+    // resolves against the LIVE config. Re-checked, never snapshotted, so a
+    // mid-dispatch `/fast off` or a settings-screen model edit reaches the next
+    // child even when it cannot stop one already running.
+    const tier = resolveFastTier(deps.getConfig(), deps.hasKey);
+    if (!deps.available() || !deps.getConfig().fast.review || !tier.ok)
+        return undefined;
+    const log = getLogger().child('fast');
+    let reviewer = null;
+    const built = new FastReviewer({
+        subscribe: (listener) => req.agent.subscribe(listener),
+        complete: deps.complete,
+        steer: (text) => req.agent.steer(text),
+        isRunning: req.isRunning,
+        isAbortRequested: req.isAbortRequested,
+        userSteerCount: () => 0,
+        clearAllQueues: () => req.agent.clearAllQueues(),
+        getTier: () => resolveFastTier(deps.getConfig(), deps.hasKey),
+        getConfig: () => deps.getConfig().fast,
+        available: () => deps.available() && resolveFastTier(deps.getConfig(), deps.hasKey).ok,
+        getApiKey: (providerId) => deps.getApiKey(providerId, 'fast'),
+        emit: (event) => {
+            log.info('child_review', { label: req.label, type: event.type });
+        },
+        snapshot: () => buildSnapshot(reviewer, tier),
+        // A CHILD HAS NO TRANSCRIPT. The lead's warnings ride `notify` into a card
+        // the user reads; the same text from a background worker would claim the
+        // user's attention for an agent they cannot see. It is logged instead.
+        notify: (level, text) => {
+            log.warn('child_review_notice', { label: req.label, level, text });
+        },
+    });
+    reviewer = built;
+    built.setGoal(req.goal);
+    log.info('child_review_attached', {
+        label: req.label,
+        model: tier.ref.modelId,
+        reviewEveryTurns: deps.getConfig().fast.reviewEveryTurns,
+    });
+    return { dispose: () => built.dispose() };
+}

package/dist/team/normalize.d.ts

@@ -17,32 +17,18 @@
  * whether an optional install step succeeded.
  *
  * NEVER THROWS. Zero survivors is the caller's single hard failure.
+ *
+ * EVERY CHILD RUNS THE LEAD'S MODEL (main-agent parity): the former
+ * `model: "fast"` per-child tier was removed, so a spec that still carries a
+ * `model` key simply ignores it - there is no tier to downgrade TO, and the
+ * honest reading of a stale key is silence, not a report line about a
+ * capability that no longer exists.
  */
 import type { SubagentSpec } from './types.js';
 export interface NormalizedSpecs {
     specs: SubagentSpec[];
     /** How many entries the model asked for, before dropping and capping. */
     requested: number;
-    /**
-     * Specs that asked for `model:"fast"` and were downgraded to `main`
-     * (fast-model-tier §3.4 / R-6).
-     *
-     * ADDITIVE: `NormalizedSpecs` GAINS a field, it does not change one, so every
-     * existing caller and test compiles unchanged.
-     */
-    downgraded: number;
-}
-/** Options for the fast tier. Optional for the reason `normalizeSubagentSpecs`
- *  documents below (RV-14). */
-export interface NormalizeOptions {
-    /**
-     * §3.3's LIVE predicate, evaluated at DISPATCH time (RV-3).
-     *
-     * `fast.delegate: false` and "the tier stopped resolving twenty minutes ago"
-     * are the same observable to the model — a downgrade, counted and reported —
-     * which is the honest reading of both.
-     */
-    fastAvailable?: boolean;
 }
 /**
  * Repair and bound a raw `subagents` array.
@@ -55,10 +41,5 @@ export interface NormalizeOptions {
  * @param max   The resolved `team.maxSubagents`; further clamped to
  *              `TEAM_LIMITS.hardMaxSubagents` here so a hand-edited config file
  *              cannot raise the requirement's ceiling (R-g).
- * @param opts  Fast-tier availability. OPTIONAL, DEFAULTING TO `false` (RV-14):
- *              this function and `NormalizedSpecs` are both exported and both
- *              have existing callers and tests, so a required third parameter
- *              would be a breaking edit that buys nothing — and an omitted one
- *              now means exactly what a pre-feature build meant.
  */
-export declare function normalizeSubagentSpecs(raw: unknown, max: number, opts?: NormalizeOptions): NormalizedSpecs;
+export declare function normalizeSubagentSpecs(raw: unknown, max: number): NormalizedSpecs;

package/dist/team/normalize.js

@@ -17,6 +17,12 @@
  * whether an optional install step succeeded.
  *
  * NEVER THROWS. Zero survivors is the caller's single hard failure.
+ *
+ * EVERY CHILD RUNS THE LEAD'S MODEL (main-agent parity): the former
+ * `model: "fast"` per-child tier was removed, so a spec that still carries a
+ * `model` key simply ignores it - there is no tier to downgrade TO, and the
+ * honest reading of a stale key is silence, not a report line about a
+ * capability that no longer exists.
  */
 import { TEAM_LIMITS } from './limits.js';
 function asString(value) {
@@ -76,21 +82,13 @@ function dedupeLabel(label, taken) {
  * @param max   The resolved `team.maxSubagents`; further clamped to
  *              `TEAM_LIMITS.hardMaxSubagents` here so a hand-edited config file
  *              cannot raise the requirement's ceiling (R-g).
- * @param opts  Fast-tier availability. OPTIONAL, DEFAULTING TO `false` (RV-14):
- *              this function and `NormalizedSpecs` are both exported and both
- *              have existing callers and tests, so a required third parameter
- *              would be a breaking edit that buys nothing — and an omitted one
- *              now means exactly what a pre-feature build meant.
  */
-export function normalizeSubagentSpecs(raw, max, opts = {}) {
+export function normalizeSubagentSpecs(raw, max) {
     if (!Array.isArray(raw))
-        return { specs: [], requested: 0, downgraded: 0 };
+        return { specs: [], requested: 0 };
     const requested = raw.length;
-    const fastAvailable = opts.fastAvailable === true;
     const kept = [];
     const taken = new Set();
-    /** Parallel to `kept`: did entry `i` ask for the fast tier? */
-    const wantedFast = [];
     for (let i = 0; i < raw.length; i += 1) {
         const item = raw[i];
         if (!item || typeof item !== 'object')
@@ -102,25 +100,14 @@ export function normalizeSubagentSpecs(raw, max, opts = {}) {
         const prompt = clamp(asString(src.prompt), TEAM_LIMITS.promptChars);
         if (prompt.length === 0)
             continue;
-        // REPAIR, NEVER REJECT — this file's own contract. `'fast'` without
-        // availability becomes `'main'` AND IS COUNTED; anything else (a typo, a
-        // model id, `undefined`) is simply `'main'` and is NOT counted, because the
-        // model did not ask for the fast tier and has nothing to be told about.
-        const wantsFast = src.model === 'fast';
-        wantedFast.push(wantsFast);
         kept.push({
             label: dedupeLabel(slugLabel(src.label, kept.length), taken),
             description,
             prompt,
             readOnly: src.readOnly === true,
-            tier: wantsFast && fastAvailable ? 'fast' : 'main',
         });
     }
     const ceiling = Math.max(1, Math.min(Math.floor(max) || 1, TEAM_LIMITS.hardMaxSubagents));
     const specs = kept.slice(0, ceiling);
-    // COUNTED OVER THE SURVIVORS, not over everything the model wrote: a spec the
-    // cap dropped never ran at all, so reporting it as "ran on the main model"
-    // would be a second, different lie in a line that exists to stop the first.
-    const downgraded = specs.filter((spec, i) => spec.tier === 'main' && wantedFast[i] === true).length;
-    return { specs, requested, downgraded };
+    return { specs, requested };
 }

package/dist/team/prompt.d.ts

@@ -18,17 +18,6 @@ export { TEAM_BLOCK_VERSION };
 export interface TeamBlockParams {
     maxSubagents: number;
     maxConcurrent: number;
-    /**
-     * Whether `model:"fast"` is honoured on `task` right now (fast-model-tier
-     * §3.8).
-     *
-     * ONE SENTENCE, AND ONLY WHEN IT IS TRUE. `<fast_tier>` carries the full
-     * guidance; this is the cross-reference that stops a model reading
-     * `<team_mode>` in isolation and concluding every child costs the same. With
-     * it absent the block is BYTE-IDENTICAL to the pre-feature output, which is
-     * what `--no-fast` and every existing snapshot depend on.
-     */
-    fastDelegation?: boolean;
 }
 /**
  * The lead's `<team_mode>` block. Under 1200 characters on purpose: it is paid

package/dist/team/prompt.js

@@ -44,19 +44,10 @@ export function buildTeamBlock(params) {
         '',
         'Each subagent starts with no memory of this conversation, so its prompt must',
         'carry everything it needs: the goal, the files or areas it owns, and what to',
-        'report back. Give each one a disjoint set of files to write. Subagents cannot',
-        'dispatch further subagents and cannot ask the user anything.',
+        'report back. Give each one a disjoint set of files to write. Every subagent',
+        'runs on your own model. Subagents cannot dispatch further subagents and',
+        'cannot ask the user anything.',
         '',
-        // THE TRAILING BLANK IS INSIDE THE CONDITIONAL, not outside it. An
-        // unconditional `''` here would add a line to EVERY team-enabled prompt and
-        // silently break the byte-identity `--no-fast` depends on (I-2).
-        ...(params.fastDelegation
-            ? [
-                'A subagent doing mechanical, high-volume work can run on the cheaper fast',
-                'model - see <fast_tier>.',
-                '',
-            ]
-            : []),
         'You get one combined report when they all finish. Read it before deciding what',
         'to do next, and tell the user what the team found in your own words.',
         '</team_mode>',

package/dist/team/report.d.ts

@@ -23,26 +23,11 @@
 import type { ModelCost } from '@aragon-agent/core';
 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). */
-    cost?: ModelCost;
-    /**
-     * The FAST model's cost table (fast-model-tier §3.4 / R-7).
-     *
-     * A SECOND TABLE, not a second number derived from the first. Summing
-     * fast-tier tokens at the lead's price over-reports a Haiku child under a
-     * Sonnet lead by roughly an order of magnitude, and the whole justification
-     * for delegating to a cheaper model is the figure on this line.
-     */
-    fastCost?: ModelCost;
-    /**
-     * The static price table has never heard of the fast model (C-11 / RV-4).
+    /** The lead's model cost table, so the header can state real spend (R-5).
      *
-     * UNKNOWN PRICING IS NOT ZERO PRICING. `buildRuntimeModel` hands back
-     * `cost: { input: 0, output: 0 }` for an unrecognised id, and the fast tier is
-     * precisely where an unrecognised id is LIKELY — so rendering it as `$0.00`
-     * would make the feature look free while it is spending money.
-     */
-    fastPricingUnknown?: boolean;
+     * THE ONE TABLE, because every child runs the lead's own model
+     * (main-agent parity): one tier, one price, one honest total. */
+    cost?: ModelCost;
 }
 /**
  * Cut `text` to at most `maxBytes` WITHOUT splitting a UTF-8 sequence.

package/dist/team/report.js

@@ -106,28 +106,6 @@ function buildHeader(outcome, options) {
             `(${counts}) in ${formatDuration(durationMs)}.`);
     lines.push(`Tokens: in ${formatTokens(outcome.usage.inputTokens)}, out ` +
         `${formatTokens(outcome.usage.outputTokens)}. Cost: ${formatCost(computeCost(outcome.usage, options.cost))}.`);
-    // A SECOND LINE, NOT A COMBINED TOTAL (fast-model-tier §3.4). Two tiers with
-    // two price tables have two answers, and folding them into one figure is the
-    // misattribution R-7 is about. Present only when a fast child actually ran, so
-    // an ordinary dispatch's header is byte-identical.
-    const fastUsage = outcome.fastUsage;
-    if (fastUsage) {
-        // `unknown` rather than a currency amount when the model has no price table
-        // (RV-4): a lower bound rendered as a total is the same class of lie as
-        // pricing a Haiku child at Sonnet rates.
-        const fastCostLabel = options.fastPricingUnknown
-            ? 'unknown (no price table)'
-            : formatCost(computeCost(fastUsage, options.fastCost));
-        lines.push(`Fast tier: in ${formatTokens(fastUsage.inputTokens)}, out ` +
-            `${formatTokens(fastUsage.outputTokens)}. Cost: ${fastCostLabel}.`);
-    }
-    // THE LINE THAT KEEPS A DOWNGRADE FROM BEING SILENT (R-6). Without it the
-    // model asked for a cheap child, got an expensive one, and has no way to learn
-    // that its cost model is wrong.
-    if (outcome.downgraded && outcome.downgraded > 0) {
-        const n = outcome.downgraded;
-        lines.push(`${n} ${n === 1 ? 'subagent' : 'subagents'} ran on the main model (fast tier off).`);
-    }
     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.`);
@@ -139,10 +117,6 @@ function buildSection(run) {
     // the only place the lead learns that a child's first attempt died before it
     // did anything (F-4).
     const retried = run.retries ? `, retried ${run.retries}x` : '';
-    // `[fast]` after the LABEL, on the head line, which is never trimmed. Six
-    // bytes, and it is the only place the lead learns which of its children were
-    // cheap — the fact the whole second cost line is about.
-    const tier = run.tier === 'fast' ? ' [fast]' : '';
     // `compacted N` in the same position `retried Nx` uses, and for the same
     // reason (context-auto-compaction-hardening §3.4.4 / W3): this is the ONLY
     // place the lead learns that a child's own history was summarized mid-task, so
@@ -150,7 +124,7 @@ function buildSection(run) {
     // rather than an unexplained one. Absent when it never happened.
     const compacted = run.compactions ? `, compacted ${run.compactions}` : '';
     const head = [
-        `### ${run.label}${tier} "${run.description}"  ${statusBadge(run)}  ${elapsed(run)}, ` +
+        `### ${run.label} "${run.description}"  ${statusBadge(run)}  ${elapsed(run)}, ` +
             `${run.turns} turns, ${run.toolCalls} tools${retried}${compacted}`,
     ];
     if (run.filesTouched.length > 0)

package/dist/team/runtime.d.ts

@@ -56,11 +56,11 @@ export interface TeamRuntimeDeps {
     /** Test seam (§8.1): a stub factory keeps the whole scheduler off the network. */
     agentFactory?: SubagentAgentFactory;
     /**
-     * Per-tier model resolution (fast-model-tier §3.4). Passed straight through to
-     * `SubagentDeps`; absent means every child runs on the session's model, which
-     * is the pre-feature behaviour.
+     * Per-child fast review (main-agent parity), passed straight through to
+     * `SubagentDeps`. ABSENT means the session has no fast wiring and children
+     * are built exactly as they were before the reviewers existed.
      */
-    resolveTier?: SubagentDeps['resolveTier'];
+    review?: SubagentDeps['review'];
     /**
      * Per-child context compaction (context-auto-compaction-hardening §3.4 / W3).
      *
@@ -104,12 +104,7 @@ export declare class TeamRuntime {
     isBusy(): boolean;
     /** The live roster, for `/team` status. `null` when nothing is dispatching. */
     snapshot(): TeamSnapshot | null;
-    dispatch(specs: SubagentSpec[], requested: number, signal?: AbortSignal, 
-    /** Carried through from the normalizer so the report can state it (§3.4 /
-     *  R-6). Optional, so every existing caller compiles unchanged. */
-    extra?: {
-        downgraded?: number;
-    }): Promise<DispatchOutcome>;
+    dispatch(specs: SubagentSpec[], requested: number, signal?: AbortSignal): Promise<DispatchOutcome>;
     /** One slot of the pool: take the next index until the list is exhausted. */
     private worker;
     /**