@aragon-agent/cli 0.5.2 → 0.5.4

package/dist/ui/TeamPanel.js

@@ -0,0 +1,134 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs } from './glyphs.js';
+import { formatDuration } from '../agent/usage.js';
+import { describeToolActivity, sanitizeActivity } from '../team/activity.js';
+import { TEAM_LIMITS } from '../team/limits.js';
+import { selectPanelRows } from '../team/panel-rows.js';
+function isRunning(run) {
+    return run.phase === 'starting' || run.phase === 'thinking' || run.phase === 'tool' ||
+        run.phase === 'waiting';
+}
+function isSettled(run) {
+    return run.phase === 'done' || run.phase === 'failed' || run.phase === 'aborted';
+}
+function statusColor(run, theme) {
+    if (run.phase === 'failed' || run.phase === 'aborted')
+        return theme.toolError;
+    if (run.phase === 'done')
+        return theme.toolDone;
+    if (isRunning(run))
+        return theme.toolRunning;
+    return theme.muted;
+}
+/**
+ * How many characters the activity column may spend at this width (P0-1).
+ *
+ * `TEAM_LIMITS.activityChars` is a STORAGE ceiling; a terminal has a COLUMN
+ * budget, and the two are not the same number. The row is
+ *
+ *     marker(3) + label(8) + description(flex) + 2 + activity + 2 + elapsed(~6)
+ *
+ * and the comment on the description cell below promises that activity and
+ * elapsed never lose characters, i.e. that `description` absorbs ALL width
+ * pressure. A 64-character prose tail plus `writing: ` is 73, which on an
+ * 80-column terminal needs 94 columns before `description` gets one. The promise
+ * cannot be kept by wishing; the column has to be sized from `cols`.
+ *
+ * `WIDE_CHAR_ALLOWANCE` is the concession to there being no display-width helper
+ * in production code: this budget is denominated in code units while the
+ * terminal is denominated in columns, and CJK and emoji occupy two columns per
+ * unit, so the budget is halved against the reserve rather than spent to the
+ * last cell. Erring small costs a few characters of prose; erring large costs
+ * the elapsed column.
+ */
+const ROW_RESERVED_COLS = 3 + 8 + 2 + 2 + 8 + 12; // marker, label, gaps, elapsed, min description
+const WIDE_CHAR_ALLOWANCE = 2;
+export function activityBudget(cols) {
+    const spare = Math.floor((cols - ROW_RESERVED_COLS) / WIDE_CHAR_ALLOWANCE);
+    return Math.max(TEAM_LIMITS.activityMinChars, Math.min(TEAM_LIMITS.activityChars, spare));
+}
+/**
+ * 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 function activityLine(run, cols) {
+    const wide = cols >= TEAM_LIMITS.activityWideCols;
+    const budget = activityBudget(cols);
+    switch (run.phase) {
+        case 'queued':
+            return 'queued';
+        case 'starting':
+            // The one row that legitimately restarts its clock, saying why (P2-4):
+            // F-2 ranks the running group by `startedAt` and a retry re-stamps it.
+            return run.retries ? 'starting (retry)' : 'starting';
+        case 'thinking':
+            // Clamped AT RENDER, against this terminal's budget. `run.activity` was
+            // clamped at STORE against `activityChars`; that is a ceiling, not a fit.
+            return run.activity ? `writing: ${sanitizeActivity(run.activity, budget)}` : 'thinking';
+        case 'tool':
+        case 'waiting':
+            return run.lastTool
+                ? sanitizeActivity(describeToolActivity(run.lastTool, run.activityArgs, wide), budget)
+                : run.phase === 'waiting'
+                    ? 'waiting for mail'
+                    : 'tool';
+        case 'done':
+            return `done  ${run.turns} turns`;
+        case 'failed':
+            return 'failed';
+        case 'aborted':
+            return 'aborted';
+    }
+}
+export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, now, }) {
+    const glyphs = pickGlyphs(caps);
+    const at = now ?? Date.now();
+    const running = snapshot.runs.filter(isRunning).length;
+    const done = snapshot.runs.filter(isSettled).length;
+    const elapsed = formatDuration(Math.max(0, at - snapshot.startedAt));
+    const header = (_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Text, { wrap: "truncate", color: theme.accent, bold: true, children: [glyphs.teamAgent, " team", '  ', _jsxs(Text, { color: theme.muted, children: [running, " running ", glyphs.midDot, " ", done, " done ", glyphs.midDot, " ", elapsed] })] }), snapshot.messageCount > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.teamMail, " ", snapshot.messageCount] }))] }));
+    // Below 20 rows the roster is more expensive than the transcript it displaces,
+    // so the panel degrades to the one line that still answers "is something
+    // running, and for how long" (§6.4).
+    if (rows < TEAM_LIMITS.panelCollapseRows) {
+        return _jsx(Box, { flexDirection: "column", flexShrink: 0, children: header });
+    }
+    // RANKED, not sliced by array index (F-2). The slot pool hands out indices in
+    // order, so `slice(0, 5)` showed the five children that finished FIRST and hid
+    // everything still working behind `+N more` - at exactly the fan-out widths
+    // the requirement permits.
+    const { visible, hiddenTotal, hiddenRunning } = selectPanelRows(snapshot.runs, TEAM_LIMITS.panelMaxRows);
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [header, visible.map((run) => {
+                const color = statusColor(run, theme);
+                // One spinner per RUNNING row, and the row cap is 5 precisely because
+                // five is the documented maximum number of simultaneous spinners. Both
+                // `reducedMotion` and a non-Unicode terminal fall back to the same
+                // static marker, exactly as `AssistantEntry` and `ToolCard` already do.
+                const animate = isRunning(run) && !reducedMotion && caps.unicode;
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityLine(run, cols)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
+            }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject] }))] }));
+}
+function marker(run, glyphs) {
+    if (run.phase === 'done')
+        return glyphs.toolDone;
+    if (run.phase === 'failed' || run.phase === 'aborted')
+        return glyphs.toolError;
+    if (run.phase === 'queued')
+        return glyphs.toolPending;
+    return glyphs.spinnerStill;
+}

package/dist/ui/Transcript.js

@@ -26,6 +26,7 @@ import { EntryFrame } from './entries/EntryFrame.js';
 import { UserEntry } from './entries/UserEntry.js';
 import { AssistantEntry } from './entries/AssistantEntry.js';
 import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
+import { TeamCard, teamCardColor } from './entries/TeamCard.js';
 /** Keep the last K entries in the live region so a mutating tail stays hot. */
 const LIVE_TAIL = 1;
 /**
@@ -47,6 +48,13 @@ export function computeSettledCount(entries, expandedToolIds) {
             break;
         if (e.kind === 'tool' && e.status !== 'done' && e.status !== 'error')
             break;
+        // A live dispatch is not settled: its `runs` are rewritten on every
+        // `teamUpdate`, and `<Static>` cannot un-print what it has already drawn.
+        // The boundary is held MONOTONIC above, which is also why a `team` entry
+        // that never settles would be re-rendered on every frame for the rest of the
+        // session — the failure `session/persist.ts` normalizes away on load (P1-5).
+        if (e.kind === 'team' && e.active)
+            break;
         count = i + 1;
     }
     return count;
@@ -81,6 +89,8 @@ function EntryView({ entry, prev, expanded, thinkingVisible, reducedMotion, dens
         }
         case 'tool':
             return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
+        case 'team':
+            return frame(glyphs.teamAgent, teamCardColor(entry.runs, entry.active, entry.aborted, theme), _jsx(TeamCard, { requested: entry.requested, runs: entry.runs, aborted: entry.aborted, durationMs: entry.durationMs, active: entry.active, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'notice':
             return frame(noticeSymbol(entry.level, theme), noticeColor(entry.level, theme), _jsx(Text, { color: noticeColor(entry.level, theme), children: entry.text }));
         default:

package/dist/ui/entries/TeamCard.d.ts

@@ -0,0 +1,31 @@
+/**
+ * TeamCard — the settled-dispatch transcript entry (team-subagents §6.3).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`.
+ *
+ * The panel is EPHEMERAL and this card is the HISTORY. It renders like a
+ * `ToolCard` — same `EntryFrame` supplied by `EntryView`, same left rail for the
+ * expanded body — so a dispatch reads as one more step in the transcript rather
+ * than a second kind of object.
+ *
+ * `Ctrl+O` expands it to the per-agent summaries, which is why `App.tsx`'s
+ * Ctrl+O finder had to widen from `kind === 'tool'` to `tool || team`.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { SubagentRun } from '../../team/types.js';
+export interface TeamCardProps {
+    requested: number;
+    runs: SubagentRun[];
+    aborted: boolean;
+    durationMs?: number;
+    active: boolean;
+    expanded?: boolean;
+    reducedMotion?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/** The card's aggregate colour: any failure dominates. */
+export declare function teamCardColor(runs: SubagentRun[], active: boolean, aborted: boolean, theme: Theme): string | undefined;
+export declare function TeamCard(props: TeamCardProps): React.ReactElement;

package/dist/ui/entries/TeamCard.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs } from '../glyphs.js';
+import { railBorderProps } from '../layout/Gutter.js';
+import { formatDuration } from '../../agent/usage.js';
+function isOk(run) {
+    return run.phase === 'done' && !run.error;
+}
+/** The card's aggregate colour: any failure dominates. */
+export function teamCardColor(runs, active, aborted, theme) {
+    if (active)
+        return theme.toolRunning;
+    if (aborted || runs.some((r) => !isOk(r)))
+        return theme.toolError;
+    return theme.toolDone;
+}
+export function TeamCard(props) {
+    const { requested, runs, aborted, durationMs, active, expanded, reducedMotion, theme, caps } = props;
+    const glyphs = pickGlyphs(caps);
+    const color = teamCardColor(runs, active, aborted, theme);
+    const ok = runs.filter(isOk).length;
+    const failed = runs.length - ok;
+    // A dispatch entry restored from `/resume` is settled and aborted but has no
+    // duration: nothing measured it, because the process it belonged to is gone.
+    // Saying so plainly beats rendering `0.0s (0 ok, 3 failed)`, which reads like
+    // a dispatch that ran and lost (§5.3 / P1-5).
+    const interrupted = !active && aborted && durationMs === undefined;
+    const settled = runs.filter((r) => r.phase === 'done' || r.phase === 'failed' || r.phase === 'aborted').length;
+    const headline = interrupted
+        ? 'interrupted (session resumed)'
+        : active
+            ? `${runs.length - settled} running`
+            : `${formatDuration(durationMs ?? 0)}  (${ok} ok, ${failed} failed)`;
+    const count = `${runs.length} ${runs.length === 1 ? 'subagent' : 'subagents'}`;
+    const dropped = requested > runs.length ? `  (${runs.length} of ${requested} requested)` : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "team" }), _jsxs(Text, { color: theme.muted, children: [' ', count, dropped, '  '] }), active && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " ", headline] })) : (_jsxs(Text, { color: color, children: [active ? `${glyphs.spinnerStill} ` : '', headline] }))] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [runs.map((run) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: isOk(run) ? theme.toolDone : theme.toolError, children: isOk(run) ? glyphs.toolDone : glyphs.toolError }), _jsxs(Text, { color: theme.primary, children: [" ", run.label.padEnd(8).slice(0, 8)] }), _jsxs(Text, { color: theme.muted, children: [' ', run.description, '  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? 0) - run.startedAt)) : '', `  ${run.turns} turns`, run.filesTouched.length > 0 ? `  ${run.filesTouched.length} files` : '', run.error ? `  ${run.error}` : ''] })] }, run.label))), expanded &&
+                        runs.map((run) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: theme.accent, children: [run.label, " ", glyphs.midDot, " ", run.description] }), _jsx(Text, { color: theme.muted, children: run.summary ?? '(no summary)' })] }, `s-${run.label}`))), !expanded && !active && runs.length > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", runs.length, " ", runs.length === 1 ? 'summary' : 'summaries', " (Ctrl+O)"] })), expanded && _jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" })] })] }));
+}

package/dist/ui/glyphs.d.ts

@@ -86,6 +86,16 @@ export interface Glyphs {
     scrollThumb: string;
     /** Redaction dot for `maskSecret` in the settings screen (§4.1 tier B). */
     maskDot: string;
+    /**
+     * Team mode (team-subagents §6.1). The rail marker for a dispatch card and
+     * the prefix on the panel's incoming-message preview.
+     *
+     * They live HERE rather than in `TeamPanel` / `TeamCard` for the reason this
+     * file's header gives: a literal in a component bypasses `pickGlyphs` entirely
+     * and shows mojibake on a legacy console, whatever the capability probe said.
+     */
+    teamAgent: string;
+    teamMail: string;
     /**
      * Ink `borderStyle` name for every boxed region (composer, completion popup,
      * overlay frame).

package/dist/ui/glyphs.js

@@ -59,6 +59,8 @@ const UNICODE_GLYPHS = {
     scrollThumb: '█',
     maskDot: '•',
     boxStyle: 'round',
+    teamAgent: '◆',
+    teamMail: '✉',
     tool: {
         read_file: '▤',
         write_file: '✎',
@@ -69,6 +71,7 @@ const UNICODE_GLYPHS = {
         list_dir: '▤',
         ask_user: '?',
         submit_plan: '◈',
+        task: '◆',
     },
     toolDefault: '•',
 };
@@ -113,6 +116,8 @@ const ASCII_GLYPHS = {
     scrollThumb: '#',
     maskDot: '*',
     boxStyle: 'classic',
+    teamAgent: '*',
+    teamMail: '@',
     tool: {
         read_file: '=',
         write_file: '+',
@@ -123,6 +128,7 @@ const ASCII_GLYPHS = {
         list_dir: '=',
         ask_user: '?',
         submit_plan: '#',
+        task: '*',
     },
     toolDefault: '*',
 };

package/dist/ui/layout/AppShell.d.ts

@@ -18,6 +18,16 @@ export interface AppShellProps {
     cols: number;
     header: React.ReactNode;
     viewport: React.ReactNode;
+    /**
+     * The live subagent roster (team-subagents §6.1), or nothing.
+     *
+     * IT RENDERS INSIDE `bottomRef` IN THE FULL-SCREEN BRANCH, and it has to
+     * (I-10): `geometryRef.current.bottom` is MEASURED from that box, and the
+     * wheel router uses it to decide whether a notch belongs to the transcript or
+     * to prompt history. A panel rendered above the measured box would make the
+     * composer band boundary stale the instant a dispatch started.
+     */
+    team?: React.ReactNode;
     toast: React.ReactNode;
     composer: React.ReactNode;
     status: React.ReactNode;
@@ -30,4 +40,4 @@ export interface AppShellProps {
      */
     geometryRef?: React.MutableRefObject<FrameGeometry>;
 }
-export declare function AppShell({ mode, rows, cols, header, viewport, toast, composer, status, geometryRef, }: AppShellProps): React.ReactElement;
+export declare function AppShell({ mode, rows, cols, header, viewport, team, toast, composer, status, geometryRef, }: AppShellProps): React.ReactElement;

package/dist/ui/layout/AppShell.js

@@ -14,7 +14,7 @@ import { useLayoutEffect, useRef } from 'react';
 import { Box, measureElement } from 'ink';
 import { frameHeight } from './frame.js';
 import { UNMEASURED_GEOMETRY } from './regions.js';
-export function AppShell({ mode, rows, cols, header, viewport, toast, composer, status, geometryRef, }) {
+export function AppShell({ mode, rows, cols, header, viewport, team, toast, composer, status, geometryRef, }) {
     const bottomRef = useRef(null);
     // DECLARED ABOVE THE INLINE EARLY RETURN, and it has to stay there: React
     // keys hooks by call order, and a hook that only runs in one mode changes
@@ -38,7 +38,7 @@ export function AppShell({ mode, rows, cols, header, viewport, toast, composer,
         };
     });
     if (mode === 'inline') {
-        return (_jsxs(Box, { flexDirection: "column", children: [header, viewport, toast, composer, status] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [header, viewport, team, toast, composer, status] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexShrink: 0, children: header }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: viewport }), _jsxs(Box, { ref: bottomRef, flexDirection: "column", flexShrink: 0, children: [toast, composer, status] })] }));
+    return (_jsxs(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexShrink: 0, children: header }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: viewport }), _jsxs(Box, { ref: bottomRef, flexDirection: "column", flexShrink: 0, children: [team, toast, composer, status] })] }));
 }

package/dist/ui/overlays/HelpOverlay.js

@@ -25,6 +25,8 @@ const COMMANDS = [
     ['/plan [on|off|status]', 'Toggle plan mode (same as Shift+Tab)'],
     ['/theme <name>', 'auto | warm | cool | light'],
     ['/thinking <level>', 'Set thinking level'],
+    ['/max-tokens [n|auto]', 'Output token cap; no argument reports the effective one'],
+    ['/team [on|off|max n]', 'Team subagents: status, switch, fan-out width'],
     ['/tools', 'List active tools'],
     ['/clear', 'Clear the visible transcript'],
     ['/reset', 'New conversation'],
@@ -53,6 +55,14 @@ const PLAN_ROWS = [
     ['submit_plan', 'The agent submits a plan: a approve, r revise, Esc dismiss'],
     ['--plan / --no-plan', 'Start a session in a given mode (also ARAGON_PLAN=1)'],
 ];
+const TEAM_ROWS = [
+    ['task', 'The tool the agent uses to run 2-5 subagents in parallel'],
+    ['/team', 'Status: on/off, max subagents, and the live roster'],
+    ['/team on | off', 'Switch team mode for this session (and save it)'],
+    ['/team max <n>', 'Fan-out width, 1-10 (5 by default)'],
+    ['--team / --no-team', 'Start a session with team mode on or off (also ARAGON_TEAM=0)'],
+    ['team_send / team_wait', 'How subagents message each other; 6 each, one every 15s'],
+];
 /** Build the overlay's rows. Exported so `app.test.tsx` can count them. */
 export function helpRows(theme, caps) {
     const glyphs = pickGlyphs(caps);
@@ -68,6 +78,9 @@ export function helpRows(theme, caps) {
     rows.push(section('Plan mode'));
     for (const [c, d] of PLAN_ROWS)
         rows.push(pair(c, d));
+    rows.push(section('Team subagents'));
+    for (const [c, d] of TEAM_ROWS)
+        rows.push(pair(c, d));
     rows.push(section('Skills'));
     for (const [c, d] of SKILL_ROWS)
         rows.push(pair(c, d));

package/dist/ui/overlays/SettingsScreen.d.ts

@@ -8,7 +8,7 @@
  * otherwise.
  */
 import React from 'react';
-import type { ThinkingLevel } from '@aragon-agent/core';
+import { type ThinkingLevel } from '@aragon-agent/core';
 import { type LogLevelName } from '../../logging/levels.js';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
@@ -40,5 +40,16 @@ interface SettingsScreenProps {
     caps: TermCapabilities;
     onSave: (values: SettingsValues) => void;
 }
+/**
+ * The cap this setting will ACTUALLY produce against the selected model.
+ *
+ * Exported for the tests, and computed on every render rather than in an effect:
+ * `resolveOutputTokens` is pure, allocation-light and does no I/O — the ceiling
+ * lookup is a `Map.get` plus at most seven regex tests.
+ *
+ * Without this row the settings screen can only show what the user typed, and
+ * "I set 64000 but answers still stop early" has no answer anywhere in the UI.
+ */
+export declare function effectiveCapLine(values: Pick<SettingsValues, 'provider' | 'model' | 'maxTokens'>): string;
 export declare function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onSave, }: SettingsScreenProps): React.ReactElement;
 export {};

package/dist/ui/overlays/SettingsScreen.js

@@ -10,7 +10,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { useState } from 'react';
 import { Text, useInput } from 'ink';
-import { ADAPTER_PROVIDERS, THINKING_LEVELS, maskSecret } from '../../config/schema.js';
+import { DEFAULT_MAX_OUTPUT_TOKENS, resolveOutputTokens, } from '@aragon-agent/core';
+import { ADAPTER_PROVIDERS, THINKING_LEVELS, maskSecret, parseMaxTokensInput, } from '../../config/schema.js';
 import { LOG_LEVEL_NAMES } from '../../logging/levels.js';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
@@ -23,6 +24,34 @@ const FIELDS = [
     { key: 'apiKey', label: 'API key', kind: 'secret' },
     { key: 'logLevel', label: 'Log level', kind: 'enum', options: LOG_LEVEL_NAMES },
 ];
+/**
+ * The cap this setting will ACTUALLY produce against the selected model.
+ *
+ * Exported for the tests, and computed on every render rather than in an effect:
+ * `resolveOutputTokens` is pure, allocation-light and does no I/O — the ceiling
+ * lookup is a `Map.get` plus at most seven regex tests.
+ *
+ * Without this row the settings screen can only show what the user typed, and
+ * "I set 64000 but answers still stop early" has no answer anywhere in the UI.
+ */
+export function effectiveCapLine(values) {
+    const parsed = parseMaxTokensInput(values.maxTokens);
+    if (parsed.kind === 'invalid')
+        return 'Effective: -  (not a number; use a value or "auto")';
+    const requested = parsed.kind === 'value' ? parsed.value : undefined;
+    const resolution = resolveOutputTokens({
+        providerId: values.provider,
+        modelId: values.model,
+        ...(requested !== undefined ? { requested } : {}),
+    });
+    if (resolution.clampedBy === 'ceiling') {
+        const ambition = requested ?? DEFAULT_MAX_OUTPUT_TOKENS;
+        return `Effective: ${resolution.value}  (clamped from ${ambition} by the ${values.model} ceiling)`;
+    }
+    if (requested === undefined)
+        return `Effective: ${resolution.value}  (auto)`;
+    return `Effective: ${resolution.value}`;
+}
 export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onSave, }) {
     const [values, setValues] = useState(initial);
     const [index, setIndex] = useState(0);
@@ -99,6 +128,10 @@ export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset,
         }
         if (f.kind === 'enum')
             return raw;
+        // An empty cap field is AUTO, not "unset". `(none)` would read as a missing
+        // setting, which is the one thing this field can never be.
+        if (f.key === 'maxTokens' && raw.length === 0)
+            return 'auto';
         return raw.length > 0 ? raw : selected ? '(type to set)' : '(none)';
     };
     // One element per row, each `wrap="truncate"` — the contract for OverlayFrame's
@@ -108,6 +141,10 @@ export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset,
         const selected = i === index;
         return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: selected ? theme.accent : theme.muted, children: selected ? `${glyphs.caret} ` : '  ' }), _jsx(Text, { color: selected ? theme.assistant : theme.muted, children: (f.key === 'apiKey' ? `API key (${values.provider})` : f.label).padEnd(18) }), _jsx(Text, { color: selected ? theme.primary : theme.muted, children: displayValue(f, selected) }), f.kind === 'enum' && selected && (_jsxs(Text, { color: theme.muted, children: [' (', glyphs.arrowLeft, "/", glyphs.arrowRight, ')'] }))] }, f.key));
     });
+    // One element, `wrap="truncate"`, pushed like every other row — OverlayFrame's
+    // controlled mode slices by ELEMENT, so a row that wraps desynchronises the
+    // position indicator.
+    rows.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: effectiveCapLine(values) }, "__effective"));
     rows.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: "Enter saves. Keys persist to the config file (0600)." }, "__save"));
     return (_jsx(OverlayFrame, { title: "Settings", hint: `${glyphs.arrowUp}${glyphs.arrowDown} field ${glyphs.midDot} ${glyphs.arrowLeft}${glyphs.arrowRight} change ${glyphs.midDot} Enter save ${glyphs.midDot} Esc close`, maxRows: maxRows, cols: cols, rows: rows, scrollOffset: scrollOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
 }

package/dist/ui/transcript-text.js

@@ -64,6 +64,26 @@ function renderEntry(entry, glyphs) {
             const duration = entry.durationMs === undefined ? '' : ` (${entry.durationMs}ms)`;
             return [`${TOOL_INDENT}${glyph} ${entry.label || entry.name}${args ? ` ${args}` : ''}${duration}`];
         }
+        case 'team': {
+            // Same rows as `TeamCard`, without colour (team-subagents §6.3). A
+            // dispatch is often the most expensive thing in a session, so leaving it
+            // out of the plain-text replay would make the exported transcript
+            // unaccountable for most of its own cost.
+            const ok = entry.runs.filter((r) => r.phase === 'done' && !r.error).length;
+            const failed = entry.runs.length - ok;
+            const head = entry.active || (entry.aborted && entry.durationMs === undefined)
+                ? 'interrupted'
+                : `${entry.durationMs ?? 0}ms (${ok} ok, ${failed} failed)`;
+            const lines = [
+                `${TOOL_INDENT}team ${entry.runs.length} subagents ${head}`,
+                ...entry.runs.map((run) => {
+                    const glyph = run.phase === 'done' && !run.error ? glyphs.toolDone : glyphs.toolError;
+                    const detail = run.error ? ` ${run.error}` : '';
+                    return `${TOOL_INDENT}${CONTINUATION_INDENT}${glyph} ${run.label} ${run.description}${detail}`;
+                }),
+            ];
+            return lines;
+        }
         case 'notice': {
             const glyph = entry.level === 'error'
                 ? glyphs.error

package/dist/ui/use-startup-notices.d.ts

@@ -19,7 +19,7 @@ export interface MouseNoticeOptions {
      * must never be given advice about a mode that is not running.
      */
     enabled: boolean;
-    /** Persist `mouseNoticeSeen`. Called once, after the notice is dispatched. */
+    /** Record that it was shown (`state.json`). Called once, after dispatch. */
     onSeen: () => void;
 }
 export declare function useStartupNotices(dispatch: (action: ViewAction) => void, mouseNotice?: MouseNoticeOptions): void;

package/dist/ui/use-startup-notices.js

@@ -13,6 +13,7 @@
  */
 import { useEffect, useRef } from 'react';
 import { readConfigFile } from '../config/store.js';
+import { getMouseNoticeSeen } from '../config/ui-state.js';
 import { getLogger } from '../logging/logger.js';
 /**
  * The §6.1 notice (mouse-wheel-region-routing). Shown at most once, ever.
@@ -55,7 +56,7 @@ export function useStartupNotices(dispatch, mouseNotice) {
     useEffect(() => {
         if (!mouseEnabled || mouseNoticeShown.current)
             return;
-        if (readConfigFile().config?.mouseNoticeSeen)
+        if (getMouseNoticeSeen())
             return;
         mouseNoticeShown.current = true;
         dispatch({ type: 'notice', level: 'info', text: MOUSE_SELECTION_NOTICE });

package/package.json

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