@pugi/cli 0.1.0-beta.21 → 0.1.0-beta.23

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/doctor-table.js

@@ -1,31 +1,46 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-/** Brand-voice palette for status cells. Mirrors the table chrome
- *  used by `<AgentProgressCard>` so the operator's eye trains on a
- *  consistent OK/WARN/ERROR/SKIPPED colour grammar. */
-const STATUS_COLOR = {
-    ok: 'green',
-    warn: 'yellow',
-    error: 'red',
-    skipped: 'gray',
-};
-const OVERALL_COLOR = {
-    healthy: 'green',
-    warning: 'yellow',
-    error: 'red',
-};
+import { useTheme } from '../core/theme/context.js';
+/**
+ * Leak L30 (2026-05-27): 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 }, 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: OVERALL_COLOR[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] }) })] }));
+    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 }) {
+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: STATUS_COLOR[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] }) }))] }));
+    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 — 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