@aiwayds/dsh-tui-pi 0.26.0 → 0.28.0

package/lib/profile.js

@@ -0,0 +1,647 @@
+/**
+ * `/profile-switch` + `/profile-cfg` — user model profiles: named snapshots
+ * of the whole model configuration (default model + think level, every
+ * subagent's model/thinking) that switch in one step between contexts like
+ * work and personal.
+ *
+ * Layers, all on the select-panel framework (src/panels.ts):
+ *
+ *   1. `/profile-switch` switcher (TablePanel) — one row per profile (name |
+ *      default model | think | agents), Enter applies it to the live
+ *      selection AND the agent markdown files, Esc backs out.
+ *   2. `/profile-cfg` manager (TablePanel) — the roster: n new, d delete
+ *      (double-press confirm), Enter opens the profile's fields.
+ *   3. profile fields (FieldPanel) — model / think / agents rows plus the
+ *      s save-current, r rename, v review shortcuts.
+ *   4. agents sub-table (TablePanel) — every discovered agent's recorded
+ *      model/thinking; Enter picks through the SAME favorites/hidden model
+ *      table /model uses (pickModel with the shared PanelHost), i sets
+ *      explicit inherit, t edits think alone.
+ *
+ * Every edit persists to `$DSH_HOME/model-profiles.json` immediately
+ * (src/model-profiles.ts). Applying a profile writes the agent frontmatter
+ * files (updateAgentFrontmatter) and the default model through the same
+ * chain as /model: live bridge selection + persistDefaultModel.
+ */
+import { agentsDir, listAgentFiles, updateAgentFrontmatter, } from "./agent-manager.js";
+import { captureAgentsSnapshot, createProfile, deleteProfile, findProfile, formatProfileRoute, loadModelProfiles, modelProfilesPath, planAgentApply, profileReviewLines, readNearestProfilePin, removeProfilePin, renameProfile, saveModelProfiles, writeProfilePin, PROFILE_PIN_FILE, } from "./model-profiles.js";
+import { join } from 'node:path';
+import { persistDefaultModel } from "./session.js";
+import { openEffortPicker, pickModel } from "./selectors.js";
+import { EditField } from "./settings.js";
+import { autoColumns, FieldPanel, PanelHost, TablePanel, ViewerPanel, } from "./panels.js";
+import { ansiFg, BOLD, RESET } from "./theme/index.js";
+import { clipToWidth } from "./text.js";
+/** How long a `d` delete arm stays confirmable (double-press window). */
+const DELETE_CONFIRM_MS = 2500;
+/** The profile table columns: NAME/MODEL/THINK fit (capped), AGENTS right-aligned tail. */
+function profileColumns(profiles, current) {
+    return autoColumns([
+        { key: 'name', title: 'Profile', cap: 18 },
+        { key: 'model', title: 'Default model', cap: 36 },
+        { key: 'think', title: 'Think', cap: 10 },
+        { key: 'agents', title: 'Agents', align: 'right' },
+    ], profiles, (profile, key) => profileCell(profile, key, current));
+}
+/** Cell text for one profile table row; the current profile gets the ● mark. */
+function profileCell(profile, key, current) {
+    switch (key) {
+        case 'name': return current === profile.name ? `● ${profile.name}` : profile.name;
+        case 'model': return profile.defaultModel === undefined
+            ? '(not set)'
+            : `${profile.defaultModel.provider}/${profile.defaultModel.model}`;
+        case 'think': return profile.defaultModel?.reasoningEffort ?? 'default';
+        default: return String(Object.keys(profile.agents).length);
+    }
+}
+/** A profile's default route as a ModelSelection (the /model handler shape). */
+function routeToSelection(route) {
+    return {
+        provider: route.provider,
+        model: route.model,
+        ...(route.reasoningEffort !== undefined
+            ? { reasoningEffort: route.reasoningEffort }
+            : {}),
+    };
+}
+/** Record what a live selection says into a plain storable route. */
+function selectionToRoute(selection) {
+    return selection.reasoningEffort === undefined
+        ? { provider: selection.provider, model: selection.model }
+        : {
+            provider: selection.provider,
+            model: selection.model,
+            reasoningEffort: selection.reasoningEffort,
+        };
+}
+/**
+ * Apply `profile` end to end: default model + think level through the /model
+ * chain (live selection ref + persisted default; a profile without a default
+ * model leaves the current selection alone), every LISTED agent's
+ * frontmatter through the snapshot semantics (src/model-profiles.ts), then
+ * the current pointer and the store. Resolves the command summary text —
+ * failures ride along as ⚠ parts instead of aborting the rest.
+ */
+async function applyProfile(ctx, path, doc, profile, deps) {
+    const parts = [];
+    if (profile.defaultModel !== undefined) {
+        const selection = routeToSelection(profile.defaultModel);
+        deps.setSelection(selection);
+        const persistError = await persistDefaultModel(ctx, selection);
+        if (persistError !== undefined)
+            parts.push(`⚠ default model not persisted: ${persistError}`);
+    }
+    const { agents } = listAgentFiles(agentsDir());
+    let updated = 0;
+    const failed = [];
+    for (const { agent, updates } of planAgentApply(profile, agents)) {
+        const error = updateAgentFrontmatter(agent.path, updates);
+        if (error === undefined) {
+            agent.meta.model = updates.model ?? undefined;
+            agent.meta.thinking = updates.thinking ?? undefined;
+            updated++;
+        }
+        else {
+            failed.push(agent.meta.name);
+        }
+    }
+    if (failed.length > 0)
+        parts.push(`⚠ agents failed: ${failed.join(', ')}`);
+    doc.current = profile.name;
+    const saveError = saveModelProfiles(path, doc);
+    if (saveError !== undefined)
+        parts.push(`⚠ profile not saved: ${saveError}`);
+    const modelText = profile.defaultModel !== undefined
+        ? formatProfileRoute(profile.defaultModel)
+        : 'model unchanged';
+    return [`Profile → ${profile.name} · ${modelText} · agents ${String(updated)} updated`, ...parts]
+        .filter(part => part !== '')
+        .join(' · ');
+}
+/**
+ * Open the `/profile-switch` switcher. Resolves the apply summary when a
+ * profile was switched, or `undefined` when cancelled / nothing applied.
+ *
+ * `p` binds the CWD to the cursor profile (writes `.dsh-profile`, see
+ * src/model-profiles.ts) so every NEW session in this tree auto-loads it;
+ * pressing `p` on the already-bound profile unpins it again — unless the pin
+ * lives in an ancestor or was hand-decorated, which is reported in the
+ * status line instead. Enter keeps its global meaning: apply now AND persist
+ * the global default.
+ */
+export async function openProfileSwitcher(ctx, tui, theme, deps, restoreFocus) {
+    const path = modelProfilesPath();
+    const doc = loadModelProfiles(path);
+    const cwd = process.cwd();
+    let settle;
+    const host = new PanelHost(tui, theme, message => {
+        restoreFocus();
+        settle?.(`✘ failed to open the profile switcher: ${message}`);
+    });
+    return new Promise(resolve => {
+        settle = resolve;
+        // Enter can fire again while the async apply runs — resolve-once guard,
+        // the same settle discipline the pickers use.
+        let applying = false;
+        // Session-local status flash for the p-toggle outcome.
+        let pinStatus;
+        /** The nearest `.dsh-profile` binding for the cwd, resolved per render. */
+        const boundPin = () => readNearestProfilePin(cwd);
+        /**
+         * Show the table once through the host (a p-toggle swaps the whole panel:
+         * simplest way to refresh the `(dir)` markers, and PanelHost's
+         * show-new-then-hide-old keeps focus stable).
+         */
+        const showTable = () => {
+            const pinnedName = boundPin()?.name;
+            const table = new TablePanel(theme, {
+                title: `● Model profiles · ${PROFILE_PIN_FILE} here: ${pinnedName ?? 'none'}`,
+                columns: profileColumns(doc.profiles, doc.current),
+                rows: doc.profiles,
+                renderCell: (profile, column) => profileCell(profile, column.key, doc.current),
+                preselect: Math.max(0, doc.profiles.findIndex(profile => profile.name === doc.current)),
+                status: () => pinStatus,
+                onSelect: profile => { void switchTo(profile); },
+                onCancel: () => { host.close(); restoreFocus(); resolve(undefined); },
+                footer: '↑↓ navigate · Enter switch · p pin to this dir / unpin · Esc back',
+                shortcuts: { p: () => togglePin(table) },
+            });
+            host.open(table);
+        };
+        /** Bind/unbind the cwd to the cursor profile; re-show to refresh markers. */
+        const togglePin = (table) => {
+            const profile = table.selectedRow();
+            if (profile === undefined)
+                return;
+            const existing = boundPin();
+            if (existing !== undefined
+                && existing.name.toLowerCase() === profile.name.toLowerCase()
+                && existing.path === join(cwd, PROFILE_PIN_FILE)) {
+                const error = removeProfilePin(cwd, profile.name);
+                pinStatus = error === undefined ? `unpinned ${cwd}` : `✘ ${error}`;
+            }
+            else {
+                const error = writeProfilePin(cwd, profile.name);
+                if (error !== undefined)
+                    pinStatus = `✘ ${error}`;
+                else {
+                    const inheritedNote = existing !== undefined && existing.path !== join(cwd, PROFILE_PIN_FILE)
+                        ? ` (overrides ancestor pin "${existing.name}")`
+                        : '';
+                    pinStatus = `pinned "${profile.name}" → .dsh-profile${inheritedNote}`;
+                }
+            }
+            showTable();
+        };
+        // First mount; a mount failure has already settled through the host's
+        // error path (this promise resolves there, everything below is no-op).
+        showTable();
+        const switchTo = async (profile) => {
+            if (applying)
+                return;
+            applying = true;
+            const summary = await applyProfile(ctx, path, doc, profile, deps);
+            host.close();
+            restoreFocus();
+            // If this tree is pinned to a DIFFERENT profile, say so — the global
+            // default moved but new sessions HERE will still auto-load the pin.
+            const pinned = readNearestProfilePin(cwd);
+            const note = pinned !== undefined && pinned.name.toLowerCase() !== profile.name.toLowerCase()
+                ? ` · note: ${PROFILE_PIN_FILE} pins "${pinned.name}" — new sessions here stay on it`
+                : '';
+            resolve(`${summary}${note}`);
+        };
+    });
+}
+/**
+ * Open the `/profile-cfg` manager. Resolves a summary when anything changed,
+ * or `undefined` when the manager closed untouched. `preselect` jumps
+ * straight into one profile's fields window.
+ */
+export async function openProfileManager(ctx, tui, theme, deps, restoreFocus, preselect) {
+    const path = modelProfilesPath();
+    const doc = loadModelProfiles(path);
+    const changed = [];
+    let tableStatus;
+    let fieldsStatus;
+    let agentsStatus;
+    /** Armed double-press delete: profile name + when it was armed. */
+    let pendingDelete;
+    let pendingDeleteAt = 0;
+    let pendingPreselect = preselect;
+    let fieldsHandle;
+    let agentsHandle;
+    let agentsCursor;
+    /** Settles the manager promise (assigned inside the executor below). */
+    let settle;
+    const host = new PanelHost(tui, theme, message => {
+        restoreFocus();
+        settle?.(`✘ failed to open the profiles manager: ${message}`);
+    });
+    /** Persist the working doc; resolves a ✘ status line on failure. */
+    const persistDoc = () => {
+        const error = saveModelProfiles(path, doc);
+        return error === undefined ? undefined : `✘ could not save profiles: ${error}`;
+    };
+    /** Mark one profile as touched for the closing summary (first touch wins). */
+    const markChanged = (name) => {
+        if (!changed.includes(name))
+            changed.push(name);
+    };
+    return new Promise(resolve => {
+        settle = resolve;
+        const showTable = () => {
+            const preselectIndex = pendingPreselect === undefined
+                ? undefined
+                : doc.profiles.findIndex(profile => profile.name === pendingPreselect);
+            pendingPreselect = undefined;
+            const table = new TablePanel(theme, {
+                title: '● Model profiles — configure',
+                columns: profileColumns(doc.profiles, doc.current),
+                rows: doc.profiles,
+                renderCell: (profile, column) => profileCell(profile, column.key, doc.current),
+                preselect: preselectIndex !== undefined && preselectIndex >= 0 ? preselectIndex : undefined,
+                status: () => tableStatus,
+                footer: '↑↓ navigate · Enter open · n new · d delete · Esc back',
+                onSelect: profile => showFields(profile),
+                onCancel: closeManager,
+                shortcuts: {
+                    n: showNew,
+                    d: () => {
+                        const profile = table.selectedRow();
+                        if (profile === undefined)
+                            return;
+                        // Double-press confirm, time-boxed: the armed state must NOT
+                        // rebuild the table (a rebuild resets the cursor to row 0, so
+                        // the confirming press would target a different profile), and
+                        // the window expires so a stale arm can never fire one press
+                        // after the user navigated away and back.
+                        const armed = pendingDelete === profile.name
+                            && Date.now() - pendingDeleteAt < DELETE_CONFIRM_MS;
+                        if (armed) {
+                            pendingDelete = undefined;
+                            const error = deleteProfile(doc, profile.name);
+                            if (error !== undefined)
+                                tableStatus = `✘ ${error}`;
+                            else {
+                                tableStatus = persistDoc() ?? `deleted profile "${profile.name}"`;
+                                markChanged(`-${profile.name}`);
+                            }
+                            showTable();
+                        }
+                        else {
+                            pendingDelete = profile.name;
+                            pendingDeleteAt = Date.now();
+                            tableStatus = `press d again to delete "${profile.name}"`;
+                            tui.requestRender();
+                        }
+                    },
+                },
+            });
+            host.open(table);
+        };
+        const closeManager = () => {
+            host.close();
+            restoreFocus();
+            resolve(changed.length > 0 ? `Profiles updated: ${changed.join(', ')}` : undefined);
+        };
+        const showFields = (profile) => {
+            const content = [
+                `named model snapshot — switch with /profile-switch · applies ${agentsDir()}`,
+            ];
+            const agentsSet = Object.keys(profile.agents).length;
+            const fields = [
+                {
+                    key: 'model',
+                    value: profile.defaultModel === undefined
+                        ? '(not set — switching keeps the current model)'
+                        : formatProfileRoute(profile.defaultModel),
+                    editable: true,
+                },
+                {
+                    key: 'think',
+                    value: profile.defaultModel?.reasoningEffort ?? '(provider default)',
+                    editable: true,
+                },
+                { key: 'agents', value: `${String(agentsSet)} agent override(s) recorded`, editable: true },
+            ];
+            const view = new FieldPanel(theme, {
+                title: profileTitle(theme, profile, doc),
+                content,
+                fields,
+                status: () => fieldsStatus,
+                footer: '↑↓ field · Enter edit (m model · t think · a agents) · s save current · r rename · v review · Esc back',
+                shortcuts: {
+                    m: () => void changeModel(profile),
+                    t: () => void changeThink(profile),
+                    a: () => showAgentsTable(profile),
+                    s: () => saveFromCurrent(profile),
+                    r: () => showRename(profile),
+                    v: () => showReview(profile),
+                },
+                onEdit: index => {
+                    if (index === 0)
+                        void changeModel(profile);
+                    else if (index === 1)
+                        void changeThink(profile);
+                    else
+                        showAgentsTable(profile);
+                },
+                onCancel: () => showTable(),
+            });
+            fieldsHandle = host.open(view);
+        };
+        /** Commit path shared by model/think/agent edits: flash and re-show. */
+        const writeFields = (profile, status, message) => {
+            if (status !== undefined)
+                fieldsStatus = status;
+            else {
+                markChanged(profile.name);
+                fieldsStatus = message;
+            }
+            showFields(profile);
+        };
+        const changeModel = async (profile) => {
+            const current = profile.defaultModel === undefined ? undefined : routeToSelection(profile.defaultModel);
+            const picked = await pickModel(ctx, tui, theme, current, () => { }, host);
+            if (picked === undefined) {
+                showFields(profile);
+                return;
+            }
+            profile.defaultModel = selectionToRoute(picked);
+            const status = persistDoc();
+            writeFields(profile, status, `saved ${profile.name} default model → ${formatProfileRoute(profile.defaultModel)}`);
+        };
+        const changeThink = async (profile) => {
+            if (profile.defaultModel === undefined) {
+                fieldsStatus = '✘ no default model set — pick a model first (m)';
+                showFields(profile);
+                return;
+            }
+            const llm = ctx.get('llm');
+            if (llm === undefined) {
+                fieldsStatus = '✘ llm service unavailable';
+                showFields(profile);
+                return;
+            }
+            const { provider, model } = profile.defaultModel;
+            let efforts;
+            try {
+                efforts = (await llm.resolveModelInfo(provider, model)).reasoning?.efforts;
+            }
+            catch {
+                efforts = undefined;
+            }
+            if (efforts === undefined || efforts.length === 0) {
+                fieldsStatus = `✘ ${provider}/${model} exposes no think levels`;
+                showFields(profile);
+                return;
+            }
+            const currentEffort = profile.defaultModel.reasoningEffort;
+            const chosen = await openEffortPicker(tui, theme, efforts, currentEffort, () => { }, () => fieldsHandle?.hide());
+            if (chosen === undefined) {
+                showFields(profile);
+                return;
+            }
+            profile.defaultModel.reasoningEffort = chosen.effort === 'default' ? undefined : chosen.effort;
+            const status = persistDoc();
+            const thinkText = profile.defaultModel.reasoningEffort === undefined
+                ? 'provider default'
+                : `think ${String(profile.defaultModel.reasoningEffort)}`;
+            writeFields(profile, status, `saved ${profile.name} think → ${thinkText}`);
+        };
+        const saveFromCurrent = (profile) => {
+            const selection = deps.getSelection();
+            if (selection !== undefined)
+                profile.defaultModel = selectionToRoute(selection);
+            const { agents } = listAgentFiles(agentsDir());
+            profile.agents = captureAgentsSnapshot(agents);
+            const status = persistDoc();
+            const message = selection === undefined
+                ? `saved ${String(agents.length)} agent(s) into "${profile.name}" · no live model selection — default model kept`
+                : `saved current configuration into "${profile.name}" (model + ${String(agents.length)} agent(s))`;
+            writeFields(profile, status, message);
+        };
+        const showAgentsTable = (profile) => {
+            const { agents } = listAgentFiles(agentsDir());
+            const rows = agents.map(agent => ({ agent, entry: profile.agents[agent.meta.name] }));
+            const cell = (row, key) => {
+                switch (key) {
+                    case 'name': return row.agent.meta.displayName ?? row.agent.meta.name;
+                    case 'model': return row.entry?.model ?? (row.entry === undefined ? '(not saved)' : '(inherit)');
+                    default: return row.entry?.thinking ?? 'inherit';
+                }
+            };
+            const table = new TablePanel(theme, {
+                title: `● Agents — ${profile.name}`,
+                columns: autoColumns([
+                    { key: 'name', title: 'Agent', cap: 16 },
+                    { key: 'model', title: 'Model', cap: 36 },
+                    { key: 'thinking', title: 'Think', cap: 10 },
+                ], rows, cell),
+                rows,
+                renderCell: (row, column) => cell(row, column.key),
+                preselect: Math.max(0, rows.findIndex(row => row.agent.meta.name === agentsCursor)),
+                status: () => agentsStatus,
+                footer: '↑↓ navigate · Enter pick model (i inherit · t think) · Esc back',
+                onSelect: row => {
+                    agentsCursor = row.agent.meta.name;
+                    void pickAgentModel(profile, row);
+                },
+                onCancel: () => showFields(profile),
+                shortcuts: {
+                    i: () => {
+                        const row = table.selectedRow();
+                        if (row === undefined)
+                            return;
+                        profile.agents[row.agent.meta.name] = {};
+                        const status = persistDoc();
+                        agentsStatus = status ?? `saved ${row.agent.meta.name} → inherit`;
+                        if (status === undefined)
+                            markChanged(profile.name);
+                        showAgentsTable(profile);
+                    },
+                    t: () => {
+                        const row = table.selectedRow();
+                        if (row === undefined)
+                            return;
+                        void changeAgentThinking(profile, row);
+                    },
+                },
+            });
+            agentsHandle = host.open(table);
+        };
+        /** Pick one agent's model + think through the full /model picker. */
+        const pickAgentModel = async (profile, row) => {
+            const current = row.entry?.model === undefined
+                ? undefined
+                : selectionFromRoute(row.entry.model, row.entry.thinking);
+            const picked = await pickModel(ctx, tui, theme, current, () => { }, host);
+            if (picked === undefined) {
+                showAgentsTable(profile);
+                return;
+            }
+            profile.agents[row.agent.meta.name] = picked.reasoningEffort === undefined
+                ? { model: `${picked.provider}/${picked.model}` }
+                : { model: `${picked.provider}/${picked.model}`, thinking: picked.reasoningEffort };
+            const status = persistDoc();
+            const entry = profile.agents[row.agent.meta.name];
+            const thinkText = entry.thinking === undefined ? '' : ` · think ${entry.thinking}`;
+            agentsStatus = status ?? `saved ${row.agent.meta.name} → ${entry.model ?? ''}${thinkText}`;
+            if (status === undefined)
+                markChanged(profile.name);
+            showAgentsTable(profile);
+        };
+        /** Edit one agent's think level alone (its recorded model must be set). */
+        const changeAgentThinking = async (profile, row) => {
+            const route = row.entry?.model;
+            if (route === undefined) {
+                agentsStatus = '✘ no model recorded — pick a model first (Enter)';
+                showAgentsTable(profile);
+                return;
+            }
+            const llm = ctx.get('llm');
+            if (llm === undefined) {
+                agentsStatus = '✘ llm service unavailable';
+                showAgentsTable(profile);
+                return;
+            }
+            const slash = route.indexOf('/');
+            if (slash <= 0) {
+                agentsStatus = `✘ cannot resolve think levels for ${route}`;
+                showAgentsTable(profile);
+                return;
+            }
+            let efforts;
+            try {
+                efforts = (await llm.resolveModelInfo(route.slice(0, slash), route.slice(slash + 1))).reasoning?.efforts;
+            }
+            catch {
+                efforts = undefined;
+            }
+            if (efforts === undefined || efforts.length === 0) {
+                agentsStatus = `✘ ${route} exposes no think levels`;
+                showAgentsTable(profile);
+                return;
+            }
+            const entry = profile.agents[row.agent.meta.name] ?? {};
+            const currentEffort = entry.thinking;
+            const chosen = await openEffortPicker(tui, theme, efforts, currentEffort, () => { }, () => agentsHandle?.hide());
+            if (chosen === undefined) {
+                showAgentsTable(profile);
+                return;
+            }
+            const next = chosen.effort === 'default' ? undefined : chosen.effort;
+            if (next === undefined)
+                delete entry.thinking;
+            else
+                entry.thinking = next;
+            profile.agents[row.agent.meta.name] = entry;
+            const status = persistDoc();
+            agentsStatus = status ?? `saved ${row.agent.meta.name} → think ${next ?? 'inherit'}`;
+            if (status === undefined)
+                markChanged(profile.name);
+            showAgentsTable(profile);
+        };
+        const showRename = (profile) => {
+            let committed = false;
+            const field = new EditField(tui, {
+                title: `Rename profile — ${profile.name}`,
+                subtitle: 'letters, digits, dash, space · must stay unique',
+                initial: profile.name,
+                parse: text => parseProfileName(doc, profile.name, text),
+                onCommit: async (parsed) => {
+                    if (parsed.kind !== 'value')
+                        return undefined;
+                    const name = parsed.value;
+                    const error = renameProfile(doc, profile.name, name);
+                    if (error !== undefined)
+                        return { error };
+                    committed = true;
+                    pendingPreselect = name;
+                    return undefined;
+                },
+                onDone: () => {
+                    if (committed) {
+                        const status = persistDoc();
+                        tableStatus = status ?? `renamed → ${profile.name}`;
+                        if (status === undefined)
+                            markChanged(profile.name);
+                    }
+                    showTable();
+                },
+                onError: message => { tableStatus = `✘ ${message}`; },
+            }, theme);
+            host.open(field);
+        };
+        const showNew = () => {
+            let committed = false;
+            const field = new EditField(tui, {
+                title: 'New model profile',
+                subtitle: 'a name like "work" or "personal" · configured next',
+                initial: '',
+                parse: text => parseProfileName(doc, '', text),
+                onCommit: async (parsed) => {
+                    if (parsed.kind !== 'value')
+                        return undefined;
+                    const { profile, error } = createProfile(doc, parsed.value);
+                    if (error !== undefined || profile === undefined)
+                        return { error: error ?? 'create failed' };
+                    committed = true;
+                    pendingPreselect = profile.name;
+                    return undefined;
+                },
+                onDone: () => {
+                    if (committed) {
+                        const status = persistDoc();
+                        tableStatus = status ?? `created profile "${pendingPreselect}"`;
+                        if (status === undefined && pendingPreselect !== undefined)
+                            markChanged(`+${pendingPreselect}`);
+                    }
+                    showTable();
+                },
+                onError: message => { tableStatus = `✘ ${message}`; },
+            }, theme);
+            host.open(field);
+        };
+        const showReview = (profile) => {
+            const { agents } = listAgentFiles(agentsDir());
+            host.open(new ViewerPanel(theme, {
+                title: `ⓘ Model profile — ${profile.name}`,
+                lines: profileReviewLines(profile, agents, doc.current === profile.name),
+                footer: '  Esc to close',
+                onClose: () => showFields(profile),
+            }));
+        };
+        showTable();
+    });
+}
+/** The accent title line of the profile fields window (current profiles get the ● mark). */
+function profileTitle(theme, profile, doc) {
+    const mark = doc.current === profile.name ? '● ' : '';
+    return ansiFg(theme.palette.accent) + BOLD + `${mark}${clipToWidth(profile.name, 100)}` + RESET;
+}
+/** Name-editor parse: trimmed non-empty, unique against the doc (case-insensitive). */
+function parseProfileName(doc, currentName, text) {
+    const name = text.trim();
+    if (name === '')
+        return { kind: 'error', error: 'profile name must not be empty' };
+    if (name.length > 32)
+        return { kind: 'error', error: 'profile name must stay under 33 characters' };
+    if (name.toLowerCase() !== currentName.toLowerCase() && findProfile(doc, name) !== undefined) {
+        return { kind: 'error', error: `a profile named "${name}" already exists` };
+    }
+    return { kind: 'value', value: name };
+}
+/** An agent entry's `provider/model` route back into a picker preselection. */
+function selectionFromRoute(route, thinking) {
+    const slash = route.indexOf('/');
+    if (slash <= 0)
+        return { provider: route, model: route };
+    return {
+        provider: route.slice(0, slash),
+        model: route.slice(slash + 1),
+        ...(thinking !== undefined ? { reasoningEffort: thinking } : {}),
+    };
+}
+//# sourceMappingURL=profile.js.map