@cspeach/cli 1.1.17 → 1.1.19

package/dist/renderer/notices.js

@@ -28,21 +28,50 @@
  * their ctx.chunkEmitter stays undefined so child-turn notices remain
  * muted — exactly the pre-existing contract pinned in agent_run.test.ts.
  */
-import chalk from 'chalk';
+import { writeStdout } from './transcript-flow.js';
+import { writeAboveSpinner } from './tool-widget.js';
+import { formatAttention, formatInfo } from './notice-shape.js';
+import { cleanErrorText, looksLikeMarkup } from '../sap-errors/clean-error-text.js';
+import stringWidth from 'string-width';
+import { getLook } from './look.js';
+import { getGlyphs } from './glyphs.js';
+import { truncateToWidth, uiWidth } from './ui-width.js';
+import { getNoticeLogPath, recordFullNotice } from './notice-log.js';
+import { getEffectiveBodyWidth, isDeclaredOneShot } from './tty.js';
 import { EventEmitter } from 'node:events';
 /**
  * Format one notice as a single terminal line (trailing newline included).
  * Multi-line messages are collapsed to one line — notices are glanceable
  * margin notes, not documents; anything long belongs in the tool result.
  *
- *   warn → yellow  "  ⚠ message"
- *   info → dim     "  · message"
+ * Piece 2 §9: warn → the attention shape ("! message"), info → the info
+ * shape ("· message", dim). Same glyphs as every other notice.
  */
 export function formatNoticeLine(level, message) {
-    const oneLine = message.replace(/\s*\r?\n\s*/g, ' ').trim();
-    if (level === 'warn')
-        return chalk.yellow(`  ⚠ ${oneLine}`) + '\n';
-    return chalk.dim(`  · ${oneLine}`) + '\n';
+    // Live fix 2026-09-26: a SAP HTML error page must never leak tags/CSS here.
+    const readable = looksLikeMarkup(message) ? cleanErrorText(message, 400) : message;
+    let oneLine = readable.replace(/\s*\r?\n\s*/g, ' ').trim();
+    // Live fix 2026-09-26 (panels): never wrap mid-word — cut to one screen
+    // line ("<glyph> " + text ≤ uiWidth) and keep the full text in the
+    // session's notice log. Legacy stays byte-identical.
+    // Review I3: only when a screen is there to wrap (stdout is a TTY) or the
+    // full text has somewhere to go (a notice log). One-shot / piped output
+    // keeps the whole single line — nothing else would record it.
+    // Re-review R3: a one-shot on a terminal has no notice log either, so it
+    // keeps the whole line too.
+    const wrapsOnScreen = process.stdout.isTTY === true && !isDeclaredOneShot();
+    if (getLook() === 'panels' && (wrapsOnScreen || getNoticeLogPath() !== undefined)) {
+        const g = getGlyphs();
+        const room = Math.min(uiWidth(), getEffectiveBodyWidth()) - stringWidth(level === 'warn' ? g.attention : g.info) - 1;
+        const cut = truncateToWidth(oneLine, room);
+        // Review M10: truncateToWidth turns tabs into two spaces — compare against
+        // the same normalisation so only a real cut is logged.
+        if (cut !== oneLine.replace(/\t/g, '  ')) {
+            recordFullNotice(level, message);
+            oneLine = cut;
+        }
+    }
+    return level === 'warn' ? formatAttention({ text: oneLine }) : formatInfo(oneLine);
 }
 /**
  * Build the output emitter for the NON-Ink paths (classic REPL, one-shot).
@@ -55,7 +84,10 @@ export function formatNoticeLine(level, message) {
  *
  * The `write` sink defaults to process.stdout — injectable for tests.
  */
-export function createClassicOutputEmitter(write = (s) => process.stdout.write(s)) {
+export function createClassicOutputEmitter(
+// Panels: through the stdout transcript flow (spacing); legacy: verbatim.
+// Above the classic tool spinner when one is painting (live fix 2026-09-26).
+write = (s) => writeAboveSpinner(s, writeStdout)) {
     const emitter = new EventEmitter();
     emitter.on('chunk', (s) => write(s));
     emitter.on('warn', (msg) => write(formatNoticeLine('warn', msg)));

package/dist/renderer/panel-rows.js

@@ -0,0 +1,16 @@
+// src/renderer/panel-rows.ts
+//
+// Piece 2 §10: every panel-like surface (whoami, /cost, /compact, /ui, /recap,
+// goodbye, help) uses ONE heading style (bold) and dim label / plain value rows.
+// Callers sanitize server- or model-supplied values before passing them in.
+import chalk from 'chalk';
+import { paint } from './theme.js';
+export function panelHeading(title, sub) {
+    return chalk.bold(title) + (sub ? '  ' + paint('dim', sub) : '');
+}
+export function panelRow(label, value, labelWidth = 12) {
+    return '  ' + paint('dim', label.padEnd(labelWidth)) + ' ' + value;
+}
+export function formatPanel(title, rows, sub) {
+    return [panelHeading(title, sub), ...rows];
+}

package/dist/renderer/pipeline.js

@@ -15,6 +15,13 @@ import { WIDGET_CONTROL } from '../ui/widget-control.js'; // NEW IN v0.3
 // kept commented-out as a breadcrumb; the file itself is retained in case
 // any other skill still emits a widget-real block we want to catch.
 import { renderQuestionCard } from './widget-fallback.js'; // NEW IN v0.3.1
+import { ensureGrammars } from './syntax.js'; // 2026-09-26
+import { getLook } from './look.js'; // 2026-09-26 polish
+import { stepFence } from './fence-state.js'; // piece 2 Z1a: one fence rule
+// Register the ABAP/CDS/BDEF/DDL hljs grammars now, exactly when syntax.ts
+// used to self-register (it was loaded through abap-inline.js above), so
+// marked-terminal's fenced blocks in renderMarkdown stay as they were.
+ensureGrammars();
 export function initialBufferState() {
     return { pending: '', fenceCount: 0, widgetBuffer: '', insideWidget: false, orderedListCounter: 0 };
 }
@@ -101,6 +108,17 @@ function renderPassthrough(chunk, state) {
     // markdown.ts / abap-inline.ts (both /^```/m). UNCHANGED FROM v0.1.1.
     const newFencesInChunk = (chunk.match(/^```/gm) || []).length;
     const projectedFenceCount = state.fenceCount + newFencesInChunk;
+    if (getLook() === 'panels') {
+        // Panels: one fence-aware scan decides the flush point (fix round 1).
+        // Pending text only ever starts outside a fence (we never cut inside
+        // one), so scanning it from the start tracks fence state over all the
+        // text emitted so far. The legacy chunk-local ``` count is not used: it
+        // misses ~~~ fences and fences split across chunks.
+        const cut = panelsFlushPoint(combined);
+        state.pending = combined.slice(cut);
+        state.fenceCount = projectedFenceCount;
+        return cut === 0 ? '' : render(combined.slice(0, cut));
+    }
     if (projectedFenceCount % 2 !== 0) {
         // Inside an open fence — hold everything until fence closes.
         state.pending = combined;
@@ -122,6 +140,54 @@ function renderPassthrough(chunk, state) {
     state.fenceCount = projectedFenceCount;
     return '';
 }
+// Panels (P5): a block that starts a list item, and a block indented under one.
+const LIST_ITEM_START_RE = /^ {0,3}(?:\d{1,9}[.)]|[-*+])[ \t]/;
+const LIST_CONTINUATION_RE = /^(?: {2,}|\t)\S/;
+/**
+ * Panels flush point in `text` (index; 0 = flush nothing).
+ *
+ * Candidate cuts are the starts of lines that follow an empty line OUTSIDE a
+ * fenced code block (```…``` or ~~~…~~~, closed by the same character, at
+ * least as long, nothing after it). Only complete lines are scanned. Of the
+ * candidates, the last one is used, then moved back to the start of a
+ * still-open list (P5): the trailing run of blocks that are list items or
+ * indented item bodies is held when it contains a list item. A block is the
+ * text between two candidates, so a "* comment" or "- " line inside a fence
+ * is never seen as a list.
+ */
+function panelsFlushPoint(text) {
+    const cuts = [];
+    let fence;
+    let pos = 0;
+    for (;;) {
+        const nl = text.indexOf('\n', pos);
+        if (nl < 0)
+            break; // last line incomplete: not scanned
+        const line = text.slice(pos, nl);
+        const step = stepFence(fence, line); // shared with the "writing code…" label (fence-state.ts)
+        fence = step.fence;
+        if (!step.consumed && line === '' && pos > 0)
+            cuts.push(nl + 1);
+        pos = nl + 1;
+    }
+    if (cuts.length === 0)
+        return 0;
+    const last = cuts[cuts.length - 1];
+    // Blocks between consecutive cuts (the first starts at 0), up to `last`.
+    const starts = [0, ...cuts.slice(0, -1)];
+    let listStart;
+    for (let i = starts.length - 1; i >= 0; i--) {
+        const block = text.slice(starts[i], i + 1 < starts.length ? starts[i + 1] : last);
+        const firstLine = block.split('\n').find((l) => l.trim() !== '');
+        if (firstLine === undefined)
+            continue; // only blank lines
+        if (LIST_ITEM_START_RE.test(firstLine))
+            listStart = starts[i];
+        else if (!LIST_CONTINUATION_RE.test(firstLine))
+            break;
+    }
+    return listStart ?? last;
+}
 // ────────────────────────────────────────────────────────────────────
 // ORDERED-LIST RENUMBER — NEW
 // Walks rendered output line-by-line and renumbers consecutive ordered

package/dist/renderer/progress-chatter.js

@@ -1,4 +1,7 @@
-import chalk from 'chalk';
+import stringWidth from 'string-width';
+import { paint } from './theme.js';
+import { uiWidth, truncateToWidth } from './ui-width.js';
+import { sanitizeControlChars } from './sanitize.js';
 /**
  * Progress chatter — keeps the tool-widget box alive while a tool runs.
  *
@@ -15,17 +18,28 @@ import chalk from 'chalk';
 const SPINNER_CHARS = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
 const SPINNER_TICK_MS = 80;
 const MESSAGE_ROTATE_MS = 3_000;
-// BOX_WIDTH must match tool-widget.ts — we could import it, but duplicating
-// the const here keeps progress-chatter.ts decoupled from that module's
-// internals and the value is set once across v0.2.
-const BOX_WIDTH = 64;
+// Piece 2 §1.4: the chatter line is as wide as the UI (uiWidth()); the
+// content area is that minus the "│ " and " │" edges.
+const contentWidth = () => Math.max(10, uiWidth() - 4);
+/**
+ * One chatter row, exactly `contentWidth() + 4` cells. The message can carry
+ * a tool arg ({name}), so it is neutralised and pre-cut with string-width
+ * BEFORE colouring: a wide or control-laden name can never widen the row or
+ * drive the terminal.
+ */
+function chatterLine(spinner, message) {
+    const w = contentWidth();
+    const text = truncateToWidth(`${spinner} ${sanitizeControlChars(message)}`, w);
+    const padded = text + ' '.repeat(Math.max(0, w - stringWidth(text)));
+    return paint('frame', '│ ') + paint('sap', padded) + paint('frame', ' │');
+}
 /**
  * Per-tool message pools. Messages may include `{name}` / `{type}` placeholders
  * — substituted from the tool's args at render time. If the arg is absent,
  * the placeholder is dropped together with any surrounding whitespace.
  *
- * Keep messages short (≤ ~50 chars) so they fit inside the widget's
- * BOX_WIDTH content area without truncation.
+ * Keep messages short (≤ ~50 chars) so they fit inside the chatter
+ * content area (uiWidth() − 4) without truncation.
  */
 const MESSAGES = {
     sap_search_object: [
@@ -203,20 +217,12 @@ export function startProgress(params) {
         }
         const spinner = SPINNER_CHARS[spinnerIdx];
         spinnerIdx = (spinnerIdx + 1) % SPINNER_CHARS.length;
-        const raw = `${spinner} ${substituted[messageIdx]}`;
-        const truncated = raw.length > BOX_WIDTH ? raw.slice(0, BOX_WIDTH - 1) + '…' : raw;
-        const padded = truncated.padEnd(BOX_WIDTH);
-        const line = chalk.dim('│ ') + chalk.cyan(padded) + chalk.dim(' │');
+        const line = chatterLine(spinner, substituted[messageIdx]);
         // Cursor-up 1, erase current line, rewrite. Trailing \n puts us back below.
         process.stdout.write(`\x1B[1A\x1B[2K${line}\n`);
     };
     // Paint the initial chatter line (no cursor-up — it occupies a fresh line).
-    const initialSpinner = SPINNER_CHARS[0];
-    const initialRaw = `${initialSpinner} ${substituted[0]}`;
-    const initialTruncated = initialRaw.length > BOX_WIDTH ? initialRaw.slice(0, BOX_WIDTH - 1) + '…' : initialRaw;
-    const initialPadded = initialTruncated.padEnd(BOX_WIDTH);
-    const initialLine = chalk.dim('│ ') + chalk.cyan(initialPadded) + chalk.dim(' │');
-    process.stdout.write(initialLine + '\n');
+    process.stdout.write(chatterLine(SPINNER_CHARS[0], substituted[0]) + '\n');
     const interval = setInterval(render, SPINNER_TICK_MS);
     // Don't keep the event loop alive waiting for this timer.
     interval.unref?.();

package/dist/renderer/rendering-mode.js

@@ -0,0 +1,34 @@
+import { setRenderingOverride, shouldUseInk } from './tty.js';
+import { formatInfo } from './notice-shape.js';
+/** The environment variable that forces the classic renderer for one launch. */
+export const CLASSIC_ENV = 'CSPEACH_UI';
+export const CLASSIC_RETIRING_NOTICE = 'Classic display is retiring · using the standard display';
+export function resolveRenderingMode(stored, env = process.env) {
+    if (env[CLASSIC_ENV]?.trim().toLowerCase() === 'classic') {
+        return { mode: 'classic', storedClassicRetired: false };
+    }
+    if (stored === 'classic')
+        return { mode: 'auto', storedClassicRetired: true };
+    return { mode: stored, storedClassicRetired: false };
+}
+/**
+ * Interactive REPL start: set the rendering override from the config (with the
+ * retiring rule above). When a stored `classic` was overridden AND this launch
+ * really gets Ink, rewrite the stored value to `auto` (best-effort — a failed
+ * save just retries next launch) and return the dim notice to show. Returns
+ * null otherwise.
+ */
+export async function applyStartupRendering(cfg, save) {
+    const r = resolveRenderingMode(cfg.ui.rendering);
+    setRenderingOverride(r.mode);
+    if (!r.storedClassicRetired || !shouldUseInk())
+        return null;
+    cfg.ui.rendering = 'auto';
+    try {
+        await save(cfg);
+    }
+    catch {
+        /* best-effort — the value is still read as auto; the next launch retries */
+    }
+    return formatInfo(CLASSIC_RETIRING_NOTICE);
+}

package/dist/renderer/routing-line.js

@@ -0,0 +1,14 @@
+// src/renderer/routing-line.ts
+//
+// Piece 2 §9: routing chatter is ONE dim line — "· Using /<skill>" when the
+// router picked silently, "· Continuing /<skill>" for a follow-up, and
+// "· Cancelled" when the picker was dismissed. No confidence percentage.
+// formatInfo sanitizes the text, so a skill name cannot drive the terminal.
+import { formatInfo } from './notice-shape.js';
+export function formatRoutingLine(e) {
+    switch (e.kind) {
+        case 'using': return formatInfo(`Using /${e.skill}`);
+        case 'continuing': return formatInfo(`Continuing /${e.skill}`);
+        case 'cancelled': return formatInfo('Cancelled');
+    }
+}

package/dist/renderer/sanitize.js

@@ -0,0 +1,12 @@
+// src/renderer/sanitize.ts
+//
+// Model- or user-supplied text (questions, labels, pasted answers) must not
+// drive the terminal. Every C0/C1 control character except tab and CRLF /
+// LF — a lone \r, ESC, BEL, NUL, DEL, CSI (\x9b) … — becomes a space, so it
+// cannot move the cursor or start an escape sequence. Tabs and newlines are
+// left to the caller (truncateToWidth / trace flattening handle them).
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]|\r(?!\n)/g;
+export function sanitizeControlChars(text) {
+    return text.replace(CONTROL_CHARS, ' ');
+}

package/dist/renderer/severity.js

@@ -1,11 +1,6 @@
 // C:\Users\Admin\ClaudeProjects\ABAPForge\cspeach-cli\src\renderer\severity.ts
-import chalk from 'chalk';
-const PILLS = {
-    CRITICAL: (s) => chalk.bgRedBright.white.bold(s),
-    HIGH: (s) => chalk.bgRed.white(s),
-    MEDIUM: (s) => chalk.bgYellow.black(s),
-    LOW: (s) => chalk.bgGreen.black(s),
-};
+import { LEGACY_SEVERITY_PILLS } from './legacy-palette.js';
+const PILLS = LEGACY_SEVERITY_PILLS;
 const FENCE_RE = /^```/;
 const ANSI_STRIP_RE = /\x1B\[[0-9;]*[mGKHFABCDsuJSTfrl]|\x1B\][^\x07]*\x07/g;
 // A line that is part of a rendered cli-table3 block always starts with one of

package/dist/renderer/startup-lines.js

@@ -0,0 +1,152 @@
+// src/renderer/startup-lines.ts
+//
+// Panels look (2026-09-26, piece 2 §10): exactly three lines (brand + sign-in,
+// status, hint or resume), then one '!' line per thing that needs action.
+// Legacy prints exactly the old lines (kept in repl.tsx). formatPromptEcho's
+// legacy branch is today's string.
+import chalk from 'chalk';
+import stringWidth from 'string-width';
+import { getLook } from './look.js';
+import { paint, BRAND_HEX } from './theme.js';
+import { formatAttention } from './notice-shape.js';
+import { truncateToWidth, uiWidth } from './ui-width.js';
+import { sanitizeControlChars } from './sanitize.js';
+import { holdBrand } from './brand-settled.js';
+export { brandSettled } from './brand-settled.js';
+/** Folder budget on the panels status line (controller ruling R2). */
+const STATUS_PATH_MAX = 20;
+/**
+ * Longest tail of whole path segments, prefixed `…<sep>`, with total length
+ * ≤ max; the path unchanged if it already fits. If even the last segment is
+ * too long, its trailing characters are kept after `…`.
+ */
+export function shortenPath(p, max) {
+    if (p.length <= max)
+        return p;
+    const sep = p.includes('\\') ? '\\' : '/';
+    const parts = p.split(sep).filter((s) => s.length > 0);
+    const last = parts.pop() ?? p;
+    let tail = last;
+    if (1 + sep.length + tail.length > max) {
+        return '…' + last.slice(-(Math.max(1, max - 1)));
+    }
+    while (parts.length > 0) {
+        const next = parts[parts.length - 1] + sep + tail;
+        if (1 + sep.length + next.length > max)
+            break;
+        tail = next;
+        parts.pop();
+    }
+    return `…${sep}${tail}`;
+}
+/** Line 1 of the panels start screen. `signIn` (piece 2 §10) folds the account
+ *  into the brand line, e.g. "signed in as a@b.com · team". */
+export function panelsBrandLine(version, signIn) {
+    return panelsBrandBase(version) + panelsBrandSuffix(version, signIn);
+}
+function panelsBrandBase(version) {
+    return `🍑 ${chalk.hex(BRAND_HEX).bold('CSPeach')} ${paint('dim', 'v' + version)}`;
+}
+/** The part of line 1 after "🍑 CSPeach vX" — empty when there is no sign-in. */
+function panelsBrandSuffix(version, signIn) {
+    if (!signIn)
+        return '';
+    // Line 1 never wraps: the fragment gets what is left of the UI width.
+    const used = stringWidth(`🍑 CSPeach v${version} · `);
+    return paint('dim', ` · ${truncateToWidth(signIn, Math.max(1, uiWidth() - used))}`);
+}
+const processSignals = {
+    once: (ev, h) => { process.once(ev, h); },
+    removeListener: (ev, h) => { process.removeListener(ev, h); },
+    exit: (code) => { process.exit(code); },
+};
+export function startEarlyBrand(p) {
+    const signals = p.signals ?? processSignals;
+    let done = false;
+    let settle;
+    const onSigint = () => {
+        if (done)
+            return;
+        done = true;
+        p.write('\n');
+        settle?.();
+        signals.exit(130);
+    };
+    if (p.tty) {
+        settle = holdBrand();
+        p.write(panelsBrandBase(p.version));
+        signals.once('SIGINT', onSigint);
+    }
+    const end = (text) => {
+        if (done)
+            return;
+        done = true;
+        if (p.tty)
+            signals.removeListener('SIGINT', onSigint);
+        if (text)
+            p.write(text);
+        settle?.();
+    };
+    return {
+        finish(signIn) {
+            end((p.tty ? panelsBrandSuffix(p.version, signIn) : panelsBrandLine(p.version, signIn)) + '\n');
+        },
+        close() {
+            end(p.tty ? '\n' : '');
+        },
+    };
+}
+/**
+ * The dim note saying where the SAP system came from (--sap-alias flag, or
+ * the resumed session). Legacy only: the panels status line already shows
+ * the system, and a 4th line would break §10's three-line screen.
+ */
+export function aliasSourceNote(source, alias) {
+    if (getLook() === 'panels')
+        return null;
+    return source === 'flag' ? chalk.dim(`Using --sap-alias ${alias}`) : chalk.dim(`Resumed on SAP ${alias}`);
+}
+export function panelsStatusLine(p) {
+    const segs = [p.standalone ? paint('dim', 'standalone (no SAP system)') : paint('sap', p.system)];
+    if (p.tools === 'files+commands')
+        segs.push(paint('warn', 'local files + commands on'));
+    else if (p.tools === 'files')
+        segs.push(paint('dim', 'files → cspeach-out'));
+    if (p.writeMode !== undefined && p.writeMode !== 'approval-gated' && p.writeMode !== 'advisory-only') {
+        segs.push(paint('warn', `writes: ${p.writeMode}`));
+    }
+    segs.push(paint('dim', shortenPath(p.cwd, STATUS_PATH_MAX)));
+    return '   ' + segs.join(paint('dim', ' · '));
+}
+/** Line 3 of the panels start screen (non-resume). */
+export function panelsHintLine(tools) {
+    const text = tools === 'files+commands'
+        ? 'turn off commands: cspeach config set local_build off · ? for shortcuts'
+        : '? for shortcuts · /help for commands';
+    return '   ' + paint('dim', text);
+}
+/** Line 3 of the panels start screen on --resume: the recap's "last session" fact.
+ *  The fact quotes the user's last prompt, so control characters are neutralised. */
+export function panelsResumeLine(last, priorTurns) {
+    const fact = last ?? `${priorTurns} prior turn${priorTurns === 1 ? '' : 's'}`;
+    return '   ' + paint('dim', truncateToWidth(sanitizeControlChars(`resumed · ${fact}`), Math.max(20, uiWidth() - 3)));
+}
+/** A "!" line for the start screen (no Next: line → exactly one line). */
+export function panelsInterruptedNote(n) {
+    return formatAttention({ text: `${n} unfinished session${n === 1 ? '' : 's'}`, fact: 'cspeach --resume' }).trimEnd();
+}
+/**
+ * Lines 2-3 of the panels start screen, then — only when something needs
+ * action — a blank line and one "!" notice per item (each already ends '\n').
+ * Always ends with one blank line before the input.
+ */
+export function panelsStartTail(p) {
+    const head = `${panelsStatusLine(p.status)}\n${p.third}\n`;
+    return p.notices.length === 0 ? head + '\n' : head + '\n' + p.notices.join('') + '\n';
+}
+export function formatPromptEcho(text, width) {
+    if (getLook() !== 'panels') {
+        return chalk.dim('\n──────────────────────────────────\n') + chalk.cyan(`› ${text}\n`);
+    }
+    return '\n' + paint('frame', '─'.repeat(Math.min(60, Math.max(20, width - 4)))) + '\n' + paint('dim', 'you ›') + ` ${text}\n`;
+}

package/dist/renderer/status-footer.js

@@ -1,8 +1,10 @@
-import chalk from 'chalk';
 import { formatCost } from '../cost/pricing.js';
 import { creditsActive, formatCreditsLine, CREDITS_PENDING } from '../cost/credits.js';
-const RULE_WIDTH = 72;
-const RULE = chalk.dim('─'.repeat(RULE_WIDTH));
+import { formatTurnReceipt, turnSpendText } from './footer-line.js';
+import { formatAttention } from './notice-shape.js';
+import { paint } from './theme.js';
+import { uiWidth } from './ui-width.js';
+import { getBoxChars } from '../ui/ascii-chars.js';
 /**
  * Phase 2 (2026-05-16) — when a session crosses this much non-cached input,
  * we nudge the user to /compact. Threshold is "feel right" — tuned to fire
@@ -13,9 +15,9 @@ export const LARGE_SESSION_THRESHOLD = 100_000;
 /**
  * Prints a status footer after each turn ends.
  *
- * Format (spec §3.7, v0.2 — cost-free variant):
+ * Format (piece 2 restyle — rules span uiWidth()):
  *   ────────────────────────────────────────────────────────────────────
- *    session 870ed8cc │ S4H-DEV │ /abap-radar │ 3 turns │ 6,533 tok this turn │ 2,100 cached │ 4.2s
+ *    session 870ed8cc · S4H-DEV · /abap-radar · 3 turns · 6,533 tok this turn · $0.12 · 2,100 cached · session: $0.54 · 4.2s
  *   ────────────────────────────────────────────────────────────────────
  *
  * H1 — `tokens` is the per-turn delta (input + output consumed THIS turn),
@@ -34,6 +36,20 @@ export const LARGE_SESSION_THRESHOLD = 100_000;
  * v0.3 transition: this chalk status-footer-after-turn is replaced (not
  * augmented) by the Ink persistent footer region in Plan 4c.
  */
+/**
+ * The "session getting large" notice (piece 2, spec §8/§9) — a `!` attention
+ * line with the /compact next step. '' below LARGE_SESSION_THRESHOLD or when
+ * the caller passed no count.
+ */
+export function largeSessionNotice(sessionInputTokens) {
+    if (sessionInputTokens == null || sessionInputTokens < LARGE_SESSION_THRESHOLD)
+        return '';
+    return formatAttention({
+        text: 'session getting large',
+        fact: `${sessionInputTokens.toLocaleString('en-US')} input tokens`,
+        next: 'type /compact to summarise older turns, or /exit and start fresh for a new topic',
+    });
+}
 /**
  * Format the status footer as a single string (with embedded newlines).
  * Pulled out from `printStatusFooter` so the Ink path can route the
@@ -42,6 +58,16 @@ export const LARGE_SESSION_THRESHOLD = 100_000;
  */
 export function formatStatusFooter(params) {
     const { sessionId, sapAlias, skill, turnCount, tokens, cachedTokens, elapsedMs, costThisTurn, costSession, sessionInputTokens, variant, credits } = params;
+    // Piece 2 (spec §8) — Ink per-turn receipt: ONE dim line, this turn only.
+    // The session total and balance live in the footer line now.
+    if (variant === 'turn') {
+        return formatTurnReceipt({
+            skill,
+            tokens,
+            spend: turnSpendText({ costThisTurn, credits }),
+            ms: elapsedMs,
+        }) + '\n' + largeSessionNotice(sessionInputTokens);
+    }
     const shortSession = sessionId.slice(0, 8);
     const skillDisplay = skill.startsWith('/') ? skill : `/${skill}`;
     const turns = `${turnCount} turn${turnCount === 1 ? '' : 's'}`;
@@ -50,8 +76,7 @@ export function formatStatusFooter(params) {
     const elapsed = elapsedMs > 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : '';
     // Credits mode: the whole spend story collapses into ONE customer-facing
     // segment (turn · session · balance) in place of the two dollar segments.
-    // Both variants read `costTurnStr`, so putting the combined line there
-    // covers the slim Ink receipt and the full classic receipt alike.
+    // (Classic receipt only — the Ink 'turn' variant returned above.)
     const inCredits = creditsActive();
     const costTurnStr = inCredits
         ? (credits ? formatCreditsLine(credits) : CREDITS_PENDING)
@@ -59,33 +84,26 @@ export function formatStatusFooter(params) {
     const costSessStr = inCredits
         ? ''
         : (costSession != null ? `session: ${formatCost(costSession)}` : '');
-    // Ink turn-receipt (see the variant doc on StatusFooterParams):
-    // turn-only facts — everything session-scoped lives in <StatusLine />.
-    const parts = variant === 'turn'
-        ? [
-            chalk.dim(skillDisplay),
-            chalk.dim(turns),
-            chalk.dim(tokStr),
-            ...(costTurnStr ? [chalk.dim(costTurnStr)] : []),
-            ...(elapsed ? [chalk.dim(elapsed)] : []),
-        ]
-        : [
-            chalk.dim(`session ${shortSession}`),
-            chalk.dim(sapAlias),
-            chalk.dim(skillDisplay),
-            chalk.dim(turns),
-            chalk.dim(tokStr),
-            ...(costTurnStr ? [chalk.dim(costTurnStr)] : []),
-            ...(cachedStr ? [chalk.dim(cachedStr)] : []),
-            ...(costSessStr ? [chalk.dim(costSessStr)] : []),
-            ...(elapsed ? [chalk.dim(elapsed)] : []),
-        ];
-    const lines = ['', RULE, ' ' + parts.join(chalk.dim(' │ '))];
-    if (sessionInputTokens != null && sessionInputTokens >= LARGE_SESSION_THRESHOLD) {
-        lines.push(' ' + chalk.yellow(`⚠  session getting large (${sessionInputTokens.toLocaleString()} input tokens)`
-            + ` — type /compact to summarise older turns, or /exit + cspeach (fresh) for a new topic`));
-    }
-    lines.push(RULE, '');
+    // Classic full receipt (piece 2 restyle — same facts, reviewed pin):
+    // rules at uiWidth() in the frame role, ' · ' separators, the large-session
+    // advisory as a `!` notice (largeSessionNotice).
+    const parts = [
+        `session ${shortSession}`,
+        sapAlias,
+        skillDisplay,
+        turns,
+        tokStr,
+        ...(costTurnStr ? [costTurnStr] : []),
+        ...(cachedStr ? [cachedStr] : []),
+        ...(costSessStr ? [costSessStr] : []),
+        ...(elapsed ? [elapsed] : []),
+    ];
+    const rule = paint('frame', getBoxChars().h.repeat(uiWidth()));
+    const lines = ['', rule, ' ' + paint('dim', parts.join(' · '))];
+    const notice = largeSessionNotice(sessionInputTokens);
+    if (notice)
+        lines.push(notice.replace(/\n$/, ''));
+    lines.push(rule, '');
     return lines.join('\n');
 }
 export function printStatusFooter(params) {

package/dist/renderer/steering-echo.js

@@ -0,0 +1,41 @@
+// src/renderer/steering-echo.ts
+//
+// The receipt a mid-turn message leaves in scrollback (spec §7). ONE themed
+// helper for both echo paths: App.beginSubmit (ui/app.tsx) and the fallback
+// in repl.tsx handleSubmit for callers that bypass beginSubmit.
+import { paint } from './theme.js';
+import { sanitizeControlChars } from './sanitize.js';
+/** Wave1 fast-follow — only the first line, clipped, with a line count. */
+export const STEERING_ECHO_MAX = 60;
+export function formatSteeringEcho(text) {
+    const lines = text.split('\n');
+    const first = lines[0] ?? '';
+    const extra = lines.length - 1;
+    const clipped = first.length > STEERING_ECHO_MAX;
+    let out = clipped ? first.slice(0, STEERING_ECHO_MAX) : first;
+    if (clipped || extra > 0)
+        out += '…';
+    if (extra > 0)
+        out += ` (+${extra} line${extra === 1 ? '' : 's'})`;
+    return out;
+}
+/**
+ * `↳ queued · <first line…>` in the dim role, newline-terminated. The text may
+ * come from a paste, so control characters are neutralised before it reaches
+ * scrollback.
+ */
+export function steeringEchoLine(text) {
+    return paint('dim', `↳ queued · ${sanitizeControlChars(formatSteeringEcho(text))}`) + '\n';
+}
+export function classifyMidTurnLine(text) {
+    const first = text.trim().split(/\s+/)[0] ?? '';
+    if (first === '/exit' || first === '/quit')
+        return { kind: 'exit' };
+    if (/^\/[A-Za-z][\w-]*$/.test(first))
+        return { kind: 'slash', command: first };
+    return { kind: 'steer' };
+}
+/** The one-line hint for a slash command typed mid-turn (dim, newline-terminated). */
+export function midTurnSlashHint(command) {
+    return paint('dim', `↳ ${sanitizeControlChars(command)} runs after this turn · press Enter when it ends`) + '\n';
+}