@aragon-agent/cli 0.5.2 → 0.5.3

package/dist/team/types.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Runtime shapes for team mode (team-subagents §5.1 / §5.2).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope.
+ *
+ * `TeamEvent` is a CLI-LOCAL stream and must stay that way (D-10 / I-5).
+ * `packages/core` freezes its runtime export list (`public-api.test.ts`) and
+ * forbids host coupling (`no-host-coupling.test.ts`); adding a member to core's
+ * `AgentEvent` union would break the first and teach core about a host shape
+ * (`SubagentRun`) it has no business defining. The whole feature therefore
+ * changes ZERO files under `packages/core/` (AC-12).
+ */
+import type { TokenUsage } from '@aragon-agent/core';
+import type { ActivityArgs } from './activity.js';
+/** One normalized delegation request. Produced only by `normalizeSubagentSpecs`. */
+export interface SubagentSpec {
+    /** Slug, unique within the dispatch. Shown in the panel, the report and logs. */
+    label: string;
+    /** <= TEAM_LIMITS.descriptionChars. What this subagent is for. */
+    description: string;
+    /** <= TEAM_LIMITS.promptChars. Self-contained: the child sees no history. */
+    prompt: string;
+    /**
+     * Force the plan-mode gate on for this child regardless of session mode.
+     * TIGHTENING ONLY (D-13): there is no field anywhere that gives a child more
+     * permission than the session it was spawned from.
+     */
+    readOnly: boolean;
+}
+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;
+    phase: SubagentPhase;
+    startedAt?: number;
+    endedAt?: number;
+    turns: number;
+    toolCalls: number;
+    lastTool?: string;
+    usage: TokenUsage;
+    /**
+     * Paths seen going through `write_file` / `edit_file`, deduped and capped at
+     * `TEAM_LIMITS.filesTouchedMax`.
+     *
+     * BEST-EFFORT BY CONSTRUCTION: a child that writes through `bash` is invisible
+     * here. The conflict warning in the report says "review before trusting
+     * either" rather than claiming completeness, and that wording is load-bearing
+     * (R-2).
+     */
+    filesTouched: string[];
+    messagesSent: number;
+    /** The child's final assistant text. The only thing the lead sees of its work. */
+    summary?: string;
+    error?: string;
+    /** Hit `team.maxTurnsPerSubagent` and was stopped mid-work. */
+    truncated?: boolean;
+    /**
+     * Prose the child is writing right now, sanitized and clamped to
+     * `TEAM_LIMITS.activityChars`. Set only between tool calls; cleared on
+     * `turn_start`, on `tool_execution_start` and on `tool_execution_end` so it
+     * can never describe work the child has already finished.
+     *
+     * THE CLAMP HERE IS A STORAGE CEILING, NOT A COLUMN WIDTH (P0-1). The panel
+     * re-clamps to `activityBudget(cols)` at render. Do not "simplify" by clamping
+     * to the display budget here: this value has no terminal.
+     *
+     * NEVER LOGGED and never persisted: it is ephemeral by construction and a
+     * resumed session has no live dispatch.
+     */
+    activity?: string;
+    /**
+     * The five argument fields any of the nine known tools might want to show,
+     * picked at capture time by `pickActivityArgs` and elided to
+     * `TEAM_LIMITS.activityArgChars` each.
+     *
+     * A PICKED SUBSET, NOT `event.args` (P1-4). The run is shallow-copied into the
+     * live snapshot and into every `agent_update` event by `publish()`, and again
+     * into `DispatchOutcome.runs` by `dispatch()`, which `TeamCard` holds in the
+     * transcript for the session. Holding `event.args` would mean holding
+     * `write_file`'s `content` - a whole file, unbounded - along all of those
+     * paths, and would put a file body one `JSON.stringify` from a log.
+     *
+     * Stored unformatted because the PANEL owns the wide/narrow decision and it is
+     * the only object that knows the terminal width. A formatted string here would
+     * bake one terminal's width into a value the report and the headless writer
+     * also read.
+     *
+     * Cleared on `turn_start` and `tool_execution_end` (P1-5).
+     */
+    activityArgs?: ActivityArgs;
+    /** `team_wait` calls refused as unanswerable (F-3). Pulled from the bus on
+     *  `tool_execution_end`, the same way `messagesSent` is. */
+    blockedWaits?: number;
+    /** Cold-start retries spent (F-4). 0 or absent for the overwhelming majority
+     *  of runs; `1` at most under `TEAM_LIMITS.maxColdStartRetries`. */
+    retries?: number;
+    /**
+     * Whether the error that ended this attempt was transport-level and
+     * retryable, read structurally off `LLMError.retryable`.
+     *
+     * NOT RENDERED ANYWHERE. It exists so `TeamRuntime` can decide without
+     * re-parsing `run.error`, which is a human-facing sentence produced by
+     * `formatStreamError` and must never become a machine-readable contract.
+     */
+    retryable?: boolean;
+}
+/** One message on the team bus. */
+export interface TeamMessage {
+    from: string;
+    to: string;
+    subject: string;
+    body: string;
+    at: number;
+}
+/** Everything one dispatch produced. The sole input to `buildDispatchReport`. */
+export interface DispatchOutcome {
+    dispatchId: string;
+    runs: SubagentRun[];
+    /** Specs the model asked for, BEFORE the cap — the "n of m requested" line. */
+    requested: number;
+    startedAt: number;
+    endedAt: number;
+    aborted: boolean;
+    /** Messages addressed to `lead`; surfaced in their own report section. */
+    leadMail: TeamMessage[];
+    /** Summed across every child. Real spend; it must reach the status bar (§3.9). */
+    usage: TokenUsage;
+}
+/**
+ * What the UI renders: a cheap immutable projection, rebuilt per event.
+ *
+ * Held in `ViewState.team` and NEVER persisted — a resumed session has no live
+ * dispatch, and pretending otherwise is what P1-5 is about.
+ */
+export interface TeamSnapshot {
+    dispatchId: string;
+    active: boolean;
+    runs: SubagentRun[];
+    requested: number;
+    startedAt: number;
+    messageCount: number;
+    lastMessage?: TeamMessage;
+}
+/**
+ * The CLI-local event stream. `TeamRuntime` emits; `AgentController.subscribeTeam`
+ * forwards; `App`, `runHeadless` and `attachTeamEvents` consume.
+ */
+export type TeamEvent = {
+    type: 'dispatch_start';
+    dispatchId: string;
+    requested: number;
+    specs: SubagentSpec[];
+} | {
+    type: 'agent_update';
+    dispatchId: string;
+    run: SubagentRun;
+} | {
+    type: 'usage';
+    dispatchId: string;
+    label: string;
+    usage: TokenUsage;
+} | {
+    type: 'message';
+    dispatchId: string;
+    message: TeamMessage;
+} | {
+    type: 'dispatch_end';
+    dispatchId: string;
+    outcome: DispatchOutcome;
+};
+export type TeamEventListener = (event: TeamEvent) => void;

package/dist/team/types.js

@@ -0,0 +1,13 @@
+/**
+ * Runtime shapes for team mode (team-subagents §5.1 / §5.2).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope.
+ *
+ * `TeamEvent` is a CLI-LOCAL stream and must stay that way (D-10 / I-5).
+ * `packages/core` freezes its runtime export list (`public-api.test.ts`) and
+ * forbids host coupling (`no-host-coupling.test.ts`); adding a member to core's
+ * `AgentEvent` union would break the first and teach core about a host shape
+ * (`SubagentRun`) it has no business defining. The whole feature therefore
+ * changes ZERO files under `packages/core/` (AC-12).
+ */
+export {};

package/dist/tools/index.d.ts

@@ -13,6 +13,19 @@ import type { AgentMode } from '../agent/agent-mode.js';
 export interface ConfirmRequest {
     tool: string;
     summary: string;
+    /**
+     * The tool call's own abort signal, when the executor supplied one.
+     *
+     * IT IS HERE BECAUSE `withConfirmation` IS THE ONLY PLACE THAT HAS IT. A
+     * confirm implementation that has to abandon a pending dialog — the subagent
+     * queue in `team/human-queue.ts` is the one that does (team-subagents §3.11 /
+     * AC-16) — cannot reach `ctx` any other way, and without it an `Esc` during a
+     * dispatch pops a fresh dialog for every request still sitting in the FIFO.
+     *
+     * Ignored by the interactive and headless confirms, which are resolved by
+     * their own channel when a run ends.
+     */
+    signal?: AbortSignal;
 }
 export interface BuiltinToolsOptions {
     getCwd: () => string;
@@ -72,6 +85,39 @@ export interface BuiltinToolsOptions {
      * burns a turn.
      */
     planTools?: AgentTool[];
+    /**
+     * Team-mode tools, appended verbatim. The lead gets `[task]`; a subagent gets
+     * `[team_send, team_wait]`.
+     *
+     * THIS OPTION EXISTS BECAUSE A TEST FORBIDS THE ALTERNATIVE (D-15 / P0-1).
+     * `tools.test.ts::C7` asserts that `HOST_TOOL_NAMES` equals WHAT THIS FACTORY
+     * ACTUALLY PRODUCES, so the moment `task` joined `HOST_TOOL_NAMES` (I-7),
+     * appending it in `AgentController` after the factory returned would turn C7
+     * red — with a failure message about two lists of names that says nothing
+     * about team mode.
+     *
+     * ONE option serves both sides on purpose: the only two call sites are the
+     * lead's controller and `createSubagent`, and a second option would just be a
+     * second name for "extra tools this caller supplies".
+     *
+     * An empty array (the `--no-team` path) leaves the tool list byte-identical to
+     * the pre-team build — AC-11, provable by object identity exactly as
+     * `--no-skills` is.
+     */
+    teamTools?: AgentTool[];
+    /**
+     * Tool names that skip the CEILING wrapper only (never the plan gate, never
+     * confirmation).
+     *
+     * It exists for a subagent's two comm tools and for nothing else (§3.11).
+     * `team_send` / `team_wait` are not in the LEAD's registered tool list, so
+     * evaluating them against the lead's `allowed-tools` ceiling would refuse them
+     * and dead-end the channel — the same dead end `SKILL_TOOL_FLOOR` exists to
+     * prevent one level up. Widening this set to anything that can write to disk
+     * would turn delegation into a ceiling bypass, which is exactly what §3.11
+     * re-applies the lead's policy to children to avoid.
+     */
+    policyExempt?: ReadonlySet<string>;
 }
 /**
  * Tools the ceiling always permits (D-G6). The ONLY place that knows which of
@@ -88,7 +134,7 @@ export interface BuiltinToolsOptions {
  * is the whole of what this mechanism is worth, and saying so plainly beats
  * implying it covers more.
  */
-export declare const SKILL_TOOL_FLOOR: readonly ["read_file", "list_dir", "glob", "grep", "skill", "skill_find", "ask_user", "submit_plan"];
+export declare const SKILL_TOOL_FLOOR: readonly ["read_file", "list_dir", "glob", "grep", "skill", "skill_find", "ask_user", "submit_plan", "task"];
 /**
  * The five tools plan mode refuses: exactly the complement of `SKILL_TOOL_FLOOR`
  * within `HOST_TOOL_NAMES` — "the five that change something", the set this file
@@ -121,5 +167,5 @@ export declare const PLAN_MODE_BLOCKED_TOOLS: ReadonlySet<string>;
  * declaration MEANS, and that reading must not change with how the CLI was
  * started.
  */
-export declare const HOST_TOOL_NAMES: readonly ["read_file", "write_file", "edit_file", "list_dir", "glob", "grep", "bash", "skill", "skill_find", "skill_install", "skill_create", "ask_user", "submit_plan"];
+export declare const HOST_TOOL_NAMES: readonly ["read_file", "write_file", "edit_file", "list_dir", "glob", "grep", "bash", "skill", "skill_find", "skill_install", "skill_create", "ask_user", "submit_plan", "task"];
 export declare function createBuiltinTools(options: BuiltinToolsOptions): AgentTool[];

package/dist/tools/index.js

@@ -46,6 +46,12 @@ export const SKILL_TOOL_FLOOR = [
     // "read-only".)
     'ask_user',
     'submit_plan',
+    // `task` joins the floor rather than the blocked set (D-5), and the choice is
+    // forced to be conscious by the partition test below. It cannot itself mutate
+    // anything: every child mutation passes through this same wrapper stack one
+    // level down, with the child inheriting `agentMode` through the same closure.
+    // Blocking it would forfeit parallel research, which is plan mode's best use.
+    'task',
 ];
 /**
  * The five tools plan mode refuses: exactly the complement of `SKILL_TOOL_FLOOR`
@@ -99,6 +105,13 @@ export const HOST_TOOL_NAMES = [
     'skill_create',
     'ask_user',
     'submit_plan',
+    // `team_send` / `team_wait` are DELIBERATELY ABSENT (P2-5). This constant
+    // answers "can a skill's `allowed-tools` declaration ever take effect?", and
+    // those two are never registered on a lead — so a skill naming them genuinely
+    // IS unenforceable, and `aragon skills doctor` saying so is correct rather
+    // than a gap. They reach children through `policyExempt`, a different
+    // mechanism answering a different question.
+    'task',
 ];
 function summarize(toolName, params) {
     if (toolName === 'bash')
@@ -118,6 +131,11 @@ function withConfirmation(tool, confirm) {
             const approved = await confirm({
                 tool: tool.name,
                 summary: summarize(tool.name, params),
+                // Forwarded, not consumed, here: this wrapper still awaits the answer,
+                // because a confirm that resolved itself on abort would let the tool run
+                // unapproved. It is the confirm IMPLEMENTATION that decides what an
+                // abort means (see `ConfirmRequest.signal`).
+                ...(ctx.signal ? { signal: ctx.signal } : {}),
             });
             if (!approved)
                 return errorResult('Cancelled by user.');
@@ -209,6 +227,12 @@ export function createBuiltinTools(options) {
     if (options.planTools && options.planTools.length > 0) {
         tools = [...tools, ...options.planTools];
     }
+    // BEFORE both wrappers, so the lead's `task` is covered by the plan gate and
+    // the ceiling like everything else, and a child's comm tools are covered by
+    // everything except the ceiling (see `policyExempt`).
+    if (options.teamTools && options.teamTools.length > 0) {
+        tools = [...tools, ...options.teamTools];
+    }
     // No decision provider (`--no-skills`, or a caller that never enabled the
     // policy) means the ceiling adds nothing.
     //
@@ -223,7 +247,8 @@ export function createBuiltinTools(options) {
     // available ordering. The ceiling needs no I/O, so it goes before confirmation.
     if (options.toolPolicy) {
         const getDecision = options.toolPolicy;
-        tools = tools.map((t) => withToolPolicy(t, getDecision, options.onToolPolicyEvent));
+        const exempt = options.policyExempt;
+        tools = tools.map((t) => exempt?.has(t.name) ? t : withToolPolicy(t, getDecision, options.onToolPolicyEvent));
     }
     // TWO OPTIONS, TWO INDEPENDENT GUARDS, NO SHARED EXIT.
     //

package/dist/ui/App.js

@@ -10,8 +10,11 @@ import process from 'node:process';
 import { Box, Text, useApp, useInput, useStdout } from 'ink';
 import { initialViewState, reduceEvent, viewReducer, } from '../agent/reducer.js';
 import { mergeDeltas } from '../agent/coalesce.js';
-import { coerceMaxTokens, DEFAULT_TRANSCRIPT_WINDOW, PROMPT_HISTORY_CAP, } from '../config/schema.js';
+import { computeCost } from '../agent/usage.js';
+import { coerceMaxTokens, DEFAULT_TRANSCRIPT_WINDOW, } from '../config/schema.js';
 import { updatePersistedConfig } from '../config/store.js';
+import { appendPrompt, loadPromptHistory } from '../config/prompt-history.js';
+import { bumpSubmitCount, setMouseNoticeSeen } from '../config/ui-state.js';
 import { getLogger } from '../logging/logger.js';
 import { registerSecret } from '../logging/secret-registry.js';
 import { detectCapabilities } from './capabilities.js';
@@ -25,6 +28,7 @@ import { Transcript, TranscriptList } from './Transcript.js';
 import { PromptInput } from './PromptInput.js';
 import { Composer } from './Composer.js';
 import { StatusBar } from './StatusBar.js';
+import { TeamPanel } from './TeamPanel.js';
 import { ToastStack } from './ToastStack.js';
 import { AppShell } from './layout/AppShell.js';
 import { ScrollViewport } from './layout/ScrollViewport.js';
@@ -58,7 +62,10 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     const [confirmState, setConfirmState] = useState(null);
     /** The request the question / plan overlay is currently rendering. */
     const [humanRequest, setHumanRequest] = useState(null);
-    const [promptHistory, setPromptHistory] = useState(() => controller.getConfig().promptHistory ?? []);
+    // Seeded from the history file, not from `CliConfig`: the list is no longer
+    // part of the resolved config, so every other `loadConfig()` caller is spared
+    // reading it (config-state-separation D-4).
+    const [promptHistory, setPromptHistory] = useState(() => loadPromptHistory());
     // Scroll plumbing: intent goes down, one derived display number comes back.
     const [scrollIntent, setScrollIntent] = useState();
     /** One prompt-history step per wheel notch over the composer band (§4.7). */
@@ -194,6 +201,62 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             unsubscribe();
         };
     }, [controller, flushPending, cancelPendingHuman]);
+    // --- Team-mode event stream (team-subagents §5.2 / §3.9). --------------
+    //
+    // A SEPARATE SUBSCRIPTION, not a branch in the one above: `TeamEvent` is
+    // deliberately not a member of core's `AgentEvent` union (D-10 / I-5), so it
+    // cannot arrive through `controller.subscribe`.
+    //
+    // These actions are NOT routed through the streaming coalescer. That buffer
+    // exists to merge text/thinking deltas; `agent_update` is already coalesced at
+    // the source at 120 ms per child (§5.2), and pushing it through a second
+    // buffer would only delay the roster.
+    useEffect(() => {
+        const unsubscribeTeam = controller.subscribeTeam((event) => {
+            switch (event.type) {
+                case 'dispatch_start':
+                    dispatch({
+                        type: 'teamStart',
+                        dispatchId: event.dispatchId,
+                        requested: event.requested,
+                        specs: event.specs,
+                    });
+                    break;
+                case 'agent_update': {
+                    const snapshot = controller.getTeamSnapshot();
+                    if (snapshot)
+                        dispatch({ type: 'teamUpdate', snapshot });
+                    break;
+                }
+                case 'message': {
+                    const snapshot = controller.getTeamSnapshot();
+                    if (snapshot)
+                        dispatch({ type: 'teamUpdate', snapshot });
+                    break;
+                }
+                case 'usage':
+                    // Child spend is REAL SPEND and must reach the status bar, or the
+                    // session cost readout under-reports by however much the team consumed
+                    // — the single most misleading possible failure of this feature (R-5).
+                    dispatch({
+                        type: 'teamUsage',
+                        usage: event.usage,
+                        costDelta: computeCost(event.usage, controller.getModelInfo().cost),
+                    });
+                    break;
+                case 'dispatch_end':
+                    dispatch({ type: 'teamEnd', outcome: event.outcome });
+                    break;
+            }
+        });
+        return () => {
+            unsubscribeTeam();
+            // Nothing else disposes the runtime on an inline-mode exit or a crash
+            // that unmounts the tree, and an orphaned child holds the event loop open
+            // (R-15). `cli.tsx` calls this too; `dispose()` is idempotent.
+            controller.dispose();
+        };
+    }, [controller]);
     // --- Elapsed timer + tokens/sec baseline while running. ----------------
     useEffect(() => {
         if (state.status !== 'running') {
@@ -241,7 +304,9 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // the events must never be shown advice about a mode not in effect (§6.1).
     useStartupNotices(dispatch, {
         enabled: !!mouseSource,
-        onSeen: () => persistConfig({ mouseNoticeSeen: true }),
+        // `state.json`, not `config.json`: whether a one-shot notice has been shown
+        // is bookkeeping, and the comment on the old persisted key said so.
+        onSeen: () => setMouseNoticeSeen(true),
     });
     // --- Exit snapshot: the only way state reaches cli.tsx (§4.4). ----------
     useEffect(() => {
@@ -399,15 +464,21 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         refreshSkills: () => setSkillsNonce((n) => n + 1),
         applyAgentMode: applyMode,
     });
+    /**
+     * Submitting a prompt no longer touches `config.json` at all — it appends one
+     * line to the history file and bumps one counter in `state.json`.
+     *
+     * `setPromptHistory` IS NOT OPTIONAL, and deleting it is the single easiest
+     * mistake to make here: `appendPrompt` keeps its own module-level array, but
+     * the `history` prop the composer recalls from is THIS React state. Without
+     * this line `↑` still works after a restart (the file is correct) and fails
+     * only for prompts submitted in the current session.
+     */
     const recordPrompt = (text) => {
-        const next = [...promptHistory.filter((p) => p !== text), text].slice(-PROMPT_HISTORY_CAP);
-        setPromptHistory(next);
-        // The submit counter rides along with the history write rather than opening
-        // a second I/O path (§4.6). It is read back through `controller.getConfig()`
-        // and never enters React state — nothing re-renders on its account.
-        const nextCount = (controller.getConfig().submitCount ?? 0) + 1;
-        controller.setSubmitCount(nextCount);
-        persistConfig({ promptHistory: next, submitCount: nextCount });
+        setPromptHistory(appendPrompt(text));
+        // Read back through `controller.getConfig()` and never entering React
+        // state, exactly as before — nothing re-renders on the counter's account.
+        controller.setSubmitCount(bumpSubmitCount());
     };
     /** `repeat` folds a coalesced wheel burst; the keyboard always sends one. */
     const scrollBy = useCallback((kind, repeat = 1) => {
@@ -641,7 +712,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             return;
         }
         if (key.ctrl && (input === 'o' || input === 'O')) {
-            const last = [...stateRef.current.entries].reverse().find((e) => e.kind === 'tool');
+            // `team` joins `tool` here (team-subagents §6.3): a dispatch card collapses
+            // its per-agent summaries behind the same key, and `toggleExpand` is keyed
+            // on entry id so it needs no change.
+            const last = [...stateRef.current.entries]
+                .reverse()
+                .find((e) => e.kind === 'tool' || e.kind === 'team');
             if (last)
                 dispatch({ type: 'toggleExpand', id: last.id });
             else
@@ -724,5 +800,13 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // `overflow: hidden` clips it away (R-14 / M-14). Cap it against the viewport.
     const popupMaxRows = fullscreen ? Math.max(1, viewportBudget - 4) : undefined;
     const composer = fullscreen ? (_jsx(Composer, { isActive: overlay === null, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: rows >= HINT_MIN_ROWS, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, popupMaxRows: popupMaxRows, historyIntent: historyIntent, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) })) : (_jsx(Box, { marginTop: 1, children: _jsx(PromptInput, { isActive: overlay === null, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), agentMode: state.agentMode, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }) }));
-    return (_jsx(AppShell, { mode: mode, rows: rows, cols: cols, geometryRef: geometryRef, header: header, viewport: viewport, toast: _jsx(ToastStack, { toasts: state.toasts, theme: theme, mode: mode }), composer: composer, status: _jsx(StatusBar, { model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, contextTokens: state.contextTokens, contextWindow: modelInfo.contextWindow, contextWindowKnown: modelKnown, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode }) }));
+    return (_jsx(AppShell, { mode: mode, rows: rows, cols: cols, geometryRef: geometryRef, header: header, viewport: viewport, team: state.team ? (_jsx(TeamPanel, { snapshot: state.team, rows: rows, cols: cols, reducedMotion: reducedMotion, theme: theme, caps: caps })) : null, toast: _jsx(ToastStack, { toasts: state.toasts, theme: theme, mode: mode }), composer: composer, status: _jsx(StatusBar, { model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, contextTokens: state.contextTokens, contextWindow: modelInfo.contextWindow, contextWindowKnown: modelKnown, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ...(state.team
+                ? {
+                    teamActive: {
+                        running: state.team.runs.filter((r) => r.phase !== 'queued' && r.phase !== 'done' &&
+                            r.phase !== 'failed' && r.phase !== 'aborted').length,
+                        total: state.team.runs.length,
+                    },
+                }
+                : {}) }) }));
 }

package/dist/ui/StatusBar.d.ts

@@ -49,6 +49,27 @@ interface StatusBarProps {
     agentMode?: AgentMode;
     /** Non-null while a deferred `plan -> build` waits for `agent_end`. */
     pendingAgentMode?: AgentMode | null;
+    /**
+     * Live subagent counts (team-subagents §6.2), or absent when no dispatch is
+     * running — an ordinary session's bar is then unchanged.
+     *
+     * LEFT CLUSTER, and it degrades (D-20 / P2-1). The left cluster is
+     * `flexShrink={0}`, so every column it takes comes out of the context gauge
+     * and the cost readout opposite it; on an 80-column terminal the full
+     * `agents 3/5` visibly squeezes them, and the gauge is how a user notices they
+     * are about to run out of context. Below `TEAM_LIMITS.statusCompactCols` this
+     * therefore renders as `[3]` — the running count alone.
+     *
+     * This does NOT contradict the "no `cols >= N` breakpoint" rule above: that
+     * rule is written about `agentMode`, whose reason is that the mode must never
+     * be unreportable. The team counter has a second, fuller home in `TeamPanel`
+     * and a third in `TeamCard`; it is the one readout on this bar that can afford
+     * to degrade.
+     */
+    teamActive?: {
+        running: number;
+        total: number;
+    };
 }
 export declare function StatusBar(props: StatusBarProps): React.ReactElement;
 export {};

package/dist/ui/StatusBar.js

@@ -4,6 +4,7 @@ import { pickGlyphs } from './glyphs.js';
 import { formatCost, formatTokens, formatDuration } from '../agent/usage.js';
 import { buildGauge } from './gauge.js';
 import { MODE_LABEL } from '../agent/agent-mode.js';
+import { TEAM_LIMITS } from '../team/limits.js';
 /**
  * I-5 — DO NOT "CLEAN THIS UP". Ink short-circuits identical output at TWO
  * gates (`ink.js:132` and `log-update.js:13`), so a fixed frame whose React
@@ -23,7 +24,7 @@ function redrawChar(nonce) {
     return nonce % 2 === 0 ? ' ' : NBSP;
 }
 export function StatusBar(props) {
-    const { model, provider, usageTotal, contextTokens, contextWindow, contextWindowKnown, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, } = props;
+    const { model, provider, usageTotal, contextTokens, contextWindow, contextWindowKnown, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, } = props;
     const { stdout } = useStdout();
     const cols = stdout?.columns ?? 80;
     const running = status === 'running';
@@ -47,5 +48,7 @@ export function StatusBar(props) {
     // and "? hel" rather than truncating cleanly at one end. Pinning the left
     // cluster keeps the run status and model intact and makes the degradation
     // land in one predictable place.
-    _jsxs(Box, { flexDirection: "row", justifyContent: "space-between", flexShrink: 0, children: [_jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsxs(Text, { color: running ? theme.toolRunning : theme.toolDone, children: [redrawChar(redrawNonce), statusGlyph, " ", running ? 'running' : 'idle'] }), modeWord && (_jsxs(Text, { color: theme.accent, bold: true, children: ['  ', modeWord] })), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
+    _jsxs(Box, { flexDirection: "row", justifyContent: "space-between", flexShrink: 0, children: [_jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsxs(Text, { color: running ? theme.toolRunning : theme.toolDone, children: [redrawChar(redrawNonce), statusGlyph, " ", running ? 'running' : 'idle'] }), modeWord && (_jsxs(Text, { color: theme.accent, bold: true, children: ['  ', modeWord] })), teamActive && (_jsxs(Text, { color: theme.toolRunning, bold: true, children: ['  ', cols >= TEAM_LIMITS.statusCompactCols
+                                ? `agents ${teamActive.running}/${teamActive.total}`
+                                : `[${teamActive.running}]`] })), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
 }

package/dist/ui/TeamPanel.d.ts

@@ -0,0 +1,57 @@
+/**
+ * TeamPanel — the live subagent roster (team-subagents §6.1).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`; a literal here bypasses the
+ * capability probe and shows mojibake on a legacy console (`glyphs.ts` header).
+ *
+ * RENDERED ONLY WHILE A DISPATCH IS RUNNING (D-11). The requirement says "(dang
+ * you de shi hou)" — when there is one — and a permanent zero-row region would
+ * be furniture. `App` passes `null` the rest of the time and this component is
+ * not mounted at all, so a session that never delegates has zero rows and zero
+ * layout shift.
+ *
+ * IT MUST BE MOUNTED INSIDE `AppShell`'s MEASURED BOTTOM BOX (I-10). The wheel
+ * router reads the composer band boundary from `measureElement(bottomRef)`; a
+ * panel rendered outside it makes that boundary stale the moment a dispatch
+ * starts, and the wheel begins scrolling prompt history over the transcript.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { TermCapabilities } from './capabilities.js';
+import type { SubagentRun, TeamSnapshot } from '../team/types.js';
+export interface TeamPanelProps {
+    snapshot: TeamSnapshot;
+    /** Terminal rows, for the one-line collapse below `panelCollapseRows`. */
+    rows: number;
+    /**
+     * Terminal columns. REQUIRED, not optional (D-13): an optional width
+     * defaulting to narrow would silently produce the degraded form forever if a
+     * call site forgot it, where a required prop fails at compile time.
+     */
+    cols: number;
+    reducedMotion: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+    /** Injectable clock so the panel test does not depend on wall time. */
+    now?: number;
+}
+export declare function activityBudget(cols: number): number;
+/**
+ * The middle column: what this child is doing right now, in a few words.
+ *
+ * Two width policies, answering different questions. `wide` decides WHICH FACT
+ * to show - a whole path or its basename, a whole command line or its program
+ * name - mirroring `StatusBar`'s `statusCompactCols` degradation rather than
+ * inventing a second threshold. `activityBudget(cols)` decides HOW MUCH OF IT
+ * FITS, and it is a continuous function of width rather than a threshold,
+ * because the failure it prevents - a row wider than the terminal - is
+ * continuous.
+ *
+ * Exported for the same reason `buildSubagentTools` is: the width bound is the
+ * property this round has to keep, and asserting it through a rendered frame
+ * cannot distinguish "the arithmetic clamped it" from "Ink truncated it" - which
+ * is precisely the confusion that let v1's fixed-width column look fine at 100
+ * columns and break at 80.
+ */
+export declare function activityLine(run: SubagentRun, cols: number): string;
+export declare function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, now, }: TeamPanelProps): React.ReactElement;