@aragon-agent/cli 0.6.12 → 0.6.14

package/dist/ui/interaction-hints.d.ts

@@ -0,0 +1,18 @@
+export interface ActionHintInput {
+    cols: number;
+    interactionPhase: 'idle' | 'starting' | 'running';
+    interruptHint?: string;
+    selectionPending?: boolean;
+    copyInFlight?: boolean;
+    copyCleanupPending?: boolean;
+    completion?: 'none' | 'slash' | 'file';
+    services?: number;
+    overlay?: string | null;
+    hintsEnabled?: boolean;
+    toast?: string;
+    updateAvailable?: boolean;
+    exitHint?: string;
+    modeToggleKey?: string;
+}
+/** Esc describes its actual owner, including while transient feedback has the row. */
+export declare function buildActionClauses(input: ActionHintInput): readonly string[];

package/dist/ui/interaction-hints.js

@@ -0,0 +1,92 @@
+import stringWidth from 'string-width';
+import { interactionCopy as copy } from './interaction-copy.js';
+import { cleanStatusText } from './layout/status-layout.js';
+function escapeClause(input) {
+    if (input.overlay)
+        return copy.close;
+    if (input.completion && input.completion !== 'none')
+        return copy.closeCompletion;
+    if (input.interactionPhase === 'starting')
+        return /again|confirm/i.test(input.interruptHint ?? '')
+            ? copy.cancelStartAgain : copy.cancelStart;
+    if (input.interactionPhase !== 'running')
+        return '';
+    if (/force|\u5f3a\u5236/i.test(input.interruptHint ?? ''))
+        return copy.forceStop;
+    if (/again|confirm|\u518d\u6309/i.test(input.interruptHint ?? ''))
+        return copy.interruptAgain;
+    return copy.interrupt;
+}
+function contextClauses(input, escape) {
+    if (input.overlay) {
+        if (input.overlay === 'confirm')
+            return [escape, copy.approveTool, copy.rejectTool];
+        const selects = /question|model|session|settings/.test(input.overlay);
+        return [escape, selects ? copy.select : copy.scroll,
+            ...(selects ? [input.overlay === 'settings' ? copy.saveSettings : copy.confirm] : [])];
+    }
+    if (input.completion && input.completion !== 'none') {
+        const candidates = input.completion === 'slash'
+            ? [copy.executeCommand, escape, copy.complete, copy.select, copy.newline]
+            : [copy.complete, escape, copy.select, copy.newline];
+        if (input.completion === 'file' && input.interactionPhase !== 'starting')
+            candidates.push(input.interactionPhase === 'running' ? copy.enqueue : copy.send);
+        return candidates;
+    }
+    if (input.interactionPhase === 'starting')
+        return [copy.startingHint, escape];
+    const running = input.interactionPhase === 'running';
+    const narrow = input.cols < 72;
+    return [running ? (narrow ? copy.enqueue : copy.enqueueLong) : (narrow ? copy.send : copy.sendLong),
+        narrow ? copy.newline : copy.newlineLong, ...(escape ? [escape] : [])];
+}
+function fitClauses(candidates, budget) {
+    const result = [];
+    for (const text of candidates.filter(Boolean)) {
+        if (stringWidth([...result, text].join(' | ')) <= budget)
+            result.push(text);
+    }
+    return result;
+}
+/** Esc describes its actual owner, including while transient feedback has the row. */
+export function buildActionClauses(input) {
+    const budget = Math.max(0, Math.floor(input.cols) - 1);
+    const escape = escapeClause(input);
+    const copyFeedback = input.copyCleanupPending
+        ? (input.toast?.includes(copy.copyFailed) ? input.toast : copy.copyCleanup)
+        : input.copyInFlight ? copy.copying : '';
+    const feedback = input.exitHint || copyFeedback || input.toast || '';
+    if (feedback) {
+        const reserved = escape ? [escape] : [];
+        const remaining = budget - stringWidth(reserved.join(' | ')) - (reserved.length ? 3 : 0);
+        let text = cleanStatusText(feedback);
+        if (stringWidth(text) > remaining) {
+            const minimum = text.includes(copy.copyFailed) ? copy.copyFailed : '';
+            let clipped = '';
+            for (const char of text) {
+                if (stringWidth(clipped + char) > remaining)
+                    break;
+                clipped += char;
+            }
+            text = minimum && stringWidth(minimum) <= remaining ? minimum : clipped;
+        }
+        return fitClauses([text, ...reserved], budget);
+    }
+    const clauses = contextClauses(input, escape);
+    if (input.selectionPending)
+        clauses.unshift(copy.copy);
+    if (input.services && !input.selectionPending)
+        clauses.unshift(input.cols < 72
+            ? `${copy.stopServicesShort} ${input.services}` : `${copy.services} ${input.services} ${copy.stopServices}`);
+    if (input.updateAvailable && input.interactionPhase === 'idle' && !input.overlay)
+        clauses.unshift(copy.update);
+    if (!input.selectionPending && !input.services)
+        clauses.push(copy.exit);
+    if (input.hintsEnabled !== false && !input.overlay)
+        clauses.push(copy.shiftNewline, `${(input.modeToggleKey ?? 'shift+tab').split('+').map((key) => key.length === 1 ? key.toUpperCase() : key[0].toUpperCase() + key.slice(1).toLowerCase()).join('+')} ${copy.modeLabel}`, copy.help, '/ commands', '@ files');
+    // Reserve Esc before lower-priority clauses, but preserve the documented display order.
+    if (!escape)
+        return fitClauses(clauses, budget);
+    const selected = fitClauses(clauses.filter((clause) => clause !== escape), budget - stringWidth(escape) - 3);
+    return clauses.filter((clause) => clause === escape || selected.includes(clause));
+}

package/dist/ui/layout/budget.js

@@ -18,7 +18,7 @@ export function chromeBudget(rows, draftRows = 1) {
     return {
         header: 1,
         toast: 1,
-        composer: 2 + clampDraftRows(rows, draftRows) + (rows >= HINT_MIN_ROWS ? 1 : 0),
+        composer: 2 + clampDraftRows(rows, draftRows),
         status: 1,
     };
 }

package/dist/ui/layout/queue-layout.d.ts

@@ -0,0 +1,19 @@
+import type { PendingSteering } from '../../agent/queued-messages.js';
+export interface QueueLayoutInput {
+    pending: readonly PendingSteering[];
+    columns: number;
+    terminalRows: number;
+    availableRows: number;
+    paused: boolean;
+}
+export interface QueueLayout {
+    rows: number;
+    title: string;
+    items: readonly {
+        queueId: string;
+        label: string;
+    }[];
+    hiddenCount: number;
+}
+/** One allocation drives both footer measurement and rendered rows. */
+export declare function buildQueueLayout(input: QueueLayoutInput): QueueLayout;

package/dist/ui/layout/queue-layout.js

@@ -0,0 +1,26 @@
+import stringWidth from 'string-width';
+import { queueSummary, truncateSummary } from '../QueueStatusRow.js';
+/** One allocation drives both footer measurement and rendered rows. */
+export function buildQueueLayout(input) {
+    const count = input.pending.length;
+    const limit = Math.max(0, Math.min(input.terminalRows >= 20 ? 4 : 2, Math.floor(input.availableRows)));
+    if (!count || !limit)
+        return { rows: 0, title: '', items: [], hiddenCount: count };
+    const shown = Math.min(count, Math.max(1, limit - 1));
+    const items = input.pending.slice(0, shown).map((item, index) => {
+        const prefix = `${index + 1}. `;
+        const lines = item.text.split(/\r\n|[\r\n]/).length;
+        const suffix = lines > 1 ? ` (+${lines - 1}\u884c)` : '';
+        return { queueId: item.queueId, label: prefix + truncateSummary(queueSummary(item.text), Math.max(0, input.columns - stringWidth(prefix + suffix)), '...') + suffix };
+    });
+    const hiddenCount = count - items.length;
+    const paused = input.paused ? ' \u5df2\u6682\u505c' : '';
+    const hidden = hiddenCount ? ` \u53e6${hiddenCount}\u6761` : '';
+    const title = `Queue: \u5f85\u5904\u7406 ${count}${paused}${hidden} /queue`;
+    if (limit === 1)
+        return { rows: 1,
+            title: truncateSummary(`Queue ${count} /queue ${items[0].label}`, input.columns, '...'),
+            items, hiddenCount: count - items.length };
+    return { rows: 1 + items.length, title: stringWidth(title) <= input.columns
+            ? title : `Queue ${count} /queue`, items, hiddenCount };
+}

package/dist/ui/layout/status-layout.d.ts

@@ -0,0 +1,55 @@
+import type { UsageTotal } from '../../agent/reducer.js';
+import type { ContextUsageSnapshot } from '../../compaction/types.js';
+export type RunPhase = 'idle' | 'starting' | 'waiting' | 'thinking' | 'generating' | 'preparing-tool' | 'tool';
+export interface StatusLayoutInput {
+    columns: number;
+    phase: RunPhase;
+    pendingCount: number;
+    context: ContextUsageSnapshot;
+    usageTotal: UsageTotal;
+    thinkingLevel: string;
+    elapsedMs: number;
+    tokPerSec: number;
+    activeTool?: {
+        name: string;
+        toolCallId: string;
+    } | null;
+    runOutcome?: 'none' | 'ended' | 'interrupted' | 'failed';
+    spinner?: string;
+    waitingForConfirmation?: boolean;
+    stopping?: boolean;
+    compacting?: boolean;
+    retryActive?: {
+        attempt: number;
+        max: number;
+        secondsLeft: number;
+    };
+    mode?: string;
+    pendingMode?: string | null;
+    servicesActive?: {
+        live: number;
+    };
+    teamActive?: {
+        running: number;
+        total: number;
+    };
+    todoActive?: {
+        done: number;
+        total: number;
+    };
+    ecoRung?: number;
+    fastActive?: {
+        inFlight: boolean;
+    };
+    scrolledLines?: number;
+}
+export interface StatusField {
+    id: string;
+    text: string;
+    cells: number;
+    tone: 'normal' | 'muted' | 'warning' | 'error';
+}
+export declare function cleanStatusText(text: string): string;
+export declare function phaseLabels(input: Pick<StatusLayoutInput, 'phase' | 'activeTool' | 'runOutcome' | 'waitingForConfirmation' | 'stopping' | 'compacting' | 'retryActive'>): readonly [string, string];
+/** Allocate complete fields before rendering; only the redraw carrier lives outside this budget. */
+export declare function planStatusFields(input: StatusLayoutInput): readonly StatusField[];

package/dist/ui/layout/status-layout.js

@@ -0,0 +1,110 @@
+import stringWidth from 'string-width';
+import stripAnsi from 'strip-ansi';
+import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../../agent/usage.js';
+import { interactionCopy as copy } from '../interaction-copy.js';
+export function cleanStatusText(text) {
+    // eslint-disable-next-line no-control-regex
+    return stripAnsi(text).replace(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/g, ' ').trim();
+}
+export function phaseLabels(input) {
+    if (input.waitingForConfirmation)
+        return copy.confirming;
+    if (input.stopping)
+        return copy.stopping;
+    if (input.compacting)
+        return copy.compacting;
+    if (input.retryActive)
+        return [copy.retrying[0], `${copy.retrying[1]} ${Math.max(0, Math.ceil(input.retryActive.secondsLeft))}s`];
+    if (input.activeTool) {
+        const name = input.activeTool.name;
+        if (name === 'read_file')
+            return copy.readFile;
+        if (name === 'write_file' || name === 'edit_file')
+            return copy.writeFile;
+        if (name === 'bash')
+            return copy.command;
+        return [copy.tool[0], `${copy.tool[1]} ${cleanStatusText(name)}`];
+    }
+    if (input.phase === 'idle' && input.runOutcome && input.runOutcome !== 'none')
+        return copy[input.runOutcome];
+    if (input.phase === 'preparing-tool')
+        return copy.preparingTool;
+    return copy[input.phase];
+}
+const field = (id, text, tone = 'muted') => ({ id, text, cells: stringWidth(text), tone });
+const width = (fields) => fields.reduce((sum, item) => sum + item.cells, 0) + Math.max(0, fields.length - 1) * 3;
+const scientific = (value) => value.toExponential(1).replace(/\.0e/, 'e').replace('e+', 'e');
+const compactNumber = (value) => value >= 1e9 ? scientific(value) : formatTokens(value).replace(/\.0([kM])$/, '$1');
+function contextText(context, detail = false, exponent = false) {
+    if (![context.occupied, context.window, context.deltaTokens, context.pct].every(Number.isFinite)
+        || context.occupied < 0 || context.window <= 0)
+        return copy.contextUnknown;
+    const number = exponent ? scientific : detail ? formatTokens : compactNumber;
+    const approximate = context.source === 'estimate' || context.deltaTokens > 0 ? '~' : '';
+    const limit = context.windowKnown ? number(context.window) : '?';
+    return `${copy.context} ${approximate}${number(context.occupied)}/${limit} ${detail ? 'tokens' : 'tok'}`;
+}
+function secondaryFields(input) {
+    const list = [];
+    if ((input.mode && input.mode !== 'build') || input.pendingMode)
+        list.push(field('mode', input.pendingMode ? `${input.mode ?? 'build'}>${input.pendingMode}` : input.mode, 'normal'));
+    if (input.servicesActive?.live)
+        list.push(field('services', `${copy.services} ${input.servicesActive.live}`, 'warning'));
+    if (Number.isFinite(input.usageTotal.costUsd))
+        list.push(field('cost', `${copy.estimatedCost} ${formatCost(input.usageTotal.costUsd).slice(1)}`));
+    if (input.phase !== 'idle') {
+        if (input.tokPerSec > 0 && Number.isFinite(input.tokPerSec))
+            list.push(field('speed', `${copy.speed} ${input.tokPerSec} tok/s`));
+        if (Number.isFinite(input.elapsedMs))
+            list.push(field('elapsed', `${copy.elapsed} ${formatDuration(input.elapsedMs)}`));
+    }
+    if (input.thinkingLevel !== 'off')
+        list.push(field('thinking', `think:${cleanStatusText(input.thinkingLevel)}`));
+    list.push(field('usage', `${copy.sessionInput} ${compactNumber(promptTokensOf(input.usageTotal))} ${copy.output} ${compactNumber(input.usageTotal.outputTokens)} tok`));
+    if (input.context.windowKnown && Number.isFinite(input.context.pct))
+        list.push(field('percentage', `${input.context.source === 'estimate' || input.context.deltaTokens > 0 || !input.context.windowKnown ? '~' : ''}${Math.round(input.context.pct)}%`));
+    if (input.ecoRung)
+        list.push(field('eco', 'eco'));
+    if (input.fastActive)
+        list.push(field('fast', `fast${input.fastActive.inFlight ? '*' : ''}`));
+    if (input.teamActive)
+        list.push(field('team', `agents ${input.teamActive.running}/${input.teamActive.total}`));
+    if (input.todoActive)
+        list.push(field('todo', `todo ${input.todoActive.done}/${input.todoActive.total}`));
+    if (input.scrolledLines)
+        list.push(field('scroll', `^${input.scrolledLines}`, 'warning'));
+    return list;
+}
+/** Allocate complete fields before rendering; only the redraw carrier lives outside this budget. */
+export function planStatusFields(input) {
+    const budget = Math.max(0, Math.floor(input.columns) - 1);
+    const [short, long] = phaseLabels(input);
+    const prefix = input.spinner ? `${input.spinner} ` : '';
+    const phaseTone = input.runOutcome === 'failed' ? 'error' : 'normal';
+    const fields = [field('phase', prefix + short, phaseTone)];
+    if (input.pendingCount > 0)
+        fields.push(field('queue', `${copy.queue} ${input.pendingCount}`, 'warning'));
+    fields.push(field('context', contextText(input.context)));
+    const contextIndex = fields.length - 1;
+    if (width(fields) > budget)
+        fields[contextIndex] = field('context', contextText(input.context, false, true));
+    if (width(fields) > budget)
+        fields[contextIndex] = field('context', '/context');
+    if (width(fields) > budget && input.pendingCount > 0)
+        fields[1] = field('queue', '/queue', 'warning');
+    if (width(fields) > budget)
+        return fields.filter((_f, index) => width(fields.slice(0, index + 1)) <= budget);
+    for (const candidate of secondaryFields(input)) {
+        if (width([...fields, candidate]) <= budget)
+            fields.push(candidate);
+    }
+    const upgrades = [field('phase', prefix + long, phaseTone),
+        field('queue', `${copy.pending} ${input.pendingCount}`, 'warning'),
+        field('context', contextText(input.context, true))];
+    for (const upgrade of upgrades) {
+        const index = fields.findIndex((f) => f.id === upgrade.id);
+        if (index >= 0 && width(fields) - fields[index].cells + upgrade.cells <= budget)
+            fields[index] = upgrade;
+    }
+    return fields;
+}

package/dist/ui/layout/todo-layout.d.ts

@@ -5,6 +5,7 @@ export interface TodoRailLayoutInput {
     itemCount: number;
     viewportBudget: number;
     teamRows: number;
+    queueRows?: number;
     popupRows: number;
     composerBaseRows?: number;
 }

package/dist/ui/layout/todo-layout.js

@@ -8,7 +8,7 @@ export function buildTodoRailLayout(input) {
     const cols = nonNegativeInt(input.cols);
     const budget = nonNegativeInt(input.viewportBudget);
     const teamRows = Math.min(budget, nonNegativeInt(input.teamRows));
-    const popupMaxHeight = Math.max(0, budget - teamRows - TODO_LIMITS.panelMinRows
+    const popupMaxHeight = Math.max(0, budget - teamRows - nonNegativeInt(input.queueRows ?? 0) - 1
         - nonNegativeInt(input.composerBaseRows ?? 0));
     const popupRows = popupMaxHeight < 3 ? 0 : Math.min(nonNegativeInt(input.popupRows), popupMaxHeight);
     const rows = budget;

package/dist/ui/overlays/HelpOverlay.js

@@ -5,7 +5,7 @@ const KEY_PAD = 24;
 function keyRows(times) {
     return [
         ['Enter', 'Submit (idle) / queue steering (running); re-pins to the newest output'],
-        ['Alt+Enter / Shift+Enter', 'Insert newline'],
+        ['Alt+Enter / Shift+Enter', 'Newline when supported; the host may intercept either binding'],
         ['Ctrl+J', 'Newline fallback; /terminal-setup explains Shift+Enter binding'],
         ['Esc', 'Close menu / overlay'],
         ['Esc twice', 'Interrupt run (within 1.5s)'],
@@ -28,15 +28,14 @@ function keyRows(times) {
         // a key, so it has to be named somewhere they can look it up. The one-shot
         // startup notice is the other place, and it scrolls away.
         ['Drag right edge', 'Scroll messages and input together; type to return'],
-        ['Run status row', 'Spinner and queue / interrupt keys, above the input during a run'],
+        ['Bottom rows', 'Input, fixed action hints, then global runtime / queue / context status'],
         ['Drag text (left button)', 'Select text on screen; the highlight waits'],
         ['Ctrl+C (with a selection)', 'Copy the pending selection - does not arm exit'],
         ['Native terminal selection', 'Copy-on-select is controlled by your terminal settings'],
-        ['Queue', 'Waits for a message receipt, not turn start; paused means not running'],
-        ['P>B / B>P', 'A pending mode switch; P=plan, B=build'],
-        ['E2 / E!', 'Esc twice to interrupt / Esc again to force-stop'],
-        ['S+ / T+', 'Services / TODO present; /bg and /todo status show counts'],
-        ['Queue(p) / (+99+)', 'Paused queue / at least 100 additional messages'],
+        ['Queue / /queue', 'Pending receipt; /queue opens full text, PgUp/PgDn pages, Esc closes'],
+        ['plan>build / build>plan', 'A mode switch pending until the current run ends'],
+        ['/bg / /todo status', 'Show full service and TODO counts when status fields are hidden'],
+        ['Queue paused', 'Unreceived messages persist after interruption until accepted or cancelled'],
         ['Up / Down', 'Prompt history (empty input)'],
         // Pasting is the one affordance here with no key of its own, so the only
         // place a user can learn what happened to their 218 lines is this row.
@@ -63,7 +62,8 @@ const COMMANDS = [
     ['/cwd [dir]', 'Show or change the tool working directory'],
     ['/save [file]', 'Save the session to JSON'],
     ['/resume [file]', 'Load a saved session'],
-    ['/copy', 'Copy the last answer to the clipboard (OSC 52, so it works over ssh)'],
+    ['/copy', 'Copy last answer; native completion confirmed, OSC 52 request unconfirmed'],
+    ['/queue', 'Read every pending message in full; no replay or queue mutation'],
     ['/mouse [on|off]', 'Release the mouse to your terminal, or take it back'],
     ['/terminal-setup', 'Show newline key bindings without changing terminal settings'],
     ['/exit', 'Exit'],

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

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type ProfileFrameProps } from './ModelProfilePicker.js';
+import { type ProfileEditorDraft, type ModelProfileAction } from './model-profile-state.js';
+interface ModelProfileEditorProps extends ProfileFrameProps {
+    editor: ProfileEditorDraft;
+    users: string;
+    error?: string;
+    dispatch: React.Dispatch<ModelProfileAction>;
+}
+/** Replacement key input starts empty; retention across targets is explicit. */
+export declare function ModelProfileEditor(props: ModelProfileEditorProps): React.ReactElement;
+export {};

package/dist/ui/overlays/ModelProfileEditor.js

@@ -0,0 +1,103 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Text, useInput } from 'ink';
+import { ADAPTER_PROVIDERS } from '../../config/schema.js';
+import { registerSecret } from '../../logging/secret-registry.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
+import { pickGlyphs } from '../glyphs.js';
+import { profileEndpointSummary, useProfileScroll } from './ModelProfilePicker.js';
+import { finishProfileEditor } from './model-profile-state.js';
+const FIELDS = ['name', 'provider', 'model', 'baseUrl', 'credentialMode', 'apiKey'];
+const LABELS = ['Name', 'Provider', 'Model', 'Base URL', 'Credential mode', 'API key'];
+function useEditorInput(props, navigation) {
+    const { editor, dispatch } = props;
+    const { index, setIndex, retain, count } = navigation;
+    function commit() {
+        const result = finishProfileEditor(editor);
+        if (result.field) {
+            const at = FIELDS.indexOf(result.field);
+            if (at >= 0)
+                setIndex(at);
+        }
+        dispatch({ type: 'merge-editor' });
+    }
+    useInput((input, key) => {
+        if (key.escape) {
+            dispatch({ type: 'cancel-editor' });
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            setIndex((index - 1 + count) % count);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            setIndex((index + 1) % count);
+            return;
+        }
+        if (key.return) {
+            if (retain && index === FIELDS.length)
+                dispatch({ type: 'retain-key' });
+            else if (index === count - 1)
+                dispatch({ type: 'cancel-editor' });
+            else
+                commit();
+            return;
+        }
+        const field = FIELDS[index];
+        if (!field || key.ctrl || key.meta)
+            return;
+        if (field === 'provider' || field === 'credentialMode') {
+            if (!key.leftArrow && !key.rightArrow)
+                return;
+            const options = field === 'provider' ? ADAPTER_PROVIDERS
+                : editor.original.apiKey && !editor.endpointChanged ? ['keep', 'replace', 'shared']
+                    : ['shared', 'replace'];
+            const current = options.indexOf(editor[field]);
+            dispatch({ type: 'editor-field', field,
+                value: options[(current + (key.leftArrow ? -1 : 1) + options.length) % options.length] });
+            return;
+        }
+        if (field === 'apiKey' && editor.credentialMode !== 'replace')
+            return;
+        const text = stripPasteFrames(stripEnterFrames(input));
+        const value = key.backspace || key.delete ? [...editor[field]].slice(0, -1).join('')
+            : editor[field] + text;
+        if (field === 'apiKey')
+            registerSecret(value);
+        if (key.backspace || key.delete || text)
+            dispatch({ type: 'editor-field', field, value });
+    });
+}
+function buildEditorRows(props, navigation) {
+    const { editor } = props;
+    const { index, retain } = navigation;
+    const glyphs = pickGlyphs(props.caps);
+    const values = FIELDS.map((field) => {
+        if (field === 'apiKey')
+            return editor.credentialMode === 'replace'
+                ? editor.apiKey ? 'Configured (replacement)' : '(type replacement)'
+                : editor.credentialMode === 'keep' ? 'Configured (unchanged)' : 'Shared / environment';
+        if (field === 'credentialMode')
+            return editor.credentialMode;
+        return editor[field] || (field === 'name' ? '(defaults to model)' : field === 'baseUrl'
+            ? '(provider default)' : '(required)');
+    });
+    const lines = LABELS.map((label, at) => `${label.padEnd(18)}${values[at]}`);
+    if (retain)
+        lines.push('Retain key for new endpoint');
+    lines.push('Apply to settings draft', 'Cancel editing');
+    const rows = lines.map((line, at) => _jsxs(Text, { wrap: "truncate", color: at === index ? props.theme.accent : props.theme.muted, children: [at === index ? `${glyphs.caret} ` : '  ', line] }, at));
+    rows.push(_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: ["Target: ", editor.provider, " ", profileEndpointSummary(editor.baseUrl)] }, "target"));
+    return rows;
+}
+/** Replacement key input starts empty; retention across targets is explicit. */
+export function ModelProfileEditor(props) {
+    const [index, setIndex] = useState(0);
+    const retain = props.editor.endpointChanged && Boolean(props.editor.original.apiKey);
+    const navigation = { index, setIndex, retain, count: FIELDS.length + (retain ? 1 : 0) + 2 };
+    const offset = useProfileScroll(props, index);
+    useEditorInput(props, navigation);
+    return _jsx(OverlayFrame, { ...props, rows: buildEditorRows(props, navigation), scrollOffset: offset, title: props.error ?? `Edit profile${props.users ? ` | Used by ${props.users}` : ''}`, hint: "Enter apply to draft | Esc cancel" });
+}

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

@@ -0,0 +1,35 @@
+import React from 'react';
+import type { ModelProfile, ModelProfilesConfig, ModelRole } from '../../config/model-profiles.js';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+export interface ProfileFrameProps {
+    theme: Theme;
+    caps: TermCapabilities;
+    cols: number;
+    maxRows: number;
+    scrollOffset: number;
+    onScrollClamp?: (offset: number) => void;
+}
+/** Move focus into view while accepting App's independent wheel/page scrolling. */
+export declare function useProfileScroll(props: ProfileFrameProps, focus: number): number;
+/** Cut by terminal columns, preserving surrogate pairs and wide names. */
+export declare function clipProfileText(value: string, columns: number): string;
+export declare function profileEndpointSummary(baseUrl: string | null): string;
+interface ModelProfilePickerProps extends ProfileFrameProps {
+    profiles: ModelProfilesConfig;
+    savedProfiles?: ModelProfilesConfig;
+    role: ModelRole;
+    manager?: boolean;
+    error?: string;
+    apiKeys: Record<string, string | undefined>;
+    customProfile?: ModelProfile;
+    onSelect: (id: string | null) => void;
+    onCreate: () => void;
+    onEdit: (profile: ModelProfile) => void;
+    onDuplicate: (id: string) => void;
+    onDelete: (id: string) => void;
+    onCancel: () => void;
+}
+/** Profile selection and explicit management actions share one input owner. */
+export declare function ModelProfilePicker(props: ModelProfilePickerProps): React.ReactElement;
+export {};