@cspeach/cli 0.9.0 → 1.1.0

package/dist/ui/ask-question-emitter.js

@@ -9,5 +9,19 @@ class AskQuestionEmitter extends EventEmitter {
             this.emit('request', { ...params, resolve });
         });
     }
+    /**
+     * UX Wave 2 / Task 2 — v2 batched form request. Same no-listener fallback
+     * contract as request(): resolve cancelled (v2 shape — empty answers) so
+     * callers without a mounted App fall through to their own path.
+     */
+    requestForm(form) {
+        return new Promise((resolve) => {
+            if (this.listenerCount('request') === 0) {
+                resolve({ formId: form.formId, answers: [], cancelled: true });
+                return;
+            }
+            this.emit('request', { ...form, resolve });
+        });
+    }
 }
 export const askQuestionEmitter = new AskQuestionEmitter();

package/dist/ui/body.js

@@ -3,6 +3,7 @@ import React, { useReducer, useEffect } from 'react';
 import { Text, Static } from 'ink';
 import { WIDGET_COMPONENTS } from './widgets/component-registry.js';
 import { WIDGET_CONTROL } from './widget-control.js';
+import { formatNoticeLine } from '../renderer/notices.js';
 /**
  * Frame interval for batching streaming chunks before dispatching to the
  * reducer (W2.2 — 2026-05-18). Ink already throttles its stdout writes to
@@ -162,9 +163,21 @@ export const Body = React.memo(function Body({ chunkEmitter }) {
         // synchronously on unmount so end-of-stream output isn't dropped.
         const batcher = createChunkBatcher((buffered) => dispatch({ chunk: buffered }));
         const handler = (chunk) => batcher.push(chunk);
+        // B2 fix (2026-06-12) — consume the 'warn'/'info' notice channel.
+        // Tool handlers (transport-resolution Rule 9 notices, write-tool
+        // snapshot lines) emit these levels on the same emitter; before this
+        // they were silent no-ops in the live Ink REPL. Notices are formatted
+        // to a single line and pushed through the SAME batcher so their order
+        // relative to surrounding chunk text is preserved.
+        const warnHandler = (msg) => batcher.push(formatNoticeLine('warn', msg));
+        const infoHandler = (msg) => batcher.push(formatNoticeLine('info', msg));
         chunkEmitter.on('chunk', handler);
+        chunkEmitter.on('warn', warnHandler);
+        chunkEmitter.on('info', infoHandler);
         return () => {
             chunkEmitter.off('chunk', handler);
+            chunkEmitter.off('warn', warnHandler);
+            chunkEmitter.off('info', infoHandler);
             batcher.dispose();
         };
     }, [chunkEmitter]);

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,44 +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 TextInput from 'ink-text-input';
+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';
-const HISTORY_FILE = 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(HISTORY_FILE, '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;
-    fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
-    fs.appendFileSync(HISTORY_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]);
@@ -70,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);
@@ -82,8 +141,42 @@ export function Footer({ onSubmit, onSlashTrigger, onHistoryTrigger, onValueChan
             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.
+    }, { 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);
@@ -98,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
@@ -108,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

@@ -19,8 +19,8 @@
 // pick, so a line flows slash → at → empty-body guard → submit no
 // matter where it entered the pipeline.
 import { isExactSlashMatch, filterSlashEntries } from '../repl/slash-picker.js';
-import { pendingAtTokenPrefix, filterFileChoices } from '../repl/at-picker.js';
-import { SKILL_CATALOG } from '../skill-catalog.js';
+import { pendingAtTokenPrefix } from '../repl/at-picker.js';
+import { SKILL_CATALOG, SKILL_ALIASES } from '../skill-catalog.js';
 export function nextResolutionStep(line, files) {
     const trimmed = line.trim();
     if (trimmed.startsWith('/') && !isExactSlashMatch(trimmed)) {
@@ -38,19 +38,36 @@ export function nextResolutionStep(line, files) {
     const filenames = files.map((f) => f.filename);
     const atPrefix = pendingAtTokenPrefix(trimmed, filenames);
     if (atPrefix !== null && files.length > 0) {
-        const seeded = filterFileChoices(atPrefix, files);
-        if (seeded.length === 1) {
-            return emptyBodyGuard(trimmed.replace(/@\S*$/, `@${seeded[0].filename}`));
-        }
+        // Always open the picker when the line ends in an unresolved @-token —
+        // even when it narrows to a single file. The old single-match shortcut
+        // silently auto-resolved AND auto-submitted, so the user never saw which
+        // file was attached and couldn't keep typing (e.g. add `--scope`). Showing
+        // the palette + inserting-on-pick (App handles that) is the correct flow.
         return { kind: 'open-at', prefix: atPrefix, line: trimmed };
     }
     // Empty workspace: nothing to pick — let the downstream @-resolution
     // 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. */
@@ -68,6 +85,16 @@ function emptyBodyGuard(line) {
         const splitIdx = line.search(/\s/);
         const head = splitIdx === -1 ? line : line.slice(0, splitIdx);
         const body = splitIdx === -1 ? '' : line.slice(splitIdx).trim();
+        // Retired-but-redirected name with no body: prefill the NEW name so the
+        // user both learns the rename and doesn't dispatch an empty prompt.
+        const aliasTarget = SKILL_ALIASES[head.toLowerCase().slice(1)];
+        if (aliasTarget !== undefined && body.length === 0) {
+            return {
+                kind: 'prefill',
+                text: `/${aliasTarget} `,
+                hint: `↪ ${head.toLowerCase()} is now /${aliasTarget} — type your prompt and press Enter`,
+            };
+        }
         const isSkill = SKILL_CATALOG.some((s) => `/${s.name}` === head.toLowerCase());
         if (isSkill && body.length === 0) {
             return {

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/session-timeline.js

@@ -6,6 +6,7 @@ const MUTATING_TOOLS = new Set([
     'sap_set_source', 'sap_update_method', 'sap_delete_object', 'sap_activate',
     'sap_create_object', 'sap_transport_release', 'sap_message_maintain',
     'sap_number_range_intervals', 'sap_service_binding_publish',
+    'sap_service_binding_unpublish',
 ]);
 export function toTimelineEntry(call) {
     // args shape depends on the tool; extract defensively.

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 })] }));
+}