@pugi/cli 0.1.0-alpha.9 → 0.1.0-beta.2

package/dist/tools/web-fetch.js

@@ -240,7 +240,7 @@ function ipv4IsBlocked(ip) {
  * a literal IP (with brackets stripped). We honor that fast-path and
  * skip DNS.
  */
-async function validateHostnameForFetch(hostname) {
+export async function validateHostnameForFetch(hostname) {
     // URL.hostname keeps the brackets off IPv6 literals already.
     if (!hostname)
         return 'empty hostname';

package/dist/tui/agent-tree-pane.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { AgentTree } from './agent-tree.js';
+export function AgentTreePane(props) {
+    const onWatch = props.agents.filter((a) => a.status === 'queued' || a.status === 'thinking').length;
+    const total = props.agents.length;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, dimColor: true, children: '─ agents ' }), _jsx(Text, { dimColor: true, children: `(${total} total, ${onWatch} on watch)` })] }), _jsx(AgentTree, { agents: props.agents, nowEpochMs: props.nowEpochMs })] }));
+}
+//# sourceMappingURL=agent-tree-pane.js.map

package/dist/tui/ask-cli.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, useApp } from 'ink';
+import { AskModal, PlanReviewModal } from './ask-modal.js';
+export async function renderAskCli(options) {
+    let resolveOuter;
+    const outerPromise = new Promise((resolve) => {
+        resolveOuter = resolve;
+    });
+    function App() {
+        const { exit } = useApp();
+        return (_jsx(AskModal, { tag: options.tag, onResolve: (verdict) => {
+                resolveOuter(verdict);
+                // Slight delay so Ink flushes the unmount before the parent
+                // CLI prints the verdict line. Otherwise the modal frame and
+                // the verdict line can interleave on slow terminals.
+                setTimeout(() => exit(), 16);
+            } }));
+    }
+    const instance = render(_jsx(App, {}));
+    const verdict = await outerPromise;
+    try {
+        await instance.waitUntilExit();
+    }
+    catch {
+        // Ink may throw if exit() races with a re-render; the verdict is
+        // already captured so we ignore.
+    }
+    return verdict;
+}
+export async function renderPlanReviewCli(options) {
+    let resolveOuter;
+    const outerPromise = new Promise((resolve) => {
+        resolveOuter = resolve;
+    });
+    function App() {
+        const { exit } = useApp();
+        return (_jsx(PlanReviewModal, { tag: options.tag, onResolve: (result) => {
+                resolveOuter(result);
+                setTimeout(() => exit(), 16);
+            } }));
+    }
+    const instance = render(_jsx(App, {}));
+    const result = await outerPromise;
+    try {
+        await instance.waitUntilExit();
+    }
+    catch {
+        // See renderAskCli — captured verdict supersedes a late Ink throw.
+    }
+    return result;
+}
+//# sourceMappingURL=ask-cli.js.map

package/dist/tui/ask-modal.js

@@ -0,0 +1,211 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Office-hours forcing questions + plan-review modals - Sprint α6.3.
+ *
+ * Two Ink components feed by the parsed `<pugi-ask>` / `<pugi-plan-review>`
+ * tag records the session module extracts from persona output.
+ *
+ *   - <AskModal />: numbered options (1-4) + optional "Other" custom-input
+ *     fallback. Operator types `1`, `2`, `3`, `4`, or `o <free text>`.
+ *
+ *   - <PlanReviewModal />: numbered steps + optional risk callout +
+ *     three-way verdict `[a] approve · [m] modify · [c] cancel`.
+ *     Operator types `a`, `m`, or `c`. `m` opens a free-text editor;
+ *     the operator's edited text is returned verbatim to the session.
+ *
+ * Both components are PURE in the Ink sense — they read props + own
+ * useState for the input buffer, and emit one final `onResolve` callback
+ * when the operator submits. The REPL root handles wiring the verdict
+ * back into the session as the next user turn (prefixed with
+ * `[ASK-RESPONSE:<value>]` / `[PLAN-VERDICT:approve|modify|cancel] ...`)
+ * so the persona transcript stays linear.
+ *
+ * Brand voice gate: ASCII glyphs only, no em-dashes, no banned brand
+ * words (journey, explore, delight, magical, friendly, AI-powered,
+ * pug-tastic). The modal copy is power-word neutral so a localized
+ * variant lands cleanly later.
+ */
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function AskModal(props) {
+    const [mode, setMode] = useState('pick');
+    const [buffer, setBuffer] = useState('');
+    useInput((input, key) => {
+        // Esc cancels the modal in either mode.
+        if (key.escape) {
+            props.onResolve({ value: '', cancelled: true });
+            return;
+        }
+        if (mode === 'pick') {
+            // Numeric keys 1..N select the matching option, capped at the
+            // total option count. Out-of-range keys are ignored.
+            const numeric = Number.parseInt(input, 10);
+            if (!Number.isNaN(numeric) && numeric >= 1 && numeric <= props.tag.options.length) {
+                const opt = props.tag.options[numeric - 1];
+                if (opt) {
+                    props.onResolve({ value: opt.value, cancelled: false });
+                    return;
+                }
+            }
+            // The "Other" sentinel is the index = options.length + 1. We
+            // also accept `o` (lowercase) as a hotkey since the cursor key
+            // for "Other" is always one-past-the-last numeric.
+            const otherIndex = props.tag.options.length + 1;
+            if ((!Number.isNaN(numeric) && numeric === otherIndex)
+                || input === 'o'
+                || input === 'O') {
+                setMode('custom');
+                setBuffer('');
+                return;
+            }
+            // Any other keystroke: ignored. The hint footer tells the
+            // operator the legal keys.
+            return;
+        }
+        // Custom-input mode: line editor.
+        if (key.return) {
+            // Empty buffer + Enter = cancel custom (return to pick).
+            if (buffer.trim().length === 0) {
+                setMode('pick');
+                setBuffer('');
+                return;
+            }
+            props.onResolve({
+                value: '',
+                customInput: buffer.trim(),
+                cancelled: false,
+            });
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setBuffer((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (input && !key.meta && !key.ctrl) {
+            setBuffer((prev) => prev + input);
+        }
+    }, { isActive: props.inert !== true });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: '? ' }), _jsx(Text, { bold: true, children: 'Need your call before I continue' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: props.tag.question }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [props.tag.options.map((opt, idx) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: opt.label })] }), opt.desc ? (_jsx(Box, { marginLeft: 5, children: _jsx(Text, { dimColor: true, children: opt.desc }) })) : null] }, opt.value))), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${props.tag.options.length + 1}. ` }), _jsx(Text, { dimColor: true, children: 'Other (type a custom answer)' })] })] }), mode === 'pick' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `Press 1-${props.tag.options.length + 1} to choose. Esc cancels.` }) })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type your custom answer. Enter submits. Esc cancels.' }) })] }))] }));
+}
+export function PlanReviewModal(props) {
+    const [mode, setMode] = useState('pick');
+    const [buffer, setBuffer] = useState('');
+    useInput((input, key) => {
+        if (key.escape) {
+            // Escape from EITHER mode means cancel — symmetric with AskModal.
+            props.onResolve({ verdict: 'cancel' });
+            return;
+        }
+        if (mode === 'pick') {
+            if (input === 'a' || input === 'A') {
+                props.onResolve({ verdict: 'approve' });
+                return;
+            }
+            if (input === 'c' || input === 'C') {
+                props.onResolve({ verdict: 'cancel' });
+                return;
+            }
+            if (input === 'm' || input === 'M') {
+                setMode('modify');
+                setBuffer('');
+                return;
+            }
+            return;
+        }
+        // Modify-mode line editor.
+        if (key.return) {
+            if (buffer.trim().length === 0) {
+                setMode('pick');
+                setBuffer('');
+                return;
+            }
+            props.onResolve({ verdict: 'modify', modifyText: buffer.trim() });
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setBuffer((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (input && !key.meta && !key.ctrl) {
+            setBuffer((prev) => prev + input);
+        }
+    }, { isActive: props.inert !== true });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "magenta", children: '? ' }), _jsx(Text, { bold: true, children: 'Plan review - approve before I execute' })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: 'Steps:' }), props.tag.steps.map((step, idx) => (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: step.text })] }, `step-${idx}`)))] }), props.tag.risk ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "red", children: 'Risk:' }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { children: props.tag.risk }) })] })) : null, mode === 'pick' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: '  [a] approve  ' }), _jsx(Text, { color: "yellow", bold: true, children: '[m] modify  ' }), _jsx(Text, { color: "red", bold: true, children: '[c] cancel' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Press a, m, or c. Esc cancels.' }) })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: 'modify > ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type the revision. Enter submits. Esc cancels.' }) })] }))] }));
+}
+/* ------------------------------------------------------------------ */
+/* Verdict serialisation                                              */
+/* ------------------------------------------------------------------ */
+/**
+ * Encode an ask-modal verdict into the literal string the session
+ * injects as the next operator turn. The persona's prompt teaches it
+ * to recognise this prefix, so the conversation stays coherent without
+ * a side channel.
+ *
+ * Examples:
+ *   { value: 'vercel' }              -> "[ASK-RESPONSE:vercel]"
+ *   { value: '', customInput: 'gcp'} -> "[ASK-RESPONSE:other] gcp"
+ *   { cancelled: true }              -> "[ASK-RESPONSE:cancelled]"
+ *
+ * customInput is stripped of any leading `[ASK-RESPONSE:...]` /
+ * `[PLAN-VERDICT:...]` pattern so a forged operator prefix cannot be
+ * read as a different verdict by a prefix-greedy persona (Claude
+ * triple-review P1, PR #375).
+ */
+export function encodeAskVerdict(verdict) {
+    if (verdict.cancelled)
+        return '[ASK-RESPONSE:cancelled]';
+    if (verdict.value.length > 0)
+        return `[ASK-RESPONSE:${verdict.value}]`;
+    const customInput = verdict.customInput
+        ? sanitiseVerdictText(verdict.customInput)
+        : '';
+    if (customInput.length > 0) {
+        return `[ASK-RESPONSE:other] ${customInput}`;
+    }
+    return '[ASK-RESPONSE:cancelled]';
+}
+/**
+ * Encode a plan-review verdict into the next operator turn. Mirrors
+ * the ask encoding so the persona sees a single grammar.
+ *
+ * modifyText is sanitised against verdict-header forgery the same way
+ * customInput is in encodeAskVerdict (Claude triple-review P1).
+ */
+export function encodePlanReviewVerdict(result) {
+    switch (result.verdict) {
+        case 'approve':
+            return '[PLAN-VERDICT:approve]';
+        case 'cancel':
+            return '[PLAN-VERDICT:cancel]';
+        case 'modify': {
+            const modifyText = result.modifyText
+                ? sanitiseVerdictText(result.modifyText)
+                : '';
+            if (modifyText.length > 0) {
+                return `[PLAN-VERDICT:modify] ${modifyText}`;
+            }
+            return '[PLAN-VERDICT:cancel]';
+        }
+    }
+}
+/**
+ * Strip any leading `[ASK-RESPONSE:...]` or `[PLAN-VERDICT:...]`
+ * pattern from free-text operator input so a malicious or accidental
+ * operator string cannot forge a verdict header. Iterates because the
+ * operator could prepend several forged headers in a row.
+ *
+ * Mirrors the same-named helper in core/repl/session.ts. Kept in both
+ * modules so the test surfaces of ask-modal and session are
+ * independently exercisable without circular imports.
+ */
+function sanitiseVerdictText(raw) {
+    let cleaned = raw;
+    for (let i = 0; i < raw.length + 4; i += 1) {
+        const stripped = cleaned.replace(/^\s*\[(?:ASK-RESPONSE|PLAN-VERDICT):[^\]]*\]\s*/u, '');
+        if (stripped === cleaned)
+            break;
+        cleaned = stripped;
+    }
+    return cleaned.trim();
+}
+//# sourceMappingURL=ask-modal.js.map

package/dist/tui/conversation-pane.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { MarkdownRender } from './markdown-render.js';
 const HUE_COLOR_BY_SLUG = {
     // Mira (Pug) - coordinator
     main: 'cyan',
@@ -23,10 +24,14 @@ const HUE_COLOR_BY_SLUG = {
     analyst: 'gray',
 };
 export function ConversationPane(props) {
+    const showHeader = props.showHeader !== false;
     if (props.rows.length === 0) {
-        return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Brief the workforce to begin. Try a short sentence or /help." }) }));
+        return (_jsxs(Box, { flexDirection: "column", children: [showHeader ? _jsx(PaneHeader, { count: 0 }) : null, _jsx(Text, { dimColor: true, children: "Brief the workforce to begin. Try a short sentence or /help." })] }));
     }
-    return (_jsx(Box, { flexDirection: "column", children: props.rows.map((row) => (_jsx(ConversationRow, { row: row, personaNames: props.personaNames }, row.id))) }));
+    return (_jsxs(Box, { flexDirection: "column", children: [showHeader ? _jsx(PaneHeader, { count: props.rows.length }) : null, props.rows.map((row) => (_jsx(ConversationRow, { row: row, personaNames: props.personaNames }, row.id)))] }));
+}
+function PaneHeader({ count }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, dimColor: true, children: '─ conversation ' }), _jsx(Text, { dimColor: true, children: `(${count} row${count === 1 ? '' : 's'})` })] }));
 }
 function ConversationRow({ row, personaNames, }) {
     switch (row.source) {
@@ -38,8 +43,48 @@ function ConversationRow({ row, personaNames, }) {
             const slug = row.personaSlug ?? '';
             const color = HUE_COLOR_BY_SLUG[slug] ?? 'white';
             const displayName = personaNames?.get(slug) ?? slug;
-            return (_jsxs(Box, { children: [_jsx(Text, { color: color, bold: true, children: `▸ ${displayName} ` }), _jsx(Text, { children: row.text })] }));
+            // α6.12: persona bodies travel through MarkdownRender so code
+            // fences, headings, and inline accents land correctly. A row that
+            // carries no Markdown syntax renders as plain text under the same
+            // path (the parser falls through to a single paragraph span), so
+            // there is no regression for the simple "Mira shipped." baseline.
+            const containsMarkdown = looksLikeMarkdown(row.text);
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: color, bold: true, children: `▸ ${displayName} ` }), containsMarkdown ? null : _jsx(Text, { children: row.text })] }), containsMarkdown ? (_jsx(Box, { marginLeft: 2, children: _jsx(MarkdownRender, { source: row.text }) })) : null] }));
         }
     }
 }
+/**
+ * Cheap heuristic for "this transcript row will benefit from Markdown
+ * rendering". We only pay the parser cost when the row plausibly
+ * contains a code fence, heading, list item, or inline accent. A bare
+ * "Mira shipped." line takes the legacy fast path.
+ *
+ * The probe is intentionally generous - false positives just route
+ * through the parser, which renders plain text identically.
+ */
+function looksLikeMarkdown(text) {
+    if (text.length === 0)
+        return false;
+    if (text.includes('```'))
+        return true;
+    // Codex P2 PR #369: intro-plus-list shape ("Summary:\n- bullet")
+    // must route through renderer. Scan EVERY line, not just the first.
+    const lines = text.split('\n');
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (/^#{1,6}\s/.test(line))
+            return true;
+        if (/^[-*+]\s/.test(line))
+            return true;
+        if (/^\d+\.\s/.test(line))
+            return true;
+    }
+    if (/\*\*[^*]+\*\*/.test(text))
+        return true;
+    if (/`[^`]+`/.test(text))
+        return true;
+    if (/\[[^\]]+\]\([^)]+\)/.test(text))
+        return true;
+    return false;
+}
 //# sourceMappingURL=conversation-pane.js.map

package/dist/tui/input-box.js

@@ -131,14 +131,57 @@ export function InputBox(props) {
     useInput((input, key) => {
         if (key.ctrl && input === 'c') {
             const t = now();
-            if (typeof lastCtrlCAt === 'number' && t - lastCtrlCAt <= CTRL_C_DOUBLE_TAP_MS) {
+            // α6.9: Claude Code-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
+            // old behaviour is preserved: first Ctrl+C clears the buffer +
+            // arms the exit timer, second Ctrl+C exits.
+            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 operator can always escape a stuck REPL.
                 props.onExit();
                 return;
             }
+            // First press in a fresh window. If the host wired a cancel
+            // surface and there is something to cancel, abort the dispatch.
+            // The buffer is left untouched on a cancel (the operator's
+            // current input is NOT trashed by an accidental Ctrl+C while a
+            // 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).
+            let cancelResult;
+            if (props.onCancel) {
+                cancelResult = props.onCancel();
+            }
+            if (cancelResult === undefined && props.onCancel) {
+                // Bypass path - modal owns the input. Drop the press silently
+                // so the modal's own cancel surface (Esc / its own Ctrl+C
+                // binding inside the modal component) takes effect on its own
+                // terms. P2 fix: previously this fell through to the
+                // legacy buffer-clear + setLastCtrlCAt path and wiped modal
+                // draft text on first Ctrl+C.
+                return;
+            }
             setLastCtrlCAt(t);
-            setLine('');
-            setCursor(0);
-            setSearch(undefined);
+            // 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
+            // the buffer so a half-typed brief is not lost.
+            if (cancelResult !== true) {
+                setLine('');
+                setCursor(0);
+                setSearch(undefined);
+            }
             return;
         }
         // Search-mode key handling. Ctrl+R / Ctrl+S cycle, Enter accepts,
@@ -456,7 +499,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 ×2 exit' }) })] }));
+    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' }) })] }));
 }
 /**
  * Render the line with the cursor glyph inserted at `cursor`. The cursor