@pugi/cli 0.1.0-beta.3 → 0.1.0-beta.31

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,11 @@ export function InputBox(props) {
     const [history, setHistory] = useState(seededHistory);
     const [historyIndex, setHistoryIndex] = useState(-1);
     const [lastCtrlCAt, setLastCtrlCAt] = useState(undefined);
+    // 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.
@@ -375,10 +388,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 +543,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 }), 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

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

package/dist/tui/onboarding-wizard.js

@@ -0,0 +1,240 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Leak L25 (2026-05-27) — Onboarding Ink wizard.
+ *
+ * Six-screen interactive walk:
+ *
+ *   1. Welcome + auth status         (single Enter to continue)
+ *   2. Default permission mode       (4-row picker)
+ *   3. Output style preset           (5-row picker)
+ *   4. MCP server pointer            (informational, Enter to continue)
+ *   5. Telemetry consent             (3-row picker)
+ *   6. Recap card                    (Enter to commit + exit)
+ *
+ * Driven entirely by Ink's `useInput`. The component does NOT perform
+ * any fs writes — it resolves the verdict back to the caller
+ * (`runOnboardingCommand`), which translates verdicts into L6 / L18 /
+ * telemetry-state mutations. Single source of truth: the runner.
+ *
+ * Each picker step pre-selects the CURRENT persisted value (from the
+ * snapshot passed in props) so pressing Enter on Step 2/3/5 keeps the
+ * current value — that is the idempotency contract.
+ *
+ * Cancellation:
+ *   - Esc / Ctrl-C at any step → verdict.cancelled = true, the runner
+ *     skips ALL writes (including the marker touch) so the next bare
+ *     `pugi` invocation still surfaces the first-run hint.
+ *
+ * Keystrokes:
+ *   - ↑/↓ or j/k — move selection in pickers.
+ *   - Enter      — confirm step (keep current = pass through; new pick
+ *                  = update verdict for that tier).
+ *   - 's'        — skip current step explicitly (verdict slot stays null).
+ *   - Esc / 'q'  — cancel the wizard.
+ */
+import { useState } from 'react';
+import { Box, Text, render, useApp, useInput } from 'ink';
+import { PERMISSION_MODES, PERMISSION_MODE_GLOSS, } from '../core/permissions/index.js';
+import { OUTPUT_STYLES, OUTPUT_STYLE_SLUGS, } from '../core/output-style/presets.js';
+import { TELEMETRY_CHOICES, } from '../core/onboarding/telemetry-state.js';
+const EMPTY_DRAFT = {
+    permissionMode: null,
+    outputStyle: null,
+    telemetry: null,
+};
+/**
+ * Lookup the snapshot value's index within the picker rows so the
+ * initial cursor sits on the current value. Returns 0 (safe default)
+ * when the snapshot value is outside the closed list — should never
+ * happen given the type guards in the state modules, but the index
+ * fallback keeps Ink from crashing on a malformed config.
+ */
+function indexOf(rows, value) {
+    const idx = rows.indexOf(value);
+    return idx === -1 ? 0 : idx;
+}
+/**
+ * The wizard component. Pure: no fs, no env, no network. Verdicts
+ * flow up via `onComplete`; the caller owns the writes.
+ */
+export function OnboardingWizard(props) {
+    const { snapshot, onComplete } = props;
+    const [step, setStep] = useState(1);
+    const [permissionIdx, setPermissionIdx] = useState(indexOf(PERMISSION_MODES, snapshot.permissionMode));
+    const [styleIdx, setStyleIdx] = useState(indexOf(OUTPUT_STYLE_SLUGS, snapshot.outputStyle));
+    const [telemetryIdx, setTelemetryIdx] = useState(indexOf(TELEMETRY_CHOICES, snapshot.telemetry));
+    const [draft, setDraft] = useState(EMPTY_DRAFT);
+    const finish = (final, cancelled) => {
+        onComplete({
+            permissionMode: final.permissionMode,
+            outputStyle: final.outputStyle,
+            telemetry: final.telemetry,
+            cancelled,
+        });
+    };
+    useInput((input, key) => {
+        // Universal cancel.
+        if (key.escape || (key.ctrl && input === 'c')) {
+            finish(EMPTY_DRAFT, true);
+            return;
+        }
+        // Universal skip — Enter on a picker means "keep current"; explicit
+        // 's' makes the skip intent obvious in the recap.
+        const isAdvance = key.return;
+        const moveUp = key.upArrow || input === 'k';
+        const moveDown = key.downArrow || input === 'j';
+        const explicitSkip = input === 's';
+        switch (step) {
+            case 1: {
+                if (isAdvance)
+                    setStep(2);
+                return;
+            }
+            case 2: {
+                if (moveUp) {
+                    setPermissionIdx((i) => (i === 0 ? PERMISSION_MODES.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setPermissionIdx((i) => (i === PERMISSION_MODES.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = PERMISSION_MODES[permissionIdx];
+                    const verdict = explicitSkip || picked === snapshot.permissionMode ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, permissionMode: verdict }));
+                    setStep(3);
+                    return;
+                }
+                return;
+            }
+            case 3: {
+                if (moveUp) {
+                    setStyleIdx((i) => (i === 0 ? OUTPUT_STYLE_SLUGS.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setStyleIdx((i) => (i === OUTPUT_STYLE_SLUGS.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = OUTPUT_STYLE_SLUGS[styleIdx];
+                    const verdict = explicitSkip || picked === snapshot.outputStyle ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, outputStyle: verdict }));
+                    setStep(4);
+                    return;
+                }
+                return;
+            }
+            case 4: {
+                if (isAdvance)
+                    setStep(5);
+                return;
+            }
+            case 5: {
+                if (moveUp) {
+                    setTelemetryIdx((i) => (i === 0 ? TELEMETRY_CHOICES.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setTelemetryIdx((i) => (i === TELEMETRY_CHOICES.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = TELEMETRY_CHOICES[telemetryIdx];
+                    const verdict = explicitSkip || picked === snapshot.telemetry ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, telemetry: verdict }));
+                    setStep(6);
+                    return;
+                }
+                return;
+            }
+            case 6: {
+                if (isAdvance)
+                    finish(draft, false);
+                return;
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(StepHeader, { step: step }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [step === 1 && _jsx(WelcomeStep, { snapshot: snapshot }), step === 2 && (_jsx(ModeStep, { current: snapshot.permissionMode, selectedIdx: permissionIdx })), step === 3 && (_jsx(StyleStep, { current: snapshot.outputStyle, currentSource: snapshot.outputStyleSource, selectedIdx: styleIdx })), step === 4 && _jsx(McpStep, {}), step === 5 && (_jsx(TelemetryStep, { current: snapshot.telemetry, selectedIdx: telemetryIdx })), step === 6 && _jsx(RecapStep, { snapshot: snapshot, draft: draft })] }), _jsx(FooterHints, { step: step })] }));
+}
+function StepHeader({ step }) {
+    const titles = {
+        1: 'Welcome to Pugi',
+        2: 'Step 2 / 5 — Default permission mode',
+        3: 'Step 3 / 5 — Output style',
+        4: 'Step 4 / 5 — MCP servers',
+        5: 'Step 5 / 5 — Telemetry consent',
+        6: 'Setup complete',
+    };
+    return (_jsx(Text, { bold: true, color: "cyan", children: titles[step] }));
+}
+function WelcomeStep({ snapshot }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Brief it. It ships." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: snapshot.authPresent
+                        ? 'You are signed in. The wizard configures local defaults; values persist to ~/.pugi/config.json.'
+                        : 'You are NOT signed in. The wizard still configures local defaults, but you should run `pugi login` after.' }) })] }));
+}
+function ModeStep({ current, selectedIdx, }) {
+    return (_jsx(Box, { flexDirection: "column", children: PERMISSION_MODES.map((mode, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: mode === current, title: mode, gloss: PERMISSION_MODE_GLOSS[mode] }, mode))) }));
+}
+function StyleStep({ current, currentSource, selectedIdx, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [OUTPUT_STYLE_SLUGS.map((slug, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: slug === current, title: slug, gloss: OUTPUT_STYLES[slug].gloss }, slug))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: currentSource === 'workspace'
+                        ? 'Active style is currently a workspace override. The wizard writes the user-tier default.'
+                        : `Active source: ${currentSource}.` }) })] }));
+}
+function McpStep() {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "MCP servers extend Pugi with extra tools (filesystem, browser, custom APIs)." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Add one with:" }) }), _jsx(Text, { children: '  pugi mcp add <name> <command>' }), _jsx(Text, { children: '  pugi mcp list' }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "You can skip for now and add servers later." }) })] }));
+}
+function TelemetryStep({ current, selectedIdx, }) {
+    const gloss = {
+        off: 'No telemetry of any kind.',
+        anonymous: 'Counts + error categories only; no payloads.',
+        community: 'Anonymous + opt-in usage panels.',
+    };
+    return (_jsx(Box, { flexDirection: "column", children: TELEMETRY_CHOICES.map((choice, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: choice === current, title: choice, gloss: gloss[choice] }, choice))) }));
+}
+function RecapStep({ snapshot, draft, }) {
+    const finalMode = draft.permissionMode ?? snapshot.permissionMode;
+    const finalStyle = draft.outputStyle ?? snapshot.outputStyle;
+    const finalTelemetry = draft.telemetry ?? snapshot.telemetry;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: `  Permission mode: ${finalMode}${draft.permissionMode === null ? ' (unchanged)' : ''}` }), _jsx(Text, { children: `  Output style:    ${finalStyle}${draft.outputStyle === null ? ' (unchanged)' : ''}` }), _jsx(Text, { children: `  Telemetry:       ${finalTelemetry}${draft.telemetry === null ? ' (unchanged)' : ''}` }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to write defaults + exit. Esc to cancel without saving." }) })] }));
+}
+function PickerRow({ isSelected, isCurrent, title, gloss, }) {
+    const indicator = isSelected ? '▸ ' : '  ';
+    const currentTag = isCurrent ? ' [current]' : '';
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, title.padEnd(18, ' ')] }), _jsx(Text, { dimColor: true, children: `${gloss}${currentTag}` })] }));
+}
+function FooterHints({ step }) {
+    const hint = step === 1 || step === 4
+        ? 'Enter continue   Esc cancel'
+        : step === 6
+            ? 'Enter commit + exit   Esc cancel'
+            : '↑/↓ select   Enter confirm   s skip   Esc cancel';
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: hint }) }));
+}
+/**
+ * Mount the wizard, await the operator's verdict, unmount Ink, return
+ * the verdict to the runner. Wrapped in a `useApp` consumer so we can
+ * call `exit()` and let `waitUntilExit()` resolve cleanly.
+ */
+export async function renderOnboardingWizard(opts) {
+    return new Promise((resolvePromise) => {
+        let resolved = false;
+        const handleComplete = (verdict) => {
+            if (resolved)
+                return;
+            resolved = true;
+            app.unmount();
+            resolvePromise(verdict);
+        };
+        const Wrapper = () => {
+            const { exit } = useApp();
+            return (_jsx(OnboardingWizard, { snapshot: opts.snapshot, onComplete: (verdict) => {
+                    handleComplete(verdict);
+                    exit();
+                } }));
+        };
+        const app = render(_jsx(Wrapper, {}));
+    });
+}
+//# sourceMappingURL=onboarding-wizard.js.map