koneck 2.27.0 → 2.29.0

package/dist/ink-chat.js

@@ -45,6 +45,7 @@ import { doctorChecks, doctorReport } from './doctor.js';
 import { runQualityGate } from './quality-gate.js';
 import { listAuditEvents } from './audit.js';
 import { initializePolicy, loadPolicy, POLICY_FILE } from './policy.js';
+import { isWorkspaceTrusted, trustWorkspace, untrustWorkspace } from './workspace-trust.js';
 const CYAN = '#54D7E7';
 const GREEN = '#9BCB8F';
 const CRIMSON = '#E8878D';
@@ -130,6 +131,10 @@ function fitCells(text, width, ellipsis = false) {
     const head = sliceToWidth(text, Math.max(0, width - 3));
     return head.text + '.'.repeat(Math.min(3, width)) + ' '.repeat(Math.max(0, width - head.width - 3));
 }
+/** A picker label uses all of its allocated column, only ellipsising at the actual boundary. */
+export function pickerLabel(text, width) {
+    return fitCells(text, width, true);
+}
 /**
  * Wraps text while keeping the shape it was written in.
  *
@@ -519,6 +524,9 @@ const COMMANDS = [
     { cmd: '/subtask', desc: 'Run a task in an isolated sub-agent' },
     { cmd: '/aside', desc: 'Ask a side question without interrupting the running task' },
     { cmd: '/clear', desc: 'Clear conversation history' },
+    { cmd: '/cancel', desc: 'Stop the current task and keep your composer text' },
+    { cmd: '/retry', desc: 'Run the last non-secret task again' },
+    { cmd: '/queue', desc: 'Inspect or clear prompts waiting behind the current task' },
     { cmd: '/new', desc: 'New session (alias of /clear)' },
     { cmd: '/reset', desc: 'Reset session (alias of /clear)' },
     { cmd: '/mode', desc: 'Set mode: auto, plan or code' },
@@ -537,9 +545,11 @@ const COMMANDS = [
     { cmd: '/fork', desc: 'Copy this session and continue on the copy' },
     { cmd: '/archive', desc: 'Keep a session but hide it from /resume' },
     { cmd: '/diff', desc: 'Show uncommitted git changes' },
+    { cmd: '/changes', desc: 'Summarize staged, unstaged, and untracked changes' },
     { cmd: '/quality', desc: 'Run the detected lint and test checks' },
     { cmd: '/audit', desc: 'Show recent redacted tool activity' },
     { cmd: '/policy', desc: 'Show or initialize workspace safety rules' },
+    { cmd: '/trust', desc: 'Show, persist, or revoke this workspace trust grant' },
     { cmd: '/verify', desc: 'Run the project test command' },
     { cmd: '/rewind', desc: 'Drop the last exchange from history' },
     { cmd: '/copy', desc: 'Copy the last response to the clipboard' },
@@ -623,6 +633,61 @@ export function filterPickerItems(items, query) {
     }
     return [...starts, ...contains];
 }
+/** The smallest number of character edits that turns one command into another. */
+function commandDistance(a, b) {
+    // A transposed neighbouring pair is the commonest command typo (`/modle`). Treat it as one
+    // edit before using the ordinary insertion/deletion/substitution matrix below.
+    if (a.length === b.length) {
+        const mismatches = [...a].map((char, index) => char === b[index] ? -1 : index).filter(index => index >= 0);
+        if (mismatches.length === 2 && mismatches[1] === mismatches[0] + 1
+            && a[mismatches[0]] === b[mismatches[1]]
+            && a[mismatches[1]] === b[mismatches[0]])
+            return 1;
+    }
+    const previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j++) {
+            current[j] = a[i - 1] === b[j - 1]
+                ? previous[j - 1]
+                : 1 + Math.min(previous[j - 1], previous[j], current[j - 1]);
+        }
+        for (let j = 0; j <= b.length; j++)
+            previous[j] = current[j];
+    }
+    return previous[b.length];
+}
+/**
+ * Turns a near-miss slash command into a direct recovery path.
+ *
+ * We deliberately do not guess at distant names: a wrong suggestion steals attention, while
+ * catching one or two transposed/omitted characters makes command use feel forgiving.
+ */
+export function commandSuggestion(command, commands = COMMANDS.map(item => item.cmd)) {
+    const wanted = command.trim().toLowerCase();
+    if (!wanted.startsWith('/'))
+        return undefined;
+    const maxDistance = wanted.length <= 5 ? 1 : wanted.length <= 9 ? 2 : 3;
+    let best;
+    let distance = Number.POSITIVE_INFINITY;
+    for (const candidate of commands) {
+        const d = commandDistance(wanted, candidate.toLowerCase());
+        // At the same edit distance, preserve as much of what the user typed as possible. For
+        // `/modle`, `/model` is more likely than the shorter `/mode` even though both are two edits.
+        if (d < distance || (d === distance && (!best || Math.abs(candidate.length - wanted.length) < Math.abs(best.length - wanted.length)))) {
+            best = candidate;
+            distance = d;
+        }
+    }
+    return distance <= maxDistance ? best : undefined;
+}
+/** Keep a small, useful recall buffer without repeating the same submitted task. */
+export function appendDraftHistory(history, draft, limit = 100) {
+    const entry = draft.trim();
+    if (entry === '' || history.at(-1) === entry)
+        return [...history];
+    return [...history, entry].slice(-Math.max(1, limit));
+}
 /**
  * The choices offered for one waiting tool call.
  *
@@ -716,8 +781,10 @@ export function pickerCountText(selected, shown, total) {
  * its row, and the constant 36 that was here cut most of them in half.
  */
 export function pickerLabelWidth(labels, descs, width) {
-    const longestDesc = Math.max(0, ...descs.map(d => d.length));
-    const longestLabel = Math.max(18, ...labels.map(l => l.length));
+    // Terminal cells, not JS code units: one wide glyph in a model name or session title used to
+    // make a supposedly exact row spill past the palette edge.
+    const longestDesc = Math.max(0, ...descs.map(displayWidth));
+    const longestLabel = Math.max(18, ...labels.map(displayWidth));
     return Math.max(18, Math.min(longestLabel, width - longestDesc - 4));
 }
 /**
@@ -732,7 +799,7 @@ export function pickerLabelWidth(labels, descs, width) {
  * a new one should work without being registered twice. The dangerous ones are few and named.
  */
 const COMMANDS_THAT_MUST_WAIT = new Set([
-    '/clear', '/reset', '/new', // would wipe the history the turn is using
+    '/clear', '/reset', '/new', '/retry', // would wipe the history or begin a new turn
     '/model', '/provider', '/connect', '/key', '/endpoint', '/baseurl', // rebuild the session
     '/resume', '/fork', // replace it
     '/revert', // undo files the turn may still be writing
@@ -765,6 +832,9 @@ Slash commands:
   /status               Provider, model, mode, tokens, cost, CWD
   /doctor               Diagnose the active provider, workspace, and developer tools
   /clear /reset /new    Clear conversation history
+  /cancel               Stop the current task; keeps the composer text
+  /retry                Run the last non-secret task again
+  /queue [clear|drop n] Inspect, clear, or drop one queued prompt
   /model [name]         Show or switch model
   /provider [name]      Show or switch provider
   /mode [auto|plan|code] Show or set mode
@@ -776,9 +846,11 @@ Slash commands:
   /cost                 Show session cost
   /memory               Show .koneck/MEMORY.md
   /diff                 Show uncommitted git changes
+  /changes              Summarize staged, unstaged, and untracked changes
   /quality              Run the detected lint and test checks
   /audit [count]        Show recent redacted tool activity
   /policy [init]        Show or create workspace safety rules
+  /trust [always|forget] Show, persist, or revoke this workspace trust grant
   /verify               Run project test command
   /agents               How parallel sub-agents are configured
   /subtask <task>       Run a task in an isolated sub-agent
@@ -791,6 +863,7 @@ Slash commands:
 Keyboard:
   Tab                   Toggle analytics panel
   Shift+Tab             Cycle mode (auto → plan → code)
+  Up/Down               Recall prior submitted prompts in the composer
   Ctrl+C                Cancel task / exit if idle
 `.trim();
 /**
@@ -1116,6 +1189,13 @@ function App({ config: initialConfig, clearFrame }) {
     }))[0];
     const [rows, setRows] = useState([{ role: 'header' }]);
     const [draft, setDraft] = useState('');
+    // Recall is deliberately session-local. It is for quick retries and refinements, not another
+    // persistence channel for prompts (which may contain sensitive project context).
+    const draftHistoryRef = useRef([]);
+    const historyIndexRef = useRef(null);
+    const historyDraftRef = useRef('');
+    /** Last agent task eligible for one-command recovery; never populated from secret-looking input. */
+    const retryTaskRef = useRef(null);
     /** Caret offset into `draft`. Kept beside it so every edit can place the caret deliberately. */
     const [caret, setCaret] = useState(0);
     const [busy, setBusy] = useState(false);
@@ -1571,6 +1651,52 @@ function App({ config: initialConfig, clearFrame }) {
     useEffect(() => { void snapshotTree(cfg.cwd).then(t => { baseTreeRef.current = t; }); }, [cfg.cwd]);
     const addRow = (row) => setRows(prev => [...prev, row]);
     const addSystem = (text) => addRow({ role: 'system', text });
+    /** Stops the in-flight turn without touching anything the developer is composing or queued. */
+    function cancelCurrentTurn() {
+        if (!busy || !abortRef.current)
+            return false;
+        abortRef.current.abort();
+        // Anything still waiting on a permission answer is refused rather than left hanging: the
+        // agents are being abandoned, and an unsettled promise keeps the pool alive after its work
+        // has been cancelled.
+        const stranded = askQueueRef.current.drain(false);
+        if (stranded > 0) {
+            setAsk(null);
+            addSystem(`Cancelled with ${stranded} permission ${stranded === 1 ? 'request' : 'requests'} unanswered; refused.`);
+        }
+        return true;
+    }
+    /** Walk submitted composer entries without losing whatever was being typed now. */
+    function recallDraft(direction) {
+        const history = draftHistoryRef.current;
+        if (history.length === 0)
+            return;
+        const current = historyIndexRef.current;
+        if (direction === -1) {
+            if (current === null)
+                historyDraftRef.current = draft;
+            const next = current === null ? history.length - 1 : Math.max(0, current - 1);
+            historyIndexRef.current = next;
+            const recalled = history[next];
+            setDraft(recalled);
+            setCaret(recalled.length);
+            return;
+        }
+        if (current === null)
+            return;
+        const next = current + 1;
+        if (next >= history.length) {
+            historyIndexRef.current = null;
+            const restored = historyDraftRef.current;
+            setDraft(restored);
+            setCaret(restored.length);
+            return;
+        }
+        historyIndexRef.current = next;
+        const recalled = history[next];
+        setDraft(recalled);
+        setCaret(recalled.length);
+    }
     async function getSession() {
         return activeSession.p;
     }
@@ -2149,7 +2275,7 @@ function App({ config: initialConfig, clearFrame }) {
                 // rather than a stale global default.
                 addSystem(`**KONECK Doctor** — checking ${cfg.provider} and this workspace…`);
                 try {
-                    const checks = await doctorChecks(cfg.cwd, cfg.provider);
+                    const checks = await doctorChecks(cfg.cwd, cfg.provider, cfg.baseURL, cfg.apiKey);
                     setRows(prev => prev.slice(0, -1));
                     addSystem(`**KONECK Doctor**\n\n${doctorReport(checks)}`);
                 }
@@ -2175,6 +2301,54 @@ function App({ config: initialConfig, clearFrame }) {
                 addSystem('Conversation cleared. The previous session is kept; /resume lists it.');
                 return;
             }
+            case '/cancel': {
+                if (!cancelCurrentTurn())
+                    addSystem('No task is running.');
+                return;
+            }
+            case '/retry': {
+                const retry = retryTaskRef.current;
+                if (!retry) {
+                    addSystem('Nothing safe to retry yet. Submit a non-secret task first.');
+                    return;
+                }
+                addSystem('Retrying the previous task…');
+                // `/retry` itself is handled as a local command. Let its `finally` release the command
+                // busy flag before starting the next agent turn, so the two cannot race each other.
+                setTimeout(() => submitDraft(retry), 0);
+                return;
+            }
+            case '/queue': {
+                const requested = arg.trim();
+                const drop = /^drop\s+(\d+)$/i.exec(requested);
+                if (drop) {
+                    const index = Number(drop[1]) - 1;
+                    if (!Number.isInteger(index) || index < 0 || index >= queued.length) {
+                        addSystem(`There is no queued prompt #${drop[1]}. Run \`/queue\` to inspect the queue.`);
+                        return;
+                    }
+                    const [removed] = queued.slice(index, index + 1);
+                    setQueued(items => items.filter((_, itemIndex) => itemIndex !== index));
+                    addSystem(`Dropped queued prompt #${index + 1}: ${removed.replace(/\s+/g, ' ').slice(0, 180)}`);
+                    return;
+                }
+                if (/^(clear|drop)$/i.test(requested)) {
+                    const count = queued.length;
+                    setQueued([]);
+                    addSystem(count === 0
+                        ? 'There are no queued prompts to clear.'
+                        : `Cleared ${count} queued ${count === 1 ? 'prompt' : 'prompts'}. The current task keeps running.`);
+                    return;
+                }
+                if (queued.length === 0) {
+                    addSystem('No prompts are queued. Type while a task runs and press enter to queue it.');
+                    return;
+                }
+                addSystem(`**Queued prompts** — ${queued.length}\n\n` +
+                    queued.map((prompt, index) => `${index + 1}. ${prompt.replace(/\s+/g, ' ').slice(0, 240)}`).join('\n') +
+                    '\n\n`/queue drop 2` removes one prompt. `/queue clear` drops all of them; the current task keeps running.');
+                return;
+            }
             case '/model': {
                 if (!arg) {
                     const now = modelFor(cfg.provider);
@@ -2412,9 +2586,50 @@ function App({ config: initialConfig, clearFrame }) {
             }
             case '/diff': {
                 try {
-                    const result = await execa('git', ['diff'], { cwd: cfg.cwd, all: true, reject: false });
-                    const out = result.all?.trim() ?? '';
-                    addSystem(out || 'No uncommitted changes.');
+                    const [unstaged, staged] = await Promise.all([
+                        execa('git', ['diff', '--no-ext-diff'], { cwd: cfg.cwd, all: true, reject: false }),
+                        execa('git', ['diff', '--cached', '--no-ext-diff'], { cwd: cfg.cwd, all: true, reject: false }),
+                    ]);
+                    if (unstaged.exitCode !== 0 || staged.exitCode !== 0) {
+                        addSystem('Not a git repository.');
+                        return;
+                    }
+                    const sections = [
+                        (staged.all ?? '').trim() ? `**Staged**\n\n${(staged.all ?? '').trim()}` : '',
+                        (unstaged.all ?? '').trim() ? `**Unstaged**\n\n${(unstaged.all ?? '').trim()}` : '',
+                    ].filter(Boolean);
+                    addSystem(sections.length ? sections.join('\n\n') : 'No staged or unstaged changes. `/changes` also shows untracked files.');
+                }
+                catch {
+                    addSystem('Not a git repository.');
+                }
+                return;
+            }
+            case '/changes': {
+                try {
+                    const [status, unstaged, staged] = await Promise.all([
+                        execa('git', ['status', '--short'], { cwd: cfg.cwd, all: true, reject: false }),
+                        execa('git', ['diff', '--stat', '--no-ext-diff'], { cwd: cfg.cwd, all: true, reject: false }),
+                        execa('git', ['diff', '--cached', '--stat', '--no-ext-diff'], { cwd: cfg.cwd, all: true, reject: false }),
+                    ]);
+                    const entries = (status.all ?? '').trim();
+                    if (status.exitCode !== 0 || unstaged.exitCode !== 0 || staged.exitCode !== 0) {
+                        addSystem('Not a git repository.');
+                        return;
+                    }
+                    if (!entries) {
+                        addSystem('Working tree is clean.');
+                        return;
+                    }
+                    const lines = ['**Working tree changes**', '', '```', entries, '```'];
+                    const stagedStat = (staged.all ?? '').trim();
+                    const unstagedStat = (unstaged.all ?? '').trim();
+                    if (stagedStat)
+                        lines.push('', '**Staged**', '```', stagedStat, '```');
+                    if (unstagedStat)
+                        lines.push('', '**Unstaged**', '```', unstagedStat, '```');
+                    lines.push('', 'Use `/diff` to inspect patches, `/quality` to verify, or `/revert` to undo KONECK checkpoints.');
+                    addSystem(lines.join('\n'));
                 }
                 catch {
                     addSystem('Not a git repository.');
@@ -2490,6 +2705,28 @@ function App({ config: initialConfig, clearFrame }) {
                     `Approval rules  : ${policy.requireApprovalFor?.join(', ') || 'none'}`);
                 return;
             }
+            case '/trust': {
+                const choice = arg.trim().toLowerCase();
+                if (choice === 'always') {
+                    await trustWorkspace(cfg.cwd);
+                    addSystem(`This workspace is now trusted for future KONECK sessions:\n\`${cfg.cwd}\``);
+                    return;
+                }
+                if (choice === 'forget' || choice === 'revoke' || choice === 'remove') {
+                    const removed = await untrustWorkspace(cfg.cwd);
+                    addSystem(removed
+                        ? `Removed the persistent trust grant for \`${cfg.cwd}\`. This open session remains active; KONECK will ask again next time.`
+                        : 'This workspace did not have a persistent trust grant.');
+                    return;
+                }
+                const trusted = await isWorkspaceTrusted(cfg.cwd);
+                addSystem(`**Workspace trust**\n\n` +
+                    `Path       : \`${cfg.cwd}\`\n` +
+                    `Persistent : ${trusted ? 'yes' : 'no — this session may be a one-time grant'}\n\n` +
+                    '`/trust always` saves this grant for future sessions.\n' +
+                    '`/trust forget` removes a saved grant; this open session stays active.');
+                return;
+            }
             case '/verify': {
                 const { detectProject } = await import('./project.js');
                 const project = await detectProject(cfg.cwd);
@@ -2912,7 +3149,12 @@ function App({ config: initialConfig, clearFrame }) {
                 return;
             }
             default:
-                addSystem(`Unknown command: ${cmd}. Type /help for the full list.`);
+                {
+                    const suggestion = commandSuggestion(cmd);
+                    addSystem(suggestion
+                        ? `Unknown command: ${cmd}. Did you mean \`${suggestion}\`?`
+                        : `Unknown command: ${cmd}. Type /help for the full list.`);
+                }
         }
     }
     /**
@@ -2974,15 +3216,7 @@ function App({ config: initialConfig, clearFrame }) {
         // Esc abandons the turn in flight and hands the keyboard straight back. The composer is
         // deliberately left alone: cancelling should not cost whatever was typed while waiting.
         if (key.escape && busy && !picker && !keyPrompt && !updatePane && !usagePane) {
-            abortRef.current?.abort();
-            // Anything still waiting on a permission answer is refused rather than left hanging: the
-            // agents are being abandoned, and an unsettled promise keeps the pool alive after the work
-            // it was doing has been given up on.
-            const stranded = askQueueRef.current.drain(false);
-            if (stranded > 0) {
-                setAsk(null);
-                addSystem(`Cancelled with ${stranded} permission ${stranded === 1 ? 'request' : 'requests'} unanswered; refused.`);
-            }
+            cancelCurrentTurn();
             return;
         }
         if (key.ctrl && input === 'c') {
@@ -3358,6 +3592,14 @@ function App({ config: initialConfig, clearFrame }) {
         // The composer used to be append-and-backspace only, so fixing a typo near the start of a
         // long prompt meant deleting everything after it. Everything below is the readline set a
         // shell gives you, so an edit costs one keystroke rather than a retype.
+        if (key.upArrow) {
+            recallDraft(-1);
+            return;
+        }
+        if (key.downArrow) {
+            recallDraft(1);
+            return;
+        }
         if (key.leftArrow) {
             const step = 1 + takeBurst('left');
             setCaret(c => (key.ctrl || key.meta ? wordStart(draft, c) : Math.max(0, c - step)));
@@ -3434,6 +3676,8 @@ function App({ config: initialConfig, clearFrame }) {
                 return;
             const next = draft.slice(0, caret) + text + draft.slice(caret);
             const nextCaret = caret + text.length;
+            // Once the recalled line is edited it is a new draft, not a history cursor position.
+            historyIndexRef.current = null;
             setDraft(next);
             setCaret(nextCaret);
             // A lone "@" at a word boundary offers workspace paths. Checking the draft as it will be,
@@ -3477,6 +3721,13 @@ function App({ config: initialConfig, clearFrame }) {
             const task = expandPastes(shown, pastesRef.current).trim();
             if (!task)
                 return;
+            // A recalled secret is just as dangerous as a saved one. Secret-looking input is sent only
+            // when the user explicitly submits it, and never retained for Up-arrow recall.
+            if (!containsSecret(task)) {
+                draftHistoryRef.current = appendDraftHistory(draftHistoryRef.current, shown);
+            }
+            historyIndexRef.current = null;
+            historyDraftRef.current = '';
             setDraft('');
             setCaret(0);
             pastesRef.current = [];
@@ -3501,6 +3752,8 @@ function App({ config: initialConfig, clearFrame }) {
                 void handleCommand(cmd, arg).finally(() => setBusy(false));
                 return;
             }
+            if (!containsSecret(task))
+                retryTaskRef.current = task;
             setBusy(true);
             setAgentState('processing');
             const started = Date.now();
@@ -3724,7 +3977,7 @@ function App({ config: initialConfig, clearFrame }) {
         });
         return (_jsx(Box, { marginTop: 1, children: _jsx(Panel, { width: panelWidth(lines, barWidth, 40), color: CYAN, title: `Plan  ${done}/${steps.length}`, children: lines }) }, index));
     })() : row.role === 'error' ? (() => {
-        const lines = [row.text ?? '', '', 'Fix the above, then retry. /status shows the active provider and model.'];
+        const lines = [row.text ?? '', '', 'Fix the above, then `/retry` to rerun the task. `/status` shows the active provider and model.'];
         return (_jsx(Box, { marginTop: 1, children: _jsx(Panel, { width: panelWidth(lines, barWidth, 40), color: CRIMSON, title: "[!] ERROR", children: lines }) }, index));
     })() : row.role === 'system' ? (() => {
         const lines = (row.text ?? '').split('\n');
@@ -4013,13 +4266,16 @@ function App({ config: initialConfig, clearFrame }) {
                 // The header is a title on the left and a count on the right, on one line. Estimating the
                 // right-hand side at a constant made "Reference a file or directory" wrap onto two rows.
                 const countText = pickerCountText(pickIndex, list.length, picker.items.length);
-                const headWidth = title.length + countText.length + 3;
-                const rowWidth = Math.max(headWidth, ...shown.map(it => 38 + (it.current ? 10 : 0) + it.desc.length));
+                const headWidth = displayWidth(title) + displayWidth(countText) + 3;
+                // Measure the filtered list, not just its current scroll window. A palette whose right
+                // edge breathes as the highlight crosses a long description feels broken even when the
+                // selection itself is correct.
+                const rowWidth = Math.max(headWidth, ...list.map(it => 38 + (it.current ? 10 : 0) + displayWidth(it.desc) + displayWidth(it.group ?? '') + 3));
                 const boxWidth = Math.max(40, Math.min(barWidth, rowWidth + 4));
                 const width = boxWidth - 4;
                 // Room for the longest label the list actually holds, rather than a constant. A session
                 // title is what identifies the row, and 36 cells cut most of them in half.
-                const labelWidth = pickerLabelWidth(shown.map(it => it.label), shown.map(it => it.desc), width);
+                const labelWidth = pickerLabelWidth(list.map(it => it.label), list.map(it => it.desc), width);
                 let lastGroup;
                 return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: CYAN, paddingX: 1, marginTop: 1, width: boxWidth, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: CYAN, bold: true, children: title }), _jsx(Text, { color: DIM, children: countText })] }), _jsxs(Box, { children: [_jsxs(Text, { color: DIM, children: [G.search, " "] }), pickQuery === ''
                                     ? _jsx(Text, { color: DIM, children: "type to search" })
@@ -4028,9 +4284,9 @@ function App({ config: initialConfig, clearFrame }) {
                             const selected = absolute === pickIndex;
                             const header = item.group && item.group !== lastGroup ? item.group : null;
                             lastGroup = item.group;
-                            const label = item.label.length > 34 ? item.label.slice(0, 31) + '...' : item.label;
-                            return (_jsxs(Box, { flexDirection: "column", children: [header && _jsx(Text, { color: DIM, children: header }), _jsx(Text, { backgroundColor: selected ? CYAN : undefined, color: selected ? '#10222A' : INK, bold: selected, children: fitCells(`${selected ? G.caret + ' ' : '  '}${fitCells(label, labelWidth)}` +
-                                            `${item.current ? '(current) ' : ''}${item.desc}`, width) })] }, item.value + absolute));
+                            const label = pickerLabel(item.label, labelWidth);
+                            return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { backgroundColor: selected ? CYAN : undefined, color: selected ? '#10222A' : INK, bold: selected, children: fitCells(`${selected ? G.caret + ' ' : '  '}${label}` +
+                                        `${item.current ? '(current) ' : ''}${header ? `${header} · ` : ''}${item.desc}`, width) }) }, item.value + absolute));
                         }), list.length > pickerRows && (_jsxs(Text, { color: DIM, children: ["\u2191\u2193 navigate \u00B7 pgup/pgdn jump \u00B7 enter select \u00B7 showing ", Math.max(0, start) + 1, "\u2013", Math.max(0, start) + shown.length, " of ", list.length] }))] }));
             })(), keyPrompt && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: AMBER, paddingX: 1, marginTop: 1, width: barWidth, children: [_jsxs(Text, { color: AMBER, bold: true, children: ["API key for ", keyPrompt.provider] }), _jsx(Text, { color: MUTED, children: "Paste it and press enter. Held in memory for this session only; esc to cancel." }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: MUTED, children: [keyPrompt.env, ": "] }), _jsx(Text, { color: INK, children: '*'.repeat(Math.min(keyPrompt.value.length, 48)) }), _jsx(Text, { color: CYAN, children: "\u2588" })] })] })), ask && (() => {
                 let detail = '';