@aragon-agent/cli 0.6.16 → 0.6.18

package/dist/team/normalize.d.ts

@@ -17,32 +17,18 @@
  * whether an optional install step succeeded.
  *
  * NEVER THROWS. Zero survivors is the caller's single hard failure.
+ *
+ * EVERY CHILD RUNS THE LEAD'S MODEL (main-agent parity): the former
+ * `model: "fast"` per-child tier was removed, so a spec that still carries a
+ * `model` key simply ignores it - there is no tier to downgrade TO, and the
+ * honest reading of a stale key is silence, not a report line about a
+ * capability that no longer exists.
  */
 import type { SubagentSpec } from './types.js';
 export interface NormalizedSpecs {
     specs: SubagentSpec[];
     /** How many entries the model asked for, before dropping and capping. */
     requested: number;
-    /**
-     * Specs that asked for `model:"fast"` and were downgraded to `main`
-     * (fast-model-tier §3.4 / R-6).
-     *
-     * ADDITIVE: `NormalizedSpecs` GAINS a field, it does not change one, so every
-     * existing caller and test compiles unchanged.
-     */
-    downgraded: number;
-}
-/** Options for the fast tier. Optional for the reason `normalizeSubagentSpecs`
- *  documents below (RV-14). */
-export interface NormalizeOptions {
-    /**
-     * §3.3's LIVE predicate, evaluated at DISPATCH time (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.
-     */
-    fastAvailable?: boolean;
 }
 /**
  * Repair and bound a raw `subagents` array.
@@ -55,10 +41,5 @@ export interface NormalizeOptions {
  * @param max   The resolved `team.maxSubagents`; further clamped to
  *              `TEAM_LIMITS.hardMaxSubagents` here so a hand-edited config file
  *              cannot raise the requirement's ceiling (R-g).
- * @param opts  Fast-tier availability. OPTIONAL, DEFAULTING TO `false` (RV-14):
- *              this function and `NormalizedSpecs` are both exported and both
- *              have existing callers and tests, so a required third parameter
- *              would be a breaking edit that buys nothing — and an omitted one
- *              now means exactly what a pre-feature build meant.
  */
-export declare function normalizeSubagentSpecs(raw: unknown, max: number, opts?: NormalizeOptions): NormalizedSpecs;
+export declare function normalizeSubagentSpecs(raw: unknown, max: number): NormalizedSpecs;

package/dist/team/normalize.js

@@ -17,6 +17,12 @@
  * whether an optional install step succeeded.
  *
  * NEVER THROWS. Zero survivors is the caller's single hard failure.
+ *
+ * EVERY CHILD RUNS THE LEAD'S MODEL (main-agent parity): the former
+ * `model: "fast"` per-child tier was removed, so a spec that still carries a
+ * `model` key simply ignores it - there is no tier to downgrade TO, and the
+ * honest reading of a stale key is silence, not a report line about a
+ * capability that no longer exists.
  */
 import { TEAM_LIMITS } from './limits.js';
 function asString(value) {
@@ -76,21 +82,13 @@ function dedupeLabel(label, taken) {
  * @param max   The resolved `team.maxSubagents`; further clamped to
  *              `TEAM_LIMITS.hardMaxSubagents` here so a hand-edited config file
  *              cannot raise the requirement's ceiling (R-g).
- * @param opts  Fast-tier availability. OPTIONAL, DEFAULTING TO `false` (RV-14):
- *              this function and `NormalizedSpecs` are both exported and both
- *              have existing callers and tests, so a required third parameter
- *              would be a breaking edit that buys nothing — and an omitted one
- *              now means exactly what a pre-feature build meant.
  */
-export function normalizeSubagentSpecs(raw, max, opts = {}) {
+export function normalizeSubagentSpecs(raw, max) {
     if (!Array.isArray(raw))
-        return { specs: [], requested: 0, downgraded: 0 };
+        return { specs: [], requested: 0 };
     const requested = raw.length;
-    const fastAvailable = opts.fastAvailable === true;
     const kept = [];
     const taken = new Set();
-    /** Parallel to `kept`: did entry `i` ask for the fast tier? */
-    const wantedFast = [];
     for (let i = 0; i < raw.length; i += 1) {
         const item = raw[i];
         if (!item || typeof item !== 'object')
@@ -102,25 +100,14 @@ export function normalizeSubagentSpecs(raw, max, opts = {}) {
         const prompt = clamp(asString(src.prompt), TEAM_LIMITS.promptChars);
         if (prompt.length === 0)
             continue;
-        // REPAIR, NEVER REJECT — this file's own contract. `'fast'` without
-        // availability becomes `'main'` AND IS COUNTED; anything else (a typo, a
-        // model id, `undefined`) is simply `'main'` and is NOT counted, because the
-        // model did not ask for the fast tier and has nothing to be told about.
-        const wantsFast = src.model === 'fast';
-        wantedFast.push(wantsFast);
         kept.push({
             label: dedupeLabel(slugLabel(src.label, kept.length), taken),
             description,
             prompt,
             readOnly: src.readOnly === true,
-            tier: wantsFast && fastAvailable ? 'fast' : 'main',
         });
     }
     const ceiling = Math.max(1, Math.min(Math.floor(max) || 1, TEAM_LIMITS.hardMaxSubagents));
     const specs = kept.slice(0, ceiling);
-    // COUNTED OVER THE SURVIVORS, not over everything the model wrote: a spec the
-    // cap dropped never ran at all, so reporting it as "ran on the main model"
-    // would be a second, different lie in a line that exists to stop the first.
-    const downgraded = specs.filter((spec, i) => spec.tier === 'main' && wantedFast[i] === true).length;
-    return { specs, requested, downgraded };
+    return { specs, requested };
 }

package/dist/team/overseer.d.ts

@@ -0,0 +1,157 @@
+/**
+ * The dispatch supervisor (team-overseer).
+ *
+ * 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.
+ *
+ * A TIME CEILING ON A CHILD IS AN INSPECTION TRIGGER, NOT A DEATH SENTENCE.
+ * When a child stalls (event silence) or simply runs long (the wall clock),
+ * the supervisor looks at it through ONE bounded fast-tier call and decides:
+ * keep waiting, steer a nudge in to help it recover, rebuild it with an
+ * amended brief, or abandon it with a recorded reason. Only the supervisor
+ * "decides"; the RUNTIME applies (see `runtime.ts`), because every child
+ * lifecycle change must funnel through the worker loop that awaits it
+ * (I-OV1).
+ *
+ * THE TRANSPORT IS THE REVIEWER'S, DELIBERATELY. One `complete` call, no
+ * tools, thinking off, temperature 0, output capped at
+ * `FAST_LIMITS.reviewOutputTokens` and wall clock at
+ * `FAST_LIMITS.reviewTimeoutMs` — a supervision call that could itself hang
+ * would need a second supervisor, which is the regress this design refuses.
+ *
+ * REPAIR, NEVER REJECT (the `normalizeSubagentSpecs` rule). An unparseable
+ * or out-of-budget decision becomes `wait` with the default interval: the
+ * failure mode of a supervisor must be "looked and let it run", never
+ * "looked and killed it" (I-OV2).
+ */
+import type { AssistantMessage, LLMRequest, Message } from '@aragon-agent/core';
+import type { ModelRole } from '../config/model-profiles.js';
+import type { CliConfig } from '../config/schema.js';
+import type { OverseerAction, OverseerDecision, SubagentRun, SubagentSpec } from './types.js';
+/** One remembered decision, so the second look knows the first happened. */
+export interface OverseerMemoryEntry {
+    /** Seconds into the dispatch. */
+    atSec: number;
+    action: OverseerAction;
+    reason: string;
+}
+/** Everything one digest is built from. Structural, so tests stub it whole. */
+export interface ChildDigestInput {
+    run: SubagentRun;
+    /** False only in the post-mortem inspection, after the child settled. */
+    childAlive: boolean;
+    trigger: 'silence' | 'clock' | 'postmortem';
+    /** The child's LIVE history (`SubagentAgentLike.state.messages`). */
+    messages: readonly Message[];
+    memory: readonly OverseerMemoryEntry[];
+    /** Seconds the child has been running. */
+    elapsedSec: number;
+}
+/**
+ * Build the bounded text one inspection reads.
+ *
+ * FACTS FIRST, HISTORY SECOND: the byte clamp (`overseerDigestBytes`, via the
+ * same `truncateBytes` the report uses so a CJK tail cannot be split mid
+ * sequence) bites the tail, and the tail is the least decisive part — a
+ * supervisor that cannot see the phase, the retry state and its own memory
+ * is worse than one missing the fifth message back.
+ */
+export declare function buildChildDigest(input: ChildDigestInput): string;
+/** Clamp a model-chosen next check into the structural range. */
+export declare function clampNextCheckMs(ms: unknown): number | undefined;
+/**
+ * Normalize a raw (JSON-parsed or garbage) decision into a safe one.
+ *
+ * `childAlive === false` PHYSICALLY REMOVES two actions: a dead child can be
+ * replaced or abandoned, never waited on or nudged, so those normalize to
+ * `abandon` rather than being rejected — a post-mortem answer the protocol
+ * cannot honour must still produce a decision the runtime can apply.
+ */
+export declare function normalizeOverseerDecision(raw: unknown, childAlive: boolean): OverseerDecision;
+/**
+ * Parse the model's answer text as one JSON decision object.
+ *
+ * Forgiving on PURPOSE: models wrap JSON in prose and fences. The FIRST `{`
+ * to the LAST `}` is the only span tried, and anything that does not parse is
+ * `wait` — the caller never sees a throw from parsing.
+ */
+export declare function parseOverseerDecisionText(text: string, childAlive: boolean): OverseerDecision;
+/** The slice the runtime needs: "can you look?" and "decide". */
+export interface OverseerProvider {
+    /** Live predicate, re-read per dispatch AND per inspection. */
+    active(): boolean;
+    /** One bounded decision call. Implementations must not throw. */
+    inspect(req: {
+        label: string;
+        goal: string;
+        digest: string;
+    }): Promise<OverseerDecision>;
+}
+/** Everything the fast-tier-backed provider needs from the session. */
+export interface FastOverseerDeps {
+    /** Read LIVE: a mid-dispatch `/fast off` must reach the next inspection. */
+    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()`. */
+    available: () => boolean;
+}
+/**
+ * The fast-tier-backed provider, mirroring `createChildReviewer`'s shape so
+ * the controller wires it the same way: shared transport, live predicates,
+ * fail-soft (any failure resolves to `wait` — I-OV2).
+ */
+export declare function createFastOverseerProvider(deps: FastOverseerDeps): OverseerProvider;
+/** One inspection request, as the runtime builds it. */
+export interface OverseerInspectRequest {
+    run: SubagentRun;
+    messages: readonly Message[];
+    trigger: 'silence' | 'clock' | 'postmortem';
+    childAlive: boolean;
+}
+export interface TeamOverseerOptions {
+    /** The dispatch's start, so memory entries read as "N s in". */
+    startedAt: number;
+    now?: () => number;
+}
+export declare const OVERSEER_DEFAULT_NEXT_CHECK_MS: 300000;
+/**
+ * Per-dispatch supervisor state: memory, budgets and the single-flight guard.
+ *
+ * THE CLASS NEVER TOUCHES A CHILD (I-OV1). It looks and decides; `runtime.ts`
+ * steers, flags, aborts and rebuilds, because only the worker loop can apply
+ * a lifecycle change without orphaning the replacement.
+ */
+export declare class TeamOverseer {
+    private readonly provider;
+    private readonly options;
+    private readonly memory;
+    private readonly inspections;
+    private readonly replacements;
+    private readonly inFlight;
+    constructor(provider: OverseerProvider, options: TeamOverseerOptions);
+    /** Never throws: a provider bug must not take the dispatch down. */
+    isActive(): boolean;
+    inspectionsExhausted(label: string): boolean;
+    replacementsLeft(label: string): boolean;
+    /** Called by the runtime when it APPLIES a replace, not when it merely reads one. */
+    noteReplacement(label: string): void;
+    /**
+     * ONE inspection. `null` means QUIET — not active, no budget left, or one
+     * already in flight for this child — and the caller then does nothing,
+     * which is exactly what quiet should do.
+     */
+    inspect(req: OverseerInspectRequest): Promise<OverseerDecision | null>;
+}
+/**
+ * Prepend the supervisor's note to a spec's prompt, bounding the TOTAL to
+ * `TEAM_LIMITS.promptChars` so the replacement fits exactly what a
+ * model-supplied spec would have been allowed to carry.
+ *
+ * THE NOTE TELLS THE FRESH CHILD WHAT THE DEAD ONE DID (`filesTouched` is
+ * best-effort, the same caveat the report's conflict warning carries): a
+ * replacement that rewrites a half-written file blind is not a recovery.
+ */
+export declare function buildReplacementPrompt(spec: SubagentSpec, decision: OverseerDecision, previousRun: SubagentRun): string;

package/dist/team/overseer.js

@@ -0,0 +1,348 @@
+/**
+ * The dispatch supervisor (team-overseer).
+ *
+ * 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.
+ *
+ * A TIME CEILING ON A CHILD IS AN INSPECTION TRIGGER, NOT A DEATH SENTENCE.
+ * When a child stalls (event silence) or simply runs long (the wall clock),
+ * the supervisor looks at it through ONE bounded fast-tier call and decides:
+ * keep waiting, steer a nudge in to help it recover, rebuild it with an
+ * amended brief, or abandon it with a recorded reason. Only the supervisor
+ * "decides"; the RUNTIME applies (see `runtime.ts`), because every child
+ * lifecycle change must funnel through the worker loop that awaits it
+ * (I-OV1).
+ *
+ * THE TRANSPORT IS THE REVIEWER'S, DELIBERATELY. One `complete` call, no
+ * tools, thinking off, temperature 0, output capped at
+ * `FAST_LIMITS.reviewOutputTokens` and wall clock at
+ * `FAST_LIMITS.reviewTimeoutMs` — a supervision call that could itself hang
+ * would need a second supervisor, which is the regress this design refuses.
+ *
+ * REPAIR, NEVER REJECT (the `normalizeSubagentSpecs` rule). An unparseable
+ * or out-of-budget decision becomes `wait` with the default interval: the
+ * failure mode of a supervisor must be "looked and let it run", never
+ * "looked and killed it" (I-OV2).
+ */
+import { resolveFastTier } from '../fast/resolve.js';
+import { assistantText } from '../fast/review-call.js';
+import { FAST_LIMITS } from '../fast/limits.js';
+import { truncateBytes } from './report.js';
+import { TEAM_LIMITS } from './limits.js';
+/** How many trailing history messages the digest carries. */
+const DIGEST_TAIL_MESSAGES = 8;
+/** Per-message text clamp inside the digest. */
+const DIGEST_MSG_CHARS = 400;
+function messageText(message) {
+    if (message.role === 'assistant') {
+        const parts = [];
+        for (const block of message.content) {
+            if (block.type === 'text')
+                parts.push(block.text);
+            if (block.type === 'tool_call')
+                parts.push(`(tool_call ${block.toolName})`);
+        }
+        return parts.join(' ').trim();
+    }
+    if (typeof message.content === 'string')
+        return message.content;
+    return message.content
+        .filter((p) => p.type === 'text')
+        .map((p) => (p.type === 'text' ? p.text : ''))
+        .join(' ')
+        .trim();
+}
+function clampChars(text, max) {
+    return text.length <= max ? text : `${text.slice(0, Math.max(0, max - 3))}...`;
+}
+/**
+ * Build the bounded text one inspection reads.
+ *
+ * FACTS FIRST, HISTORY SECOND: the byte clamp (`overseerDigestBytes`, via the
+ * same `truncateBytes` the report uses so a CJK tail cannot be split mid
+ * sequence) bites the tail, and the tail is the least decisive part — a
+ * supervisor that cannot see the phase, the retry state and its own memory
+ * is worse than one missing the fifth message back.
+ */
+export function buildChildDigest(input) {
+    const { run, childAlive, trigger, messages, memory, elapsedSec } = input;
+    const lines = [];
+    lines.push(`child: ${run.label} "${run.description}"`);
+    lines.push(`trigger: ${trigger === 'silence' ? 'event silence (suspected stall)' : trigger === 'clock' ? 'wall-clock check' : 'post-mortem (child already ended)'}`);
+    lines.push(`elapsed: ${Math.round(elapsedSec)}s, alive: ${childAlive ? 'yes' : 'no'}`);
+    lines.push(`phase: ${run.phase}, turns: ${run.turns}, toolCalls: ${run.toolCalls}` +
+        (run.lastTool ? `, lastTool: ${run.lastTool}` : ''));
+    if (run.retry)
+        lines.push(`api-retry: attempt ${run.retry.attempt}/${run.retry.maxRetries} (legitimate backoff, not a stall)`);
+    if (run.error)
+        lines.push(`error: ${clampChars(run.error, DIGEST_MSG_CHARS)}`);
+    if (run.filesTouched.length > 0)
+        lines.push(`files: ${run.filesTouched.join(', ')}`);
+    if (memory.length > 0) {
+        lines.push('previous supervisor decisions:');
+        for (const entry of memory) {
+            lines.push(`  [${entry.atSec}s] ${entry.action}: ${clampChars(entry.reason, 120)}`);
+        }
+    }
+    const tail = messages.slice(-DIGEST_TAIL_MESSAGES);
+    if (tail.length > 0) {
+        lines.push('history tail:');
+        for (const message of tail) {
+            const text = clampChars(messageText(message), DIGEST_MSG_CHARS);
+            lines.push(`  ${message.role}: ${text.length > 0 ? text : '(no text)'}`);
+        }
+    }
+    return truncateBytes(lines.join('\n'), TEAM_LIMITS.overseerDigestBytes);
+}
+// ---------------------------------------------------------------------------
+// Decision normalization
+// ---------------------------------------------------------------------------
+const VALID_ACTIONS = new Set(['wait', 'nudge', 'replace', 'abandon']);
+/** Clamp a model-chosen next check into the structural range. */
+export function clampNextCheckMs(ms) {
+    const n = typeof ms === 'number' ? ms : Number.NaN;
+    if (!Number.isFinite(n) || n <= 0)
+        return undefined;
+    return Math.min(TEAM_LIMITS.overseerNextCheckMaxMs, Math.max(TEAM_LIMITS.overseerNextCheckMinMs, Math.round(n)));
+}
+function waitDecision(reason, nextCheckMs) {
+    return {
+        action: 'wait',
+        reason: clampChars(reason, TEAM_LIMITS.overseerReasonChars),
+        ...(nextCheckMs !== undefined ? { nextCheckMs } : {}),
+    };
+}
+/**
+ * Normalize a raw (JSON-parsed or garbage) decision into a safe one.
+ *
+ * `childAlive === false` PHYSICALLY REMOVES two actions: a dead child can be
+ * replaced or abandoned, never waited on or nudged, so those normalize to
+ * `abandon` rather than being rejected — a post-mortem answer the protocol
+ * cannot honour must still produce a decision the runtime can apply.
+ */
+export function normalizeOverseerDecision(raw, childAlive) {
+    const obj = (raw && typeof raw === 'object' ? raw : {});
+    const action = typeof obj.action === 'string' && VALID_ACTIONS.has(obj.action)
+        ? obj.action
+        : 'wait';
+    const reason = typeof obj.reason === 'string' && obj.reason.trim().length > 0
+        ? obj.reason.trim()
+        : 'no reason given';
+    const guidance = typeof obj.guidance === 'string' && obj.guidance.trim().length > 0
+        ? clampChars(obj.guidance.trim(), TEAM_LIMITS.overseerGuidanceChars)
+        : undefined;
+    const nextCheckMs = clampNextCheckMs(obj.nextCheckMs);
+    if (!childAlive && (action === 'wait' || action === 'nudge')) {
+        return {
+            action: 'abandon',
+            reason: clampChars(`child already ended; supervisor answered ${action}: ${reason}`, TEAM_LIMITS.overseerReasonChars),
+        };
+    }
+    return {
+        action,
+        reason: clampChars(reason, TEAM_LIMITS.overseerReasonChars),
+        ...(guidance !== undefined && action === 'nudge' ? { guidance } : {}),
+        ...(action === 'wait' && nextCheckMs !== undefined ? { nextCheckMs } : {}),
+    };
+}
+/**
+ * Parse the model's answer text as one JSON decision object.
+ *
+ * Forgiving on PURPOSE: models wrap JSON in prose and fences. The FIRST `{`
+ * to the LAST `}` is the only span tried, and anything that does not parse is
+ * `wait` — the caller never sees a throw from parsing.
+ */
+export function parseOverseerDecisionText(text, childAlive) {
+    const first = text.indexOf('{');
+    const last = text.lastIndexOf('}');
+    if (first >= 0 && last > first) {
+        try {
+            return normalizeOverseerDecision(JSON.parse(text.slice(first, last + 1)), childAlive);
+        }
+        catch {
+            // Fall through to the safe default.
+        }
+    }
+    return waitDecision('decision unparseable; defaulting to wait');
+}
+const OVERSEER_SYSTEM_PROMPT = [
+    'You are the supervisor of a team of subagents. You are shown ONE subagent',
+    'that crossed a time trigger (event silence or a wall-clock check) and must',
+    'decide what to do with it. Answer with ONE JSON object and nothing else:',
+    '{"action": "wait" | "nudge" | "replace" | "abandon", "reason": "<= 200 chars",',
+    ' "guidance": "<= 1200 chars, nudge only", "nextCheckMs": <ms, wait only>}.',
+    'wait: the child looks healthy or is legitimately blocked (API backoff,',
+    '  waiting on a teammate or a human confirmation) - keep waiting, pick the',
+    '  next check delay.',
+    'nudge: the child is stuck in a way a hint can fix (wrong path, retrying a',
+    '  failing command, circling) - write the hint as guidance.',
+    'replace: the child cannot recover - a fresh child will be built with your',
+    '  reason and guidance prepended to its brief.',
+    'abandon: the task is not worth more attempts - the child is stopped and',
+    '  your reason is reported to the lead.',
+    'A nudge is only delivered after the child finishes its current tool call;',
+    'a long-running tool is not a stall. Prefer the cheapest action that works.',
+].join('\n');
+function buildInspectionRequest(params) {
+    return {
+        model: params.modelId,
+        ...(params.baseUrl ? { baseUrl: params.baseUrl } : {}),
+        apiKey: params.apiKey,
+        systemPrompt: OVERSEER_SYSTEM_PROMPT,
+        messages: [{ role: 'user', content: params.digest, timestamp: Date.now() }],
+        maxTokens: FAST_LIMITS.reviewOutputTokens,
+        thinkingLevel: 'off',
+        temperature: 0,
+        signal: params.signal,
+    };
+}
+/**
+ * The fast-tier-backed provider, mirroring `createChildReviewer`'s shape so
+ * the controller wires it the same way: shared transport, live predicates,
+ * fail-soft (any failure resolves to `wait` — I-OV2).
+ */
+export function createFastOverseerProvider(deps) {
+    const tier = () => resolveFastTier(deps.getConfig(), deps.hasKey);
+    return {
+        active: () => deps.available() && tier().ok,
+        async inspect(req) {
+            const resolved = tier();
+            if (!deps.available() || !resolved.ok) {
+                return waitDecision('fast tier unavailable; defaulting to wait');
+            }
+            const apiKey = deps.getApiKey(resolved.ref.providerId, 'fast');
+            if (apiKey === undefined) {
+                return waitDecision('no fast-tier key; defaulting to wait');
+            }
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), FAST_LIMITS.reviewTimeoutMs);
+            try {
+                const message = await deps.complete(resolved.ref.providerId, buildInspectionRequest({
+                    digest: req.digest,
+                    modelId: resolved.ref.modelId,
+                    ...(resolved.ref.baseUrl ? { baseUrl: resolved.ref.baseUrl } : {}),
+                    apiKey,
+                    signal: controller.signal,
+                }));
+                return parseOverseerDecisionText(assistantText(message), true);
+            }
+            catch {
+                // INCLUDING a timeout abort: supervision failing is wait, never kill.
+                return waitDecision('inspection call failed; defaulting to wait');
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    };
+}
+export const OVERSEER_DEFAULT_NEXT_CHECK_MS = TEAM_LIMITS.overseerDefaultCheckMs;
+/**
+ * Per-dispatch supervisor state: memory, budgets and the single-flight guard.
+ *
+ * THE CLASS NEVER TOUCHES A CHILD (I-OV1). It looks and decides; `runtime.ts`
+ * steers, flags, aborts and rebuilds, because only the worker loop can apply
+ * a lifecycle change without orphaning the replacement.
+ */
+export class TeamOverseer {
+    provider;
+    options;
+    memory = new Map();
+    inspections = new Map();
+    replacements = new Map();
+    inFlight = new Set();
+    constructor(provider, options) {
+        this.provider = provider;
+        this.options = options;
+    }
+    /** Never throws: a provider bug must not take the dispatch down. */
+    isActive() {
+        try {
+            return this.provider.active();
+        }
+        catch {
+            return false;
+        }
+    }
+    inspectionsExhausted(label) {
+        return (this.inspections.get(label) ?? 0) >= TEAM_LIMITS.overseerMaxInspectionsPerChild;
+    }
+    replacementsLeft(label) {
+        return (this.replacements.get(label) ?? 0) < TEAM_LIMITS.overseerMaxReplacementsPerChild;
+    }
+    /** Called by the runtime when it APPLIES a replace, not when it merely reads one. */
+    noteReplacement(label) {
+        this.replacements.set(label, (this.replacements.get(label) ?? 0) + 1);
+    }
+    /**
+     * ONE inspection. `null` means QUIET — not active, no budget left, or one
+     * already in flight for this child — and the caller then does nothing,
+     * which is exactly what quiet should do.
+     */
+    async inspect(req) {
+        const label = req.run.label;
+        if (!this.isActive() || this.inspectionsExhausted(label) || this.inFlight.has(label)) {
+            return null;
+        }
+        this.inFlight.add(label);
+        const now = this.options.now?.() ?? Date.now();
+        const digest = buildChildDigest({
+            run: req.run,
+            childAlive: req.childAlive,
+            trigger: req.trigger,
+            messages: req.messages,
+            memory: this.memory.get(label) ?? [],
+            elapsedSec: Math.max(0, (now - (req.run.startedAt ?? now)) / 1000),
+        });
+        let decision;
+        try {
+            decision = await this.provider.inspect({
+                label,
+                goal: req.run.description,
+                digest,
+            });
+        }
+        catch {
+            decision = waitDecision('inspection threw; defaulting to wait');
+        }
+        finally {
+            this.inFlight.delete(label);
+        }
+        this.inspections.set(label, (this.inspections.get(label) ?? 0) + 1);
+        const entries = this.memory.get(label) ?? [];
+        entries.push({
+            atSec: Math.max(0, Math.round((now - this.options.startedAt) / 1000)),
+            action: decision.action,
+            reason: decision.reason,
+        });
+        this.memory.set(label, entries);
+        return decision;
+    }
+}
+// ---------------------------------------------------------------------------
+// Replacement brief
+// ---------------------------------------------------------------------------
+/** Headroom the amended brief keeps over the original prompt's clamp. */
+const REPLACEMENT_NOTE_CHARS = 800;
+/**
+ * Prepend the supervisor's note to a spec's prompt, bounding the TOTAL to
+ * `TEAM_LIMITS.promptChars` so the replacement fits exactly what a
+ * model-supplied spec would have been allowed to carry.
+ *
+ * THE NOTE TELLS THE FRESH CHILD WHAT THE DEAD ONE DID (`filesTouched` is
+ * best-effort, the same caveat the report's conflict warning carries): a
+ * replacement that rewrites a half-written file blind is not a recovery.
+ */
+export function buildReplacementPrompt(spec, decision, previousRun) {
+    const files = previousRun.filesTouched.length > 0
+        ? ` It already wrote to: ${previousRun.filesTouched.join(', ')}.`
+        : '';
+    const guidance = decision.action === 'replace' && decision.guidance !== undefined
+        ? ` Guidance: ${decision.guidance}`
+        : '';
+    const note = clampChars(`[supervisor note] A previous attempt at this task ran ${previousRun.turns} turns ` +
+        `and was replaced. Reason: ${decision.reason}.${files}${guidance} ` +
+        `Verify rather than assume prior work is complete.\n\n`, REPLACEMENT_NOTE_CHARS);
+    const originalBudget = Math.max(0, TEAM_LIMITS.promptChars - note.length);
+    return `${note}${spec.prompt.slice(0, originalBudget)}`;
+}

package/dist/team/prompt.d.ts

@@ -18,17 +18,6 @@ export { TEAM_BLOCK_VERSION };
 export interface TeamBlockParams {
     maxSubagents: number;
     maxConcurrent: number;
-    /**
-     * Whether `model:"fast"` is honoured on `task` right now (fast-model-tier
-     * §3.8).
-     *
-     * ONE SENTENCE, AND ONLY WHEN IT IS TRUE. `<fast_tier>` carries the full
-     * guidance; this is the cross-reference that stops a model reading
-     * `<team_mode>` in isolation and concluding every child costs the same. With
-     * it absent the block is BYTE-IDENTICAL to the pre-feature output, which is
-     * what `--no-fast` and every existing snapshot depend on.
-     */
-    fastDelegation?: boolean;
 }
 /**
  * The lead's `<team_mode>` block. Under 1200 characters on purpose: it is paid

package/dist/team/prompt.js

@@ -44,19 +44,10 @@ export function buildTeamBlock(params) {
         '',
         'Each subagent starts with no memory of this conversation, so its prompt must',
         'carry everything it needs: the goal, the files or areas it owns, and what to',
-        'report back. Give each one a disjoint set of files to write. Subagents cannot',
-        'dispatch further subagents and cannot ask the user anything.',
+        'report back. Give each one a disjoint set of files to write. Every subagent',
+        'runs on your own model. Subagents cannot dispatch further subagents and',
+        'cannot ask the user anything.',
         '',
-        // THE TRAILING BLANK IS INSIDE THE CONDITIONAL, not outside it. An
-        // unconditional `''` here would add a line to EVERY team-enabled prompt and
-        // silently break the byte-identity `--no-fast` depends on (I-2).
-        ...(params.fastDelegation
-            ? [
-                'A subagent doing mechanical, high-volume work can run on the cheaper fast',
-                'model - see <fast_tier>.',
-                '',
-            ]
-            : []),
         'You get one combined report when they all finish. Read it before deciding what',
         'to do next, and tell the user what the team found in your own words.',
         '</team_mode>',