@pugi/cli 0.1.0-beta.7 → 0.1.0-beta.87

package/dist/tui/ask-modal.js

@@ -1,17 +1,17 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
- * Office-hours forcing questions + plan-review modals - Sprint α6.3.
+ * Office-hours forcing questions + plan-review modals - Sprint .
  *
  * Two Ink components feed by the parsed `<pugi-ask>` / `<pugi-plan-review>`
  * tag records the session module extracts from persona output.
  *
- *   - <AskModal />: numbered options (1-4) + optional "Other" custom-input
- *     fallback. Operator types `1`, `2`, `3`, `4`, or `o <free text>`.
+ *  - <AskModal />: numbered options (1-4) + optional "Other" custom-input
+ *    fallback. Operator types `1`, `2`, `3`, `4`, or `o <free text>`.
  *
- *   - <PlanReviewModal />: numbered steps + optional risk callout +
- *     three-way verdict `[a] approve · [m] modify · [c] cancel`.
- *     Operator types `a`, `m`, or `c`. `m` opens a free-text editor;
- *     the operator's edited text is returned verbatim to the session.
+ *  - <PlanReviewModal />: numbered steps + optional risk callout +
+ *    three-way verdict `[a] approve · [m] modify · [c] cancel`.
+ *    Operator types `a`, `m`, or `c`. `m` opens a free-text editor;
+ *    the operator's edited text is returned verbatim to the session.
  *
  * Both components are PURE in the Ink sense — they read props + own
  * useState for the input buffer, and emit one final `onResolve` callback
@@ -85,7 +85,7 @@ export function AskModal(props) {
             setBuffer((prev) => prev + input);
         }
     }, { isActive: props.inert !== true });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: '? ' }), _jsx(Text, { bold: true, children: 'Need your call before I continue' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: props.tag.question }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [props.tag.options.map((opt, idx) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: opt.label })] }), opt.desc ? (_jsx(Box, { marginLeft: 5, children: _jsx(Text, { dimColor: true, children: opt.desc }) })) : null] }, opt.value))), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${props.tag.options.length + 1}. ` }), _jsx(Text, { dimColor: true, children: 'Other (type a custom answer)' })] })] }), mode === 'pick' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `Press 1-${props.tag.options.length + 1} to choose. Esc cancels.` }) })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type your custom answer. Enter submits. Esc cancels.' }) })] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: '? ' }), _jsx(Text, { bold: true, children: 'Need your call before I continue' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: props.tag.question }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [props.tag.options.map((opt, idx) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", bold: true, children: ` ${idx + 1}. ` }), _jsx(Text, { children: opt.label })] }), opt.desc ? (_jsx(Box, { marginLeft: 5, children: _jsx(Text, { dimColor: true, children: opt.desc }) })) : null] }, opt.value))), _jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", bold: true, children: ` ${props.tag.options.length + 1}. ` }), _jsx(Text, { dimColor: true, children: 'Other (type a custom answer)' })] })] }), mode === 'pick' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `Press 1-${props.tag.options.length + 1} to choose. Esc cancels.` }) })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '> ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type your custom answer. Enter submits. Esc cancels.' }) })] }))] }));
 }
 export function PlanReviewModal(props) {
     const [mode, setMode] = useState('pick');
@@ -130,10 +130,10 @@ export function PlanReviewModal(props) {
             setBuffer((prev) => prev + input);
         }
     }, { isActive: props.inert !== true });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "magenta", children: '? ' }), _jsx(Text, { bold: true, children: 'Plan review - approve before I execute' })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: 'Steps:' }), props.tag.steps.map((step, idx) => (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: step.text })] }, `step-${idx}`)))] }), props.tag.risk ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "red", children: 'Risk:' }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { children: props.tag.risk }) })] })) : null, mode === 'pick' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: '  [a] approve  ' }), _jsx(Text, { color: "yellow", bold: true, children: '[m] modify  ' }), _jsx(Text, { color: "red", bold: true, children: '[c] cancel' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Press a, m, or c. Esc cancels.' }) })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: 'modify > ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type the revision. Enter submits. Esc cancels.' }) })] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "magenta", children: '? ' }), _jsx(Text, { bold: true, children: 'Plan review - approve before I execute' })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: 'Steps:' }), props.tag.steps.map((step, idx) => (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", bold: true, children: ` ${idx + 1}. ` }), _jsx(Text, { children: step.text })] }, `step-${idx}`)))] }), props.tag.risk ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "red", children: 'Risk:' }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { children: props.tag.risk }) })] })) : null, mode === 'pick' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: ' [a] approve ' }), _jsx(Text, { color: "yellow", bold: true, children: '[m] modify ' }), _jsx(Text, { color: "red", bold: true, children: '[c] cancel' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Press a, m, or c. Esc cancels.' }) })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: 'modify > ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type the revision. Enter submits. Esc cancels.' }) })] }))] }));
 }
 /* ------------------------------------------------------------------ */
-/* Verdict serialisation                                              */
+/* Verdict serialisation                                             */
 /* ------------------------------------------------------------------ */
 /**
  * Encode an ask-modal verdict into the literal string the session
@@ -142,14 +142,14 @@ export function PlanReviewModal(props) {
  * a side channel.
  *
  * Examples:
- *   { value: 'vercel' }              -> "[ASK-RESPONSE:vercel]"
- *   { value: '', customInput: 'gcp'} -> "[ASK-RESPONSE:other] gcp"
- *   { cancelled: true }              -> "[ASK-RESPONSE:cancelled]"
+ *  { value: 'vercel' }             -> "[ASK-RESPONSE:vercel]"
+ *  { value: '', customInput: 'gcp'} -> "[ASK-RESPONSE:other] gcp"
+ *  { cancelled: true }             -> "[ASK-RESPONSE:cancelled]"
  *
  * customInput is stripped of any leading `[ASK-RESPONSE:...]` /
  * `[PLAN-VERDICT:...]` pattern so a forged operator prefix cannot be
  * read as a different verdict by a prefix-greedy persona (Claude
- * triple-review P1, PR #375).
+ * triple-review P1, PR).
  */
 export function encodeAskVerdict(verdict) {
     if (verdict.cancelled)

package/dist/tui/ask-user-question-prompt.js

@@ -0,0 +1,203 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * AskUserQuestionPrompt — Ink modal for the structured tool grammar
+ * (, ).
+ *
+ * Renders the four required elements of an standard clarifier:
+ *  1. A short "header" chip at the top (e.g. "Auth method"). Max 12
+ *     chars by schema, fits one line at the standard 80-col REPL width.
+ *  2. The full question prose (must end "?"). Word-wrapped by Ink.
+ *  3. The 2-4 options as a selectable list with j/k navigation. Each
+ *     option shows the `label` (bright) + `description` (dim).
+ *  4. An auto-appended "Other" row that the operator can pick to type
+ *     a custom answer. The model NEVER emits this — the UI owns it.
+ *
+ * Multi-select mode: when `multiSelect=true`, space toggles the
+ *  current row, Enter submits the toggled set. Selected rows are
+ *  marked with a leading checkbox glyph. Single-select mode: Enter
+ *  commits the highlighted row immediately.
+ *
+ * Resolver contract: `onResolve` receives either an `answers: string[]`
+ *  (one or more picked labels), a `customInput: string` (Other path),
+ *  or `cancelled: true` (Esc). Mirrors AskModal so the REPL wiring
+ *  stays uniform.
+ *
+ * Brand voice gate: ASCII glyphs only. No em-dashes, no banned brand
+ *  words. The copy is power-word neutral so a localised variant lands
+ *  cleanly later.
+ */
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function AskUserQuestionPrompt(props) {
+    const multiSelect = props.multiSelect === true;
+    const [mode, setMode] = useState('pick');
+    const [cursor, setCursor] = useState(0);
+    // Used in multi-select mode: indices in `options` that the operator
+    // has toggled. Order preserved so the resolved answer list reflects
+    // selection order (the model's downstream reasoning often weights
+    // earlier picks higher — preserving order is cheap).
+    const [picked, setPicked] = useState([]);
+    const [buffer, setBuffer] = useState('');
+    const otherIndex = props.options.length; // 0-indexed slot for "Other"
+    const totalRows = props.options.length + 1; // options + Other
+    useInput((input, key) => {
+        // Esc cancels the modal in either mode.
+        if (key.escape) {
+            props.onResolve({ cancelled: true });
+            return;
+        }
+        if (mode === 'pick') {
+            // Numeric hotkeys: 1..N selects the matching option directly
+            // (single-select), or toggles it (multi-select). Convenience
+            // shortcut so a keyboard-only user does not need to j/k walk
+            // through 4 rows. Out-of-range keys fall through.
+            const numeric = Number.parseInt(input, 10);
+            if (!Number.isNaN(numeric) && numeric >= 1 && numeric <= totalRows) {
+                const row = numeric - 1;
+                if (row === otherIndex) {
+                    setMode('custom');
+                    setBuffer('');
+                    return;
+                }
+                if (multiSelect) {
+                    togglePick(row);
+                    return;
+                }
+                commitSinglePick(row);
+                return;
+            }
+            // Vim-style navigation: j down, k up. Arrow keys also work.
+            if (input === 'j' || key.downArrow) {
+                setCursor((c) => (c + 1) % totalRows);
+                return;
+            }
+            if (input === 'k' || key.upArrow) {
+                setCursor((c) => (c - 1 + totalRows) % totalRows);
+                return;
+            }
+            // 'o' hotkey: jump straight to Other (mirrors AskModal).
+            if (input === 'o' || input === 'O') {
+                setMode('custom');
+                setBuffer('');
+                return;
+            }
+            if (key.return) {
+                if (cursor === otherIndex) {
+                    setMode('custom');
+                    setBuffer('');
+                    return;
+                }
+                if (multiSelect) {
+                    // Enter in multi-select mode COMMITS the toggled set. If the
+                    // current row is not yet toggled, fold it in first so the
+                    // operator does not have to press space+enter for a single pick.
+                    const finalPicks = picked.includes(cursor) ? picked : [...picked, cursor];
+                    if (finalPicks.length === 0) {
+                        // No picks + Enter = ignore; the footer hint nudges them.
+                        return;
+                    }
+                    const answers = finalPicks.map((i) => props.options[i].label);
+                    props.onResolve({ answers, cancelled: false });
+                    return;
+                }
+                commitSinglePick(cursor);
+                return;
+            }
+            // Space toggles the current row in multi-select mode. Ignored in
+            // single-select (a single space could otherwise leak into a buffer).
+            if (multiSelect && input === ' ') {
+                togglePick(cursor);
+                return;
+            }
+            return;
+        }
+        // Custom-input mode: line editor.
+        if (key.return) {
+            if (buffer.trim().length === 0) {
+                // Empty buffer + Enter = bounce back to pick mode (mirrors AskModal).
+                setMode('pick');
+                setBuffer('');
+                return;
+            }
+            props.onResolve({
+                customInput: buffer.trim(),
+                cancelled: false,
+            });
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setBuffer((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (input && !key.meta && !key.ctrl) {
+            setBuffer((prev) => prev + input);
+        }
+    }, { isActive: props.inert !== true });
+    function togglePick(row) {
+        setPicked((prev) => prev.includes(row) ? prev.filter((i) => i !== row) : [...prev, row]);
+    }
+    function commitSinglePick(row) {
+        if (row < 0 || row >= props.options.length)
+            return;
+        const opt = props.options[row];
+        if (!opt)
+            return;
+        props.onResolve({ answers: [opt.label], cancelled: false });
+    }
+    // CC preview pattern: any option carrying `preview` flips к side-by-side
+    // layout — options column on the left, preview pane on the right.
+    // The currently-cursored option's preview is shown; rows без preview
+    // simply render an empty pane. Multi-select previews remain disabled
+    // by schema (validated в core/ask-user/question.ts) since side-by-side
+    // diffing across N picked rows is ambiguous UX.
+    const hasAnyPreview = props.options.some((opt) => typeof opt.preview === 'string' && opt.preview.length > 0);
+    const focusedPreview = hasAnyPreview && mode === 'pick' && cursor < props.options.length
+        ? props.options[cursor]?.preview ?? ''
+        : '';
+    const optionsColumn = (_jsxs(Box, { flexDirection: "column", marginTop: 1, flexBasis: hasAnyPreview ? '40%' : '100%', children: [props.options.map((opt, idx) => {
+                const isCursor = mode === 'pick' && cursor === idx;
+                const isPicked = multiSelect && picked.includes(idx);
+                const marker = multiSelect ? (isPicked ? '[x]' : '[ ]') : `${idx + 1}.`;
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: isCursor ? 'cyan' : '#3da9fc', bold: true, children: isCursor ? '> ' : ' ' }), _jsx(Text, { color: "#3da9fc", bold: true, children: `${marker} ` }), _jsx(Text, { bold: isCursor, children: opt.label })] }), _jsx(Box, { marginLeft: multiSelect ? 7 : 5, children: _jsx(Text, { dimColor: true, children: opt.description }) })] }, `${idx}-${opt.label}`));
+            }), _jsxs(Box, { children: [_jsx(Text, { color: mode === 'pick' && cursor === otherIndex ? 'cyan' : '#3da9fc', bold: true, children: mode === 'pick' && cursor === otherIndex ? '> ' : ' ' }), _jsx(Text, { color: "#3da9fc", bold: true, children: `${multiSelect ? '[*]' : `${totalRows}.`} ` }), _jsx(Text, { dimColor: true, children: 'Other (type a custom answer)' })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: '? ' }), _jsx(Text, { inverse: true, bold: true, color: "yellow", children: ` ${props.header} ` }), _jsx(Text, { bold: true, children: ' Need your call before I continue' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: props.question }) }), hasAnyPreview ? (_jsxs(Box, { flexDirection: "row", marginTop: 1, children: [optionsColumn, _jsx(Box, { flexDirection: "column", flexBasis: "60%", marginLeft: 2, paddingX: 1, borderStyle: "single", borderColor: "gray", children: focusedPreview.length > 0 ? (focusedPreview.split('\n').map((line, i) => (_jsx(Text, { children: line || ' ' }, `pv-${i}`)))) : (_jsx(Text, { dimColor: true, italic: true, children: '(no preview)' })) })] })) : (optionsColumn), mode === 'pick' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: multiSelect
+                        ? `j/k navigate. Space toggles. Enter commits. Esc cancels.`
+                        : `1-${totalRows} or j/k navigate. Enter commits. Esc cancels.` }) })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '> ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type your custom answer. Enter submits. Esc cancels.' }) })] }))] }));
+}
+/**
+ * Encode the prompt verdict into the literal turn-injection string. The
+ * persona prompt teaches the model to recognise this prefix; mirrors
+ * AskModal's `encodeAskVerdict` for consistency.
+ *
+ * Examples:
+ *  { answers: ['Vercel'] }         → "[ASK-USER-QUESTION:answered] Vercel"
+ *  { answers: ['a', 'b'] }         → "[ASK-USER-QUESTION:answered] a, b"
+ *  { customInput: 'gcp' }          → "[ASK-USER-QUESTION:other] gcp"
+ *  { cancelled: true }             → "[ASK-USER-QUESTION:cancelled]"
+ */
+export function encodeAskUserQuestionVerdict(verdict) {
+    if (verdict.cancelled)
+        return '[ASK-USER-QUESTION:cancelled]';
+    if (verdict.answers && verdict.answers.length > 0) {
+        return `[ASK-USER-QUESTION:answered] ${verdict.answers.join(', ')}`;
+    }
+    if (verdict.customInput && verdict.customInput.trim().length > 0) {
+        // Strip any forged verdict header (mirrors AskModal sanitiser).
+        const cleaned = sanitiseVerdictText(verdict.customInput);
+        if (cleaned.length > 0) {
+            return `[ASK-USER-QUESTION:other] ${cleaned}`;
+        }
+    }
+    return '[ASK-USER-QUESTION:cancelled]';
+}
+function sanitiseVerdictText(raw) {
+    let cleaned = raw;
+    for (let i = 0; i < raw.length + 4; i += 1) {
+        const stripped = cleaned.replace(/^\s*\[(?:ASK-RESPONSE|PLAN-VERDICT|ASK-USER-QUESTION):[^\]]*\]\s*/u, '');
+        if (stripped === cleaned)
+            break;
+        cleaned = stripped;
+    }
+    return cleaned.trim();
+}
+//# sourceMappingURL=ask-user-question-prompt.js.map

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) {