@aragon-agent/cli 0.6.16 → 0.6.18

package/dist/agent/controller.js

@@ -12,7 +12,9 @@ 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 { createFastOverseerProvider } from '../team/overseer.js';
 import { createTaskTool } from '../team/task-tool.js';
 import { buildTeamBlock } from '../team/prompt.js';
 import { buildFastBlock } from '../fast/prompt.js';
@@ -161,14 +163,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 +313,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 +326,47 @@ 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,
+                },
+                // THE DISPATCH SUPERVISOR (team-overseer): the fast tier that powers the
+                // per-child reviewers also powers the supervisor one-shot decision
+                // calls. Same live-predicate discipline as review above - every
+                // this.fast read lives in a closure that only runs from inside a
+                // dispatch, long after the wiring exists.
+                overseer: createFastOverseerProvider({
+                    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,
+                }),
                 providerRegistry: this.providerRegistry,
                 getCwd: () => this.cwd,
                 getMode: () => this.effectiveMode,
@@ -488,23 +513,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 +617,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 +690,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 +749,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 +768,6 @@ export class AgentController {
             fastBlock: fastAvailable
                 ? buildFastBlock({
                     model: tier.ok ? tier.ref.modelId : '',
-                    delegate: config.fast.delegate,
                     review: config.fast.review,
                 })
                 : '',

package/dist/agent/headless.js

@@ -116,6 +116,13 @@ export async function runHeadless(controller, prompt, options = {}) {
             }
             return;
         }
+        if (event.type === 'overseer') {
+            // ONE LINE PER DECISION, on stderr with the rest of the team feed:
+            // a machine consumer reads the JSON events; a human watching a long
+            // dispatch reads who the supervisor touched and why.
+            err.write(`[team] supervisor ${event.label}: ${event.decision.action} (${event.trigger}) ${event.decision.reason}\n`);
+            return;
+        }
         if (event.type === 'dispatch_end') {
             const ok = event.outcome.runs.filter((r) => r.phase === 'done' && !r.error).length;
             err.write(`[team] done ${ok}/${event.outcome.runs.length} ok` +

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');
@@ -256,7 +254,7 @@ const COMMANDS = [
     },
     {
         name: 'team',
-        description: 'Team subagents: status | on | off | max <n>',
+        description: 'Team subagents: status | on | off | max <n> | overseer on|off',
         /**
          * `/team on` CANNOT turn team mode on in a session that started without it,
          * and this command must not pretend otherwise (§4.5 / D-17 / P0-2).
@@ -296,7 +294,7 @@ const COMMANDS = [
                     ? `\nRunning: ${snapshot.runs.map((r) => `${r.label} (${r.phase})`).join(', ')}`
                     : '';
                 ctx.notify('info', `Team mode: ${state}. Max subagents: ${cfg.maxSubagents}, ` +
-                    `concurrent: ${cfg.maxConcurrent}.${roster}`);
+                    `concurrent: ${cfg.maxConcurrent}, supervisor: ${cfg.overseer ? 'on' : 'off'} (needs the fast tier).${roster}`);
                 return;
             }
             if (verb === 'on' || verb === 'off') {
@@ -333,13 +331,28 @@ const COMMANDS = [
                 ctx.toast('success', `Max subagents set to ${applied.maxSubagents}.`);
                 return;
             }
-            ctx.notify('warn', `Unknown argument "${verb}" - use /team [status|on|off|max <n>].`);
+            if (verb === 'overseer') {
+                if (value !== 'on' && value !== 'off') {
+                    ctx.notify('warn', 'Usage: /team overseer on|off');
+                    return;
+                }
+                // Read LIVE per dispatch by the runtime, so no rebuild is needed - the
+                // same reason this command does not touch the tool array (its own header
+                // comment). Clamped by `setTeamConfig` and again on the persist path.
+                const applied = controller.setTeamConfig({ overseer: value === 'on' });
+                ctx.persistConfig({
+                    team: { overseer: applied.overseer },
+                });
+                ctx.toast('success', `Dispatch supervisor ${applied.overseer ? 'on' : 'off'}.`);
+                return;
+            }
+            ctx.notify('warn', `Unknown argument "${verb}" - use /team [status|on|off|max <n>|overseer on|off].`);
         },
     },
     {
         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 +529,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/commands/index-build.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Ctrl+I project-index trigger (bundled `project-indexer` skill).
+ *
+ * WHY A MODULE AND NOT INLINE IN `App.tsx`. `App.tsx` is a documented
+ * historical oversize file (see `.claude-index/config.md`); the convention
+ * those entries record is that a feature only wires into it and keeps its
+ * logic in a small named module. Everything here is pure and unit-tested:
+ * the key handler in `App.tsx` guards, confirms, and dispatches; this file
+ * owns the words and the names.
+ *
+ * THE TRIGGER IS A SKILL COMMAND, NOT A REIMPLEMENTATION. Ctrl+I dispatches
+ * `/skill:project-indexer <args>` through the ordinary command path, so the
+ * load/activate/queue-frame/submit lifecycle is the SAME one a typed command
+ * gets, and the whole indexing run streams into the transcript like any
+ * agent turn. All strings here are ASCII-only: `commands/` is inside the
+ * `glyphs.test.ts` scan scope and every byte reaches a terminal.
+ */
+/** The bundled skill Ctrl+I runs. Bundled skills are read-only by scope. */
+export declare const INDEX_SKILL_NAME = "project-indexer";
+/** True when a previous run left a main index file behind (rebuild, not first build). */
+export declare function hasProjectIndex(cwd: string): boolean;
+/**
+ * Args handed to `/skill:project-indexer`. They land in the skill body's
+ * `$ARGUMENTS` placeholder, so the model sees WHY the turn started - a
+ * confirmed keypress, not a typed request - and skips asking "proceed?" a
+ * second time (the skill's own edge-case list says exactly that).
+ */
+export declare function indexBuildInvocationArgs(hasExistingIndex: boolean): string;
+export interface IndexConfirmInput {
+    cwd: string;
+    /** True when `.claude-index/index.md` already exists (rebuild, not first build). */
+    hasExistingIndex: boolean;
+}
+/**
+ * The Yes/No dialog body. It names WHAT WILL BE WRITTEN - an index run is a
+ * batch of file writes the user never typed, and the one question a confirm
+ * gate must answer is "what did I just agree to?".
+ */
+export declare function buildIndexConfirmSummary(input: IndexConfirmInput): string;

package/dist/commands/index-build.js

@@ -0,0 +1,61 @@
+/**
+ * Ctrl+I project-index trigger (bundled `project-indexer` skill).
+ *
+ * WHY A MODULE AND NOT INLINE IN `App.tsx`. `App.tsx` is a documented
+ * historical oversize file (see `.claude-index/config.md`); the convention
+ * those entries record is that a feature only wires into it and keeps its
+ * logic in a small named module. Everything here is pure and unit-tested:
+ * the key handler in `App.tsx` guards, confirms, and dispatches; this file
+ * owns the words and the names.
+ *
+ * THE TRIGGER IS A SKILL COMMAND, NOT A REIMPLEMENTATION. Ctrl+I dispatches
+ * `/skill:project-indexer <args>` through the ordinary command path, so the
+ * load/activate/queue-frame/submit lifecycle is the SAME one a typed command
+ * gets, and the whole indexing run streams into the transcript like any
+ * agent turn. All strings here are ASCII-only: `commands/` is inside the
+ * `glyphs.test.ts` scan scope and every byte reaches a terminal.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+/** The bundled skill Ctrl+I runs. Bundled skills are read-only by scope. */
+export const INDEX_SKILL_NAME = 'project-indexer';
+/** True when a previous run left a main index file behind (rebuild, not first build). */
+export function hasProjectIndex(cwd) {
+    try {
+        return existsSync(join(cwd, '.claude-index', 'index.md'));
+    }
+    catch {
+        // A cwd that cannot be probed simply has no index to reuse.
+        return false;
+    }
+}
+/**
+ * Args handed to `/skill:project-indexer`. They land in the skill body's
+ * `$ARGUMENTS` placeholder, so the model sees WHY the turn started - a
+ * confirmed keypress, not a typed request - and skips asking "proceed?" a
+ * second time (the skill's own edge-case list says exactly that).
+ */
+export function indexBuildInvocationArgs(hasExistingIndex) {
+    return hasExistingIndex
+        ? 'The user pressed Ctrl+I and confirmed. Rebuild the project index for this workspace now, reusing the existing .claude-index/config.md preferences.'
+        : 'The user pressed Ctrl+I and confirmed. Build the project index for this workspace now, asking the configuration questions first.';
+}
+/**
+ * The Yes/No dialog body. It names WHAT WILL BE WRITTEN - an index run is a
+ * batch of file writes the user never typed, and the one question a confirm
+ * gate must answer is "what did I just agree to?".
+ */
+export function buildIndexConfirmSummary(input) {
+    const action = input.hasExistingIndex ? 'Rebuild' : 'Build';
+    const existing = input.hasExistingIndex
+        ? '\nThe existing .claude-index/config.md preferences are reused.'
+        : '\nThe bundled skill asks a few configuration questions first.';
+    return (`${action} the project index for this workspace?\n` +
+        `\nRuns the bundled "${INDEX_SKILL_NAME}" skill as a normal agent turn:` +
+        `\n- scans the workspace (exclusions apply), extracts exported symbols` +
+        `\n- writes .claude-index/index.md and .claude-index/config.md` +
+        `\n- updates CLAUDE.md (index section + Clean Code Guidelines)` +
+        `${existing}` +
+        `\nWorkspace: ${input.cwd}` +
+        `\nEvery step is visible in the transcript; Esc interrupts.`);
+}

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

@@ -20,7 +20,7 @@ export declare const LOG_CONFIG_SET_KEYS: readonly ["log.level", "log.toFile", "
  * switch falls through every case, writes nothing, and still prints
  * `Set team.enabled = false`.
  */
-export declare const TEAM_CONFIG_SET_KEYS: readonly ["team.enabled", "team.maxSubagents", "team.maxConcurrent", "team.subagentTimeoutMs", "team.dispatchTimeoutMs", "team.maxTurnsPerSubagent"];
+export declare const TEAM_CONFIG_SET_KEYS: readonly ["team.enabled", "team.maxSubagents", "team.maxConcurrent", "team.subagentTimeoutMs", "team.dispatchTimeoutMs", "team.maxTurnsPerSubagent", "team.overseer"];
 /**
  * Config keys under `retry.` that `aragon config set` accepts
  * (llm-api-retry-backoff §8.2).
@@ -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).