@cspeach/cli 1.1.17 → 1.1.19

package/dist/ui/footer.js

@@ -2,44 +2,44 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useState, useEffect, useCallback, useRef } from 'react';
 import { Box, Text, useInput, useStdout } from 'ink';
 // D29 paste fix (2026-06-12): vendored paste-safe replacement for
-// ink-text-input — multi-chunk pastes were losing every chunk but the
-// last (stale-prop closure in the upstream component). See text-input.tsx.
+// ink-text-input. See text-input.tsx.
 import TextInput from './text-input.js';
 import { pasteClipboardImage } from './clipboard-image.js';
 import Fuse from 'fuse.js';
-// Task 8 (ux-wave1) — persistence lives in the shared writer (one file,
-// one dedup guard for the Footer, Ink handleSubmit, and classic readline).
-// It resolves os.homedir() lazily so tests can point it at a temp dir.
+// Task 8 (ux-wave1) — persistence lives in the shared writer.
 import { appendHistoryEntry, readHistoryEntries, flattenHistoryEntry } from '../repl/history.js';
+import { uiWidth, truncateToWidth } from '../renderer/ui-width.js';
+import { shouldUseUnicodeBoxChars } from '../renderer/tty.js';
+import { getGlyphs } from '../renderer/glyphs.js';
+import { roleProps, selectedProps } from './role-props.js';
+import { countInputRows, expandPasteChips, nextPasteChip, INPUT_MAX_LINES } from './input-wrap.js';
+import { sanitizeControlChars } from '../renderer/sanitize.js';
 function loadHistory() {
     return readHistoryEntries();
 }
 function appendHistory(line, history) {
-    // The shared writer flattens (newlines/tabs/C0 controls → ' '), trims,
-    // and skips consecutive duplicates (bash HISTCONTROL=ignoredups / CC
-    // parity). Mirror into the in-memory array ONLY when the entry was
-    // actually written, so arrow-up and Ctrl+R stay consistent with the
-    // file. Same flatten as the writer (tab-flatten fast-follow) so the
-    // mirror never diverges from the persisted entry.
+    // The shared writer flattens, trims and skips consecutive duplicates;
+    // mirror into memory only when the entry was written (↑ / Ctrl+R stay
+    // consistent with the file).
     const entry = flattenHistoryEntry(line);
     if (appendHistoryEntry(entry))
         history.push(entry);
 }
-const PEACH = '#FFCBA4';
-/** The input prompt — its width feeds the display budget below. */
-const PROMPT = 'CSPeach › ';
-/** Held multi-line draft: how many of the newest lines are shown above the input. */
-const HELD_LINES_SHOWN = 3;
-export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChange, prefill, disabled, onNotice, onBufferChange }) {
+/** I1 (spec §7) — the prompt glyph; the brand stays on the start screen. */
+export const PROMPT_GLYPH = '›';
+const PROMPT = `${PROMPT_GLYPH} `;
+/** Rounded border (2) + paddingX 1 on each side (2). */
+const BOX_CHROME = 4;
+/**
+ * Width of the input box (and of the footer line under it). uiWidth() caps it
+ * at 100; the −1 keeps the box off the exact-terminal-width deferred-wrap edge
+ * on Windows Terminal (the margin the old single-row budget kept, Bug 1).
+ */
+export function inputBoxWidth(columns) {
+    return Math.max(12, Math.min(uiWidth(columns), columns - 1));
+}
+export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChange, prefill, disabled, onNotice, onBufferChange, maxLines, onInputLinesChange, waitingForCard, }) {
     const [value, setValue] = useState('');
-    // Wave1 live-fix (Bug 1, statusline duplication) — the input row must
-    // NEVER soft-wrap in the terminal: Ink's log-update erases logical
-    // lines, not terminal rows, so one wrapped dynamic-frame row leaks the
-    // StatusLine into scrollback on every keystroke repaint (see the
-    // maxDisplayWidth doc in text-input.tsx for the ink source refs). Cap
-    // the displayed value at columns − prompt − 1 (the −1 keeps the row off
-    // the exact-width deferred-wrap edge on Windows Terminal). Re-rendered
-    // on stdout resize so a narrowed window tightens the budget promptly.
     const { stdout } = useStdout();
     const [, bumpOnResize] = useState(0);
     useEffect(() => {
@@ -50,46 +50,40 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
         return () => { stdout.off('resize', onResize); };
     }, [stdout]);
     const columns = stdout?.columns || 80;
-    const inputBudget = Math.max(8, columns - PROMPT.length - 1);
+    const boxWidth = inputBoxWidth(columns);
+    const wrapWidth = Math.max(4, boxWidth - BOX_CHROME - PROMPT.length);
     const [history] = useState(loadHistory);
     const [histIdx, setHistIdx] = useState(-1);
     const [fuzzyMode, setFuzzyMode] = useState(false);
     const [fuzzyQuery, setFuzzyQuery] = useState('');
     const [fuzzyResults, setFuzzyResults] = useState([]);
-    // Task 7 (ux-wave1) — multiline continuation buffer. Holds COMPLETE
-    // lines (from trailing-`\` submits and multi-line pastes) until the
-    // final Enter joins them with the current input line into ONE message.
-    // The TextInput never sees this state — it stays single-line.
-    //
-    // bufferRef is the synchronous mirror of the same D29 shape as
-    // text-input's valueRef: a paste tail and its Enter can land in ONE
-    // stdin drain, so onPasteLines and handleSubmit may both run before
-    // React commits the state update. All reads/writes go through the ref;
-    // the state exists only to drive the indicator render.
+    const [fuzzyIdx, setFuzzyIdx] = useState(0);
+    // Task 7 (ux-wave1) — continuation buffer (complete lines from trailing-`\`
+    // submits and short multi-line pastes). bufferRef is the synchronous mirror
+    // (a paste tail and its Enter can land in ONE stdin drain).
     const [buffer, setBuffer] = useState([]);
     const bufferRef = useRef([]);
     const updateBuffer = useCallback((lines) => {
         bufferRef.current = lines;
         setBuffer(lines);
     }, []);
+    // I1 — folded long pastes: chip text → pasted text, expanded on submit.
+    const pastesRef = useRef(new Map());
     const fuse = React.useMemo(() => new Fuse(history, { threshold: 0.4 }), [history]);
-    // Mirror state into parent when it cares (e.g. App's ? key-binding gate).
     useEffect(() => { onValueChange?.(value); }, [value, onValueChange]);
-    // Task 7 — mirror the buffer depth into App (live-trigger suppression).
     useEffect(() => { onBufferChange?.(buffer.length); }, [buffer.length, onBufferChange]);
-    // Task 7 — complete lines carved out of a multi-line paste by the
-    // TextInput (see onPasteLines in text-input.tsx). Append, never submit.
+    const desiredRows = countInputRows(buffer, value, wrapWidth);
+    useEffect(() => { onInputLinesChange?.(desiredRows); }, [desiredRows, onInputLinesChange]);
     const handlePasteLines = useCallback((lines) => {
         updateBuffer([...bufferRef.current, ...lines]);
     }, [updateBuffer]);
-    // If the parent pushes a prefill (palette pick, palette cancel restore,
-    // empty-body guard), pre-fill our input. Keyed on the nonce so identical
-    // text can re-fire. Empty text is honoured too (Task 5): App's live
-    // key-triggers (`/`, `?`, Alt+M) push an empty prefill to SWALLOW the
-    // trigger character, which Ink also delivers to our TextInput — without
-    // the clear, the leaked char reappears once the overlay closes. Nonce 0
-    // is the untouched initial state (App never pushes nonce 0), so skip it
-    // rather than clearing on mount.
+    const handleLargePaste = useCallback((text) => {
+        const chip = nextPasteChip(text, pastesRef.current);
+        pastesRef.current.set(chip, text);
+        return chip;
+    }, []);
+    // Prefill (palette pick / cancel restore / live-trigger swallow). Nonce 0 is
+    // the untouched initial state — skip it rather than clearing on mount.
     useEffect(() => {
         if (prefill && prefill.nonce > 0)
             setValue(prefill.text);
@@ -98,13 +92,30 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
     useEffect(() => {
         if (fuzzyMode) {
             setFuzzyResults(fuse.search(fuzzyQuery).slice(0, 8).map((r) => r.item));
+            setFuzzyIdx(0);
         }
     }, [fuzzyQuery, fuzzyMode, fuse]);
+    // I1 — history recall, called by the TextInput at the first / last visual row.
+    const historyUp = useCallback(() => {
+        const next = Math.min(histIdx + 1, history.length - 1);
+        setHistIdx(next);
+        setValue(history[history.length - 1 - next] ?? '');
+    }, [histIdx, history]);
+    const historyDown = useCallback(() => {
+        // Not browsing history: ↓ on the last row leaves the draft alone.
+        if (histIdx === -1)
+            return;
+        const next = Math.max(histIdx - 1, -1);
+        setHistIdx(next);
+        setValue(next === -1 ? '' : history[history.length - 1 - next] ?? '');
+    }, [histIdx, history]);
     useInput((input, key) => {
         if (key.ctrl && input === 'r') {
-            onHistoryTrigger();
+            // I1 — Ctrl+R is prompt-history search (spec §8 shortcuts); the write
+            // history stays on /history.
             setFuzzyMode(true);
             setFuzzyQuery('');
+            setFuzzyIdx(0);
             return;
         }
         if (fuzzyMode) {
@@ -112,77 +123,65 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
                 setFuzzyMode(false);
                 return;
             }
-            if (key.return && fuzzyResults[0]) {
-                // TODO (v0.4): cursor-aware selection for Ctrl+R palette.
-                // Current implementation always selects the top result, matching
-                // bash/zsh default reverse-i-search behaviour — users who want a
-                // different result re-type to refine the query.
-                setValue(fuzzyResults[0]);
-                setFuzzyMode(false);
+            if (key.upArrow) {
+                setFuzzyIdx((i) => Math.max(0, i - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setFuzzyIdx((i) => Math.min(Math.max(0, fuzzyResults.length - 1), i + 1));
+                return;
+            }
+            if (key.return) {
+                // I1 — Enter takes the HIGHLIGHTED result (was: always the first).
+                const pick = fuzzyResults[fuzzyIdx] ?? fuzzyResults[0];
+                if (pick) {
+                    setValue(pick);
+                    setFuzzyMode(false);
+                }
                 return;
             }
             return;
         }
-        // Task 7 — Esc discards the multiline draft. Runs AFTER the fuzzy
-        // branch (fuzzy Esc closes the search) and only while this hook is
-        // active at all (isActive: !disabled) — when a palette/modal overlay
-        // is up the Footer is disabled, so overlay-Esc never races this.
+        // Task 7 — Esc discards the multiline draft.
         if (key.escape && bufferRef.current.length > 0) {
             updateBuffer([]);
+            // Chips that lived only in the discarded lines go with them; a chip
+            // still in the input keeps its text.
+            for (const chip of [...pastesRef.current.keys()]) {
+                if (!value.includes(chip))
+                    pastesRef.current.delete(chip);
+            }
             onNotice?.('multiline draft discarded');
             return;
         }
-        if (key.upArrow) {
-            const next = Math.min(histIdx + 1, history.length - 1);
-            setHistIdx(next);
-            setValue(history[history.length - 1 - next] ?? '');
-            return;
-        }
-        if (key.downArrow) {
-            const next = Math.max(histIdx - 1, -1);
-            setHistIdx(next);
-            setValue(next === -1 ? '' : history[history.length - 1 - next] ?? '');
-            return;
-        }
-        // 2026-06-16 — go dormant while a modal (ask_question / coaching picker)
-        // owns input. Without this, arrow-key navigation INSIDE the modal also
-        // hits this handler (Ink delivers every keystroke to every active
-        // useInput), recalling a history line into the hidden Footer — so the
-        // last command "comes back" in the input once the modal closes. Mirrors
-        // why the TextInput is swapped for a placeholder when disabled.
+        // ↑/↓ belong to the TextInput now (visual rows first, then history).
     }, { isActive: !disabled });
     const handleSubmit = useCallback((line) => {
-        // Task 7 — trailing `\` continues the message: strip the backslash,
-        // hold the line (indentation preserved — this is for ABAP snippets),
-        // clear the input, submit nothing. A bare `\` inserts a blank line.
+        // Task 7 — trailing `\` continues the message (chips stay folded until the final submit).
         if (line.endsWith('\\')) {
             updateBuffer([...bufferRef.current, line.slice(0, -1)]);
             setHistIdx(-1);
             setValue('');
             return;
         }
-        // Task 7 — final submit with buffered lines: join into ONE message.
-        // The onSubmit contract is unchanged (one string, may contain \n) —
-        // App's beginSubmit / steering path takes it as a single message.
-        // The bare-`/` and `/history` intercepts are intentionally skipped
-        // here: mid-composition a `/` line is literal text (same pin as the
-        // live-trigger suppression in App).
         if (bufferRef.current.length > 0) {
-            const joined = [...bufferRef.current, line].join('\n').trim();
+            const joined = expandPasteChips([...bufferRef.current, line].join('\n'), pastesRef.current).trim();
             updateBuffer([]);
+            pastesRef.current.clear();
             setHistIdx(-1);
             setValue('');
             if (!joined)
                 return;
-            // The history file is one-entry-per-line; flatten so a multiline
-            // message doesn't split into N bogus entries on the next load.
             appendHistory(joined.replace(/\n/g, ' '), history);
             onSubmit(joined);
             return;
         }
-        if (!line.trim())
+        // I1 — chips expand on submit; history stores (and Ctrl+R matches) the expanded text.
+        const full = expandPasteChips(line, pastesRef.current);
+        if (!full.trim())
             return;
-        appendHistory(line.trim(), history);
+        appendHistory(full.trim(), history);
+        pastesRef.current.clear();
         setHistIdx(-1);
         setValue('');
         if (line.trim() === '/') {
@@ -193,27 +192,29 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
             onHistoryTrigger();
             return;
         }
-        onSubmit(line.trim());
+        onSubmit(full.trim());
     }, [onSubmit, onSlashTrigger, onHistoryTrigger, history, updateBuffer]);
-    // Claude Code-style image paste (2026-09-23): Ctrl+V / Alt+V saves the
-    // clipboard image and returns an [Image #N] chip; the turn loop swaps the
-    // chip for the file path before the image attachment step.
     const handlePasteImage = useCallback(async () => {
         const chip = await pasteClipboardImage();
         if (!chip)
             onNotice?.('no image on the clipboard');
         return chip;
     }, [onNotice]);
+    const borderStyle = shouldUseUnicodeBoxChars() ? 'round' : 'classic';
+    const borderColor = roleProps('frame').color;
     if (fuzzyMode) {
-        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "History search (Ctrl+R)" }), _jsx(TextInput, { value: fuzzyQuery, onChange: setFuzzyQuery, placeholder: "type to search...", maxDisplayWidth: Math.max(8, columns - 5) }), fuzzyResults.map((r, i) => (_jsx(Text, { dimColor: i > 0, wrap: "truncate-end", children: flattenHistoryEntry(r) }, i))), _jsx(Text, { dimColor: true, children: "Esc: cancel  Enter: select" })] }));
+        const g = getGlyphs();
+        const rowWidth = Math.max(4, boxWidth - BOX_CHROME - 2);
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: borderStyle, borderColor: borderColor, paddingX: 1, width: boxWidth, children: [_jsx(Text, { bold: true, children: "History search" }), _jsx(TextInput, { value: fuzzyQuery, onChange: setFuzzyQuery, placeholder: "type to search...", maxDisplayWidth: Math.max(8, boxWidth - BOX_CHROME - 1) }), fuzzyResults.map((r, i) => (i === fuzzyIdx
+                    ? _jsx(Text, { ...selectedProps(), wrap: "truncate-end", children: `${g.cursor} ${truncateToWidth(sanitizeControlChars(flattenHistoryEntry(r)), rowWidth)}` }, i)
+                    : _jsx(Text, { ...roleProps('dim'), wrap: "truncate-end", children: `  ${truncateToWidth(sanitizeControlChars(flattenHistoryEntry(r)), rowWidth)}` }, i))), _jsx(Text, { ...roleProps('dim'), children: "\u2191\u2193 move \u00B7 Enter select \u00B7 Esc cancel" })] }));
     }
-    // 2026-05-17 — when a modal owns input (coaching picker / ask_question),
-    // render a dim placeholder INSTEAD of the live TextInput. Otherwise
-    // keystrokes go to BOTH the modal AND this TextInput, and the queued
-    // Footer submission fires after the modal resolves → spurious picker
-    // for what the user thought was their modal answer.
+    // A card or palette owns input — show a static prompt instead of a live
+    // TextInput so keystrokes never double-fire (answer + stray submit). Only a
+    // waiting CARD says "(answer above to continue)" (spec §7); an open `/` or
+    // `@` palette or the timeline shows the prompt with nothing after it.
     if (disabled) {
-        return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: PROMPT }), _jsx(Text, { dimColor: true, children: "(answer above to continue)" })] }));
+        return (_jsx(Box, { borderStyle: borderStyle, borderColor: borderColor, paddingX: 1, width: boxWidth, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { ...roleProps('sap', { bold: true }), children: waitingForCard ? PROMPT : PROMPT_GLYPH }), waitingForCard ? _jsx(Text, { ...roleProps('dim'), children: "(answer above to continue)" }) : null] }) }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [buffer.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [buffer.length > HELD_LINES_SHOWN && (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2026 ", buffer.length - HELD_LINES_SHOWN, " earlier line", buffer.length - HELD_LINES_SHOWN === 1 ? '' : 's'] })), buffer.slice(-HELD_LINES_SHOWN).map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['│ ', line] }, `held-${buffer.length}-${i}`))), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [buffer.length, " line", buffer.length === 1 ? '' : 's', " pending \u2014 Enter sends all, Esc discards, \\ continues"] })] })), _jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: PROMPT }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSubmit, onPasteLines: handlePasteLines, onPasteImage: handlePasteImage, maxDisplayWidth: inputBudget })] })] }));
+    return (_jsx(Box, { flexDirection: "column", borderStyle: borderStyle, borderColor: borderColor, paddingX: 1, width: boxWidth, children: _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSubmit, onPasteLines: handlePasteLines, onPasteImage: handlePasteImage, onLargePaste: handleLargePaste, wrapWidth: wrapWidth, maxLines: Math.max(1, Math.min(INPUT_MAX_LINES, maxLines ?? INPUT_MAX_LINES)), heldLines: buffer, prompt: PROMPT, onHistoryUp: historyUp, onHistoryDown: historyDown }) }));
 }

package/dist/ui/input-wrap.js

@@ -0,0 +1,122 @@
+// src/ui/input-wrap.ts
+//
+// Piece 2 (spec §7) — pure layout for the input box. The Footer's input
+// HARD-WRAPS itself (string-width cells, graphemes kept whole, tabs → 2
+// spaces, other control chars → 1 space) so what we measure is what the
+// terminal draws; it never relies on terminal soft-wrap, which broke Ink's
+// erase accounting (the reason text-input.tsx used a one-row window).
+import stringWidth from 'string-width';
+/** The box grows to this many rows, then scrolls (spec §7). One definition, owned by F3's live-area budget. */
+export { INPUT_MAX_LINES } from './live-area.js';
+/** A paste of MORE than this many lines folds to `[Pasted N lines]` (spec §7). */
+export const PASTE_FOLD_LINES = 6;
+/** Tabs render as two spaces. */
+export const INPUT_TAB = '  ';
+const SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+function display(segment) {
+    if (segment === '\t')
+        return INPUT_TAB;
+    // C0, DEL and C1 (e.g. CSI \x9b) — same set as renderer/sanitize.ts — so
+    // pasted or recalled text can never drive the terminal.
+    // eslint-disable-next-line no-control-regex
+    return /^[\x00-\x1f\x7f-\x9f]+$/.test(segment) ? ' ' : segment;
+}
+function layout(value, width) {
+    const cells = [];
+    let line = 0;
+    let col = 0;
+    for (const { segment, index } of SEGMENTER.segment(value)) {
+        const disp = display(segment);
+        const w = stringWidth(disp);
+        if (col > 0 && col + w > width) {
+            line++;
+            col = 0;
+        }
+        cells.push({ index, end: index + segment.length, line, col, disp });
+        col += w;
+    }
+    return { cells, lastLine: line, lastCol: col };
+}
+/**
+ * Hard-wrap `value` into display lines of at most `width` cells. `cursor` is
+ * a UTF-16 offset into `value`; outside [0, value.length] means "no cursor"
+ * (cursorLine -1). A cursor at the very end needs one free cell, so an
+ * exactly-full last line puts it on a fresh empty line.
+ */
+export function wrapInput(value, cursor, width) {
+    const w = Math.max(2, Math.floor(width));
+    const { cells, lastLine, lastCol } = layout(value, w);
+    const lines = Array.from({ length: lastLine + 1 }, () => '');
+    for (const c of cells)
+        lines[c.line] += c.disp;
+    if (cursor < 0 || cursor > value.length)
+        return { lines, cursorLine: -1, cursorCol: 0 };
+    const at = cells.find((c) => cursor >= c.index && cursor < c.end);
+    if (at)
+        return { lines, cursorLine: at.line, cursorCol: at.col };
+    if (lastCol + 1 > w) {
+        lines.push('');
+        return { lines, cursorLine: lastLine + 1, cursorCol: 0 };
+    }
+    return { lines, cursorLine: lastLine, cursorCol: lastCol };
+}
+/** Rows [start, end) to show: all when they fit, else maxLines rows with the cursor row inside. */
+export function visibleRange(total, cursorRow, maxLines) {
+    const m = Math.max(1, Math.floor(maxLines));
+    if (total <= m)
+        return { start: 0, end: total };
+    const row = Math.min(Math.max(cursorRow, 0), total - 1);
+    const start = Math.min(Math.max(0, row - m + 1), total - m);
+    return { start, end: start + m };
+}
+/**
+ * The value offset for visual (line, col) — used by ↑/↓ inside the box.
+ * A col past the end of a wrapped (non-last) line lands on that line's last
+ * character, so the cursor stays on the row the user moved to.
+ */
+export function indexAt(value, width, line, col) {
+    const { cells, lastLine } = layout(value, Math.max(2, Math.floor(width)));
+    if (line > lastLine)
+        return value.length;
+    const onLine = cells.filter((c) => c.line === line);
+    if (onLine.length === 0)
+        return value.length;
+    const hit = onLine.find((c) => c.col >= col);
+    if (hit)
+        return hit.index;
+    return line === lastLine ? value.length : onLine[onLine.length - 1].index;
+}
+/** Rows the box would need, uncapped — held lines (no cursor) + the value (cursor at end). */
+export function countInputRows(held, value, width) {
+    const heldRows = held.reduce((n, l) => n + wrapInput(l, -1, width).lines.length, 0);
+    return heldRows + wrapInput(value, value.length, width).lines.length;
+}
+/** Lines in a pasted chunk (CR/CRLF normalised, trailing newlines ignored). */
+export function pastedLineCount(text) {
+    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n+$/, '').split('\n').length;
+}
+/** `[Pasted N lines]`, or `[Pasted N lines #k]` when that chip is already in use. */
+export function nextPasteChip(text, existing) {
+    const n = pastedLineCount(text);
+    const base = `[Pasted ${n} lines]`;
+    if (!existing.has(base))
+        return base;
+    for (let k = 2;; k++) {
+        const chip = `[Pasted ${n} lines #${k}]`;
+        if (!existing.has(chip))
+            return chip;
+    }
+}
+/** Replace every chip with the text it stands for (done on submit). */
+export function expandPasteChips(text, chips) {
+    if (chips.size === 0)
+        return text;
+    // ONE pass over the known chips (longest first, so `[Pasted 7 lines #2]` is
+    // never read as `[Pasted 7 lines]`): chip-looking text INSIDE a paste is
+    // never expanded a second time.
+    const alternation = [...chips.keys()]
+        .sort((a, b) => b.length - a.length)
+        .map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .join('|');
+    return text.replace(new RegExp(alternation, 'g'), (chip) => chips.get(chip) ?? chip);
+}

package/dist/ui/interrupt.js

@@ -0,0 +1,103 @@
+/**
+ * Ctrl+C decision for the Ink REPL (fix round 3, item 4).
+ *
+ * - During a turn: the first press cancels the turn, a second press in the
+ *   same turn exits hard (escape hatch if the abort never lands).
+ * - Idle: the first press only ARMS the exit — the App shows a dim
+ *   "Press Ctrl+C again to exit" hint — and a second press inside
+ *   IDLE_EXIT_WINDOW_MS exits. Same as Claude Code.
+ *
+ * Cards, sheets and palettes handle their own Ctrl+C (cancel that card
+ * only); the App never forwards a Ctrl+C here while one is open.
+ */
+export const IDLE_EXIT_WINDOW_MS = 2000;
+/**
+ * The ONE line a pending cancel prints (re-review 3): say only what will
+ * actually happen in that phase.
+ *  - routing: the turn never starts (routing checks the cancel and returns);
+ *  - prep:    the turn is aborted the moment it creates its controller;
+ *  - post:    the turn is over; only an automatic next plan phase is stopped.
+ */
+export function pendingCancelLine(phase, exiting, what = 'the next plan phase') {
+    if (phase === 'routing')
+        return exiting ? 'Turn cancelled · nothing was sent · exiting' : 'Turn cancelled · nothing was sent';
+    if (phase === 'post') {
+        return exiting
+            ? `Exiting when this turn has finished saving · ${what} will not start`
+            : `${what.charAt(0).toUpperCase()}${what.slice(1)} will not start automatically`;
+    }
+    return exiting ? 'Stopping the turn · exiting when it has saved' : 'Stopping the turn · it stops as it starts';
+}
+/**
+ * Round 4 item 9a — what a post-turn cancel stops, by what is queued: a plan
+ * resume (or a plan chain that has not queued yet) is "the next plan phase";
+ * any other queued command (a dispatch_skill switch) is named as itself.
+ */
+export function queuedWorkLabel(queued) {
+    const cmd = (queued ?? '').trim();
+    if (!cmd || /^\/abap-plan\s+--resume\b/.test(cmd))
+        return 'the next plan phase';
+    return `the switch to ${cmd.split(/\s+/)[0]}`;
+}
+/** Round 4 item 9b — how long an exit waits for post-turn work (saving, audit) to finish. */
+export const EXIT_TAIL_CAP_MS = 5000;
+/**
+ * Round 4 item 9b — wait for `tail` (the in-flight dispatch) to settle, but
+ * never longer than `capMs`. A rejected tail counts as settled; never throws.
+ */
+export async function settleWithin(tail, capMs) {
+    if (!tail)
+        return 'settled';
+    let timer;
+    const cap = new Promise((r) => { timer = setTimeout(() => r('timeout'), capMs); });
+    try {
+        return await Promise.race([tail.then(() => 'settled', () => 'settled'), cap]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function decideInterrupt(s) {
+    if (s.turnActive)
+        return s.turnPresses === 0 ? 'abort-turn' : 'force-exit';
+    // Post-turn work that cannot start anything more: nothing to cancel, so
+    // Ctrl+C behaves as at idle (arm, then exit).
+    const idleLike = s.phase === 'post' && !s.canChain;
+    if (s.busy && !idleLike)
+        return s.turnPresses === 0 ? 'cancel-pending' : 'force-exit';
+    if (s.lastIdleAt > 0 && s.now - s.lastIdleAt <= IDLE_EXIT_WINDOW_MS)
+        return 'exit';
+    return 'arm';
+}
+export function createPendingTurnCancel() {
+    let pending = false;
+    return {
+        request() {
+            const first = !pending;
+            pending = true;
+            return first;
+        },
+        get pending() {
+            return pending;
+        },
+        applyTo(controller) {
+            if (!pending)
+                return false;
+            pending = false;
+            controller.abort();
+            return true;
+        },
+        clear() {
+            pending = false;
+        },
+    };
+}
+export function autoDispatchDecision(s, cmd) {
+    if (s.done)
+        return { kind: 'skip' };
+    if (s.exitRequested || s.cancelPending) {
+        const what = queuedWorkLabel(cmd).replace(/^the /, '');
+        return { kind: 'not-started', line: `${what.charAt(0).toUpperCase()}${what.slice(1)} not started · run it when ready: ${cmd}` };
+    }
+    return { kind: 'go' };
+}