@aragon-agent/cli 0.6.15 → 0.6.17

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/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>',

package/dist/team/report.d.ts

@@ -23,26 +23,11 @@
 import type { ModelCost } from '@aragon-agent/core';
 import type { DispatchOutcome, SubagentRun } from './types.js';
 export interface ReportOptions {
-    /** The lead's model cost table, so the header can state real spend (R-5). */
-    cost?: ModelCost;
-    /**
-     * The FAST model's cost table (fast-model-tier §3.4 / R-7).
-     *
-     * A SECOND TABLE, not a second number derived from the first. Summing
-     * fast-tier tokens at the lead's price over-reports a Haiku child under a
-     * Sonnet lead by roughly an order of magnitude, and the whole justification
-     * for delegating to a cheaper model is the figure on this line.
-     */
-    fastCost?: ModelCost;
-    /**
-     * The static price table has never heard of the fast model (C-11 / RV-4).
+    /** The lead's model cost table, so the header can state real spend (R-5).
      *
-     * UNKNOWN PRICING IS NOT ZERO PRICING. `buildRuntimeModel` hands back
-     * `cost: { input: 0, output: 0 }` for an unrecognised id, and the fast tier is
-     * precisely where an unrecognised id is LIKELY — so rendering it as `$0.00`
-     * would make the feature look free while it is spending money.
-     */
-    fastPricingUnknown?: boolean;
+     * THE ONE TABLE, because every child runs the lead's own model
+     * (main-agent parity): one tier, one price, one honest total. */
+    cost?: ModelCost;
 }
 /**
  * Cut `text` to at most `maxBytes` WITHOUT splitting a UTF-8 sequence.

package/dist/team/report.js

@@ -106,28 +106,6 @@ function buildHeader(outcome, options) {
             `(${counts}) in ${formatDuration(durationMs)}.`);
     lines.push(`Tokens: in ${formatTokens(outcome.usage.inputTokens)}, out ` +
         `${formatTokens(outcome.usage.outputTokens)}. Cost: ${formatCost(computeCost(outcome.usage, options.cost))}.`);
-    // A SECOND LINE, NOT A COMBINED TOTAL (fast-model-tier §3.4). Two tiers with
-    // two price tables have two answers, and folding them into one figure is the
-    // misattribution R-7 is about. Present only when a fast child actually ran, so
-    // an ordinary dispatch's header is byte-identical.
-    const fastUsage = outcome.fastUsage;
-    if (fastUsage) {
-        // `unknown` rather than a currency amount when the model has no price table
-        // (RV-4): a lower bound rendered as a total is the same class of lie as
-        // pricing a Haiku child at Sonnet rates.
-        const fastCostLabel = options.fastPricingUnknown
-            ? 'unknown (no price table)'
-            : formatCost(computeCost(fastUsage, options.fastCost));
-        lines.push(`Fast tier: in ${formatTokens(fastUsage.inputTokens)}, out ` +
-            `${formatTokens(fastUsage.outputTokens)}. Cost: ${fastCostLabel}.`);
-    }
-    // THE LINE THAT KEEPS A DOWNGRADE FROM BEING SILENT (R-6). Without it the
-    // model asked for a cheap child, got an expensive one, and has no way to learn
-    // that its cost model is wrong.
-    if (outcome.downgraded && outcome.downgraded > 0) {
-        const n = outcome.downgraded;
-        lines.push(`${n} ${n === 1 ? 'subagent' : 'subagents'} ran on the main model (fast tier off).`);
-    }
     for (const conflict of findFileConflicts(outcome.runs)) {
         const who = conflict.labels.map((l) => `"${l}"`).join(' and ');
         lines.push(`WARNING: agents ${who} both wrote ${conflict.path} - review before trusting either.`);
@@ -139,10 +117,6 @@ function buildSection(run) {
     // the only place the lead learns that a child's first attempt died before it
     // did anything (F-4).
     const retried = run.retries ? `, retried ${run.retries}x` : '';
-    // `[fast]` after the LABEL, on the head line, which is never trimmed. Six
-    // bytes, and it is the only place the lead learns which of its children were
-    // cheap — the fact the whole second cost line is about.
-    const tier = run.tier === 'fast' ? ' [fast]' : '';
     // `compacted N` in the same position `retried Nx` uses, and for the same
     // reason (context-auto-compaction-hardening §3.4.4 / W3): this is the ONLY
     // place the lead learns that a child's own history was summarized mid-task, so
@@ -150,7 +124,7 @@ function buildSection(run) {
     // rather than an unexplained one. Absent when it never happened.
     const compacted = run.compactions ? `, compacted ${run.compactions}` : '';
     const head = [
-        `### ${run.label}${tier} "${run.description}"  ${statusBadge(run)}  ${elapsed(run)}, ` +
+        `### ${run.label} "${run.description}"  ${statusBadge(run)}  ${elapsed(run)}, ` +
             `${run.turns} turns, ${run.toolCalls} tools${retried}${compacted}`,
     ];
     if (run.filesTouched.length > 0)

package/dist/team/runtime.d.ts

@@ -56,11 +56,11 @@ export interface TeamRuntimeDeps {
     /** Test seam (§8.1): a stub factory keeps the whole scheduler off the network. */
     agentFactory?: SubagentAgentFactory;
     /**
-     * Per-tier model resolution (fast-model-tier §3.4). Passed straight through to
-     * `SubagentDeps`; absent means every child runs on the session's model, which
-     * is the pre-feature behaviour.
+     * Per-child fast review (main-agent parity), passed straight through to
+     * `SubagentDeps`. ABSENT means the session has no fast wiring and children
+     * are built exactly as they were before the reviewers existed.
      */
-    resolveTier?: SubagentDeps['resolveTier'];
+    review?: SubagentDeps['review'];
     /**
      * Per-child context compaction (context-auto-compaction-hardening §3.4 / W3).
      *
@@ -104,12 +104,7 @@ export declare class TeamRuntime {
     isBusy(): boolean;
     /** The live roster, for `/team` status. `null` when nothing is dispatching. */
     snapshot(): TeamSnapshot | null;
-    dispatch(specs: SubagentSpec[], requested: number, signal?: AbortSignal, 
-    /** Carried through from the normalizer so the report can state it (§3.4 /
-     *  R-6). Optional, so every existing caller compiles unchanged. */
-    extra?: {
-        downgraded?: number;
-    }): Promise<DispatchOutcome>;
+    dispatch(specs: SubagentSpec[], requested: number, signal?: AbortSignal): Promise<DispatchOutcome>;
     /** One slot of the pool: take the next index until the list is exhausted. */
     private worker;
     /**

package/dist/team/runtime.js

@@ -65,10 +65,7 @@ export class TeamRuntime {
     // -------------------------------------------------------------------------
     // Dispatch
     // -------------------------------------------------------------------------
-    async dispatch(specs, requested, signal, 
-    /** Carried through from the normalizer so the report can state it (§3.4 /
-     *  R-6). Optional, so every existing caller compiles unchanged. */
-    extra = {}) {
+    async dispatch(specs, requested, signal) {
         this.counter += 1;
         const dispatchId = `d${this.counter}`;
         const config = this.deps.getConfig();
@@ -131,7 +128,7 @@ export class TeamRuntime {
             confirmTools: config.confirmTools,
             ...(this.deps.humanQueue ? { humanQueue: this.deps.humanQueue } : {}),
             agentFactory: this.deps.agentFactory ?? defaultSubagentFactory,
-            ...(this.deps.resolveTier ? { resolveTier: this.deps.resolveTier } : {}),
+            ...(this.deps.review ? { review: this.deps.review } : {}),
             // Site two of two, and the omission is silent in the same way the policy
             // one above is: declaring it on `TeamRuntimeDeps` and forgetting this line
             // type-checks and forwards nothing, so every child would quietly run with
@@ -147,11 +144,7 @@ export class TeamRuntime {
         // show the child its brief twice.
         const makeHandle = (spec) => createSubagent(spec, subDeps, {
             onUpdate: (run) => this.publish(dispatchId, run),
-            // `tier` rides along so `App.tsx` can pick the RIGHT cost table for this
-            // event rather than always using the lead's (§3.6 / R-7). Taken from the
-            // SPEC, which the normalizer already downgraded when the tier was
-            // unavailable, so it names the model that actually billed.
-            onUsage: (label, usage) => this.emit({ type: 'usage', dispatchId, label, usage, tier: spec.tier }),
+            onUsage: (label, usage) => this.emit({ type: 'usage', dispatchId, label, usage }),
         });
         // ASSIGNMENT, not a declaration: a `const` here would shadow the `let` above
         // the bus, `canSend` would see the empty array forever, and every peer would
@@ -179,7 +172,15 @@ export class TeamRuntime {
         // so the override only bites because `task` listens to `ctx.signal` — and a
         // second, independent timer means a signal that never arrives still ends the
         // dispatch.
-        this.dispatchTimer = setTimeout(() => this.abortAll(), team.dispatchTimeoutMs);
+        //
+        // `0` MEANS NO CEILING (main-agent parity): the dispatch lasts as long as
+        // its slowest child and only an Esc ends it early. The lead's idle
+        // watchdog is paused for the whole dispatch either way, exactly as it is
+        // for the lead's own long turns.
+        this.dispatchTimer =
+            team.dispatchTimeoutMs > 0
+                ? setTimeout(() => this.abortAll(), team.dispatchTimeoutMs)
+                : null;
         const runCtx = {
             dispatchId,
             handles,
@@ -195,24 +196,13 @@ export class TeamRuntime {
         signal?.removeEventListener('abort', onAbort);
         for (const handle of handles)
             handle.unsubscribe();
-        // SUMMED PER TIER (fast-model-tier §3.4 / R-7). One total priced at the
-        // lead's table would over-report a Haiku child under a Sonnet lead by
-        // roughly an order of magnitude — and the whole justification for delegating
-        // to a cheaper model is a number in the report this feeds.
-        // `main` IS THE COMPLEMENT OF `fast`, not an equality test. `SubagentRun.tier`
-        // is populated by `createSubagent` from the spec, but a hand-built run in a
-        // test — or a run restored from a session file written before this field
-        // existed — has it `undefined`, and `=== 'main'` would silently drop that
-        // child's spend from the total. Under-reporting is the one failure this
-        // split exists to prevent, so the default direction has to be "counted".
-        const sumTier = (tier) => handles
-            .filter((h) => (tier === 'fast' ? h.run.tier === 'fast' : h.run.tier !== 'fast'))
-            .reduce((acc, h) => ({
+        // ONE TOTAL, AT THE LEAD'S TABLE. Every child runs the lead's own model
+        // (main-agent parity), so there is exactly one tier to sum and one price to
+        // sum it at; a split would be two answers to one question.
+        const usage = handles.reduce((acc, h) => ({
             inputTokens: acc.inputTokens + h.run.usage.inputTokens,
             outputTokens: acc.outputTokens + h.run.usage.outputTokens,
         }), { inputTokens: 0, outputTokens: 0 });
-        const fastUsage = sumTier('fast');
-        const ranFast = handles.some((h) => h.run.tier === 'fast');
         const outcome = {
             dispatchId,
             runs: handles.map((h) => ({ ...h.run, filesTouched: [...h.run.filesTouched] })),
@@ -221,11 +211,7 @@ export class TeamRuntime {
             endedAt: Date.now(),
             aborted: this.aborted,
             leadMail: bus.leadMail(),
-            usage: sumTier('main'),
-            // ABSENT when no fast child ran, which is what keeps a default session's
-            // outcome shape byte-identical to the pre-feature one.
-            ...(ranFast ? { fastUsage } : {}),
-            ...(extra.downgraded ? { downgraded: extra.downgraded } : {}),
+            usage,
         };
         this.live = [];
         this.bus = null;
@@ -262,14 +248,23 @@ export class TeamRuntime {
         for (let attempt = 0;; attempt += 1) {
             const handle = handles[index];
             const { run, agent } = handle;
+            // ABORTS GO THROUGH THE HANDLE (never `agent.abort()` directly): the
+            // handle sets the synchronous `abortRequested` flag the child's fast
+            // reviewer reads as its never-steer-into-a-requested-abort fact.
             run.phase = 'starting';
             run.startedAt = Date.now();
             this.publish(dispatchId, run);
+            // `subagentTimeoutMs: 0` MEANS NO CEILING (main-agent parity): no timer
+            // is armed and `timedOut` can never become true. A wedged child is still
+            // ended by its OWN idle watchdog, which is the exact ceiling the lead
+            // runs under.
             let timedOut = false;
-            const timer = setTimeout(() => {
-                timedOut = true;
-                agent.abort();
-            }, subagentTimeoutMs);
+            const timer = subagentTimeoutMs > 0
+                ? setTimeout(() => {
+                    timedOut = true;
+                    handle.abort();
+                }, subagentTimeoutMs)
+                : null;
             try {
                 await agent.prompt(handle.spec.prompt);
             }
@@ -281,7 +276,8 @@ export class TeamRuntime {
                 run.error = err instanceof Error ? err.message : String(err);
             }
             finally {
-                clearTimeout(timer);
+                if (timer)
+                    clearTimeout(timer);
             }
             // THE TWO ABORT EXCLUSIONS THAT MAKE THE PREDICATE SAFE. Every abort in
             // this system reaches the provider as an aborted fetch, and `core` marks
@@ -319,7 +315,7 @@ export class TeamRuntime {
         const retries = (handle.run.retries ?? 0) + 1;
         handle.unsubscribe();
         try {
-            handle.agent.abort();
+            handle.abort();
         }
         catch {
             // Already gone; this must not stop the retry.
@@ -346,7 +342,7 @@ export class TeamRuntime {
         if (this.aborted) {
             run.phase = 'aborted';
         }
-        else if (timedOut) {
+        else if (timedOut && subagentTimeoutMs > 0) {
             run.phase = 'failed';
             run.error = run.error ?? `subagent exceeded ${Math.round(subagentTimeoutMs / 1000)}s`;
         }
@@ -398,7 +394,7 @@ export class TeamRuntime {
         this.aborted = true;
         for (const handle of this.live) {
             try {
-                handle.agent.abort();
+                handle.abort();
             }
             catch {
                 // A child that is already gone must not stop the others being aborted.

package/dist/team/subagent.d.ts

@@ -11,12 +11,12 @@
  * 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';
@@ -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,11 @@ 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).
+     * 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.
      */
-    resolveTier?: (tier: FastTierName) => {
-        ref: ModelRef;
-        thinkingLevel: ThinkingLevel;
-        role?: ModelRole;
-    };
+    review?: ChildReviewProvider;
     /**
      * Build this child its own context manager
      * (context-auto-compaction-hardening §3.4.3 / W3).
@@ -134,6 +126,14 @@ export interface SubagentHandle {
     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;
     unsubscribe: () => void;
 }
 /**