@aragon-agent/cli 0.6.16 → 0.6.18

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,11 @@ 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]' : '';
+    // Same head-line position as `retried Nx`, for the same reason: the ONLY
+    // place the lead learns that a supervisor looked at this child (N times) or
+    // rebuilt it (team-overseer §3.7).
+    const overseen = run.interventions ? `, overseer ${run.interventions}` : '';
+    const replaced = run.replacements ? `, replaced ${run.replacements}x` : '';
     // `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,8 +129,8 @@ 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.turns} turns, ${run.toolCalls} tools${retried}${compacted}`,
+        `### ${run.label} "${run.description}"  ${statusBadge(run)}  ${elapsed(run)}, ` +
+            `${run.turns} turns, ${run.toolCalls} tools${retried}${compacted}${overseen}${replaced}`,
     ];
     if (run.filesTouched.length > 0)
         head.push(`files: ${run.filesTouched.join(', ')}`);
@@ -163,6 +142,23 @@ function buildSection(run) {
     const summary = (run.summary ?? '').trim();
     return { head, summary: summary.length > 0 ? summary : '(no summary)' };
 }
+/**
+ * The supervisor's ledger (team-overseer §3.7): one line per APPLIED decision,
+ * so the lead can see who was nudged or replaced, when, and why. Budgeted by
+ * the same `reportMaxBytes` ladder as everything else - it renders as a block,
+ * so trimming it means trimming the blocks, which the ladder already does.
+ */
+function buildOverseer(outcome) {
+    const list = outcome.interventions ?? [];
+    if (list.length === 0)
+        return [];
+    const lines = ['### Supervisor'];
+    for (const item of list) {
+        const at = Math.max(0, Math.round((item.at - outcome.startedAt) / 1000));
+        lines.push(`[${item.trigger} ${at}s] ${item.label}: ${item.action} - ${item.reason}`);
+    }
+    return lines;
+}
 function buildLeadMail(outcome) {
     if (outcome.leadMail.length === 0)
         return [];
@@ -188,6 +184,7 @@ export function buildDispatchReport(outcome, options = {}) {
     const header = buildHeader(outcome, options);
     const sections = outcome.runs.map(buildSection);
     const mail = buildLeadMail(outcome);
+    const overseer = buildOverseer(outcome);
     const summaries = sections.map((s) => truncateBytes(s.summary, TEAM_LIMITS.summaryMaxBytes));
     const trimmed = summaries.map((s, i) => s.length < sections[i].summary.length);
     const render = (bodies) => {
@@ -200,6 +197,8 @@ export function buildDispatchReport(outcome, options = {}) {
             }
             blocks.push(lines.join('\n'));
         });
+        if (overseer.length > 0)
+            blocks.push(overseer.join('\n'));
         if (mail.length > 0)
             blocks.push(mail.join('\n'));
         return blocks.join('\n\n');

package/dist/team/runtime.d.ts

@@ -1,6 +1,6 @@
 /**
  * TeamRuntime — dispatch scheduling, budgets, the `TeamEvent` stream, abort and
- * disposal (team-subagents §3.2 / §3.5 / §3.8).
+ * disposal (team-subagents §3.2 / §3.5 / §3.8; team-overseer §3.4).
  *
  * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope.
  *
@@ -16,6 +16,16 @@
  * worker loops, awaited with `Promise.allSettled`. No worker abstraction, no
  * queue class, no event-loop trickery — every path is observable from the event
  * stream.
+ *
+ * THE DISPATCH SUPERVISOR (team-overseer) — a time ceiling is an inspection
+ * trigger, not a death sentence. When a supervisor is live for the dispatch,
+ * two SOFT timers per child (wall clock and event silence) fire an inspection;
+ * the supervisor decides wait / nudge / replace / abandon; THIS module applies.
+ * Lifecycle changes are funnelled exclusively through `runOne`, the only place
+ * a child's `prompt()` is awaited (I-OV1): the supervisor may steer, flag and
+ * abort, but a replacement is built by the worker loop or it is built for
+ * nobody. Without a supervisor, every path below is byte for byte the
+ * pre-feature behaviour.
  */
 import type { ModelRole } from '../config/model-profiles.js';
 import type { ProviderRegistry, SkillRegistry, ToolPolicyDecision, ToolPolicyVerdict } from '@aragon-agent/core';
@@ -23,6 +33,7 @@ import type { AgentMode } from '../agent/agent-mode.js';
 import type { CliConfig } from '../config/schema.js';
 import type { ToolPermission } from '../exec/permission.js';
 import type { TeamHumanQueue } from './human-queue.js';
+import { type OverseerProvider } from './overseer.js';
 import { type SubagentAgentFactory, type SubagentDeps } from './subagent.js';
 import type { DispatchOutcome, SubagentSpec, TeamEventListener, TeamSnapshot } from './types.js';
 export interface TeamRuntimeDeps {
@@ -56,21 +67,28 @@ 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).
      *
      * Passed straight through to `SubagentDeps`; absent means children get none,
      * which is the pre-hardening behaviour exactly. `AgentController` supplies it
      * from `CompactionWiring.childFactory()`, and the closure returns `undefined`
-     * when compaction is unregistered or `compaction.subagents` is false - which is
-     * what lets `subagent.ts` spread nothing at all.
+     * when compaction is unregistered or `compaction.subagents` is false - which
+     * is what lets `subagent.ts` spread nothing at all.
      */
     contextManagerFor?: SubagentDeps['contextManagerFor'];
+    /**
+     * The dispatch supervisor (team-overseer). ABSENT means the session has no
+     * supervision, and every path below is the pre-feature behaviour exactly.
+     * `active()` is read once per dispatch AND once per inspection (inside
+     * `TeamOverseer`), so a mid-dispatch `/fast off` stops the next look.
+     */
+    overseer?: OverseerProvider;
 }
 export declare class TeamRuntime {
     private readonly deps;
@@ -94,6 +112,16 @@ export declare class TeamRuntime {
      * quietly not for the others.
      */
     private readonly pendingBackoffs;
+    /**
+     * The dispatch supervisor, LIVE for the current dispatch only (team-overseer).
+     * Null when the provider is absent/disabled/off, and reset to null at every
+     * dispatch end so nothing supervision-shaped leaks across dispatches.
+     */
+    private overseer;
+    /** The soft timers, same lifetime as `overseer`. */
+    private supervision;
+    /** Applied interventions for the in-flight dispatch's outcome. */
+    private interventions;
     constructor(deps: TeamRuntimeDeps);
     subscribe(listener: TeamEventListener): () => void;
     /**
@@ -104,28 +132,60 @@ 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;
     /**
      * Run one child to a terminal phase, replacing it once if its very first
-     * request died on a transport error before it did anything at all (F-4).
+     * request died on a transport error before it did anything at all (F-4), and
+     * replacing it when the SUPERVISOR decides to (team-overseer §3.4).
+     *
+     * ONE LOOP, ALL LIFECYCLE: the cold-start replacement, the supervisor's
+     * replace and the post-mortem replace all swap `handles[index]` and continue
+     * THIS loop, because the await below is the only place a child is driven and
+     * a handle swapped anywhere else would never be (I-OV1).
      */
     private runOne;
     /**
-     * Swap a cold-started child for a fresh one, carrying only what must survive.
+     * One post-mortem inspection, and possibly ONE replacement driven by a
+     * recursive `runOne` — the worker that called us has already moved on to the
+     * next index, so nobody else will drive the fresh child (I-OV1 holds here
+     * too, one frame deeper). Recursion depth is bounded by the replacement
+     * budget, which is 1.
+     */
+    private maybePostMortem;
+    /**
+     * Swap one child for a fresh one, carrying only what must survive.
      *
      * `this.live` IS `handles`, so the single assignment below also makes
      * `abortAll()` abort the NEW child and makes the outcome carry the new run.
      * Anyone tempted to "clean up" that aliasing into a defensive copy must update
      * both places.
+     *
+     * `verdict === null` is the COLD-START retry (F-4): identical spec, `retries`
+     * carried. A verdict is the SUPERVISOR's replace: an amended brief
+     * (`buildReplacementPrompt`), `replacements` carried, and the supervisor's
+     * budget spent HERE, at the moment the rebuild is real.
+     */
+    private replaceChild;
+    /**
+     * Whether a child's silence is a legitimate wait rather than a stall:
+     * `team_wait` (the comm tool already pauses the child's own watchdog for
+     * exactly this wait) or a confirmation queued on the one human slot.
+     */
+    private isBlocked;
+    /**
+     * One trigger handled: look, then apply. Fired from a supervision timer and
+     * therefore async-and-forgotten; nothing here may throw.
+     *
+     * QUIET (`decision === null` — provider gone, budget spent) CLEARS the
+     * child's timers: supervision that has nothing left to say should stop
+     * waking up, and the child's own hard ceilings take over.
      */
-    private replaceForRetry;
+    private inspectAndApply;
+    private applyDecision;
+    /** Record one applied decision on the outcome, the run and the event stream. */
+    private recordIntervention;
     /**
      * The final phase of an attempt, in a FIXED ORDER: aborted, then timed out,
      * then error, then no-summary, then done.