@aragon-agent/cli 0.6.16 → 0.6.18

package/dist/config/cli-commands.js

@@ -14,7 +14,7 @@ import { getConfigBackupPath, getConfigPath, getHomeRoot, getLogsDir, getPromptH
 import { getHomeMigrationBreadcrumbPath } from './migrate-home.js';
 import { loadPersistedConfig, updatePersistedConfig } from './store.js';
 import { normalizeModelProfiles, validateModelProfiles } from './model-profiles.js';
-import { clampFastConfig, clampRetryConfig, clampCompactionConfig, parseThresholdInput, clampUpdateConfig, coercePositiveInt, maskSecret, DEFAULT_FAST_CONFIG, DEFAULT_RETRY_CONFIG, DEFAULT_TEAM_CONFIG, DEFAULT_COMPACTION_CONFIG, DEFAULT_UPDATE_CONFIG, } from './schema.js';
+import { clampFastConfig, clampRetryConfig, clampCompactionConfig, clampTeamConfig, parseThresholdInput, clampUpdateConfig, coercePositiveInt, maskSecret, DEFAULT_FAST_CONFIG, DEFAULT_RETRY_CONFIG, DEFAULT_TEAM_CONFIG, DEFAULT_COMPACTION_CONFIG, DEFAULT_UPDATE_CONFIG, } from './schema.js';
 import { clampLogLevel } from '../logging/levels.js';
 /** Config keys under `log.` that `aragon config set` accepts. */
 export const LOG_CONFIG_SET_KEYS = [
@@ -43,6 +43,7 @@ export const TEAM_CONFIG_SET_KEYS = [
     'team.subagentTimeoutMs',
     'team.dispatchTimeoutMs',
     'team.maxTurnsPerSubagent',
+    'team.overseer',
 ];
 /**
  * Config keys under `retry.` that `aragon config set` accepts
@@ -81,7 +82,6 @@ export const FAST_CONFIG_SET_KEYS = [
     'fast.model',
     'fast.baseUrl',
     'fast.thinkingLevel',
-    'fast.delegate',
     'fast.review',
     'fast.reviewEveryTurns',
     'fast.reviewContextTurns',
@@ -177,25 +177,31 @@ export function applyLogConfigSet(key, value) {
  */
 export function applyTeamConfigSet(key, value) {
     const patch = (team) => ({ team });
+    // EVERY NUMERIC KEY ROUTES THROUGH `clampTeamConfig`, not through
+    // `coercePositiveInt`, for the reason `applyRetryConfigSet` records one block
+    // below: `coercePositiveInt` returns its fallback for `n <= 0`, so
+    // `config set team.subagentTimeoutMs 0` would write 300000 (the old default)
+    // instead of the documented NO-LIMIT value, silently. The caller echoes the
+    // STORED value, which is what makes an out-of-range input visible.
+    const clampOne = (field) => {
+        const merged = clampTeamConfig({ ...DEFAULT_TEAM_CONFIG, [field]: value });
+        return { [field]: merged[field] };
+    };
     switch (key) {
         case 'team.enabled':
             return patch({ enabled: isTrue(value) });
         case 'team.maxSubagents':
-            return patch({ maxSubagents: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.maxSubagents) });
+            return patch(clampOne('maxSubagents'));
         case 'team.maxConcurrent':
-            return patch({ maxConcurrent: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.maxConcurrent) });
+            return patch(clampOne('maxConcurrent'));
         case 'team.subagentTimeoutMs':
-            return patch({
-                subagentTimeoutMs: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.subagentTimeoutMs),
-            });
+            return patch(clampOne('subagentTimeoutMs'));
         case 'team.dispatchTimeoutMs':
-            return patch({
-                dispatchTimeoutMs: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.dispatchTimeoutMs),
-            });
+            return patch(clampOne('dispatchTimeoutMs'));
         case 'team.maxTurnsPerSubagent':
-            return patch({
-                maxTurnsPerSubagent: coercePositiveInt(value, DEFAULT_TEAM_CONFIG.maxTurnsPerSubagent),
-            });
+            return patch(clampOne('maxTurnsPerSubagent'));
+        case 'team.overseer':
+            return patch({ overseer: isTrue(value) });
         default:
             return null;
     }
@@ -273,8 +279,6 @@ export function applyFastConfigSet(key, value) {
             return patch(clampOne('baseUrl'));
         case 'fast.thinkingLevel':
             return patch(clampOne('thinkingLevel'));
-        case 'fast.delegate':
-            return patch({ delegate: isTrue(value) });
         case 'fast.review':
             return patch({ review: isTrue(value) });
         case 'fast.reviewEveryTurns':

package/dist/config/load.d.ts

@@ -193,23 +193,6 @@ export interface CliFlags {
      * to keep in step with `toFlags`.
      */
     fastReview?: string;
-    /**
-     * `--fast-delegate` ⇒ true, `--no-fast-delegate` ⇒ false, absent ⇒ undefined
-     * (web-use-tier-cooperation-and-control-closure §4.1.5).
-     *
-     * DECLARED AS A PAIR — MANDATORY, for the reason `--team`, `--todo-panel`,
-     * `--render-governor`, `--retry` and `--fast` each record in turn, and here
-     * with the SAME polarity as `--update`: `fast.delegate` is PERSISTED and
-     * defaults to `true`, so a lone `--no-fast-delegate` would make commander
-     * default `opts.fastDelegate` to `true` and silently overwrite a stored
-     * `false` on every run that passed no flag at all.
-     *
-     * It exists because it is the ONLY `fast.*` sub-switch with no channel a
-     * wrapper can reach: `--fast-review <n|off>` already covers `review` and
-     * `reviewEveryTurns`, and `enabled` / `model` / `provider` have both a flag
-     * and an environment variable.
-     */
-    fastDelegate?: boolean;
     /**
      * `--update` ⇒ true, `--no-update` ⇒ false, absent ⇒ undefined
      * (cli-auto-update §4.2).

package/dist/config/load.js

@@ -243,12 +243,6 @@ function resolveFastConfig(flags, env, file) {
         ...(flags.fastProvider !== undefined && flags.fastProvider !== ''
             ? { provider: flags.fastProvider }
             : {}),
-        // `!== undefined`, for the reason stated on `flags.fast` above: commander
-        // materialises a lone `--no-fast-delegate` as `opts.fastDelegate = true`
-        // when the flag is absent, and `delegate` defaults to TRUE — so a truthiness
-        // check would force it on for every run that passed no flag at all,
-        // overwriting a stored `false` with nothing to show for it.
-        ...(flags.fastDelegate !== undefined ? { delegate: flags.fastDelegate } : {}),
         ...reviewPatch,
     });
 }

package/dist/config/schema.d.ts

@@ -303,12 +303,43 @@ export interface TeamConfig {
      * failed subagent.
      */
     maxConcurrent: number;
-    /** One child's wall clock before its own abort. */
+    /**
+     * One child's wall clock before its own abort. `0` (the default) means NO
+     * ceiling: a subagent runs until it finishes or is aborted, exactly like
+     * the lead, whose only in-run ceiling is the event-silence idle watchdog
+     * a child already keeps. A wedged child still dies on its OWN watchdog.
+       *
+       * WITH `team.overseer` ON (the default) this is the FIRST wall-clock
+       * INSPECTION point, not a hard abort: the supervisor looks and decides
+       * (wait / nudge / replace / abandon), so a slow-but-healthy child is no
+       * longer killed at an arbitrary wall clock.
+     */
     subagentTimeoutMs: number;
-    /** The whole dispatch's wall clock. Also the `task` tool-timeout override. */
+    /**
+     * The whole dispatch's wall clock, and the `task` tool-timeout override.
+     * `0` (the default) means NO ceiling: the executor override of `0` arms no
+     * timer (see Core `ToolExecutor`), so the fan-out lasts as long as its
+     * slowest child and only an Esc ends it early.
+     */
     dispatchTimeoutMs: number;
-    /** Runaway-loop cap: turns one child may take before it is stopped. */
+    /**
+     * Runaway-loop cap: turns one child may take before it is stopped.
+     * `0` (the default) means NO cap - the same exposure the lead has, and
+     * the deliberate trade of "subagents as capable as the main agent".
+     */
     maxTurnsPerSubagent: number;
+    /**
+     * The dispatch supervisor (team-overseer): time ceilings on children
+     * become inspection triggers for a fast-tier supervisor that decides
+     * wait / nudge / replace / abandon, instead of aborts. Default TRUE.
+     *
+     * READ PER DISPATCH. With the supervisor off (or no fast tier), children
+     * run exactly the pre-feature regime: `subagentTimeoutMs` is a hard abort
+     * and silence is the child's own watchdog. With it ON,
+     * `subagentTimeoutMs > 0` is the FIRST wall-clock inspection point, not
+     * a death sentence.
+     */
+    overseer: boolean;
 }
 /**
  * The requirement's ceiling on the fan-out (R-g).
@@ -458,8 +489,6 @@ export interface FastConfig {
     /** Applied to fast-tier children and to the review call. Defaults to `'off'`:
      *  a "fast" model asked to think for 32 768 tokens is not fast (D-13). */
     thinkingLevel: ThinkingLevel;
-    /** Allow `model: "fast"` on `task`. */
-    delegate: boolean;
     /** Run the periodic asynchronous review. */
     review: boolean;
     /** Completed turns between reviews. */
@@ -584,10 +613,13 @@ export interface CompactionConfig {
      * (context-auto-compaction-hardening §3.4 / W3). Default TRUE.
      *
      * IT REVERSES D-15, WHOSE PREMISE IS MEASURABLY FALSE at the configured bounds:
-     * `team.maxTurnsPerSubagent` is 24 and `team.dispatchTimeoutMs` is 900 000, and
-     * 24 turns over fifteen minutes is the same profile as the lead run this
-     * feature exists for. When a child overflows today its history is discarded and
-     * the lead receives one partial sentence for the whole dispatch.
+     * D-15 measured `team.maxTurnsPerSubagent` 24 and `team.dispatchTimeoutMs`
+     * 900 000, where 24 turns over fifteen minutes is already the same profile
+     * as the lead run this feature exists for — and the parity defaults of
+     * 2ff15a9c3 later removed both ceilings (0 = no turn cap, no wall clock),
+     * which makes the premise falser still, not truer. When a child overflows
+     * today its history is discarded and the lead receives one partial sentence
+     * for the whole dispatch.
      *
      * `false` REPRODUCES ROUND 1 EXACTLY: `subagent.ts` spreads no `contextManager`
      * key at all, so the child's loop gate tests an absent field.

package/dist/config/schema.js

@@ -447,15 +447,23 @@ export const DEFAULT_TEAM_CONFIG = {
     enabled: true,
     maxSubagents: 5,
     maxConcurrent: 3,
-    subagentTimeoutMs: 300_000,
-    dispatchTimeoutMs: 900_000,
-    maxTurnsPerSubagent: 24,
+    // 0 = NO LIMIT. Subagents run under the same regime as the lead: no
+    // wall clock, no turn cap; only the idle watchdog and the user's Esc.
+    subagentTimeoutMs: 0,
+    dispatchTimeoutMs: 0,
+    maxTurnsPerSubagent: 0,
+    // The dispatch supervisor, default ON (team-overseer): ceilings become
+    // inspections; the fast-tier supervisor decides what to do.
+    overseer: true,
 };
 const SUBAGENTS_RANGE = { min: 1, max: HARD_MAX_SUBAGENTS };
 const CONCURRENT_RANGE = { min: 1, max: HARD_MAX_SUBAGENTS };
-const SUBAGENT_TIMEOUT_RANGE = { min: 30_000, max: 1_800_000 };
-const DISPATCH_TIMEOUT_RANGE = { min: 60_000, max: 3_600_000 };
-const TURNS_RANGE = { min: 4, max: 100 };
+// `min: 0` is the documented OFF SWITCH for each bound, so these MUST use
+// `clampIntAllowingZero`: plain `clampInt` folds `0` back to the fallback
+// ("my setting won't stick"), the exact trap `scrollResumeMs` records above.
+const SUBAGENT_TIMEOUT_RANGE = { min: 0, max: 1_800_000 };
+const DISPATCH_TIMEOUT_RANGE = { min: 0, max: 3_600_000 };
+const TURNS_RANGE = { min: 0, max: 100 };
 /**
  * THE single gate for every team-config read AND write, mirroring
  * `clampSkillsConfig` / `clampLogConfig` for the reason those two record:
@@ -474,9 +482,10 @@ export function clampTeamConfig(raw) {
         enabled: bool(src.enabled, DEFAULT_TEAM_CONFIG.enabled),
         maxSubagents,
         maxConcurrent: Math.min(maxSubagents, clampInt(src.maxConcurrent, DEFAULT_TEAM_CONFIG.maxConcurrent, CONCURRENT_RANGE)),
-        subagentTimeoutMs: clampInt(src.subagentTimeoutMs, DEFAULT_TEAM_CONFIG.subagentTimeoutMs, SUBAGENT_TIMEOUT_RANGE),
-        dispatchTimeoutMs: clampInt(src.dispatchTimeoutMs, DEFAULT_TEAM_CONFIG.dispatchTimeoutMs, DISPATCH_TIMEOUT_RANGE),
-        maxTurnsPerSubagent: clampInt(src.maxTurnsPerSubagent, DEFAULT_TEAM_CONFIG.maxTurnsPerSubagent, TURNS_RANGE),
+        subagentTimeoutMs: clampIntAllowingZero(src.subagentTimeoutMs, DEFAULT_TEAM_CONFIG.subagentTimeoutMs, SUBAGENT_TIMEOUT_RANGE),
+        dispatchTimeoutMs: clampIntAllowingZero(src.dispatchTimeoutMs, DEFAULT_TEAM_CONFIG.dispatchTimeoutMs, DISPATCH_TIMEOUT_RANGE),
+        maxTurnsPerSubagent: clampIntAllowingZero(src.maxTurnsPerSubagent, DEFAULT_TEAM_CONFIG.maxTurnsPerSubagent, TURNS_RANGE),
+        overseer: bool(src.overseer, DEFAULT_TEAM_CONFIG.overseer),
     };
 }
 export const DEFAULT_TODO_CONFIG = {
@@ -615,7 +624,6 @@ export const DEFAULT_FAST_CONFIG = {
     model: '',
     baseUrl: '',
     thinkingLevel: 'off',
-    delegate: true,
     review: true,
     reviewEveryTurns: 5,
     reviewContextTurns: 3,
@@ -655,7 +663,6 @@ export function clampFastConfig(raw) {
         model: text(src.model, DEFAULT_FAST_CONFIG.model),
         baseUrl: text(src.baseUrl, DEFAULT_FAST_CONFIG.baseUrl),
         thinkingLevel: clampThinkingLevel(src.thinkingLevel, DEFAULT_FAST_CONFIG.thinkingLevel),
-        delegate: bool(src.delegate, DEFAULT_FAST_CONFIG.delegate),
         review: bool(src.review, DEFAULT_FAST_CONFIG.review),
         reviewEveryTurns: clampInt(src.reviewEveryTurns, DEFAULT_FAST_CONFIG.reviewEveryTurns, REVIEW_EVERY_RANGE),
         reviewContextTurns: clampInt(src.reviewContextTurns, DEFAULT_FAST_CONFIG.reviewContextTurns, REVIEW_CONTEXT_RANGE),

package/dist/exec/events.d.ts

@@ -193,7 +193,10 @@ export interface ExecTodoEvent {
 export interface ExecTeamEvent {
     type: 'team';
     sessionId: string;
-    subtype: 'dispatch_start' | 'agent_update' | 'dispatch_end';
+    subtype: 'dispatch_start' | 'agent_update' | 'dispatch_end' | 'overseer';
+    action?: string;
+    trigger?: string;
+    reason?: string;
     label?: string;
     phase?: string;
     description?: string;
@@ -219,11 +222,11 @@ export interface ExecFastReviewEvent {
  * not know is unaffected.
  *
  * THE PROBLEM IT SOLVES. `fast_review` only fires when a review produced TEXT,
- * so every other outcome — a review that failed, a tier that switched itself off
- * after three failures, a budget that ran out, a delegation that did or did not
- * happen — was invisible to a wrapper. The single most likely and least
- * self-diagnosable failure ("it runs but not one review card ever arrives") had
- * no signal at all on this stream.
+ * so every other outcome — a review that failed, a tier that switched itself
+ * off after three failures, or a budget that ran out — was invisible to a
+ * wrapper. The single most likely and least self-diagnosable failure ("it
+ * runs but not one review card ever arrives") had no signal at all on this
+ * stream.
  *
  * IT IS A STATE EVENT, NOT A LOG LINE. It fires on `tier_changed` and on every
  * `review_end`, which in a session with reviews is a handful per hundred turns.
@@ -249,7 +252,11 @@ export interface ExecFastTierEvent {
     reviews: number;
     reviewBudget: number;
     budgetReached: boolean;
-    /** Fast-tier children dispatched — the only evidence delegation is working. */
+    /**
+     * DEPRECATED, ALWAYS `0`. Fast-tier children no longer exist (every `task`
+     * child runs the lead's model); the field is kept so schema-v1 consumers
+     * keep parsing. Do not build new readers on it.
+     */
     delegated: number;
     inFlight: boolean;
     /** Present only on the `review_end` branch. */
@@ -399,8 +406,8 @@ export interface ExecInitParams {
  *
  *  · `'interrupt'`         — `{"type":"interrupt"}` on stdin settles the turn
  *                            without killing the process.
- *  · `'fast-policy'`       — this build understands `--fast-delegate` and
- *                            `--fast-review`. FOR AFTER-THE-FACT DISPLAY ONLY:
+ *  · `'fast-policy'`       — this build understands `--fast-review`.
+ *                            FOR AFTER-THE-FACT DISPLAY ONLY:
  *                            argv is fixed before `system/init` arrives, so it
  *                            cannot gate whether the flags are passed.
  *  · `'fast-tier-events'`  — this build emits `fast_tier`. Its ABSENCE is what

package/dist/exec/events.js

@@ -34,8 +34,8 @@ export const EXEC_SCHEMA_VERSION = 1;
  *
  *  · `'interrupt'`         — `{"type":"interrupt"}` on stdin settles the turn
  *                            without killing the process.
- *  · `'fast-policy'`       — this build understands `--fast-delegate` and
- *                            `--fast-review`. FOR AFTER-THE-FACT DISPLAY ONLY:
+ *  · `'fast-policy'`       — this build understands `--fast-review`.
+ *                            FOR AFTER-THE-FACT DISPLAY ONLY:
  *                            argv is fixed before `system/init` arrives, so it
  *                            cannot gate whether the flags are passed.
  *  · `'fast-tier-events'`  — this build emits `fast_tier`. Its ABSENCE is what

package/dist/exec/runner.js

@@ -153,7 +153,10 @@ export class ExecRunner {
                 reviews: snapshot.reviews,
                 reviewBudget: snapshot.reviewBudget,
                 budgetReached: snapshot.budgetReached,
-                delegated: snapshot.delegated,
+                // Deprecated in schema v1: always 0 since fast-tier children were
+                // removed (every task child runs the lead's model). Emitted so
+                // schema-v1 consumers keep parsing.
+                delegated: 0,
                 inFlight: snapshot.inFlight,
                 ...(event.type === 'review_end'
                     ? {
@@ -704,6 +707,19 @@ export class ExecRunner {
                 total: runs.length,
                 aborted: event.outcome.aborted,
             });
+            return;
+        }
+        if (event.type === 'overseer') {
+            this.emit({
+                type: 'team',
+                sessionId: this.sessionId,
+                subtype: 'overseer',
+                label: event.label,
+                action: event.decision.action,
+                trigger: event.trigger,
+                reason: event.decision.reason,
+            });
+            return;
         }
     }
 }

package/dist/fast/limits.d.ts

@@ -76,7 +76,7 @@ export declare const FAST_LIMITS: {
      * A critique waiting for its injection window goes stale (RV-12).
      *
      * The window is not guaranteed to be prompt: one `task` dispatch is a single
-     * tool call that can run for `team.dispatchTimeoutMs`, so a critique triggered
+     * tool call that can run for as long as its children need, so a critique triggered
      * just before one arrives at the far side describing a state five children
      * have since rewritten. Advice that is merely late is worse than no advice,
      * because the lead cannot tell that it is late.
@@ -95,4 +95,4 @@ export declare const FAST_LIMITS: {
  * changes, so a behaviour report can be tied to a block revision with one grep -
  * exactly what `TEAM_BLOCK_VERSION` and `TODO_BLOCK_VERSION` are for.
  */
-export declare const FAST_BLOCK_VERSION = "v1-2026-07";
+export declare const FAST_BLOCK_VERSION = "v2-2026-10";

package/dist/fast/limits.js

@@ -76,7 +76,7 @@ export const FAST_LIMITS = {
      * A critique waiting for its injection window goes stale (RV-12).
      *
      * The window is not guaranteed to be prompt: one `task` dispatch is a single
-     * tool call that can run for `team.dispatchTimeoutMs`, so a critique triggered
+     * tool call that can run for as long as its children need, so a critique triggered
      * just before one arrives at the far side describing a state five children
      * have since rewritten. Advice that is merely late is worse than no advice,
      * because the lead cannot tell that it is late.
@@ -95,4 +95,4 @@ export const FAST_LIMITS = {
  * changes, so a behaviour report can be tied to a block revision with one grep -
  * exactly what `TEAM_BLOCK_VERSION` and `TODO_BLOCK_VERSION` are for.
  */
-export const FAST_BLOCK_VERSION = 'v1-2026-07';
+export const FAST_BLOCK_VERSION = 'v2-2026-10';

package/dist/fast/prompt.d.ts

@@ -19,23 +19,22 @@ export interface FastBlockParams {
     /** The resolved fast model id, interpolated so the prompt never names a model
      *  the tier will not actually use (§3.9 / RV-3). */
     model: string;
-    /** `fast.delegate` — whether `model: "fast"` is honoured on `task`. */
-    delegate: boolean;
     /** `fast.review` — whether `<fast_review>` blocks can appear at all. */
     review: boolean;
 }
 /**
- * The lead's `<fast_tier>` block. Under 1100 characters on purpose: it is paid
- * for on EVERY turn of every fast-enabled session, so anything that does not
- * change a delegation decision does not belong in it (R-11).
+ * The `<fast_tier>` block, spliced for the lead AND for task children running
+ * under a per-child reviewer. Under 1100 characters on purpose: it is paid for
+ * on EVERY turn of every fast-enabled session, so anything that does not change
+ * a decision does not belong in it (R-11).
  *
- * EACH PARAGRAPH IS PRESENT ONLY WHEN ITS CAPABILITY IS. `fast.delegate: false,
- * fast.review: true` advertises only the review, because telling a model about a
- * `model: "fast"` field that the normalizer will downgrade every time is how you
- * get a model that keeps asking for something it can never have.
+ * REVIEW-ONLY SIN MAIN-AGENT PARITY: every `task` child runs the lead's own
+ * model, so the block no longer advertises a per-child `model:"fast"`. Telling
+ * a model about a field that no longer exists is how you get a model that keeps
+ * asking for something it can never have.
  *
- * Returns `''` when neither capability is live, which the splice treats as "no
- * block" and which keeps the byte-identity branch intact.
+ * Returns `''` when the review is off, which the splice treats as "no block"
+ * and which keeps the byte-identity branch intact.
  */
 export declare function buildFastBlock(params: FastBlockParams): string;
 export interface ReviewSystemPromptParams {

package/dist/fast/prompt.js

@@ -16,33 +16,32 @@
 import { FAST_BLOCK_VERSION } from './limits.js';
 export { FAST_BLOCK_VERSION };
 /**
- * The lead's `<fast_tier>` block. Under 1100 characters on purpose: it is paid
- * for on EVERY turn of every fast-enabled session, so anything that does not
- * change a delegation decision does not belong in it (R-11).
+ * The `<fast_tier>` block, spliced for the lead AND for task children running
+ * under a per-child reviewer. Under 1100 characters on purpose: it is paid for
+ * on EVERY turn of every fast-enabled session, so anything that does not change
+ * a decision does not belong in it (R-11).
  *
- * EACH PARAGRAPH IS PRESENT ONLY WHEN ITS CAPABILITY IS. `fast.delegate: false,
- * fast.review: true` advertises only the review, because telling a model about a
- * `model: "fast"` field that the normalizer will downgrade every time is how you
- * get a model that keeps asking for something it can never have.
+ * REVIEW-ONLY SIN MAIN-AGENT PARITY: every `task` child runs the lead's own
+ * model, so the block no longer advertises a per-child `model:"fast"`. Telling
+ * a model about a field that no longer exists is how you get a model that keeps
+ * asking for something it can never have.
  *
- * Returns `''` when neither capability is live, which the splice treats as "no
- * block" and which keeps the byte-identity branch intact.
+ * Returns `''` when the review is off, which the splice treats as "no block"
+ * and which keeps the byte-identity branch intact.
  */
 export function buildFastBlock(params) {
-    if (!params.delegate && !params.review)
+    if (!params.review)
         return '';
-    const lines = [
+    return [
         '<fast_tier>',
         `A second, cheaper model is available in this session (${params.model}).`,
-    ];
-    if (params.delegate) {
-        lines.push('', 'Delegation: pass model:"fast" to a task subagent whose work is mechanical and', 'high-volume - reading or searching many files, summarizing long command output,', 'applying the same small edit in several places. Keep model:"main" (the default)', 'for design decisions, tricky debugging, and anything that has to be right the', 'first time. A fast subagent has the same tools and the same permissions as any', 'other; only the model differs.');
-    }
-    if (params.review) {
-        lines.push('', 'Reviews: every few turns a <fast_review> block may appear in the conversation.', 'It is an automated second opinion from the fast model - NOT a message from the', 'user. Treat it as advice: act on it when it is right, say so briefly and carry', 'on when it is not, and never ask the user to confirm it.');
-    }
-    lines.push('</fast_tier>');
-    return lines.join('\n');
+        '',
+        'Reviews: every few turns a <fast_review> block may appear in the conversation.',
+        'It is an automated second opinion from the fast model - NOT a message from the',
+        'user. Treat it as advice: act on it when it is right, say so briefly and carry',
+        'on when it is not, and never ask the user to confirm it.',
+        '</fast_tier>',
+    ].join('\n');
 }
 /**
  * The reviewer's own system prompt.

package/dist/fast/reviewer.d.ts

@@ -97,7 +97,7 @@ export interface FastReviewerDeps {
      * `FastWiring.snapshot()`, so the self-disable can announce itself.
      *
      * The reviewer cannot build a `FastSnapshot` on its own — `live`,
-     * `sameAsMain`, `delegated` and `pricingUnknown` all belong to the wiring —
+     * `sameAsMain` and `pricingUnknown` all belong to the wiring —
      * and the two existing `tier_changed` emitters read it the same way.
      */
     snapshot(): FastSnapshot;

package/dist/fast/reviewer.js

@@ -375,7 +375,7 @@ export class FastReviewer {
             return;
         this.budgetAnnouncedAt = limit;
         this.deps.notify('info', `Fast reviews: session budget reached (${limit}). ` +
-            `Delegation is unaffected. Raise it with /fast budget <n>.`);
+            `Raise it with /fast budget <n>.`);
         this.log.info('fast_review_budget_reached', { limit, reviews: this.reviewIndex });
     }
     // -----------------------------------------------------------------------

package/dist/fast/types.d.ts

@@ -107,8 +107,6 @@ export interface FastSnapshot {
      * report a budget reached for a session that never had one (RV-H10).
      */
     budgetReached: boolean;
-    /** Fast-tier children dispatched this session. */
-    delegated: number;
     usage: TokenUsage;
     /**
      * No price table for `model` (C-11 / RV-4).

package/dist/fast/wiring.d.ts

@@ -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
@@ -31,10 +31,10 @@
  * caused it (`agent-loop.ts:140-145`).
  */
 import type { ModelRole } from '../config/model-profiles.js';
-import { type AgentEvent, type AssistantMessage, type LLMRequest, type ModelRef, type ThinkingLevel } from '@aragon-agent/core';
+import { type AgentEvent, type AssistantMessage, type LLMRequest, type ModelRef } from '@aragon-agent/core';
 import type { CliConfig } from '../config/schema.js';
 import type { NoticeLevel } from '../agent/reducer.js';
-import type { FastEventListener, FastSnapshot, FastTier, FastTierName } from './types.js';
+import type { FastEventListener, FastSnapshot, FastTier } from './types.js';
 export interface FastWiringDeps {
     /** Read LIVE on every call - the controller replaces the object on mutation. */
     getConfig: () => CliConfig;
@@ -88,7 +88,6 @@ export declare class FastWiring {
     private tier;
     /** Warned once per TRANSITION, so a broken tier does not shout every turn. */
     private lastReportedReason;
-    private delegated;
     constructor(deps: FastWiringDeps);
     /**
      * The registry the REVIEW calls through — separate from the lead's, and
@@ -120,22 +119,13 @@ export declare 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(): boolean;
-    /**
-     * 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(): boolean;
     setEnabled(enabled: boolean): void;
     /**
      * Re-resolve the tier after ANY config mutation (§3.2 rule 8 / §3.9 / RV-3).
@@ -152,24 +142,18 @@ export declare class FastWiring {
      * (§3.3). Raised once, at construction, through the controller's `notify`.
      */
     startupNotice(): string | null;
+    /** The resolved fast `ModelRef`, or `null` - for cost lookups (§3.6). */
+    fastRef(): ModelRef | null;
     /**
-     * The `ModelRef` and thinking level one subagent tier runs on.
+     * 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`.
      *
-     * `'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).
+     * 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.
      */
-    resolveTier(tier: FastTierName): {
-        ref: ModelRef;
-        thinkingLevel: ThinkingLevel;
-        role?: ModelRole;
-    };
-    /** The resolved fast `ModelRef`, or `null` - for per-tier cost lookup (§3.6). */
-    fastRef(): ModelRef | null;
-    /** Count fast-tier children so `/fast status` can answer "is this saving me
-     *  anything?" — the aggregate on the status bar cannot. */
-    noteDelegated(count: number): void;
+    completeViaFastRegistry(providerId: string, request: LLMRequest): Promise<AssistantMessage>;
     setGoal(text: string): void;
     abort(): void;
     dispose(): void;