@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/ui/App.js

@@ -16,13 +16,13 @@ import { computeCost } from '../agent/usage.js';
 import { parseMaxTokensInput, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from '../config/schema.js';
 import { updatePersistedConfig } from '../config/store.js';
 import { appendPrompt, loadPromptHistory } from '../config/prompt-history.js';
-import { bumpSubmitCount, setMouseNoticeVersion, setScrollModeNoticeVersion, setVtInputNoticeVersion, } from '../config/ui-state.js';
+import { bumpSubmitCount, setMouseNoticeVersion, setPromptKeyNoticeVersion, setScrollModeNoticeVersion, setVtInputNoticeVersion, } from '../config/ui-state.js';
 import { getLogger } from '../logging/logger.js';
 import { isTerminalStatus } from '../proc/types.js';
 import { getSecrets } from '../logging/secret-registry.js';
 import { redactText } from '../logging/redact.js';
 import { resolveTuiCapabilities } from './capabilities.js';
-import { useStartupNotices, MOUSE_NOTICE_VERSION, SCROLL_MODE_NOTICE_VERSION, VT_INPUT_NOTICE_VERSION, } from './use-startup-notices.js';
+import { useStartupNotices, MOUSE_NOTICE_VERSION, PROMPT_KEY_NOTICE_VERSION, SCROLL_MODE_NOTICE_VERSION, VT_INPUT_NOTICE_VERSION, } from './use-startup-notices.js';
 import { getTheme } from './theme.js';
 import { pickGlyphs } from './glyphs.js';
 import { Header } from './Header.js';
@@ -44,9 +44,11 @@ import { buildExitSummary } from './scrollback/exit-summary.js';
 import { LiveTail } from './scrollback/LiveTail.js';
 import { SCROLLBACK_LIMITS } from './scrollback/limits.js';
 import { TODO_LIMITS } from '../todo/limits.js';
+import { planIsResolved } from '../todo/acceptance.js';
 import { ScrollViewport } from './layout/ScrollViewport.js';
-import { buildTodoRailLayout } from './layout/todo-layout.js';
+import { acceptanceChip, acceptanceRung, buildTodoRailLayout } from './layout/todo-layout.js';
 import { buildTeamPanelLayout } from './layout/team-panel.js';
+import { isLiveTeamCard, lastTeamEntry, rosterCounts } from './team-status.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
 import { useTerminalSize } from './layout/useTerminalSize.js';
 import { useHeightStore } from './use-height-store.js';
@@ -62,6 +64,16 @@ import { publishSessionView } from './session-bridge.js';
 import { OverlayFrame, overlayPageSize } from './layout/OverlayFrame.js';
 import { helpRows } from './overlays/HelpOverlay.js';
 import { ModelPicker } from './overlays/ModelPicker.js';
+import { KitPicker } from './overlays/KitPicker.js';
+import { PromptLibraryOverlay } from './overlays/PromptLibraryOverlay.js';
+import { PromptPicker } from './overlays/PromptPicker.js';
+import { draftToInput } from './overlays/prompt-library-state.js';
+import { createPrompt, deletePrompt, flushPromptStats, loadPromptLibrary, movePrompt, recordPromptUse, setPromptFavorite, takePromptRepairNotice, updatePrompt, } from '../prompts/store.js';
+import { resolvePromptRef } from '../prompts/resolve.js';
+import { promptLineCount } from '../prompts/fill.js';
+import { PROMPT_CORRUPT_COPY, PROMPT_INSERTED_COPY, promptFilledCopy, promptSkippedCopy, } from '../prompts/copy.js';
+import { INACTIVE_KIT } from '../config/kit-resolution.js';
+import { kitApplyMessage, kitNoteMessages } from '../agent/kit-apply.js';
 import { createModelProbe } from '../agent/model-probe.js';
 import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, } from './overlays/SettingsScreen.js';
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
@@ -74,6 +86,7 @@ import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
 import { createClipboardCoordinator } from './clipboard-task.js';
 import { QueuePanel } from './QueuePanel.js';
 import { QueueOverlay } from './overlays/QueueOverlay.js';
+import { AgentsBoardOverlay } from './overlays/AgentsBoardOverlay.js';
 import { buildQueueLayout } from './layout/queue-layout.js';
 import { interactionCopy } from './interaction-copy.js';
 import { createRunMetrics, updateRunMetrics, freezeRunMetrics, projectRunMetrics } from './run-metrics.js';
@@ -138,6 +151,25 @@ function seedViewState(seed) {
         ? viewReducer(base, { type: 'restoreEntries', entries: seed.entries })
         : base;
 }
+/**
+ * One prompt-library mutation, translated into the store call it names.
+ *
+ * MODULE-LEVEL, so it is a table rather than a closure rebuilt on every render: the
+ * overlay sends an INTENT (`{kind:'create', draft}`), and this is the single place that
+ * intent becomes a write. Every branch returns the store's own result, which carries
+ * the new snapshot on success AND on `write_failed` (D-4).
+ */
+function applyPromptMutation(action) {
+    if (action.kind === 'create')
+        return createPrompt(draftToInput(action.draft));
+    if (action.kind === 'update')
+        return updatePrompt(action.id, draftToInput(action.draft));
+    if (action.kind === 'delete')
+        return deletePrompt(action.id);
+    if (action.kind === 'move')
+        return movePrompt(action.id, action.delta);
+    return setPromptFavorite(action.id, action.favorite);
+}
 export function App({ controller, version, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, scrollMode = 'app', scrollback, initialEntries, session, sessionBridge, sessionNotice, }) {
     const native = scrollMode === 'native' && scrollback !== undefined;
     /** Set when the native writer swallowed repeated tall frames; cleared by a resize. */
@@ -153,6 +185,19 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // nonce render (the async clear lands a frame later - see the timing
     // invariant beside the ladder itself).
     const [draftClearNonce, setDraftClearNonce] = useState(0);
+    // --- Quick prompt library (quick-prompt-library §5.2) --------------------
+    //
+    // THE SNAPSHOT IS READ ONCE, from the store's own cache, and re-read only after a
+    // mutation or a command that might have written the file. `App` never edits it: the
+    // store is the only write authority (I-6), so the render can never disagree with the
+    // disk about what exists.
+    const [promptLibrary, setPromptLibrary] = useState(loadPromptLibrary);
+    const [promptIntent, setPromptIntent] = useState(null);
+    const promptIntentNonce = useRef(0);
+    // The fill channel's payload (D-6). `null` until the first fill, so the composer's
+    // effect has nothing to do on every mount.
+    const [draftFill, setDraftFill] = useState(null);
+    const draftFillNonce = useRef(0);
     const [draftClearedByCtrlC, setDraftClearedByCtrlC] = useState(false);
     const [popupRows, setPopupRows] = useState(0);
     const [statusExpanded, setStatusExpanded] = useState(false);
@@ -616,8 +661,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                     if (controller.isRunning() || controller.isCompactionBusy?.())
                         return;
                     const live = controller.getTodoSnapshot();
-                    if (!live || live.doneCount >= live.total)
-                        return; // the list moved
+                    // `planIsResolved`, NOT `doneCount >= total` (todo-acceptance-criteria
+                    // §6.7 / AC-20). With steps all done but criteria unchecked the old test
+                    // said "no work left" and returned silently - one second after the notice
+                    // promised "Continuing with 2 unchecked acceptance criteria in 3s". A
+                    // promise that cancels itself is the worst failure this design has.
+                    if (!live || planIsResolved(live.items, live.acceptance?.items ?? null))
+                        return;
                     budgetRef.current = { ...budgetRef.current, used: budgetRef.current.used + 1 };
                     autoContinuationRef.current = true;
                     // COUNTS ONLY, NEVER ITEM TEXT (D-19), and only at the fire point —
@@ -627,6 +677,8 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                         noProgressStreak: budgetRef.current.noProgressStreak,
                         total: live.total,
                         done: live.doneCount,
+                        accTotal: live.acceptance?.total ?? 0,
+                        accChecked: live.acceptance?.checkedCount ?? 0,
                         mode: 'auto',
                     });
                     submitRef.current(decision.message, { userInitiated: false, todoPolicy: 'continue' });
@@ -1041,32 +1093,45 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // the events must never be shown advice about a mode not in effect (§6.1).
     // `cli.tsx::wantMouse` now folds the platform check into the same expression,
     // so on a console that reports nothing there is no source and no advice.
+    // SIX NOTICES, TWO ARGUMENTS (quick-prompt-library D-20 / P1-6). The hook took five
+    // positional arguments and this feature added a sixth, which `CLAUDE.md` forbids; the
+    // options object is also what makes an older caller that passes nothing byte-identical.
     useStartupNotices(dispatch, {
-        enabled: !!mouseSource,
-        // NOT re-derived here (see `MouseNoticeOptions`): `cli.tsx` computes
-        // `mouseFilter !== null && cfg.mouseSelect` once and four things read it,
-        // so a second derivation is a second chance for them to disagree.
-        selectEnabled: terminal?.mouseSelect ?? false,
-        // `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.
-        //
-        // THE VERSION, NOT `true` (P1-8). The gate compares against
-        // `MOUSE_NOTICE_VERSION`, so storing anything else either replays the
-        // notice forever or silences a future revision of the text.
-        onSeen: () => setMouseNoticeVersion(MOUSE_NOTICE_VERSION),
-    }, 
-    // Present only when `loadConfig` had to raise the user's own
-    // `transcriptRetain` to `transcriptWindow` (tui-render-performance §5.1).
-    cfg.transcriptRetainRequested !== undefined
-        ? { requested: cfg.transcriptRetainRequested, resolved: cfg.transcriptRetain }
-        : undefined, vtInputWarning
-        ? {
-            nodeVersion: vtInputWarning.nodeVersion,
-            onSeen: () => setVtInputNoticeVersion(VT_INPUT_NOTICE_VERSION),
-        }
-        : undefined, native
-        ? { onSeen: () => setScrollModeNoticeVersion(SCROLL_MODE_NOTICE_VERSION) }
-        : undefined);
+        mouse: {
+            enabled: !!mouseSource,
+            // NOT re-derived here (see `MouseNoticeOptions`): `cli.tsx` computes
+            // `mouseFilter !== null && cfg.mouseSelect` once and four things read it,
+            // so a second derivation is a second chance for them to disagree.
+            selectEnabled: terminal?.mouseSelect ?? false,
+            // `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.
+            //
+            // THE VERSION, NOT `true` (P1-8). The gate compares against
+            // `MOUSE_NOTICE_VERSION`, so storing anything else either replays the
+            // notice forever or silences a future revision of the text.
+            onSeen: () => setMouseNoticeVersion(MOUSE_NOTICE_VERSION),
+        },
+        // Present only when `loadConfig` had to raise the user's own
+        // `transcriptRetain` to `transcriptWindow` (tui-render-performance §5.1).
+        ...(cfg.transcriptRetainRequested !== undefined
+            ? { retain: { requested: cfg.transcriptRetainRequested, resolved: cfg.transcriptRetain } }
+            : {}),
+        ...(vtInputWarning
+            ? {
+                vtInput: {
+                    nodeVersion: vtInputWarning.nodeVersion,
+                    onSeen: () => setVtInputNoticeVersion(VT_INPUT_NOTICE_VERSION),
+                },
+            }
+            : {}),
+        ...(native
+            ? { scrollMode: { onSeen: () => setScrollModeNoticeVersion(SCROLL_MODE_NOTICE_VERSION) } }
+            : {}),
+        // THE KEY MIGRATION (D-20 / AC-32). Always supplied: the hook gates it on
+        // `state.json::promptKeyNoticeVersion`, so a user who has already been told pays
+        // nothing and `state.json` is never touched for a notice that will not be shown.
+        promptKeys: { onSeen: () => setPromptKeyNoticeVersion(PROMPT_KEY_NOTICE_VERSION) },
+    });
     // --- Exit snapshot: the only way state reaches cli.tsx (§4.4). ----------
     useEffect(() => {
         const merged = mergePendingEntries(state.entries, state.pendingSteering);
@@ -1202,6 +1267,102 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // --- Helpers -----------------------------------------------------------
     const notify = (level, text) => dispatch({ type: 'notice', level, text });
     const toast = (level, text) => dispatch({ type: 'pushToast', level, text });
+    // --- Quick prompt library: two one-shot channels and the store port ------
+    const refreshPromptLibrary = useCallback(() => setPromptLibrary(loadPromptLibrary()), []);
+    /**
+     * Open the manager on a specific page (D-21).
+     *
+     * THE NONCE IS BUMPED BEFORE THE OVERLAY OPENS, and the overlay consumes it at most
+     * once. Without that, two `/prompts edit 1` in a row would be one intent and the
+     * second would look like a no-op (I-8).
+     */
+    const openPromptLibrary = useCallback((entry) => {
+        promptIntentNonce.current += 1;
+        setPromptIntent({ nonce: promptIntentNonce.current, entry });
+        dispatch({ type: 'setOverlay', overlay: 'prompts' });
+    }, []);
+    /**
+     * Hand the composer a body to insert (D-6 / §4.6).
+     *
+     * `App` DOES NOT TOUCH THE DRAFT. It only carries the payload and closes the overlay;
+     * `PromptInput` owns the editor, the caret and the one submission path (P0-1).
+     */
+    const fillComposer = useCallback((text, submit = false) => {
+        draftFillNonce.current += 1;
+        setDraftFill({
+            nonce: draftFillNonce.current,
+            text,
+            ...(submit ? { submit: true } : {}),
+        });
+        dispatch({ type: 'setOverlay', overlay: null });
+    }, []);
+    const handlePromptMutate = useCallback((action) => {
+        const result = applyPromptMutation(action);
+        // ON FAILURE TOO, and that is not a mistake: a `write_failed` still applied in
+        // memory (D-4), so the user must be able to see the prompt they just created.
+        setPromptLibrary(result.library);
+        return result;
+    }, []);
+    /**
+     * Closing the picker is when the usage counters reach the disk (D-7).
+     *
+     * The snapshot is refreshed FIRST so the next open shows the counts this session just
+     * produced, then the stats are flushed - two independent concerns that happen to share
+     * a moment.
+     */
+    const closePromptPicker = () => {
+        refreshPromptLibrary();
+        flushPromptStats();
+        dispatch({ type: 'setOverlay', overlay: null });
+    };
+    const handlePromptFill = (id, submit) => {
+        // THE FRESH LIBRARY, not the render snapshot: a `/prompts fill` can arrive in the
+        // same tick as a mutation, and the snapshot would then be one render behind.
+        const prompt = loadPromptLibrary().prompts.find((entry) => entry.id === id);
+        if (!prompt)
+            return;
+        recordPromptUse(id);
+        fillComposer(prompt.content, submit);
+        // The usage counters change, so the list the picker re-opens with is the one with
+        // the new counts (D-7: memory first, disk on a debounce).
+        refreshPromptLibrary();
+        // TWO ACKNOWLEDGEMENTS, ONE OF THEM HONEST ABOUT WHAT HAPPENED (D-6). When the draft
+        // already had text and the mode is `insert`, the sentence has to say that the words
+        // are still there - otherwise "filled" reads as "replaced" and the user retypes what
+        // they had. `hasDraftRef` is the composer's own presence flag (the host has no copy
+        // of the text), so this costs no new state.
+        const keptDraft = cfg.prompts?.insertMode !== 'replace' && hasDraftRef.current;
+        notify('info', keptDraft
+            ? PROMPT_INSERTED_COPY
+            : promptFilledCopy(prompt.title, promptLineCount(prompt.content)));
+    };
+    /**
+     * One-shot report of a repaired or partially unreadable library (§8).
+     *
+     * A DURABLE `notice`, not a toast: the user has to be able to scroll back to the
+     * sentence that explains why entries are missing, and a `.bak` file is only useful to
+     * someone who knows it exists.
+     */
+    useEffect(() => {
+        const repair = takePromptRepairNotice();
+        if (!repair)
+            return;
+        if (repair.repaired !== 'entries')
+            notify('warn', PROMPT_CORRUPT_COPY);
+        if (repair.dropped > 0)
+            notify('warn', promptSkippedCopy(repair.dropped));
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Usage counters are written when the surface that produced them closes, and again
+    // on unmount (D-7). The 1 s debounce inside the store covers the common case; these
+    // two make a clean exit cost exactly one write instead of waiting for a timer.
+    const promptOverlayOpen = state.overlay === 'prompts' || state.overlay === 'prompt-pick';
+    useEffect(() => {
+        if (!promptOverlayOpen)
+            return undefined;
+        return () => { flushPromptStats(); };
+    }, [promptOverlayOpen]);
+    useEffect(() => () => { flushPromptStats(); }, []);
     // THE BRANCH / `--save` NOTICE (D-13). Once, on mount, and only when the
     // caller supplied one: "the session you branched from is unchanged" is the
     // sentence that makes `--resume` safe to reach for, and it belongs in the
@@ -1520,6 +1681,16 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             }
             dispatch(action);
         },
+        // The prompt library's three capabilities (quick-prompt-library §4.3 / P1-3).
+        // Present even when `prompts.enabled` is false: `/prompts` has to be able to SAY
+        // that it is off, and a missing port would answer "not available in this build"
+        // instead (AC-30). `resolve` reads the store's cache, so it always sees the last
+        // mutation rather than this render's snapshot.
+        prompts: {
+            openPicker: () => dispatch({ type: 'setOverlay', overlay: 'prompt-pick' }),
+            openManager: (entry) => openPromptLibrary(entry),
+            resolve: (ref) => resolvePromptRef(loadPromptLibrary(), ref),
+        },
         setOverlay: (overlay) => dispatch({ type: 'setOverlay', overlay }),
         notify,
         toast,
@@ -1681,6 +1852,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             notify('error', `Command failed: ${redactText(reason, getSecrets())}\nInput: ${safe}`);
         }
         finally {
+            // A command may have written the prompt library (`/prompts add|rm|move|sort`).
+            // The store's cache already holds the new snapshot, so this is a `setState`, not
+            // a disk read - and without it the list would show the library as it was when
+            // the overlay opened.
+            refreshPromptLibrary();
             if (switching) {
                 switchingConversation.current = false;
                 drainCompactionQueue.current();
@@ -1724,6 +1900,39 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         dispatch({ type: 'setOverlay', overlay: null });
         toast('info', `Model set to ${provider}:${model}.`);
     };
+    /**
+     * `ctrl+K` chose a row (agent-model-kits §4.7 / AC-25).
+     *
+     * `null` is `Current setup`, which is the RELEASE action, not a no-op: it runs
+     * `clearSessionKit` so the live connections go back to the file's bindings.
+     * Both paths close the overlay, and both report through the same toast funnel -
+     * including every `KitNote`, because a kit that turns the fast tier on spends
+     * money and must never do it silently (§4.2 / F-23).
+     */
+    const handleKitChoose = (kitId) => {
+        // NO KIT PORT, NO CRASH: a legacy host can still press the key, and the only
+        // honest answer is a sentence rather than a stack trace.
+        const port = controller;
+        if (typeof port.applySessionKit !== 'function' || typeof port.clearSessionKit !== 'function') {
+            dispatch({ type: 'setOverlay', overlay: null });
+            toast('error', 'This build cannot switch kits.');
+            return;
+        }
+        const result = kitId === null
+            ? controller.clearSessionKit() : controller.applySessionKit(kitId);
+        dispatch({ type: 'setOverlay', overlay: null });
+        // The config is already updated synchronously, so this reads the kit that is
+        // in effect RIGHT NOW rather than the id the user asked for - if the apply
+        // fell back to anything, the toast says so.
+        const applied = controller.getActiveKit().name;
+        const text = !result.ok ? kitApplyMessage(result)
+            : kitId === null ? "Kit released; using the config file's settings."
+                : `Kit ${applied} applied for this session.`;
+        const notes = kitNoteMessages(result.notes);
+        // A NOTE IS A WARNING, NOT A SUCCESS (F-23): the toast colour is the only
+        // signal a user gets that applying a kit can start spending money.
+        toast(result.ok ? (notes.length ? 'warn' : 'success') : 'error', [text, ...notes].join(' '));
+    };
     const closeConfirm = () => {
         setConfirmState(null);
         dispatch({ type: 'setOverlay', overlay: null });
@@ -1967,6 +2176,71 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             setStatusExpanded(value => !value);
             return;
         }
+        // Ctrl+B: the Agents board (tui-subagent-panel D-6 / §6.5).
+        //
+        // THE GUARD ORDER IS Ctrl+G's EXACTLY, plus one rung: pressing it again CLOSES the
+        // board, and any OTHER overlay keeps the keyboard (a second overlay drawn over the
+        // first would leave two `isActive` input handlers fighting for Up/Down).
+        //
+        // Two byte forms, like Ctrl+K: the raw 0x02 byte and `key.ctrl` + `b`. 0x02 is
+        // unbound everywhere in this app, and `Alt+B` (keymap.ts's `wordLeft`) is a
+        // different modifier with a different prefix, so neither collides.
+        const isCtrlB = (key.ctrl && (input === 'b' || input === 'B')) || input === '\x02';
+        if (isCtrlB) {
+            if (tooSmall)
+                return;
+            const openOverlay = stateRef.current.overlay;
+            if (openOverlay === 'agents') {
+                dispatch({ type: 'setOverlay', overlay: null });
+                return;
+            }
+            if (openOverlay)
+                return;
+            // ONE GUARD, SHARED WITH `/agents` (AC-18): an empty board would read as a broken
+            // feature, and the honest answer is the same notice the command gives.
+            if (stateRef.current.team === null && lastTeamEntry(stateRef.current.entries) === null) {
+                toast('info', 'No subagent dispatch yet.');
+                return;
+            }
+            dispatch({ type: 'setOverlay', overlay: 'agents' });
+            return;
+        }
+        // Ctrl+P: the quick prompt library (quick-prompt-library D-1).
+        //
+        // THIS KEY USED TO BE THE MODE FALLBACK and now opens a library, because the
+        // requirement names it as a first-class entry point. The guards are exactly the
+        // ones Ctrl+K and Ctrl+G use: an overlay owns the keyboard, and on a too-small
+        // terminal the frame has nowhere to go. `prompts.enabled=false` is read at KEY
+        // TIME rather than at mount, so the switch takes effect without a restart - and
+        // the command stays registered so `/prompts` can say it is off (D-19 / AC-30).
+        if (key.ctrl && (input === 'p' || input === 'P')) {
+            if (tooSmall || stateRef.current.overlay)
+                return;
+            // `!== false`, so a hand-built `CliConfig` without the section behaves like the
+            // default (enabled) rather than like a dead key.
+            if (controller.getConfig().prompts?.enabled === false)
+                return;
+            openPromptLibrary({ kind: 'list' });
+            return;
+        }
+        // Ctrl+K: the Agent-kit picker (agent-model-kits D-15 / §4.7).
+        //
+        // NOT AN INPUT FRAME, unlike Ctrl+I below. Ctrl+I collides with the Tab byte,
+        // so a stdin translator has to disambiguate it; 0x0B is unambiguous in every
+        // encoding this app supports (utf8 byte, win32-input-mode's pass-through of
+        // control chars, and CSI-u's `ctrlByte` fold), so the raw byte IS the key.
+        //
+        // `killToEnd` HAS MOVED TO Alt+K FIRST (keymap.ts): `PromptInput`'s
+        // recognizer runs before its `key.ctrl` early-return, so leaving the old
+        // binding would delete the draft in one listener while this one opened the
+        // overlay. Two listeners both see the event; `return` only leaves one.
+        const isCtrlK = (key.ctrl && (input === 'k' || input === 'K')) || input === '\x0b';
+        if (isCtrlK) {
+            if (tooSmall || stateRef.current.overlay)
+                return;
+            dispatch({ type: 'setOverlay', overlay: 'kit' });
+            return;
+        }
         // Ctrl+I arrives as INDEX_KEY_FRAME, never as key.ctrl + 'i': legacy
         // terminals encode it as the Tab byte and the stdin filter's translators
         // are the only layer that can tell them apart (see input/limits.ts).
@@ -2004,7 +2278,15 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             const overlay = stateRef.current.overlay;
             // Modes A only. `model` / `confirm` manage their own keys; registering an
             // arrow handler for them would double every keypress (R-12).
-            const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan' || overlay === 'queue';
+            const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan'
+                || overlay === 'queue' || overlay === 'kit'
+                // The Agents board pages through `overlayScroll` too, but keeps Up/Down for its
+                // CHILD CURSOR - the same trade `settings` makes with its field cursor.
+                || overlay === 'agents'
+                // The prompt surfaces page themselves through `overlayScroll` too
+                // (quick-prompt-library appendix B-1). Without them a `PgDn` in the list does
+                // nothing and the wheel falls through to the transcript behind it.
+                || overlay === 'prompts' || overlay === 'prompt-pick';
             if (key.pageUp) {
                 if (controlled)
                     setOverlayScroll((n) => Math.max(0, n - overlayPage));
@@ -2029,11 +2311,13 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // everything else falls through (AC-P2).
         //
         // TWO KEYS, ONE BRANCH (shift-tab-mode-toggle-still-dead-on-windows, C2).
-        // `Ctrl+P` is not a Windows-only alias bolted on beside the real binding: it
-        // is the rung that survives when `Shift+Tab` cannot be delivered at all, and
-        // it shares this branch precisely so the two can never drift into different
-        // behaviour. See `MODE_TOGGLE_KEYS` for why this key and not another.
-        if ((key.tab && key.shift) || (key.ctrl && (input === 'p' || input === 'P'))) {
+        // `Ctrl+N` is not a Windows-only alias bolted on beside the real binding: it is the
+        // rung that survives when `Shift+Tab` cannot be delivered at all, and it shares this
+        // branch precisely so the two can never drift into different behaviour. See
+        // `MODE_TOGGLE_KEYS` for why this key and not another - and for why it is `Ctrl+N`
+        // now rather than the `Ctrl+P` this branch used to own (quick-prompt-library D-1:
+        // `Ctrl+P` opens the prompt library, and one key may not mean two things).
+        if ((key.tab && key.shift) || (key.ctrl && (input === 'n' || input === 'N'))) {
             if (stateRef.current.overlay)
                 return;
             applyMode(nextMode(controller.getAgentMode()));
@@ -2114,10 +2398,16 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             const entries = stateRef.current.entries;
             const card = [...entries]
                 .reverse()
-                .find((e) => e.kind === 'tool' ||
-                e.kind === 'team' ||
-                e.kind === 'compaction' ||
-                (e.kind === 'service' && !e.terminal));
+                .find((e) => 
+            // THE LIVE DISPATCH CARD IS NOT EXPANDABLE (tui-subagent-double-roster
+            // A-2'): it is suppressed on screen, so expanding it would print a frozen
+            // copy of a card that is still being rewritten. Once it settles it becomes
+            // an ordinary history card and this key reaches it again.
+            !isLiveTeamCard(e) &&
+                (e.kind === 'tool' ||
+                    e.kind === 'team' ||
+                    e.kind === 'compaction' ||
+                    (e.kind === 'service' && !e.terminal)));
             // NATIVE MODE ONLY. The fallback exists because native mode cannot scroll inside the
             // frame - the answer's head is reachable only if it is printed. Full-screen mode has a
             // viewport that already reaches it, and it has no `expanded` rendering for an answer,
@@ -2224,6 +2514,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const overlay = state.overlay;
     const settingsDraft = useMemo(() => overlay === 'settings'
         ? controller.createModelSettingsDraft() : undefined, [controller, overlay]);
+    // THE FILE'S BINDINGS, FOR THE KIT PICKER'S FIRST ROW (§4.6 / D-13). While a
+    // session kit is held the live config mirrors the KIT (I-6), so `Current setup`
+    // can only describe what choosing it restores by reading the file - one read per
+    // opening, the same price `settingsDraft` one line up already pays.
+    const kitDiskConfig = useMemo(() => overlay === 'kit'
+        ? controller.createModelSettingsDraft().baseline : undefined, [controller, overlay]);
     // ONE PROBE PER APP (model-profile-connection-test 5 row 9): the port needs the
     // controller's provider registry, which the overlay has no business owning.
     // Built only while the settings overlay is open, so no other screen pays for it.
@@ -2237,6 +2533,22 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         return createModelProbe({ registry: controller.getProviderRegistry() });
     }, [controller, overlay]);
     const hasKey = controller.hasApiKey();
+    // THE ACTIVE KIT, DERIVED PER FRAME (D-5 / F-22): `controller.getActiveKit()` is
+    // pure, so it cannot go stale the way a cached copy would after `ctrl+K`,
+    // `/model` or a saved default. Absent when no kit is in effect, which is what
+    // keeps the status row byte-identical for users who own none (I-9).
+    //
+    // A TEST DOUBLE OR AN EMBEDDED HOST MAY PREDATE THIS PORT: the same tolerance
+    // the probe port gets one screen over ("absent means the rows read
+    // unresolved") applies here - no kit, no crash.
+    const activeKit = typeof controller.getActiveKit === 'function'
+        ? controller.getActiveKit() : INACTIVE_KIT;
+    const kitChip = activeKit.source === 'none' ? undefined : {
+        name: activeKit.name,
+        modified: activeKit.modified,
+        otherNames: (cfg.modelProfiles?.kits ?? [])
+            .filter((kit) => kit.id !== activeKit.id).map((kit) => kit.name),
+    };
     const empty = state.entries.length === 0;
     // RENDER SCOPE, so the chip and the composer hint agree with what the Ctrl+C
     // handler will do on the very next keystroke.
@@ -2340,7 +2652,14 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // ALWAYS CALLED, INERT WHEN `enabled` IS FALSE: hooks cannot be conditional, and
     // an inert hook is what keeps `scrollMode: 'app'` byte-identical (I-S9).
     const viewCols = native ? Math.max(1, cols - 1) : cols;
-    const header = (_jsx(Header, { columns: viewCols, statusExpanded: statusExpanded, scrolledLines: scrolledLines, overlayOpen: overlay !== null, cwd: controller.getCwd(), provider: cfg.provider, model: cfg.model, hasKey: hasKey, variant: pickHeaderVariant(cols), theme: theme, caps: caps }));
+    const header = (_jsx(Header, { columns: viewCols, statusExpanded: statusExpanded, scrolledLines: scrolledLines, overlayOpen: overlay !== null, cwd: controller.getCwd(), provider: cfg.provider, model: cfg.model, hasKey: hasKey, variant: pickHeaderVariant(cols), theme: theme, caps: caps, 
+        // ALWAYS TRUE (agent-model-kits §4.7 / RV-P1-2): the requirement is that
+        // `ctrl+G` reveals `ctrl+K`, and the user with an empty library needs that
+        // hint most - the picker itself carries the "create one in /settings" row.
+        kitHint: true, 
+        // `prompts.hint=false` removes the `^P prompts` clause and nothing else; the key
+        // still works (AC-3).
+        promptsHint: cfg.prompts?.hint !== false }));
     // The header and the opener are SLOTS OF THE SHELL, not printed bytes (D3/D4): at
     // `H = rows - 1` a printed row is pushed off the screen by the very next frame, so
     // `printBanner()` was a way of making the banner invisible. Neither is passed here.
@@ -2391,7 +2710,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const openerCols = nativeBudget ? nativeBudget.previewCols : contentCols;
     const opener = empty ? (_jsx(SessionOpener, { variant: pickOpenerVariant(openerRows, openerCols), version: version, cwd: controller.getCwd(), hasKey: hasKey, viewportRows: openerRows, theme: theme, caps: caps })) : null;
     const overlayMaxRows = nativeBudget ? nativeBudget.overlayRows : viewportBudget;
-    const overlayNode = overlay === 'queue' ? (_jsx(QueueOverlay, { pending: state.pendingSteering, cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'help' ? (_jsx(OverlayFrame, { title: "Help", hint: `Esc close ${glyphs.midDot} PgUp/PgDn scroll`, maxRows: overlayMaxRows, cols: viewCols, rows: helpRows(theme, caps, native), scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'model' ? (_jsx(ModelPicker, { isActive: !tooSmall, registry: controller.getModelRegistry(), currentProvider: cfg.provider, currentModel: cfg.model, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onSelect: handleModelSelect })) : overlay === 'settings' ? (_jsx(SettingsScreen, { isActive: !tooSmall, initial: {
+    const overlayNode = overlay === 'queue' ? (_jsx(QueueOverlay, { pending: state.pendingSteering, cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'help' ? (_jsx(OverlayFrame, { title: "Help", hint: `Esc close ${glyphs.midDot} PgUp/PgDn scroll`, maxRows: overlayMaxRows, cols: viewCols, rows: helpRows(theme, caps, native), scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'model' ? (_jsx(ModelPicker, { isActive: !tooSmall, registry: controller.getModelRegistry(), currentProvider: cfg.provider, currentModel: cfg.model, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onSelect: handleModelSelect })) : overlay === 'kit' ? (_jsx(KitPicker, { isActive: !tooSmall, library: cfg.modelProfiles, config: cfg, ...(kitDiskConfig ? { diskConfig: kitDiskConfig } : {}), active: activeKit, 
+        // ONLY THE APPLY IS BLOCKED while work is in flight (§4.7): a list a
+        // user cannot even OPEN reads as a broken key.
+        busy: controller.isModelSettingsBusy(), maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onChoose: handleKitChoose, onClose: () => dispatch({ type: 'setOverlay', overlay: null }) })) : overlay === 'prompts' ? (_jsx(PromptLibraryOverlay, { isActive: !tooSmall, library: promptLibrary, ...(promptIntent ? { intent: promptIntent } : {}), cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onMutate: handlePromptMutate, onNotice: notify, onClose: () => dispatch({ type: 'setOverlay', overlay: null }) })) : overlay === 'prompt-pick' ? (_jsx(PromptPicker, { isActive: !tooSmall, library: promptLibrary, cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onFill: handlePromptFill, onManage: (entry) => openPromptLibrary(entry), onClose: closePromptPicker })) : overlay === 'settings' ? (_jsx(SettingsScreen, { isActive: !tooSmall, initial: {
             provider: cfg.provider,
             model: cfg.model,
             baseUrl: cfg.baseUrl ?? '',
@@ -2428,7 +2750,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, draft: settingsDraft, probe: probe, onProfileSave: handleProfileSave, onReload: () => controller.createModelSettingsDraft(), onClose: () => dispatch({ type: 'setOverlay', overlay: null }), 
         // Read from `cfg` (render scope, re-read every frame), so `/retry off`
         // while the screen is open shows the new value on the next paint.
-        retrySummary: cfg.retry.enabled && cfg.retry.maxRetries > 0 ? String(cfg.retry.maxRetries) : 'off' })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { isActive: !tooSmall, state: confirmState, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { isActive: !tooSmall, questions: humanRequest.questions, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }) })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { isActive: !tooSmall, plan: humanRequest.plan, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;
+        retrySummary: cfg.retry.enabled && cfg.retry.maxRetries > 0 ? String(cfg.retry.maxRetries) : 'off' })) : overlay === 'agents' ? (
+    // THE BRANCH AND THE `Overlay` MEMBER SHIP TOGETHER (R-11): a missing branch is not
+    // a type error, it is a SILENT BLANK FRAME, because `active={overlay === null}` has
+    // already disabled the transcript underneath.
+    _jsx(AgentsBoardOverlay, { team: state.team, entries: state.entries, cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, isActive: !tooSmall, native: native, theme: theme, caps: caps })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { isActive: !tooSmall, state: confirmState, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { isActive: !tooSmall, questions: humanRequest.questions, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }) })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { isActive: !tooSmall, plan: humanRequest.plan, maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;
     const density = cfg.density;
     const transcriptWindow = cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW;
     // The fixed status bar remains visible underneath every overlay and toast.
@@ -2463,6 +2789,16 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                 windowStart: scrollbackView.windowStart,
                 windowEntries: scrollbackView.tailEntries.length,
                 headRows: scrollbackView.headRows,
+                // WHICH RUNG THE ACCEPTANCE SECTION REACHED, from the same function the rail
+                // rendered with (§6.9.6). `n/a` is the honest answer when the plan has no
+                // criteria at all, which is a different fact from `absent`.
+                acceptance: state.todos?.acceptance
+                    ? acceptanceRung({
+                        snapshot: state.todos,
+                        railRows: nativeBudget.band.railRows,
+                        width: railWidth,
+                    })
+                    : 'n/a',
             }
             : null,
         // A getter: the bridge's `frameReady` and geometry change outside React renders.
@@ -2511,6 +2847,16 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         toast: latestToast ? { text: latestToast.text,
             level: latestToast.level === 'success' ? 'info' : latestToast.level } : undefined,
     });
+    // THE ACCEPTANCE CHIP, COMPUTED ONCE for both status surfaces (P1-8 / C-9).
+    // Whether the rail is already reporting the count is a question about the rail, so
+    // it is asked of the module that owns the rail's geometry - both here and in the
+    // detail row. `App` contributes the two numbers only it knows: which rail was drawn
+    // and how wide it was.
+    const acceptanceActive = acceptanceChip({
+        snapshot: state.todos,
+        railRows: native ? (nativeBudget?.band.railRows ?? 0) : (fullscreenRailVisible ? railRows : 0),
+        width: native ? (nativeBudget?.band.railCols ?? 0) : railWidth,
+    });
     const statusInput = {
         columns: viewCols, phase: state.runPhase, pendingCount: state.pendingSteering.length,
         context: state.context, usageTotal: state.usageTotal, thinkingLevel: cfg.thinkingLevel,
@@ -2524,9 +2870,16 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         compacting: compactionLive || !!state.compaction?.inFlight,
         mode: state.agentMode, pendingMode: state.pendingAgentMode,
         servicesActive: { live: liveServices }, ecoRung: governor.rung,
-        teamActive: state.team ? { running: state.team.runs.filter(item => !['queued', 'done', 'failed', 'aborted'].includes(item.phase)).length,
-            total: state.team.runs.length } : undefined,
+        // THE STATUS-DETAIL ROW COUNTS LIKE THE ROSTER AND THE CHIP (A-1): this was the
+        // last inline phase filter, left behind when the StatusBar chip converged, and it
+        // feeds the `Team n/m` on the second status row.
+        teamActive: state.team
+            ? { running: rosterCounts(state.team.runs).running, total: state.team.runs.length }
+            : undefined,
         todoActive: state.todos ? { done: state.todos.doneCount, total: state.todos.total } : undefined,
+        // ONE LINE, NO ROW ALGEBRA HERE (P1-8 / C-9): whether the acceptance count still
+        // needs the second status row was decided once, above, by `acceptanceChip`.
+        ...(acceptanceActive ? { acceptanceActive } : {}),
         fastActive: state.fast?.live ? { inFlight: state.fast.inFlight } : undefined,
         ...feedbackProjection,
     };
@@ -2538,7 +2891,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             hintsEnabled: cfg.hints, modeToggleKey,
             interruptPhase: interruptGesture.current.phase,
             updateAvailable: !!updateSnapshot && shouldRenderUpdateLine(updateSnapshot) } });
-    const composer = (_jsx(Composer, { deleteDisambiguated: terminal?.deleteDisambiguated ?? false, onCompletionContextChange: setCompletion, cols: frameBudget.composerCols, terminalRows: rows, statusExpanded: statusExpanded, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: false, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: frameBudget.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onDraftRows: onDraftRows, onDraftPresence: onDraftPresence, draftClearNonce: draftClearNonce, onNotice: notify, theme: theme, caps: caps, onSubmit: handleSubmit, onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
+    const composer = (_jsx(Composer, { deleteDisambiguated: terminal?.deleteDisambiguated ?? false, onCompletionContextChange: setCompletion, cols: frameBudget.composerCols, terminalRows: rows, statusExpanded: statusExpanded, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: false, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: frameBudget.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onDraftRows: onDraftRows, onDraftPresence: onDraftPresence, draftClearNonce: draftClearNonce, ...(draftFill ? { draftFill } : {}), insertMode: cfg.prompts?.insertMode ?? 'insert', onNotice: notify, theme: theme, caps: caps, onSubmit: handleSubmit, onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
     const team = state.team ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: contentCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     // --- Native panel band (release-gate-and-native-panels §6.3/§6.4) -------------
     //
@@ -2549,16 +2902,22 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // panel that mounts on one value and lays out against another renders nothing and
     // reports nothing (TodoPanel's own I-10 / P1-3 note).
     const nativeBand = nativeBudget ? nativeBudget.band : null;
+    // The band's FULL width, from the budget rather than from the band object: `band`
+    // carries `previewCols` (which `rail.ts` narrows) but `contentCols` lives on the
+    // budget, and the roster spans the whole thing (tui-subagent-panel D-2).
+    const nativeBandCols = nativeBudget ? nativeBudget.contentCols : 0;
     const nativeRail = state.todos && nativeBand && nativeBand.railRows >= TODO_LIMITS.panelMinRows
         ? (_jsx(TodoPanel, { snapshot: state.todos, width: nativeBand.railCols, rows: nativeBand.railRows, running: running, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
-    // `cols` is the band's left column, not `contentCols`: `TeamPanel.activityBudget` is
-    // continuous in `cols`, so a roster laid out against a column it is not in is exactly
-    // the bug that pushes the elapsed column off an 80-column terminal.
-    const nativeTeam = state.team && nativeBand ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: nativeBand.previewCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
+    // `cols` is the WHOLE band, not its left column (tui-subagent-panel §4.1.2 / D-2): the
+    // roster is a full-width slot spanning the TODO rail's columns as well, so a row laid
+    // out against `previewCols` would stop its clock one rail short of the screen's edge.
+    // `teamRowGeometry` is continuous in `cols`, so the number that decides whether the
+    // panel mounts IS the number it lays out against.
+    const nativeTeam = state.team && nativeBand ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: nativeBandCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const rail = fullscreenRailVisible && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: running, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const viewport = (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: overlayNode, footer: _jsxs(_Fragment, { children: [team, _jsx(QueuePanel, { layout: queueLayout, theme: theme })] }), rail: rail, scrollbar: terminal?.scrollbar, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, onGeometryChange: onGeometryChange, geometryKey: `${rows}:${cols}:${viewportBudget}:${frameBudget.composerSlotRows}:${frameBudget.statusRows}:${contentCols}:${overlay}:${tooSmall}`, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: transcriptEntries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] }));
     const detailsNode = _jsx(BottomStatusRow, { plan: details, columns: viewCols, theme: theme });
-    const statusNode = (_jsx(StatusBar, { columns: viewCols, speedKnown: speedKnown, ...feedbackProjection, interruptPhase: interruptGesture.current.phase, pendingSteering: state.pendingSteering, runPhase: state.runPhase, activeTool: state.activeTool, ...(wait ? { wait } : {}), runOutcome: state.runOutcome, reducedMotion: reducedMotion, ...(sessionId ? { sessionId } : {}), waitingForConfirmation: !!humanRequest || !!confirmState, stopping: interruptGesture.current.phase === 'stopping', interruptHint: interruptGesture.current.phase === 'stopping'
+    const statusNode = (_jsx(StatusBar, { columns: viewCols, speedKnown: speedKnown, ...feedbackProjection, interruptPhase: interruptGesture.current.phase, pendingSteering: state.pendingSteering, runPhase: state.runPhase, activeTool: state.activeTool, ...(wait ? { wait } : {}), runOutcome: state.runOutcome, reducedMotion: reducedMotion, ...(sessionId ? { sessionId } : {}), ...(kitChip ? { kit: kitChip } : {}), waitingForConfirmation: !!humanRequest || !!confirmState, stopping: interruptGesture.current.phase === 'stopping', interruptHint: interruptGesture.current.phase === 'stopping'
             ? 'Esc force-stop' : 'Esc x2 interrupt', model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, 
         // ONE OBJECT INSTEAD OF FOUR PARALLEL PROPS (§4.3). The four were a
         // projection of "many sources of truth" into the props layer, and a
@@ -2568,9 +2927,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // `contextWindow` override reach the bar.
         context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ecoRung: governor.rung, ...(state.team
             ? {
+                // `rosterCounts`, NOT a fourth inline phase filter (A-1): the chip and
+                // the roster header above it must never disagree.
                 teamActive: {
-                    running: state.team.runs.filter((r) => r.phase !== 'queued' && r.phase !== 'done' &&
-                        r.phase !== 'failed' && r.phase !== 'aborted').length,
+                    running: rosterCounts(state.team.runs).running,
                     total: state.team.runs.length,
                 },
             }
@@ -2578,7 +2938,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             ? (nativeBudget?.band.railRows ?? 0) > 0
             : fullscreenRailVisible)
             ? { todoActive: { done: state.todos.doneCount, total: state.todos.total } }
-            : {}), ...(liveServices > 0 ? { servicesActive: { live: liveServices } } : {}), ...(state.fast?.live ? { fastActive: { inFlight: state.fast.inFlight } } : {}), 
+            : {}), ...(acceptanceActive ? { acceptanceActive } : {}), ...(liveServices > 0 ? { servicesActive: { live: liveServices } } : {}), ...(state.fast?.live ? { fastActive: { inFlight: state.fast.inFlight } } : {}), 
         // Manual compaction starts before its next snapshot is published.
         compactionActive: { inFlight: statusInput.compacting ?? false }, ...(controller.isCompactionEnabled()
             ? {