@pugi/cli 0.1.0-beta.20 → 0.1.0-beta.22

package/dist/tools/todo-write.js

@@ -0,0 +1,184 @@
+/**
+ * todo_write tool — Leak L16 (TodoWrite single-in-progress invariant).
+ *
+ * Mirrors Claude Code's `TodoWrite` tool 1:1 so a model trained on the
+ * upstream grammar speaks Pugi's variant verbatim. The tool dispatches
+ * a BATCH replace of the workspace todo board (not an incremental
+ * mutation — the model emits the FULL list every call). At most ONE
+ * todo may carry `status: 'in_progress'` at any time; violations
+ * reject with the `TODO_INVARIANT_VIOLATED` sentinel and the board on
+ * disk is left unchanged.
+ *
+ * Relationship to `task_*` (β1 T1/T6, tools/tasks.ts):
+ *   - `task_*` is GRANULAR (create/get/list/update one task at a
+ *     time) with an append-only JSONL journal scoped to the SESSION.
+ *   - `todo_write` is BATCH (snapshot the whole board) with an atomic
+ *     JSON snapshot scoped to the WORKSPACE.
+ *   They are complementary surfaces: agents that prefer the upstream
+ *   TodoWrite grammar use `todo_write`; agents that want a fine-grained
+ *   audit trail use `task_*`.
+ *
+ * Hard rules (enforced by Zod + dispatcher):
+ *   - `todos.length` ≤ 50 (board overload guard).
+ *   - Every item: id (≥1 char, ≤128), content (≥1 char), status enum.
+ *   - At most ONE item with `status === 'in_progress'`.
+ *   - All ids unique within the batch.
+ *
+ * Dispatch returns the persisted board as JSON; callers can read
+ * `todos: [...]` directly. Errors return the sentinel-prefixed message
+ * so the engine adapter can pattern-match.
+ */
+import { z } from 'zod';
+import { saveTodoBoard } from '../core/todos/state.js';
+/** Cap matches the `task_*` family's title cap for parity. */
+export const TODO_CONTENT_MAX = 2_000;
+/** id is opaque to us but must be slug-safe so file paths could embed it. */
+export const TODO_ID_MIN = 1;
+export const TODO_ID_MAX = 128;
+/** Hard cap on board size. Beyond this the operator should split work. */
+export const TODO_BATCH_MAX = 50;
+export const todoItemSchema = z
+    .strictObject({
+    id: z
+        .string()
+        .min(TODO_ID_MIN)
+        .max(TODO_ID_MAX)
+        .describe('Stable id for this todo. Opaque, ≤128 chars.'),
+    content: z
+        .string()
+        .min(1)
+        .max(TODO_CONTENT_MAX)
+        .describe('Imperative task description. E.g. "Add invariant check".'),
+    status: z
+        .enum(['pending', 'in_progress', 'completed'])
+        .describe('Lifecycle status. At most ONE in_progress per board.'),
+    activeForm: z
+        .string()
+        .min(1)
+        .max(TODO_CONTENT_MAX)
+        .optional()
+        .describe('Present-continuous form. E.g. "Adding invariant check".'),
+});
+export const todoWriteArgsSchema = z.strictObject({
+    todos: z
+        .array(todoItemSchema)
+        .max(TODO_BATCH_MAX)
+        .describe(`Full todo board (batch replace, not incremental). Max ${TODO_BATCH_MAX} items. ` +
+        `At most ONE item may carry status="in_progress".`),
+});
+/**
+ * JSON-Schema fragment surfaced to the model via the tool-bridge
+ * `parameters` field. Mirrors the Zod schema 1:1 — kept hand-written
+ * (same convention as ask_user_question) because the runtime engine
+ * wires OpenAI-compatible JSON Schema and we have not greenlit the
+ * zod-to-json-schema transitive dep. Keep both in lockstep.
+ */
+export const todoWriteJsonSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['todos'],
+    properties: {
+        todos: {
+            type: 'array',
+            maxItems: TODO_BATCH_MAX,
+            description: `Full todo board (batch replace, not incremental). Max ${TODO_BATCH_MAX} items. ` +
+                `At most ONE item may carry status="in_progress".`,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['id', 'content', 'status'],
+                properties: {
+                    id: {
+                        type: 'string',
+                        minLength: TODO_ID_MIN,
+                        maxLength: TODO_ID_MAX,
+                        description: 'Stable id for this todo. Opaque, ≤128 chars.',
+                    },
+                    content: {
+                        type: 'string',
+                        minLength: 1,
+                        maxLength: TODO_CONTENT_MAX,
+                        description: 'Imperative task description.',
+                    },
+                    status: {
+                        type: 'string',
+                        enum: ['pending', 'in_progress', 'completed'],
+                        description: 'Lifecycle status. At most ONE in_progress per board.',
+                    },
+                    activeForm: {
+                        type: 'string',
+                        minLength: 1,
+                        maxLength: TODO_CONTENT_MAX,
+                        description: 'Present-continuous form.',
+                    },
+                },
+            },
+        },
+    },
+};
+/**
+ * Sentinel prefix the dispatcher returns when Zod schema validation
+ * rejects the raw arguments. Distinct from `TODO_INVARIANT_VIOLATED`
+ * (>1 in_progress) and `TODO_DUPLICATE_ID` (collision within batch),
+ * which are emitted from `saveTodoBoard` AFTER schema parsing.
+ *
+ * Surfaced as a return string (not a throw) so the engine adapter sees
+ * a recoverable tool error and the model can self-correct its args,
+ * instead of the engine loop tearing down on an uncaught ZodError.
+ */
+export const TODO_INVALID_ARGS = 'INVALID_ARGS';
+/**
+ * Render a ZodError into a deterministic `INVALID_ARGS: ...` sentinel
+ * the model can pattern-match. Each issue contributes one
+ * `path: message` clause; clauses are joined with `; ` so the model
+ * sees every offence in a single line. Path with the root scope is
+ * rendered as `<root>` to avoid an empty colon.
+ */
+function renderZodIssues(error) {
+    const parts = error.issues.map((issue) => {
+        const path = issue.path.length === 0 ? '<root>' : issue.path.join('.');
+        return `${path}: ${issue.message}`;
+    });
+    return `${TODO_INVALID_ARGS}: ${parts.join('; ')}`;
+}
+/**
+ * Validate via Zod + persist atomically. Surfaces three sentinel
+ * families the dispatcher pattern-matches on:
+ *   - `INVALID_ARGS: <path>: <issue>; ...`        — Zod schema rejected
+ *     the raw arguments (returned as STRING, not thrown).
+ *   - `TODO_INVARIANT_VIOLATED: ...`              — >1 in_progress
+ *     (thrown by `saveTodoBoard`).
+ *   - `TODO_DUPLICATE_ID: ...`                    — collision within batch
+ *     (thrown by `saveTodoBoard`).
+ *
+ * Why the asymmetry: schema rejection means the model emitted malformed
+ * structure (missing field, wrong type) and CAN self-correct given a
+ * clear breakdown of the offending path. The invariant + duplicate-id
+ * paths mean the model emitted structurally-valid but semantically
+ * conflicting state — those still throw so the engine loop's tool-error
+ * hook can surface them through `PostToolUseFailure` for observability,
+ * mirroring how the file-tools layer surfaces `STALE_READ` / `PermissionDenied`.
+ */
+export function dispatchTodoWrite(ctx, rawArgs) {
+    // L16 P1 fix (2026-05-27): `.parse` throws a `ZodError` on validation
+    // failure. The previous implementation let that throw bubble through
+    // the engine adapter's catch arm as a free-form `error.message`,
+    // which (a) loses the issue-by-issue structure the model needs to
+    // self-correct, and (b) tears down the tool-call as a hard failure
+    // rather than a recoverable tool result. Switch to `safeParse` and
+    // emit a structured `INVALID_ARGS: <path>: <issue>; ...` sentinel
+    // string instead — the engine sees a successful tool call, the model
+    // sees the offending paths, and the dispatcher's catch arm reserves
+    // throws for the genuine semantic conflicts emitted by `saveTodoBoard`.
+    const parsed = todoWriteArgsSchema.safeParse(rawArgs);
+    if (!parsed.success) {
+        return renderZodIssues(parsed.error);
+    }
+    const stateCtx = {
+        workspaceRoot: ctx.workspaceRoot,
+        ...(ctx.now ? { now: ctx.now } : {}),
+    };
+    const board = saveTodoBoard(stateCtx, parsed.data.todos);
+    return JSON.stringify(board);
+}
+//# sourceMappingURL=todo-write.js.map

package/dist/tui/compact-banner.js

@@ -36,14 +36,27 @@ export function CompactBanner(props) {
  * Build the centred label. Examples:
  *   "context compacted (12 turns → 1 summary, auto)"
  *   "context compacted (4 turns → 1 summary, manual · ~3.2k tokens)"
+ *   "context compacted (12 turns → summary at 14:32, auto)"
+ *   "context compacted (12 turns → 1 summary, manual) · 6 turns ago"
  */
 export function buildLabel(props) {
     const trigger = props.trigger === 'auto' ? 'auto' : 'manual';
     const turns = `${props.turnsBefore} ${props.turnsBefore === 1 ? 'turn' : 'turns'}`;
+    const summarySlot = typeof props.summaryAtEpochMs === 'number' && props.summaryAtEpochMs > 0
+        ? `summary at ${formatClock(props.summaryAtEpochMs)}`
+        : '1 summary';
     const tokens = props.summaryTokenCount && props.summaryTokenCount > 0
         ? ` · ~${formatTokens(props.summaryTokenCount)} tokens`
         : '';
-    return `context compacted (${turns} → 1 summary, ${trigger}${tokens})`;
+    const base = `context compacted (${turns} → ${summarySlot}, ${trigger}${tokens})`;
+    // L29 history-replay suffix. Only render when the boundary has live
+    // turns following it — a fresh in-REPL `/compact` lands with
+    // `turnsAgo === 0` and we keep the label compact.
+    if (typeof props.turnsAgo === 'number' && props.turnsAgo > 0) {
+        const ago = `${props.turnsAgo} ${props.turnsAgo === 1 ? 'turn' : 'turns'} ago`;
+        return `${base} · ${ago}`;
+    }
+    return base;
 }
 /** Format token counts like 1234 → 1.2k, 950 → 950. */
 function formatTokens(n) {
@@ -51,4 +64,18 @@ function formatTokens(n) {
         return `${n}`;
     return `${(n / 1000).toFixed(1)}k`;
 }
+/**
+ * Render an epoch-ms instant as a deterministic `HH:MM` clock in the
+ * operator's local timezone. Used only inside the centred label so a
+ * boundary that landed mid-session reads `summary at 14:32` instead of
+ * the generic `1 summary`. Pure (no side effects), constant-time.
+ */
+function formatClock(epochMs) {
+    const d = new Date(epochMs);
+    if (Number.isNaN(d.getTime()))
+        return '--:--';
+    const hh = d.getHours().toString().padStart(2, '0');
+    const mm = d.getMinutes().toString().padStart(2, '0');
+    return `${hh}:${mm}`;
+}
 //# sourceMappingURL=compact-banner.js.map

package/dist/tui/conversation-pane.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { MarkdownRender } from './markdown-render.js';
+import { CompactBanner } from './compact-banner.js';
 const HUE_COLOR_BY_SLUG = {
     // Mira (Pug) - coordinator
     main: 'cyan',
@@ -39,6 +40,18 @@ function ConversationRow({ row, personaNames, }) {
             return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "#3da9fc", children: '› ' }), _jsx(Text, { children: row.text })] }));
         case 'system':
             return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '· ' }), _jsx(Text, { dimColor: true, children: row.text })] }));
+        case 'compact-boundary': {
+            // L29 (2026-05-27): structured render. When the row carries the
+            // `compaction` payload, drive the Ink banner directly so the
+            // operator sees a width-aware gray separator with the canonical
+            // label. Fallback: a legacy boundary missing the structured
+            // payload (older replay events, hand-built rows) renders through
+            // the dim text path so the operator still sees the marker.
+            if (row.compaction) {
+                return (_jsx(CompactBanner, { turnsBefore: row.compaction.turnsBefore, trigger: row.compaction.trigger, summaryTokenCount: row.compaction.summaryTokenCount, turnsAgo: row.compaction.turnsAgo, summaryAtEpochMs: row.timestampEpochMs, columns: process.stdout?.columns }));
+            }
+            return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: row.text }) }));
+        }
         case 'persona': {
             const slug = row.personaSlug ?? '';
             const color = HUE_COLOR_BY_SLUG[slug] ?? 'white';

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/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