@aragon-agent/cli 0.5.1 → 0.5.3

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

@@ -9,6 +9,8 @@ import type { AgentController } from '../agent/controller.js';
 import type { ConfirmRequest } from '../tools/index.js';
 import { type Overlay } 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';
 import type { HumanInputBridge } from '../tools/human-input.js';
 export interface ConfirmBridge {
     handler: ((req: ConfirmRequest) => Promise<boolean>) | null;
@@ -23,5 +25,11 @@ export interface AppProps {
     confirmBridge?: ConfirmBridge;
     /** The plan-mode human channel; absent in tests that do not exercise it. */
     humanInputBridge?: HumanInputBridge;
+    /** Wheel events, already stripped out of stdin. Absent whenever mouse support
+     *  is off: inline mode, `--no-mouse`, a non-TTY, or a filter that failed to
+     *  build (mouse-wheel-region-routing §4.2). */
+    mouseSource?: MouseSource;
+    /** Test-only seam (§8.2): frame geometry, bypassing `measureElement`. */
+    geometryOverride?: FrameGeometry;
 }
-export declare function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, }: AppProps): React.ReactElement;
+export declare function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, geometryOverride, }: AppProps): React.ReactElement;

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,12 +28,15 @@ 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';
 import { useTerminalSize } from './layout/useTerminalSize.js';
 import { frameHeight, MIN_FULLSCREEN_ROWS } from './layout/frame.js';
 import { HINT_MIN_ROWS, viewportRows as computeViewportRows } from './layout/budget.js';
+import { UNMEASURED_GEOMETRY } from './layout/regions.js';
+import { OVERLAY_PAGE, useWheelRouting } from './use-wheel-routing.js';
 import { installConsoleBridge } from './console-bridge.js';
 import { publishExitSnapshot } from './exit-snapshot.js';
 import { OverlayFrame } from './layout/OverlayFrame.js';
@@ -46,9 +52,7 @@ import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js'
 import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
 /** Merge pending delta actions ~33 ms and flush the coalescer buffer. */
 const COALESCE_MS = 33;
-/** Rows a PgUp/PgDn moves inside a controlled overlay. */
-const OVERLAY_PAGE = 8;
-export function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, }) {
+export function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, geometryOverride, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const fullscreen = mode === 'fullscreen';
@@ -58,9 +62,14 @@ 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). */
+    const [historyIntent, setHistoryIntent] = useState();
     const [pinToBottomNonce, setPinToBottomNonce] = useState(0);
     const [scrolledLines, setScrolledLines] = useState(0);
     // I-5 (§4.13): Ctrl+L cannot repaint by writing escapes — Ink dedupes
@@ -98,6 +107,8 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     /** Every outstanding `gate.request()`. Held in a ref, never in state: it is
      *  bookkeeping for promises, and re-rendering on it would be noise. */
     const pendingHuman = useRef(new Set());
+    /** Written by `AppShell`'s layout effect, read at wheel-event time (§4.5). */
+    const geometryRef = useRef(UNMEASURED_GEOMETRY);
     /**
      * THE SINGLE SETTLE PATH for a human request. Idempotent per entry, and it
      * clears the overlay as its last act.
@@ -190,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') {
@@ -233,7 +300,14 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             return undefined;
         return installConsoleBridge((level, text) => dispatch({ type: 'notice', level, text }));
     }, [fullscreen]);
-    useStartupNotices(dispatch);
+    // `enabled` is `mouseSource`, not `cfg.mouse`: a user whose terminal drops
+    // the events must never be shown advice about a mode not in effect (§6.1).
+    useStartupNotices(dispatch, {
+        enabled: !!mouseSource,
+        // `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(() => {
         publishExitSnapshot({
@@ -390,18 +464,25 @@ 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());
     };
-    const scrollBy = useCallback((kind) => {
-        setScrollIntent((prev) => ({ kind, nonce: (prev?.nonce ?? 0) + 1 }));
+    /** `repeat` folds a coalesced wheel burst; the keyboard always sends one. */
+    const scrollBy = useCallback((kind, repeat = 1) => {
+        setScrollIntent((prev) => ({ kind, nonce: (prev?.nonce ?? 0) + 1, repeat }));
     }, []);
     /**
      * Send a message to the agent, bypassing slash parsing.
@@ -500,11 +581,30 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         }
         resolveHuman({ kind: 'planDecision', decision: verdict.decision, feedback: verdict.feedback });
     };
+    // --- Mouse wheel region routing (§4.6). Table and coalescer live in the
+    // hook (D-13); only the wiring it cannot own stays here. Inline arrows are
+    // fine — the hook re-reads its options through a ref every render. The
+    // `Math.max(0, …)` mirrors the keyboard branch below, and for the same
+    // reason: `OverlayFrame` only ever reports a clamp DOWNWARD.
+    const { clearCoalescer } = useWheelRouting({
+        mouseSource,
+        geometryRef,
+        geometryOverride,
+        getOverlay: () => stateRef.current.overlay,
+        onScroll: scrollBy,
+        onOverlayScroll: (delta) => setOverlayScroll((n) => Math.max(0, n + delta)),
+        onHistoryStep: (dir) => setHistoryIntent((prev) => ({ dir, nonce: (prev?.nonce ?? 0) + 1 })),
+    });
     // A fresh overlay always opens at the top; carrying the previous overlay's
     // offset over would open Help mid-list for no reason the user can see.
+    //
+    // `clearCoalescer()` rides along here rather than adding a second subscriber
+    // to the same transition (§4.7 rule 2): an accumulated-but-unflushed
+    // transcript scroll must not survive an overlay opening.
     useEffect(() => {
         setOverlayScroll(0);
-    }, [state.overlay]);
+        clearCoalescer();
+    }, [state.overlay, clearCoalescer]);
     // --- Initial overlay / prompt (after handlers are defined). ------------
     useEffect(() => {
         if (initialOverlay)
@@ -612,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
@@ -666,6 +771,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             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;
+    // A MEASUREMENT MUST NEVER OUTLIVE THE FRAME IT DESCRIBED (P1-5): neither
+    // path below renders the full-screen `AppShell`, so nothing else would
+    // overwrite a stale `bottom`. See `UNMEASURED_GEOMETRY` for why there is no
+    // arithmetic fallback.
+    if (!fullscreen || rows < MIN_FULLSCREEN_ROWS)
+        geometryRef.current = UNMEASURED_GEOMETRY;
     // A resize can drop below the usable floor. Do NOT leave the alt-screen —
     // entering and leaving it on every drag is worse than a placeholder — and take
     // the height from `frameHeight()` like everything else, because this is the
@@ -683,11 +794,19 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // the header the moment the first message lands.
     const opener = empty ? (_jsx(SessionOpener, { variant: fullscreen ? pickOpenerVariant(viewportBudget, cols, caps) : 'none', version: version, cwd: controller.getCwd(), hasKey: hasKey, viewportRows: fullscreen ? viewportBudget : Number.POSITIVE_INFINITY, theme: theme, caps: caps })) : null;
     const density = cfg.density;
-    const viewport = fullscreen ? (overlayNode ? (_jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: overlayNode })) : (_jsxs(ScrollViewport, { intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps, windowSize: cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW })] }))) : (_jsxs(_Fragment, { children: [opener, _jsx(Transcript, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }), overlayNode] }));
+    const viewport = fullscreen ? (overlayNode ? (_jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: overlayNode })) : (_jsxs(ScrollViewport, { intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, showScrollIndicator: true, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps, windowSize: cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW })] }))) : (_jsxs(_Fragment, { children: [opener, _jsx(Transcript, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }), overlayNode] }));
     // The completion popup lives inside the bottom chrome and can add up to 9
     // rows; unbounded, it pushes the status bar past the frame height where
     // `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, 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, 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 }) }));
+    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, 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/Composer.d.ts

@@ -35,9 +35,14 @@ export interface ComposerProps {
     /** Mirror of the controller's effective mode; drives the chip and the border. */
     agentMode: AgentMode;
     popupMaxRows?: number;
+    /** Pure pass-through to `PromptInput` (mouse-wheel-region-routing §5.6). */
+    historyIntent?: {
+        dir: 'up' | 'down';
+        nonce: number;
+    };
     theme: Theme;
     caps: TermCapabilities;
     onSubmit: (text: string) => void;
     onHelp?: () => void;
 }
-export declare function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+export declare function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, historyIntent, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;

package/dist/ui/Composer.js

@@ -56,7 +56,7 @@ function hintText(running, submitCount, glyphs, mode) {
         '? help',
     ].join(dot);
 }
-export function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, theme, caps, onSubmit, onHelp, }) {
+export function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, historyIntent, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => setHasDraft(next), []);
     // Plan mode inserts ONE branch, above `draft` and below `running`. The
@@ -73,7 +73,7 @@ export function Composer({ isActive, running, history, commands, cwd, showHint,
                     : theme.idleBorder ?? theme.border;
     const glyphs = pickGlyphs(caps);
     const visible = showHint && hintsEnabled;
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { isActive: isActive, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange }), visible && (
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { isActive: isActive, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange, historyIntent: historyIntent }), visible && (
             // The chip rides the EXISTING hint row rather than adding one, so it
             // costs zero rows on a 24-row terminal.
             _jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsx(Text, { children: '  ' }), _jsx(ModeChip, { mode: agentMode, theme: theme, caps: caps }), _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: hintText(running, submitCount, glyphs, agentMode) })] }))] }));

package/dist/ui/PromptInput.d.ts

@@ -55,6 +55,20 @@ interface PromptInputProps {
     };
     /** Fires only when the draft flips empty ⇄ non-empty, for the border color. */
     onDraftChange?: (hasDraft: boolean) => void;
+    /**
+     * One prompt-history step, pushed by the wheel router when a notch lands on
+     * the composer band (mouse-wheel-region-routing §5.6). `nonce` is monotonic
+     * so two notches in the same direction are two steps.
+     *
+     * Applied through the SAME `verticalOrHistory` / popup-selection branches the
+     * keyboard uses, deliberately: it means the wheel and `↑`/`↓` cannot drift
+     * apart, and the "never clobber an in-progress draft" guard protects the
+     * wheel for free.
+     */
+    historyIntent?: {
+        dir: 'up' | 'down';
+        nonce: number;
+    };
 }
 /** Apply an edit intent as a pure buffer/cursor transform. */
 export declare function applyEdit(buffer: string, cursor: number, intent: EditIntent): {
@@ -84,5 +98,5 @@ export declare function fileTokenAt(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
-export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }: PromptInputProps): React.ReactElement;
+export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, historyIntent, }: PromptInputProps): React.ReactElement;
 export {};

package/dist/ui/PromptInput.js

@@ -127,7 +127,7 @@ function isControlSeq(input) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }) {
+export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, historyIntent, }) {
     const [buffer, setBuffer] = useState('');
     const [cursor, setCursor] = useState(0);
     const [historyIndex, setHistoryIndex] = useState(null);
@@ -261,6 +261,43 @@ export function PromptInput({ isActive, running, history, commands, cwd, theme,
                 recallDown();
         }
     };
+    // --- Wheel-driven history step (mouse-wheel-region-routing §5.6). ---------
+    // The applier closes over the buffer, the cursor and the popup state, so it
+    // is re-created on every render and reached through a ref: depending on it
+    // directly would re-fire the effect on every keystroke.
+    const applyHistoryIntent = useRef(() => { });
+    applyHistoryIntent.current = (dir) => {
+        // Mirrors the keyboard branch exactly — with the completion popup open,
+        // Up/Down move the selection rather than recalling history.
+        if (popupItems.length > 0) {
+            setSel(dir === 'up'
+                ? Math.max(0, clampedSel - 1)
+                : Math.min(popupItems.length - 1, clampedSel + 1));
+            return;
+        }
+        verticalOrHistory(dir);
+    };
+    const historyIntentRef = useRef(historyIntent);
+    historyIntentRef.current = historyIntent;
+    // I-9: seeded from the incoming nonce during the FIRST render, so a mount
+    // that inherits a nonce cannot replay it. This component really does remount
+    // — `App` returns the terminal-too-small placeholder before `AppShell` —
+    // so without the guard, shrinking the window mid-wheel and growing it back
+    // recalls a history entry with no gesture behind it.
+    const lastHistoryNonce = useRef(historyIntent?.nonce);
+    const historyNonce = historyIntent?.nonce ?? 0;
+    useEffect(() => {
+        const current = historyIntentRef.current;
+        if (!current || !isActive)
+            return;
+        if (current.nonce === lastHistoryNonce.current)
+            return;
+        lastHistoryNonce.current = current.nonce;
+        applyHistoryIntent.current(current.dir);
+        // Keyed on the nonce alone, same reasoning as `ScrollViewport`'s intent
+        // effect: `historyIntent` is a fresh object on every parent render.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [historyNonce]);
     // --- Input handling. -----------------------------------------------------
     useInput((input, key) => {
         // FIRST STATEMENT, BEFORE THE POPUP BRANCH, AND IT HAS TO STAY THERE.

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)] }))] })] }));
 }