@cspeach/cli 1.0.0 → 1.1.0

package/dist/ui/context-grid.js

@@ -0,0 +1,108 @@
+// cspeach-cli/src/ui/context-grid.tsx
+//
+// UX Wave 3 / Task 5 — render the /context composition grid to lines of text.
+//
+// One bar per segment, proportional to the exact billed prompt total (share of
+// USED context), capped at 40 columns. Classic mode = the same lines minus
+// color, so this is a single
+// pure line-builder with a `color` flag rather than two renderers. The Ink
+// dispatch path emits these lines through chunkEmitter; the classic path
+// console.logs them — same seam as /cost and /export.
+//
+// Wave-1 invariant (binding): NO row may ever wrap. Every row is truncated end
+// to the terminal width AS PLAIN TEXT FIRST, then color is applied to the
+// already-truncated string — so colored lines are truncated identically to
+// classic ones and an ANSI escape can never be split by the cut.
+import chalk from 'chalk';
+import { shouldUseUnicodeBoxChars } from '../renderer/tty.js';
+import { buildContextReport } from '../session/context-report.js';
+import { readCostLog } from '../cost/cost-log.js';
+/** Bars never exceed this many columns (Wave-1 proportional-bar cap). */
+const BAR_MAX = 40;
+/** Segment labels are padded to this width so values line up. */
+const LABEL_WIDTH = 22;
+/**
+ * Values (`~130k`) are padded to this width so the bars that follow line up.
+ * `~` + up to 3 digits + `k` = 5; a couple of spare columns keep three-digit
+ * k-values aligned. The value sits BEFORE the bar (triage #14) so a narrow
+ * terminal truncates bar characters, never the number's digits.
+ */
+const VALUE_WIDTH = 7;
+/** k-format a token count: 130400 → "130k". */
+function k(n) {
+    return `${Math.round(n / 1000)}k`;
+}
+/** Truncate a plain string to `width` columns (end-truncation, no wrap). */
+function truncateEnd(s, width) {
+    if (width <= 0)
+        return '';
+    return s.length > width ? s.slice(0, width) : s;
+}
+/**
+ * Build the /context grid as an array of ready-to-emit lines.
+ *
+ * The header shows the one exact number (lastTurnInput, in k). Every segment
+ * row shows a `~` (approx) token figure — the heuristic honesty marker. Bars
+ * are scaled against lastTurnInput so they read as "share of the USED
+ * context", and capped at BAR_MAX.
+ */
+export function renderContextGrid(report, opts = {}) {
+    const color = opts.color ?? true;
+    const width = opts.width ?? (typeof process !== 'undefined' && process.stdout?.columns ? process.stdout.columns : 80);
+    const unicode = shouldUseUnicodeBoxChars();
+    const fill = unicode ? '█' : '#';
+    const arrow = unicode ? '→' : '->';
+    const lines = [];
+    // ── header: context: 87k / 200k (43%) ──  (the only exact number)
+    // Truncate the PLAIN text first, then color — so the width cut is identical
+    // in both modes and can never land inside an ANSI escape.
+    const pctInt = Math.round(report.pct * 100);
+    const headerText = truncateEnd(`context: ${k(report.lastTurnInput)} / ${k(report.windowTokens)} (${pctInt}%)`, width);
+    lines.push(color ? chalk.bold(headerText) : headerText);
+    lines.push('');
+    // Scale bars against the exact billed prompt total (lastTurnInput) so a
+    // segment's bar reads as its share of the USED context, capped at BAR_MAX.
+    // Fall back to the largest segment when there is no billed input yet (so an
+    // unbilled session still renders a readable grid).
+    const scaleBase = report.lastTurnInput > 0
+        ? report.lastTurnInput
+        : Math.max(1, ...report.segments.map((s) => s.approxTokens));
+    for (const seg of report.segments) {
+        const barLen = Math.min(BAR_MAX, Math.max(0, Math.round((BAR_MAX * seg.approxTokens) / scaleBase)));
+        const bar = fill.repeat(barLen);
+        const label = seg.label.padEnd(LABEL_WIDTH).slice(0, LABEL_WIDTH);
+        const value = `~${k(seg.approxTokens)}`;
+        // Value BEFORE the bar (triage #14): a narrow terminal truncates the bar
+        // run, never the number's digits (value-after-bar clipped "~130k" → "~1").
+        // Plain, color-free row: identical bytes in both modes → truncation can
+        // never split an ANSI escape, and classic == Ink minus color trivially.
+        const row = `${label} ${value.padEnd(VALUE_WIDTH)} ${bar}`;
+        lines.push(truncateEnd(row, width));
+    }
+    if (report.hints.length > 0) {
+        lines.push('');
+        for (const h of report.hints) {
+            // Same order as the header: plain-truncate, THEN color.
+            const text = truncateEnd(`${arrow} ${h}`, width);
+            lines.push(color ? chalk.dim(text) : text);
+        }
+    }
+    return lines;
+}
+/**
+ * `/context` command — read the session's cost log, build the composition
+ * report, render the grid, and emit it line by line through the caller's sink
+ * (chunkEmitter in Ink mode, console.log in classic mode — same seam as
+ * runCostCommand). Read-only, no network. `costEntries` is injectable for
+ * tests; otherwise it is read from the session's JSONL log.
+ */
+export async function runContextCommand(opts) {
+    const { session, emit } = opts;
+    const costEntries = opts.costEntries ?? (await readCostLog(session.id));
+    const report = buildContextReport(session, costEntries);
+    const lines = renderContextGrid(report, { color: opts.color });
+    emit('');
+    for (const line of lines)
+        emit(line);
+    emit('');
+}

package/dist/ui/footer.js

@@ -1,52 +1,94 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React, { useState, useEffect, useCallback } from 'react';
-import { Box, Text, useInput } from 'ink';
+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.
 import TextInput from './text-input.js';
 import Fuse from 'fuse.js';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-// Resolved lazily (not at module load) so it honours the HOME/USERPROFILE
-// active at render time — lets tests point it at a temp dir.
-function historyFile() {
-    return path.join(os.homedir(), '.cspeach', 'history');
-}
+// 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.
+import { appendHistoryEntry, readHistoryEntries, flattenHistoryEntry } from '../repl/history.js';
 function loadHistory() {
-    try {
-        return fs.readFileSync(historyFile(), 'utf8').split('\n').filter(Boolean);
-    }
-    catch {
-        return [];
-    }
+    return readHistoryEntries();
 }
 function appendHistory(line, history) {
-    // Skip consecutive duplicates (matches bash HISTCONTROL=ignoredups).
-    if (history[history.length - 1] === line)
-        return;
-    const file = historyFile();
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.appendFileSync(file, line + '\n');
-    history.push(line);
+    // 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.
+    const entry = flattenHistoryEntry(line);
+    if (appendHistoryEntry(entry))
+        history.push(entry);
 }
 const PEACH = '#FFCBA4';
-export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChange, prefill, disabled }) {
+/** The input prompt — its width feeds the display budget below. */
+const PROMPT = 'CSPeach › ';
+export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChange, prefill, disabled, onNotice, onBufferChange }) {
     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(() => {
+        if (!stdout)
+            return;
+        const onResize = () => bumpOnResize((n) => n + 1);
+        stdout.on('resize', onResize);
+        return () => { stdout.off('resize', onResize); };
+    }, [stdout]);
+    const columns = stdout?.columns || 80;
+    const inputBudget = Math.max(8, columns - PROMPT.length - 1);
     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 [buffer, setBuffer] = useState([]);
+    const bufferRef = useRef([]);
+    const updateBuffer = useCallback((lines) => {
+        bufferRef.current = lines;
+        setBuffer(lines);
+    }, []);
     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 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.
+    // 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.
     useEffect(() => {
-        if (prefill && prefill.text.length > 0)
+        if (prefill && prefill.nonce > 0)
             setValue(prefill.text);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [prefill?.nonce]);
@@ -78,6 +120,15 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
             }
             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.
+        if (key.escape && bufferRef.current.length > 0) {
+            updateBuffer([]);
+            onNotice?.('multiline draft discarded');
+            return;
+        }
         if (key.upArrow) {
             const next = Math.min(histIdx + 1, history.length - 1);
             setHistIdx(next);
@@ -98,6 +149,34 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
         // why the TextInput is swapped for a placeholder when disabled.
     }, { 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.
+        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();
+            updateBuffer([]);
+            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())
             return;
         appendHistory(line.trim(), history);
@@ -112,9 +191,9 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
             return;
         }
         onSubmit(line.trim());
-    }, [onSubmit, onSlashTrigger, onHistoryTrigger, history]);
+    }, [onSubmit, onSlashTrigger, onHistoryTrigger, history, updateBuffer]);
     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..." }), fuzzyResults.map((r, i) => _jsx(Text, { dimColor: i > 0, children: r }, i)), _jsx(Text, { dimColor: true, children: "Esc: cancel  Enter: select" })] }));
+        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" })] }));
     }
     // 2026-05-17 — when a modal owns input (coaching picker / ask_question),
     // render a dim placeholder INSTEAD of the live TextInput. Otherwise
@@ -122,7 +201,7 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
     // Footer submission fires after the modal resolves → spurious picker
     // for what the user thought was their modal answer.
     if (disabled) {
-        return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: "CSPeach \u203A " }), _jsx(Text, { dimColor: true, children: "(answer above to continue)" })] }));
+        return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: PROMPT }), _jsx(Text, { dimColor: true, children: "(answer above to continue)" })] }));
     }
-    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: "CSPeach \u203A " }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSubmit })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [buffer.length > 0 && (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["\u2026 ", buffer.length, " line", buffer.length === 1 ? '' : 's', " pending (Enter sends, \\ continues)"] })), _jsxs(Box, { children: [_jsx(Text, { bold: true, color: PEACH, children: PROMPT }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSubmit, onPasteLines: handlePasteLines, maxDisplayWidth: inputBudget })] })] }));
 }

package/dist/ui/header.js

@@ -4,6 +4,13 @@ import { useSapState } from './sap-state-store.js';
 import { CLI_VERSION } from '../lib/version.js';
 const PEACH = '#FFCBA4';
 /**
+ * ⚠ SUPERSEDED (UX Wave 1, Task 4 — 2026-07) by ui/status-line.tsx, the
+ * bottom-anchored borderless statusline mounted in App between TurnStatus
+ * and Footer. This component is no longer rendered anywhere: Phase D6
+ * removed the persistent top Header (inline mode can't pin the frame top),
+ * and the statusline took over the SapStateStore display role. Kept for
+ * reference, not deleted.
+ *
  * Single-line rich header (Phase D3, 2026-05-16) — back to one line per
  * Laeeq's feedback that the two-line variant felt worse. Uses tighter
  * separators and shorter labels so it fits cleanly on typical terminals

package/dist/ui/line-resolution.js

@@ -49,9 +49,25 @@ export function nextResolutionStep(line, files) {
     // produce its normal "no file matching" message.
     return emptyBodyGuard(trimmed);
 }
-/** Substitute the picked command head into the pending line and continue. */
-export function applySlashPick(pickedName, rest, files) {
+/**
+ * Substitute the picked command head into the pending line and continue.
+ *
+ * `fillIn` (UX Wave 1, Task 5 — CC v2.1.19x behavior): true when the palette
+ * was opened by the LIVE bare-`/` trigger (original line empty). A pick then
+ * PREFILLS `/{command} ` into the Footer — never submits, not even for
+ * builtins that take no body — so the user can add arguments before Enter.
+ * The typed-and-submitted flow (fillIn=false, the default) keeps today's
+ * semantics: re-run the pipeline, which submits when the line is complete.
+ */
+export function applySlashPick(pickedName, rest, files, fillIn = false) {
     const name = pickedName.startsWith('/') ? pickedName : `/${pickedName}`;
+    if (fillIn) {
+        return {
+            kind: 'prefill',
+            text: `${name} `,
+            hint: `↪ ${name} — add arguments or press Enter to run`,
+        };
+    }
     return nextResolutionStep(`${name}${rest}`, files);
 }
 /** Substitute the picked filename into the rightmost @-token and continue. */

package/dist/ui/rewind-emitter.js

@@ -0,0 +1,10 @@
+import { EventEmitter } from 'node:events';
+/**
+ * Open-request channel for the Rewind panel (UX Wave 3 / Task 3). The Esc-Esc
+ * chord opens the panel from inside <App>'s own useInput; the `/rewind` builtin
+ * lives in repl.tsx (a separate React-less dispatch), so it signals the mounted
+ * <App> through this singleton emitter — the same producer→consumer pattern as
+ * todoEmitter / approvalEmitter. In classic mode <App> is never mounted, this
+ * emitter has no listeners, and `/rewind` takes the inquirer path instead.
+ */
+export const rewindEmitter = new EventEmitter();

package/dist/ui/rewind-panel.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { hhmm, rewindRowLabel, packageUnknown } from '../rewind/format.js';
+/**
+ * RewindPanel — UX Wave 3 / Task 3. The Esc-Esc (and /rewind) overlay that
+ * turns "undo for your SAP system" into a picker. House style follows
+ * SessionTimeline / TodoPanel / CommandPalette: a bordered box mounted above
+ * the Footer by <App>, closes on Esc / q, every row wrap="truncate-end"
+ * (Wave-1 rule — no dynamic-frame row may soft-wrap), and lists longer than
+ * REWIND_VISIBLE_ROWS scroll in a window (CommandPalette pattern).
+ *
+ * Row: `▸ ZMNT_NOTE (TABL) · set_source · 14:32 · snapshot 12:01`
+ *   - restorable  → bold, cyan when the cursor is on it.
+ *   - restorable delete with an unknown recreate package → a dim
+ *     `(package unknown — restore may fail)` tail (rider c).
+ *   - non-restorable → dim, with the candidate's reason.
+ *
+ * Enter on a restorable row swaps the footer hint for an inline confirm line
+ * (`restore … to snapshot 12:01? runs the write gates — [y]/[n]`). `y` fires
+ * onRestore(candidate) and closes; `n` / Esc returns to the list. The panel
+ * NEVER runs the write itself — onRestore bridges to the gated executor.
+ *
+ * Empty state: a single dim `no restorable writes this session` line that
+ * closes on any key.
+ */
+export const REWIND_VISIBLE_ROWS = 10;
+export function RewindPanel({ candidates, onRestore, onClose }) {
+    const [cursor, setCursor] = useState(0);
+    const [confirming, setConfirming] = useState(null);
+    const empty = candidates.length === 0;
+    useInput((input, key) => {
+        // Empty state: any key dismisses.
+        if (empty) {
+            onClose();
+            return;
+        }
+        if (confirming) {
+            if (input === 'y' || input === 'Y') {
+                onRestore(confirming);
+                onClose();
+                return;
+            }
+            // n / N / Esc / q — back to the list, nothing written.
+            setConfirming(null);
+            return;
+        }
+        if (key.escape || input === 'q') {
+            onClose();
+            return;
+        }
+        if (key.upArrow) {
+            setCursor((cu) => Math.max(0, cu - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setCursor((cu) => Math.min(candidates.length - 1, cu + 1));
+            return;
+        }
+        if (key.return) {
+            const c = candidates[cursor];
+            if (c && c.restorable)
+                setConfirming(c); // no-op on a dimmed non-restorable row
+            return;
+        }
+    });
+    const maxOffset = Math.max(0, candidates.length - REWIND_VISIBLE_ROWS);
+    const windowStart = Math.max(0, Math.min(cursor - 3, maxOffset));
+    const visible = candidates.slice(windowStart, windowStart + REWIND_VISIBLE_ROWS);
+    const below = Math.max(0, candidates.length - (windowStart + REWIND_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: "Rewind \u2014 undo a write this session \u00B7 times UTC" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [empty && _jsx(Text, { dimColor: true, children: "no restorable writes this session" }), !empty && windowStart > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2191 ", windowStart, " more"] }), !empty && visible.map((c, i) => {
+                        const idx = windowStart + i;
+                        const sel = idx === cursor;
+                        const glyph = sel ? '▸ ' : '  ';
+                        return (_jsxs(React.Fragment, { children: [c.restorable
+                                    ? _jsxs(Text, { bold: true, color: sel ? 'cyan' : undefined, wrap: "truncate-end", children: [glyph, rewindRowLabel(c)] })
+                                    : _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [glyph, rewindRowLabel(c)] }), packageUnknown(c) && (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: "     package unknown \u2014 restore may fail" }))] }, idx));
+                    }), !empty && below > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2193 ", below, " more"] })] }), _jsx(Box, { marginTop: 1, children: confirming ? (_jsxs(Text, { color: "yellow", wrap: "truncate-end", children: ["restore ", confirming.object, " to snapshot ", hhmm(confirming.snapshotAt), "? runs write gates \u2014 [y]/[n]"] })) : (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: empty
+                        ? 'any key to close'
+                        : `${candidates.length > REWIND_VISIBLE_ROWS ? '↑↓ scroll · ' : ''}Enter restore · Esc/q close` })) })] }));
+}

package/dist/ui/sap-state-store.js

@@ -14,6 +14,7 @@ import React, { createContext, useContext } from 'react';
 const DEFAULT_STATE = {
     system: '', user: '', transport: null, locksHeld: [],
     tokenUsageToday: 0, dollarSpendToday: 0, dollarCap: 100, recentTurns: [],
+    writeMode: null,
 };
 /**
  * Rate limiter: calls `fn` at most once every `minIntervalMs`. Trailing-only:

package/dist/ui/status-line.js

@@ -0,0 +1,43 @@
+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';
+/**
+ * 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();
+    const spendDisplay = `$${s.dollarSpendToday.toFixed(2)}`;
+    // 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
+                ? _jsx(Text, { color: "yellow", children: s.transport })
+                : _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/text-input.js

@@ -27,7 +27,28 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useState, useEffect, useRef } from 'react';
 import { Text, useInput } from 'ink';
 import chalk from 'chalk';
-export function PasteSafeTextInput({ value: originalValue, placeholder = '', focus = true, mask, showCursor = true, onChange, onSubmit, }) {
+/**
+ * Pure windowing core (exported for tests). Given the value length, the
+ * cursor position, the display budget (character cells) and whether the
+ * fake cursor is rendered, return the [start, end) slice of the value to
+ * display. Invariants:
+ *  - (end - start) + (cursor-at-end cell ? 1 : 0) <= budget
+ *  - start <= cursorOffset <= start + budget - 1 (cursor always visible)
+ *  - tail-biased: typing at the end shows the end of the value.
+ */
+export function computeDisplayWindow(valueLength, cursorOffset, budget, cursorVisible) {
+    if (!budget || budget <= 0)
+        return { start: 0, end: valueLength };
+    const virtualLength = valueLength + (cursorVisible ? 1 : 0); // trailing cursor cell
+    if (virtualLength <= budget)
+        return { start: 0, end: valueLength };
+    let start = virtualLength - budget; // default: show the tail
+    if (cursorOffset < start)
+        start = cursorOffset; // scrolled left past the window
+    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, }) {
     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.
@@ -66,21 +87,37 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
         setCursorOffset((previous) => previous > originalValue.length ? originalValue.length : previous);
     }, [originalValue, focus, showCursor]);
     const value = mask ? mask.repeat(originalValue.length) : originalValue;
-    let renderedValue = value;
+    // Wave1 live-fix (Bug 1) — display-only horizontal window + control-char
+    // flattening. The mirrors, the props, and every handler above operate on
+    // the FULL value; only what's painted is windowed, so the row can never
+    // soft-wrap in the terminal (see maxDisplayWidth doc). Tabs are flattened
+    // to one space IN THE DISPLAY ONLY: string-width measures '\t' as 0 while
+    // terminals render up to 8 cells — the exact measurement drift that broke
+    // Ink's erase accounting live.
+    const cursorRendered = showCursor && focus;
+    const win = computeDisplayWindow(value.length, cursorOffset, maxDisplayWidth, cursorRendered);
+    const displayCursor = cursorOffset - win.start; // may equal display length (end cell)
+    // Left-clip marker: swap the first visible char for '…' (same cell
+    // count, so the budget still holds) unless the cursor sits on that cell.
+    const clipMarker = win.start > 0 && displayCursor !== 0;
+    const displayValue = (clipMarker ? '…' : '') +
+        value.slice(win.start + (clipMarker ? 1 : 0), win.end).replace(/\t/g, ' ');
+    let renderedValue = displayValue;
     let renderedPlaceholder = placeholder ? chalk.grey(placeholder) : undefined;
-    // Fake cursor — vendored rendering from ink-text-input v6.
-    if (showCursor && focus) {
+    // Fake cursor — vendored rendering from ink-text-input v6, over the
+    // windowed display string.
+    if (cursorRendered) {
         renderedPlaceholder =
             placeholder.length > 0
                 ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1))
                 : chalk.inverse(' ');
-        renderedValue = value.length > 0 ? '' : chalk.inverse(' ');
+        renderedValue = displayValue.length > 0 ? '' : chalk.inverse(' ');
         let i = 0;
-        for (const char of value) {
-            renderedValue += i === cursorOffset ? chalk.inverse(char) : char;
+        for (const char of displayValue) {
+            renderedValue += i === displayCursor ? chalk.inverse(char) : char;
             i++;
         }
-        if (value.length > 0 && cursorOffset === value.length) {
+        if (displayValue.length > 0 && displayCursor === displayValue.length) {
             renderedValue += chalk.inverse(' ');
         }
     }
@@ -102,6 +139,9 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
         const currentValue = valueRef.current;
         let nextCursorOffset = cursorRef.current;
         let nextValue = currentValue;
+        // Task 7 — complete lines carved out of a newline-bearing paste
+        // chunk; reported to the parent AFTER the mirrors are updated.
+        let pasteLines = null;
         if (key.leftArrow) {
             if (showCursor)
                 nextCursorOffset--;
@@ -118,6 +158,28 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
                 nextCursorOffset--;
             }
         }
+        else if (onPasteLines && (input.includes('\n') || input.includes('\r'))) {
+            // Task 7 — multi-line paste chunk. Normalise CRLF / bare CR
+            // (Windows Terminal converts pasted newlines to \r in raw mode),
+            // insert at the cursor as usual, then split at the LAST newline:
+            // everything before it is complete lines for the parent's
+            // continuation buffer; the tail fragment becomes the new value.
+            // Because the fragment (not the full paste) lands in the
+            // synchronous mirror, a follow-up chunk of the same drain
+            // compounds on the fragment — duplicate delivery of a completed
+            // line is structurally impossible, and every D29 mirror/echo
+            // mechanism below operates exactly as for a plain insert.
+            const cleanInput = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            const combined = currentValue.slice(0, cursorRef.current) +
+                cleanInput +
+                currentValue.slice(cursorRef.current, currentValue.length);
+            const lastNl = combined.lastIndexOf('\n');
+            pasteLines = combined.slice(0, lastNl).split('\n');
+            nextValue = combined.slice(lastNl + 1);
+            // Cursor lands where the insertion ended, mapped into the fragment
+            // (0 when the paste ended on the newline itself).
+            nextCursorOffset = Math.max(0, cursorRef.current + cleanInput.length - (lastNl + 1));
+        }
         else {
             nextValue =
                 currentValue.slice(0, cursorRef.current) +
@@ -134,6 +196,8 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
         valueRef.current = nextValue;
         cursorRef.current = nextCursorOffset;
         setCursorOffset(nextCursorOffset);
+        if (pasteLines)
+            onPasteLines?.(pasteLines);
         if (nextValue !== currentValue) {
             // Register the outgoing value so its (possibly late) prop echo is
             // recognised and never rewinds the mirror.

package/dist/ui/todo-emitter.js

@@ -0,0 +1,25 @@
+import { EventEmitter } from 'node:events';
+/**
+ * UX Wave 2 / Task 4 — singleton update channel from the `todo_set` tool
+ * (producer) to `<App>` (consumer, Task 5: Ctrl+T panel + turn-status
+ * strip). Mirror of approvalEmitter: the tool emits, App subscribes in a
+ * useEffect and pushes the list into its state.
+ *
+ * Event contract (Task 5 renders from this):
+ *   todoEmitter.emit('update', todos)   // todos: TodoItem[]
+ *
+ * Fire-and-forget by design — unlike askQuestionEmitter there is no
+ * resolve callback because nothing about the tool result depends on the
+ * UI. The tool reaches this singleton via `ctx.todoEmitter` (Task 5):
+ * top-level entry points (repl.tsx, one-shot.ts) wire it into their
+ * ToolContext; agent_run's child ctx DELIBERATELY omits it — same seam
+ * as chunkEmitter — so a subagent's todo_set is fully suppressed and can
+ * never clobber the parent's panel. With no emitter on the ctx, or no
+ * listener attached (classic REPL, one-shot, headless), the tool behaves
+ * identically: state still lands on session.todos, only the live panel
+ * is absent.
+ *
+ * Never spawn a sibling Ink root for the panel — that fights the main
+ * <App> for stdout and corrupts the Ink frame.
+ */
+export const todoEmitter = new EventEmitter();