@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/ui/layout/todo-layout.d.ts

@@ -1,3 +1,4 @@
+import type { TodoSnapshot } from '../../todo/types.js';
 export interface TodoRailLayoutInput {
     cols: number;
     panelEnabled: boolean;
@@ -22,3 +23,40 @@ export interface TodoRailLayout {
  * never depends on menu occupancy or rail visibility, preventing feedback loops.
  */
 export declare function buildTodoRailLayout(input: TodoRailLayoutInput): TodoRailLayout;
+export interface AcceptanceChipInput {
+    snapshot: TodoSnapshot | null;
+    /** Rows the rail (in-band or full-screen) actually drew; 0 means it drew none. */
+    railRows: number;
+    width: number;
+}
+/**
+ * Does the acceptance count still need the status-bar chip
+ * (todo-acceptance-criteria §6.11)?
+ *
+ * HERE, NEXT TO `buildTodoRailLayout`, because it answers the same question from
+ * the same inputs: "what did the rail actually draw". Putting it in `App` - a
+ * 3,215-line registered oversize file - would give one fact a second owner, which
+ * is precisely what `scrollback/band.ts`'s "one number, one owner" rule exists to
+ * prevent (P1-8 / C-9).
+ *
+ * THE RULE IS ABOUT THE RAIL, NOT ABOUT THE SECTION: while the section is `visible`
+ * or `summary` the rail is already reporting the count, so a chip would repeat it in
+ * the same glance (RV-P2-4). Only two situations leave the count unreported - no rail
+ * at all, and the single `rows === 3 && footer` corner where the panel is up but the
+ * section could not be fitted.
+ */
+export declare function acceptanceChip(input: AcceptanceChipInput): {
+    checked: number;
+    total: number;
+    failed: number;
+} | null;
+/**
+ * Which rung the acceptance section reached in the rail, for `/perf`'s band line
+ * (§6.9.6).
+ *
+ * `n/a` means "this plan has no criteria", which is a different fact from `absent`
+ * ("the plan has criteria and the rail could not show them"). Both come from the
+ * same `buildPlanSections` call the rail rendered with, so the readout cannot
+ * disagree with the screen.
+ */
+export declare function acceptanceRung(input: AcceptanceChipInput): 'visible' | 'summary' | 'absent' | 'n/a';

package/dist/ui/layout/todo-layout.js

@@ -1,4 +1,6 @@
 import { TODO_LIMITS } from '../../todo/limits.js';
+import { derivePlanPhase } from '../../todo/acceptance.js';
+import { buildPlanSections } from '../../todo/plan-sections.js';
 import { todoRailWidth } from './rail.js';
 /** Allocate columns and rows from the same team/menu projections as the renderers.
  * Invalid geometry becomes zero, excess team/menu rows are clamped. Menu capacity
@@ -25,3 +27,76 @@ export function buildTodoRailLayout(input) {
 function nonNegativeInt(value) {
     return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
 }
+/**
+ * Does the acceptance count still need the status-bar chip
+ * (todo-acceptance-criteria §6.11)?
+ *
+ * HERE, NEXT TO `buildTodoRailLayout`, because it answers the same question from
+ * the same inputs: "what did the rail actually draw". Putting it in `App` - a
+ * 3,215-line registered oversize file - would give one fact a second owner, which
+ * is precisely what `scrollback/band.ts`'s "one number, one owner" rule exists to
+ * prevent (P1-8 / C-9).
+ *
+ * THE RULE IS ABOUT THE RAIL, NOT ABOUT THE SECTION: while the section is `visible`
+ * or `summary` the rail is already reporting the count, so a chip would repeat it in
+ * the same glance (RV-P2-4). Only two situations leave the count unreported - no rail
+ * at all, and the single `rows === 3 && footer` corner where the panel is up but the
+ * section could not be fitted.
+ */
+export function acceptanceChip(input) {
+    const acceptance = input.snapshot?.acceptance;
+    if (!acceptance || acceptance.total === 0)
+        return null;
+    const chip = {
+        checked: acceptance.checkedCount,
+        total: acceptance.total,
+        failed: acceptance.failedCount,
+    };
+    if (input.railRows <= 0)
+        return chip;
+    return acceptanceSectionOf(input) === 'absent' ? chip : null;
+}
+/**
+ * Which rung the acceptance section reached in the rail, for `/perf`'s band line
+ * (§6.9.6).
+ *
+ * `n/a` means "this plan has no criteria", which is a different fact from `absent`
+ * ("the plan has criteria and the rail could not show them"). Both come from the
+ * same `buildPlanSections` call the rail rendered with, so the readout cannot
+ * disagree with the screen.
+ */
+export function acceptanceRung(input) {
+    const acceptance = input.snapshot?.acceptance;
+    if (!acceptance || acceptance.total === 0)
+        return 'n/a';
+    // No rail drawn at all: the section is not on screen, and saying `absent` is the
+    // one honest answer for that.
+    if (input.railRows <= 0)
+        return 'absent';
+    return acceptanceSectionOf(input) ?? 'absent';
+}
+/**
+ * The section's reason for a given rail, or `null` when the plan has no criteria.
+ *
+ * `showGauge` is assumed TRUE. That is the conservative direction for the ROW BUDGET -
+ * it can only make the rail look shorter - and it cannot change the REASON at all: the
+ * compact rung (rows < 6, where the real gauge is always off) ignores `available`
+ * entirely, and the full rung spends the difference on item rows. So this readout can
+ * never disagree with the rail about `visible` / `summary` / `absent`, and the chip
+ * therefore never duplicates a count the rail is already showing (RV-P2-4).
+ */
+function acceptanceSectionOf(input) {
+    const snapshot = input.snapshot;
+    const acceptance = snapshot?.acceptance;
+    if (!snapshot || !acceptance || acceptance.total === 0)
+        return null;
+    const sections = buildPlanSections({
+        rows: input.railRows,
+        width: input.width,
+        phase: derivePlanPhase(snapshot.items, acceptance.items),
+        todoCount: snapshot.items.length,
+        acceptanceCount: acceptance.total,
+        showGauge: true,
+    });
+    return sections.acceptance?.reason ?? null;
+}

package/dist/ui/layout/virtual-window.js

@@ -38,6 +38,7 @@ import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
 import { expandTabs } from '../display-tab.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
+import { isLiveTeamCard } from '../team-status.js';
 export const VIRTUAL_LIMITS = {
     /**
      * Entries kept mounted on each side of the visible band.
@@ -95,7 +96,17 @@ export function entryRevision(entry) {
                 .map((r) => r.phase[0])
                 .join('')}.${entry.runs.reduce((acc, r) => acc + r.toolCalls, 0)}`;
         case 'todo':
-            return `d${entry.live ? 1 : 0}.${entry.doneCount}.${entry.total}.${entry.items.length}`;
+            // REVISION MUST COVER EVERY FIELD THAT CAN CHANGE THE HEIGHT (§6.10.1). A
+            // criterion going `pending` -> `failed` changes NONE of `items.length`,
+            // `doneCount` or `total`, yet it adds an evidence row; without
+            // `checkedCount` and `failedCount` here the height cache would keep the old
+            // measurement and the cache would be silently wrong - textbook form of "add a
+            // field, forget the revision".
+            return `d${entry.live ? 1 : 0}.${entry.doneCount}.${entry.total}.${entry.items.length}`
+                + `.a${entry.acceptance
+                    ? `${entry.acceptance.items.length}.${entry.acceptance.checkedCount}` +
+                        `.${entry.acceptance.failedCount}`
+                    : '-'}`;
         /**
          * The retry card is ONE ROW IN EVERY PHASE, so its revision carries the phase
          * and the counter but deliberately NOT the countdown: `resumeAt` changes the
@@ -315,9 +326,27 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
             return separation + 1 + shown + 1;
         }
         case 'team':
+            // A LIVE DISPATCH CARD IS NOT DRAWN AT ALL (tui-subagent-double-roster A-2):
+            // the roster is the only live subagent surface, so this entry owes the window
+            // ZERO rows. Estimating it at its real height while `EntryView` renders nothing
+            // would make `selectWindow` reserve four rows for a card that is not on screen -
+            // blank space at the bottom of every dispatch frame, and a window boundary that
+            // disagrees with what the printer measures.
+            if (isLiveTeamCard(entry))
+                return 0;
             return separation + 1 + entry.runs.length + (expanded ? entry.runs.length * 3 + 1 : 1);
-        case 'todo':
-            return separation + 1 + entry.items.length;
+        case 'todo': {
+            // THE ACCEPTANCE BLOCK'S ROWS, EXACTLY (§6.10.1): one title row plus one row
+            // per criterion plus one row per FAILED criterion's evidence. Exact because
+            // every one of those lines is `wrap="truncate"`; the moment one of them wraps,
+            // this stops being an equality and becomes an upper bound - and the failure
+            // mode is scroll drift, which nothing reports.
+            const acceptance = entry.acceptance;
+            const acceptanceRows = acceptance && acceptance.total > 0
+                ? 1 + acceptance.items.length + acceptance.failedCount
+                : 0;
+            return separation + 1 + entry.items.length + acceptanceRows;
+        }
         // ONE ROW, ALWAYS. The card is `wrap="truncate"` in every phase, so this is an
         // exact height rather than an upper bound.
         case 'retry':

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

@@ -0,0 +1,57 @@
+/**
+ * AgentsBoardOverlay — the read-only detail board behind `Ctrl+B` / `/agents`
+ * (tui-subagent-panel §4.4 / §6.3).
+ *
+ * READ-ONLY IS THE SAFETY BOUNDARY (§2.2). Nothing here nudges, kills or re-dispatches
+ * a child, and no new `TeamEvent` member was introduced to feed it: a board that can
+ * only read can never kill a healthy child, which is the whole reason this is a
+ * second surface rather than a control panel.
+ *
+ * ONE SCREEN, CONTROLLED MODE. `OverlayFrame`'s controlled form already owns paging,
+ * the position indicator and the narrow-terminal degradation, and `helpRows` /
+ * `projectQueueRows` are the precedent. A second pane would mean a second horizontal
+ * budget inside Ink for a benefit the board's 2-up field rows already deliver.
+ *
+ * IT DOES NOT GO BLANK WHEN THE DISPATCH ENDS (D-9). `state.team` becomes `null` the
+ * frame the dispatch settles, and a reader would lose the child they were reading
+ * about at the exact moment they wanted the post-mortem. The last live snapshot is
+ * therefore FROZEN (a copy, held in a ref) and keeps rendering with a
+ * `dispatch ended` row; a board opened AFTER the dispatch has ended builds from the
+ * transcript's settled `team` entry instead (`resolveBoardSource`), which is where the
+ * `result` section earns its place - the error is the one fact that is never stripped.
+ *
+ * NO `ink-spinner` HERE (D-13): `spinner-census.test.ts` pins the exact list of files
+ * that mount an animated spinner, and this is a reading surface, not an animation.
+ * The panel is where motion belongs.
+ *
+ * AND NO MOTION PROP (v2 implementation note, appended to the spec's
+ * "implementation findings"). Because nothing here animates, a motion flag would be a
+ * prop with no consumer - and worse, the same census counts how many times `App.tsx`
+ * hands the RAW motion flag to a child and asserts the count is EXACTLY ONE, so passing
+ * it from the board's branch would break a shipped guard rail for no gain.
+ *
+ * ASCII ONLY: every symbol comes through `glyphs`.
+ */
+import React from 'react';
+import type { Entry } from '../../agent/reducer.js';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { TeamSnapshot } from '../../team/types.js';
+export interface AgentsBoardOverlayProps {
+    /** The live snapshot; `null` once the dispatch has settled. */
+    team: TeamSnapshot | null;
+    /** The transcript, for the settled fallback (D-9 path 4). */
+    entries: readonly Entry[];
+    /** Overlay content width (`App`'s `viewCols`). */
+    cols: number;
+    maxRows: number;
+    scrollOffset: number;
+    onScrollClamp: (offset: number) => void;
+    isActive: boolean;
+    native: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+    /** Injectable clock, so the board's tests do not depend on wall time. */
+    now?: number;
+}
+export declare function AgentsBoardOverlay({ team, entries, cols, maxRows, scrollOffset, onScrollClamp, isActive, native, theme, caps, now, }: AgentsBoardOverlayProps): React.ReactElement;

package/dist/ui/overlays/AgentsBoardOverlay.js

@@ -0,0 +1,183 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * AgentsBoardOverlay — the read-only detail board behind `Ctrl+B` / `/agents`
+ * (tui-subagent-panel §4.4 / §6.3).
+ *
+ * READ-ONLY IS THE SAFETY BOUNDARY (§2.2). Nothing here nudges, kills or re-dispatches
+ * a child, and no new `TeamEvent` member was introduced to feed it: a board that can
+ * only read can never kill a healthy child, which is the whole reason this is a
+ * second surface rather than a control panel.
+ *
+ * ONE SCREEN, CONTROLLED MODE. `OverlayFrame`'s controlled form already owns paging,
+ * the position indicator and the narrow-terminal degradation, and `helpRows` /
+ * `projectQueueRows` are the precedent. A second pane would mean a second horizontal
+ * budget inside Ink for a benefit the board's 2-up field rows already deliver.
+ *
+ * IT DOES NOT GO BLANK WHEN THE DISPATCH ENDS (D-9). `state.team` becomes `null` the
+ * frame the dispatch settles, and a reader would lose the child they were reading
+ * about at the exact moment they wanted the post-mortem. The last live snapshot is
+ * therefore FROZEN (a copy, held in a ref) and keeps rendering with a
+ * `dispatch ended` row; a board opened AFTER the dispatch has ended builds from the
+ * transcript's settled `team` entry instead (`resolveBoardSource`), which is where the
+ * `result` section earns its place - the error is the one fact that is never stripped.
+ *
+ * NO `ink-spinner` HERE (D-13): `spinner-census.test.ts` pins the exact list of files
+ * that mount an animated spinner, and this is a reading surface, not an animation.
+ * The panel is where motion belongs.
+ *
+ * AND NO MOTION PROP (v2 implementation note, appended to the spec's
+ * "implementation findings"). Because nothing here animates, a motion flag would be a
+ * prop with no consumer - and worse, the same census counts how many times `App.tsx`
+ * hands the RAW motion flag to a child and asserts the count is EXACTLY ONE, so passing
+ * it from the board's branch would break a shipped guard rail for no gain.
+ *
+ * ASCII ONLY: every symbol comes through `glyphs`.
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { buildAgentBoardRows, resolveBoardSource, resolveSelection, } from '../layout/agents-board.js';
+/** `OverlayFrame`'s own breakpoint, mirrored so the chrome estimate cannot drift. */
+const FRAME_BORDERLESS_COLS = 48;
+/**
+ * Close a frozen live snapshot: the dispatch it described has ended.
+ *
+ * `durationMs` is derived from the LAST frame the snapshot was live, so the board's
+ * summary shows the dispatch's real total instead of a clock that keeps running against
+ * a dispatch nobody can see any more. When the snapshot never had a `startedAt` there is
+ * nothing to derive and the field stays absent - the LIVE-ONLY rule turns that into an
+ * empty clock cell rather than an invented number (§4.4.2).
+ */
+function settleFrozen(frozen) {
+    const { source, at } = frozen;
+    const total = source.startedAt === undefined ? undefined : Math.max(0, at - source.startedAt);
+    return {
+        ...source,
+        active: false,
+        ...(total !== undefined ? { durationMs: total } : {}),
+    };
+}
+/** Palette slot -> theme colour. One place, so a tone can never be spelled twice. */
+function toneColor(tone, theme) {
+    switch (tone) {
+        case 'accent':
+            return theme.accent;
+        case 'primary':
+            return theme.primary;
+        case 'muted':
+            return theme.muted;
+        case 'warn':
+            return theme.noticeWarn;
+        case 'error':
+            return theme.noticeError;
+        case 'done':
+            return theme.toolDone;
+        case 'hint':
+            return theme.hintFg;
+    }
+}
+export function AgentsBoardOverlay({ team, entries, cols, maxRows, scrollOffset, onScrollClamp, isActive, native, theme, caps, now, }) {
+    const glyphs = pickGlyphs(caps);
+    const at = now ?? Date.now();
+    const [selectedLabel, setSelectedLabel] = useState(null);
+    /**
+     * THE FROZEN SNAPSHOT (D-9), plus the clock reading it was frozen at.
+     *
+     * A ref rather than state on purpose: it is written from an effect that must not
+     * trigger a render of its own, and reading it during the render that FIRST sees
+     * `team === null` is what keeps the board from blinking empty for one frame. The
+     * timestamp is kept WITH the snapshot because a frozen live source still says
+     * `active: true` - it was live when it was copied - and a board that kept believing
+     * that would never show its `dispatch ended` row nor stop its clock.
+     */
+    const frozen = useRef(null);
+    const live = team === null ? null : resolveBoardSource({ team, entries });
+    useEffect(() => {
+        if (live !== null)
+            frozen.current = { source: live, at };
+    }, [live, at]);
+    // PRIORITY: live > frozen > the most recent settled entry (§4.4.5). The frozen copy
+    // only ever takes over on the frame the live snapshot disappears, and a NEW dispatch
+    // overwrites it on its own first frame, so the two paths cannot both be active.
+    //
+    // A FROZEN SOURCE IS SETTLED, and it is closed here rather than at the moment of
+    // copying: `active: false` is what draws `dispatch ended` (task AC-17), and taking
+    // `durationMs` from the freeze instant stops the clock at the dispatch's real end
+    // instead of letting it count up forever from a snapshot that no longer exists.
+    const frozenSource = frozen.current === null ? null : settleFrozen(frozen.current);
+    const source = live ?? frozenSource ?? resolveBoardSource({ team: null, entries });
+    const selected = source === null ? null : resolveSelection(source.runs, selectedLabel);
+    /**
+     * UP/DOWN MOVES THE CHILD CURSOR, and a change of child RESETS the scroll.
+     *
+     * `agents` deliberately does NOT join `App`'s row-scroll set (`help | plan | queue`):
+     * the same trade `settings` makes with its field cursor, where Up/Down is worth more
+     * as navigation than as a six-row scroll. `PgUp` / `PgDn` / the wheel still page the
+     * board through `App`'s `controlled` set, so no reading gesture is lost.
+     */
+    const move = useCallback((delta) => {
+        const runs = source?.runs ?? [];
+        if (runs.length === 0)
+            return;
+        const current = resolveSelection(runs, selectedLabel);
+        const index = current === null ? -1 : runs.findIndex((run) => run.label === current.label);
+        const next = runs[Math.min(runs.length - 1, Math.max(0, index + delta))];
+        if (next === undefined || next.label === current?.label)
+            return;
+        setSelectedLabel(next.label);
+        // The documented semantic of this port is "the offset should now be 0" (§6.3).
+        onScrollClamp(0);
+    }, [onScrollClamp, selectedLabel, source]);
+    useInput((_input, key) => {
+        if (!isActive)
+            return;
+        if (key.upArrow)
+            move(-1);
+        else if (key.downArrow)
+            move(1);
+    }, { isActive });
+    // THE FRAME'S CHROME IS NOT FREE (v2 implementation note). `cols` arrives as the
+    // overlay's FRAME width (`App`'s `viewCols`), and `OverlayFrame` spends 4 of those
+    // columns on its border plus `paddingX={1}` (2 in the narrow rail form, which drops
+    // the right border and the right padding). A board laid out against the frame width
+    // therefore has its LAST four columns eaten by Ink's truncation - which lands exactly
+    // on the right-anchored figures this board exists to align. `helpRows` gets away with
+    // it because its rows are prose; these are a table.
+    const contentCols = Math.max(1, cols - (cols >= FRAME_BORDERLESS_COLS ? 4 : 2));
+    const rows = source === null
+        ? [{
+                key: 'empty',
+                kind: 'hint',
+                text: 'No subagent dispatch yet.',
+                tone: 'muted',
+            }]
+        : buildAgentBoardRows({
+            source,
+            cols: contentCols,
+            now: at,
+            selectedLabel: selected?.label ?? null,
+            glyphs,
+            native,
+        });
+    // The `dispatch ended` banner is a ROW rather than a title swap: the title is the
+    // frame's own ("Agents"), and replacing it would hide which screen the reader is on.
+    const endedRow = source !== null && !source.active
+        ? [{
+                key: 'ended',
+                kind: 'hint',
+                text: `dispatch ended ${glyphs.midDot} Esc to close`,
+                tone: 'warn',
+            }]
+        : [];
+    const elements = [...endedRow, ...rows].map((row) => (_jsx(Text, { wrap: "truncate", color: toneColor(row.tone, theme), ...(row.kind === 'section' ? { bold: true } : {}), children: row.text }, row.key)));
+    // THE HINT SHRINKS WITH THE FRAME. `OverlayFrame` prints the hint as one unwrapped
+    // row, so a 41-column hint inside a 30-column frame makes the FRAME 41 wide - the
+    // board would overflow the terminal and take the overlay's border with it.
+    const hint = contentCols >= 60
+        ? `Esc close ${glyphs.midDot} Up/Down child ${glyphs.midDot} PgUp/PgDn scroll`
+        : contentCols >= 30
+            ? `Esc close ${glyphs.midDot} Up/Down child`
+            : 'Esc close';
+    return (_jsx(OverlayFrame, { title: "Agents", hint: hint, maxRows: maxRows, cols: cols, rows: elements, scrollOffset: scrollOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
+}

package/dist/ui/overlays/HelpOverlay.js

@@ -34,7 +34,12 @@ function allKeyRows(times) {
         // terminal (`showHint`) and `hints: false`. A key that only exists behind
         // either of them is a key the affected user never learns about, which is the
         // one-shot notice's failure repeated with a different switch.
-        ['Shift+Tab / Ctrl+P', 'Toggle plan mode (same as /plan)'],
+        // BOTH KEYS ARE SPELLED OUT, and `Ctrl+N` is written in FULL: `^N` is this
+        // product's word for transcript line offset (the header chip and the row below),
+        // so abbreviating the mode fallback would put two meanings of `^` on one screen
+        // (quick-prompt-library D-1 / P1-7).
+        ['Shift+Tab / Ctrl+N', 'Toggle plan mode (same as /plan)'],
+        ['Ctrl+P', 'Quick prompt library: manage, create, reorder, pick'],
         // The ladder clears a draft first (ctrl-c-clear-draft-exit):
         // with a draft x2 clears the input and x3 exits; an empty input
         // keeps the previous x2 exit.
@@ -46,7 +51,17 @@ function allKeyRows(times) {
         ['Ctrl+R', 'Redraw the frame'],
         ['Ctrl+T', 'Show/hide thinking (off by default)'],
         ['Ctrl+I', 'Build the project index (bundled skill; asks first; needs keyboard enhancement)'],
+        // THE KIT KEYS (agent-model-kits D-11 / D-15): `Ctrl+K` moved to the picker
+        // and `killToEnd` moved to `Alt+K`. BOTH rows are listed, because an existing
+        // user will press the old key by muscle memory and needs to find out where it
+        // went - and because `^K` is only advertised in the expanded header row.
+        ['Ctrl+K', 'Agent kits: pick a preset for this session (see /kit)'],
+        ['Alt+K', 'Delete from the cursor to the end of the line (was Ctrl+K)'],
         ['Ctrl+G', 'Expand/collapse status details; disabled while an overlay is open'],
+        // The board's key is listed HERE and in the team table below: the roster shows
+        // `ctrl+b` only on a terminal wide enough for the hint cell, and a key a user can
+        // only learn from a wide terminal is a key the rest never discover (AC-18).
+        ['Ctrl+B', 'Agents board: every subagent, its facts and its timeline (read-only)'],
         ['PgUp / PgDn', 'Scroll a page (transcript, or this overlay)'],
         ['Shift+Up / Shift+Down', 'Scroll the transcript a line (full-screen mode)'],
         ['Wheel', 'Scroll the transcript (or the open overlay)'],
@@ -85,6 +100,7 @@ const COMMANDS = [
     ['/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'],
     ['/fast [on|off|model|review]', 'Fast model tier: status, switch, model, review cadence'],
+    ['/kit [list|use <name>]', 'Agent kits: what is in effect, list them, use one for this session'],
     [
         '/todo [on|off|panel|follow|clear|continue]',
         'Todo planning: status, switches, the rail, follow-through',
@@ -105,6 +121,11 @@ const COMMANDS = [
     ['/branch', 'Same as Ctrl+L: branch into a new terminal'],
     ['/copy', 'Copy last answer; native completion confirmed, OSC 52 request unconfirmed'],
     ['/queue', 'Read every pending message in full; no replay or queue mutation'],
+    ['/prompts', 'Quick prompt library: pick one and fill the draft (Enter fills)'],
+    ['/agents', 'Open the subagent board: every child, its facts and its timeline'],
+    ['/prompts list | add | edit | rm', 'Manage the library; `add` opens the editor'],
+    ['/prompts move <n> <to> | sort',
+        'Reorder by hand, or rewrite the order by name/recent/favorite'],
     ['/mouse [on|off]', 'Release the mouse to your terminal, or take it back'],
     ['/terminal-setup', 'Show newline key bindings without changing terminal settings'],
     ['/exit', 'Exit'],
@@ -126,7 +147,7 @@ const PLAN_ROWS = [
     // this one is the reader whose `Shift+Tab` does nothing, and what they need is
     // the reason, not another synonym. Listing the key in both places instead just
     // says it twice and explains it nowhere.
-    ['Ctrl+P', 'The same toggle, for Windows consoles that deliver Shift+Tab as a plain Tab'],
+    ['Ctrl+N', 'The same toggle, for Windows consoles that deliver Shift+Tab as a plain Tab'],
     ['In PLAN mode', 'write_file, edit_file, bash, skill_install and skill_create are refused'],
     ['bash', 'Refused in full, including git status - use read_file / glob / grep'],
     ['ask_user', 'The agent asks 1-5 multiple-choice questions; Enter takes the recommendation'],
@@ -140,6 +161,7 @@ const TEAM_ROWS = [
     ['/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'],
+    ['Ctrl+B / /agents', 'The board: every child, its full facts, its 24-event timeline'],
 ];
 const FAST_ROWS = [
     ['/fast', 'Status: on/off, the model, the cadence, and this session\'s totals'],

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

@@ -0,0 +1,23 @@
+/**
+ * Settings > Kit pack > editor (agent-model-kits §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * FOUR ROWS AND TWO ACTIONS, and every slot is an explicit decision (D-8): the
+ * Main slot is required, the Fast slot is a two-state choice (`off` is a
+ * decision, not an omission), and the Subagent slot reuses the existing
+ * `Same as main` / `Fast tier model` vocabulary so the summary sentence the root
+ * page already prints (`Fast tier (off - falls back to main)`) needs no second
+ * wording. Nothing is written until the ROOT page's Save.
+ */
+import React from 'react';
+import type { ModelProfileState } from './model-profile-state.js';
+import type { KitAction, KitDraft } from './kit-settings-state.js';
+import { type ProfileFrameProps } from './ModelProfilePicker.js';
+interface KitEditorProps extends ProfileFrameProps {
+    draft: KitDraft;
+    state: ModelProfileState;
+    dispatch: React.Dispatch<KitAction>;
+}
+export declare function KitEditor(props: KitEditorProps): React.ReactElement;
+export {};

package/dist/ui/overlays/KitEditor.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Settings > Kit pack > editor (agent-model-kits §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * FOUR ROWS AND TWO ACTIONS, and every slot is an explicit decision (D-8): the
+ * Main slot is required, the Fast slot is a two-state choice (`off` is a
+ * decision, not an omission), and the Subagent slot reuses the existing
+ * `Same as main` / `Fast tier model` vocabulary so the summary sentence the root
+ * page already prints (`Fast tier (off - falls back to main)`) needs no second
+ * wording. Nothing is written until the ROOT page's Save.
+ */
+import { useState } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
+import { clipProfileText, useProfileScroll } from './ModelProfilePicker.js';
+const ROWS = ['name', 'main', 'subagent', 'fast', 'save', 'cancel'];
+function slotLabel(draft, state) {
+    const entries = state.draft.profiles?.entries ?? [];
+    const name = (id) => {
+        const entry = id ? entries.find((item) => item.id === id) : undefined;
+        // `Profile missing` rather than a blank: a kit can be pointed at a profile
+        // that was removed on disk, and the editor is where that gets fixed.
+        return entry ? `${entry.provider}:${entry.model}  (${entry.name})` : id ? 'Profile missing'
+            : '(not set)';
+    };
+    const subagent = draft.subagent.model === 'main' ? 'Same as main'
+        : draft.subagent.model === 'fast' ? 'Fast tier model'
+            : name(draft.subagent.modelProfileId);
+    return { main: name(draft.mainProfileId), fast: name(draft.fastProfileId),
+        subagent };
+}
+export function KitEditor(props) {
+    const glyphs = pickGlyphs(props.caps);
+    const { draft, dispatch } = props;
+    const [index, setIndex] = useState(0);
+    const row = ROWS[index];
+    const offset = useProfileScroll(props, index);
+    const labels = slotLabel(draft, props.state);
+    const filled = [draft.mainProfileId, draft.fastProfileId,
+        draft.subagent.model !== 'profile' || draft.subagent.modelProfileId]
+        .filter(Boolean).length;
+    function activate(target) {
+        if (target === 'main')
+            dispatch({ type: 'kit-slot', slot: 'main' });
+        if (target === 'fast')
+            dispatch({ type: 'kit-slot', slot: 'fast' });
+        if (target === 'subagent')
+            dispatch({ type: 'kit-slot', slot: 'subagent' });
+        if (target === 'save')
+            dispatch({ type: 'kit-save' });
+        if (target === 'cancel')
+            dispatch({ type: 'kit-cancel' });
+    }
+    useInput((input, key) => {
+        if (props.isActive === false)
+            return;
+        if (key.escape) {
+            dispatch({ type: 'kit-cancel' });
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            setIndex((index - 1 + ROWS.length) % ROWS.length);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            setIndex((index + 1) % ROWS.length);
+            return;
+        }
+        if (key.return) {
+            activate(row);
+            return;
+        }
+        if (row !== 'name' || key.ctrl || key.meta)
+            return;
+        // THE NAME IS THE ONLY TEXT FIELD, and control characters are stripped by the
+        // reducer rather than refused here - a pasted name with a newline should
+        // become a name, not an error the user cannot see.
+        const text = stripPasteFrames(stripEnterFrames(input));
+        if (key.backspace || key.delete) {
+            dispatch({ type: 'kit-name', value: [...draft.name].slice(0, -1).join('') });
+            return;
+        }
+        if (text)
+            dispatch({ type: 'kit-name', value: `${draft.name}${text}` });
+    });
+    const lines = [`Name          ${draft.name}`,
+        `Main profile  ${labels.main}`,
+        `Subagent      ${labels.subagent}`,
+        `Fast tier     ${draft.fastProfileId ? labels.fast : 'off (this kit turns it off)'}`,
+        `Save          (${filled} slots set)`, 'Cancel'];
+    const rows = lines.map((line, at) => (_jsx(Text, { wrap: "truncate", color: at === index ? props.theme.accent : props.theme.muted, children: `${at === index ? glyphs.caret : ' '} ${clipProfileText(line, props.cols - 8)}` }, at)));
+    if (draft.error) {
+        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.noticeError, children: clipProfileText(draft.error, props.cols - 8) }, "error"));
+    }
+    return _jsx(OverlayFrame, { ...props, title: draft.id ? 'Edit kit' : 'New kit', hint: "Enter choose | type to rename | Esc back", rows: rows, scrollOffset: offset });
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Settings > Kit pack: the manager page (agent-model-kits §4.5 / D-9).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * CRUD LIVES HERE AND NOWHERE ELSE: `New kit` and `e` open the editor, `d` asks
+ * a confirmation that NAMES the consequences, `s` runs exit A (three slots plus
+ * the persisted pointer, because a default that only moved a pointer would not
+ * be in effect at the next launch - RV-P0-3), and `Enter` applies a kit to the
+ * transaction draft. Nothing on this page writes the config file.
+ */
+import React from 'react';
+import { type ProfileFrameProps } from './ModelProfilePicker.js';
+import type { KitAction, KitManagerRow } from './kit-settings-state.js';
+interface KitManagerProps extends ProfileFrameProps {
+    rows: KitManagerRow[];
+    error?: string;
+    dispatch: React.Dispatch<KitAction>;
+    /** Leave the kit pages entirely: `Esc` here means "back to Settings". */
+    onBack: () => void;
+}
+export declare function KitManager(props: KitManagerProps): React.ReactElement;
+export {};