@aragon-agent/cli 0.6.21 → 0.6.23

package/dist/team/subagent.d.ts

@@ -135,6 +135,16 @@ export interface SubagentHooks {
      * so the phase read at fire time is current.
      */
     onActivity?: () => void;
+    /**
+     * THE TURN CAP AS AN INSPECTION TRIGGER (F-8 A'2). Called ONCE, at the turn
+     * that crossed `maxTurnsPerSubagent`, ONLY when the dispatch supervisor is
+     * live - the runtime wires this hook under the same gate as
+     * `overseerActive`, so its presence IS the supervised/legacy branch. The
+     * child is NOT stopped: the supervisor decides wait / nudge / replace /
+     * abandon through the same `inspectAndApply` path every other trigger
+     * uses, and a child it lets run carries no `truncated` flag.
+     */
+    onTurnCapReached?: (label: string) => void;
 }
 export interface SubagentHandle {
     spec: SubagentSpec;

package/dist/team/subagent.js

@@ -359,12 +359,26 @@ export function createSubagent(spec, deps, hooks) {
                 // 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();
+                    if (hooks.onTurnCapReached !== undefined) {
+                        // A'2, D-4 for the turn cap: SUPERVISED means the ceiling is
+                        // an inspection trigger, not a death sentence. ONE look at the
+                        // crossing turn (`===`), never a per-turn storm; the child
+                        // keeps working unless the supervisor decides replace or
+                        // abandon, and a child that keeps running carries NO
+                        // `truncated` flag - the report must not call it partial.
+                        if (run.turns === turnCap)
+                            hooks.onTurnCapReached(spec.label);
+                    }
+                    else {
+                        // LEGACY regime (no supervisor for this dispatch): the hard
+                        // stop, byte for byte what it always was.
+                        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;
             }

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

@@ -39,6 +39,13 @@ export interface TaskToolDeps {
     activeProvider: () => string;
     /** The lead's cost table, so the report header states real spend (R-5). */
     modelCost: () => ModelCost | undefined;
+    /**
+     * The FAST tier's cost table, so the report's supervisor spend line states
+     * real spend (subagent-overseer-v2 D-7 / R-P1-2). OPTIONAL and returning
+     * `undefined`: an unpriced fast model renders `pricing unknown`, never a
+     * fabricated `$0.00` - the C-11 / RV-4 rule.
+     */
+    fastModelCost?: () => ModelCost | undefined;
     /**
      * Run the dispatch with the LEAD's idle watchdog paused, `try/finally` inside.
      *

package/dist/team/task-tool.js

@@ -123,8 +123,10 @@ export function createTaskTool(deps) {
             //    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 } : {}),
             }));
         },
     };

package/dist/team/types.d.ts

@@ -159,6 +159,22 @@ export interface SubagentRun {
      * report reads "this row is the Nth body of the same brief".
      */
     replacements?: number;
+    /**
+     * The most recent supervisor decision applied to this child
+     * (subagent-overseer-v2 section 6). TRANSIENT, never persisted - the
+     * same rule as `activity` / `activityArgs`; a resumed session has no
+     * live dispatch.
+     *
+     * `at` is ABSOLUTE epoch ms, the same units as `startedAt` / `endedAt`
+     * (R-P2-3), so the panel renders `nudged 2m` with one subtraction and
+     * no second clock convention. `reasonHead` <= 60 chars, for the UI
+     * badge line only.
+     */
+    lastIntervention?: {
+        action: OverseerAction;
+        at: number;
+        reasonHead: string;
+    };
 }
 /** What the supervisor may do with one inspected child. */
 export type OverseerAction = 'wait' | 'nudge' | 'replace' | 'abandon';
@@ -184,8 +200,15 @@ export interface OverseerIntervention {
     at: number;
     action: OverseerAction;
     reason: string;
-    /** What the trigger was: event stall, wall-clock check, or post-mortem. */
-    trigger: 'silence' | 'clock' | 'postmortem';
+    /**
+     * What the trigger was: event stall, wall-clock check, the child's turn
+     * cap (F-8 A'2 - an inspection the supervisor then ruled on), post-mortem,
+     * or the supervisor going QUIET (subagent-overseer-v2 D-10) - the look
+     * budget ran out and supervision stopped waking this child. A VALUE OF
+     * THE UNION, never a reason prefix: a human-readable sentence is not a
+     * machine contract (the `run.error` rule).
+     */
+    trigger: 'silence' | 'clock' | 'turncap' | 'postmortem' | 'quiet';
 }
 /**
  * A terminal supervisor decision handed to the WORKER LOOP, which is the only
@@ -231,6 +254,25 @@ export interface DispatchOutcome {
      * total priced at the lead's table is the honest accounting.
      */
     usage: TokenUsage;
+    /**
+     * The supervisor's own fast-tier spend for this dispatch
+     * (subagent-overseer-v2 D-7). Absent when nothing supervised the
+     * dispatch; read straight off the provider at dispatch end so there is
+     * exactly one accounting of it.
+     */
+    overseerUsage?: TokenUsage;
+    /** Inspection calls made, including ones that failed softly. */
+    overseerCalls?: number;
+    /**
+     * EDGE-LATCHED, once per dispatch (D-10): the fast tier was missing at
+     * least one cadence tick and the children waited UNASSISTED - announced,
+     * never killed. The per-child wait events of a degraded tick
+     * deliberately do NOT enter `interventions`; this flag plus the tick
+     * count below are the report's aggregate note.
+     */
+    overseerDegraded?: boolean;
+    /** How many cadence ticks ran unassisted (the aggregate note's number). */
+    overseerDegradedTicks?: number;
 }
 /**
  * What the UI renders: a cheap immutable projection, rebuilt per event.

package/dist/ui/App.js

@@ -664,6 +664,20 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     const snap = controller.getTeamSnapshot();
                     if (snap)
                         dispatch({ type: 'teamUpdate', snapshot: snap });
+                    // G-4 / AC-5 (subagent-overseer-v2): a TERMINAL verdict is the
+                    // one decision the user must not discover from the final report
+                    // - it removes work they watched running. wait and nudge stay
+                    // panel-only so the transcript gains no per-tick noise.
+                    if (event.decision.action === 'replace' || event.decision.action === 'abandon') {
+                        const verb = event.decision.action === 'replace' ? 'replaced' : 'abandoned';
+                        const level = event.decision.action === 'replace' ? 'info' : 'warn';
+                        const reason = event.decision.reason.slice(0, 120);
+                        dispatch({
+                            type: 'notice',
+                            level,
+                            text: `team supervisor ${verb} ${event.label} - ${reason}`,
+                        });
+                    }
                     break;
                 }
                 case 'usage': {

package/dist/ui/TeamPanel.d.ts

@@ -57,4 +57,26 @@ export declare function activityBudget(cols: number): number;
  * columns and break at 80.
  */
 export declare function activityLine(run: SubagentRun, cols: number): string;
+/**
+ * The row's supervisor badge (subagent-overseer-v2 AC-5): what the supervisor
+ * last did to THIS child and how long ago, e.g. `nudged 2m03s`.
+ *
+ * `lastIntervention.at` is ABSOLUTE epoch ms (R-P2-3), the same units as
+ * `startedAt`, so this is one subtraction - no second clock convention.
+ */
+export declare function overseerBadge(run: SubagentRun, at: number): string;
+/**
+ * The activity column WITH the badge composed in (AC-5 / risk table): the
+ * badge rides the SAME `activityBudget(cols)` allocation the prose uses, so
+ * a row can never grow past its terminal; on a narrow terminal the badge
+ * degrades to the action word alone - the who-acted fact outranks the
+ * what-they-are-doing tail exactly when there is room for only one.
+ */
+export declare function activityWithBadge(run: SubagentRun, cols: number, at: number): string;
+/**
+ * The panel's one supervisor status line (AC-5): the most recent intervention
+ * across the roster, human-phrased. Empty when the supervisor has not acted
+ * yet - furniture that says nothing is worse than no line.
+ */
+export declare function supervisorStatusLine(runs: SubagentRun[], at: number): string;
 export declare function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, now, layout, }: TeamPanelProps): React.ReactElement | null;

package/dist/ui/TeamPanel.js

@@ -101,6 +101,69 @@ export function activityLine(run, cols) {
             return 'aborted';
     }
 }
+/** The past-tense word the supervisor badge and status line render. */
+function interventionWord(action) {
+    switch (action) {
+        case 'nudge':
+            return 'nudged';
+        case 'replace':
+            return 'replaced';
+        case 'abandon':
+            return 'abandoned';
+        default:
+            return 'waited';
+    }
+}
+/**
+ * The row's supervisor badge (subagent-overseer-v2 AC-5): what the supervisor
+ * last did to THIS child and how long ago, e.g. `nudged 2m03s`.
+ *
+ * `lastIntervention.at` is ABSOLUTE epoch ms (R-P2-3), the same units as
+ * `startedAt`, so this is one subtraction - no second clock convention.
+ */
+export function overseerBadge(run, at) {
+    const last = run.lastIntervention;
+    if (last === undefined)
+        return '';
+    return `${interventionWord(last.action)} ${formatDuration(Math.max(0, at - last.at))}`;
+}
+/**
+ * The activity column WITH the badge composed in (AC-5 / risk table): the
+ * badge rides the SAME `activityBudget(cols)` allocation the prose uses, so
+ * a row can never grow past its terminal; on a narrow terminal the badge
+ * degrades to the action word alone - the who-acted fact outranks the
+ * what-they-are-doing tail exactly when there is room for only one.
+ */
+export function activityWithBadge(run, cols, at) {
+    const last = run.lastIntervention;
+    if (last === undefined)
+        return activityLine(run, cols);
+    const badge = overseerBadge(run, at);
+    if (cols < TEAM_LIMITS.activityWideCols)
+        return interventionWord(last.action);
+    return sanitizeActivity(`${badge}; ${activityLine(run, cols)}`, activityBudget(cols));
+}
+/**
+ * The panel's one supervisor status line (AC-5): the most recent intervention
+ * across the roster, human-phrased. Empty when the supervisor has not acted
+ * yet - furniture that says nothing is worse than no line.
+ */
+export function supervisorStatusLine(runs, at) {
+    let label = '';
+    let latest;
+    for (const run of runs) {
+        const last = run.lastIntervention;
+        if (last !== undefined && (latest === undefined || last.at > latest.at)) {
+            latest = last;
+            label = run.label;
+        }
+    }
+    if (latest === undefined)
+        return '';
+    const ago = formatDuration(Math.max(0, at - latest.at));
+    const head = latest.reasonHead.length > 0 ? ` (${latest.reasonHead})` : '';
+    return `supervisor: ${interventionWord(latest.action)} ${label} ${ago} ago${head}`;
+}
 export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, now, layout, }) {
     const projection = layout ?? buildTeamPanelLayout({
         snapshot, terminalRows: rows, availableRows: Infinity,
@@ -130,8 +193,14 @@ export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, no
                 // `reducedMotion` and a non-Unicode terminal fall back to the same
                 // static marker, exactly as `AssistantEntry` and `ToolCard` already do.
                 const animate = isRunning(run) && !reducedMotion && caps.unicode;
-                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description.replace(/\s+/g, ' ') }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityLine(run, cols)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
-            }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject.replace(/\s+/g, ' ')] }))] }));
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description.replace(/\s+/g, ' ') }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityWithBadge(run, cols, at)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
+            }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), (() => {
+                // The panel's supervisor line (AC-5): one row, only when the
+                // supervisor has actually acted - the per-row badges above already
+                // carry the per-child facts.
+                const line = supervisorStatusLine(snapshot.runs, at);
+                return line ? (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', line] })) : null;
+            })(), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject.replace(/\s+/g, ' ')] }))] }));
 }
 function marker(run, glyphs) {
     if (run.phase === 'done')

package/dist/ui/layout/team-panel.js

@@ -12,7 +12,10 @@ export function buildTeamPanelLayout(input) {
     }
     const selection = selectPanelRows(input.snapshot.runs, TEAM_LIMITS.panelMaxRows);
     const natural = 1 + selection.visible.length + Number(selection.hiddenTotal > 0)
-        + Number(Boolean(input.snapshot.lastMessage));
+        + Number(Boolean(input.snapshot.lastMessage))
+        // The supervisor status line (subagent-overseer-v2 AC-5) occupies one
+        // row whenever any run carries an intervention badge.
+        + Number(input.snapshot.runs.some((run) => run.lastIntervention !== undefined));
     const collapsed = nonNegativeInt(input.terminalRows) < TEAM_LIMITS.panelCollapseRows
         || available - natural < TODO_LIMITS.panelMinRows;
     return { ...selection, collapsed, rowCount: collapsed ? 1 : natural };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.21",
+  "version": "0.6.23",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.33",
+    "@aragon-agent/core": "^0.2.35",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",