@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/ui/overlays/kit-settings-state.js

@@ -0,0 +1,267 @@
+/**
+ * The settings screen's kit pages: manager rows, the editor draft, and the ONE
+ * reducer that turns intents into draft mutations (agent-model-kits §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * TWO REDUCERS, ONE PAGE AXIS. `modelProfileReducer` owns the profile pages and
+ * `kitReducer` owns kit data; both return the same `ModelProfileState`, so the
+ * screen still has exactly one state object and one Save button. The alternative
+ * - a second state machine inside `SettingsScreen.tsx`, which is already over the
+ * 1000-line cap - is what this module exists to avoid.
+ *
+ * NOTHING HERE WRITES ANYTHING: every action mutates the transaction draft and
+ * sets `dirty`. `Save` stays the only writer (F-7/F-10).
+ */
+import { KIT_LIMITS, createAgentKit, duplicateAgentKit, findKit, kitCandidate, kitSlotConnections } from '../../config/model-kits.js';
+import { resolveActiveKit } from '../../config/kit-resolution.js';
+import { emptyModelProfiles } from '../../config/model-profiles.js';
+/** The library the transaction would save, with a read error falling back to empty. */
+export function draftLibrary(state) {
+    return state.draft.profiles ?? emptyModelProfiles();
+}
+function kitsOf(state) { return draftLibrary(state).kits ?? []; }
+export function findKitInState(state, id) {
+    return id ? findKit(draftLibrary(state), id) : undefined;
+}
+/**
+ * Open the editor on an existing kit, or on a PREFILLED new one (§4.10).
+ *
+ * THE FIRST KIT IS NEVER A BLANK FORM (D-13): it starts from the three bindings
+ * this machine already runs, so "create a kit" is one rename and one Save. When
+ * no Main profile is bound the kit starts with an empty main slot and Save
+ * refuses - the picker's own `Create profile` action is where a profile is born,
+ * which keeps this module free of the profile-creating code path.
+ */
+export function openKitDraft(state, id) {
+    const existing = findKitInState(state, id);
+    if (existing) {
+        return { id: existing.id, name: existing.name, mainProfileId: existing.mainProfileId,
+            fastProfileId: existing.fastProfileId,
+            subagent: { ...existing.subagent }, slot: null };
+    }
+    const library = draftLibrary(state);
+    const team = state.draft.baseline.team;
+    return {
+        id: null,
+        name: `Kit ${kitsOf(state).length + 1}`,
+        mainProfileId: library.mainId ?? '',
+        // `fastId` alone is not enough: a tier that is switched OFF is off, and
+        // prefilling its endpoint would silently turn it back on at the first Save.
+        fastProfileId: state.draft.baseline.fast.enabled ? library.fastId ?? null : null,
+        subagent: { model: team.model, modelProfileId: team.modelProfileId ?? null },
+        slot: null,
+    };
+}
+function withDraft(state, kitDraft) {
+    return { ...state, kitDraft, error: undefined };
+}
+function saveKitDraft(state) {
+    const kitDraft = state.kitDraft;
+    if (!kitDraft)
+        return state;
+    const name = [...kitDraft.name.trim()];
+    if (!name.length) {
+        return withDraft(state, { ...kitDraft, error: 'Name: enter a name for this kit.',
+            field: 'name' });
+    }
+    if (!kitDraft.mainProfileId) {
+        return withDraft(state, { ...kitDraft, error: 'Main profile: choose a profile.',
+            field: 'main' });
+    }
+    if (kitDraft.subagent.model === 'profile' && !kitDraft.subagent.modelProfileId) {
+        return withDraft(state, { ...kitDraft, error: 'Subagent: choose a profile.',
+            field: 'subagent' });
+    }
+    const library = draftLibrary(state);
+    const kits = library.kits ?? [];
+    const fields = { name: name.slice(0, KIT_LIMITS.nameMaxChars).join(''),
+        mainProfileId: kitDraft.mainProfileId, fastProfileId: kitDraft.fastProfileId,
+        subagent: { ...kitDraft.subagent } };
+    let merged;
+    if (kitDraft.id) {
+        const existing = kits.find((kit) => kit.id === kitDraft.id);
+        if (!existing)
+            return { ...state, page: 'kits', kitDraft: undefined };
+        merged = kits.map((kit) => (kit.id === kitDraft.id ? { ...existing, ...fields } : kit));
+    }
+    else {
+        if (kits.length >= KIT_LIMITS.maxKits) {
+            return withDraft(state, { ...kitDraft,
+                error: `Maximum ${KIT_LIMITS.maxKits} kits. Delete an unused kit first.` });
+        }
+        merged = [...kits, createAgentKit(fields)];
+    }
+    return { ...state, page: 'kits', kitDraft: undefined, dirty: true,
+        draft: { ...state.draft, profiles: { ...library, kits: merged } } };
+}
+/** Exit A: the kit's three slots become the draft's bindings (§4.2). */
+function applyKitToDraft(state, id, asDefault) {
+    const library = draftLibrary(state);
+    const kit = findKit(library, id);
+    if (!kit)
+        return state;
+    const patch = kitCandidate({ library, kit, ...(asDefault ? { defaultKitId: kit.id } : {}) });
+    return { ...state, dirty: true, page: 'kits', kitDraft: undefined,
+        draft: { ...state.draft,
+            profiles: patch.modelProfiles,
+            patch: { ...state.draft.patch, team: patch.team,
+                fast: { ...state.draft.patch.fast, ...patch.fast } },
+            // I-13: a kit that turns the tier off must NOT project the fast role.
+            activateRoles: [...new Set([...state.draft.activateRoles,
+                    'main', ...(kit.fastProfileId === null ? [] : ['fast'])])],
+            // The transaction now decides all three slots, so the session kit is done
+            // (§4.3 row 4). Leaving it held would make the save ambiguous.
+            sessionKit: null } };
+}
+function removeKit(state, id) {
+    const library = draftLibrary(state);
+    const remaining = (library.kits ?? []).filter((kit) => kit.id !== id);
+    const released = state.draft.sessionKit?.id === id ? null : state.draft.sessionKit;
+    return { ...state, page: 'kits', kitDraft: undefined, dirty: true,
+        draft: { ...state.draft, sessionKit: released,
+            profiles: { ...library, kits: remaining,
+                defaultKitId: (library.defaultKitId ?? null) === id ? null : library.defaultKitId } } };
+}
+/** Every kit-page intent, applied to the ONE draft. */
+export function kitReducer(state, action) {
+    const kitDraft = state.kitDraft;
+    switch (action.type) {
+        case 'kit-open':
+            return { ...state, page: 'kit-edit', error: undefined,
+                kitDraft: openKitDraft(state, action.id) };
+        case 'kit-name':
+            if (!kitDraft)
+                return state;
+            // Control characters are stripped at the boundary rather than refused: a
+            // pasted name with a stray newline should become a name, not an error.
+            return withDraft(state, { ...kitDraft,
+                name: [...action.value.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')]
+                    .slice(0, KIT_LIMITS.nameMaxChars).join(''), error: undefined });
+        case 'kit-slot':
+            return kitDraft ? { ...state, page: 'kit-slot',
+                kitDraft: { ...kitDraft, slot: action.slot } } : state;
+        case 'kit-main':
+            return kitDraft ? { ...state, page: 'kit-edit',
+                kitDraft: { ...kitDraft, mainProfileId: action.id ?? '', slot: null, error: undefined } }
+                : state;
+        case 'kit-fast':
+            return kitDraft ? { ...state, page: 'kit-edit',
+                kitDraft: { ...kitDraft, fastProfileId: action.id, slot: null, error: undefined } } : state;
+        case 'kit-subagent':
+            return kitDraft ? { ...state, page: 'kit-edit', kitDraft: { ...kitDraft,
+                    subagent: { model: action.model, modelProfileId: action.modelProfileId },
+                    slot: null, error: undefined } } : state;
+        case 'kit-save': return saveKitDraft(state);
+        case 'kit-cancel': return { ...state, page: 'kits', kitDraft: undefined, error: undefined };
+        case 'kit-duplicate': {
+            const library = draftLibrary(state);
+            const original = findKit(library, action.id);
+            if (!original || (library.kits ?? []).length >= KIT_LIMITS.maxKits)
+                return state;
+            return { ...state, page: 'kits', dirty: true, draft: { ...state.draft,
+                    profiles: { ...library,
+                        kits: [...(library.kits ?? []), duplicateAgentKit(original, library.kits ?? [])] } } };
+        }
+        case 'kit-delete': return { ...state, page: 'kit-delete',
+            kitDraft: { ...(kitDraft ?? openKitDraft(state, action.id)), id: action.id } };
+        case 'kit-confirm-delete': return kitDraft?.id ? removeKit(state, kitDraft.id) : state;
+        case 'kit-apply': return applyKitToDraft(state, action.id, false);
+        case 'kit-default': return applyKitToDraft(state, action.id, true);
+        default: return state;
+    }
+}
+function shortConnection(connection) {
+    return connection ? `${connection.provider}:${connection.model}` : 'Profile missing';
+}
+function subagentSummary(connections, kit) {
+    if (kit.subagent.model === 'main')
+        return 'same as main';
+    if (kit.subagent.model === 'fast')
+        return 'fast tier';
+    return connections.subagent.name ? `profile ${connections.subagent.name}` : 'Profile missing';
+}
+/** Rows in library order, each with the markers the picker also uses (§4.5). */
+export function kitManagerRows(state) {
+    const library = draftLibrary(state);
+    return (library.kits ?? []).map((kit) => {
+        const connections = kitSlotConnections(library, kit);
+        const isDefault = (library.defaultKitId ?? null) === kit.id;
+        const inUse = state.draft.sessionKit?.id === kit.id;
+        const markers = [isDefault ? '[Default]' : '', inUse ? '[In use]' : '']
+            .filter(Boolean).join(' ');
+        const fast = kit.fastProfileId === null ? 'off' : shortConnection(connections.fast);
+        return {
+            id: kit.id,
+            label: `${markers ? `${markers} ` : ''}${kit.name}`,
+            summary: [shortConnection(connections.main), fast, subagentSummary(connections, kit)]
+                .join(' | '),
+            isDefault,
+            inUse,
+        };
+    });
+}
+/**
+ * Whether the kit this transaction opened on had already drifted (§4.8).
+ *
+ * READ FROM `liveBaseline`, i.e. the config the screen was opened over, because
+ * drift is a fact about the SESSION - the draft cannot change a connection
+ * without releasing the slot, so there is nothing newer to look at.
+ */
+function liveDrift(state, session) {
+    // THE DRAFT'S `held`, NOT `liveBaseline.sessionKit`: the transaction may already
+    // have given slots back, and the row has to describe THIS transaction.
+    const live = resolveActiveKit({ ...state.draft.liveBaseline, sessionKit: session });
+    return live.source === 'session' && live.modified;
+}
+/**
+ * The `Kit pack` root row's five states (§4.5 table, AC-27).
+ *
+ * READ FROM THE DRAFT, not from the live config: the row sits inside a
+ * transaction, and showing the saved state under a pending selection is how a
+ * settings screen lies to the user about what `Save` is going to do.
+ */
+export function kitPackRow(state) {
+    const library = draftLibrary(state);
+    const kits = library.kits ?? [];
+    const session = state.draft.sessionKit;
+    const sessionKit = session ? findKit(library, session.id) : undefined;
+    const defaultKit = findKit(library, library.defaultKitId ?? null);
+    const defaultClause = defaultKit ? `  (default: ${defaultKit.name})` : '';
+    if (sessionKit && session) {
+        const partial = session.held.length < 3;
+        const held = partial ? `: ${session.held.join('+')}` : '';
+        // THE SAME `~` THE CHIP SHOWS (D-12): dropping a slot is only ONE way to
+        // drift. The other is a connection that `/model`, `/fast` or `/team model`
+        // rewrote after the kit was applied, and a row that stayed silent about that
+        // would disagree with the status bar about the same session.
+        const drift = liveDrift(state, session) ? '~' : '';
+        return `${sessionKit.name}  [session${held}]${drift}${defaultClause}`;
+    }
+    if (defaultKit)
+        return `${defaultKit.name}  [default]`;
+    return kits.length ? 'Current setup' : 'Current setup  (no kit yet)';
+}
+/**
+ * The held slots' EFFECTIVE values (RV-P0-2).
+ *
+ * WITHOUT THIS the root page shows the file's bindings while the header shows the
+ * kit's, and the only conclusion available to the user is that one of them is
+ * broken. `Enter` on any of these rows writes an explicit choice, which releases
+ * that slot - so "what you see is what you change" stays true.
+ */
+export function heldSlots(state) {
+    const session = state.draft.sessionKit;
+    const kit = session ? findKitInState(state, session.id) : undefined;
+    if (!session || !kit) {
+        return { kitName: null, held: [], mainId: null, fastId: null, subagent: null };
+    }
+    const held = session.held;
+    return {
+        kitName: kit.name,
+        held,
+        mainId: held.includes('main') ? kit.mainProfileId : null,
+        fastId: held.includes('fast') ? kit.fastProfileId : null,
+        subagent: held.includes('subagent') ? { ...kit.subagent } : null,
+    };
+}

package/dist/ui/overlays/model-profile-state.d.ts

@@ -1,7 +1,9 @@
 import { type ModelProfile, type ModelProfilesConfig, type ModelRole } from '../../config/model-profiles.js';
+import type { AgentKit } from '../../config/model-kits.js';
 import type { ModelSettingsDraft } from '../../config/model-profile-store.js';
 import type { SubagentModelMode } from '../../team/model.js';
-export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm';
+import type { KitDraft } from './kit-settings-state.js';
+export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm' | 'kits' | 'kit-edit' | 'kit-slot' | 'kit-delete';
 /**
  * Which role a PROFILE PICKER page is choosing for.
  *
@@ -9,8 +11,13 @@ export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' |
  * `'main' | 'fast'` because it is the type basis of the config layer's
  * `${role}Id` template keys - widening it would invent a `subagentId` library
  * key nothing reads. The subagent picker writes `draft.patch.team` instead.
+ *
+ * `'binding'` IS A KIT SLOT CHOOSER (agent-model-kits §4.5): a plain profile
+ * list with no `Current custom` row, no built-in rows and one `Create profile`
+ * action. A kit slot can only ever name a profile, so offering "no profile" as a
+ * choice there would be offering an invalid kit.
  */
-export type ProfilePickerRole = ModelRole | 'subagent';
+export type ProfilePickerRole = ModelRole | 'subagent' | 'binding';
 /** The picker's built-in `Fast tier model` row; never a profile id on disk. */
 export declare const SUBAGENT_FAST_ROW_ID = "__fast__";
 export interface ProfileEditorDraft {
@@ -30,13 +37,27 @@ export interface ModelProfileState {
     page: ProfilePage;
     role: ProfilePickerRole;
     editor?: ProfileEditorDraft;
-    returnPage: 'picker' | 'manager';
+    /**
+     * Where the editor and the delete confirmation hand control back.
+     *
+     * `'kit-slot'` JOINS `'picker'` (agent-model-kits §4.5): the kit slot chooser
+     * is a profile picker too, and its `Create profile` action must return to the
+     * slot it was creating for rather than to the profile manager.
+     */
+    returnPage: 'picker' | 'manager' | 'kit-slot';
     bindNew: boolean;
     dirty: boolean;
     error?: string;
     deleteId?: string;
     /** Who referenced the entry being deleted ('Main + Subagent', or ''). */
     deleteUsers?: string;
+    /**
+     * The kit editor's own draft (agent-model-kits §4.5), owned by `kitReducer`.
+     *
+     * ONE FIELD, NOT A SECOND STATE OBJECT: the page axis stays shared, so `Save`
+     * and `Esc` mean the same thing on every page of this screen.
+     */
+    kitDraft?: KitDraft;
 }
 export type ModelProfileAction = {
     type: 'page';
@@ -90,6 +111,8 @@ export declare function finishProfileEditor(editor: ProfileEditorDraft): {
 };
 /** Make an isolated root draft; opening the screen never mutates live config. */
 export declare function createModelProfileState(draft: ModelSettingsDraft): ModelProfileState;
+/** The kits whose three slots name `id`, for the delete confirmation (D-9). */
+export declare function kitsUsingProfile(profiles: ModelProfilesConfig | undefined, id: string): AgentKit[];
 /** Describe references using text so ASCII and no-color modes remain usable. */
 export declare function profileUsers(profiles: ModelProfilesConfig | undefined, id: string, subagentProfileId?: string | null): string;
 /**

package/dist/ui/overlays/model-profile-state.js

@@ -41,10 +41,38 @@ export function createModelProfileState(draft) {
     return { draft: copy, page: 'root', role: 'main', returnPage: 'manager',
         bindNew: false, dirty: false };
 }
+/** The kits whose three slots name `id`, for the delete confirmation (D-9). */
+export function kitsUsingProfile(profiles, id) {
+    return (profiles?.kits ?? []).filter((kit) => kit.mainProfileId === id
+        || kit.fastProfileId === id
+        || (kit.subagent.model === 'profile' && kit.subagent.modelProfileId === id));
+}
+/**
+ * Drop `slot` from the session kit (§4.3 row 2 / AC-38).
+ *
+ * THE DRAFT IS NARROWED HERE, NOT ONLY AT SAVE TIME. `releasedSlots` already
+ * strips the same slot from the transaction before it commits, but the ROOT PAGE
+ * paints the kit's effective value for every HELD slot - so without this line a
+ * user picks a profile and the row keeps showing the one they just replaced,
+ * which is the most confusing thing a settings screen can do. Releasing the last
+ * slot ends the kit: `held: []` is not a state any surface can render.
+ */
+function releaseHeldSlot(draft, slot) {
+    const current = draft.sessionKit;
+    if (!current || !current.held.includes(slot))
+        return draft;
+    const held = current.held.filter((item) => item !== slot);
+    return { ...draft, sessionKit: held.length ? { id: current.id, held } : null };
+}
 /** Describe references using text so ASCII and no-color modes remain usable. */
 export function profileUsers(profiles, id, subagentProfileId) {
+    // THE KITS ARE REFERENCES TOO (D-9 / RV-P2-6): "Main + kit "Deep work"" is what
+    // makes the confirmation honest, because deleting this entry also deletes that
+    // kit. The empty case must stay empty - a leading ` + ` is what a naive
+    // `join` after an unconditional push produces.
     return [profiles?.mainId === id ? 'Main' : '', profiles?.fastId === id ? 'Fast' : '',
-        subagentProfileId === id ? 'Subagent' : '']
+        subagentProfileId === id ? 'Subagent' : '',
+        ...kitsUsingProfile(profiles, id).map((kit) => `kit "${kit.name}"`)]
         .filter(Boolean).join(' + ');
 }
 /**
@@ -155,14 +183,27 @@ export function modelProfileReducer(state, action) {
                         ? { model: 'fast', modelProfileId: null }
                         : { model: 'profile', modelProfileId: action.id };
                 return { ...state, page: 'root', dirty: true, error: undefined,
-                    draft: { ...state.draft, patch: { ...state.draft.patch, team } } };
+                    draft: releaseHeldSlot({ ...state.draft,
+                        patch: { ...state.draft.patch, team } }, 'subagent') };
             }
+            // `'binding'` NEVER REACHES THIS REDUCER: a kit slot's choice is applied
+            // by `kitReducer` (`kit-main` / `kit-fast`), because the value belongs to
+            // an editor draft rather than to a `${role}Id` library key. Returning the
+            // state unchanged is the honest answer to an impossible action.
+            if (action.role === 'binding')
+                return state;
             return { ...state, page: 'root', dirty: true, error: undefined,
-                draft: { ...state.draft, profiles: { ...library, [`${action.role}Id`]: action.id },
-                    activateRoles: [...new Set([...state.draft.activateRoles, action.role])] } };
+                draft: releaseHeldSlot({ ...state.draft,
+                    profiles: { ...library, [`${action.role}Id`]: action.id },
+                    activateRoles: [...new Set([...state.draft.activateRoles, action.role])] }, action.role) };
         }
         case 'edit': return { ...state, editor: createProfileEditor(action.profile), page: 'editor',
-            returnPage: state.page === 'picker' ? 'picker' : 'manager',
+            // A PROFILE BORN IN A KIT SLOT RETURNS TO THAT SLOT (§4.5): the picker's
+            // `Create profile` action is the only way to invent one and it is offered on
+            // the kit's slot chooser - landing in the profile MANAGER there would
+            // abandon the half-built kit behind a page the user never asked for.
+            returnPage: state.page === 'picker' || state.page === 'kit-slot'
+                ? state.page : 'manager',
             bindNew: action.bindNew ?? false, error: undefined };
         case 'editor-field': return editField(state, action);
         case 'retain-key': return state.editor?.original.apiKey ? { ...state,
@@ -206,17 +247,29 @@ export function modelProfileReducer(state, action) {
             // when it named THIS entry. `removeModelProfile`'s throw stays as the
             // bottom-line defense - the UI has already unbound, so it cannot fire
             // on this path.
+            //
+            // AND THE KITS GO WITH IT (agent-model-kits D-9 / I-8): a kit naming a
+            // deleted profile can neither be applied nor repaired from any screen, so
+            // leaving it behind would be leaving a permanent error. The confirmation
+            // page has already named them, so this is the action the user agreed to.
+            const doomed = kitsUsingProfile(library, id);
+            const defaultKitKept = doomed.some((kit) => kit.id === (library.defaultKitId ?? null))
+                ? null : library.defaultKitId;
+            const sessionReleased = doomed.some((kit) => kit.id === state.draft.sessionKit?.id)
+                ? null : state.draft.sessionKit;
             const profiles = {
                 ...library,
                 mainId: library.mainId === id ? null : library.mainId,
                 fastId: library.fastId === id ? null : library.fastId,
                 entries: library.entries.filter((entry) => entry.id !== id),
+                kits: (library.kits ?? []).filter((kit) => !doomed.includes(kit)),
+                defaultKitId: defaultKitKept,
             };
             const teamReset = draftSubagentProfileId(state.draft) === id
                 ? { team: { model: 'main', modelProfileId: null } }
                 : {};
             return { ...state, page: 'manager', dirty: true,
-                draft: { ...state.draft, profiles,
+                draft: { ...state.draft, profiles, sessionKit: sessionReleased,
                     patch: { ...state.draft.patch, ...teamReset } },
                 deleteId: undefined, deleteUsers: undefined,
                 // No orphan editor for a deleted entry (3.7).

package/dist/ui/overlays/prompt-library-state.d.ts

@@ -0,0 +1,162 @@
+/**
+ * The prompt manager's state machine and view models (quick-prompt-library §4.4).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`. Every sentence the
+ * user reads comes from `prompts/copy.ts`; nothing in this file may hold a literal
+ * non-ASCII byte.
+ *
+ * WHY A PURE REDUCER AND NOT `useState` INSIDE THE COMPONENT: the page stack has two
+ * transitions that are easy to get wrong and impossible to see on screen - "the
+ * second Esc discards, the first does not" and "the intent is consumed exactly
+ * once" - and both are assertions, not screenshots. Everything below can be driven
+ * from a test with no Ink mounted.
+ */
+import type { PromptDraftInput, PromptDraftVerdict, PromptEditorDraft, PromptLibrary, PromptLibraryEntry, PromptWriteError, QuickPrompt } from '../../prompts/types.js';
+export type PromptLibraryPage = 'list' | 'editor' | 'delete';
+/** The six rows `Tab` cycles on the editor page, in visual order. */
+export declare const PROMPT_EDITOR_FIELDS: readonly ["title", "content", "description", "tags", "save", "cancel"];
+export type PromptEditorField = (typeof PROMPT_EDITOR_FIELDS)[number];
+export interface PromptLibraryState {
+    page: PromptLibraryPage;
+    /** Focus index on the list page (clamped by the view). */
+    index: number;
+    /**
+     * Id the focus should land on when the list is next drawn.
+     *
+     * BY ID, NEVER BY POSITION: a create appends and an edit does not move the entry,
+     * but a delete shifts every row after it, and "focus row 3" would then point at a
+     * different prompt than the one the user was working on.
+     */
+    focusId: string | null;
+    draft: PromptEditorDraft;
+    /** The entry the draft was seeded from, so `dirty` is a comparison, not a guess. */
+    baseline: PromptEditorDraft | null;
+    /** The first Esc on a dirty editor arms the discard; any edit disarms it. */
+    escArmed: boolean;
+    pendingDeleteId: string | null;
+    error: PromptWriteError | null;
+    /** The row that should own focus after a refusal (D-12). */
+    errorField: PromptEditorField | null;
+    /** Highest intent nonce this overlay has acted on (I-8). */
+    consumedIntentNonce: number;
+}
+export type PromptLibraryAction = {
+    type: 'init';
+    entry: PromptLibraryEntry;
+    library: PromptLibrary;
+    nonce: number;
+} | {
+    type: 'list';
+    focusId?: string;
+} | {
+    type: 'focus';
+    index: number;
+} | {
+    type: 'create';
+    seed?: {
+        title?: string;
+        content?: string;
+    };
+} | {
+    type: 'edit';
+    id: string;
+    library: PromptLibrary;
+} | {
+    type: 'delete';
+    id: string;
+} | {
+    type: 'draft';
+    patch: Partial<PromptEditorDraft>;
+} | {
+    type: 'commit';
+    id: string | null;
+} | {
+    type: 'failed';
+    code: PromptWriteError;
+    field?: PromptEditorField;
+} | {
+    type: 'esc';
+} | {
+    type: 'cancelled';
+};
+/** A new, empty draft. `id: null` is what makes `Save` a create rather than an update. */
+export declare const EMPTY_PROMPT_DRAFT: PromptEditorDraft;
+export declare const INITIAL_PROMPT_LIBRARY_STATE: PromptLibraryState;
+/** The editable projection of a stored entry. */
+export declare function draftFromEntry(entry: QuickPrompt): PromptEditorDraft;
+/** A create draft seeded from a command (`/prompts add title :: body`). */
+export declare function seededDraft(seed?: {
+    title?: string;
+    content?: string;
+}): PromptEditorDraft;
+/** Structural equality is enough: every field is a string or a boolean. */
+export declare function draftIsDirty(draft: PromptEditorDraft, baseline: PromptEditorDraft | null): boolean;
+/**
+ * Validate a draft and turn it into what the store accepts (D-12).
+ *
+ * THE VALIDATOR IS `store.ts`'S, not a second copy here: the sentence the editor
+ * shows and the rule the write applies have to be the same rule, or a user can be
+ * told a title is fine by the form and refused by the store.
+ */
+export declare function finishPromptEditor(draft: PromptEditorDraft): PromptDraftVerdict;
+/** Index of the first focusable row, for a refusal that named a field. */
+export declare function fieldIndex(field: PromptEditorField | null): number;
+/**
+ * The reducer.
+ *
+ * `init` is the ONLY action that can jump straight to the editor or the delete page:
+ * that is what makes `/prompts edit 2` land where it should (D-21). The intent's
+ * nonce is stored as `consumedIntentNonce` by the component before dispatching, so a
+ * replayed intent is a no-op at the component, not a second edit here.
+ */
+export declare function promptLibraryReducer(state: PromptLibraryState, action: PromptLibraryAction, library: PromptLibrary): PromptLibraryState;
+export interface PromptLibraryRow {
+    id: string;
+    /** One-line render text: the title plus its markers. The caret is the component's. */
+    label: string;
+    markers: {
+        favorite: boolean;
+        hasTags: boolean;
+        uses: number;
+    };
+    /** Body length in code points; the detail block and the delete page share it. */
+    chars: number;
+}
+/** `1.2k` for anything a fixed-width column cannot show in full. */
+export declare function formatCount(count: number): string;
+/** `3d ago` / `2h ago` / `just now`. Deliberately coarse: it is a hint, not a clock. */
+export declare function formatAgo(timestamp: number | undefined, now: number): string;
+/**
+ * The list, one row per entry, in the library's own order.
+ *
+ * DUPLICATE TITLES GET AN ID PREFIX (I-2), exactly as `kit-picker-state.ts` does for
+ * duplicate kit names: two rows reading the same words make `Enter` a coin flip.
+ */
+export declare function libraryRows(library: PromptLibrary): PromptLibraryRow[];
+/**
+ * The detail block under the list: at most `detailMaxLines` rows, fixed shape.
+ *
+ * FIXED, because `OverlayFrame`'s window is shared with the list (D-16): a body that
+ * participated in row height would squeeze six prompts into two visible rows. The
+ * full text has exactly one home, and it is the editor.
+ */
+export declare function libraryDetail(row: PromptLibraryRow | undefined, library: PromptLibrary, cols: number, now?: number): string[];
+/**
+ * The list page's footer.
+ *
+ * THE LAST CLAUSE IS ALWAYS THE WAY OUT (§9.5): a narrow terminal clips from the
+ * left, so the reader always keeps `Esc close`. The reorder keys are named here
+ * rather than in the row above it because they are the one affordance a user cannot
+ * discover by pressing a key they already know.
+ */
+export declare function libraryHint(state: PromptLibraryState, count: number): string;
+/** The delete page's four lines: what it is, how big, and what it costs. */
+export declare function deleteDetail(library: PromptLibrary, id: string | null): string[];
+/**
+ * The draft as the store accepts it.
+ *
+ * THE TAGS FIELD IS PARSED HERE, ONCE, and nowhere else: the editor edits a raw
+ * string, the store validates a `string[]`, and a second parser between them is how
+ * `a,b` and `a b` come to mean different things depending on which surface saved it.
+ */
+export declare function draftToInput(draft: PromptEditorDraft): PromptDraftInput;