@aragon-agent/cli 0.6.16 → 0.6.18

package/dist/fast/wiring.js

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

package/dist/input/csiu-keys.js

@@ -24,7 +24,7 @@
  * legacy bytes, with the modified-Enter family becoming `ENTER_NEWLINE_FRAME`.
  * Pure: no node/React imports.
  */
-import { ENTER_NEWLINE_FRAME } from './limits.js';
+import { ENTER_NEWLINE_FRAME, INDEX_KEY_FRAME } from './limits.js';
 /** Enable / disable the two CSI-u report modes (posix side). */
 export const CSI_U_ENABLE = '\x1b[>1u\x1b[>4;2m';
 export const CSI_U_DISABLE = '\x1b[<u\x1b[>4m';
@@ -111,8 +111,19 @@ export function translateCsiUKey(key) {
         return m === 0 ? '\r' : ENTER_NEWLINE_FRAME;
     if (key.code === 27)
         return alt ? '\x1b\x1b' : '\x1b';
-    if (key.code === 9)
+    if (key.code === 9) {
+        // A modified Tab codepoint (modifyOtherKeys shape) mirrors the VK_TAB
+        // decision in win32-input-mode.ts: ctrl (without shift/alt) is the
+        // project-indexer trigger frame, shift stays Shift+Tab.
+        if (ctrl && !shift && !alt)
+            return INDEX_KEY_FRAME;
         return shift ? '\x1b[Z' : '\t';
+    }
+    // Ctrl+I under kitty disambiguate arrives as codepoint 105 with the ctrl
+    // modifier; the generic printable branch below would fold it back onto the
+    // legacy Tab byte, which is exactly the ambiguity the frame exists to break.
+    if (key.code === 105 && ctrl && !shift && !alt)
+        return INDEX_KEY_FRAME;
     if (key.code === 127) {
         // POST-normalisation bytes, same rationale as VK_BACK in win32-input-mode.
         if (alt)

package/dist/input/limits.d.ts

@@ -64,6 +64,21 @@ export declare const PASTE_CLOSE = "\0]";
  * no payload, so one constant replaces the OPEN/CLOSE pair.
  */
 export declare const ENTER_NEWLINE_FRAME = "\0n";
+/**
+ * The inline frame that carries ONE "Ctrl+I was pressed" intent from the stdin
+ * filter to `App` (project-indexer Ctrl+I trigger).
+ *
+ * WHY A FRAME AND NOT `key.ctrl && input === 'i'`. Legacy terminals encode
+ * Ctrl+I as the same byte as Tab (0x09), so by the time the stream reaches Ink
+ * the two are indistinguishable. Under win32-input-mode (`?9001h`) and kitty
+ * CSI-u the modifiers ARE known at translation time, and both translators emit
+ * this frame instead of the legacy Tab byte. Same NUL-delimiter guarantee as
+ * `ENTER_NEWLINE_FRAME`: no terminal delivers NUL for a key and pasted text is
+ * stripped of NUL, so a payload can never forge it. Terminals without keyboard
+ * enhancement keep the legacy collapse — Ctrl+I there is Tab, documented in the
+ * README keybindings table.
+ */
+export declare const INDEX_KEY_FRAME = "\0i";
 /**
  * The one channel from the stdin filter to `App`'s notice dispatch (P1-3 / I-15).
  *

package/dist/input/limits.js

@@ -64,6 +64,21 @@ export const PASTE_CLOSE = '\u0000]';
  * no payload, so one constant replaces the OPEN/CLOSE pair.
  */
 export const ENTER_NEWLINE_FRAME = '\u0000n';
+/**
+ * The inline frame that carries ONE "Ctrl+I was pressed" intent from the stdin
+ * filter to `App` (project-indexer Ctrl+I trigger).
+ *
+ * WHY A FRAME AND NOT `key.ctrl && input === 'i'`. Legacy terminals encode
+ * Ctrl+I as the same byte as Tab (0x09), so by the time the stream reaches Ink
+ * the two are indistinguishable. Under win32-input-mode (`?9001h`) and kitty
+ * CSI-u the modifiers ARE known at translation time, and both translators emit
+ * this frame instead of the legacy Tab byte. Same NUL-delimiter guarantee as
+ * `ENTER_NEWLINE_FRAME`: no terminal delivers NUL for a key and pasted text is
+ * stripped of NUL, so a payload can never forge it. Terminals without keyboard
+ * enhancement keep the legacy collapse — Ctrl+I there is Tab, documented in the
+ * README keybindings table.
+ */
+export const INDEX_KEY_FRAME = '\u0000i';
 /** Human-readable byte size for the refusal toast (`4.1 MB`, `812.0 KB`, `7 B`). */
 export function formatPasteSize(bytes) {
     if (bytes >= 1024 * 1024)

package/dist/input/win32-input-mode.js

@@ -20,7 +20,7 @@
  *
  * Pure: no node/React imports, callable from any test environment.
  */
-import { ENTER_NEWLINE_FRAME } from './limits.js';
+import { ENTER_NEWLINE_FRAME, INDEX_KEY_FRAME } from './limits.js';
 /** Enable / disable win32-input-mode (private mode 9001). */
 export const WIN32_INPUT_ENABLE = '\x1b[?9001h';
 export const WIN32_INPUT_DISABLE = '\x1b[?9001l';
@@ -190,6 +190,12 @@ export function translateWin32Key(record) {
             // A modified Enter NEVER submits -- same rule as `ENTER_SEQUENCES`.
             return m === 0 ? '\r' : ENTER_NEWLINE_FRAME;
         case VK_TAB:
+            // Ctrl+I is the project-indexer trigger, and the ONLY place the two are
+            // tell-apart is right here: legacy encoding collapses it to the Tab
+            // byte. Shift keeps ESC [ Z (Shift+Tab) so the mode toggle stays intact,
+            // and Ctrl+Shift+I stays on that Shift branch.
+            if (ctrl && !shift && !alt)
+                return INDEX_KEY_FRAME;
             return shift ? '\x1b[Z' : '\t';
         case VK_ESCAPE:
             return alt ? '\x1b\x1b' : '\x1b';

package/dist/logging/install.d.ts

@@ -292,6 +292,15 @@ export type TeamLogEvent = {
         subject?: string;
         body?: string;
     };
+} | {
+    type: 'overseer';
+    dispatchId: string;
+    label?: string;
+    decision?: {
+        action?: string;
+        reason?: string;
+    };
+    trigger?: string;
 } | {
     type: 'dispatch_end';
     dispatchId: string;

package/dist/logging/install.js

@@ -510,6 +510,17 @@ export function attachTeamEvents(logger, controller) {
                     subject: event.message?.subject,
                 });
                 break;
+            case 'overseer':
+                // REASON ONLY, and at debug: interventions are routine supervision,
+                // not failures; the report and the panel carry them to the user.
+                logger.debug('agent', 'team_overseer', {
+                    dispatchId: event.dispatchId,
+                    label: event.label,
+                    action: event.decision?.action,
+                    trigger: event.trigger,
+                    reason: event.decision?.reason,
+                });
+                break;
             case 'dispatch_end': {
                 const outcome = event.outcome;
                 const runs = outcome?.runs ?? [];

package/dist/session/validate-session.js

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

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

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

package/dist/team/child-reviewer.js

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

package/dist/team/human-queue.d.ts

@@ -33,7 +33,18 @@ export declare class TeamHumanQueue {
     private readonly confirm;
     /** The chain. Never rejects: a failed request resolves `false` (deny). */
     private tail;
+    /**
+     * Labels with a request chained but not yet answered (team-overseer I-OV3).
+     *
+     * The queue pauses the CHILD's own watchdog on enqueue; the supervisor's
+     * soft silence timer needs the same fact one level up, or a user who takes
+     * four minutes over the first dialog burns inspection budget on siblings
+     * that are third in the FIFO and provably fine.
+     */
+    private readonly waiting;
     constructor(confirm: (req: ConfirmRequest) => Promise<boolean>);
+    /** Whether `label` has a confirmation queued or displayed right now. */
+    isWaiting(label: string): boolean;
     /**
      * Ask the human about `req` on behalf of `label`, one at a time.
      *

package/dist/team/human-queue.js

@@ -27,9 +27,22 @@ export class TeamHumanQueue {
     confirm;
     /** The chain. Never rejects: a failed request resolves `false` (deny). */
     tail = Promise.resolve();
+    /**
+     * Labels with a request chained but not yet answered (team-overseer I-OV3).
+     *
+     * The queue pauses the CHILD's own watchdog on enqueue; the supervisor's
+     * soft silence timer needs the same fact one level up, or a user who takes
+     * four minutes over the first dialog burns inspection budget on siblings
+     * that are third in the FIFO and provably fine.
+     */
+    waiting = new Set();
     constructor(confirm) {
         this.confirm = confirm;
     }
+    /** Whether `label` has a confirmation queued or displayed right now. */
+    isWaiting(label) {
+        return this.waiting.has(label);
+    }
     /**
      * Ask the human about `req` on behalf of `label`, one at a time.
      *
@@ -41,13 +54,17 @@ export class TeamHumanQueue {
      */
     request(child, label, req, signal) {
         child?.pauseIdleWatchdog();
+        this.waiting.add(label);
         const queued = this.enqueue(async () => {
             if (signal?.aborted)
                 return false;
             return this.confirm({ ...req, summary: `[${label}] ${req.summary}` });
         });
         const raced = signal ? Promise.race([queued, abortsToFalse(signal)]) : queued;
-        return raced.finally(() => child?.resumeIdleWatchdog());
+        return raced.finally(() => {
+            this.waiting.delete(label);
+            child?.resumeIdleWatchdog();
+        });
     }
     /**
      * Chain `run` after everything already queued.

package/dist/team/limits.d.ts

@@ -101,6 +101,46 @@ export declare const TEAM_LIMITS: {
      *  nothing a re-dispatch by the lead would not buy better. */
     readonly maxColdStartRetries: 1;
     readonly retryBackoffMs: 2000;
+    /**
+     * Wall-clock budget of everything one inspection may carry. The digest holds
+     * run facts, the supervisor's own memory and the tail of the child's live
+     * history; unbounded, one look at a child that read five big files would
+     * make the "cheap" supervision call cost more than the child (the argument
+     * FAST_LIMITS.digestMaxChars makes, one level up).
+     */
+    readonly overseerDigestBytes: 8000;
+    /** Clamp on a `nudge` guidance text. Advice, not a second brief. */
+    readonly overseerGuidanceChars: 1200;
+    /** Clamp on the decision `reason` recorded in the report. */
+    readonly overseerReasonChars: 200;
+    /**
+     * Inspections PER CHILD per dispatch. An indecisive supervisor must stop
+     * burning fast-tier calls; past the budget the child simply runs under its
+     * hard ceilings and the supervisor goes quiet.
+     */
+    readonly overseerMaxInspectionsPerChild: 4;
+    /**
+     * Rebuilds PER CHILD per dispatch. One: a replacement that also stalls dies
+     * on its own watchdog rather than ping-ponging fresh children at a task the
+     * supervisor already failed to rescue once.
+     */
+    readonly overseerMaxReplacementsPerChild: 1;
+    /**
+     * First wall-clock check when `team.subagentTimeoutMs === 0` (the shipped
+     * default): the supervisor still looks even when no ceiling was configured.
+     */
+    readonly overseerDefaultCheckMs: 300000;
+    /** Clamp on the model-chosen `nextCheckMs`, lower bound. */
+    readonly overseerNextCheckMinMs: 60000;
+    /** Clamp on the model-chosen `nextCheckMs`, upper bound. */
+    readonly overseerNextCheckMaxMs: 900000;
+    /**
+     * A child's OWN idle watchdog, multiplied by this while the supervisor is
+     * active, so the soft silence inspection at `idleTimeoutMs` always precedes
+     * the hard abort. The watchdog stays as the backstop for a child that
+     * wedges past every inspection.
+     */
+    readonly overseerWatchdogFactor: 4;
 };
 /**
  * The two comm tools, which are POLICY-EXEMPT inside a child (§3.11).

package/dist/team/limits.js

@@ -106,6 +106,47 @@ export const TEAM_LIMITS = {
      *  nothing a re-dispatch by the lead would not buy better. */
     maxColdStartRetries: 1,
     retryBackoffMs: 2_000,
+    // --- The dispatch supervisor (team-overseer) ---
+    /**
+     * Wall-clock budget of everything one inspection may carry. The digest holds
+     * run facts, the supervisor's own memory and the tail of the child's live
+     * history; unbounded, one look at a child that read five big files would
+     * make the "cheap" supervision call cost more than the child (the argument
+     * FAST_LIMITS.digestMaxChars makes, one level up).
+     */
+    overseerDigestBytes: 8_000,
+    /** Clamp on a `nudge` guidance text. Advice, not a second brief. */
+    overseerGuidanceChars: 1_200,
+    /** Clamp on the decision `reason` recorded in the report. */
+    overseerReasonChars: 200,
+    /**
+     * Inspections PER CHILD per dispatch. An indecisive supervisor must stop
+     * burning fast-tier calls; past the budget the child simply runs under its
+     * hard ceilings and the supervisor goes quiet.
+     */
+    overseerMaxInspectionsPerChild: 4,
+    /**
+     * Rebuilds PER CHILD per dispatch. One: a replacement that also stalls dies
+     * on its own watchdog rather than ping-ponging fresh children at a task the
+     * supervisor already failed to rescue once.
+     */
+    overseerMaxReplacementsPerChild: 1,
+    /**
+     * First wall-clock check when `team.subagentTimeoutMs === 0` (the shipped
+     * default): the supervisor still looks even when no ceiling was configured.
+     */
+    overseerDefaultCheckMs: 300_000,
+    /** Clamp on the model-chosen `nextCheckMs`, lower bound. */
+    overseerNextCheckMinMs: 60_000,
+    /** Clamp on the model-chosen `nextCheckMs`, upper bound. */
+    overseerNextCheckMaxMs: 900_000,
+    /**
+     * A child's OWN idle watchdog, multiplied by this while the supervisor is
+     * active, so the soft silence inspection at `idleTimeoutMs` always precedes
+     * the hard abort. The watchdog stays as the backstop for a child that
+     * wedges past every inspection.
+     */
+    overseerWatchdogFactor: 4,
 };
 /**
  * The two comm tools, which are POLICY-EXEMPT inside a child (§3.11).