@pugi/cli 0.1.0-beta.17 → 0.1.0-beta.19

package/dist/tools/ask-user-question.js

@@ -0,0 +1,213 @@
+/**
+ * AskUserQuestion structured tool — leak L5 (research memo §2.5).
+ *
+ * Mirrors openclaude's `src/tools/AskUserQuestionTool/prompt.ts`
+ * pattern: clarifying questions go through a structured multi-choice
+ * tool, NOT free-text prose. The model dispatches the tool with a
+ * `question` + a `header` chip + 2-4 `options` (each with `label` +
+ * `description`). The UI renders the modal, auto-appends an "Other"
+ * fallback for custom text, and surfaces the operator's pick back to
+ * the model as a tool_result frame.
+ *
+ * Why P0 leverage: the structured form forecloses Pugi's recurring
+ * "agent rambles instead of dispatching" failure mode at the schema
+ * level. When the model is uncertain, the cheapest legal output is
+ * `ask_user_question` — not a prose menu, not a fake "Шипану через
+ * 8 минут" dispatch promise.
+ *
+ * Relationship to ask-user.ts (β1 T2):
+ *   - ask-user.ts is the LEGACY string-array form (`options: string[]`).
+ *     Kept for back-compat; the existing prompt envelope `<pugi-ask>`
+ *     and the persona prompts still emit that grammar.
+ *   - ask-user-question.ts is the STRUCTURED form layered on top. It
+ *     normalises a {label, description} option into the legacy string
+ *     before delegating to `askUser`, so the Ink modal does not need
+ *     two render paths and the abort/timeout race logic is shared.
+ *
+ * Hard rules (enforced by Zod):
+ *   - question: 5-500 chars, must end with "?". Plain English.
+ *   - header: 2-12 chars (short chip label, e.g. "Auth method").
+ *   - options: 2-4 strict (no more, no less). Mutually exclusive.
+ *     UI auto-adds "Other" — the model NEVER emits it.
+ *   - multiSelect: default false.
+ */
+import { z } from 'zod';
+import { askUser } from './ask-user.js';
+/** Cap matches the Ink modal layout: 12 chars fits the header chip. */
+export const ASK_USER_QUESTION_HEADER_MIN = 2;
+export const ASK_USER_QUESTION_HEADER_MAX = 12;
+/** Question must be a real question (ends with ?). 5-500 chars. */
+export const ASK_USER_QUESTION_MIN = 5;
+export const ASK_USER_QUESTION_MAX = 500;
+/** Each option label: 2-40 chars (1-5 words). */
+export const ASK_USER_QUESTION_OPTION_LABEL_MIN = 2;
+export const ASK_USER_QUESTION_OPTION_LABEL_MAX = 40;
+/** Each option description: 10-200 chars (one short sentence). */
+export const ASK_USER_QUESTION_OPTION_DESC_MIN = 10;
+export const ASK_USER_QUESTION_OPTION_DESC_MAX = 200;
+/** Option count: 2-4 strict. UI adds "Other" automatically. */
+export const ASK_USER_QUESTION_OPTIONS_MIN = 2;
+export const ASK_USER_QUESTION_OPTIONS_MAX = 4;
+/**
+ * Structured option. `label` is the display text; `description` is the
+ * implication line shown dim below it. Both are required — the model
+ * cannot ship a label-only option (forces it to think about why each
+ * choice exists).
+ */
+export const askUserQuestionOptionSchema = z.strictObject({
+    label: z
+        .string()
+        .min(ASK_USER_QUESTION_OPTION_LABEL_MIN)
+        .max(ASK_USER_QUESTION_OPTION_LABEL_MAX)
+        .describe('Display text. Concise (1-5 words).'),
+    description: z
+        .string()
+        .min(ASK_USER_QUESTION_OPTION_DESC_MIN)
+        .max(ASK_USER_QUESTION_OPTION_DESC_MAX)
+        .describe('What this option means / implications.'),
+});
+export const askUserQuestionSchema = z.strictObject({
+    question: z
+        .string()
+        .min(ASK_USER_QUESTION_MIN)
+        .max(ASK_USER_QUESTION_MAX)
+        .refine((q) => q.trim().endsWith('?'), {
+        message: 'question must end with "?"',
+    })
+        .describe('The complete question. Must end with "?". Plain English, no jargon.'),
+    header: z
+        .string()
+        .min(ASK_USER_QUESTION_HEADER_MIN)
+        .max(ASK_USER_QUESTION_HEADER_MAX)
+        .describe('Short chip label (max 12 chars). E.g. "Auth method".'),
+    options: z
+        .array(askUserQuestionOptionSchema)
+        .min(ASK_USER_QUESTION_OPTIONS_MIN)
+        .max(ASK_USER_QUESTION_OPTIONS_MAX)
+        .describe('2-4 mutually-exclusive options. NEVER add "Other" — UI auto-adds.'),
+    multiSelect: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Allow multiple selections. Default false.'),
+});
+/**
+ * Dispatch the structured tool: validate args via Zod, then route
+ * through the shared `askUser` primitive so abort/timeout/non-TTY
+ * envelope behaviour is identical to the legacy form.
+ *
+ * The bridge surface is the same `AskUserBridge` signature — the
+ * structured form just gives the Ink modal richer metadata to render
+ * (header chip + per-option description). The bridge sees the legacy
+ * `{question, options: string[]}` shape because all production bridges
+ * (Ink modal + non-TTY envelope emitter) already consume that shape.
+ * Per-option descriptions and the header chip are surfaced separately
+ * via `enrich` — the modal layer reads them off the dispatched payload
+ * stash, NOT off the bridge input, so structured callers can layer on
+ * top of the legacy interface without touching the modal contract.
+ *
+ * Return contract:
+ *   - Interactive + bridge present + operator picks N options →
+ *     `[ask_user_question:answered] <labels joined by ", ">`.
+ *   - Interactive + bridge present + operator cancels →
+ *     `[ask_user_question:cancelled]`.
+ *   - Interactive + bridge present + timeout →
+ *     `[ask_user_question:timeout]`.
+ *   - Non-TTY or no bridge → `[user_input_required]<json>[/...]`
+ *     envelope identical to the legacy form. Includes `header` +
+ *     structured options so a scripted caller can parse the full shape.
+ */
+export async function dispatchAskUserQuestion(ctx, rawArgs) {
+    const parsed = askUserQuestionSchema.parse(rawArgs);
+    // Schema-level guard against the "Other" leak: the prompt rules tell
+    // the model NEVER to include "Other" in `options`, but we still reject
+    // it defensively in case a future model misreads the spec. The Ink
+    // modal auto-appends "Other" itself; a model-supplied duplicate would
+    // render two "Other" rows.
+    for (const opt of parsed.options) {
+        const trimmed = opt.label.trim().toLowerCase();
+        if (trimmed === 'other' || trimmed === 'другое') {
+            throw new Error('ask_user_question: do NOT include "Other" in options — UI auto-adds it');
+        }
+    }
+    const legacyOptions = parsed.options.map((opt) => opt.label);
+    const result = await askUser(ctx, {
+        question: parsed.question,
+        options: legacyOptions,
+        multiSelect: parsed.multiSelect ?? false,
+    });
+    if (result.answers && result.answers.length > 0) {
+        return {
+            answers: result.answers,
+            envelope: `[ask_user_question:answered] ${result.answers.join(', ')}`,
+        };
+    }
+    // Non-TTY / cancelled / timeout. Re-wrap the envelope so callers can
+    // grep for the structured tool name even when the underlying primitive
+    // surfaced its legacy `[user_input_required]` envelope.
+    if (result.envelope.includes('"reason":"timeout"')) {
+        return { envelope: '[ask_user_question:timeout]' };
+    }
+    if (result.envelope.includes('"reason":"cancelled"')) {
+        return { envelope: '[ask_user_question:cancelled]' };
+    }
+    // Default to the legacy envelope verbatim — it is still
+    // grep-friendly and includes the structured payload above.
+    return { envelope: result.envelope };
+}
+/**
+ * JSON-Schema fragment surfaced to the model via the tool-bridge
+ * `parameters` field. Mirrors the Zod schema 1:1 — kept hand-written
+ * because the runtime engine wires OpenAI-compatible JSON Schema and
+ * the Zod-to-JSON-Schema converter pulls in a transitive dep we have
+ * not greenlit. If the Zod schema above changes, mirror the change here.
+ */
+export const askUserQuestionJsonSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['question', 'header', 'options'],
+    properties: {
+        question: {
+            type: 'string',
+            minLength: ASK_USER_QUESTION_MIN,
+            maxLength: ASK_USER_QUESTION_MAX,
+            description: 'The complete question. Must end with "?". Plain English, no jargon.',
+        },
+        header: {
+            type: 'string',
+            minLength: ASK_USER_QUESTION_HEADER_MIN,
+            maxLength: ASK_USER_QUESTION_HEADER_MAX,
+            description: 'Short chip label (max 12 chars). E.g. "Auth method".',
+        },
+        options: {
+            type: 'array',
+            minItems: ASK_USER_QUESTION_OPTIONS_MIN,
+            maxItems: ASK_USER_QUESTION_OPTIONS_MAX,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['label', 'description'],
+                properties: {
+                    label: {
+                        type: 'string',
+                        minLength: ASK_USER_QUESTION_OPTION_LABEL_MIN,
+                        maxLength: ASK_USER_QUESTION_OPTION_LABEL_MAX,
+                        description: 'Display text. Concise (1-5 words).',
+                    },
+                    description: {
+                        type: 'string',
+                        minLength: ASK_USER_QUESTION_OPTION_DESC_MIN,
+                        maxLength: ASK_USER_QUESTION_OPTION_DESC_MAX,
+                        description: 'What this option means / implications.',
+                    },
+                },
+            },
+            description: '2-4 mutually-exclusive options. NEVER add "Other" — UI auto-adds.',
+        },
+        multiSelect: {
+            type: 'boolean',
+            description: 'Allow multiple selections. Default false.',
+        },
+    },
+};
+//# sourceMappingURL=ask-user-question.js.map

package/dist/tools/file-tools.js

@@ -27,11 +27,11 @@
  *   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';
 /**
@@ -47,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`
@@ -152,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,
@@ -182,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');
@@ -195,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/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/compact-banner.js

@@ -0,0 +1,54 @@
+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)"
+ */
+export function buildLabel(props) {
+    const trigger = props.trigger === 'auto' ? 'auto' : 'manual';
+    const turns = `${props.turnsBefore} ${props.turnsBefore === 1 ? 'turn' : 'turns'}`;
+    const tokens = props.summaryTokenCount && props.summaryTokenCount > 0
+        ? ` · ~${formatTokens(props.summaryTokenCount)} tokens`
+        : '';
+    return `context compacted (${turns} → 1 summary, ${trigger}${tokens})`;
+}
+/** Format token counts like 1234 → 1.2k, 950 → 950. */
+function formatTokens(n) {
+    if (n < 1000)
+        return `${n}`;
+    return `${(n / 1000).toFixed(1)}k`;
+}
+//# sourceMappingURL=compact-banner.js.map