@aragon-agent/cli 0.5.2 → 0.5.4

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.d.ts

@@ -7,7 +7,7 @@
 import React from 'react';
 import type { AgentController } from '../agent/controller.js';
 import type { ConfirmRequest } from '../tools/index.js';
-import { type Overlay } from '../agent/reducer.js';
+import { type Overlay, type ToastLevel } from '../agent/reducer.js';
 import { type RenderMode } from './layout/frame.js';
 import { type FrameGeometry } from './layout/regions.js';
 import type { MouseSource } from '../input/stdin-mouse-filter.js';
@@ -15,6 +15,27 @@ import type { HumanInputBridge } from '../tools/human-input.js';
 export interface ConfirmBridge {
     handler: ((req: ConfirmRequest) => Promise<boolean>) | null;
 }
+/** What the settings screen's `Max tokens` field resolved to. */
+export interface SettingsMaxTokens {
+    /** Pushed into the live controller. `undefined` is AUTO. */
+    applied: number | undefined;
+    /** Written to the config file, or `'skip'` to leave the stored value alone. */
+    persist: number | null | 'skip';
+    /** Replaces the generic "Settings saved." acknowledgement when present. */
+    toast?: [ToastLevel, string];
+}
+/**
+ * Decide what the `Max tokens` field means, WITHOUT letting a bad value in it
+ * discard the rest of the form.
+ *
+ * The three outcomes are genuinely different and must stay distinguishable:
+ * `auto` is a setting, a clamped number is a setting the user should be told
+ * about, and nonsense is not a setting at all — it keeps the previous value and
+ * says so, rather than silently resolving to a default the user never chose.
+ *
+ * Exported for the tests; there is no other caller.
+ */
+export declare function resolveSettingsMaxTokens(raw: string, previous: number | undefined): SettingsMaxTokens;
 export interface AppProps {
     controller: AgentController;
     version: string;

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 { parseMaxTokensInput, 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';
@@ -46,6 +50,41 @@ import { CommandRegistry, runSlashInput } from '../commands/registry.js';
 import { registerBuiltinCommands } from '../commands/builtins.js';
 import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js';
 import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
+/**
+ * Decide what the `Max tokens` field means, WITHOUT letting a bad value in it
+ * discard the rest of the form.
+ *
+ * The three outcomes are genuinely different and must stay distinguishable:
+ * `auto` is a setting, a clamped number is a setting the user should be told
+ * about, and nonsense is not a setting at all — it keeps the previous value and
+ * says so, rather than silently resolving to a default the user never chose.
+ *
+ * Exported for the tests; there is no other caller.
+ */
+export function resolveSettingsMaxTokens(raw, previous) {
+    const parsed = parseMaxTokensInput(raw);
+    if (parsed.kind === 'auto') {
+        return {
+            applied: undefined,
+            persist: null,
+            toast: ['info', 'Max tokens: auto (per-model ceiling).'],
+        };
+    }
+    if (parsed.kind === 'value') {
+        return {
+            applied: parsed.value,
+            persist: parsed.value,
+            ...(parsed.clamped
+                ? { toast: ['warn', `Max tokens clamped to ${parsed.value}.`] }
+                : {}),
+        };
+    }
+    return {
+        applied: previous,
+        persist: 'skip',
+        toast: ['warn', 'Max tokens must be a number or "auto".'],
+    };
+}
 /** Merge pending delta actions ~33 ms and flush the coalescer buffer. */
 const COALESCE_MS = 33;
 export function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, geometryOverride, }) {
@@ -58,7 +97,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 +236,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 +339,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 +499,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) => {
@@ -447,10 +553,13 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         submitMessage(raw.startsWith('//') ? raw.slice(1) : raw);
     };
     const handleSettingsSave = (values) => {
-        const maxTokens = coerceMaxTokens(values.maxTokens);
+        // An unusable cap must NOT discard the rest of the form: the same Enter
+        // press is often carrying a freshly pasted API key, and losing that to a
+        // typo in an unrelated field is the worst outcome available here.
+        const cap = resolveSettingsMaxTokens(values.maxTokens, controller.getConfig().maxTokens);
         controller.setModel(values.provider, values.model, values.baseUrl || undefined);
         controller.setThinkingLevel(values.thinkingLevel);
-        controller.setMaxTokens(maxTokens);
+        controller.setMaxTokens(cap.applied);
         const key = values.apiKey.trim();
         if (key.length > 0) {
             // Registration site 4 (§4.4.3), and the one that matters most: this is how
@@ -465,7 +574,9 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             model: values.model,
             baseUrl: values.baseUrl.trim() ? values.baseUrl.trim() : null,
             thinkingLevel: values.thinkingLevel,
-            maxTokens: maxTokens ?? null,
+            // Omitted entirely when the field was unusable, so the previous value
+            // survives instead of being overwritten with a guess.
+            ...(cap.persist !== 'skip' ? { maxTokens: cap.persist } : {}),
         };
         if (key.length > 0)
             patch.apiKeys = { [values.provider]: key };
@@ -476,7 +587,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         persistConfig(patch);
         getLogger().reconfigure({ ...controller.getConfig().log, level: values.logLevel });
         dispatch({ type: 'setOverlay', overlay: null });
-        toast('success', 'Settings saved.');
+        toast(cap.toast?.[0] ?? 'success', cap.toast?.[1] ?? 'Settings saved.');
     };
     const handleModelSelect = (provider, model) => {
         controller.setModel(provider, model);
@@ -641,7 +752,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
@@ -691,7 +807,9 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             model: cfg.model,
             baseUrl: cfg.baseUrl ?? '',
             thinkingLevel: cfg.thinkingLevel,
-            maxTokens: cfg.maxTokens ? String(cfg.maxTokens) : '',
+            // `auto`, not an empty string: an empty field reads as "unset", which
+            // is indistinguishable from AUTO and is not a state this can be in.
+            maxTokens: cfg.maxTokens ? String(cfg.maxTokens) : 'auto',
             apiKey: '',
             logLevel: cfg.log.level,
         }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onSave: handleSettingsSave })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { state: confirmState, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { questions: humanRequest.questions, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }) })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { plan: humanRequest.plan, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;
@@ -724,5 +842,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;