@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/ui/overlays/KitManager.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Settings > Kit pack: the manager page (agent-model-kits §4.5 / D-9).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * CRUD LIVES HERE AND NOWHERE ELSE: `New kit` and `e` open the editor, `d` asks
+ * a confirmation that NAMES the consequences, `s` runs exit A (three slots plus
+ * the persisted pointer, because a default that only moved a pointer would not
+ * be in effect at the next launch - RV-P0-3), and `Enter` applies a kit to the
+ * transaction draft. Nothing on this page writes the config file.
+ */
+import { useState } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { clipProfileText, useProfileScroll } from './ModelProfilePicker.js';
+/** `New kit` first, then one row per kit, then the three actions. */
+const NEW_KIT = 'New kit';
+const ACTIONS = ['Duplicate', 'Delete', 'Set default'];
+export function KitManager(props) {
+    const glyphs = pickGlyphs(props.caps);
+    const [index, setIndex] = useState(0);
+    // NULL, NOT THE FIRST KIT: `selected` is "the last kit the cursor was on", and
+    // starting it at `rows[0]` would let `d` on the `New kit` row delete a kit the
+    // user never pointed at.
+    const [selected, setSelected] = useState(null);
+    const count = props.rows.length + 1 + ACTIONS.length;
+    const cursor = Math.min(index, count - 1);
+    const focused = props.rows[cursor - 1];
+    const offset = useProfileScroll(props, cursor);
+    const current = focused?.id ?? selected;
+    function action(name) {
+        if (!current)
+            return;
+        if (name === 'Duplicate')
+            props.dispatch({ type: 'kit-duplicate', id: current });
+        if (name === 'Delete')
+            props.dispatch({ type: 'kit-delete', id: current });
+        // EXIT A, NOT A POINTER WRITE (RV-P0-3): the three slots and the pointer move
+        // together, because "the default" IS the disk binding (D-13).
+        if (name === 'Set default')
+            props.dispatch({ type: 'kit-default', id: current });
+    }
+    useInput((input, key) => {
+        if (props.isActive === false)
+            return;
+        if (key.escape) {
+            props.onBack();
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            const next = (cursor - 1 + count) % count;
+            setIndex(next);
+            if (props.rows[next - 1])
+                setSelected(props.rows[next - 1].id);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            const next = (cursor + 1) % count;
+            setIndex(next);
+            if (props.rows[next - 1])
+                setSelected(props.rows[next - 1].id);
+            return;
+        }
+        if (key.return) {
+            if (cursor === 0) {
+                props.dispatch({ type: 'kit-open', id: null });
+                return;
+            }
+            if (focused) {
+                props.dispatch({ type: 'kit-apply', id: focused.id });
+                return;
+            }
+            action(ACTIONS[cursor - 1 - props.rows.length]);
+            return;
+        }
+        if (key.ctrl || key.meta)
+            return;
+        const letter = input.toLowerCase();
+        // `e` opens the focused kit; `d` and `s` are the two destructive/intent-bearing
+        // single keys. ALL THREE require a focused KIT ROW, so none of them can fire
+        // from `New kit` or from the action rows at the bottom.
+        if (!focused)
+            return;
+        if (letter === 'e') {
+            props.dispatch({ type: 'kit-open', id: focused.id });
+            return;
+        }
+        if (letter === 'd') {
+            props.dispatch({ type: 'kit-delete', id: focused.id });
+            return;
+        }
+        if (letter === 's')
+            action('Set default');
+    });
+    const lines = [NEW_KIT, ...props.rows.map((row) => `${row.label}  ${row.summary}`),
+        ...ACTIONS];
+    const rows = lines.map((line, at) => (_jsx(Text, { wrap: "truncate", color: at === cursor ? props.theme.accent : props.theme.muted, children: `${at === cursor ? glyphs.caret : ' '} ${clipProfileText(line, props.cols - 8)}` }, at)));
+    if (!props.rows.length) {
+        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: clipProfileText('No kits yet. Press Enter on New kit to build one from this setup.', props.cols - 8) }, "empty"));
+    }
+    return _jsx(OverlayFrame, { ...props, title: props.error ?? 'Agent kits', hint: "Enter apply | e edit | d delete | s set default | Esc back", rows: rows, scrollOffset: offset });
+}

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

@@ -0,0 +1,49 @@
+/**
+ * The Agent-kit picker: `ctrl+K` (agent-model-kits §4.6 / D-10 / D-11).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * A LIST PLUS A DETAIL BLOCK, not one row per kit with three columns: three
+ * connections never fit on a 72-column terminal, and the `OverlayFrame` detail
+ * idiom is how this package already says everything that does not fit in a row
+ * (`ModelProfilePicker`, the compaction card). The list carries names and
+ * markers only, so the choice stays scannable at any width.
+ *
+ * THE OVERLAY IS READ-ONLY (R-11): Enter applies for this session, Esc leaves
+ * everything as it was. That is what makes moving `killToEnd` off `Ctrl+K`
+ * (D-15) a one-time surprise instead of a risk - a user who presses the old
+ * key gets a reversible screen, not a deleted line.
+ */
+import React from 'react';
+import type { ModelProfilesConfig } from '../../config/model-profiles.js';
+import type { CliConfig } from '../../config/schema.js';
+import type { ActiveKit } from '../../config/kit-resolution.js';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import { type KitConnectionsSource } from './kit-picker-state.js';
+export interface KitPickerProps {
+    isActive?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+    cols: number;
+    maxRows: number;
+    scrollOffset: number;
+    onScrollClamp?: (offset: number) => void;
+    library?: ModelProfilesConfig | undefined;
+    config: CliConfig;
+    /**
+     * The config file's bindings, for the `Current setup` detail block (§4.6).
+     *
+     * OMITTED BY EMBEDDED HOSTS AND TESTS, in which case the block falls back to
+     * `config` - which is exactly right when no kit is in effect, since the live
+     * config then IS the file.
+     */
+    diskConfig?: KitConnectionsSource | undefined;
+    active: ActiveKit;
+    /** Only the APPLY is refused while work is in flight; browsing still works. */
+    busy: boolean;
+    /** `null` = `Current setup`, i.e. release the session kit. */
+    onChoose: (kitId: string | null) => void;
+    onClose: () => void;
+}
+export declare function KitPicker(props: KitPickerProps): React.ReactElement;

package/dist/ui/overlays/KitPicker.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The Agent-kit picker: `ctrl+K` (agent-model-kits §4.6 / D-10 / D-11).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * A LIST PLUS A DETAIL BLOCK, not one row per kit with three columns: three
+ * connections never fit on a 72-column terminal, and the `OverlayFrame` detail
+ * idiom is how this package already says everything that does not fit in a row
+ * (`ModelProfilePicker`, the compaction card). The list carries names and
+ * markers only, so the choice stays scannable at any width.
+ *
+ * THE OVERLAY IS READ-ONLY (R-11): Enter applies for this session, Esc leaves
+ * everything as it was. That is what makes moving `killToEnd` off `Ctrl+K`
+ * (D-15) a one-time surprise instead of a risk - a user who presses the old
+ * key gets a reversible screen, not a deleted line.
+ */
+import { useState } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { clipProfileText, useProfileScroll } from './ModelProfilePicker.js';
+import { kitDetail, kitPickHint, kitRows, NO_KITS_HINT } from './kit-picker-state.js';
+export function KitPicker(props) {
+    const rows = kitRows({ library: props.library, active: props.active });
+    const glyphs = pickGlyphs(props.caps);
+    const [index, setIndex] = useState(0);
+    const count = rows.length;
+    const cursor = Math.min(index, count - 1);
+    const focused = rows[cursor];
+    const offset = useProfileScroll(props, cursor);
+    const hasKits = (props.library?.kits ?? []).length > 0;
+    const body = rows.map((row, at) => (_jsx(Text, { wrap: "truncate", color: at === cursor ? props.theme.accent : props.theme.muted, children: `${at === cursor ? glyphs.caret : ' '} ${clipProfileText(row.label, props.cols - 8)}` }, row.id ?? 'current')));
+    if (!hasKits) {
+        body.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: clipProfileText(NO_KITS_HINT, props.cols - 8) }, "empty"));
+    }
+    // THE DETAIL BLOCK DESCRIBES THE FOCUSED ROW ONLY. Shown last so a narrow
+    // terminal clips the detail, never the choice.
+    for (const [at, line] of kitDetail({ row: focused, library: props.library,
+        config: props.config, diskConfig: props.diskConfig }).entries()) {
+        body.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: clipProfileText(`  ${line}`, props.cols - 8) }, `detail-${at}`));
+    }
+    useInput((_input, key) => {
+        if (props.isActive === false)
+            return;
+        if (key.escape) {
+            props.onClose();
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift))
+            setIndex((cursor - 1 + count) % count);
+        else if (key.downArrow || key.tab)
+            setIndex((cursor + 1) % count);
+        else if (key.return)
+            props.onChoose(focused.id);
+    });
+    return _jsx(OverlayFrame, { title: props.busy ? 'Agent kits (running)' : 'Agent kits', hint: kitPickHint({ busy: props.busy, hasKits }), rows: body, scrollOffset: offset, onScrollClamp: props.onScrollClamp, maxRows: props.maxRows, cols: props.cols, theme: props.theme, caps: props.caps });
+}

package/dist/ui/overlays/ModelProfilePicker.js

@@ -64,7 +64,12 @@ function usePickerState(props) {
     const actions = props.manager ? ['New', 'Edit', 'Duplicate', 'Delete'] : ['Create profile'];
     // THE SUBAGENT PICKER swaps the `Current custom` row for TWO built-in rows:
     // `Same as main` (selection id null) and `Fast tier model` (the sentinel).
-    const prefix = props.role === 'subagent' ? 2 : props.manager ? 0 : 1;
+    //
+    // THE BINDING PICKER HAS NEITHER (agent-model-kits §4.5): a kit slot can only
+    // name a profile, so `prefix` is 0 there even though it is a selection page -
+    // "no profile" is not a choice a kit may make.
+    const prefix = props.role === 'subagent' ? 2 : props.role === 'binding' ? 0
+        : props.manager ? 0 : 1;
     const count = entries.length + prefix + actions.length;
     const cursor = Math.min(index, count - 1);
     const focused = entries[cursor - prefix];
@@ -89,7 +94,7 @@ function usePickerInput(props, state) {
                 return;
             }
         }
-        else if (!props.manager && cursor === 0) {
+        else if (!props.manager && props.role !== 'binding' && cursor === 0) {
             props.onSelect(null);
             return;
         }
@@ -164,7 +169,10 @@ function usePickerInput(props, state) {
 function currentSelectionId(props) {
     if (props.selectedIdOverride !== undefined)
         return props.selectedIdOverride;
-    if (props.role === 'subagent')
+    // `subagent` and `binding` have no `${role}Id` key: their selection arrives
+    // through `selectedIdOverride`, so looking one up would read a key that does
+    // not exist on the library.
+    if (props.role === 'subagent' || props.role === 'binding')
         return undefined;
     return props.profiles[`${props.role}Id`];
 }
@@ -190,7 +198,7 @@ function buildPickerRows(props, state) {
         lines.push(`${current === SUBAGENT_FAST_ROW_ID ? '[Selected] ' : ''}Fast tier model`
             + `${props.fastTierOff === true ? '  (fast tier off)' : ''}`);
     }
-    else if (!props.manager)
+    else if (!props.manager && props.role !== 'binding')
         lines.push('Current custom');
     lines.push(...entries.map((entry) => profilePickerLabel(props, entry)));
     lines.push(...actions);
@@ -200,7 +208,8 @@ function buildPickerRows(props, state) {
     // The subagent picker has no `Current custom` row to describe; its
     // built-in rows already say everything there is to say.
     const detail = props.role === 'subagent' ? focused
-        : !props.manager && cursor === 0 ? props.customProfile : focused ?? selected;
+        : !props.manager && props.role !== 'binding' && cursor === 0 ? props.customProfile
+            : focused ?? selected;
     if (detail) {
         rows.push(_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: [detail.provider, ":", detail.model || '(not set)', " ", host(detail), detail === props.customProfile ? '' : ` #${detail.id}`] }, "detail"));
         rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: detail.apiKey ? 'Profile key: Configured'
@@ -215,7 +224,8 @@ export function ModelProfilePicker(props) {
     usePickerInput(props, state);
     return _jsx(OverlayFrame, { ...props, title: props.error ?? (props.manager ? 'Manage profiles'
             : props.role === 'subagent' ? 'Subagent model'
-                : `${props.role === 'main' ? 'Main' : 'Fast'} profile`), rows: buildPickerRows(props, state), scrollOffset: state.searching ? 0 : state.offset, hint: state.searching ? 'Type search | Enter done | Esc back'
+                : props.role === 'binding' ? 'Choose profile'
+                    : `${props.role === 'main' ? 'Main' : 'Fast'} profile`), rows: buildPickerRows(props, state), scrollOffset: state.searching ? 0 : state.offset, hint: state.searching ? 'Type search | Enter done | Esc back'
             : props.manager ? 'Enter action | e edit | d delete | Esc back'
                 : 'Enter select | e edit | d delete | Esc back' });
 }

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

@@ -0,0 +1,48 @@
+/**
+ * The prompt editor page (quick-prompt-library §4.4 / D-11).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`. Labels and the footer
+ * are English like every other overlay; every sentence that explains a REFUSAL comes
+ * from `prompts/copy.ts`.
+ *
+ * SELF-MANAGED `OverlayFrame`, not the controlled one. The two modes are a
+ * discriminated union (`children?: undefined`), and this page lays out a multi-row
+ * body field that owns its own scrolling: handing it over as `rows` would mean the
+ * frame counts a body's lines as rows and windows them again (P2-2).
+ *
+ * TWO WAYS TO SAVE, AND THE SECOND ONE IS NOT DECORATION. `Ctrl+S` is the fast path,
+ * and it is a byte a terminal can eat (XON/XOFF) - so `Tab` to the `Save` row and
+ * `Enter` must do exactly the same thing. That is what keeps "I cannot save" from
+ * being a bug a whole class of terminals can reproduce.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import { type PromptLibraryState } from './prompt-library-state.js';
+export interface PromptEditorPageProps {
+    isActive: boolean;
+    state: PromptLibraryState;
+    cols: number;
+    maxRows: number;
+    theme: Theme;
+    caps: TermCapabilities;
+    reducedMotion?: boolean;
+    /** One field changed; the page never owns the text, only the caret. */
+    onDraft: (patch: {
+        title?: string;
+        content?: string;
+        description?: string;
+        tags?: string;
+    }) => void;
+    onSave: () => void;
+    onEsc: () => void;
+    onCancel: () => void;
+}
+/**
+ * The page.
+ *
+ * The draft lives in the parent (the reducer owns it, so `Save` and `Esc` can see the
+ * same text); this component owns only what no other surface needs: which row has
+ * focus, and where each single-line field's caret sits.
+ */
+export declare function PromptEditorPage(props: PromptEditorPageProps): React.ReactElement;

package/dist/ui/overlays/PromptEditorPage.js

@@ -0,0 +1,227 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The prompt editor page (quick-prompt-library §4.4 / D-11).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`. Labels and the footer
+ * are English like every other overlay; every sentence that explains a REFUSAL comes
+ * from `prompts/copy.ts`.
+ *
+ * SELF-MANAGED `OverlayFrame`, not the controlled one. The two modes are a
+ * discriminated union (`children?: undefined`), and this page lays out a multi-row
+ * body field that owns its own scrolling: handing it over as `rows` would mean the
+ * frame counts a body's lines as rows and windows them again (P2-2).
+ *
+ * TWO WAYS TO SAVE, AND THE SECOND ONE IS NOT DECORATION. `Ctrl+S` is the fast path,
+ * and it is a byte a terminal can eat (XON/XOFF) - so `Tab` to the `Save` row and
+ * `Enter` must do exactly the same thing. That is what keeps "I cannot save" from
+ * being a bug a whole class of terminals can reproduce.
+ */
+import { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
+import { stepGrapheme } from '../editor-navigation.js';
+import { OverlayFrame, overlayBodyRows } from '../layout/OverlayFrame.js';
+import { promptErrorCopy } from '../../prompts/copy.js';
+import { PROMPT_EDITOR_FIELDS, fieldIndex, } from './prompt-library-state.js';
+import { EMPTY_TEXT_AREA, PromptTextArea, promptTextAreaReducer, } from './PromptTextArea.js';
+/** Columns the field labels occupy. Fixed, so the values line up. */
+const LABEL_CELLS = 10;
+/** Body rows the page reserves for chrome when the frame is generous. */
+const MIN_BODY_ROWS = 3;
+/** Text fields of the page, in the order Tab visits them. */
+function nextField(at, delta) {
+    const count = PROMPT_EDITOR_FIELDS.length;
+    return (at + delta + count) % count;
+}
+/**
+ * Which deletion key was pressed, if any.
+ *
+ * `key.delete` IS TREATED AS BACKSPACE, and the reason is measured rather than assumed:
+ * ink's parser reports the `0x7f` byte - which is what the BACKSPACE KEY sends on every
+ * terminal this product runs on - as `name: 'delete'`, and it hands the component an
+ * EMPTY `input` for both it and `ESC [ 3 ~`. The two are therefore indistinguishable at
+ * this layer, and the safe reading is the one the keyboard actually produces: backward.
+ * A forward-delete binding that fired on Backspace would delete the character the user
+ * was not looking at, and there is no undo in this field.
+ */
+function deletionKind(_input, key) {
+    return key.backspace === true || key.delete === true ? 'backspace' : null;
+}
+/**
+ * The page.
+ *
+ * The draft lives in the parent (the reducer owns it, so `Save` and `Esc` can see the
+ * same text); this component owns only what no other surface needs: which row has
+ * focus, and where each single-line field's caret sits.
+ */
+export function PromptEditorPage(props) {
+    const { state, cols, maxRows, theme, caps } = props;
+    const draft = state.draft;
+    const glyphs = pickGlyphs(caps);
+    const [focus, setFocus] = useState(0);
+    // THE CARET STARTS AT THE END OF EACH FIELD, which is where a user expects to append:
+    // starting at 0 would put every typed character in FRONT of the prefilled text, so an
+    // edit to `Clean code review` would read `FixClean code review`.
+    const [cursors, setCursors] = useState(() => ({
+        title: draft.title.length,
+        description: draft.description.length,
+        tags: draft.tags.length,
+    }));
+    const [content, setContent] = useState({
+        ...EMPTY_TEXT_AREA,
+        buffer: draft.content,
+        cursor: draft.content.length,
+    });
+    const field = PROMPT_EDITOR_FIELDS[Math.min(focus, PROMPT_EDITOR_FIELDS.length - 1)];
+    const bodyRows = Math.max(MIN_BODY_ROWS, overlayBodyRows(maxRows, cols) - 5);
+    const fieldCols = Math.max(8, cols - LABEL_CELLS - 6);
+    // A REFUSAL OWNS THE FOCUS (D-12): the store already names the row that failed, so the
+    // caret is moved there instead of leaving the user to read an error in a footer and
+    // work out which of four fields it is about. Keyed on `state.error`, so it fires once
+    // per distinct refusal rather than on every render.
+    useEffect(() => {
+        if (state.error === null)
+            return;
+        setFocus(fieldIndex(state.errorField));
+    }, [state.error, state.errorField]);
+    const editSingle = (name, text, key, deletion) => {
+        const value = draft[name];
+        const cursor = Math.min(cursors[name], value.length);
+        if (key.leftArrow || key.rightArrow) {
+            setCursors({
+                ...cursors,
+                [name]: stepGrapheme(value, cursor, key.leftArrow ? 'left' : 'right'),
+            });
+            return;
+        }
+        if (deletion === 'backspace') {
+            if (cursor <= 0)
+                return;
+            const from = stepGrapheme(value, cursor, 'left');
+            props.onDraft({ [name]: value.slice(0, from) + value.slice(cursor) });
+            setCursors({ ...cursors, [name]: from });
+            return;
+        }
+        if (text.length === 0)
+            return;
+        const next = value.slice(0, cursor) + text + value.slice(cursor);
+        props.onDraft({ [name]: next });
+        setCursors({ ...cursors, [name]: cursor + text.length });
+    };
+    const applyContent = (action) => {
+        const current = { ...content, buffer: draft.content };
+        const next = promptTextAreaReducer(current, action);
+        // COMPARED ON THE FIELDS, not on object identity: the reducer echoes its input object
+        // back for a no-op move, and that object is rebuilt on every keystroke - so an
+        // identity check would both hide the no-op and trigger a render for it.
+        if (next.buffer !== current.buffer || next.cursor !== current.cursor)
+            setContent(next);
+        if (next.buffer !== draft.content)
+            props.onDraft({ content: next.buffer });
+    };
+    useInput((input, key) => {
+        if (props.isActive === false)
+            return;
+        // BEFORE EVERYTHING: a refused save and a dirty Esc are both two-step states, and
+        // the accelerator that resolves them must not be swallowed by the text handling
+        // below. `Ctrl+S` is the same precedent `SettingsScreen.tsx` set.
+        if (key.ctrl && (input === 's' || input === 'S')) {
+            props.onSave();
+            return;
+        }
+        if (key.escape) {
+            props.onEsc();
+            return;
+        }
+        if (key.tab) {
+            setFocus(nextField(focus, key.shift ? -1 : 1));
+            return;
+        }
+        const clean = stripPasteFrames(stripEnterFrames(input));
+        if (field === 'save') {
+            if (key.return)
+                props.onSave();
+            return;
+        }
+        if (field === 'cancel') {
+            if (key.return)
+                props.onCancel();
+            return;
+        }
+        if (field === 'content') {
+            if (key.upArrow) {
+                applyContent({ type: 'up', cols: fieldCols });
+                return;
+            }
+            if (key.downArrow) {
+                applyContent({ type: 'down', cols: fieldCols });
+                return;
+            }
+            if (key.return || clean.includes('\n')) {
+                applyContent({ type: 'newline' });
+                return;
+            }
+            const contentDeletion = deletionKind(input, key);
+            if (contentDeletion !== null) {
+                applyContent({ type: contentDeletion });
+                return;
+            }
+            if (key.leftArrow) {
+                applyContent({ type: 'left' });
+                return;
+            }
+            if (key.rightArrow) {
+                applyContent({ type: 'right' });
+                return;
+            }
+            if (key.ctrl || key.meta)
+                return;
+            if (clean.length > 0)
+                applyContent({ type: 'insert', text: clean });
+            return;
+        }
+        // Single-line fields: Enter advances rather than saving, because there is nothing
+        // for a newline to mean in a one-line field.
+        if (key.return) {
+            setFocus(nextField(focus, 1));
+            return;
+        }
+        if (key.upArrow) {
+            setFocus(nextField(focus, -1));
+            return;
+        }
+        if (key.downArrow) {
+            setFocus(nextField(focus, 1));
+            return;
+        }
+        if (key.ctrl || key.meta)
+            return;
+        editSingle(field, clean, key, deletionKind(input, key));
+    });
+    /** One text field, or an action row. The caret marks the focused one. */
+    const row = (name) => {
+        const focused = field === name;
+        const caret = focused ? glyphs.caret : ' ';
+        if (name === 'save' || name === 'cancel') {
+            const label = name === 'save' ? 'Save' : 'Cancel';
+            return (_jsx(Text, { wrap: "truncate", color: focused ? theme.accent : theme.muted, children: `${caret} [ ${label} ]` }, name));
+        }
+        const label = name === 'title' ? 'Title' : name === 'content' ? 'Body'
+            : name === 'description' ? 'Note' : 'Tags';
+        const value = draft[name];
+        if (name === 'content') {
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { wrap: "truncate", color: focused ? theme.accent : theme.muted, children: `${caret} ${label.padEnd(LABEL_CELLS)}` }), _jsx(Box, { flexDirection: "column", paddingLeft: 2, children: _jsx(PromptTextArea, { state: { ...content, buffer: draft.content }, cols: fieldCols, rows: bodyRows, focused: focused, theme: theme, caps: caps, ...(props.reducedMotion === undefined ? {} : { reducedMotion: props.reducedMotion }) }) })] }, name));
+        }
+        const shown = value.length === 0 ? '(empty)' : value;
+        return (_jsx(Text, { wrap: "truncate", color: focused ? theme.accent : theme.muted, children: `${caret} ${label.padEnd(LABEL_CELLS)}${shown}` }, name));
+    };
+    const title = state.error === null
+        ? (draft.id === null ? 'New prompt' : 'Edit prompt')
+        : promptErrorCopy(state.error);
+    const hint = state.escArmed
+        ? 'Esc again discards the draft | Tab next field'
+        : 'Tab next field | Enter next line | Ctrl+S save | Esc close';
+    return (_jsxs(OverlayFrame, { title: title, hint: hint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, children: [_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [_jsx(Text, { color: draft.favorite ? theme.toolDone : theme.muted, children: draft.favorite ? '[fav] ' : '      ' }), `${[...draft.content].length} chars`] }), _jsx(Box, { flexDirection: "column", children: PROMPT_EDITOR_FIELDS.map((name) => row(name)) })] }));
+}

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

@@ -0,0 +1,37 @@
+/**
+ * The prompt manager: `Ctrl+P` (quick-prompt-library §4.4 / §6.4).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * A LIST PLUS A DETAIL BLOCK, the `KitPicker` idiom (F-17): three columns of prompt
+ * metadata never fit on a 72-column terminal, and the detail block is how this
+ * package already shows everything that does not fit in a row.
+ *
+ * THE OVERLAY OWNS NO DATA. Every mutation goes out through `onMutate`, and the new
+ * snapshot comes back through `library`. An overlay that patched its own copy would
+ * show a prompt the disk does not have (I-6), and the first time that happened the
+ * user would find out at the next launch.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { PromptLibrary, PromptLibraryIntent, PromptLibraryMutation, PromptMutationResult } from '../../prompts/types.js';
+export interface PromptLibraryOverlayProps {
+    isActive: boolean;
+    library: PromptLibrary;
+    /** D-21's one-shot hand-off; consumed at most once (I-8). */
+    intent?: PromptLibraryIntent;
+    cols: number;
+    maxRows: number;
+    scrollOffset: number;
+    onScrollClamp?: (offset: number) => void;
+    theme: Theme;
+    caps: TermCapabilities;
+    reducedMotion?: boolean;
+    /** The store, reached through `App` so this component stays a view. */
+    onMutate: (action: PromptLibraryMutation) => PromptMutationResult;
+    /** One-shot feedback (save, delete, write failure) for `App`'s toast channel. */
+    onNotice?: (level: 'info' | 'warn' | 'error', text: string) => void;
+    onClose: () => void;
+}
+export declare function PromptLibraryOverlay(props: PromptLibraryOverlayProps): React.ReactElement;