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

package/dist/tui/multi-file-diff-approval.js

@@ -0,0 +1,375 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * MultiFileDiffApproval — side-by-side multi-file diff approval modal
+ * (PUGI-68).
+ *
+ * When the engine proposes a batch of edits that touches more than one
+ * file, the operator needs to review every diff in a single coherent
+ * view, then accept-all / reject-all / per-file approve before the
+ * dispatcher applies anything. The single-file approval surfaces in
+ * the AskModal / PlanReviewModal family are insufficient — a per-file
+ * back-to-back prompt loses the cross-file context the operator needs
+ * to spot a regression that spans modules.
+ *
+ * Layout (matches the AskUserQuestionChips PUGI-130 side-by-side
+ * precedent, see `ask-user-question-chips.tsx`):
+ *
+ *   ┌─ Multi-file diff review ───────────────────────────────────────┐
+ *   │ ┌─ Files ─────────────┐ ┌─ Diff: src/foo/bar.ts ─────────────┐ │
+ *   │ │ ▸ • src/foo/bar.ts  │ │ --- src/foo/bar.ts                 │ │
+ *   │ │   ✓ src/baz.ts      │ │ +++ src/foo/bar.ts                 │ │
+ *   │ │   ✗ src/qux.ts      │ │ @@ -1,4 +1,4 @@                    │ │
+ *   │ │     • src/x/y.ts    │ │ -const x = 1;                      │ │
+ *   │ │                     │ │ +const x = 2;                      │ │
+ *   │ └─────────────────────┘ └────────────────────────────────────┘ │
+ *   │ 1/4 approved · 1/4 rejected · 2 remaining · Enter when done    │
+ *   └────────────────────────────────────────────────────────────────┘
+ *
+ * Key bindings:
+ *  - ↑ / ↓ ............ navigate the file list
+ *  - a ................ approve the highlighted file
+ *  - r ................ reject the highlighted file
+ *  - A (shift+a) ...... approve every file in the batch
+ *  - R (shift+r) ...... reject every file in the batch
+ *  - PgUp / PgDn ...... scroll the diff pane
+ *  - Enter ............ finalise — emit per-file verdicts
+ *  - Esc .............. cancel the whole batch (every file → rejected)
+ *
+ * Contract notes:
+ *  - The component is PURE (Ink-style). It mounts useState for cursor,
+ *    per-file verdict map, and diff-pane scroll offset. Emits exactly
+ *    one `onResolve` callback when the operator presses Enter (or Esc
+ *    for a cancel).
+ *  - Per-file diff bodies are rendered verbatim from the provided
+ *    unified-diff text — the component does NOT compute diffs from raw
+ *    file contents. Callers (typically the dispatcher result transcript)
+ *    own the diff text generation.
+ *  - Long file paths are truncated middle-style so prefix + suffix stay
+ *    visible (the parts the operator scans for module scope + filename).
+ *  - Long diff bodies scroll via a single-axis offset; horizontal
+ *    overflow is left to Ink's text wrapping per line. No mouse support.
+ *
+ * Brand voice gate: ASCII glyphs only (✓ / ✗ kept for status — already
+ * shipped в other TUI components like agent-progress-card). No banned
+ * brand words, no em-dashes, no attribution to external AIs.
+ */
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+/* ------------------------------------------------------------------ */
+/* Defensive caps                                                      */
+/* ------------------------------------------------------------------ */
+/** Maximum chars rendered per file path in the left pane. */
+export const MULTI_FILE_DIFF_PATH_CAP = 48;
+/** Visible rows in the diff pane viewport. */
+export const MULTI_FILE_DIFF_PANE_HEIGHT = 18;
+/** Width hint for the left file-list column (used for path truncation). */
+export const MULTI_FILE_DIFF_LEFT_WIDTH = 32;
+/** Hard cap on diff body length (chars) — defends against runaway model output. */
+export const MULTI_FILE_DIFF_BODY_CHAR_CAP = 200_000;
+/* ------------------------------------------------------------------ */
+/* Helpers                                                             */
+/* ------------------------------------------------------------------ */
+/**
+ * Middle-truncate a long file path so both prefix (module scope) and
+ * suffix (filename) stay visible. Mirrors the macOS `truncate=middle`
+ * convention. Appends `…` in the middle when truncation happens.
+ *
+ * Examples (cap = 24):
+ *   "src/foo/bar/baz/qux.ts"      → "src/foo/bar/baz/qux.ts"  (fits)
+ *   "src/a-long-module/b/c/d.ts"  → "src/a-long-mo…/b/c/d.ts" (cut middle)
+ *
+ * Exported so the spec can assert the contract directly.
+ */
+export function truncateMiddle(raw, cap) {
+    if (cap <= 1)
+        return '…';
+    if (raw.length <= cap)
+        return raw;
+    // Reserve one slot for the ellipsis; balance prefix/suffix around it.
+    // The suffix gets one extra char on odd budgets so the filename stays
+    // longer (operators scan filenames more than the path prefix).
+    const remaining = cap - 1;
+    const prefixLen = Math.floor(remaining / 2);
+    const suffixLen = remaining - prefixLen;
+    return `${raw.slice(0, prefixLen)}…${raw.slice(raw.length - suffixLen)}`;
+}
+/**
+ * Defensive char cap on the diff body. Schema-level caps live upstream;
+ * this is belt + braces against a malformed dispatcher transcript that
+ * could otherwise exhaust the terminal scrollback.
+ */
+export function clampDiffBody(raw) {
+    if (raw.length <= MULTI_FILE_DIFF_BODY_CHAR_CAP)
+        return raw;
+    return `${raw.slice(0, MULTI_FILE_DIFF_BODY_CHAR_CAP - 1)}…`;
+}
+export function classifyDiffLine(line) {
+    if (line.startsWith('+++') || line.startsWith('---'))
+        return 'file-header';
+    if (line.startsWith('@@'))
+        return 'hunk-header';
+    if (line.startsWith('+'))
+        return 'addition';
+    if (line.startsWith('-'))
+        return 'deletion';
+    return 'context';
+}
+/** Inline helper — return per-line render props for a diff line. */
+function renderProps(kind) {
+    switch (kind) {
+        case 'file-header':
+            return { bold: true };
+        case 'hunk-header':
+            return { color: 'blue', bold: true };
+        case 'addition':
+            return { color: 'green' };
+        case 'deletion':
+            return { color: 'red' };
+        case 'context':
+            return { dimColor: true };
+    }
+}
+/**
+ * Public verdict-encoder mirror of the AskModal / PlanReviewModal
+ * encoders. Surfaces a single human-readable summary string the caller
+ * can inject as the next operator turn or log to a session journal.
+ *
+ *  - `cancelled`        → "[MULTI-DIFF-VERDICT:cancelled]"
+ *  - all approved       → "[MULTI-DIFF-VERDICT:all-approved] file1; file2"
+ *  - all rejected       → "[MULTI-DIFF-VERDICT:all-rejected] file1; file2"
+ *  - mixed              → "[MULTI-DIFF-VERDICT:mixed] +file1; -file2; ?file3"
+ *
+ * Each per-file token in mixed mode is prefixed `+` (approved), `-`
+ * (rejected), or `?` (still pending — operator hit Enter без deciding).
+ */
+export function encodeMultiFileDiffVerdict(result) {
+    if (result.cancelled)
+        return '[MULTI-DIFF-VERDICT:cancelled]';
+    const total = result.verdicts.length;
+    if (total === 0)
+        return '[MULTI-DIFF-VERDICT:empty]';
+    const allApproved = result.verdicts.every((v) => v.verdict === 'approved');
+    const allRejected = result.verdicts.every((v) => v.verdict === 'rejected');
+    if (allApproved) {
+        return `[MULTI-DIFF-VERDICT:all-approved] ${result.verdicts
+            .map((v) => v.path)
+            .join('; ')}`;
+    }
+    if (allRejected) {
+        return `[MULTI-DIFF-VERDICT:all-rejected] ${result.verdicts
+            .map((v) => v.path)
+            .join('; ')}`;
+    }
+    const tokens = result.verdicts.map((v) => {
+        const prefix = v.verdict === 'approved' ? '+' : v.verdict === 'rejected' ? '-' : '?';
+        return `${prefix}${v.path}`;
+    });
+    return `[MULTI-DIFF-VERDICT:mixed] ${tokens.join('; ')}`;
+}
+/* ------------------------------------------------------------------ */
+/* Component                                                           */
+/* ------------------------------------------------------------------ */
+/**
+ * Build the result object for a given verdict map + entries vector.
+ * Hoisted because both the commit (Enter) and cancel (Esc) paths need
+ * to project the same shape — cancel just overrides every verdict to
+ * `rejected` and stamps `cancelled: true`.
+ */
+function buildResult(entries, verdicts, cancelled) {
+    const projected = entries.map((entry, idx) => ({
+        path: entry.path,
+        verdict: verdicts[idx] ?? 'pending',
+    }));
+    return {
+        verdicts: projected,
+        approvedPaths: projected
+            .filter((v) => v.verdict === 'approved')
+            .map((v) => v.path),
+        rejectedPaths: projected
+            .filter((v) => v.verdict === 'rejected')
+            .map((v) => v.path),
+        cancelled,
+    };
+}
+export function MultiFileDiffApproval(props) {
+    // FIX (PR #876 triple-review): the previous `useMemo(() => props.entries,
+    // [props.entries])` was a no-op — it returned the same reference it
+    // depended on, so the memo never produced a stable identity gain. We
+    // reference `props.entries` directly now; downstream useEffect /
+    // useMemo hooks key on the real prop, not a redundant wrapper.
+    const entries = props.entries;
+    const paneHeight = props.paneHeight ?? MULTI_FILE_DIFF_PANE_HEIGHT;
+    const [cursor, setCursor] = useState(0);
+    const [verdicts, setVerdicts] = useState(() => entries.map(() => 'pending'));
+    const [scrollOffset, setScrollOffset] = useState(0);
+    // FIX (PR #876 triple-review, P1): the lazy useState initialiser
+    // captures `entries.length` ONCE at mount. If the caller swaps in
+    // a different entries array (length mismatch), the verdicts vector
+    // would drift — `setVerdictAt` could index out of range or
+    // `buildResult` could project a `pending` for a real entry whose
+    // verdict the operator already set. Re-sync on length change while
+    // preserving existing per-index verdicts (forgiving variant A).
+    useEffect(() => {
+        setVerdicts((prev) => {
+            if (prev.length === entries.length)
+                return prev;
+            return entries.map((_, i) => prev[i] ?? 'pending');
+        });
+        // Also clamp the cursor so it never points past the new end.
+        setCursor((c) => {
+            if (entries.length === 0)
+                return 0;
+            return Math.min(c, entries.length - 1);
+        });
+    }, [entries.length, entries]);
+    // FIX (PR #876 triple-review, P1): `commit()` is called from inside
+    // the useInput closure, which captures the `verdicts` value at the
+    // render time the closure was created. With rapid keypresses (e.g.
+    // `a` then Enter on the same React tick), React has scheduled the
+    // setVerdicts update but the closure still sees the previous array.
+    // The emitted MultiFileDiffResult would drop the latest verdict.
+    // Fix: track verdicts via a ref synced in a useEffect — the commit
+    // path reads `verdictsRef.current` so it always sees the latest map.
+    const verdictsRef = useRef(verdicts);
+    useEffect(() => {
+        verdictsRef.current = verdicts;
+    }, [verdicts]);
+    // Pre-split the active diff body into lines for the right pane. The
+    // body is clamped defensively before splitting so a runaway model
+    // payload cannot exhaust the terminal scrollback. useMemo here keeps
+    // the line array stable across navigation re-renders on the SAME
+    // file — only the cursor changes when the operator presses ↑/↓ on
+    // the same diff body.
+    const activeEntry = entries[cursor];
+    const activeLines = useMemo(() => {
+        const body = clampDiffBody(activeEntry?.diff ?? '');
+        if (body.length === 0)
+            return [];
+        return body.split('\n');
+    }, [activeEntry?.diff]);
+    function commit(cancelled = false) {
+        // Read the freshest verdict map via ref — the closure-captured
+        // `verdicts` state could be one render behind on rapid keypresses.
+        const latest = verdictsRef.current;
+        const finalVerdicts = cancelled
+            ? entries.map(() => 'rejected')
+            : latest;
+        props.onResolve(buildResult(entries, finalVerdicts, cancelled));
+    }
+    function setVerdictAt(idx, verdict) {
+        setVerdicts((prev) => {
+            const next = prev.slice();
+            next[idx] = verdict;
+            return next;
+        });
+    }
+    function setAllVerdicts(verdict) {
+        setVerdicts(() => entries.map(() => verdict));
+    }
+    useInput((input, key) => {
+        // Esc cancels the whole batch (every file → rejected). Mirrors the
+        // AskModal cancel contract so operator muscle memory transfers.
+        if (key.escape) {
+            commit(true);
+            return;
+        }
+        // Enter commits the current verdict map. Pending files stay
+        // pending — the caller decides whether `pending` is treated as
+        // approve or reject (dispatcher policy lives upstream).
+        if (key.return) {
+            commit(false);
+            return;
+        }
+        // ↑ / ↓ navigate file list. Reset scroll on file change so the
+        // operator sees the diff header again, not a stale offset from
+        // the previous file.
+        if (key.upArrow) {
+            if (entries.length === 0)
+                return;
+            setCursor((c) => (c - 1 + entries.length) % entries.length);
+            setScrollOffset(0);
+            return;
+        }
+        if (key.downArrow) {
+            if (entries.length === 0)
+                return;
+            setCursor((c) => (c + 1) % entries.length);
+            setScrollOffset(0);
+            return;
+        }
+        // PgUp / PgDn scroll the diff pane by a near-full viewport. We
+        // keep one row of overlap so the operator's eye anchors across
+        // pages. Clamped to [0, max] so over-scroll stops at the bottom
+        // line instead of producing an empty pane.
+        if (key.pageUp) {
+            setScrollOffset((o) => Math.max(0, o - Math.max(1, paneHeight - 1)));
+            return;
+        }
+        if (key.pageDown) {
+            setScrollOffset((o) => {
+                const maxOffset = Math.max(0, activeLines.length - paneHeight);
+                return Math.min(maxOffset, o + Math.max(1, paneHeight - 1));
+            });
+            return;
+        }
+        // Capital A / R = bulk verdict. Lowercase a / r = per-file. The
+        // order matters: Ink delivers SHIFTed keys as the upper-case
+        // glyph in `input`, so we can match с a direct equality.
+        if (input === 'A') {
+            setAllVerdicts('approved');
+            return;
+        }
+        if (input === 'R') {
+            setAllVerdicts('rejected');
+            return;
+        }
+        if (input === 'a') {
+            setVerdictAt(cursor, 'approved');
+            return;
+        }
+        if (input === 'r') {
+            setVerdictAt(cursor, 'rejected');
+            return;
+        }
+    }, { isActive: props.inert !== true });
+    const approvedCount = verdicts.filter((v) => v === 'approved').length;
+    const rejectedCount = verdicts.filter((v) => v === 'rejected').length;
+    const pendingCount = verdicts.filter((v) => v === 'pending').length;
+    const total = entries.length;
+    // Diff pane viewport: a window of `paneHeight` lines starting at
+    // scrollOffset. Empty entries render с a placeholder so the operator
+    // sees the file is intentionally empty (vs the modal being broken).
+    const visibleLines = activeLines.slice(scrollOffset, scrollOffset + paneHeight);
+    const diffPaneTitle = activeEntry
+        ? `Diff: ${truncateMiddle(activeEntry.path, MULTI_FILE_DIFF_PATH_CAP)}`
+        : 'Diff';
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: '? ' }), _jsx(Text, { bold: true, children: `Multi-file diff review (${total} ${total === 1 ? 'file' : 'files'})` })] }), _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginRight: 1, minWidth: MULTI_FILE_DIFF_LEFT_WIDTH, children: [_jsx(Box, { children: _jsx(Text, { bold: true, dimColor: true, children: 'Files' }) }), entries.map((entry, idx) => {
+                                const isHighlighted = idx === cursor;
+                                const verdict = verdicts[idx] ?? 'pending';
+                                // Badge: ✓ approved (green), ✗ rejected (red), • pending (dim).
+                                // The badge sits BEFORE the cursor arrow so the operator can
+                                // skim status without scanning the cursor column.
+                                let badgeGlyph = '•';
+                                let badgeColor;
+                                let badgeDim = true;
+                                if (verdict === 'approved') {
+                                    badgeGlyph = '✓';
+                                    badgeColor = 'green';
+                                    badgeDim = false;
+                                }
+                                else if (verdict === 'rejected') {
+                                    badgeGlyph = '✗';
+                                    badgeColor = 'red';
+                                    badgeDim = false;
+                                }
+                                // Path budget = left width minus borders, cursor arrow (2),
+                                // badge + space (2), padding (2). Defensive floor at 8 chars.
+                                const pathBudget = Math.max(8, MULTI_FILE_DIFF_LEFT_WIDTH - 4 - 2 - 2);
+                                return (_jsxs(Box, { children: [_jsx(Text, { color: isHighlighted ? 'cyan' : undefined, bold: isHighlighted, children: isHighlighted ? '▸ ' : '  ' }), _jsx(Text, { color: badgeColor, dimColor: badgeDim, bold: !badgeDim, children: `${badgeGlyph} ` }), _jsx(Text, { color: isHighlighted ? 'cyan' : undefined, bold: isHighlighted, children: truncateMiddle(entry.path, pathBudget) }), entry.hint !== undefined && entry.hint.length > 0 ? (_jsx(Text, { dimColor: true, italic: true, children: ` (${entry.hint})` })) : null] }, `file-${idx}-${entry.path}`));
+                            })] }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, flexGrow: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, dimColor: true, children: diffPaneTitle }), activeLines.length > paneHeight ? (_jsx(Text, { dimColor: true, children: ` · lines ${scrollOffset + 1}-${Math.min(scrollOffset + paneHeight, activeLines.length)}/${activeLines.length}` })) : null] }), visibleLines.length === 0 ? (_jsx(Text, { dimColor: true, italic: true, children: '(empty diff)' })) : (visibleLines.map((line, idx) => {
+                                const kind = classifyDiffLine(line);
+                                const rp = renderProps(kind);
+                                return (_jsx(Text, { color: rp.color, bold: rp.bold, dimColor: rp.dimColor, children: line.length > 0 ? line : ' ' }, `diff-${cursor}-${scrollOffset + idx}`));
+                            }))] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", children: `${approvedCount}/${total} approved` }), _jsx(Text, { dimColor: true, children: ' · ' }), _jsx(Text, { color: "red", children: `${rejectedCount}/${total} rejected` }), _jsx(Text, { dimColor: true, children: ' · ' }), _jsx(Text, { children: `${pendingCount} remaining` }), _jsx(Text, { dimColor: true, children: ' · Enter when done' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '[↑↓] navigate  ·  [a] approve  ·  [r] reject  ·  [A] all  ·  [R] none  ·  [PgUp/PgDn] scroll  ·  [Esc] cancel' }) })] })] }));
+}
+//# sourceMappingURL=multi-file-diff-approval.js.map

package/dist/tui/onboarding-wizard.js

@@ -0,0 +1,240 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * — 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