@pugi/cli 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/tui/input-box.js

@@ -1,27 +1,27 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
- * REPL input box - Sprint α6.14 (REPL UX P0 wave 1).
+ * REPL input box - Sprint (REPL UX P0 wave 1).
  *
- * Bordered, cursor-aware input box matching Claude Code / Codex CLI
- * aesthetics. Layered upgrade over α5.7:
+ * Bordered, cursor-aware input box matching the upstream tool / peer CLI
+ * aesthetics. Layered upgrade over :
  *
- *   - Top divider (full-width cyan rule) anchors the input below the
- *     main pane and gives the operator a clear visual seam.
- *   - Rounded cyan border wraps the prompt + line + cursor.
- *   - Cursor follows the caret position (left/right arrows + Home/End
- *     reposition without losing the trailing text).
- *   - Single-arrow `›` prompt in brand cyan; dim continuation prompt
- *     `┊` when the input wraps past the available width so the operator
- *     sees that they are still inside one logical line.
- *   - History navigation (↑/↓), slash palette inline suggestion, Esc
- *     cancel, Ctrl+C ×2 exit remain wired identically to α5.7.
+ *  - Top divider (full-width cyan rule) anchors the input below the
+ *    main pane and gives the operator a clear visual seam.
+ *  - Rounded cyan border wraps the prompt + line + cursor.
+ *  - Cursor follows the caret position (left/right arrows + Home/End
+ *    reposition without losing the trailing text).
+ *  - Single-arrow `›` prompt in brand cyan; dim continuation prompt
+ *    `┊` when the input wraps past the available width so the operator
+ *    sees that they are still inside one logical line.
+ *  - History navigation (↑/↓), slash palette inline suggestion, Esc
+ *    cancel, Ctrl+C ×2 exit remain wired identically to .
  *
  * State that belongs in this component:
- *   - `line` (string)             - current buffer
- *   - `cursor` (number)           - caret offset into `line`
- *   - `history` (string[])        - session-local; persistence lands in
- *                                   commit 2 (per-workspace JSONL).
- *   - `historyIndex` (number)     - -1 when not navigating
+ *  - `line` (string)            - current buffer
+ *  - `cursor` (number)          - caret offset into `line`
+ *  - `history` (string[])       - session-local; persistence lands in
+ *                                  commit 2 (per-workspace JSONL).
+ *  - `historyIndex` (number)    - -1 when not navigating
  *
  * Brand voice gate: no forbidden words. ASCII-only glyphs.
  */
@@ -33,6 +33,14 @@ import { SlashPalette, completePalette, filterPalette, } from './slash-palette.j
 import { EMPTY_KILL_RING, killToLineEnd, killToLineStart, killWordBackward, yankAtCursor, } from '../core/repl/kill-ring.js';
 import { readClipboard } from '../core/repl/clipboard-read.js';
 const CTRL_C_DOUBLE_TAP_MS = 1_000;
+/**
+ * BT 8 (the upstream tool parity): Esc-Esc walks the conversation back
+ * one turn. 500ms is tight enough that an operator clearing the buffer +
+ * later changing their mind does NOT accidentally pop a turn, while
+ * still feeling like one motion. Matches the upstream tool's documented
+ * double-Esc window.
+ */
+const ESCAPE_DOUBLE_TAP_MS = 500;
 /** Width subtracted from the terminal width so the border + padding fit. */
 const FRAME_OVERHEAD_COLUMNS = 4;
 /** Fallback width when ink cannot read stdout (e.g. test harness). */
@@ -75,6 +83,18 @@ export function InputBox(props) {
     const [history, setHistory] = useState(seededHistory);
     const [historyIndex, setHistoryIndex] = useState(-1);
     const [lastCtrlCAt, setLastCtrlCAt] = useState(undefined);
+    // CEO P0 #2 : the upstream tool parity — surface а visible
+    // "Press Ctrl+C again to exit" toast on the first Ctrl+C press so
+    // the operator knows the second press will terminate the REPL.
+    // Auto-clears after CTRL_C_DOUBLE_TAP_MS so it never lingers past
+    // the double-tap window.
+    const [ctrlCToast, setCtrlCToast] = useState(null);
+    const ctrlCToastTimerRef = useRef(null);
+    // BT 8: Esc-Esc walkback double-tap window. Tracks the epoch
+    // ms of the most recent Esc press so the next Esc within
+    // ESCAPE_DOUBLE_TAP_MS triggers the walkback handler instead of
+    // re-clearing the buffer.
+    const [lastEscapeAt, setLastEscapeAt] = useState(undefined);
     const [cursorVisible, setCursorVisible] = useState(true);
     // Ctrl+R / Ctrl+S reverse-search mode. Undefined when idle, a
     // HistorySearchState while the operator is searching.
@@ -94,6 +114,11 @@ export function InputBox(props) {
     // panes when Ctrl+L wipes the terminal (the parent React tree is
     // otherwise stable and would not redraw on a stdout.write alone).
     const [, setRedrawTick] = useState(0);
+    // Shift+Tab toast — flashed for 2s after a mode cycle so the
+    // operator sees `Mode → acceptEdits` под the input divider. Cleared
+    // by a setTimeout so a quick second Shift+Tab refreshes the toast.
+    const [modeCycleToast, setModeCycleToast] = useState(null);
+    const modeCycleTimerRef = useRef(null);
     const now = props.now ?? Date.now;
     const { stdout } = useStdout();
     const columns = stdout?.columns ?? FALLBACK_COLUMNS;
@@ -131,7 +156,7 @@ export function InputBox(props) {
     useInput((input, key) => {
         if (key.ctrl && input === 'c') {
             const t = now();
-            // α6.9: Claude Code-style double-press semantics. First Ctrl+C
+            // : the upstream tool-style double-press semantics. First Ctrl+C
             // ALWAYS attempts to cancel an in-flight dispatch (when the
             // session reports non-idle); second Ctrl+C within 1s exits the
             // process. If onCancel is omitted (legacy callers, tests), the
@@ -140,7 +165,7 @@ export function InputBox(props) {
             const withinDoubleTapWindow = typeof lastCtrlCAt === 'number' && t - lastCtrlCAt <= CTRL_C_DOUBLE_TAP_MS;
             if (withinDoubleTapWindow) {
                 // Second press inside the window — always exit. This matches
-                // Claude Code: even mid-dispatch, the second Ctrl+C wins so
+                // the upstream tool: even mid-dispatch, the second Ctrl+C wins so
                 // the operator can always escape a stuck REPL.
                 props.onExit();
                 return;
@@ -152,13 +177,13 @@ export function InputBox(props) {
             // tool is running).
             //
             // Three-valued onCancel return (see prop docstring):
-            //   - true       → dispatch cancelled, keep buffer, arm exit timer
-            //   - false      → idle, clear buffer (legacy), arm exit timer
-            //   - undefined  → handler bypassed (modal owns input); NO state
-            //                  change at all. Buffer stays, exit timer NOT
-            //                  armed (otherwise the modal would silently
-            //                  promote a Ctrl+C to "press again to exit",
-            //                  which is wrong context for a modal cancel).
+            //  - true      → dispatch cancelled, keep buffer, arm exit timer
+            //  - false     → idle, clear buffer (legacy), arm exit timer
+            //  - undefined → handler bypassed (modal owns input); NO state
+            //                 change at all. Buffer stays, exit timer NOT
+            //                 armed (otherwise the modal would silently
+            //                 promote a Ctrl+C to "press again to exit",
+            //                 which is wrong context for a modal cancel).
             let cancelResult;
             if (props.onCancel) {
                 cancelResult = props.onCancel();
@@ -173,6 +198,28 @@ export function InputBox(props) {
                 return;
             }
             setLastCtrlCAt(t);
+            // CEO P0 #2 : surface the "Press Ctrl+C again to
+            // exit" toast on the first press so the operator sees the
+            // double-tap semantics in the UI, not just в the bottom hint
+            // line. Mirrors the standard tool's exit affordance verbatim. The
+            // toast string varies by which branch fired (cancel vs idle
+            // clear) so the operator learns what the press just did:
+            //
+            //  - cancelResult === true → "Aborted. Press Ctrl+C again to exit."
+            //  - cancelResult === false → "Press Ctrl+C again to exit."
+            //
+            // (The undefined branch already returned above — а modal owns
+            // input и the toast is suppressed.)
+            const toastCopy = cancelResult === true
+                ? 'Aborted. Press Ctrl+C again to exit.'
+                : 'Press Ctrl+C again to exit.';
+            setCtrlCToast(toastCopy);
+            if (ctrlCToastTimerRef.current)
+                clearTimeout(ctrlCToastTimerRef.current);
+            ctrlCToastTimerRef.current = setTimeout(() => {
+                setCtrlCToast(null);
+                ctrlCToastTimerRef.current = null;
+            }, CTRL_C_DOUBLE_TAP_MS);
             // Legacy behaviour: on idle (or no onCancel wired), clear the
             // buffer + reset search so the operator's screen is calm before
             // they confirm exit. When we DID cancel a live dispatch, keep
@@ -184,6 +231,24 @@ export function InputBox(props) {
             }
             return;
         }
+        // — the upstream tool parity: Shift+Tab cycles permission mode.
+        // The host owns the cycle logic + persistence; we just intercept
+        // the chord and surface a one-line toast on success. Place this
+        // BEFORE the search-mode and palette branches so a Shift+Tab fires
+        // even while reverse-search is active (operator habit-driven).
+        if (key.shift && key.tab && props.onCyclePermissionMode) {
+            const nextMode = props.onCyclePermissionMode();
+            if (nextMode) {
+                setModeCycleToast(`Mode → ${nextMode}`);
+                if (modeCycleTimerRef.current)
+                    clearTimeout(modeCycleTimerRef.current);
+                modeCycleTimerRef.current = setTimeout(() => {
+                    setModeCycleToast(null);
+                    modeCycleTimerRef.current = null;
+                }, 2_000);
+            }
+            return;
+        }
         // Search-mode key handling. Ctrl+R / Ctrl+S cycle, Enter accepts,
         // Esc cancels (restoring the pre-search draft), backspace shortens
         // the query, typed characters extend it.
@@ -202,7 +267,9 @@ export function InputBox(props) {
                 setCursor(draftBeforeSearch.length);
                 return;
             }
-            if (key.return) {
+            // Bare LF accepts the focused match, same as CR (`key.return`).
+            // See the post-search block below for the rationale.
+            if (key.return || (input === '\n' && !key.meta && !key.ctrl && !key.shift)) {
                 const picked = currentBrief(search);
                 setSearch(undefined);
                 if (picked !== null) {
@@ -221,6 +288,11 @@ export function InputBox(props) {
                 return;
             }
             if (input && !key.meta && !key.ctrl) {
+                // Drop a bare LF from the search query — the Enter-accept
+                // branch above already handled it; falling through here would
+                // splice a newline into the search string.
+                if (input === '\n')
+                    return;
                 const nextQuery = search.query + input;
                 setSearch(applyQuery(search, nextQuery, history));
                 return;
@@ -243,6 +315,118 @@ export function InputBox(props) {
             setSearch(initialSearchState(history));
             return;
         }
+        // P0 fix (CEO dogfood, second iteration): bare LF (`\n`)
+        // MUST submit the brief, same as bare CR (`\r`). Ink's parseKeypress
+        // maps `\r` to `key.return` and `\n` to `key.name === 'enter'`
+        // WITHOUT setting `key.return`. Most real terminals deliver CR for
+        // Enter (ICRNL on by default), so the `key.return` branch below
+        // catches them. But when stdin is a PTY whose parent writes raw
+        // `\n` (Python's `pty.fork` + `os.write(fd, b"\n")`, automation
+        // harnesses, certain SSH multiplexers), the LF arrives as a
+        // printable char.
+        //
+        // PR (beta.45) fixed the case where `input === '\n'` exactly.
+        // CEO PTY smoke surfaced the REAL shape: when the parent
+        // writes the brief AND the Enter as separate `os.write` calls (or
+        // even when it doesn't), Node's stdin buffer COALESCES them into
+        // ONE chunk before Ink delivers the `useInput` event. The repro
+        // confirmed via stderr instrumentation: typing `hi\n` arrives in
+        // input-box as `bytes=[68 69 0a] len=3 flags=-` — a SINGLE 3-char
+        // chunk "hi\n" with no key flags. The PR branch (`input ===
+        // '\n'`) does not match, so `hi\n` falls through to the printable-
+        // char branch and the literal newline lands in the buffer as
+        // `› hi\n █` (multi-line composer, brief never dispatches, status
+        // stays `idle` forever).
+        //
+        // Fix: detect a TRAILING `\n` in a printable chunk with no
+        // modifiers — type the prefix into the buffer, then submit. The
+        // discriminator that keeps multi-line paste working: the chunk
+        // must contain EXACTLY ONE `\n` (the trailing one) and no other
+        // newlines. Multi-line pastes have ≥2 `\n` characters (or arrive
+        // wrapped in bracketed-paste markers handled below), so they
+        // still preserve interior newlines via the printable-char branch.
+        //
+        // Detection contract:
+        //  - `input` ends with `\n`
+        //  - no Ctrl / Meta / Shift modifiers
+        //  - exactly ONE `\n` in the chunk (the trailing one)
+        //  - chunk is not bracketed-paste wrapped (markers stripped below)
+        //
+        // Edge cases covered by `test/input-box-lf-submit.spec.tsx`:
+        //  - bare `\n`                 → submit empty (no-op on empty buf)
+        //  - `hi\n`                    → splice `hi` + submit
+        //  - `hi\nthere\n` (multi-line) → printable branch, preserves \n
+        //  - `\r` (CR)                 → key.return branch unchanged
+        //  - `hi\r\n` (CRLF)           → key.return branch (CR wins first)
+        const endsWithLf = input.length > 0 && input.charCodeAt(input.length - 1) === 0x0a;
+        const newlineCount = (input.match(/\n/g) || []).length;
+        if (endsWithLf
+            && newlineCount === 1
+            && !key.meta
+            && !key.ctrl
+            && !key.shift) {
+            // Splice the prefix (everything before the trailing `\n`) into
+            // the buffer at the cursor, then run the canonical submit path.
+            // Refs (cursorRef / lineRef) hold the latest committed values so
+            // the splice runs against the operator's most recent edits even
+            // if a previous async paste / setState is still mid-flight.
+            const prefix = input.slice(0, -1);
+            let mergedLine = lineRef.current;
+            let mergedCursor = cursorRef.current;
+            if (prefix.length > 0) {
+                // Same sanitisation as the printable-char branch below — strip
+                // bracketed-paste markers so a stray escape sequence never
+                // lands in the submitted brief.
+                const stripped = prefix
+                    .replace(/\x1b\[200~/g, '')
+                    .replace(/\x1b\[201~/g, '')
+                    .replace(/\[200~/g, '')
+                    .replace(/\[201~/g, '');
+                if (stripped.length > 0) {
+                    mergedLine =
+                        mergedLine.slice(0, mergedCursor) + stripped + mergedLine.slice(mergedCursor);
+                    mergedCursor = mergedCursor + stripped.length;
+                }
+            }
+            // Synthesise the same payload-shape the `key.return` branch
+            // below uses so palette completion + history dedup + onSubmit
+            // dispatch all run identically.
+            const paletteHere = !paletteSuppressed
+                ? filterPalette(mergedLine)
+                : { rows: [], totalBeforeLimit: 0 };
+            const paletteOpenHere = paletteHere.rows.length > 0;
+            const paletteFocusedIndexHere = paletteHere.rows.length === 0
+                ? 0
+                : Math.min(paletteIndex, paletteHere.rows.length - 1);
+            let payload = mergedLine;
+            if (paletteOpenHere) {
+                const completed = completePalette(mergedLine, paletteHere.rows, paletteFocusedIndexHere);
+                if (completed !== null)
+                    payload = completed;
+            }
+            const trimmed = payload.trim();
+            if (trimmed.length > 0) {
+                setHistory((prev) => {
+                    if (prev[prev.length - 1] === trimmed)
+                        return prev;
+                    return [...prev, trimmed];
+                });
+                setHistoryIndex(-1);
+                if (props.workspaceSlug) {
+                    appendHistory({
+                        home: props.historyHome,
+                        workspaceSlug: props.workspaceSlug,
+                        brief: trimmed,
+                    });
+                }
+                props.onSubmit(trimmed);
+            }
+            setLine('');
+            setCursor(0);
+            setPaletteSuppressed(false);
+            setPaletteIndex(0);
+            return;
+        }
         // Readline-style kill ring shortcuts. All four kills push the
         // removed slice onto the ring; Ctrl+Y yanks the most recent.
         if (key.ctrl && input === 'u') {
@@ -375,10 +559,41 @@ export function InputBox(props) {
         if (key.escape) {
             if (paletteOpen) {
                 // Close the palette without clearing the buffer so the operator
-                // can still send `/help` as plain text if they want.
+                // can still send `/help` as plain text if they want. Palette
+                // takes precedence over walkback because the operator's mental
+                // model is "Esc closes the visible overlay first".
                 setPaletteSuppressed(true);
+                setLastEscapeAt(undefined);
+                return;
+            }
+            // BT 8: Esc-Esc walkback. Two presses within
+            // ESCAPE_DOUBLE_TAP_MS step the conversation back by one turn.
+            // First press still clears the buffer (legacy behaviour for the
+            // single-Esc cancel UX); the second press calls the host's
+            // walkback handler. Buffer-clear on the first press is what makes
+            // the double-tap feel "free" - the operator did not have to
+            // memorise a new chord; they just have to keep pressing.
+            const tEsc = now();
+            const withinEscapeWindow = typeof lastEscapeAt === 'number'
+                && tEsc - lastEscapeAt <= ESCAPE_DOUBLE_TAP_MS;
+            if (withinEscapeWindow && props.onWalkback) {
+                // Second tap inside the window. Buffer was already cleared on
+                // the first press, so the host sees a clean input box AND the
+                // walkback result. We clear the window so a third tap restarts
+                // the cycle (no run-on walkbacks from a stuck Esc key).
+                const verdict = props.onWalkback();
+                setLastEscapeAt(undefined);
+                if (verdict !== 'walked-back') {
+                    // Host refused (dispatch in flight, no turns to pop). The
+                    // host owns the refusal copy via its own writeOutput path;
+                    // we do not double-message here.
+                    return;
+                }
                 return;
             }
+            // First Esc (or no walkback wired). Arm the window + clear the
+            // buffer per the long-standing single-Esc cancel contract.
+            setLastEscapeAt(tEsc);
             setLine('');
             setCursor(0);
             setHistoryIndex(-1);
@@ -442,7 +657,7 @@ export function InputBox(props) {
             // Read cursor via ref inside the updater so the slice indices come
             // from the latest committed value, not the closure-captured one.
             // Same React-18 strict-mode race that bit the Ctrl+V paste path
-            // (Claude P1 on PR #335 wave 1): updaters run twice under strict
+            // (Claude P1 on PR wave 1): updaters run twice under strict
             // mode, and a stale closure `cursor` produces a double-edit on the
             // second invocation. cursorRef is the canonical fix — do NOT
             // re-introduce closure `cursor` inside setLine updaters.
@@ -479,7 +694,7 @@ export function InputBox(props) {
             // Read cursor via ref inside the updater so the splice indices come
             // from the latest committed value, not the closure-captured one.
             // Same React-18 strict-mode race that bit the Ctrl+V paste path
-            // (Claude P1 on PR #335 wave 1): updaters run twice under strict
+            // (Claude P1 on PR wave 1): updaters run twice under strict
             // mode, and a stale closure `cursor` produces a duplicated insert
             // on the second invocation. cursorRef is the canonical fix — do
             // NOT re-introduce closure `cursor` inside setLine updaters.
@@ -499,7 +714,7 @@ export function InputBox(props) {
         : Math.min(paletteIndex, paletteView.rows.length - 1);
     const divider = '─'.repeat(innerWidth);
     const focusedMatch = search ? search.matches[search.focusedIndex] : undefined;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next  ·  Ctrl+S prev  ·  Enter accept  ·  Esc cancel  ·  ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "cyan", dimColor: true, children: divider }), line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history  ·  Ctrl+R search  ·  / commands  ·  Enter brief  ·  Esc cancel  ·  Ctrl+C abort / ×2 exit' }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "#3da9fc", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next · Ctrl+S prev · Enter accept · Esc cancel · ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "#3da9fc", dimColor: true, children: divider }), modeCycleToast ? (_jsx(Box, { children: _jsx(Text, { color: "#3da9fc", bold: true, children: ` ${modeCycleToast}` }) })) : null, ctrlCToast ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", bold: true, children: ` ${ctrlCToast}` }) })) : null, line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history · Ctrl+R search · / commands · Shift+Tab mode · Enter brief · Esc cancel · Ctrl+C abort / ×2 exit' }) })] }));
 }
 /**
  * Render the line with the cursor glyph inserted at `cursor`. The cursor

package/dist/tui/login-picker.js

@@ -54,15 +54,15 @@ export function LoginPicker(props) {
         if (input === '3')
             props.onSelect('env');
     });
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Sign in to Pugi" }), _jsx(Text, { dimColor: true, children: `      (endpoint: ${props.apiUrl})` })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: ITEMS.map((item, itemIndex) => {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Sign in to Pugi" }), _jsx(Text, { dimColor: true, children: `     (endpoint: ${props.apiUrl})` })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: ITEMS.map((item, itemIndex) => {
                     const isSelected = itemIndex === index;
                     return (_jsx(PickerRow, { isSelected: isSelected, title: item.title, hint: item.hint }, item.provider));
-                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '↑/↓ select   Enter confirm   Esc cancel' }) })] }));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '↑/↓ select  Enter confirm  Esc cancel' }) })] }));
 }
 function PickerRow({ isSelected, title, hint, }) {
     // Arrow glyph + padded title so highlighted and dim rows share
     // column alignment.
-    const indicator = isSelected ? '▸ ' : '  ';
+    const indicator = isSelected ? '▸ ' : ' ';
     const padded = title.padEnd(22, ' ');
     return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, padded] }), _jsx(Text, { dimColor: true, children: hint })] }));
 }

package/dist/tui/markdown-render.js

@@ -95,7 +95,7 @@ function parseBlocks(source) {
     return blocks;
 }
 /* ------------------------------------------------------------------ */
-/* Block renderers                                                    */
+/* Block renderers                                                   */
 /* ------------------------------------------------------------------ */
 function renderBlock(block, key) {
     switch (block.kind) {
@@ -107,9 +107,9 @@ function renderBlock(block, key) {
         case 'paragraph':
             return (_jsx(Text, { children: renderInline(block.text) }, key));
         case 'bullet':
-            return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '• ' }), _jsx(Text, { children: renderInline(block.text) })] }, key));
+            return (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '• ' }), _jsx(Text, { children: renderInline(block.text) })] }, key));
         case 'ordered':
-            return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: `${block.index}. ` }), _jsx(Text, { children: renderInline(block.text) })] }, key));
+            return (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: `${block.index}. ` }), _jsx(Text, { children: renderInline(block.text) })] }, key));
         case 'code':
             return renderCodeBlock(block.lang, block.body, key);
         case 'blank':
@@ -148,7 +148,7 @@ function renderCodeLine(line, keywords) {
             spans.push(_jsx(Text, { color: "green", children: tok }, key));
         }
         else if (keywords.includes(tok)) {
-            spans.push(_jsx(Text, { color: "cyan", bold: true, children: tok }, key));
+            spans.push(_jsx(Text, { color: "#3da9fc", bold: true, children: tok }, key));
         }
         else {
             spans.push(_jsx(Text, { children: tok }, key));
@@ -184,7 +184,7 @@ function findCommentStart(line) {
     return -1;
 }
 /* ------------------------------------------------------------------ */
-/* Inline tokeniser                                                   */
+/* Inline tokeniser                                                  */
 /* ------------------------------------------------------------------ */
 /**
  * Parse one paragraph line into a list of inline spans, then render
@@ -260,7 +260,7 @@ function renderSpan(span, key) {
         case 'code':
             return _jsx(Text, { color: "green", children: span.text }, key);
         case 'link':
-            return (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", underline: true, children: span.text }), _jsx(Text, { dimColor: true, children: ` (${span.url})` })] }, key));
+            return (_jsxs(Text, { children: [_jsx(Text, { color: "#3da9fc", underline: true, children: span.text }), _jsx(Text, { dimColor: true, children: ` (${span.url})` })] }, key));
     }
 }
 //# sourceMappingURL=markdown-render.js.map