@pugi/cli 0.1.0-beta.16 → 0.1.0-beta.18

package/dist/tools/file-tools.js

@@ -1,9 +1,37 @@
+/**
+ * file-tools - Pugi CLI file/bash/glob/grep tool surface.
+ *
+ * Workspace-binding contract (CEO red-alert 2026-05-27 follow-up):
+ *
+ *   Every tool dispatch path threads `ctx.root` from the operator's
+ *   `process.cwd()` through `EngineTask.workspaceRoot` ->
+ *   `native-pugi.run()` -> `toolCtx.root` -> here. Tools call
+ *   `resolveWorkspacePath(ctx.root, path)` for every on-disk operation
+ *   so a dispatched specialist (e.g. Hiroshi writing tic-tac-toe HTML)
+ *   produces files in the OPERATOR'S cwd, never in a server-side temp
+ *   space. The path-security gate refuses traversal (`../etc/passwd`,
+ *   URL-encoded variants, symlink escapes at the target).
+ *
+ *   Wiring chain:
+ *     1. runtime/cli.ts:    workspaceRoot = process.cwd()
+ *     2. EngineTask.workspaceRoot threads through to native-pugi.run().
+ *     3. native-pugi:       const root = task.workspaceRoot
+ *     4. tool-bridge:       passes ctx.root to file-tools / bash.
+ *     5. file-tools:        resolveWorkspacePath(ctx.root, path).
+ *
+ *   The contract is locked by `test/tools-write-to-workspace.spec.ts`
+ *   (6 cases covering relative + nested + absolute paths + traversal
+ *   refusal). If any layer of the chain regressed silently, dispatched
+ *   files would land in `/tmp` instead of the operator's repo, which
+ *   is the same failure surface as the menu-mode anti-pattern the
+ *   sibling commits close.
+ */
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, relative } from 'node:path';
 import { globSync } from 'node:fs';
 import { decidePermission } from '../core/permission.js';
-import { createReadRecord, hashContent } from '../core/file-cache.js';
+import { StaleReadError, createReadRecord, hashContent, } from '../core/file-cache.js';
 import { resolveWorkspacePath } from '../core/path-security.js';
 import { recordFileMutation, recordToolCall, recordToolResult } from '../core/session.js';
 /**
@@ -19,6 +47,11 @@ export class OperatorAbortedError extends Error {
         this.name = 'OperatorAbortedError';
     }
 }
+// Re-export StaleReadError so tool-bridge / test consumers can import
+// the typed error from a single file-tools surface alongside
+// OperatorAbortedError. Same shape as the existing OperatorAbortedError
+// re-surface pattern.
+export { StaleReadError } from '../core/file-cache.js';
 /**
  * α6.9 WriteGate: refuse the tool dispatch when the active
  * cancellation token has aborted. Idempotent (the token's `isAborted`
@@ -124,10 +157,37 @@ export function writeTool(ctx, path, content) {
         throw error;
     }
     const existed = existsSync(resolved);
-    const before = existed ? readFileSync(resolved, 'utf8') : undefined;
+    // Leak L1 stale-read gate for writeTool's update-existing path. The
+    // model uses writeTool for two distinct intents:
+    //
+    //   - create-new: path does not exist on disk. There is no prior
+    //     read to validate against; skip the gate. This is the
+    //     intentional escape hatch the leak spec also calls out.
+    //   - overwrite-existing: path exists. Without the gate the model
+    //     could blind-clobber an externally-modified file, losing the
+    //     concurrent change silently. Force the model to re-read first.
+    //
+    // We deliberately apply the SAME stale-validation primitive editTool
+    // uses so the two write surfaces stay symmetric and a future fix to
+    // either one cannot accidentally weaken the other.
+    let before;
+    if (existed) {
+        before = readFileSync(resolved, 'utf8');
+        const currentStat = statSync(resolved);
+        const validation = ctx.readCache.validate(ctx.root, path, currentStat.mtimeMs, before);
+        if (validation.stale) {
+            const reason = `stale_read: write ${path} refused — ${validation.detail}`;
+            recordToolResult(ctx.session, toolCallId, 'error', reason);
+            throw new StaleReadError(path, validation.reason, validation.detail);
+        }
+    }
     const tmp = `${resolved}.pugi-tmp-${Date.now()}`;
     writeFileSync(tmp, content, { encoding: 'utf8', mode: 0o600 });
     renameSync(tmp, resolved);
+    // Refresh the cache with the post-write content so the model can
+    // chain a follow-up read+edit on the same file without an extra
+    // round-trip. Same pattern editTool uses below.
+    ctx.readCache.set(createReadRecord(ctx.root, path, content, 'read_tool'));
     recordFileMutation(ctx.session, {
         toolCallId,
         path,
@@ -154,10 +214,6 @@ export function editTool(ctx, path, oldString, newString) {
         recordToolResult(ctx.session, toolCallId, 'error', reason);
         throw new Error(reason);
     }
-    const readRecord = ctx.readCache.get(ctx.root, path);
-    if (!readRecord) {
-        throw new Error(`Cannot edit ${path}: file must be read first`);
-    }
     let resolved;
     try {
         resolved = permissionGatedResolve(ctx, path, 'edit', 'edit');
@@ -167,16 +223,31 @@ export function editTool(ctx, path, oldString, newString) {
         recordToolResult(ctx.session, toolCallId, 'error', reason);
         throw error;
     }
+    // Leak L1 stale-read gate. Validate the model's read-time view of
+    // the file against the on-disk state BEFORE applying the mutation.
+    // We read disk content once and feed it to the validator so a single
+    // syscall covers both the gate decision AND the oldString/newString
+    // replacement below.
     const before = readFileSync(resolved, 'utf8');
-    const currentHash = hashContent(before);
-    if (currentHash !== readRecord.sha256) {
-        throw new Error(`Cannot edit ${path}: file changed since last read`);
+    const currentStat = statSync(resolved);
+    const validation = ctx.readCache.validate(ctx.root, path, currentStat.mtimeMs, before);
+    if (validation.stale) {
+        const reason = `stale_read: edit ${path} refused — ${validation.detail}`;
+        recordToolResult(ctx.session, toolCallId, 'error', reason);
+        throw new StaleReadError(path, validation.reason, validation.detail);
     }
+    const currentHash = hashContent(before);
     const matches = before.split(oldString).length - 1;
-    if (matches === 0)
-        throw new Error(`Cannot edit ${path}: oldString not found`);
-    if (matches > 1)
-        throw new Error(`Cannot edit ${path}: oldString is not unique`);
+    if (matches === 0) {
+        const reason = `Cannot edit ${path}: oldString not found`;
+        recordToolResult(ctx.session, toolCallId, 'error', reason);
+        throw new Error(reason);
+    }
+    if (matches > 1) {
+        const reason = `Cannot edit ${path}: oldString is not unique`;
+        recordToolResult(ctx.session, toolCallId, 'error', reason);
+        throw new Error(reason);
+    }
     const after = before.replace(oldString, newString);
     const tmp = `${resolved}.pugi-tmp-${Date.now()}`;
     writeFileSync(tmp, after, { encoding: 'utf8', mode: 0o600 });

package/dist/tools/registry.js

@@ -3,6 +3,13 @@ const registry = [
     // gate as Layer A/B/C, so the risk class matches `edit`/`write`
     // (medium — writes inside the workspace, never to protected files).
     { name: 'apply_patch', permission: 'edit', risk: 'medium', concurrencySafe: false, m1: true },
+    // Leak L5 (2026-05-27): structured multi-choice clarifier tool. Risk =
+    // low because the dispatch is a pure UI surface — no file writes, no
+    // shell, no network. Permission = none (no workspace access required).
+    // concurrencySafe = true because the prompt-budget gate runs in the
+    // engine loop, not via tool-side mutex (one prompt per turn is enforced
+    // by the persona system prompt + the engine's tool_calls budget).
+    { name: 'ask_user_question', permission: 'none', risk: 'low', concurrencySafe: true, m1: true },
     { name: 'bash', permission: 'bash', risk: 'high', concurrencySafe: false, m1: true },
     { name: 'edit', permission: 'edit', risk: 'medium', concurrencySafe: false, m1: true },
     { name: 'glob', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },

package/dist/tui/agent-progress-card.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+/** Width of the progress bar in display cells. Tuned to fit comfortably
+ *  inside an 80-col terminal alongside the percent label. */
+export const PROGRESS_BAR_WIDTH = 24;
+/** Max milestone rows the card renders before collapsing to the footer
+ *  summary. Matches the CC `/compact` cutoff. */
+export const MAX_VISIBLE_MILESTONES = 5;
+const STATUS_GLYPH = {
+    done: '◼',
+    active: '▸',
+    pending: '◻',
+};
+const STATUS_COLOR = {
+    done: 'green',
+    active: 'yellow',
+    pending: 'gray',
+};
+const HEADER_DOT_COLOR = {
+    running: 'cyan',
+    completed: 'green',
+    failed: 'red',
+};
+/**
+ * Build the unicode progress bar. Exported для тесты — guarantees the
+ * filled/empty counts match the percent under all rounding edges.
+ */
+export function renderProgressBarCells(percent, width = PROGRESS_BAR_WIDTH) {
+    const safePercent = Math.max(0, Math.min(100, percent));
+    const cells = Math.round((safePercent / 100) * width);
+    const clamped = Math.max(0, Math.min(width, cells));
+    return {
+        filled: '▰'.repeat(clamped),
+        empty: '▱'.repeat(width - clamped),
+        cells: clamped,
+    };
+}
+/**
+ * Format milliseconds as the CC-style `Hh Mm Ss` / `Mm Ss` / `Ss` label.
+ * Mirrors the rule used by status-bar elapsed slot.
+ */
+export function formatElapsed(ms) {
+    const total = Math.max(0, Math.floor(ms / 1000));
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = total % 60;
+    if (h > 0)
+        return `${h}h ${m}m ${s}s`;
+    if (m > 0)
+        return `${m}m ${s}s`;
+    return `${s}s`;
+}
+/**
+ * Format a raw token count as `21.7k` / `3.4M` / `812`. Mirrors the
+ * formatter in `core/repl/model-pricing.ts` so both surfaces stay
+ * visually consistent without coupling.
+ */
+export function formatTokenCount(n) {
+    if (n === undefined)
+        return undefined;
+    if (n < 1_000)
+        return `${n}`;
+    if (n < 1_000_000) {
+        const k = n / 1_000;
+        return `${k >= 10 ? k.toFixed(1).replace(/\.0$/, '') : k.toFixed(1)}k`;
+    }
+    const m = n / 1_000_000;
+    return `${m >= 10 ? m.toFixed(1).replace(/\.0$/, '') : m.toFixed(1)}M`;
+}
+/**
+ * Compute the "… +N pending, M completed" footer counts. When the
+ * agent supplied rollups they win; otherwise we derive from the
+ * milestone array.
+ */
+export function computeFooterCounts(milestones, visibleCount, rollup) {
+    const pending = rollup.pendingCount
+        ?? milestones.filter((m) => m.status === 'pending').length;
+    const completed = rollup.completedCount
+        ?? milestones.filter((m) => m.status === 'done').length;
+    const hidden = Math.max(0, milestones.length - visibleCount);
+    return { pending, completed, hidden };
+}
+function MilestoneRow({ milestone }) {
+    const glyph = STATUS_GLYPH[milestone.status];
+    const color = STATUS_COLOR[milestone.status];
+    // Truncate to 64 chars so a verbose label can't wrap and break the
+    // grid layout in the watcher.
+    const label = milestone.label.length > 64
+        ? `${milestone.label.slice(0, 63)}…`
+        : milestone.label;
+    return (_jsxs(Box, { children: [_jsx(Text, { children: '   ' }), _jsx(Text, { color: color, children: glyph }), _jsx(Text, { children: " " }), _jsx(Text, { color: color === 'gray' ? 'gray' : undefined, dimColor: milestone.status === 'pending', children: label })] }));
+}
+export function AgentProgressCard({ progress, nowEpochMs, }) {
+    // Re-derive elapsed from the wall clock when the parent supplied it;
+    // this is what makes the card tick once a second without the writer
+    // re-emitting JSON every tick.
+    const elapsed = nowEpochMs !== undefined
+        ? Math.max(progress.elapsedMs, nowEpochMs - Date.parse(progress.startedAt))
+        : progress.elapsedMs;
+    const bar = renderProgressBarCells(progress.percentComplete);
+    const percentLabel = `${Math.round(Math.max(0, Math.min(100, progress.percentComplete)))}%`;
+    const tokensLabel = formatTokenCount(progress.tokensUsed);
+    const dotColor = HEADER_DOT_COLOR[progress.status];
+    const visibleMilestones = progress.milestones.slice(0, MAX_VISIBLE_MILESTONES);
+    const footer = computeFooterCounts(progress.milestones, visibleMilestones.length, { pendingCount: progress.pendingCount, completedCount: progress.completedCount });
+    // CC compact pattern: header has a leading `· ` glyph + the task label.
+    // We append `…` only while running (matches CC's "Compacting…" verb form).
+    const headerVerb = progress.status === 'running' ? '…' : '';
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: dotColor, children: '· ' }), _jsx(Text, { bold: true, children: progress.agentType }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [progress.task, headerVerb] }), _jsxs(Text, { dimColor: true, children: [' (', formatElapsed(elapsed), tokensLabel ? ` · ↑ ${tokensLabel} tokens` : '', ')'] })] }), _jsxs(Box, { children: [_jsx(Text, { children: '  ' }), _jsx(Text, { color: "cyan", children: bar.filled }), _jsx(Text, { dimColor: true, children: bar.empty }), _jsxs(Text, { children: [' ', percentLabel] })] }), progress.stepDescription ? (_jsxs(Box, { children: [_jsx(Text, { children: '  ' }), _jsxs(Text, { dimColor: true, children: ["step ", progress.currentStep, "/", progress.totalSteps, ": ", progress.stepDescription] })] })) : null, visibleMilestones.length > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { children: '  ' }), _jsx(Text, { dimColor: true, children: "\u23BF" })] }), visibleMilestones.map((m, i) => (_jsx(MilestoneRow, { milestone: m }, `${m.label}-${i}`))), footer.hidden > 0 ? (_jsxs(Box, { children: [_jsx(Text, { children: '     ' }), _jsxs(Text, { dimColor: true, children: ["\u2026 +", footer.pending, " pending, ", footer.completed, " completed"] })] })) : null] })) : null] }));
+}
+//# sourceMappingURL=agent-progress-card.js.map

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

@@ -0,0 +1,192 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * AskUserQuestionPrompt — Ink modal for the structured tool grammar
+ * (leak L5, openclaude pattern).
+ *
+ * Renders the four required elements of an openclaude-style 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 });
+    }
+    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 }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, 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)' })] })] }), 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/conversation-pane.js

@@ -43,16 +43,77 @@ function ConversationRow({ row, personaNames, }) {
             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 2026-05-27: 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 Claude Code / 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 Mira 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 Mira reply opening "Я Pugi — твоя инженерная напарница…" leaked
+        // past the strip. P1 reviewer fix PR #540 (2026-05-27).
+        /^(?:Я\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

package/dist/tui/doctor-table.js

@@ -0,0 +1,31 @@
+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',
+};
+export function DoctorTable({ envelope }) {
+    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] }) })] }));
+}
+function DoctorRow({ row, nameWidth, statusWidth }) {
+    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] }) }))] }));
+}
+//# sourceMappingURL=doctor-table.js.map

package/dist/tui/tool-stream-pane.js

@@ -64,6 +64,13 @@ function toolDisplayName(tool) {
     switch (tool) {
         case 'read':
             return 'Read';
+        case 'write':
+            // 2026-05-27 — Write is the most operator-visible tool for the
+            // codegen-dispatch surface (Hiroshi writing index.html / style.css
+            // / script.js for a tic-tac-toe brief). Add the display name so
+            // the tool stream pane renders ✓ Write(index.html) instead of an
+            // unlabeled placeholder. Mirrors the Claude Code Write rendering.
+            return 'Write';
         case 'edit':
             return 'Edit';
         case 'bash':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-beta.16",
+  "version": "0.1.0-beta.18",
   "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -54,7 +54,7 @@
     "undici": "^8.3.0",
     "zod": "^3.23.0",
     "@pugi/personas": "0.1.2",
-    "@pugi/sdk": "0.1.0-beta.16"
+    "@pugi/sdk": "0.1.0-beta.18"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",