@aragon-agent/cli 0.6.16 → 0.6.18

package/dist/team/subagent.d.ts

@@ -11,15 +11,15 @@
  * omission has a reason that is a correctness boundary rather than caution.
  */
 import type { ModelRole } from '../config/model-profiles.js';
-import { type AgentConfig, type AgentEvent, type AgentTool, type Message, type ModelRef, type ProviderRegistry, type SkillRegistry, type ThinkingLevel, type TokenUsage, type ToolPolicyDecision, type ToolPolicyVerdict } from '@aragon-agent/core';
+import { type AgentConfig, type AgentEvent, type AgentTool, type Message, type ProviderRegistry, type SkillRegistry, type TokenUsage, type ToolPolicyDecision, type ToolPolicyVerdict } from '@aragon-agent/core';
 import type { AgentMode } from '../agent/agent-mode.js';
 import type { ChildContextManagerProvider } from '../compaction/child.js';
 import type { CliConfig } from '../config/schema.js';
 import type { ToolPermission } from '../exec/permission.js';
-import type { FastTierName } from '../fast/types.js';
+import type { ChildReviewProvider } from './child-reviewer.js';
 import { TeamBus } from './bus.js';
 import type { TeamHumanQueue, WatchdogPausable } from './human-queue.js';
-import type { SubagentRun, SubagentSpec } from './types.js';
+import type { OverseerVerdict, SubagentRun, SubagentSpec } from './types.js';
 /**
  * The slice of `Agent` a child is used through.
  *
@@ -31,6 +31,10 @@ export interface SubagentAgentLike extends WatchdogPausable {
     prompt(text: string): Promise<void>;
     abort(): void;
     subscribe(listener: (event: AgentEvent) => void): () => void;
+    /** Steering surface for the child's own fast reviewer (core `Agent.steer`). */
+    steer(text: string): void;
+    /** Queued-block hygiene on abort, again mirroring the lead (D-21). */
+    clearAllQueues(): void;
     /**
      * The child's live history, for its own context manager
      * (context-auto-compaction-hardening §3.4.3 / W3).
@@ -95,23 +99,19 @@ export interface SubagentDeps {
     humanQueue?: TeamHumanQueue;
     agentFactory: SubagentAgentFactory;
     /**
-     * Which model and thinking level a tier runs on (fast-model-tier §3.4).
-     *
-     * OPTIONAL, defaulting to the session's own model, so every existing caller
-     * and test compiles unchanged and a `--no-fast` session builds children
-     * exactly as it always did.
-     *
-     * `resolveTier('fast')` RETURNS THE MAIN TIER when the fast tier is not
-     * available, which is what makes 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 stopped resolving twenty minutes ago (RV-3 / R-14).
+     * Whether the dispatch supervisor is live for THIS dispatch
+     * (team-overseer). Read once per dispatch by the runtime and spread here;
+     * when true the child's OWN idle watchdog is lengthened by
+     * `TEAM_LIMITS.overseerWatchdogFactor`, so the supervisor's soft silence
+     * inspection at `idleTimeoutMs` always precedes the hard abort.
      */
-    resolveTier?: (tier: FastTierName) => {
-        ref: ModelRef;
-        thinkingLevel: ThinkingLevel;
-        role?: ModelRole;
-    };
+    overseerActive?: boolean;
+    /**
+     * Per-child fast review (main-agent parity): the controller's shared
+     * provider, built on the lead's `FastWiring`. ABSENT means the session
+     * has no fast wiring, and the child is then exactly what it always was.
+     */
+    review?: ChildReviewProvider;
     /**
      * Build this child its own context manager
      * (context-auto-compaction-hardening §3.4.3 / W3).
@@ -128,12 +128,41 @@ export interface SubagentHooks {
     /** Coalesced at the source (§5.2); phase transitions always pass. */
     onUpdate: (run: SubagentRun) => void;
     onUsage: (label: string, usage: TokenUsage) => void;
+    /**
+     * UNTHROTTLED per-event callback (team-overseer I-OV3). `onUpdate` is
+     * coalesced, so it would lie about silence; the supervisor's soft stall
+     * timer needs one kick per REAL agent event. Called after the phase switch
+     * so the phase read at fire time is current.
+     */
+    onActivity?: () => void;
 }
 export interface SubagentHandle {
     spec: SubagentSpec;
     run: SubagentRun;
     agent: SubagentAgentLike;
     tools: AgentTool[];
+    /**
+     * THE HANDLE-LEVEL ABORT, and the only one `TeamRuntime` may call. It sets a
+     * synchronous `abortRequested` flag BEFORE `agent.abort()`, which is what the
+     * child's fast reviewer reads as its guard-1 fact: an Esc or a dispatch stop
+     * must be visible to the reviewer in the same tick it happens, or the
+     * reviewer steers a `<fast_review>` block into a run that is already dying.
+     */
+    abort: () => void;
+    /**
+     * Whether `abort()` has been called on this handle (team-overseer
+     * I-OV4): the supervisor reads it before steering a nudge, so advice is
+     * never queued into a child that is already dying - the same guard-1 fact
+     * the child's own fast reviewer reads.
+     */
+    isAborted: () => boolean;
+    /**
+     * A terminal supervisor decision awaiting application by the WORKER LOOP
+     * (team-overseer I-OV1). Written by `TeamRuntime` immediately before
+     * `abort()`; read by `runOne` after `prompt()` resolves. NEVER cleared,
+     * so an abort racing the read cannot hide the cause.
+     */
+    overseerVerdict?: OverseerVerdict;
     unsubscribe: () => void;
 }
 /**

package/dist/team/subagent.js

@@ -13,6 +13,7 @@
 import { Agent, createSkillFindTool, } from '@aragon-agent/core';
 import { formatStreamError } from '../agent/reducer.js';
 import { buildSystemPrompt } from '../agent/system-prompt.js';
+import { buildFastBlock } from '../fast/prompt.js';
 import { createBuiltinTools } from '../tools/index.js';
 import { pickActivityArgs, sanitizeActivity } from './activity.js';
 import { TEAM_LIMITS, TEAM_SUBAGENT_TOOL_NAMES } from './limits.js';
@@ -40,11 +41,17 @@ function assistantText(message) {
  * the security boundary here, so it has to be directly checkable.
  */
 export function buildSubagentTools(spec, deps, getAgent) {
+    // `team_wait`'s ceiling is the STRUCTURAL clamp when the child itself has no
+    // wall clock (`subagentTimeoutMs: 0`): a peer wait must stay bounded even when
+    // the child's run is not, or one forgotten wait would hold a slot forever.
+    const subagentTimeoutMs = deps.config.team.subagentTimeoutMs;
     const commTools = [
         makeTeamSend(deps.bus, spec.label),
         makeTeamWait(deps.bus, spec.label, {
             getAgent,
-            maxWaitMs: deps.config.team.subagentTimeoutMs,
+            maxWaitMs: subagentTimeoutMs > 0
+                ? subagentTimeoutMs
+                : TEAM_LIMITS.waitMaxSeconds * 1000,
         }),
     ];
     const tools = createBuiltinTools({
@@ -141,9 +148,6 @@ export function createSubagent(spec, deps, hooks) {
     const run = {
         label: spec.label,
         description: spec.description,
-        // FROM THE SPEC, which the normalizer already downgraded when the tier was
-        // unavailable — so this is what RAN, not what was asked for (§3.4).
-        tier: spec.tier,
         phase: 'queued',
         turns: 0,
         toolCalls: 0,
@@ -158,37 +162,38 @@ export function createSubagent(spec, deps, hooks) {
     let agentRef = null;
     const getAgent = () => agentRef;
     const tools = buildSubagentTools(spec, deps, getAgent);
-    // THE TWO HARDCODED CONFIG READS THAT USED TO LIVE HERE NOW ROUTE THROUGH ONE
-    // RESOLVER (fast-model-tier §3.4). The fallback reproduces them exactly, so a
-    // caller that passes no `resolveTier` builds a byte-identical child.
+    // THE CHILD'S MODEL IS THE LEAD'S MODEL, READ FROM THE DISPATCH-TIME CONFIG
+    // (main-agent parity). Same provider, same model id, same base URL, same
+    // thinking level: a delegation is never a downgrade, and the only model a
+    // child may surprise its lead with is one a settings-screen edit made live
+    // between two dispatches.
     //
-    // `thinkingLevel` is PER TIER and defaults to `'off'` for the fast tier
-    // (D-13): a "fast" model asked to think for 32 768 tokens is not fast, and
-    // inheriting the session's `xhigh` into a mechanical file-scan child would be
-    // the most expensive possible reading of the word.
-    //
-    // `maxTokens` is deliberately NOT per tier (RV-15). A child inherits
-    // `deps.config.maxTokens` below, which is an ambition sized for the main
-    // model; the adapter clamps it down to whatever the fast model actually
-    // accepts (`llm/provider.ts:44-52`), so a large inherited value degrades to
-    // the right number rather than to an HTTP 400.
-    const resolved = deps.resolveTier
-        ? deps.resolveTier(spec.tier)
-        : {
-            ref: {
-                providerId: deps.config.provider,
-                modelId: deps.config.model,
-                ...(deps.config.baseUrl ? { baseUrl: deps.config.baseUrl } : {}),
-            },
-            thinkingLevel: deps.config.thinkingLevel,
-            role: 'main',
-        };
+    // `maxTokens` inherits `deps.config.maxTokens` below - the same ambition the
+    // lead sends, clamped by the same adapter, so an inherited large value
+    // degrades to the right number rather than to an HTTP 400.
+    const resolved = {
+        ref: {
+            providerId: deps.config.provider,
+            modelId: deps.config.model,
+            ...(deps.config.baseUrl ? { baseUrl: deps.config.baseUrl } : {}),
+        },
+        thinkingLevel: deps.config.thinkingLevel,
+        role: 'main',
+    };
     const model = resolved.ref;
     // HOISTED TO A LOCAL, AND THAT IS WHAT MAKES W3 POSSIBLE AT ALL. This was built
     // INLINE inside the `agentFactory({...})` argument, so there was nothing for the
     // child manager's `getSystemPrompt` accessor to close over - and the accessor
     // cannot read it back off the agent, because `SubagentAgentLike` is narrowed to
     // `state.messages` on purpose.
+    // THE SAME `<fast_tier>` BLOCK THE LEAD GETS, spliced only when this child
+    // will actually have a reviewer. The gating expression is written against
+    // `deps.review` here and the reviewer is built from the SAME predicate
+    // below, so the prompt can never advertise a capability the child lacks -
+    // and a child with a reviewer is never surprised by its first injection.
+    const fastBlock = deps.review !== undefined && deps.review.active()
+        ? buildFastBlock({ model: deps.review.modelId(), review: true })
+        : '';
     const systemPrompt = buildSystemPrompt({
         cwd: deps.getCwd(),
         tools,
@@ -203,6 +208,7 @@ export function createSubagent(spec, deps, hooks) {
             description: spec.description,
             peers: deps.bus.peersOf(spec.label),
         }),
+        ...(fastBlock ? { fastBlock } : {}),
     });
     // LAZY ACCESSORS OVER `agentRef`, WHICH IS ASSIGNED AFTER THIS RETURNS. A
     // non-lazy read here is `undefined` at construction and the child's estimate
@@ -235,7 +241,9 @@ export function createSubagent(spec, deps, hooks) {
             // (§3.8). The two places a child legitimately blocks on something other
             // than its own LLM or tool — `team_wait` and the confirm queue — pause it
             // explicitly.
-            idleTimeout: deps.config.idleTimeoutMs,
+            idleTimeout: deps.overseerActive === true
+                ? deps.config.idleTimeoutMs * TEAM_LIMITS.overseerWatchdogFactor
+                : deps.config.idleTimeoutMs,
         },
         // SPREAD CONDITIONALLY, never `contextManager: deps.contextManagerFor?.(...)`.
         // With the feature off the options bag has no such key, so the loop's gate
@@ -244,6 +252,27 @@ export function createSubagent(spec, deps, hooks) {
         ...(contextManager ? { contextManager } : {}),
     });
     agentRef = agent;
+    // PER-CHILD FAST REVIEW (main-agent parity). GATED ON THE PROVIDER'S OWN
+    // LIVE PREDICATE, read once here so the prompt and the reviewer CANNOT
+    // DISAGREE about whether the child has one: a child told about
+    // `<fast_review>` blocks must be a child that actually receives them, and a
+    // child with a reviewer must have been told. `abortRequested` is the flag
+    // `handle.abort()` sets (see `SubagentHandle`); the reviewer reads it as its
+    // never-steer-into-a-requested-abort fact.
+    let abortRequested = false;
+    const reviewLive = deps.review !== undefined && deps.review.active() === true;
+    const reviewer = reviewLive
+        ? deps.review?.create({
+            label: spec.label,
+            goal: spec.description,
+            agent,
+            isRunning: () => run.phase === 'starting' ||
+                run.phase === 'thinking' ||
+                run.phase === 'tool' ||
+                run.phase === 'waiting',
+            isAbortRequested: () => abortRequested,
+        })
+        : undefined;
     let lastEmit = 0;
     let lastPhase = run.phase;
     /**
@@ -325,8 +354,16 @@ export function createSubagent(spec, deps, hooks) {
                 // an aborted run, which the report renders as partial rather than lost.
                 if (text.length > 0)
                     run.summary = text;
-                if (run.turns >= deps.config.team.maxTurnsPerSubagent) {
+                // `0` MEANS NO CAP (main-agent parity): the lead has no turn ceiling
+                // either, and a child that needs forty turns for a forty-turn job is
+                // not runaway - it is working.
+                const turnCap = deps.config.team.maxTurnsPerSubagent;
+                if (turnCap > 0 && run.turns >= turnCap) {
                     run.truncated = true;
+                    // THE FLAG FIRST, exactly like `handle.abort()`: the child's
+                    // reviewer reads `abortRequested` as its guard-1 fact, and a
+                    // turn-cap stop must be visible to it in the same tick.
+                    abortRequested = true;
                     agent.abort();
                 }
                 break;
@@ -402,7 +439,27 @@ export function createSubagent(spec, deps, hooks) {
             default:
                 break;
         }
+        // AFTER the switch, so `run.phase` is current when the supervisor's
+        // silence timer consults it (team-overseer I-OV3): a `team_wait` start
+        // must be observable as `waiting` on the very kick that follows it.
+        hooks.onActivity?.();
         emit();
     });
-    return { spec, run, agent, tools, unsubscribe };
+    return {
+        spec,
+        run,
+        agent,
+        tools,
+        // THE HANDLE-LEVEL ABORT (see `SubagentHandle`): the flag first, then the
+        // agent, so the reviewer's guard observes the request in the same tick.
+        abort: () => {
+            abortRequested = true;
+            agent.abort();
+        },
+        isAborted: () => abortRequested,
+        unsubscribe: () => {
+            reviewer?.dispose();
+            unsubscribe();
+        },
+    };
 }

package/dist/team/task-tool.d.ts

@@ -19,6 +19,12 @@
  * `normalizeSubagentSpecs`, which is deterministic and unit-tested. `maxItems`
  * in the schema would behave differently depending on whether `ajv`, an OPTIONAL
  * dependency of core, happened to install.
+ *
+ * EVERY CHILD RUNS THE LEAD'S OWN MODEL (main-agent parity): same provider,
+ * model, thinking level and token ambition, resolved from the LIVE config at
+ * dispatch. There is no per-child `model` property and no cheap tier to pick -
+ * a delegation is never a downgrade, and the fast tier reaches children the
+ * same way it reaches the lead (compaction summaries, per-child reviews).
  */
 import { type AgentTool } from '@aragon-agent/core';
 import type { ModelCost } from '@aragon-agent/core';
@@ -27,38 +33,12 @@ export interface TaskToolDeps {
     runtime: TeamRuntime;
     /** Read LIVE, never cached: `/team off` flips this, it does not unregister. */
     isTeamEnabled: () => boolean;
-    /**
-     * Whether the fast tier was resolvable AT CONSTRUCTION (fast-model-tier §3.3 /
-     * C-2).
-     *
-     * DECIDED ONCE, because the tool array is built once and must never be
-     * rebuilt: `Agent.setTools()` mutates the live `ToolRegistry`, and
-     * `submit_plan` flips the session mode from INSIDE a tool execution. So the
-     * `model` property either exists in this schema for the whole session or never
-     * does — and with it absent, `TASK_DESCRIPTION` and the schema are
-     * BYTE-IDENTICAL to the pre-feature build (AC-3).
-     *
-     * Optional so every existing construction site and test compiles unchanged.
-     */
-    fastRegistered?: boolean;
-    /**
-     * Whether `model:"fast"` is honoured RIGHT NOW. Read LIVE, at dispatch time
-     * (RV-3) — the tier can stop resolving mid-session, and a downgrade is the
-     * honest observable either way.
-     */
-    fastAvailable?: () => boolean;
     maxSubagents: () => number;
     /** Whether a usable key exists for the active provider right now (P2-3). */
     hasApiKey: () => boolean;
     activeProvider: () => string;
     /** The lead's cost table, so the report header states real spend (R-5). */
     modelCost: () => ModelCost | undefined;
-    /** The FAST model's cost table (fast-model-tier §3.4). Absent when the tier is
-     *  off, which is what leaves the report byte-identical. */
-    fastModelCost?: () => ModelCost | undefined;
-    /** Whether the static price table has never heard of the fast model (C-11 /
-     *  RV-4). `unknown` is rendered as unknown, NEVER as `$0.00`. */
-    fastPricingUnknown?: () => boolean;
     /**
      * Run the dispatch with the LEAD's idle watchdog paused, `try/finally` inside.
      *

package/dist/team/task-tool.js

@@ -19,6 +19,12 @@
  * `normalizeSubagentSpecs`, which is deterministic and unit-tested. `maxItems`
  * in the schema would behave differently depending on whether `ajv`, an OPTIONAL
  * dependency of core, happened to install.
+ *
+ * EVERY CHILD RUNS THE LEAD'S OWN MODEL (main-agent parity): same provider,
+ * model, thinking level and token ambition, resolved from the LIVE config at
+ * dispatch. There is no per-child `model` property and no cheap tier to pick -
+ * a delegation is never a downgrade, and the fast tier reaches children the
+ * same way it reaches the lead (compaction summaries, per-child reviews).
  */
 import { errorResult, textResult } from '@aragon-agent/core';
 import { TEAM_LIMITS } from './limits.js';
@@ -33,45 +39,23 @@ const TEAM_OFF_REFUSAL = 'Team mode is off for this session. Do this work yourse
  */
 const TASK_DESCRIPTION = 'Run several independent subagents in parallel and get one combined report. Each ' +
     'subagent is a fresh agent with the same tools and working directory but NO memory of ' +
-    'this conversation - its prompt must be self-contained. Use this when a task splits ' +
+    'this conversation - its prompt must be self-contained. Each runs on the same model ' +
+    'you are running on. Use this when a task splits ' +
     'into 2 or more parts that do not depend on each other\'s output, especially reading or ' +
     'searching several areas at once. Do NOT use it when one part needs another part\'s ' +
     'result (do those yourself, in order), when two parts would edit the same file, or for ' +
     'a change small enough to just make. Subagents cannot dispatch further subagents and ' +
     'cannot ask the user anything. Give each a description of at most ' +
     `${TEAM_LIMITS.descriptionChars} characters and a complete prompt. Extra entries beyond the ` +
-    'configured maximum are dropped, so keep within it.';
-/**
- * The one sentence appended when the fast tier exists (fast-model-tier §4.1).
- *
- * WHEN to use a tier is POLICY and lives here and in `<fast_tier>`, where the
- * model actually reads it; the `enum` below is SHAPE and lives in the schema.
- * That split is what keeps behaviour the same whether or not `ajv` — an OPTIONAL
- * dependency of core — happened to install (C-8).
- */
-const TASK_FAST_SENTENCE = ' Set model:"fast" on a subagent whose job is bulk reading, searching or summarizing; ' +
-    'leave it out for work that needs judgement.';
-/**
- * NOT `as const`: `AgentTool.parameters` is a `JSONSchema7`, whose `enum` is a
- * MUTABLE `unknown[]`, and a readonly tuple is not assignable to it.
- */
-const SUBAGENT_MODEL_PROPERTY = {
-    type: 'string',
-    enum: ['main', 'fast'],
-    default: 'main',
-    description: 'Which tier runs this subagent. "fast" is a cheaper, quicker model - use it for ' +
-        'mechanical, high-volume work (reading or searching many files, summarizing long ' +
-        'output, mechanical edits). Keep "main" for design, tricky debugging, and anything ' +
-        'that must be right the first time.',
-};
+    'configured maximum are dropped, so keep within it. A supervisor watches the ' +
+    'fan-out: a child that stalls or runs very long may be nudged with guidance ' +
+    'or replaced by a fresh attempt, and the report\'s Supervisor section ' +
+    'records every intervention.';
 export function createTaskTool(deps) {
-    const fastRegistered = deps.fastRegistered === true;
     return {
         name: 'task',
         label: 'Dispatch subagents',
-        // BYTE-IDENTICAL WITHOUT THE TIER (AC-3): concatenation is conditional, so a
-        // default session's description is the exact string it always was.
-        description: fastRegistered ? `${TASK_DESCRIPTION}${TASK_FAST_SENTENCE}` : TASK_DESCRIPTION,
+        description: TASK_DESCRIPTION,
         parameters: {
             type: 'object',
             properties: {
@@ -99,11 +83,6 @@ export function createTaskTool(deps) {
                                 default: false,
                                 description: 'Refuse all writes and shell for this subagent.',
                             },
-                            // Spread rather than a `?:` property, so with the tier off the
-                            // object has exactly the four keys it always had — `undefined`
-                            // survives `JSON.stringify` as an absent key but not as an
-                            // identical object, and AC-3 is asserted on the schema itself.
-                            ...(fastRegistered ? { model: SUBAGENT_MODEL_PROPERTY } : {}),
                         },
                         required: ['description', 'prompt'],
                     },
@@ -131,31 +110,21 @@ export function createTaskTool(deps) {
                     'yourself, or ask the user to set a key.');
             }
             // 4. Repair, never reject. Zero survivors is the single hard failure.
-            //    `fastAvailable` is read HERE, at dispatch time, not captured at
-            //    construction (RV-3): the tier can stop resolving mid-session, and the
-            //    normalizer and the subagent factory must agree about that at the same
-            //    instant or a child gets built against a provider with no key.
-            const { specs, requested, downgraded } = normalizeSubagentSpecs(params.subagents, deps.maxSubagents(), { fastAvailable: deps.fastAvailable?.() === true });
+            const { specs, requested } = normalizeSubagentSpecs(params.subagents, deps.maxSubagents());
             if (specs.length === 0) {
                 return errorResult('No usable subagent specs: each needs a description and a prompt.');
             }
             // 5. Pause the lead's watchdog for the whole dispatch (I-3).
-            const outcome = await deps.withPausedWatchdog(() => deps.runtime.dispatch(specs, requested, ctx.signal, { downgraded }));
+            const outcome = await deps.withPausedWatchdog(() => deps.runtime.dispatch(specs, requested, ctx.signal));
             // 6. ALWAYS A NON-ERROR RESULT, abort and all-children-failed included.
             //    A cancellation or a partial result rendered as a tool FAILURE invites
             //    the model to retry the whole fan-out, which is the most expensive
             //    possible reaction (the same reasoning as `ask_user`'s cancelled
-            //    shape, and D-14 one level up).
-            //    TWO COST TABLES (§3.4 / R-7). Summing fast-tier tokens at the lead's
-            //    price is not a rounding error: for a Haiku child under a Sonnet lead
-            //    it over-reports by roughly an order of magnitude, and the whole
-            //    justification for the feature is a number in this report.
+            //    shape, and D-14 one level up). Every child ran the lead's own model,
+            //    so the lead's cost table is the one honest price for the total.
             const cost = deps.modelCost();
-            const fastCost = deps.fastModelCost?.();
             return textResult(buildDispatchReport(outcome, {
                 ...(cost ? { cost } : {}),
-                ...(fastCost ? { fastCost } : {}),
-                ...(deps.fastPricingUnknown?.() ? { fastPricingUnknown: true } : {}),
             }));
         },
     };

package/dist/team/types.d.ts

@@ -11,7 +11,6 @@
  * changes ZERO files under `packages/core/` (AC-12).
  */
 import type { TokenUsage } from '@aragon-agent/core';
-import type { FastTierName } from '../fast/types.js';
 import type { ActivityArgs } from './activity.js';
 /** One normalized delegation request. Produced only by `normalizeSubagentSpecs`. */
 export interface SubagentSpec {
@@ -27,34 +26,12 @@ export interface SubagentSpec {
      * permission than the session it was spawned from.
      */
     readOnly: boolean;
-    /**
-     * Which model runs this child (fast-model-tier §3.4).
-     *
-     * THE WIRE NAME IS `model` AND THE INTERNAL NAME IS `tier`, on purpose: a
-     * model expects to see `model:"fast"`, while `SubagentSpec.model` would read
-     * as a model ID at every call site in this package.
-     *
-     * DELEGATION IS A MODEL CHOICE, NEVER A PERMISSION BOUNDARY (D-15 / I-4). A
-     * fast child gets the same tools, the same `--confirm` gate, the same
-     * plan-mode gate and the same skills ceiling as any other; only the model
-     * differs. Restricting a fast child's tools would look like security, would
-     * not be, and would make the report's `[fast]` rows mean two different things.
-     */
-    tier: FastTierName;
 }
 export type SubagentPhase = 'queued' | 'starting' | 'thinking' | 'tool' | 'waiting' | 'done' | 'failed' | 'aborted';
 /** Live, mutable record of one child. Projected into the UI and the report. */
 export interface SubagentRun {
     label: string;
     description: string;
-    /**
-     * The tier this child actually ran on (fast-model-tier §3.4).
-     *
-     * WHAT RAN, NOT WHAT WAS ASKED FOR. A spec the normalizer downgraded arrives
-     * here as `'main'`, which is what makes the report's `[fast]` annotation and
-     * its second cost table agree with the bill.
-     */
-    tier: FastTierName;
     phase: SubagentPhase;
     startedAt?: number;
     endedAt?: number;
@@ -171,6 +148,57 @@ export interface SubagentRun {
         attempt: number;
         maxRetries: number;
     };
+    /**
+     * Supervisor inspections this child received (team-overseer). Optional so
+     * every existing fixture compiles; absent and `0` read the same.
+     */
+    interventions?: number;
+    /**
+     * Supervisor-driven rebuilds this child went through (team-overseer). The
+     * run object survives a rebuild with the same label, so this is where the
+     * report reads "this row is the Nth body of the same brief".
+     */
+    replacements?: number;
+}
+/** What the supervisor may do with one inspected child. */
+export type OverseerAction = 'wait' | 'nudge' | 'replace' | 'abandon';
+/**
+ * One supervisor decision, already normalized and clamped.
+ *
+ * Produced ONLY by `normalizeOverseerDecision` (repair, never reject): an
+ * unparseable or out-of-budget model answer becomes `wait` with the default
+ * interval, because supervision must not kill a healthy child.
+ */
+export interface OverseerDecision {
+    action: OverseerAction;
+    /** <= TEAM_LIMITS.overseerReasonChars. Why, for the report and the log. */
+    reason: string;
+    /** `nudge` only: <= TEAM_LIMITS.overseerGuidanceChars. Steered into the child. */
+    guidance?: string;
+    /** Model-chosen next check, clamped to the structural range. */
+    nextCheckMs?: number;
+}
+/** One supervisor intervention, as recorded on the outcome and rendered. */
+export interface OverseerIntervention {
+    label: string;
+    at: number;
+    action: OverseerAction;
+    reason: string;
+    /** What the trigger was: event stall, wall-clock check, or post-mortem. */
+    trigger: 'silence' | 'clock' | 'postmortem';
+}
+/**
+ * A terminal supervisor decision handed to the WORKER LOOP, which is the only
+ * place a child's `prompt()` is awaited and therefore the only place a
+ * lifecycle change can be applied without orphaning the replacement (I-OV1).
+ *
+ * Set by `TeamRuntime` on the handle, then `handle.abort()`; consumed and
+ * left in place (never cleared) by `runOne` after the await resolves.
+ */
+export interface OverseerVerdict {
+    action: 'replace' | 'abandon';
+    reason: string;
+    guidance?: string;
 }
 /** One message on the team bus. */
 export interface TeamMessage {
@@ -192,26 +220,17 @@ export interface DispatchOutcome {
     /** Messages addressed to `lead`; surfaced in their own report section. */
     leadMail: TeamMessage[];
     /**
-     * Summed across MAIN-TIER children. Real spend; it must reach the status bar
-     * (§3.9).
-     *
-     * THE MEANING NARROWED WHEN THE FAST TIER LANDED, and the split is not a
-     * rounding concern: a Haiku child under a Sonnet lead priced at the lead's
-     * table over-reports by roughly an order of magnitude, and the entire
-     * justification for delegating is a number in this report (R-7).
+     * Every supervisor decision that was applied (team-overseer), in order.
+     * Bounded by the per-child inspection budget; rendered as the report's
+     * Overseer section so the lead can see WHO was nudged or replaced and why.
      */
-    usage: TokenUsage;
-    /** Summed across FAST-TIER children. Absent when none ran, which is what
-     *  keeps a pre-feature dispatch's report byte-identical. */
-    fastUsage?: TokenUsage;
+    interventions?: OverseerIntervention[];
     /**
-     * Specs that asked for `model:"fast"` and ran on `main` anyway (§3.4 / R-6).
-     *
-     * REPORTED, NEVER SILENT. A silent downgrade means the model asked for a cheap
-     * child, got an expensive one, and has no way to learn that its cost model is
-     * wrong.
+     * Summed across all children. Real spend; it must reach the status bar
+     * (§3.9). Every child runs the LEAD's model (main-agent parity), so one
+     * total priced at the lead's table is the honest accounting.
      */
-    downgraded?: number;
+    usage: TokenUsage;
 }
 /**
  * What the UI renders: a cheap immutable projection, rebuilt per event.
@@ -246,11 +265,16 @@ export type TeamEvent = {
     dispatchId: string;
     label: string;
     usage: TokenUsage;
-    tier: FastTierName;
 } | {
     type: 'message';
     dispatchId: string;
     message: TeamMessage;
+} | {
+    type: 'overseer';
+    dispatchId: string;
+    label: string;
+    decision: OverseerDecision;
+    trigger: OverseerIntervention['trigger'];
 } | {
     type: 'dispatch_end';
     dispatchId: string;

package/dist/ui/App.d.ts

@@ -11,7 +11,7 @@ import type { ConfirmRequest } from '../tools/index.js';
 import { type Overlay, type ToastLevel } from '../agent/reducer.js';
 import type { UpdateBridge } from '../update/types.js';
 import type { MouseSource } from '../input/stdin-filter.js';
-import type { PasteBridge } from '../input/limits.js';
+import { type PasteBridge } from '../input/limits.js';
 import type { SelectionBridge } from './selection/selection-controller.js';
 import type { HumanInputBridge } from '../tools/human-input.js';
 export interface ConfirmBridge {