@pugi/cli 0.1.0-beta.5 → 0.1.0-beta.50

package/dist/tui/feedback-prompt.js

@@ -0,0 +1,156 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * `/feedback` interactive prompt — Leak L21 (2026-05-27).
+ *
+ * Five-step wizard mounted from both the top-level `pugi feedback`
+ * shell handler and the in-REPL `/feedback` slash. Steps:
+ *
+ *   1. category  — bug / feature / general / praise (numeric pick 1-4)
+ *   2. rating    — 1-5 stars (numeric pick 1-5)
+ *   3. comment   — free-text, multi-line, Ctrl-D submits, Esc cancels
+ *   4. context   — y/n include last 5 turns (redacted)? default no
+ *   5. confirm   — y/n submit?
+ *
+ * Brand voice gate: ASCII glyphs only, no em-dashes, no banned brand
+ * words. Copy is intentionally power-word neutral so the future i18n
+ * landing localises cleanly.
+ *
+ * The component is PURE in the Ink sense — props in, one terminal
+ * `onResolve` event out. The caller owns the submit + queue logic.
+ *
+ * The verdict the operator submits is:
+ *   - `{ cancelled: true }` when the operator presses Esc at any step
+ *   - `{ cancelled: false, draft }` when the wizard completes
+ *
+ * `draft` is the assembled `FeedbackDraft` — NOT yet a full envelope
+ * (the caller still injects `ts` + `cliVersion` + maybe `tier`).
+ */
+import { useState } from 'react';
+import { Box, Text, render, useApp, useInput } from 'ink';
+const CATEGORIES = [
+    { value: 'bug', label: 'bug', gloss: 'something broke or behaves unexpectedly' },
+    { value: 'feature', label: 'feature', gloss: 'request a new capability' },
+    { value: 'general', label: 'general', gloss: 'observation, idea, comment' },
+    { value: 'praise', label: 'praise', gloss: 'positive note for the team' },
+];
+export function FeedbackPrompt(props) {
+    const [step, setStep] = useState('category');
+    const [category, setCategory] = useState(null);
+    const [rating, setRating] = useState(null);
+    const [commentBuffer, setCommentBuffer] = useState('');
+    const [includeContext, setIncludeContext] = useState(false);
+    useInput((input, key) => {
+        if (key.escape) {
+            props.onResolve({ cancelled: true });
+            return;
+        }
+        if (step === 'category') {
+            const n = Number.parseInt(input, 10);
+            if (!Number.isNaN(n) && n >= 1 && n <= CATEGORIES.length) {
+                const picked = CATEGORIES[n - 1];
+                if (picked) {
+                    setCategory(picked.value);
+                    setStep('rating');
+                }
+            }
+            return;
+        }
+        if (step === 'rating') {
+            const n = Number.parseInt(input, 10);
+            if (!Number.isNaN(n) && n >= 1 && n <= 5) {
+                setRating(n);
+                setStep('comment');
+            }
+            return;
+        }
+        if (step === 'comment') {
+            // Ctrl-D submits the comment (even when empty — rating-only
+            // feedback is allowed). Enter inserts a newline so the
+            // operator can write multi-line bug repros without the wizard
+            // ending the buffer prematurely.
+            if (key.ctrl && (input === 'd' || input === '')) {
+                setStep('context');
+                return;
+            }
+            if (key.return) {
+                setCommentBuffer((prev) => prev + '\n');
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setCommentBuffer((prev) => prev.slice(0, -1));
+                return;
+            }
+            // Printable characters land in the buffer. We accept anything
+            // non-empty + non-control. Ink's useInput sometimes delivers
+            // multi-char paste bursts as one `input` — we append the whole
+            // burst so paste lands intact.
+            if (input && !key.ctrl && !key.meta) {
+                setCommentBuffer((prev) => prev + input);
+            }
+            return;
+        }
+        if (step === 'context') {
+            if (input === 'y' || input === 'Y') {
+                setIncludeContext(true);
+                setStep('confirm');
+                return;
+            }
+            if (input === 'n' || input === 'N' || key.return) {
+                // Default no — Enter at the context prompt picks "no" so
+                // the operator can blast through with all defaults.
+                setIncludeContext(false);
+                setStep('confirm');
+                return;
+            }
+            return;
+        }
+        if (step === 'confirm') {
+            if (input === 'y' || input === 'Y' || key.return) {
+                if (category != null && rating != null) {
+                    props.onResolve({
+                        cancelled: false,
+                        draft: {
+                            category,
+                            rating,
+                            comment: commentBuffer,
+                            includeSessionContext: includeContext,
+                        },
+                    });
+                }
+                return;
+            }
+            if (input === 'n' || input === 'N') {
+                props.onResolve({ cancelled: true });
+                return;
+            }
+            return;
+        }
+    }, { isActive: !props.inert });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Pugi /feedback" }), _jsx(Text, { children: " \u2014 share what you saw. Esc cancels at any step." })] }), step === 'category' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "1. Category" }), CATEGORIES.map((c, idx) => (_jsx(Text, { children: `  ${idx + 1}. ${c.label.padEnd(8)} ${c.gloss}` }, c.value))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Pick 1-4." }) })] })), step === 'rating' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "2. Rating" }), _jsx(Text, { children: `  1=poor, 5=excellent. Picked category: ${category ?? '?'}` }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Pick 1-5." }) })] })), step === 'comment' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "3. Comment" }), _jsx(Text, { dimColor: true, children: "Multi-line. Enter inserts a newline. Ctrl-D submits." }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: commentBuffer.length === 0 ? (_jsx(Text, { dimColor: true, children: "(empty \u2014 Ctrl-D submits without a comment)" })) : (commentBuffer.split('\n').map((line, idx) => (_jsx(Text, { children: `> ${line}` }, idx)))) })] })), step === 'context' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "4. Include session context?" }), _jsx(Text, { children: '  Last 5 turns, redacted (tokens / *_KEY=* values stripped).' }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "y / n \u2014 default n (Enter)." }) })] })), step === 'confirm' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "5. Submit?" }), _jsx(Text, { children: `  category=${category ?? '?'} rating=${rating ?? '?'} context=${includeContext ? 'yes' : 'no'}` }), _jsx(Text, { children: `  comment=${commentBuffer.length} chars` }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "y / n \u2014 default y (Enter)." }) })] }))] }));
+}
+export async function renderFeedbackPrompt() {
+    let resolveOuter;
+    const outerPromise = new Promise((resolve) => {
+        resolveOuter = resolve;
+    });
+    function App() {
+        const { exit } = useApp();
+        return (_jsx(FeedbackPrompt, { onResolve: (verdict) => {
+                resolveOuter(verdict);
+                // Mirror renderAskCli: tiny delay so Ink flushes unmount
+                // before the caller prints the toast line.
+                setTimeout(() => exit(), 16);
+            } }));
+    }
+    const instance = render(_jsx(App, {}));
+    const verdict = await outerPromise;
+    try {
+        await instance.waitUntilExit();
+    }
+    catch {
+        // Ink can throw when exit() races with a re-render — the verdict
+        // is already captured so we ignore.
+    }
+    return verdict;
+}
+//# sourceMappingURL=feedback-prompt.js.map

package/dist/tui/input-box.js

@@ -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;
+/**
+ * Wave 6 BT 8 (Claude Code 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 Claude Code'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 (2026-05-29): Claude Code 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);
+    // Wave 6 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);
+    // Wave 7 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;
@@ -173,6 +198,28 @@ export function InputBox(props) {
                 return;
             }
             setLastCtrlCAt(t);
+            // CEO P0 #2 (2026-05-29): 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 Claude Code'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;
         }
+        // Wave 7 — Claude Code 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 2026-05-29 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 #697 (beta.45) fixed the case where `input === '\n'` exactly.
+        // CEO PTY smoke 2026-05-29 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 #697 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;
+            }
+            // Wave 6 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);
@@ -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/markdown-render.js

@@ -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));
@@ -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