@cspeach/cli 1.1.51 → 1.1.53

package/dist/ui/footer.js

@@ -9,7 +9,7 @@ import Fuse from 'fuse.js';
 // Task 8 (ux-wave1) — persistence lives in the shared writer.
 import { appendHistoryEntry, readHistoryEntries, flattenHistoryEntry } from '../repl/history.js';
 import { frameWidth, truncateToWidth } from '../renderer/ui-width.js';
-import { shouldUseUnicodeBoxChars } from '../renderer/tty.js';
+import { cardBorderStyle } from './ascii-chars.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';
@@ -25,6 +25,22 @@ function appendHistory(line, history) {
     if (appendHistoryEntry(entry))
         history.push(entry);
 }
+/** LT-15 final review I1 — the second Esc must come within this to clear returned text. */
+export const RETURNED_ESC_WINDOW_MS = 2000;
+/** LT-15 final review I1 — the dim hint at the first Esc on returned held lines. */
+export const RETURNED_ESC_HINT = 'Esc again to clear the returned message';
+/**
+ * LT-15 (review I3) — where returned text lands in the box. The input row
+ * shows a newline as a space, so a multiline message goes into the held
+ * lines (shown as real lines, sent joined with '\n' on Enter) and only its
+ * last line becomes the editable value. A draft already in the box stays in
+ * front of it, never overwritten: its value line becomes a held line too.
+ */
+export function placeInBox(held, value, text) {
+    const lines = text.split(/\r?\n/);
+    const last = lines.pop() ?? '';
+    return { held: [...held, ...(value !== '' ? [value] : []), ...lines], value: last };
+}
 /** I1 (spec §7) — the prompt glyph; the brand stays on the start screen. */
 export const PROMPT_GLYPH = '›';
 const PROMPT = `${PROMPT_GLYPH} `;
@@ -38,8 +54,12 @@ const BOX_CHROME = 4;
 export function inputBoxWidth(columns) {
     return frameWidth(columns);
 }
-export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChange, prefill, disabled, onNotice, onBufferChange, maxLines, onInputLinesChange, waitingForCard, }) {
+export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChange, prefill, disabled, onNotice, onBufferChange, maxLines, onInputLinesChange, waitingForCard, onWithdraw, boxRef, onFuzzyChange, }) {
     const [value, setValue] = useState('');
+    // LT-15 (review I3) — the value as of the last render, for putInBox (called
+    // from outside the input handlers, so it must not read a stale closure).
+    const valueNowRef = useRef(value);
+    valueNowRef.current = value;
     const { stdout } = useStdout();
     const [, bumpOnResize] = useState(0);
     useEffect(() => {
@@ -72,9 +92,24 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
     const fuse = React.useMemo(() => new Fuse(history, { threshold: 0.4 }), [history]);
     useEffect(() => { onValueChange?.(value); }, [value, onValueChange]);
     useEffect(() => { onBufferChange?.(buffer.length); }, [buffer.length, onBufferChange]);
+    useEffect(() => { onFuzzyChange?.(fuzzyMode); }, [fuzzyMode, onFuzzyChange]);
     const desiredRows = countInputRows(buffer, value, wrapWidth);
     useEffect(() => { onInputLinesChange?.(desiredRows); }, [desiredRows, onInputLinesChange]);
+    // LT-15 final review I1 — held lines that came from putInBox and were not
+    // edited since. The first Esc on them only shows a hint; a second Esc
+    // within RETURNED_ESC_WINDOW_MS discards as today. Any edit (a key, a
+    // paste, a submit) makes them an ordinary draft again.
+    const putHeldFreshRef = useRef(false);
+    const escArmedAtRef = useRef(0);
+    // Set while the Footer handles an Esc; cleared after the current input
+    // burst (a microtask runs only once the synchronous drain is done).
+    const escOwnedRef = useRef(false);
+    const handleChange = useCallback((v) => {
+        putHeldFreshRef.current = false;
+        setValue(v);
+    }, []);
     const handlePasteLines = useCallback((lines) => {
+        putHeldFreshRef.current = false;
         updateBuffer([...bufferRef.current, ...lines]);
     }, [updateBuffer]);
     const handleLargePaste = useCallback((text) => {
@@ -95,12 +130,73 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
             setFuzzyIdx(0);
         }
     }, [fuzzyQuery, fuzzyMode, fuse]);
+    // LT-15 Feature 2 / review I3 — text put back into the box.
+    // `boxPutPendingRef`: set by putInBox, cleared by the first commit after
+    // it (that render already holds the put's state updates, and the input
+    // handlers are re-bound with the new value by then). A second ↑ in the same
+    // input burst still sees the old (empty) value in its closure; without this
+    // it would take a second message and overwrite the first one in the box.
+    // The token is captured during render, so an older commit's effect can
+    // never clear a newer put, and nothing can leave it set for good.
+    // `skipHistRef`: the history copy of the text just put back (the Footer
+    // stored it in history when it was first sent). The next ↑ skips it, so ↑
+    // does not show the same text again (controller ruling I2.4).
+    const boxPutPendingRef = useRef(null);
+    const skipHistRef = useRef(null);
+    const putPendingAtRender = boxPutPendingRef.current;
+    useEffect(() => {
+        if (putPendingAtRender !== null && boxPutPendingRef.current === putPendingAtRender)
+            boxPutPendingRef.current = null;
+    });
+    // Fix round 1 (C1) — the field's synchronous handle (null while the box is
+    // disabled or Ctrl+R search shows; the field then mounts with the state).
+    const inputHandleRef = useRef(null);
+    const putInBox = useCallback((text) => {
+        // LT-15 Task 4 — the field's live text when it has one (a key typed just
+        // before an outside put must stay in front), else the last render's value.
+        const next = placeInBox(bufferRef.current, inputHandleRef.current?.getValueNow() ?? valueNowRef.current, text);
+        updateBuffer(next.held);
+        inputHandleRef.current?.setValueNow(next.value);
+        setValue(next.value);
+        valueNowRef.current = next.value;
+        setHistIdx(-1);
+        skipHistRef.current = flattenHistoryEntry(text);
+        boxPutPendingRef.current = {};
+        putHeldFreshRef.current = next.held.length > 0;
+        escArmedAtRef.current = 0;
+    }, [updateBuffer]);
+    const ownsEscape = useCallback(() => bufferRef.current.length > 0 || escOwnedRef.current, []);
+    useEffect(() => {
+        if (!boxRef)
+            return undefined;
+        boxRef.current = { putInBox, ownsEscape };
+        return () => { if (boxRef.current?.putInBox === putInBox)
+            boxRef.current = null; };
+    }, [boxRef, putInBox, ownsEscape]);
     // 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);
+    const historyUp = useCallback((currentValue) => {
+        // LT-15 — text was just put in the box and has not rendered yet: this ↑
+        // belongs to the same burst. Do nothing rather than overwrite it.
+        if (boxPutPendingRef.current !== null)
+            return;
+        // LT-15 Feature 2 — an EMPTY box takes back the last waiting message.
+        // A miss (nothing waits, no turn, the loop just read it) falls through.
+        // Fix round 1 (I1) — "empty" is the field's CURRENT text (its synchronous
+        // mirror), not this render's value: a key typed in the same burst counts.
+        const now = currentValue ?? value;
+        if (now === '' && histIdx === -1 && bufferRef.current.length === 0 && onWithdraw?.())
+            return;
+        const skip = skipHistRef.current;
+        const skipOne = histIdx === -1 && skip !== null && history[history.length - 1] === skip;
+        // Fix round 1 (M3) — the copy is the ONLY entry: nothing older to show.
+        // Leave the box (and the skip) as they are rather than show the copy.
+        if (skipOne && history.length === 1)
+            return;
+        skipHistRef.current = null;
+        const next = Math.min(histIdx + (skipOne ? 2 : 1), history.length - 1);
         setHistIdx(next);
         setValue(history[history.length - 1 - next] ?? '');
-    }, [histIdx, history]);
+    }, [histIdx, history, value, onWithdraw]);
     const historyDown = useCallback(() => {
         // Not browsing history: ↓ on the last row leaves the draft alone.
         if (histIdx === -1)
@@ -144,6 +240,29 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
         }
         // Task 7 — Esc discards the multiline draft.
         if (key.escape && bufferRef.current.length > 0) {
+            escOwnedRef.current = true;
+            queueMicrotask(() => { escOwnedRef.current = false; });
+            // LT-15 final review I1 — returned text, not edited since: the first
+            // Esc only warns; the second within the window discards.
+            const returned = putHeldFreshRef.current;
+            if (returned) {
+                const now = Date.now();
+                if (now - escArmedAtRef.current > RETURNED_ESC_WINDOW_MS) {
+                    escArmedAtRef.current = now;
+                    onNotice?.(RETURNED_ESC_HINT);
+                    return;
+                }
+                putHeldFreshRef.current = false;
+                escArmedAtRef.current = 0;
+                // Live check 2026-10-26 — the returned message's last line sits in
+                // the field, not in the held lines: clear it too, or the discard
+                // leaves part of the message behind. Typed drafts keep their line.
+                inputHandleRef.current?.setValueNow('');
+                setValue('');
+                valueNowRef.current = '';
+            }
+            // Its history copy is no longer in the box: ↑ may show it again.
+            skipHistRef.current = null;
             updateBuffer([]);
             // Chips that lived only in the discarded lines go with them; a chip
             // still in the input keeps its text.
@@ -157,6 +276,8 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
         // ↑/↓ belong to the TextInput now (visual rows first, then history).
     }, { isActive: !disabled });
     const handleSubmit = useCallback((line) => {
+        putHeldFreshRef.current = false; // LT-15 final review I1 — sent or continued: no longer "returned"
+        skipHistRef.current = null; // LT-15 I2.4 — the skip lasts until the next submit
         // Task 7 — trailing `\` continues the message (chips stay folded until the final submit).
         if (line.endsWith('\\')) {
             updateBuffer([...bufferRef.current, line.slice(0, -1)]);
@@ -200,7 +321,7 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
             onNotice?.('no image on the clipboard');
         return chip;
     }, [onNotice]);
-    const borderStyle = shouldUseUnicodeBoxChars() ? 'round' : 'classic';
+    const borderStyle = cardBorderStyle();
     const borderColor = roleProps('frame').color;
     if (fuzzyMode) {
         const g = getGlyphs();
@@ -216,5 +337,5 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
     if (disabled) {
         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 (_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 }) }));
+    return (_jsx(Box, { flexDirection: "column", borderStyle: borderStyle, borderColor: borderColor, paddingX: 1, width: boxWidth, children: _jsx(TextInput, { value: value, onChange: handleChange, 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, handleRef: inputHandleRef, onHistoryUp: historyUp, onHistoryDown: historyDown }) }));
 }

package/dist/ui/interrupt.js

@@ -95,9 +95,43 @@ export function createPendingTurnCancel() {
 export function autoDispatchDecision(s, cmd) {
     if (s.done)
         return { kind: 'skip' };
-    if (s.exitRequested || s.cancelPending) {
+    if (s.exitRequested || s.cancelPending || (s.stopped === true && s.chatFallback !== true)) {
         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' };
 }
+export function leftoverDecision(s) {
+    if (s.waiting <= 0)
+        return 'none';
+    if (s.done || s.exitRequested || s.forceExit)
+        return 'report-unsent';
+    if (s.ctrlCStop || s.errorEnd)
+        return 'to-input';
+    if (s.dispatchScheduled || s.restoreActive)
+        return 'wait';
+    return 'run';
+}
+/** LT-15 Feature 4 — the one line at exit for messages that never ran. */
+export function unsentLine(n) {
+    return `${n} waiting message${n === 1 ? '' : 's'} not sent`;
+}
+export function decideEscape(s) {
+    if (s.overlayOpen || s.bufferCount > 0 || s.fuzzyOpen)
+        return 'none';
+    if (s.alreadyStopped || s.restoreActive)
+        return 'none';
+    if (s.turnActive)
+        return 'brake';
+    if (s.busy && s.phase === 'post' && s.canChain === true)
+        return 'cancel-pending';
+    return 'none';
+}
+/** The one line at the Esc press (D2: the short form when nothing waits). */
+export function brakeLine(waiting) {
+    return waiting ? 'Stopping at the next safe point · your message goes next' : 'Stopping at the next safe point';
+}
+/** The one dim line a braked turn prints in place of the turn-error block. */
+export function brakeEndLine(waiting) {
+    return waiting ? 'Stopped · your work so far is kept' : 'Stopped · your work so far is kept · type continue to pick up';
+}

package/dist/ui/live-area.js

@@ -2,9 +2,10 @@
 //
 // Pure layout decisions for the Ink live area (CLI look piece 2, spec §2).
 // Order, top to bottom: Body (<Static>) → checklist → card slot → status
-// strip → input → footer → palettes. Ink 5 clears and redraws the WHOLE
-// screen once the live region reaches the terminal height (ink.js
-// `outputHeight >= stdout.rows`), so the live area is capped at rows − 2.
+// strip → queue row (LT-15) → input → footer → palettes. Ink 5 clears and
+// redraws the WHOLE screen once the live region reaches the terminal height
+// (ink.js `outputHeight >= stdout.rows`), so the live area is capped at
+// rows − 2.
 /** Precedence: model-driven blocking cards first, then user-opened panels. */
 const PRECEDENCE = ['approval', 'confirm', 'ask', 'coaching', 'files', 'rewind', 'timeline', 'shortcuts'];
 /** The ONE card shown in the slot (spec §1.6: one card at a time), or null. */
@@ -57,10 +58,13 @@ export const PALETTE_ROWS = 13;
  *      even one input line fits beside the full card.
  * The status row is always counted (conservative: it is hidden while a card
  * is open, so the real frame is one row shorter).
+ * LT-15 Feature 1 — `queueRows` is the "N waiting" row's height as shown
+ * (0 when it is hidden). It is fixed like the status row; absent means 0.
  */
 export function liveBudget(args) {
     const cap = Math.max(0, args.rows - 2);
-    const fixed = STATUS_ROWS + INPUT_BORDER_ROWS + FOOTER_ROWS + Math.max(0, args.paletteRows);
+    const fixed = STATUS_ROWS + INPUT_BORDER_ROWS + FOOTER_ROWS + Math.max(0, args.paletteRows)
+        + Math.max(0, args.queueRows ?? 0);
     const wanted = Math.max(0, args.checklistRows);
     const card = Math.max(0, args.cardRows);
     const checklistRows = card > 0
@@ -70,6 +74,19 @@ export function liveBudget(args) {
     const inputMaxLines = Math.max(1, Math.min(Math.max(1, args.inputLines), INPUT_MAX_LINES, remaining));
     return { checklistRows, inputMaxLines, showDescriptions: remaining >= 1 };
 }
+/**
+ * LT-15 Task 2 fix round 1 (review I-2): the rows the "N waiting" row may
+ * take so the live area stays ≤ rows − 2 — the cap less the status strip,
+ * the input border, the footer, an open palette, the checklist's one folded
+ * line (when there is a checklist) and one input line. Never below 1: the
+ * row then folds to one line (formatQueueRow). The row is hidden while a
+ * card is open, so no card term.
+ */
+export function queueRowBudget(args) {
+    const cap = Math.max(0, args.rows - 2);
+    const fixed = STATUS_ROWS + INPUT_BORDER_ROWS + FOOTER_ROWS + Math.max(0, args.paletteRows);
+    return Math.max(1, cap - fixed - Math.min(Math.max(0, args.checklistRows), 1) - 1);
+}
 /**
  * Fix round 1 (review I1): the rows a card may take so the whole live area
  * stays ≤ rows − 2 with one input line beside it — the cap less the status

package/dist/ui/queue-box-emitter.js

@@ -0,0 +1,14 @@
+import { EventEmitter } from 'node:events';
+/**
+ * LT-15 Task 4 (owner D1, plan review I3/I5) — repl.tsx asks the mounted
+ * <App> to put every waiting message back into the input box: a turn end
+ * after Ctrl+C or an error, and a session switch. <App> owns the box
+ * (returnQueueToBox), repl.tsx owns the turn, so they talk through this
+ * singleton — the same pattern as rewindEmitter. In classic mode <App> is
+ * never mounted and nothing listens.
+ */
+export const queueBoxEmitter = new EventEmitter();
+/** True when a mounted <App> took the request (it may still find nothing to put). */
+export function requestQueueToBox() {
+    return queueBoxEmitter.emit('return');
+}

package/dist/ui/rewind-panel.js

@@ -7,6 +7,7 @@ import { roleProps, selectedProps } from './role-props.js';
 import { getGlyphs } from '../renderer/glyphs.js';
 import { uiWidth, truncateToWidth } from '../renderer/ui-width.js';
 import { sanitizeControlChars } from '../renderer/sanitize.js';
+import { cardBorderStyle } from './ascii-chars.js';
 /**
  * RewindPanel — UX Wave 3 / Task 3; a card-slot occupant since CLI look
  * piece 2 (§10). The Esc-Esc (and /rewind) card that turns "undo for your
@@ -120,7 +121,7 @@ export function RewindPanel({ candidates, onRestore, onClose, width = uiWidth()
     const below = Math.max(0, candidates.length - windowStop);
     const scrolls = windowStart > 0 || below > 0;
     const g = getGlyphs();
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: roleProps('frame').color, paddingX: 2, width: width, children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: truncateToWidth('Rewind · undo a write from this session', inner) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [empty && _jsx(Text, { ...roleProps('dim'), children: "No restorable writes this session" }), !empty && windowStart > 0 && _jsxs(Text, { ...roleProps('dim'), children: ["  \u2191 ", windowStart, " more"] }), !empty && visible.map((c, i) => {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: cardBorderStyle(), borderColor: roleProps('frame').color, paddingX: 2, width: width, children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: truncateToWidth('Rewind · undo a write from this session', inner) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [empty && _jsx(Text, { ...roleProps('dim'), children: "No restorable writes this session" }), !empty && windowStart > 0 && _jsxs(Text, { ...roleProps('dim'), children: ["  \u2191 ", windowStart, " more"] }), !empty && visible.map((c, i) => {
                         const idx = windowStart + i;
                         const sel = idx === cursor;
                         const row = truncateToWidth(`${sel ? `${g.cursor} ` : '  '}${rewindRowLabel(c)}`, inner);

package/dist/ui/session-timeline.js

@@ -8,6 +8,7 @@ import { uiWidth, truncateToWidth } from '../renderer/ui-width.js';
 import { toolLabel } from '../renderer/tool-labels.js';
 import { sanitizeControlChars } from '../renderer/sanitize.js';
 import { hhmm } from '../rewind/format.js';
+import { cardBorderStyle } from './ascii-chars.js';
 // v1.1: add 'skipped' (approval rejection logs) and 'rolled_back' (snapshot restore).
 // Both need session-schema bump (schema_version 2) — deferred.
 const MUTATING_TOOLS = new Set([
@@ -64,7 +65,7 @@ export function SessionTimeline({ entries, onClose, width = uiWidth() }) {
             return;
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: roleProps('frame').color, paddingX: 2, width: width, children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: ["Write history ", _jsx(Text, { ...roleProps('dim'), children: maxOffset > 0 ? '· ↑↓ scroll · Esc to close' : '· Esc to close' })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [writes.length === 0 && _jsx(Text, { ...roleProps('dim'), children: "No writes this session" }), start > 0 && _jsxs(Text, { ...roleProps('dim'), children: ["  \u2191 ", start, " more"] }), visible.map((e, i) => {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: cardBorderStyle(), borderColor: roleProps('frame').color, paddingX: 2, width: width, children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: ["Write history ", _jsx(Text, { ...roleProps('dim'), children: maxOffset > 0 ? '· ↑↓ scroll · Esc to close' : '· Esc to close' })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [writes.length === 0 && _jsx(Text, { ...roleProps('dim'), children: "No writes this session" }), start > 0 && _jsxs(Text, { ...roleProps('dim'), children: ["  \u2191 ", start, " more"] }), visible.map((e, i) => {
                         const time = `${hhmm(e.timestamp)}  `;
                         const glyph = e.isError ? g.failed : g.done;
                         const verb = toolLabel(e.toolName, {}).verb;

package/dist/ui/text-input.js

@@ -88,7 +88,7 @@ export function computeDisplayWindow(valueLength, cursorOffset, budget, cursorVi
     const end = Math.min(valueLength, start + budget);
     return { start, end };
 }
-export function PasteSafeTextInput({ value: originalValue, placeholder = '', focus = true, mask, showCursor = true, onChange, onSubmit, onPasteLines, maxDisplayWidth, onPasteImage, wrapWidth, maxLines, heldLines, prompt, onHistoryUp, onHistoryDown, onLargePaste, }) {
+export function PasteSafeTextInput({ value: originalValue, placeholder = '', focus = true, mask, showCursor = true, onChange, onSubmit, onPasteLines, maxDisplayWidth, onPasteImage, wrapWidth, maxLines, heldLines, prompt, onHistoryUp, onHistoryDown, onLargePaste, handleRef, }) {
     const [cursorOffset, setCursorOffset] = useState((originalValue || '').length);
     // The paste-safety core: synchronous mirrors of value + cursor. The
     // input handler reads/writes THESE, never the (possibly stale) props.
@@ -102,6 +102,9 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
     // the repro as words landing out of order). An echo — even a stale
     // one — must never overwrite the mirror; only EXTERNAL pushes may.
     const pendingEchoes = useRef([]);
+    // LT-15 Task 4 — the value prop as of the last render (for getValueNow).
+    const propValueRef = useRef(originalValue);
+    propValueRef.current = originalValue;
     // Re-sync the mirrors on EXTERNAL value pushes only (parent setValue('')
     // after submit, palette prefill). Echoes of our own onChange — current
     // or stale — are recognised via pendingEchoes and skipped: the mirror
@@ -119,6 +122,32 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
             setCursorOffset(originalValue.length);
         }
     }, [originalValue]);
+    // LT-15 (fix round 1, C1) — the synchronous put. The value is recorded as
+    // our own pending echo: when the parent's matching `value` prop commits,
+    // the re-sync effect above skips it (it is not an external push), so a
+    // keystroke typed on top of it in the meantime is never rewound.
+    useEffect(() => {
+        if (!handleRef)
+            return undefined;
+        const handle = {
+            setValueNow: (next) => {
+                valueRef.current = next;
+                cursorRef.current = next.length;
+                // LT-15 Task 4 — added, not replaced: an older echo of our own typing
+                // that commits late must still be recognised, or it would rewind the put.
+                pendingEchoes.current.push(next);
+                setCursorOffset(next.length);
+            },
+            // While the field has typing the parent has not echoed back yet, its
+            // mirror is the truth (a key typed just before an outside put). Otherwise
+            // the last rendered prop is: right after Enter the parent has already
+            // cleared the box, but the mirror only hears it in a later effect.
+            getValueNow: () => (pendingEchoes.current.length > 0 ? valueRef.current : propValueRef.current) ?? '',
+        };
+        handleRef.current = handle;
+        return () => { if (handleRef.current === handle)
+            handleRef.current = null; };
+    }, [handleRef]);
     // Clamp rendered cursor when the value shrinks under it (vendored
     // semantic from ink-text-input's first effect).
     useEffect(() => {
@@ -179,7 +208,7 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
                 if (w.cursorLine > 0)
                     moveCursor(indexAt(cur, wrapWidth, w.cursorLine - 1, w.cursorCol));
                 else
-                    onHistoryUp?.();
+                    onHistoryUp?.(cur);
             }
             else if (w.cursorLine < w.lines.length - 1) {
                 moveCursor(indexAt(cur, wrapWidth, w.cursorLine + 1, w.cursorCol));