@aragon-agent/cli 0.6.35 → 0.6.37

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,10 +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, rosterCounts } from './team-status.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';
@@ -64,6 +65,13 @@ 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';
@@ -78,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';
@@ -142,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. */
@@ -157,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);
@@ -620,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 —
@@ -631,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' });
@@ -1045,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);
@@ -1206,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
@@ -1524,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,
@@ -1685,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();
@@ -2004,6 +2176,53 @@ 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,
@@ -2060,7 +2279,14 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // 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' || overlay === 'kit';
+                || 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));
@@ -2085,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()));
@@ -2428,7 +2656,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // 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 }));
+        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.
@@ -2482,7 +2713,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     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 === 'settings' ? (_jsx(SettingsScreen, { isActive: !tooSmall, initial: {
+        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 ?? '',
@@ -2519,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.
@@ -2554,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.
@@ -2602,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,
@@ -2622,6 +2877,9 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             ? { 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,
     };
@@ -2633,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) -------------
     //
@@ -2644,12 +2902,18 @@ 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 });
@@ -2674,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()
             ? {

package/dist/ui/Composer.d.ts

@@ -5,7 +5,7 @@ import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import { pickGlyphs } from './glyphs.js';
 import type { ComposerSubmitResult } from './composer-input.js';
-import { type CommandOption } from './PromptInput.js';
+import { type CommandOption, type DraftFill } from './PromptInput.js';
 import type { RunActivity } from './run-status-row.js';
 import { type AgentMode } from '../agent/agent-mode.js';
 /** Legacy caller shape retained for source compatibility; Composer no longer mounts it. */
@@ -77,6 +77,10 @@ export interface ComposerProps {
      * PromptInput unchanged.
      */
     draftClearNonce?: number;
+    /** Downward half of the fill channel; forwarded to `PromptInput` unchanged. */
+    draftFill?: DraftFill;
+    /** `prompts.insertMode`, forwarded unchanged. */
+    insertMode?: 'insert' | 'replace';
     /** Paste refusals from `PromptInput`, routed to `App`'s notice dispatch. */
     onNotice?: (level: 'warn' | 'error', text: string) => void;
     theme: Theme;
@@ -101,5 +105,5 @@ declare function hintText(opts: {
 }): string;
 /** Compatibility export for existing hint contract tests. */
 export declare const hintTextForTest: typeof hintText;
-export declare function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+export declare function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, draftFill, insertMode, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
 export {};

package/dist/ui/Composer.js

@@ -36,7 +36,7 @@ function hintText(opts) {
 }
 /** Compatibility export for existing hint contract tests. */
 export const hintTextForTest = hintText;
-export function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, onNotice, theme, caps, onSubmit, onHelp, }) {
+export function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, draftFill, insertMode, onNotice, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => {
         setHasDraft(next.hasDraft);
@@ -57,5 +57,5 @@ export function Composer({ deleteDisambiguated, onCompletionContextChange, cols,
                 : hasDraft
                     ? theme.focusBorder ?? theme.primary
                     : theme.idleBorder ?? theme.border;
-    return (_jsx(Box, { ref: measureRef, width: cols, flexDirection: "column", flexShrink: 0, children: _jsx(PromptInput, { deleteDisambiguated: deleteDisambiguated, onCompletionContextChange: onCompletionContextChange, cols: cols, terminalRows: terminalRows, statusExpanded: statusExpanded, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, borderColor: borderColor, onDraftChange: onDraftChange, draftClearNonce: draftClearNonce, onNotice: onNotice }) }));
+    return (_jsx(Box, { ref: measureRef, width: cols, flexDirection: "column", flexShrink: 0, children: _jsx(PromptInput, { deleteDisambiguated: deleteDisambiguated, onCompletionContextChange: onCompletionContextChange, cols: cols, terminalRows: terminalRows, statusExpanded: statusExpanded, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, borderColor: borderColor, onDraftChange: onDraftChange, draftClearNonce: draftClearNonce, draftFill: draftFill, insertMode: insertMode, onNotice: onNotice }) }));
 }

package/dist/ui/Header.d.ts

@@ -23,6 +23,14 @@ interface HeaderProps {
      * forgets the prop silently teaching nothing.
      */
     kitHint?: boolean;
+    /**
+     * Whether the collapsed row teaches `ctrl+P` (quick-prompt-library D-15).
+     *
+     * DEFAULTS TO TRUE for the same reason `kitHint` does: the requirement is that the
+     * key be visible, and a default of `false` would leave the one caller that forgets
+     * the prop silently teaching nothing. `cfg.prompts.hint` is what turns it off.
+     */
+    promptsHint?: boolean;
 }
-export declare function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns, statusExpanded, scrolledLines, overlayOpen, kitHint }: HeaderProps): React.ReactElement;
+export declare function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns, statusExpanded, scrolledLines, overlayOpen, kitHint, promptsHint }: HeaderProps): React.ReactElement;
 export {};

package/dist/ui/Header.js

@@ -3,7 +3,7 @@ import { basename } from 'node:path';
 import { Box, Text } from 'ink';
 import { Logo } from './Logo.js';
 import { planHeaderHints, HEADER_HINT_LIMITS } from './layout/header-hints.js';
-export function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns = 80, statusExpanded = false, scrolledLines = 0, overlayOpen = false, kitHint = true }) {
+export function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns = 80, statusExpanded = false, scrolledLines = 0, overlayOpen = false, kitHint = true, promptsHint = true }) {
     // The right-hand hints are planned, not assembled (tui-branch-terminal-shortcut
     // 3.9 / D-11). `plan.text` is exactly `plan.cells` wide and already carries the
     // scroll chip's own trailing spacing, so this component can no longer clip a
@@ -14,7 +14,7 @@ export function Header({ cwd, provider, model, hasKey, variant, theme, caps, col
     // passes `true` always, because the requirement is that `ctrl+G` reveals the
     // key - and the user with no kits needs that hint most.
     const plan = planHeaderHints({
-        columns, statusExpanded, overlayOpen, scrolledLines, kitHint,
+        columns, statusExpanded, overlayOpen, scrolledLines, kitHint, promptsHint,
     });
     // THE TWO HALVES ARE SEPARATED BY CELLS, NOT BY LUCK (defect 12). The left half
     // is `wrap="truncate"`, which draws its ellipsis in the LAST cell it owns; with