@aragon-agent/cli 0.6.16 → 0.6.17

package/README.md

@@ -409,7 +409,7 @@ signal ends the run (`130` SIGINT, `143` SIGTERM, `129` SIGHUP).
 | `/team [on\|off\|max <n>]` | Team subagents: status and the live roster, the on/off switch, the fan-out width |
 | `/todo [on\|off\|panel on\|off\|follow <mode>\|clear\|continue]` | Todo planning: status, the on/off switch, the rail, follow-through, and picking an unfinished plan back up |
 | `/retry [show\|on\|off\|max <n>]` | API retry: the effective ladder, the on/off switch, the retry count. Takes effect **in the running session**, children included |
-| `/fast [on\|off\|model <id>\|provider <id>\|same\|review <n\|off>\|delegate on\|off]` | Fast model tier: status and this session's totals, the on/off switch, which model, the review cadence |
+| `/fast [on\|off\|model <id>\|provider <id>\|same\|review <n\|off>]` | Fast model tier: status and this session's totals, the on/off switch, which model, the review cadence |
 | `/compact [status\|on\|off\|threshold <n>\|keep <n>\|history\|show <n>\|<instructions>]` | Context compaction: occupancy and this session's totals, the on/off switch, when it fires, how much it keeps. With free text, compacts now and tells the summarizer what to pay attention to |
 | `/context` | What the context gauge is showing: occupancy split into measured and estimated, the window and **where it came from**, how stale the measurement is, compaction's actual state, and what the session-spend readout includes |
 | `/bg [list\|logs <id> [n]\|stop <id\|all>\|status]` | Background services: what is running, its log tail, and how to stop it. `list` is the default |
@@ -810,9 +810,11 @@ still exits the session outright.
 
 ### Where the mode is shown
 
-The status bar always names a non-default mode (`PLAN`, or `PLAN → BUILD` while
-a switch is pending), including on short terminals and with `--no-hints`. The composer additionally shows a `PLAN` chip on its hint row and
-tints its border, where there is room for it.
+The status bar's first row always names the current mode (`BUILD` or `PLAN`,
+an accent word right after the run state; `PLAN>BUILD` while a switch is
+pending; `B` / `P` / `P>B` when the terminal is narrow), including on short
+terminals and with `--no-hints`. The Ctrl+G details row repeats it, and the
+composer tints its border in plan mode.
 
 ### Switching mid-run
 
@@ -821,7 +823,7 @@ during a run takes effect immediately — you pressed it *because* the agent is
 about to do something. Pressing it toward `BUILD` during a run is **deferred to
 the end of the run**, so a session you launched under a read-only guarantee
 cannot start writing files because of one stray keypress. The status bar shows
-`PLAN → BUILD` while that is pending. Approving a plan is the one exception, and
+`PLAN>BUILD` while that is pending. Approving a plan is the one exception, and
 it is an informed act rather than a stray keypress.
 
 ### If `Shift+Tab` does nothing
@@ -839,7 +841,7 @@ node -e "process.stdin.setRawMode(true);process.stdin.resume();process.stdin.on(
 | It prints | What it means |
 | --- | --- |
 | `09` | The console is swallowing the modifier — the key is arriving as an ordinary `Tab`. Check `node -v`: below 22.17.0 (or on 24.0/24.1) this is expected, and aragon's own attempt to fix it was blocked. See [Requirements](#requirements) |
-| `1b5b5a` | The key reaches the process fine, so something inside aragon is eating it — most often an overlay is open, or the run is still going and the switch is pending (the status bar shows `BUILD → PLAN`) |
+| `1b5b5a` | The key reaches the process fine, so something inside aragon is eating it — most often an overlay is open, or the run is still going and the switch is pending (the status bar shows `PLAN>BUILD`) |
 | nothing | Your terminal, multiplexer or remote-desktop stack never sent it; some never send `CSI Z` at all |
 
 On the first row the wheel is dead for the same reason, and with the `/` palette
@@ -1184,25 +1186,24 @@ children's tokens are folded into the `[usage]` footer.
 ## Fast model tier
 
 A second, cheaper model can be made a first-class citizen of a session. It is
-**off by default** — with `fast.enabled: false` the system prompt, the `task`
-tool schema, the transcript and the request payloads are exactly what they were
-before this feature existed — and it buys you two things once you turn it on.
-
-**Delegation (the agent decides).** `task` gains one optional field per
-subagent, `model: "fast"`. A child marked that way runs on the fast model and is
-otherwise identical: same tools, same working directory, same `--confirm` gate,
-same plan-mode gate, same skills ceiling. Delegating to a cheaper model is a
-*model* choice, never a permission boundary. This is where "not complicated, but
-very expensive in context" is actually paid for: a child that reads nine files
-and reports four sentences moves ~200 KB of file bodies out of the lead's window
-and onto a model that costs a fraction as much per token.
+**off by default** — with `fast.enabled: false` the system prompt, the
+transcript and the request payloads are exactly what they were before this
+feature existed — and it buys you two things once you turn it on.
+
+**Every `task` child runs the lead's own model.** Per-child fast dispatch
+(`model: "fast"`) was removed for main-agent parity: a delegation is never a
+downgrade, and all the gates (tools, working directory, `--confirm`, plan mode,
+skills ceiling, compaction policy) are the lead's own.
 
 **Periodic review (the harness decides).** Every *N* completed turns, a small
 digest of what the lead has been doing goes to the fast model with one question
 — is this still on track? — and if the answer is not "on track" it is injected
 back into the running loop as a `<fast_review>` block. The lead sees a short
 second opinion mid-run, when it can still act on it, for a few hundred tokens
-instead of a second full-size turn.
+instead of a second full-size turn. **Subagents get the same review**: when the
+tier is live and `fast.review` is on, each dispatched child runs with its own
+reviewer — same cadence, same budget per child, same fail-fast transport — so a
+team is as capable as the agent that dispatched it.
 
 ```
 > refactor the config loader and keep the tests green
@@ -1224,7 +1225,7 @@ separately. If the fast model is not in the built-in price table the number is
 shown as `unknown` rather than as `$0.00` — a feature that looks free while it
 is spending money is worse than one that admits it does not know.
 
-**The review has a session budget, and delegation deliberately does not.** A
+**The review has a session budget.** A
 session is not one run — it is one run per message you send — so a cadence alone
 bounds nothing over a working afternoon. `fast.reviewMaxPerSession` (default
 **40**) is the total number of reviews a session may *start*; reaching it prints
@@ -1233,9 +1234,7 @@ first review rather than a bare count you can only size afterwards. Raise it liv
 with `/fast budget 80`. The budget is denominated in **reviews, not currency**,
 because the fast tier is precisely where a model the price table has never seen
 lives — a dollar ceiling would silently never fire for the configuration that
-most needs one. Delegation is never budgeted: it is spend the lead chose in
-service of a message you sent, it is already bounded by `team.*`, and it exists
-to *reduce* total cost.
+most needs one.
 
 ### Turning it on
 
@@ -1255,9 +1254,8 @@ cannot grow a field mid-session.
 | `fast.provider` | `''` | Empty inherits the main provider. |
 | `fast.model` | `''` | The fast model id. Empty means *not configured* — it never falls back to the main model, so "same as main" stays distinguishable from a typo. |
 | `fast.baseUrl` | `''` | Empty inherits the session's base URL **only** when the provider matches. |
-| `fast.thinkingLevel` | `'off'` | Applied to fast children and to reviews. |
-| `fast.delegate` | `true` | Allow `model:"fast"` on `task`. |
-| `fast.review` | `true` | Run the periodic review. |
+| `fast.thinkingLevel` | `'off'` | Applied to reviews (lead and subagents) and to fast-tier compaction summaries. |
+| `fast.review` | `true` | Run the periodic review — for the lead and for every `task` child. |
 | `fast.reviewEveryTurns` | `5` | Turns between reviews (1–50). |
 | `fast.reviewContextTurns` | `3` | Turns included in one digest (1–10). |
 | `fast.reviewMaxChars` | `280` | Ceiling on an injected critique (80–600). |
@@ -1281,7 +1279,6 @@ reporting one:
 /fast same                 run the fast tier on the main model
 /fast review <n> | off
 /fast budget [n]           the session review budget; bare form reads it
-/fast delegate on | off
 ```
 
 `/fast budget` with no argument is a **read**, so it is answerable while a `task`
@@ -1290,9 +1287,8 @@ like every other `/fast` setting.
 
 **What you see.** A `fast` chip in the status bar's right cluster while the tier
 is live (`fast*` while a review is in flight, dropped below 100 columns), a
-one-line card per review in the transcript, and `n fast` plus a trailing `~` on
-fast children in the team roster. `/fast status` reports the session totals the
-status bar cannot: reviews run, children delegated, tokens and cost. Under `-p`
+one-line card per review in the transcript. `/fast status` reports the session totals the
+status bar cannot: reviews run, tokens and cost. Under `-p`
 nothing extra is written to stdout or stderr — the review spend is folded into
 the `[usage]` footer and the reviews are in the log.
 
@@ -1558,19 +1554,20 @@ refusal is explained. Automatic tail clipping and failure truncation are disable
 
 ### Sub-agents get the same protection
 
-A `task` child is bounded by `team.maxTurnsPerSubagent` (24) and
-`team.dispatchTimeoutMs` (15 minutes) — the same profile as a lead run that fills
-a window. When a child overflowed, its history was discarded and the whole
-dispatch reached you as one partial sentence.
-
-Children now compact their own history, under tighter bounds: **two** retained
-turns instead of four, at most **two** compactions per child instead of five, the
-fast tier preferred whenever it resolves, and failures preserve history. Each
+Children compact their own history **under the lead's own policy**: the same
+`keepRecentTurns`, the same `onFailure`, the same archive setting, the same
+per-run compaction bound, the fast tier preferred whenever it resolves. Each
 child owns its own context meter and counts compaction only after Core accepts
 the candidate. There is no transcript card for a
 child — the lead's transcript describes the lead's context. Turn it off with
 `compaction.subagents: false`.
 
+Since main-agent parity, the turn cap, the per-child wall clock and the dispatch
+wall clock all default to **0 = no limit**: a child runs until it finishes, like
+the lead, with only its own idle watchdog and your Esc as ceilings. Set any of
+`team.subagentTimeoutMs` / `team.dispatchTimeoutMs` / `team.maxTurnsPerSubagent`
+to a positive value to bring a ceiling back.
+
 ### A compaction is no longer irreversible
 
 After a splice is adopted, the dropped messages are written verbatim to
@@ -1959,9 +1956,9 @@ env / `.env` → CLI flags**.
 | `team.enabled` | `true` | Master switch for team subagents. `false` means the `task` tool is never registered — `/team on` in such a session saves the setting for next launch and says so, rather than advertising a tool that is not there. |
 | `team.maxSubagents` | `5` | Subagents per dispatch, clamped to `[1, 10]`. The 10 is the hard ceiling and is enforced twice — on the config value and again on what the model asks for — so hand-editing this file cannot raise it. |
 | `team.maxConcurrent` | `3` | Subagents in flight at once, clamped to `[1, 10]` and capped at `maxSubagents`. A separate knob because provider rate limits are a different constraint from context economics. |
-| `team.subagentTimeoutMs` | `300000` | One subagent's wall clock before it is aborted, clamped to `[30000, 1800000]`. A wedged subagent dies on its own ceiling without taking the dispatch with it. |
-| `team.dispatchTimeoutMs` | `900000` | The whole dispatch's wall clock, clamped to `[60000, 3600000]`. |
-| `team.maxTurnsPerSubagent` | `24` | Runaway-loop cap, clamped to `[4, 100]`. A subagent stopped here is reported as `stopped: turn cap reached`, with whatever it had produced. |
+| `team.subagentTimeoutMs` | `0` | One subagent's wall clock before it is aborted, clamped to `[0, 1800000]`. `0` (the default) = no ceiling — a wedged subagent still dies on its own idle watchdog, exactly like the lead. |
+| `team.dispatchTimeoutMs` | `0` | The whole dispatch's wall clock (and the `task` tool timeout), clamped to `[0, 3600000]`. `0` (the default) = no ceiling; only Esc ends a dispatch early. |
+| `team.maxTurnsPerSubagent` | `0` | Runaway-loop cap, clamped to `[0, 100]`. `0` (the default) = no cap, matching the lead. A subagent stopped at a positive cap is reported as `stopped: turn cap reached`, with whatever it had produced. |
 | `todo.enabled` | `true` | Master switch for todo planning. `false` means the `todo_write` tool is never registered — `/todo on` in such a session saves the setting for next launch and says so, rather than advertising a tool that is not there. |
 | `todo.panel` | `true` | Render the right-hand rail. Independent of `todo.enabled` on purpose: a screen-reader user wants the planning discipline without the column, and the system prompt varies one sentence accordingly. |
 | `todo.followThrough` | `"notify"` | What happens when a run ends with steps left. `notify` says so and stops; `auto` continues the plan after a 3-second grace window, bounded by two structural limits (one fruitless attempt, 25 continuations per plan) that are deliberately **not** settings; `off` is silent. An unrecognized value falls back to `notify`. |
@@ -1972,7 +1969,7 @@ env / `.env` → CLI flags**.
 | `retry.multiplier` | `2` | Growth factor, clamped to `[1, 5]`. The one **float** key in this section: `2.5` is a legitimate factor and is stored as typed. |
 | `retry.jitter` | `true` | Equal jitter (`d/2 + rand·d/2`), which de-correlates concurrent subagents hitting the same 429 while keeping the announced countdown within a factor of two of the truth. Full jitter can fire 40 ms after announcing 30 s, which reads as a bug. |
 | `retry.respectRetryAfter` | `true` | Honour `Retry-After` (and the provider rate-limit reset headers) as a **floor**, never a replacement — a `Retry-After: 1` on the ninth retry does not undo eight retries of backoff. A stated wait above 60 s is surfaced immediately instead of waited out. |
-| `retry.maxElapsedMs` | `240000` | Wall-clock budget from the first failure, clamped to `[10000, 1800000]`. Deliberately **below** `team.subagentTimeoutMs`: an equal budget means a subagent is killed at the same instant its ladder ends, and the user is then told "subagent timed out" for what was a provider outage. |
+| `retry.maxElapsedMs` | `240000` | Wall-clock budget from the first failure, clamped to `[10000, 1800000]`. When `team.subagentTimeoutMs` is positive, keep this below it: an equal budget means a subagent is killed at the same instant its ladder ends, and the user is then told "subagent timed out" for what was a provider outage. |
 | `retry.onPartialStream` | `true` | Allow a restart after content has already streamed to the transcript. The view is rewound and the discarded tool cards removed; engine history is provably clean at that point, because it is only written on a completed turn. `false` refuses the whole path. |
 | `skills.enabled` | `true` | Master switch for the skill system. |
 | `skills.requireApproval` | `true` | Require a human to approve `skill_install` / `skill_create`. |
@@ -2364,19 +2361,19 @@ node packages/cli/dist/cli.js --version
 - `echo "list files" | node dist/cli.js -p` prints an answer and exits `0`.
 - A missing/invalid key produces a visible, actionable message (never a blank
   screen), both in the TUI and headless.
-- `Shift+Tab` at 40, 80 and 120 columns - the chip, the hint and the status bar
-  are all legible and nothing wraps onto a second row.
+- `Shift+Tab` at 40, 80 and 120 columns - the status-bar mode word (`PLAN` / `P`)
+  stays legible and nothing wraps onto a second row.
 - The question wizard at 24 rows with 5 questions x 4 options - no clipping, and
   the `n/N` counter matches what is on screen.
 - Approve a plan and watch the SAME run start writing files, with no second
   prompt.
-- `--no-color` on a legacy `cmd.exe` - the chip renders `[PLAN]`, radios render
-  `*`/`o`, checkboxes render `[x]`/`[ ]`, no mojibake anywhere.
+- `--no-color` on a legacy `cmd.exe` - the mode word renders as plain `PLAN` text,
+  radios render `*`/`o`, checkboxes render `[x]`/`[ ]`, no mojibake anywhere.
 - A plan with a 600-character summary and a 400-character step detail - the text
   wraps and scrolls, the footer count matches the real number of rows, and
   nothing is truncated to a single line.
 - `--no-hints` on a 20-row terminal in plan mode - the status bar still says
-  `PLAN` with no chip on screen.
+  `PLAN`.
 - Dismiss a plan card with `Esc`, let the agent resubmit, then close the card and press `Esc` twice within 1.5 seconds:
   the run aborts and the session returns to an idle prompt. Do this one BY HAND
   as well as in a test - the point of the check is whether the exit is findable,

package/dist/agent/controller.js

@@ -12,6 +12,7 @@ import { createBuiltinTools } from '../tools/index.js';
 import { createFileChangeStore } from '../tools/file-change-store.js';
 import { createToolOutputStore, } from '../tools/tool-output-store.js';
 import { TeamRuntime } from '../team/runtime.js';
+import { createChildReviewer } from '../team/child-reviewer.js';
 import { TeamHumanQueue } from '../team/human-queue.js';
 import { createTaskTool } from '../team/task-tool.js';
 import { buildTeamBlock } from '../team/prompt.js';
@@ -161,14 +162,14 @@ export class AgentController {
     // Fast model tier (fast-model-tier §3.1 / §3.3)
     //
     // ONE FIELD AND FOUR THIN FORWARDERS. The flag pair, the tier cache, the
-    // reviewer's lifetime and the `resolveTier` closure all live in
+    // reviewer's lifetime and the shared fail-fast review transport all live in
     // `fast/wiring.ts`, which is a BUDGET decision rather than an aesthetic one
     // (C-12 / RV-5): `CLAUDE.md` caps a source file at 1000 lines and this one had
     // 40 to spare when the design was written.
     //
     // `null` when the tier could not be resolved at construction, which is the
-    // byte-identity branch: no reviewer is subscribed, `task` carries no `model`
-    // property, and `<fast_tier>` is never spliced (I-2).
+    // byte-identity branch: no reviewer is subscribed and `<fast_tier>` is
+    // never spliced (I-2).
     // -----------------------------------------------------------------------
     fast;
     // -----------------------------------------------------------------------
@@ -311,8 +312,8 @@ export class AgentController {
         this.todos = this.todoRegistered ? new TodoStore() : null;
         // --- Fast model tier ---------------------------------------------------
         //
-        // RESOLVED BEFORE THE TOOL ARRAY, because `fastRegistered` decides whether
-        // `task`'s schema carries a `model` property at all and the array is built
+        // RESOLVED BEFORE THE AGENT, because `fastRegistered` decides whether the
+        // `FastWiring` (reviewer, tier cache) exists at all and the wiring is built
         // ONCE (C-2). `FastWiring` re-runs the same pure function in its own
         // constructor; the two agree by construction because they read the same
         // config through the same resolver.
@@ -324,24 +325,35 @@ export class AgentController {
         this.teamRuntime = this.teamRegistered
             ? new TeamRuntime({
                 getConfig: () => this.config,
-                // Read LIVE through the wiring, exactly as `resolveTier` below is: the
-                // closure is only ever called from inside a dispatch, and
-                // `childFactory()` re-reads `compaction.subagents` on every call so a
-                // settings-screen edit reaches the next dispatch.
+                // Read LIVE: the closure is only ever called from inside a dispatch,
+                // and `childFactory()` re-reads `compaction.subagents` on every call
+                // so a settings-screen edit reaches the next dispatch.
                 contextManagerFor: (req) => this.compaction?.childFactory()?.(req),
-                // Read LIVE through the wiring, which does not exist yet — the closure
-                // is only ever called from inside a dispatch, long after construction.
-                resolveTier: (tier) => this.fast
-                    ? this.fast.resolveTier(tier)
-                    : {
-                        ref: {
-                            providerId: this.config.provider,
-                            modelId: this.config.model,
-                            ...(this.config.baseUrl ? { baseUrl: this.config.baseUrl } : {}),
-                        },
-                        thinkingLevel: this.config.thinkingLevel,
-                        role: 'main',
+                // PER-CHILD FAST REVIEW (main-agent parity): one reviewer per
+                // child, sharing the lead wiring's tier, policy and fail-fast
+                // transport. `this.fast` is null until after the Agent exists; these
+                // closures run only from inside a dispatch, long after construction.
+                review: {
+                    // EVERY `this.fast` READ LIVES INSIDE A CLOSURE: the wiring is
+                    // assigned AFTER this constructor block (it needs the Agent), and
+                    // a read in the constructor's own flow would be a use-before-assign.
+                    // The closures run only from inside a dispatch, long after
+                    // construction, when the field has its final value.
+                    active: () => this.fast !== null && this.fast.available() && this.config.fast.review,
+                    modelId: () => {
+                        const tier = this.fast?.getTier();
+                        return tier && tier.ok ? tier.ref.modelId : '';
                     },
+                    create: (request) => this.fast
+                        ? createChildReviewer(request, {
+                            getConfig: () => this.config,
+                            hasKey: (id, role) => this.hasApiKey(id, role),
+                            getApiKey: (id, role) => this.resolveKey(id, role),
+                            complete: (providerId, llmRequest) => this.fast.completeViaFastRegistry(providerId, llmRequest),
+                            available: () => this.fast?.available() === true,
+                        })
+                        : undefined,
+                },
                 providerRegistry: this.providerRegistry,
                 getCwd: () => this.cwd,
                 getMode: () => this.effectiveMode,
@@ -488,23 +500,12 @@ export class AgentController {
                         runtime: this.teamRuntime,
                         // Read LIVE: `/team off` flips the flag, it cannot unregister.
                         isTeamEnabled: () => this.teamEnabled,
-                        // FROZEN AT CONSTRUCTION (C-2). `/fast on` in a session launched
-                        // without the tier cannot add a schema property, and it says so
-                        // rather than advertising one that is not there.
-                        fastRegistered,
-                        // Read LIVE at dispatch time (RV-3): the tier can stop resolving
-                        // mid-session, and the normalizer and the subagent factory must
-                        // agree about that at the same instant.
-                        fastAvailable: () => this.fast?.delegationAvailable() === true,
                         maxSubagents: () => this.config.team.maxSubagents,
                         hasApiKey: () => this.hasApiKey(),
                         activeProvider: () => this.config.provider,
+                        // Every child runs the lead's own model, so the lead's cost table
+                        // is the one honest price for the dispatch total.
                         modelCost: () => this.getModelInfo().cost,
-                        fastModelCost: () => {
-                            const ref = this.fast?.fastRef();
-                            return ref ? this.getModelInfoFor(ref).cost : undefined;
-                        },
-                        fastPricingUnknown: () => this.fast?.snapshot().pricingUnknown === true,
                         withPausedWatchdog: (fn) => this.withPausedWatchdog(fn),
                     }),
                 ]
@@ -603,6 +604,10 @@ export class AgentController {
                     // number only bites BECAUSE `task` races `ctx.signal` — the
                     // executor's timeout is cooperative, so an override is inert for any
                     // tool that does not listen (I-2).
+                    //
+                    // `dispatchTimeoutMs: 0` (the default) reaches the executor as an
+                    // override of `0` = NO TIMER AT ALL: the dispatch lasts as long as its
+                    // slowest child, and only an Esc ends it early (main-agent parity).
                     ...(this.teamRegistered ? { task: config.team.dispatchTimeoutMs } : {}),
                 },
             },
@@ -672,13 +677,6 @@ export class AgentController {
         });
         if (this.fast) {
             this.rebuildSystemPrompt();
-            // Fast-tier children are counted from the outcome rather than from the
-            // specs, so a downgraded child is not miscounted as a saving (§3.6).
-            this.teamRuntime?.subscribe((event) => {
-                if (event.type !== 'dispatch_end')
-                    return;
-                this.fast?.noteDelegated(event.outcome.runs.filter((r) => r.tier === 'fast').length);
-            });
         }
         // ONE LINE FOR THE TWO CONFIGURATION MISTAKES THAT ARE OTHERWISE INVISIBLE
         // (§3.3): the tier is on but unnamed, or named against a provider with no
@@ -738,11 +736,6 @@ export class AgentController {
                 ? buildTeamBlock({
                     maxSubagents: config.team.maxSubagents,
                     maxConcurrent: config.team.maxConcurrent,
-                    // One cross-reference sentence, present only when the capability
-                    // is (§3.8). `this.fast` is null during the FIRST compose (the
-                    // wiring needs the Agent), which is why the constructor composes
-                    // again once it exists.
-                    fastDelegation: !!fastAvailable && config.fast.delegate,
                 })
                 : '',
             // BOTH FLAGS, exactly as team mode uses both, and for the identical
@@ -762,7 +755,6 @@ export class AgentController {
             fastBlock: fastAvailable
                 ? buildFastBlock({
                     model: tier.ok ? tier.ref.modelId : '',
-                    delegate: config.fast.delegate,
                     review: config.fast.review,
                 })
                 : '',

package/dist/agent/reducer.js

@@ -860,10 +860,6 @@ export function viewReducer(state, action) {
             const runs = action.specs.map((spec) => ({
                 label: spec.label,
                 description: spec.description,
-                // Already downgraded by the normalizer when the tier was unavailable, so
-                // the card and the report agree from the first frame (fast-model-tier
-                // §3.4).
-                tier: spec.tier,
                 phase: 'queued',
                 turns: 0,
                 toolCalls: 0,

package/dist/cli.js

@@ -160,11 +160,6 @@ function toFlags(opts) {
         fastModel: opts.fastModel,
         fastProvider: opts.fastProvider,
         fastReview: opts.fastReview,
-        // …and again for `--fast-delegate` / `--no-fast-delegate`, one feature
-        // later — NINE features, one trap. It is `fast.delegate`'s only channel:
-        // there is no `ARAGON_FAST_DELEGATE`, so missing this line leaves a wrapper
-        // with no way at all to say "do not delegate on this run".
-        fastDelegate: opts.fastDelegate,
         // `--verbose` is just a shorthand for `--log-level debug`; an explicit
         // `--log-level` still wins, so the two can be combined without surprise.
         logLevel: opts.logLevel ?? (opts.verbose ? 'debug' : undefined),
@@ -1537,14 +1532,6 @@ function buildProgram() {
         .option('--fast-model <id>', 'The fast model id (implies nothing about --fast)')
         .option('--fast-provider <id>', 'Provider for the fast model (default: the main provider)')
         .option('--fast-review <n|off>', 'Turns between automatic fast reviews, or "off"')
-        // BOTH FORMS, POSITIVE FIRST, and here it matters more than anywhere above:
-        // `fast.delegate` is PERSISTED and defaults to TRUE, so declaring only
-        // `--no-fast-delegate` would make commander default `opts.fastDelegate` to
-        // `true` and force `delegate: true` on EVERY run that passed no flag at all
-        // — silently overwriting a user's stored `false`. Same polarity, same trap
-        // and same fix as `--update` / `--compaction`.
-        .option('--fast-delegate', 'Let the fast tier take mechanical sub-steps (the default)')
-        .option('--no-fast-delegate', 'Run every sub-step on the main model')
         // BOTH FORMS, positive first, for the reason recorded seven times above —
         // and this is the pair whose omission would be worst. `update.mode` is
         // PERSISTED and defaults to `'auto'`, so a lone `--no-update` would make

package/dist/commands/builtins.js

@@ -106,8 +106,7 @@ function formatFastStatus(controller) {
     else {
         lines.push(`Fast tier: ${state}. Model: ${cfg.model || '(not set)'}.`);
     }
-    lines.push(`Review: ${cfg.review ? `every ${cfg.reviewEveryTurns} turns` : 'off'}. ` +
-        `Delegation: ${cfg.delegate ? 'on' : 'off'}.`);
+    lines.push(`Review: ${cfg.review ? `every ${cfg.reviewEveryTurns} turns` : 'off'}.`);
     const snapshot = status.snapshot;
     const cost = snapshot.pricingUnknown
         ? `unknown (no price table for ${snapshot.model})`
@@ -124,7 +123,6 @@ function formatFastStatus(controller) {
     // numbers are `0` placeholders and `reviews >= reviewBudget` would be true.
     const budget = snapshot.budgetReached ? ' (budget reached - raise with /fast budget <n>)' : '';
     lines.push(`This session: ${snapshot.reviews}/${snapshot.reviewBudget} reviews${budget}, ` +
-        `${snapshot.delegated} delegated subagents, ` +
         `in ${formatTokens(snapshot.usage.inputTokens)} / out ` +
         `${formatTokens(snapshot.usage.outputTokens)}, cost ${cost}.`);
     return lines.join('\n');
@@ -339,7 +337,7 @@ const COMMANDS = [
     {
         name: 'fast',
         description: 'Fast model tier: status | on | off | model <id> | provider <id> | same | ' +
-            'review <n|off> | budget <n> | delegate on|off',
+            'review <n|off> | budget <n>',
         /**
          * `/fast on` CANNOT turn the tier on in a session that started without it,
          * for the reason `/team on` above records at length: the tool array is built
@@ -516,20 +514,8 @@ const COMMANDS = [
                     `${snapshot.reviews} used.`);
                 return;
             }
-            if (verb === 'delegate') {
-                const raw = (value ?? '').trim().toLowerCase();
-                if (raw !== 'on' && raw !== 'off') {
-                    ctx.notify('warn', 'Usage: /fast delegate <on|off>');
-                    return;
-                }
-                if (!persist({ delegate: raw === 'on' }))
-                    return;
-                ctx.toast('success', `Fast delegation ${raw}.`);
-                return;
-            }
             ctx.notify('warn', `Unknown argument "${verb}" - use /fast ` +
-                '[status|on|off|model <id>|provider <id>|same|review <n|off>|budget <n>|' +
-                'delegate on|off].');
+                '[status|on|off|model <id>|provider <id>|same|review <n|off>|budget <n>].');
         },
     },
     {

package/dist/compaction/child.d.ts

@@ -13,15 +13,17 @@
  * turn the child already ran, and receives one partial sentence for all of it.
  * Two fast-model summarizations is the cheap side of that trade.
  *
- * A CHILD MANAGER IS THE SAME `Compactor` UNDER A DIFFERENT POLICY, and the
- * overlay needs TWO mechanisms rather than one (RV-2):
+ * SINCE MAIN-AGENT PARITY, A CHILD MANAGER RUNS THE LEAD'S OWN POLICY. The only
+ * overlay left is the CONNECTION (provider / model / base URL / manual window),
+ * which must follow the model the child actually runs on. `keepRecentTurns`,
+ * `onFailure`, `useFastTier`, `archive` and the per-run compaction bound are all
+ * read from the SAME live config the lead reads, so a user who tunes compaction
+ * tunes every child identically - the requirement "same mode and configuration
+ * as the main agent", taken literally.
  *
- *   A. A CONFIG VIEW, for `keepRecentTurns` / `onFailure` / `useFastTier`, which
- *      `Compactor` reads through `deps.getConfig()`.
- *   B. AN INSTANCE BOUND, for `maxPerRun`, which is STRUCTURAL and has no config
- *      path by design (`limits.ts` header). Without it the child silently
- *      inherits the lead's 5 - two and a half times the bound the reversal above
- *      rests on.
+ * THE INSTANCE BOUND stays (mechanism B of RV-2) because `maxPerRun` is
+ * STRUCTURAL with no config path by design (`limits.ts` header); it is now the
+ * SAME `COMPACTION_LIMITS.maxPerRun` the lead's own manager runs under.
  *
  * NO UI. A child's compaction produces no transcript card (DH-7): the lead's
  * transcript describes the LEAD's context, and a card there would claim the

package/dist/compaction/child.js

@@ -13,15 +13,17 @@
  * turn the child already ran, and receives one partial sentence for all of it.
  * Two fast-model summarizations is the cheap side of that trade.
  *
- * A CHILD MANAGER IS THE SAME `Compactor` UNDER A DIFFERENT POLICY, and the
- * overlay needs TWO mechanisms rather than one (RV-2):
+ * SINCE MAIN-AGENT PARITY, A CHILD MANAGER RUNS THE LEAD'S OWN POLICY. The only
+ * overlay left is the CONNECTION (provider / model / base URL / manual window),
+ * which must follow the model the child actually runs on. `keepRecentTurns`,
+ * `onFailure`, `useFastTier`, `archive` and the per-run compaction bound are all
+ * read from the SAME live config the lead reads, so a user who tunes compaction
+ * tunes every child identically - the requirement "same mode and configuration
+ * as the main agent", taken literally.
  *
- *   A. A CONFIG VIEW, for `keepRecentTurns` / `onFailure` / `useFastTier`, which
- *      `Compactor` reads through `deps.getConfig()`.
- *   B. AN INSTANCE BOUND, for `maxPerRun`, which is STRUCTURAL and has no config
- *      path by design (`limits.ts` header). Without it the child silently
- *      inherits the lead's 5 - two and a half times the bound the reversal above
- *      rests on.
+ * THE INSTANCE BOUND stays (mechanism B of RV-2) because `maxPerRun` is
+ * STRUCTURAL with no config path by design (`limits.ts` header); it is now the
+ * SAME `COMPACTION_LIMITS.maxPerRun` the lead's own manager runs under.
  *
  * NO UI. A child's compaction produces no transcript card (DH-7): the lead's
  * transcript describes the LEAD's context, and a card there would claim the
@@ -45,11 +47,11 @@ export function createChildContextManager(req, deps) {
      * which is the same reason `subagent.ts` reuses the lead's `getApiKey` closure
      * rather than the resolved key.
      *
-     * `useFastTier: true` EXPRESSES A PREFERENCE, NOT AN OUTCOME. `resolveFastTier`
-     * still decides, and when nothing resolves the child falls back exactly as the
-     * lead does - to its OWN model, because `provider` / `model` are overlaid here
-     * too.
-     *
+     * `useFastTier` is read LIVE from the base config (main-agent
+     * parity - no overlay): it expresses a PREFERENCE, not an outcome.
+     * `resolveFastTier` still decides, and when nothing resolves the child
+     * falls back exactly as the lead does - to its OWN model, because
+     * `provider` / `model` are overlaid here too.
      * Failed summaries preserve the child's task just as they preserve the lead's.
      */
     const childConfig = () => {
@@ -63,16 +65,11 @@ export function createChildContextManager(req, deps) {
             baseUrl: req.model.baseUrl,
             // The lead's manual limit describes its connection, not every worker.
             contextWindow: sameConnection ? base.contextWindow : null,
-            compaction: {
-                ...base.compaction,
-                keepRecentTurns: COMPACTION_LIMITS.childKeepRecentTurns,
-                onFailure: 'stop',
-                useFastTier: true,
-                // ONE ARCHIVE PER LEAD COMPACTION IS AUDITABLE; TWENTY PER DISPATCH IS
-                // NOISE. The child's dropped slice is therefore never retained either -
-                // `runCompaction` reads this key before it stashes anything.
-                archive: false,
-            },
+            // NO POLICY OVERLAY (main-agent parity): `keepRecentTurns`, `onFailure`,
+            // `useFastTier` and `archive` are read LIVE from the base config, so the
+            // child compacts under exactly the policy the lead compacts under. A
+            // settings-screen edit mid-dispatch reaches a running child because this
+            // view is re-read on every call.
         };
     };
     const meter = new ContextMeter({
@@ -121,8 +118,9 @@ export function createChildContextManager(req, deps) {
         // user's transcript with no card to explain which agent it is about.
         notify: () => { },
     }, 
-    // MECHANISM B - the instance bound (RV-2 / DH-16).
-    { maxPerRun: COMPACTION_LIMITS.childMaxPerRun });
+    // MECHANISM B - the instance bound (RV-2 / DH-16). The SAME bound the
+    // lead's own manager runs under (main-agent parity).
+    { maxPerRun: COMPACTION_LIMITS.maxPerRun });
     return {
         // THERE IS NO `/compact` FOR A CHILD, so nothing is ever queued and the
         // manual branch of `shouldCompact` is unreachable by construction.

package/dist/compaction/limits.d.ts

@@ -28,8 +28,6 @@ export declare const COMPACTION_LIMITS: {
     readonly archiveMaxFiles: 20;
     readonly archiveMaxAgeMs: 604800000;
     readonly archiveMaxBytes: 8000000;
-    readonly childKeepRecentTurns: 2;
-    readonly childMaxPerRun: 2;
     readonly cardTextRows: 6;
     readonly statusCompactCols: 100;
 };

package/dist/compaction/limits.js

@@ -29,8 +29,6 @@ export const COMPACTION_LIMITS = {
     archiveMaxFiles: 20,
     archiveMaxAgeMs: 604_800_000,
     archiveMaxBytes: 8_000_000,
-    childKeepRecentTurns: 2,
-    childMaxPerRun: 2,
     cardTextRows: 6,
     statusCompactCols: 100,
 };

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

@@ -42,7 +42,7 @@ export declare const RETRY_CONFIG_SET_KEYS: readonly ["retry.enabled", "retry.ma
  * would silently never take effect, and `config set` would still print
  * `Set fast.model = haiku`.
  */
-export declare const FAST_CONFIG_SET_KEYS: readonly ["fast.enabled", "fast.provider", "fast.model", "fast.baseUrl", "fast.thinkingLevel", "fast.delegate", "fast.review", "fast.reviewEveryTurns", "fast.reviewContextTurns", "fast.reviewMaxChars", "fast.reviewMaxPerSession"];
+export declare const FAST_CONFIG_SET_KEYS: readonly ["fast.enabled", "fast.provider", "fast.model", "fast.baseUrl", "fast.thinkingLevel", "fast.review", "fast.reviewEveryTurns", "fast.reviewContextTurns", "fast.reviewMaxChars", "fast.reviewMaxPerSession"];
 /**
  * Config keys under `update.` that `aragon config set` accepts (cli-auto-update
  * §4.1).