@cspeach/cli 1.1.48 → 1.1.49

package/dist/ui/status-line.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { useSapState } from './sap-state-store.js';
+import { formatCredits, CREDITS_PENDING } from '../cost/credits.js';
+/**
+ * The spend segment shared by <StatusLine /> and <Header />.
+ *
+ * Single home for the credits/dollar switch so the two chrome widgets can
+ * never drift apart — a drift here is exactly how our COGS would leak onto a
+ * managed customer's screen from one of them.
+ */
+export function formatSpendSegment(s) {
+    if (!s.creditsMode)
+        return `$${s.dollarSpendToday.toFixed(2)}`;
+    if (s.creditsPending && s.creditsSessionTotal === 0)
+        return CREDITS_PENDING;
+    return formatCredits(s.creditsSessionTotal, s.creditsUnitLabel);
+}
+/**
+ * Persistent SAP statusline (UX Wave 1, Task 4) — Header reborn,
+ * bottom-anchored. Single borderless line rendered between <TurnStatus />
+ * and <Footer /> in the dynamic Ink frame:
+ *
+ *   S4H │ S.LAEEQ │ tr K903417 │ approval-gated │ $0.54
+ *
+ * Descends from ui/header.tsx (Phase D3) minus the border (3 rows → 1) and
+ * the version/🍑 (the startup banner owns those). All fields come from the
+ * SapStateStore singleton, so transport creation, spend accrual, and
+ * write-mode cycling (Shift+Tab / Alt+M / /mode) re-render it live.
+ *
+ * The mode chip is omitted until the store's writeMode is seeded at REPL
+ * startup (null = pre-seed; only reachable in tests and the first ms of
+ * mount). Chip colors: advisory-only yellow / approval-gated green / auto
+ * cyan.
+ */
+const MODE_COLORS = {
+    'advisory-only': 'yellow',
+    'approval-gated': 'green',
+    auto: 'cyan',
+};
+export function StatusLine() {
+    const s = useSapState();
+    // Credits mode (2026-09-16): a managed customer sees what THEY are charged.
+    // The segment keeps its meaning — "what this session has cost me" — so it
+    // carries the session credit total, not the balance (the balance has its
+    // own home in the post-turn receipt and `cspeach doctor`).
+    const spendDisplay = formatSpendSegment(s);
+    // Wave1 live-fix (Bug 1) — one TRUNCATING <Text> instead of a <Box> of
+    // sibling Texts. The statusline lives in the dynamic Ink frame, where a
+    // row that soft-wraps in the terminal breaks log-update's logical-line
+    // erase accounting and leaks stale rows into scrollback (the live
+    // "statusline printed 11×" bug — see text-input.tsx maxDisplayWidth doc
+    // for the ink source refs). Nested <Text> children squash into one text
+    // node, so wrap="truncate-end" clips the whole row at the terminal
+    // width via ANSI-aware cli-truncate — this row can never wrap, whatever
+    // the field lengths.
+    return (_jsxs(Text, { wrap: "truncate-end", children: [s.system
+                ? _jsx(Text, { color: "cyan", children: s.system })
+                : _jsx(Text, { dimColor: true, children: "no system" }), _jsx(Text, { dimColor: true, children: " \u2502 " }), _jsx(Text, { color: "white", children: s.user || '—' }), _jsx(Text, { dimColor: true, children: " \u2502 tr " }), (s.transport ?? s.lastWriteTransport)
+                ? _jsx(Text, { color: "yellow", children: s.transport ?? s.lastWriteTransport })
+                : _jsx(Text, { dimColor: true, children: "none" }), s.writeMode && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: " \u2502 " }), _jsx(Text, { color: MODE_COLORS[s.writeMode], children: s.writeMode })] })), _jsx(Text, { dimColor: true, children: " \u2502 " }), _jsx(Text, { color: "green", children: spendDisplay })] }));
+}

package/dist/ui/status-row.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { formatCost } from '../cost/pricing.js';
+import { LARGE_SESSION_THRESHOLD } from '../renderer/status-footer.js';
+/**
+ * Single-line status row mounted in the Ink frame above `<Footer>`.
+ * Mirrors the layout of `printStatusFooter` (renderer/status-footer.ts)
+ * so users see the same fields whichever mode they run in.
+ *
+ * Phase A #1 (2026-05-16): mounted into App.tsx for the first time —
+ * the component existed but no one rendered it. Also added the
+ * large-session advisory inline so N3 closes with this change.
+ */
+export function StatusRow({ data }) {
+    if (!data)
+        return _jsx(Box, {});
+    const shortSession = data.sessionId.slice(0, 8);
+    const skillDisplay = data.skill.startsWith('/') ? data.skill : `/${data.skill}`;
+    const turns = data.turnCount != null ? `${data.turnCount} turn${data.turnCount === 1 ? '' : 's'}` : '';
+    const tokStr = `${data.tokens.toLocaleString()} tok this turn`;
+    const cachedStr = data.cachedTokens && data.cachedTokens > 0 ? `${data.cachedTokens.toLocaleString()} cached` : '';
+    const elapsedStr = data.elapsedMs > 0 ? `${(data.elapsedMs / 1000).toFixed(1)}s` : '';
+    const costTurnStr = data.costThisTurn != null ? formatCost(data.costThisTurn) : '';
+    const costSessStr = data.costSession != null ? `session: ${formatCost(data.costSession)}` : '';
+    const parts = [
+        `session ${shortSession}`,
+        data.sapAlias,
+        skillDisplay,
+        ...(turns ? [turns] : []),
+        tokStr,
+        ...(costTurnStr ? [costTurnStr] : []),
+        ...(cachedStr ? [cachedStr] : []),
+        ...(costSessStr ? [costSessStr] : []),
+        ...(elapsedStr ? [elapsedStr] : []),
+    ];
+    const isLarge = data.sessionInputTokens != null && data.sessionInputTokens >= LARGE_SESSION_THRESHOLD;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: parts.join(' │ ') }), isLarge && (_jsxs(Text, { color: "yellow", children: ["\u26A0  session getting large (", data.sessionInputTokens.toLocaleString(), " input tokens)", ' ', "\u2014 type /compact to summarise older turns, or /exit + cspeach (fresh) for a new topic"] }))] }));
+}

package/dist/ui/todo-panel.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+/**
+ * TodoPanel — UX Wave 2 / Task 5. The Ctrl+T overlay rendering the
+ * model-maintained task list (`todo_set` tool → session.todos). House
+ * style follows SessionTimeline: bordered box mounted above the Footer
+ * by <App>, closes on Esc / q — plus Ctrl+T itself (toggle; App's
+ * open-handler goes inactive while the panel is up, so the chord cannot
+ * double-fire).
+ *
+ * Row glyphs: ▣ completed (dim) · ▶ in_progress (peach, bold) ·
+ * □ pending. Every row is wrap="truncate-end" — Wave-1 rule: no
+ * dynamic-frame row may ever soft-wrap (wrapped rows break Ink's erase
+ * accounting and leak stale rows into scrollback).
+ *
+ * Lists longer than TODO_VISIBLE_ROWS get a scrolling window
+ * (CommandPalette pattern): ↑/↓ move the window, hidden counts show as
+ * "↑ N more" / "↓ N more". The initial window anchors the live in_progress
+ * item ~3 rows from the top so the current step is visible on open.
+ * "Live" = the LAST in_progress item in list order (F-L2-3) — see
+ * activeTodoIndex below.
+ */
+const PEACH = '#FFCBA4';
+export const TODO_VISIBLE_ROWS = 12;
+/** Pure header-counts formatter, exported for tests. */
+export function formatTodoCounts(todos) {
+    const done = todos.filter((t) => t.status === 'completed').length;
+    const active = todos.filter((t) => t.status === 'in_progress').length;
+    const open = todos.filter((t) => t.status === 'pending').length;
+    return `Tasks — ${done} done · ${active} active · ${open} open`;
+}
+/**
+ * Index of the LIVE step — the LAST in_progress item in list order, or -1.
+ *
+ * F-L2-3 (sitting #1): todo_set tolerates several in_progress items (a
+ * warning, not an error — todo.ts), and models routinely batch transitions,
+ * leaving an earlier item still marked in_progress. List order IS plan
+ * order, so the later item is the one actually being worked; picking the
+ * FIRST match pinned the ▶ on a step already long finished.
+ */
+export function activeTodoIndex(todos) {
+    for (let i = todos.length - 1; i >= 0; i--) {
+        if (todos[i].status === 'in_progress')
+            return i;
+    }
+    return -1;
+}
+export function TodoPanel({ todos, onClose }) {
+    const maxOffset = Math.max(0, todos.length - TODO_VISIBLE_ROWS);
+    const activeIdx = activeTodoIndex(todos);
+    // Anchor the initial window so the live in_progress item sits ~3 rows from
+    // the top (CommandPalette's cursor rule, with the active item as cursor).
+    const [offset, setOffset] = useState(() => {
+        if (activeIdx <= 3)
+            return 0;
+        return Math.min(activeIdx - 3, maxOffset);
+    });
+    useInput((input, key) => {
+        if (key.escape || input === 'q' || (key.ctrl && (input === 't' || input === 'T'))) {
+            onClose();
+            return;
+        }
+        if (key.upArrow)
+            setOffset((o) => Math.max(0, o - 1));
+        if (key.downArrow)
+            setOffset((o) => Math.min(maxOffset, o + 1));
+    });
+    const clamped = Math.min(offset, maxOffset);
+    const visible = todos.slice(clamped, clamped + TODO_VISIBLE_ROWS);
+    const below = Math.max(0, todos.length - (clamped + TODO_VISIBLE_ROWS));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, width: 72, children: [_jsx(Text, { bold: true, color: "cyan", wrap: "truncate-end", children: formatTodoCounts(todos) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [todos.length === 0 && (_jsx(Text, { dimColor: true, children: "(no tasks yet \u2014 the model maintains this list on multi-step work)" })), clamped > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2191 ", clamped, " more"] }), visible.map((t, i) => {
+                        const key = `${clamped + i}`;
+                        if (t.status === 'completed') {
+                            return _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u25A3 ", t.text] }, key);
+                        }
+                        // Only the LIVE step gets the ▶; a stale earlier in_progress item
+                        // (batched transition) renders as an ordinary open row, so the
+                        // panel never shows two arrows or points at finished work.
+                        if (t.status === 'in_progress' && clamped + i === activeIdx) {
+                            return _jsxs(Text, { color: PEACH, bold: true, wrap: "truncate-end", children: ["\u25B6 ", t.text] }, key);
+                        }
+                        return _jsxs(Text, { wrap: "truncate-end", children: ["\u25A1 ", t.text] }, key);
+                    }), below > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2193 ", below, " more"] })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [todos.length > TODO_VISIBLE_ROWS ? '↑↓ scroll · ' : '', "Esc/q/Ctrl+T to close"] }) })] }));
+}

package/dist/ui/widgets/ask-form.js

@@ -0,0 +1,250 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * AskForm — UX Wave 2 / Task 2: the multi-question Ink form for
+ * ask_question v2 batched requests (the CC-parity flagship interaction).
+ *
+ * One request = 1..4 questions answered in a single visit. Visual
+ * de-clutter pass (2026-07, product-owner review): no border box — the
+ * chip row + indentation is the form's identity; the approval modal keeps
+ * its border deliberately (danger checkpoint):
+ *
+ *    ✓ env  name  style                       ← chips (two-space gaps)
+ *
+ *    Which naming style?
+ *    Used for every generated object
+ *    ▸ snake_case    lv_/lt_ prefixes
+ *      CamelCase     modern style
+ *      ✎ Other (type your own)
+ *      [ Submit ]                             ← ONLY once all answered
+ *    Enter pick · Tab next · Esc cancel       ← one context-sensitive hint
+ *
+ * Binding rules (Task-2 brief + de-clutter pass):
+ *  - Chips: one per question (`header`), two-space gaps (no pipes);
+ *    current = peach + bold, answered = dim with `✓ ` prefix,
+ *    unanswered = dim. ONE blank line separates the chip row from the
+ *    question text. Tab/→ next, Shift+Tab/← previous — all INSIDE the
+ *    form; App's global handlers (mode-cycle, `?`, `/`, `@`) are already
+ *    gated off by askQuestionPending.
+ *  - Options: arrow-key list, label + dim description, CommandPalette-style
+ *    scroll window; multiSelect ⇒ Space toggles ▣/□, Enter confirms the
+ *    set; single ⇒ Enter picks. ALWAYS a final `✎ Other (type your own)`
+ *    row → inline windowed TextInput; a typed answer flags `custom: true`.
+ *    freeText questions render the input directly (no escape row, and the
+ *    typed answer is the EXPECTED path — no custom flag, per the Task-1
+ *    AskFormAnswer contract: custom marks the Other ESCAPE only).
+ *  - Answering advances to the next UNANSWERED question (wrapping); when
+ *    none remain, focus lands on [ Submit ]. Enter there resolves ALL
+ *    answers at once, in question order. Tab back re-answers freely.
+ *    Single-question forms (n === 1) auto-submit on answer — no extra
+ *    Enter vs the v1 modal; the Submit affordance is multi-question
+ *    review only (review round M2).
+ *  - Esc — DELIBERATE DEVIATION from the brief's "Esc anywhere cancels",
+ *    reviewer-accepted (review round I1): on an OPTIONED question with
+ *    the Other input focused, Esc first returns focus to the options
+ *    list (the typed draft is KEPT in otherDrafts); Esc at options
+ *    level — and anywhere else, including freeText questions (no inner
+ *    level) — cancels the WHOLE form → { formId, answers: [],
+ *    cancelled: true } (v1 cancel contract shape per Task 1).
+ *  - Dynamic-frame safety (Wave-1 lesson): every row truncates (NOTHING
+ *    may wrap), options scroll, total height ≤ MAX_FORM_ROWS.
+ *  - No React state keyed on formId (collision caveat from review) — all
+ *    per-question state lives in arrays keyed by question INDEX within
+ *    this request object.
+ */
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+// Wave-1 windowed input — display can never wrap the row (D29 paste-safe).
+import TextInput from '../text-input.js';
+import { askHelpLine, useReclaimRawStdin } from './ask-question-modal.js';
+const PEACH = '#FFCBA4';
+/** Option rows visible at once — the rest scroll (CommandPalette style). */
+export const VISIBLE_OPTION_ROWS = 5;
+/**
+ * Hard cap on total rendered rows — pinned by test. Re-derived for the
+ * de-clutter pass (border gone = −2 rows; blank chip-gap row = +1; the
+ * Submit row only renders once all questions are answered).
+ *
+ * Worst case — all answered, user Tabbed BACK into a scrolled optioned
+ * question for review (Submit row visible below it):
+ *   chips + blank + question + context + "↑ more" + VISIBLE_OPTION_ROWS
+ *   + "↓ more" + Other + Submit + help = 14.
+ * Pre-completion the Submit row is absent → 13.
+ */
+export const MAX_FORM_ROWS = 14;
+/** Display window for the Other/freeText input — the row must never wrap. */
+const OTHER_INPUT_WIDTH = 50;
+export function AskForm({ request, onResolve }) {
+    useReclaimRawStdin();
+    const questions = request.questions;
+    const n = questions.length;
+    // Focus slots: 0..n-1 = questions, n = the [ Submit ] row (reachable
+    // only once every question has an answer).
+    const [focus, setFocus] = useState(0);
+    // Per-question state, keyed by question INDEX (never formId): option
+    // cursor (0..options.length — the last row is Other), multi-select
+    // sets, Other draft text, and the committed answer.
+    const [cursors, setCursors] = useState(() => questions.map(() => 0));
+    const [multiSel, setMultiSel] = useState(() => questions.map(() => new Set()));
+    const [otherDrafts, setOtherDrafts] = useState(() => questions.map(() => ''));
+    const [answers, setAnswers] = useState(() => questions.map(() => null));
+    const isSubmit = focus === n;
+    const q = isSubmit ? undefined : questions[focus];
+    const otherRow = q ? q.options.length : 0;
+    const cursor = isSubmit ? 0 : cursors[focus];
+    // The inline TextInput owns typing whenever the question is freeText or
+    // the cursor sits on the Other row. While it does, the form-level
+    // handler must NOT interpret space/Enter/←/→ (Ink delivers every key to
+    // every active useInput — there is no stopPropagation).
+    const otherFocused = q != null && (q.freeText || cursor === otherRow);
+    const allAnswered = answers.every((a) => a !== null);
+    const cancel = () => onResolve({ formId: request.formId, answers: [], cancelled: true });
+    const submit = (finalAnswers) => onResolve({
+        formId: request.formId,
+        // Question order, always — regardless of the order the user
+        // actually answered in.
+        answers: questions.map((qq, i) => ({
+            id: qq.id,
+            answer: finalAnswers[i]?.answer ?? null,
+            ...(finalAnswers[i]?.custom ? { custom: true } : {}),
+        })),
+    });
+    /**
+     * Commit an answer, then advance to the next UNANSWERED question
+     * (wrapping past the end); none left → focus [ Submit ] — except
+     * single-question forms, which resolve immediately (M2: no extra Enter
+     * vs the v1 modal).
+     */
+    const answerAndAdvance = (i, value, custom) => {
+        const next = answers.map((a, j) => j === i ? { answer: value, ...(custom ? { custom: true } : {}) } : a);
+        for (let step = 1; step <= n; step++) {
+            const j = (i + step) % n;
+            if (next[j] === null) {
+                setAnswers(next);
+                setFocus(j);
+                return;
+            }
+        }
+        if (n === 1) {
+            submit(next);
+            return;
+        }
+        setAnswers(next);
+        setFocus(n);
+    };
+    useInput((input, key) => {
+        if (key.escape) {
+            // Two-level Esc (I1, documented deviation — see file header): the
+            // Other input focused on an OPTIONED question → back to the options
+            // list, draft kept. freeText has no inner level; the options level
+            // cancels the whole form.
+            if (q && !q.freeText && otherFocused) {
+                setCursors((prev) => prev.map((c, j) => (j === focus ? otherRow - 1 : c)));
+                return;
+            }
+            cancel();
+            return;
+        }
+        // Chip navigation. Tab/Shift+Tab always work (TextInput ignores tab);
+        // ←/→ only while the inline text input doesn't own horizontal cursor
+        // movement.
+        const maxSlot = allAnswered ? n : n - 1;
+        if ((key.tab && !key.shift) || (!otherFocused && key.rightArrow)) {
+            setFocus((f) => (f >= maxSlot ? 0 : f + 1));
+            return;
+        }
+        if ((key.tab && key.shift) || (!otherFocused && key.leftArrow)) {
+            setFocus((f) => (f <= 0 ? maxSlot : f - 1));
+            return;
+        }
+        if (isSubmit) {
+            if (key.return && allAnswered)
+                submit(answers);
+            return;
+        }
+        if (!q)
+            return;
+        // ↑/↓ move the option cursor — also FROM the Other row back into the
+        // list (TextInput ignores vertical arrows, so no conflict).
+        if (!q.freeText) {
+            if (key.upArrow) {
+                setCursors((prev) => prev.map((c, j) => (j === focus ? Math.max(0, c - 1) : c)));
+                return;
+            }
+            if (key.downArrow) {
+                setCursors((prev) => prev.map((c, j) => (j === focus ? Math.min(otherRow, c + 1) : c)));
+                return;
+            }
+        }
+        // Everything below is typing territory while the Other input has focus.
+        if (otherFocused)
+            return;
+        if (q.multiSelect && input === ' ') {
+            const opt = q.options[cursor];
+            if (opt) {
+                setMultiSel((prev) => prev.map((s, j) => {
+                    if (j !== focus)
+                        return s;
+                    const nextSet = new Set(s);
+                    if (nextSet.has(opt.value))
+                        nextSet.delete(opt.value);
+                    else
+                        nextSet.add(opt.value);
+                    return nextSet;
+                }));
+            }
+            return;
+        }
+        if (key.return) {
+            if (q.multiSelect) {
+                const values = q.options
+                    .filter((o) => multiSel[focus].has(o.value))
+                    .map((o) => o.value);
+                if (values.length === 0) {
+                    // 2026-09-17 — nothing toggled: Enter used to do NOTHING, silently.
+                    // Every other question answers on Enter, so a user who arrows to a
+                    // row and presses Enter (Glenn's first session) sat there stuck.
+                    // Enter alone now picks the highlighted option, single-choice style.
+                    const opt = q.options[cursor];
+                    if (opt)
+                        answerAndAdvance(focus, opt.value);
+                    return;
+                }
+                answerAndAdvance(focus, values.join(','));
+            }
+            else {
+                const opt = q.options[cursor];
+                if (opt)
+                    answerAndAdvance(focus, opt.value);
+            }
+        }
+    }, { isActive: true });
+    // CommandPalette-style scroll window over the options (the Other row is
+    // rendered separately and is always visible).
+    const opts = q?.options ?? [];
+    const winStart = Math.max(0, Math.min(cursor - 3, opts.length - VISIBLE_OPTION_ROWS));
+    const visible = opts.slice(winStart, winStart + VISIBLE_OPTION_ROWS);
+    const below = Math.max(0, opts.length - (winStart + VISIBLE_OPTION_ROWS));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, flexShrink: 0, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { wrap: "truncate-end", children: questions.map((qq, i) => {
+                        const cur = i === focus;
+                        const done = answers[i] !== null;
+                        return (_jsxs(Text, { color: cur ? PEACH : undefined, bold: cur, dimColor: !cur, children: [i > 0 ? '  ' : '', done ? '✓ ' : '', qq.header ?? qq.id] }, qq.id));
+                    }) }) }), isSubmit ? (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: "All questions answered \u2014 Tab/\u2190 to review, Enter to submit \u00B7 Esc cancel" })) : q ? (_jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: [q.question, q.multiSelect ? ' (choose one or more)' : ''] }), q.context && _jsx(Text, { dimColor: true, wrap: "truncate-end", children: q.context }), !q.freeText && (_jsxs(_Fragment, { children: [winStart > 0 && _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  \u2191 ", winStart, " more"] }), visible.map((o, vi) => {
+                                const idx = winStart + vi;
+                                const isCur = !otherFocused && idx === cursor;
+                                const mark = q.multiSelect
+                                    ? (multiSel[focus].has(o.value) ? '▣ ' : '□ ')
+                                    : '';
+                                // v1 never renders the `recommended` flag — the convention
+                                // is skills writing "(recommended)" INTO the label. Render
+                                // the same dim convention only when the label lacks it.
+                                const rec = o.recommended === true && !/\brecommended\b/i.test(o.label);
+                                return (_jsxs(Text, { wrap: "truncate-end", color: isCur ? PEACH : undefined, bold: isCur, children: [isCur ? '▸ ' : '  ', mark, o.label, rec && _jsx(Text, { dimColor: true, children: " (recommended)" }), o.description && _jsxs(Text, { dimColor: true, children: ["  ", o.description] })] }, o.value));
+                            }), below > 0 && _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  \u2193 ", below, " more"] })] })), _jsxs(Box, { children: [q.freeText ? (_jsx(Text, { color: PEACH, wrap: "truncate-end", children: '> ' })) : (_jsxs(Text, { color: otherFocused ? PEACH : undefined, bold: otherFocused, wrap: "truncate-end", children: [otherFocused ? '▸ ' : '  ', "\u270E Other (type your own)", otherFocused ? ': ' : ''] })), otherFocused && (_jsx(TextInput, { value: otherDrafts[focus], onChange: (v) => setOtherDrafts((prev) => prev.map((d, j) => (j === focus ? v : d))), onSubmit: (v) => {
+                                    const trimmed = v.trim();
+                                    if (trimmed.length === 0)
+                                        return; // nothing typed — ignore
+                                    // custom marks the Other ESCAPE on an optioned question;
+                                    // freeText typing is the expected path (Task-1 contract).
+                                    answerAndAdvance(focus, trimmed, !q.freeText);
+                                }, maxDisplayWidth: OTHER_INPUT_WIDTH }))] })] })) : null, allAnswered && (_jsxs(Text, { wrap: "truncate-end", color: isSubmit ? PEACH : undefined, bold: isSubmit, dimColor: !isSubmit, children: [isSubmit ? '▸ ' : '  ', "[ Submit ]"] })), q && (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: askHelpLine(q.freeText ? 'freeText' : q.multiSelect ? 'multi' : 'pick', { single: n === 1 }) }))] }));
+}

package/dist/ui/widgets/ask-question-modal.js

@@ -0,0 +1,178 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * AskQuestionModal — Ink-native interactive form for the ask_question tool.
+ *
+ * Critical #2 fix (2026-05-17): the prior path called inquirer.input/
+ * select/checkbox directly. In Ink that draws raw to stdout, corrupts
+ * the React frame, and the user often can't tell what's being asked.
+ *
+ * Three modes match the tool's three kinds:
+ *   - text   → free-form TextInput, Enter to submit, Esc to cancel
+ *   - choice → arrow-key single-select list (mirrors CoachingPicker)
+ *   - multi  → space-to-toggle checkbox list, Enter to submit
+ *
+ * Mounted inline by App.tsx (NOT as position="absolute" overlay — we
+ * learned the hard way that absolute overlays paint over Body and
+ * can't be navigated cleanly).
+ */
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+// D29 paste fix (2026-06-12): paste-safe replacement for ink-text-input —
+// pasted free-form answers were losing every chunk but the last on large
+// pastes (stale-prop closure upstream). See ../text-input.tsx.
+import TextInput from '../text-input.js';
+const PEACH = '#FFCBA4';
+export function askHelpLine(kind, opts) {
+    switch (kind) {
+        // 2026-09-17 — spelled out after a first-session user could not tell a
+        // multi-select from a single pick ("was it a multi select?").
+        case 'multi': return 'Space ticks a row · Enter confirms · Enter alone picks the highlighted row · Esc cancels';
+        case 'pick': return opts?.single ? 'Enter pick · Esc cancel' : 'Enter pick · Tab next · Esc cancel';
+        default: return opts?.single ? 'Enter submit · Esc cancel' : 'Tab next · Esc cancel';
+    }
+}
+/**
+ * Reclaim raw-mode stdin when an Ink modal mounts (2026-06-08).
+ *
+ * The approval plan-gate uses `@inquirer/prompts`, which toggles the
+ * terminal's raw mode (and pauses stdin) out from under Ink while it runs.
+ * When it releases, Ink's INTERNAL bookkeeping still thinks raw mode is on,
+ * so it does not re-assert it — and a modal mounted afterwards (this one)
+ * receives no keypresses: arrow keys and Enter are dead, the user cannot
+ * answer the question. Re-syncing the OS state to what Ink expects on mount
+ * fixes it. Direct `process.stdin` calls (not Ink's ref-counted setRawMode)
+ * because the whole problem is that Ink's count is stale.
+ *
+ * Exported (UX Wave 2 / Task 2) so <AskForm> — the v2 multi-question form —
+ * reuses the exact same reclaim on mount. v1 rendering is untouched.
+ */
+export function useReclaimRawStdin() {
+    useEffect(() => {
+        const stdin = process.stdin;
+        if (stdin.isTTY && typeof stdin.setRawMode === 'function') {
+            try {
+                stdin.setRawMode(true);
+            }
+            catch { /* not a TTY — ignore */ }
+            stdin.resume();
+        }
+    }, []);
+}
+export function AskQuestionModal({ params, onResolve }) {
+    useReclaimRawStdin();
+    if (params.kind === 'text' || params.choices.length === 0) {
+        return _jsx(TextInputForm, { params: params, onResolve: onResolve });
+    }
+    if (params.kind === 'choice') {
+        return _jsx(ChoiceForm, { params: params, onResolve: onResolve });
+    }
+    return _jsx(MultiForm, { params: params, onResolve: onResolve });
+}
+// ---------------------------------------------------------------------------
+// Free-form text
+// ---------------------------------------------------------------------------
+function TextInputForm({ params, onResolve }) {
+    const [value, setValue] = useState('');
+    useInput((_input, key) => {
+        if (key.escape) {
+            onResolve({ answer: null, cancelled: true });
+        }
+    }, { isActive: true });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, flexShrink: 0, children: [_jsx(Text, { bold: true, children: params.question }), params.context && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: params.context }) })), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: PEACH, children: '> ' }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: (v) => {
+                            const trimmed = v.trim();
+                            if (trimmed.length === 0) {
+                                onResolve({ answer: null, cancelled: true });
+                            }
+                            else {
+                                onResolve({ answer: trimmed });
+                            }
+                        } })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: askHelpLine('freeText', { single: true }) }) })] }));
+}
+// ---------------------------------------------------------------------------
+// Single choice (kind = 'choice')
+// ---------------------------------------------------------------------------
+function ChoiceForm({ params, onResolve }) {
+    const [cursor, setCursor] = useState(0);
+    useInput((_input, key) => {
+        if (key.escape) {
+            onResolve({ answer: null, cancelled: true });
+            return;
+        }
+        if (key.upArrow) {
+            setCursor((c) => Math.max(0, c - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor((c) => Math.min(params.choices.length - 1, c + 1));
+            return;
+        }
+        if (key.return) {
+            const chosen = params.choices[cursor];
+            if (chosen)
+                onResolve({ answer: chosen.value });
+        }
+    }, { isActive: true });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, flexShrink: 0, children: [_jsx(Text, { bold: true, children: params.question }), params.context && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: params.context }) })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: params.choices.map((c, i) => {
+                    const isCursor = i === cursor;
+                    return (_jsxs(Text, { color: isCursor ? PEACH : undefined, bold: isCursor, children: [isCursor ? '▸ ' : '  ', c.label] }, c.value));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: askHelpLine('pick', { single: true }) }) })] }));
+}
+// ---------------------------------------------------------------------------
+// Multi choice (kind = 'multi') — space to toggle, Enter to submit
+// ---------------------------------------------------------------------------
+function MultiForm({ params, onResolve }) {
+    const [cursor, setCursor] = useState(0);
+    const [selected, setSelected] = useState(new Set());
+    useInput((input, key) => {
+        if (key.escape) {
+            onResolve({ answer: null, cancelled: true });
+            return;
+        }
+        if (key.upArrow) {
+            setCursor((c) => Math.max(0, c - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor((c) => Math.min(params.choices.length - 1, c + 1));
+            return;
+        }
+        if (input === ' ') {
+            const current = params.choices[cursor];
+            if (current) {
+                setSelected((prev) => {
+                    const next = new Set(prev);
+                    if (next.has(current.value))
+                        next.delete(current.value);
+                    else
+                        next.add(current.value);
+                    return next;
+                });
+            }
+            return;
+        }
+        if (key.return) {
+            const values = params.choices
+                .filter((c) => selected.has(c.value))
+                .map((c) => c.value);
+            if (values.length === 0) {
+                // 2026-09-17 — nothing toggled: Enter alone picks the highlighted
+                // option (single-choice muscle memory) instead of cancelling.
+                const current = params.choices[cursor];
+                if (current)
+                    onResolve({ answer: current.value });
+                else
+                    onResolve({ answer: null, cancelled: true });
+            }
+            else {
+                onResolve({ answer: values.join(',') });
+            }
+        }
+    }, { isActive: true });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, flexShrink: 0, children: [_jsxs(Text, { bold: true, children: [params.question, " (choose one or more)"] }), params.context && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: params.context }) })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: params.choices.map((c, i) => {
+                    const isCursor = i === cursor;
+                    const isSelected = selected.has(c.value);
+                    const mark = isSelected ? '◉' : '○';
+                    const prefix = isCursor ? '▸ ' : '  ';
+                    return (_jsxs(Text, { color: isCursor ? PEACH : undefined, bold: isCursor, children: [prefix, mark, " ", c.label] }, c.value));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: askHelpLine('multi') }) })] }));
+}

package/fiori/zlas-inspection-lr/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "zlas.inspectionlog",
+  "version": "0.0.1",
+  "description": "Description of zlas.inspectionlog.",
+  "keywords": [
+    "ui5",
+    "openui5",
+    "sapui5"
+  ],
+  "main": "webapp/index.html",
+  "dependencies": {},
+  "devDependencies": {
+    "@ui5/cli": "^4.0.33",
+    "@sap/ux-ui5-tooling": "1"
+  },
+  "scripts": {
+    "start": "fiori run --open \"/test/flpSandbox.html?sap-ui-xx-viewCache=false#zlasinspectionlog-tile\"",
+    "start-local": "fiori run --config ./ui5-local.yaml --open \"/test/flpSandbox.html?sap-ui-xx-viewCache=false#zlasinspectionlog-tile\"",
+    "build": "ui5 build --config=ui5.yaml --clean-dest --dest dist",
+    "deploy": "fiori verify",
+    "deploy-config": "fiori add deploy-config",
+    "start-noflp": "fiori run --open \"/index.html?sap-ui-xx-viewCache=false\"",
+    "start-variants-management": "fiori run --open \"/preview.html?sap-ui-xx-viewCache=false&fiori-tools-rta-mode=true&sap-ui-rta-skip-flex-validation=true#zlasinspectionlog-tile\""
+  },
+  "sapux": true
+}