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

package/dist/runtime/version.js

@@ -44,7 +44,7 @@ export function sanitizeSemver(raw) {
  * during import). When bumping the CLI version BOTH literals must be
  * updated; the release smoke-test (`pack:smoke`) verifies they agree.
  */
-export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.17');
+export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.18');
 /**
  * Outbound: the CLI's installed semver. Read at request time by
  * `version-interceptor.ts` and injected on every `fetch` call.

package/dist/tools/agent-tool.js

@@ -58,8 +58,16 @@ import { spawnSubagentWithOutcome } from '../core/subagents/spawn.js';
  * inverse (forces shared-fs even for roles whose default is `worktree`).
  *
  * The role enum mirrors the SDK's SubagentRole — keep both in lockstep.
+ *
+ * Leak P0 L2 (2026-05-27): `z.strictObject` rejects ANY additional or
+ * aliased fields at parse time. Matches the openclaude FileEditTool /
+ * FileWriteTool posture (research memo §1.1). The model-facing JSON
+ * schema already declares `additionalProperties: false`; the strict
+ * Zod variant is defense-in-depth — if the bridge ever bypasses the
+ * model-side gate (raw test fixture, internal dispatch), the runtime
+ * still refuses unknown keys instead of silently dropping them.
  */
-export const agentToolArgsSchema = z.object({
+export const agentToolArgsSchema = z.strictObject({
     role: z.enum([
         'orchestrator',
         'architect',
@@ -70,12 +78,18 @@ export const agentToolArgsSchema = z.object({
         'release',
         'devops',
         'design_qa',
-    ]),
+    ]).describe('SubagentRole — selects persona + isolation tier.'),
     brief: z
         .string()
         .min(1, 'brief must not be empty')
-        .max(8000, 'brief must be ≤ 8000 chars'),
-    isolation: z.enum(['worktree', 'shared_fs', 'auto']).optional(),
+        .max(8000, 'brief must be ≤ 8000 chars')
+        .describe('One-paragraph task description forwarded to the child as the user prompt. '
+        + 'Be concrete: include filenames, expected behavior, and acceptance criteria.'),
+    isolation: z
+        .enum(['worktree', 'shared_fs', 'auto'])
+        .optional()
+        .describe('Optional override. `worktree` forces a scratch git worktree for write isolation; '
+        + '`shared_fs` forces same-tree execution; `auto` (default) defers to the role tier.'),
 });
 /**
  * Dispatch a subagent via the `agent` tool. Returns the JSON envelope

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