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

package/dist/tui/compact-banner.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Visible boundary marker for the conversation pane.
+ *
+ * Rendered inline in the transcript when the replay walker hits a
+ * `compaction` event. Conveys three facts at a glance:
+ *
+ *  1. A compaction happened (separator line).
+ *  2. How many turns were folded into the summary.
+ *  3. Whether it was manual or auto-triggered.
+ *
+ * The separator line uses U+2500 (BOX DRAWINGS LIGHT HORIZONTAL) so
+ * the visual weight matches the rest of the Ink chrome. Dim ink-color
+ * `gray` keeps the marker subdued — it is a navigation aid, not the
+ * conversation itself.
+ *
+ * Width-aware: when stdout columns are known we render the dashes to
+ * fill the line minus the centred label; on unknown width we fall
+ * back to a fixed 64-dash pad. The fallback is wide enough for any
+ * realistic terminal and narrow enough to not wrap on small ones.
+ */
+import { Box, Text } from 'ink';
+const FALLBACK_COLUMNS = 80;
+/**
+ * Render the boundary line. The wrapping `<Box>` keeps the marker on
+ * its own row even when the surrounding flex container packs siblings.
+ */
+export function CompactBanner(props) {
+    const columns = props.columns && props.columns > 20 ? props.columns : FALLBACK_COLUMNS;
+    const label = buildLabel(props);
+    const dashesEach = Math.max(3, Math.floor((columns - label.length - 2) / 2));
+    const dashes = '─'.repeat(dashesEach);
+    return (_jsx(Box, { children: _jsx(Text, { color: "gray", children: `${dashes} ${label} ${dashes}` }) }));
+}
+/**
+ * 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`
+        : '';
+    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) {
+    if (n < 1000)
+        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,8 +1,9 @@
 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
+    // Pugi (Pug) - coordinator
     main: 'cyan',
     // Olivia (Honeybee) - release
     pm: 'yellow',
@@ -36,28 +37,101 @@ function PaneHeader({ count }) {
 function ConversationRow({ row, personaNames, }) {
     switch (row.source) {
         case 'operator':
-            return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: '› ' }), _jsx(Text, { children: row.text })] }));
+            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 : 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';
             const displayName = personaNames?.get(slug) ?? slug;
-            // α6.12: persona bodies travel through MarkdownRender so code
-            // fences, headings, and inline accents land correctly. A row that
-            // carries no Markdown syntax renders as plain text under the same
-            // path (the parser falls through to a single paragraph span), so
-            // there is no regression for the simple "Mira shipped." baseline.
-            const containsMarkdown = looksLikeMarkdown(row.text);
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: color, bold: true, children: `▸ ${displayName} ` }), containsMarkdown ? null : _jsx(Text, { children: row.text })] }), containsMarkdown ? (_jsx(Box, { marginLeft: 2, children: _jsx(MarkdownRender, { source: row.text }) })) : null] }));
+            // CEO live dogfood: a body that started with a
+            // Cyrillic letter (e.g. "Принял.") rendered as "PugiПринял." on
+            // the same line because the persona label sat at zero margin and
+            // the body fell flush behind it. The label is bold-coloured chrome,
+            // not text the operator is meant to read as a sentence stem.
+            // Split body to its own row and indent two columns so the
+            // transcript reads:
+            //
+            //  ▸ Pugi
+            //    Принял.
+            //
+            // matching the the upstream tool / Codex / Gemini baseline visually +
+            // preventing the "PugiПринял" glue regardless of the body's
+            // leading character.
+            //
+            // The render also strips a leading identity-intro phrase as a
+            // defense-in-depth complement to the backend output gate — when
+            // turnIndex > 1, the operator must NOT see "Я Pugi - твой
+            // инженерный напарник." opening every reply. This is belt-and-
+            // braces; the prompt + output-gate already block it upstream.
+            const stripped = stripLeadingIdentityIntro(row.text);
+            const containsMarkdown = looksLikeMarkdown(stripped);
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsx(Text, { color: color, bold: true, children: `▸ ${displayName}` }) }), containsMarkdown ? (_jsx(Box, { marginLeft: 2, children: _jsx(MarkdownRender, { source: stripped }) })) : (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { children: stripped }) }))] }));
         }
     }
 }
+/**
+ * Strip a leading identity-intro line ("I'm Pugi — your engineering
+ * copilot..." / "Я Pugi — твой инженерный напарник...") from the
+ * transcript body as a defense-in-depth complement to the backend
+ * output gate. The prompt + gate already block this upstream; the
+ * render guards against the rare case where a legacy model release
+ * sneaks the intro past both layers.
+ *
+ * The strip is intentionally conservative — we only remove the
+ * canonical phrasings the prompt teaches Pugi to emit. Any other
+ * prose containing the word "Pugi" passes through unchanged.
+ *
+ * Exported for spec.
+ */
+export function stripLeadingIdentityIntro(text) {
+    if (!text || text.length === 0)
+        return text;
+    // Try each canonical intro shape in turn (RU + EN). We strip only
+    // the LEADING occurrence; a mid-body mention is intentional citation
+    // (e.g. "the Pugi codename..." in an explainer turn).
+    const introPatterns = [
+        // RU canonical — both masculine ("напарник/напарника/напарнику") and
+        // feminine ("напарница/напарницей/напарнице") declensions land on this
+        // strip. The prior pattern `напарни[ккк][аеу]?` was a character-class
+        // typo (three `к`s collapse to one) and accepted no feminine form, so
+        // a Pugi reply opening "Я Pugi — твоя инженерная напарница…" leaked
+        // past the strip. P1 reviewer fix PR .
+        /^(?:Я\s+Pugi\s*[—–-]\s*тв(?:ой|ё|оя)\s+инженерн[аыяий][хйеомя]*\s+напарни(?:к[аеу]?|ц(?:ей|а|ы|е|у))[.,!]?\s*)/u,
+        /^(?:Я\s+Pugi\s*[—–-]\s*координатор[.,!]?\s*)/u,
+        // EN canonical
+        /^(?:I'?m\s+Pugi\s*[—–-]\s*your\s+engineering\s+copilot[.,!]?\s*)/iu,
+        /^(?:Pugi\s+here[.,!]?\s*)/iu,
+        /^(?:This\s+is\s+Pugi[.,!]?\s*)/iu,
+    ];
+    let out = text;
+    for (const re of introPatterns) {
+        out = out.replace(re, '');
+    }
+    // If the body had ONLY the intro phrase, return the original — never
+    // hand the operator an empty bubble. The output gate would have
+    // logged the verbosity hit; the operator sees the unmodified text.
+    if (out.trim().length === 0)
+        return text;
+    return out;
+}
 /**
  * Cheap heuristic for "this transcript row will benefit from Markdown
  * rendering". We only pay the parser cost when the row plausibly
  * contains a code fence, heading, list item, or inline accent. A bare
- * "Mira shipped." line takes the legacy fast path.
+ * "Pugi shipped." line takes the legacy fast path.
  *
  * The probe is intentionally generous - false positives just route
  * through the parser, which renders plain text identically.
@@ -67,7 +141,7 @@ function looksLikeMarkdown(text) {
         return false;
     if (text.includes('```'))
         return true;
-    // Codex P2 PR #369: intro-plus-list shape ("Summary:\n- bullet")
+    // Codex P2 PR: intro-plus-list shape ("Summary:\n- bullet")
     // must route through renderer. Scan EVERY line, not just the first.
     const lines = text.split('\n');
     for (const raw of lines) {

package/dist/tui/cost-table.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { estimateUsd, formatTokensWithCommas, formatUsd, rateFor } from '../core/cost/rate-card.js';
+/**
+ * Column widths chosen to match the L19 spec output. The model column is
+ * the widest because slug strings like `qwen3-coder-480b-instruct-fp8`
+ * run 31 chars. We pad/truncate inside the renderer so a TUI on a 80-col
+ * terminal does not wrap mid-table.
+ */
+const COL_MODEL = 34;
+const COL_IN = 8;
+const COL_OUT = 9;
+const COL_USD = 10;
+/**
+ * Render one cost report. Stateless — re-rendering with the same view
+ * produces the same output by construction. Tests assert against
+ * `lastFrame()` from `ink-testing-library`.
+ */
+export function CostTable({ view }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: view.heading }), _jsx(Text, { children: "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [pad('MODEL', COL_MODEL), padLeft('IN_TOK', COL_IN), padLeft('OUT_TOK', COL_OUT), padLeft('$ EST', COL_USD)] }), view.rows.length === 0 ? (_jsx(Text, { dimColor: true, children: "No calls recorded yet \u2014 brief a persona to charge the meter." })) : (view.rows.map((row) => (_jsxs(Text, { children: [pad(row.model, COL_MODEL), padLeft(formatTokensWithCommas(row.inputTokens), COL_IN), padLeft(formatTokensWithCommas(row.outputTokens), COL_OUT), padLeft(formatUsd(row.usd), COL_USD), row.note ? ` (${row.note})` : ''] }, row.model)))), _jsx(Text, { children: " " }), _jsxs(Text, { children: ["Total tokens: ", formatTokensWithCommas(view.totalInputTokens + view.totalOutputTokens), ' (in: ', formatTokensWithCommas(view.totalInputTokens), ', out: ', formatTokensWithCommas(view.totalOutputTokens), ')'] }), _jsxs(Text, { children: ["Total dollar estimate: ", formatUsd(view.totalUsd)] }), view.tier ? _jsxs(Text, { children: ["Tier: ", view.tier.tier, view.tier.quotaLine ? ` (${view.tier.quotaLine})` : ''] }) : null] }));
+}
+/**
+ * Build a `CostView` from a `SessionAggregate`. The function lives here
+ * (next to the renderer) so a future caller — the REPL slash, the CLI
+ * command, a JSON-only path — uses the same view-model shape and the
+ * same row-sort rule.
+ */
+export function buildCostView(input) {
+    const rows = [];
+    for (const [model, entry] of Object.entries(input.aggregate.models)) {
+        const usd = estimateUsd(model, entry.input, entry.output);
+        const rate = rateFor(model);
+        rows.push({
+            model,
+            inputTokens: entry.input,
+            outputTokens: entry.output,
+            usd,
+            note: rate.note,
+        });
+    }
+    // Sort by USD descending first (most-expensive-first, matches the L19
+    // sample output where the Claude row leads). Ties break by total
+    // tokens so two free open-weight rows order deterministically.
+    rows.sort((a, b) => {
+        if (b.usd !== a.usd)
+            return b.usd - a.usd;
+        return (b.inputTokens + b.outputTokens) - (a.inputTokens + a.outputTokens);
+    });
+    let totalIn = 0;
+    let totalOut = 0;
+    let totalUsd = 0;
+    for (const row of rows) {
+        totalIn += row.inputTokens;
+        totalOut += row.outputTokens;
+        totalUsd += row.usd;
+    }
+    return {
+        heading: input.heading,
+        rows,
+        totalInputTokens: totalIn,
+        totalOutputTokens: totalOut,
+        totalUsd,
+        tier: input.tier,
+    };
+}
+/**
+ * Plain-string renderer for non-TTY / `--json` callers. Produces the
+ * same table the Ink component would render — no ANSI / no color so it
+ * pipes cleanly into `less` or a JSON tool.
+ */
+export function renderCostTableText(view) {
+    const lines = [];
+    lines.push(view.heading);
+    lines.push('════════════════════════════════════════════════');
+    lines.push('');
+    lines.push(pad('MODEL', COL_MODEL) +
+        padLeft('IN_TOK', COL_IN) +
+        padLeft('OUT_TOK', COL_OUT) +
+        padLeft('$ EST', COL_USD));
+    if (view.rows.length === 0) {
+        lines.push('No calls recorded yet — brief a persona to charge the meter.');
+    }
+    else {
+        for (const row of view.rows) {
+            const noteSuffix = row.note ? ` (${row.note})` : '';
+            lines.push(pad(row.model, COL_MODEL) +
+                padLeft(formatTokensWithCommas(row.inputTokens), COL_IN) +
+                padLeft(formatTokensWithCommas(row.outputTokens), COL_OUT) +
+                padLeft(formatUsd(row.usd), COL_USD) +
+                noteSuffix);
+        }
+    }
+    lines.push('');
+    lines.push(`Total tokens: ${formatTokensWithCommas(view.totalInputTokens + view.totalOutputTokens)} (in: ${formatTokensWithCommas(view.totalInputTokens)}, out: ${formatTokensWithCommas(view.totalOutputTokens)})`);
+    lines.push(`Total dollar estimate: ${formatUsd(view.totalUsd)}`);
+    if (view.tier) {
+        lines.push(`Tier: ${view.tier.tier}${view.tier.quotaLine ? ` (${view.tier.quotaLine})` : ''}`);
+    }
+    return lines.join('\n');
+}
+function pad(value, width) {
+    if (value.length >= width)
+        return value.slice(0, Math.max(0, width - 1)) + ' ';
+    return value + ' '.repeat(width - value.length);
+}
+function padLeft(value, width) {
+    if (value.length >= width)
+        return value.slice(0, width);
+    return ' '.repeat(width - value.length) + value;
+}
+//# sourceMappingURL=cost-table.js.map

package/dist/tui/device-flow.js

@@ -5,7 +5,7 @@ const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧',
 const ACCENT_CYAN = 'cyan';
 const ACCENT_RED = 'red';
 /**
- * P2-1 (triple-review 2026-05-24): both `userCode` and
+ * P2-1 (triple-review): both `userCode` and
  * `verificationUrl` originate from a server response and would render
  * verbatim into Ink `<Text>`. A hostile or compromised server could
  * embed ANSI escape sequences (clear screen, cursor moves, hyperlink
@@ -108,7 +108,7 @@ export function DeviceFlow(props) {
  * cabinet page.
  */
 function CodeChip({ code }) {
-    return (_jsx(Box, { marginTop: 1, justifyContent: "center", children: _jsx(Text, { bold: true, color: ACCENT_CYAN, children: `  ${code}  ` }) }));
+    return (_jsx(Box, { marginTop: 1, justifyContent: "center", children: _jsx(Text, { bold: true, color: ACCENT_CYAN, children: ` ${code} ` }) }));
 }
 function BrowserHintRow({ opened, url, copied, }) {
     if (copied) {

package/dist/tui/doctor-table.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useTheme } from '../core/theme/context.js';
+/**
+ * status colors flow through the active theme
+ * instead of being hard-coded Ink color names. The `colorblind`
+ * preset re-maps OK/WARN/ERROR to a blue-yellow-magenta axis so
+ * deuteranopia operators can still distinguish the three states; the
+ * `default` / `dark` / `light` themes route to green/yellow/red
+ * variants tuned for each background. `skipped` keeps a muted color
+ * (theme-controlled muted token) so dimmed rows still pick up the
+ * theme tint.
+ */
+function buildStatusColor(theme) {
+    return {
+        ok: theme.success,
+        warn: theme.warning,
+        error: theme.error,
+        skipped: theme.muted,
+    };
+}
+function buildOverallColor(theme) {
+    return {
+        healthy: theme.success,
+        warning: theme.warning,
+        error: theme.error,
+    };
+}
+export function DoctorTable({ envelope }) {
+    const theme = useTheme();
+    const statusColor = buildStatusColor(theme);
+    const overallColor = buildOverallColor(theme);
+    const nameWidth = Math.max('NAME'.length, ...envelope.probes.map((row) => row.name.length));
+    const statusWidth = Math.max('STATUS'.length, ...envelope.probes.map((row) => row.status.length));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Pugi Doctor" }) }), envelope.probes.map((row) => (_jsx(DoctorRow, { row: row, nameWidth: nameWidth, statusWidth: statusWidth, statusColor: statusColor }, row.name))), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [envelope.counts.error, " error(s), ", envelope.counts.warn, " warning(s), ", envelope.counts.ok, " ok,", ' ', envelope.counts.skipped, " skipped. Overall:", ' ', _jsx(Text, { color: overallColor[envelope.overall], bold: true, children: envelope.overall.toUpperCase() })] }) }), _jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["CLI ", envelope.meta.cliVersion, " Node ", envelope.meta.nodeVersion, " cwd ", envelope.meta.cwd] }) })] }));
+}
+function DoctorRow({ row, nameWidth, statusWidth, statusColor }) {
+    const namePart = row.name.padEnd(nameWidth, ' ');
+    const statusPart = row.status.toUpperCase().padEnd(statusWidth, ' ');
+    const latencyPart = typeof row.latencyMs === 'number' ? ` (${row.latencyMs}ms)` : '';
+    const showRemediation = typeof row.remediation === 'string' &&
+        row.remediation.length > 0 &&
+        (row.status === 'warn' || row.status === 'error');
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { children: [namePart, " "] }), _jsx(Text, { color: statusColor[row.status], bold: true, children: statusPart }), _jsxs(Text, { children: [' ', row.detail, latencyPart] })] }), showRemediation && (_jsx(Box, { marginLeft: nameWidth + statusWidth + 4, children: _jsxs(Text, { dimColor: true, children: ["\u2192 ", row.remediation] }) }))] }));
+}
+//# sourceMappingURL=doctor-table.js.map

package/dist/tui/feedback-prompt.js

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