@cspeach/cli 1.1.18 → 1.1.19

package/dist/renderer/legacy-palette.js

@@ -0,0 +1,41 @@
+// src/renderer/legacy-palette.ts
+//
+// FROZEN legacy colours (CLI look piece 2, 2026-09-26, spec §1.1). These are
+// the literal colours the legacy look uses today, byte for byte. They are
+// pinned by test/unit/legacy-look-pin.test.ts, legacy-look-pin-production
+// .test.ts and legacy-palette-move-pin.test.ts. Nothing new may use them:
+// panels and new surfaces paint through theme roles (theme.ts / role-props.ts).
+// This file is deleted when the legacy look retires (release N+1).
+import chalk from 'chalk';
+import { colorOff } from './color-mode.js';
+/** Was banners.ts PEACH: brand name, ⏺/⎿ glyphs, spinner, todo block, approvals. */
+export const LEGACY_PEACH = '#FFCBA4';
+/** Was markdown.ts PEACH: legacy first heading + bold. */
+export const LEGACY_MD_PEACH = '#FFB88C';
+/** Was renderer/severity.ts PILLS. */
+export const LEGACY_SEVERITY_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),
+};
+/** Was the cyan / white / peach literals in markdown.ts's legacy markedTerminal options. */
+export const LEGACY_MD_STYLES = {
+    heading: chalk.cyan.bold,
+    firstHeading: chalk.hex(LEGACY_MD_PEACH).bold,
+    strong: chalk.bold.hex(LEGACY_MD_PEACH),
+    codespan: chalk.bgGray.white,
+    listitem: chalk.white,
+    paragraph: chalk.white,
+};
+/** Was markdown.ts buildTable's cli-table3 style. Fresh object per call (cli-table3 may mutate). */
+export function legacyTableStyle() {
+    return { head: ['cyan', 'bold'], border: ['gray'] };
+}
+/** Was markdown.ts ZEBRA_BG / ZEBRA_RESET (256-colour dark gray stripe). */
+export const LEGACY_ZEBRA_BG = '\x1b[48;5;235m';
+export const LEGACY_ZEBRA_RESET = '\x1b[49m';
+export function legacyZebra(s) {
+    // NO_COLOR / level 0: no background stripe (applyZebraBg then leaves the row untouched).
+    return colorOff() ? s : LEGACY_ZEBRA_BG + s + LEGACY_ZEBRA_RESET;
+}

package/dist/renderer/look.js

@@ -0,0 +1,30 @@
+// src/renderer/look.ts
+//
+// CLI look (2026-09-26, spec docs/superpowers/specs/2026-09-26-cli-look-piece1-design.md).
+// 'panels' = the new look (config default); 'legacy' = today's output, byte for
+// byte. The MODULE fallback is 'legacy' so any caller or test that never sets a
+// look is unchanged; the REPL and one-shot set it from config at startup.
+let look = 'legacy';
+let background;
+export function getLook() {
+    return look;
+}
+export function setLook(next) {
+    look = next;
+}
+/** COLORFGBG is "fg;bg" (some terminals add a middle field). bg 7 / 15 = light. */
+export function backgroundFromColorFgBg(v) {
+    if (!v)
+        return undefined;
+    const last = v.split(';').pop();
+    if (last === undefined || !/^\d+$/.test(last))
+        return undefined;
+    const bg = Number(last);
+    return bg === 7 || bg === 15 ? 'light' : 'dark';
+}
+export function getBackground() {
+    return background ?? backgroundFromColorFgBg(process.env['COLORFGBG']) ?? 'dark';
+}
+export function setBackground(bg) {
+    background = bg;
+}

package/dist/renderer/markdown.js

@@ -8,16 +8,24 @@
  * and `image(href, title, text)`; every other key is a wrapper applied to the
  * already-rendered text.
  *
- * We cannot distinguish h1/h2/h3/h4 with a single chalk function, so we pick one
- * styling for all heading levels — terminal output rarely needs a level hierarchy.
+ * Legacy look: marked-terminal's `heading` is a single chalk function, so all
+ * heading levels share one style (plus `firstHeading`), with "#" prefixes.
+ * Panels look: a separate Marked instance (bottom of this file) overrides
+ * `heading` and distinguishes levels, without "#" prefixes.
  */
 import chalk from 'chalk';
-import { marked } from 'marked';
+import { marked, Marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import Table from 'cli-table3';
+import { highlight as cliHighlight, supportsLanguage } from 'cli-highlight';
 import { applySeverityToCell } from './severity.js';
 import { getEffectiveBodyWidth } from './tty.js';
-const PEACH = '#FFB88C';
+import { getLook, getBackground } from './look.js';
+import { paint } from './theme.js';
+import { highlightFencedBody } from './abap-inline.js';
+import { getBoxChars } from '../ui/ascii-chars.js';
+import { LEGACY_MD_STYLES, legacyTableStyle, legacyZebra } from './legacy-palette.js';
+import { colorOff, tableStyle } from './color-mode.js';
 // marked-terminal uses these sentinels internally. We parse them back out to
 // rebuild a width-capped cli-table3 in our table renderer override below.
 // Source: node_modules/marked-terminal/index.js lines 10-15.
@@ -111,24 +119,24 @@ function computeColWidths(naturalContentWidths, minContentWidths, termWidth) {
 // is resized mid-session the wrap will be slightly off but still word-safe.
 const PROSE_WIDTH = Math.max(60, (process.stdout.columns || 100) - 2);
 marked.use(markedTerminal({
-    heading: chalk.cyan.bold,
-    firstHeading: chalk.hex(PEACH).bold,
+    heading: LEGACY_MD_STYLES.heading,
+    firstHeading: LEGACY_MD_STYLES.firstHeading,
     // `strong` (markdown bold via `**...**`) was previously plain `chalk.bold`,
     // which emits only `[1m`. On many terminals — and inside Ink's default
     // <Text> wrap — bold weight on white text is visually indistinguishable
     // from normal-weight white. Pair bold with the peach brand colour so
     // labels like `**Headline:**` stand out even when bold weight isn't
     // rendered strongly. Cheap, safe, and consistent with firstHeading.
-    strong: chalk.bold.hex(PEACH),
+    strong: LEGACY_MD_STYLES.strong,
     em: chalk.italic,
-    codespan: chalk.bgGray.white,
+    codespan: LEGACY_MD_STYLES.codespan,
     code: chalk.gray,
     blockquote: chalk.gray.italic,
     link: chalk.blue.underline,
     href: chalk.blue.underline,
-    listitem: chalk.white,
+    listitem: LEGACY_MD_STYLES.listitem,
     hr: chalk.gray,
-    paragraph: chalk.white,
+    paragraph: LEGACY_MD_STYLES.paragraph,
     // Enable reflow so paragraphs and list items wrap at WORD boundaries at
     // the configured width, and continuation lines of list items align under
     // the bullet content (not at column 0). Without this, marked-terminal
@@ -147,81 +155,89 @@ marked.use(markedTerminal({
 marked.use({
     renderer: {
         table(header, body) {
-            const headerRow = parseMtTableRows(header)[0] ?? [];
-            const rawBodyRows = parseMtTableRows(body);
-            if (headerRow.length === 0)
-                return `${header}${body}\n\n`;
-            // Apply severity pills to EACH CELL before cli-table3 sees them. If we
-            // left severity for the outer pipeline (applySeverity after markdown),
-            // it would wrap "HIGH" (4 chars) with " HIGH " (6 visible chars) AFTER
-            // cli-table3 had already allocated a 4-char column — the extra 2 chars
-            // then push the next `│` border right and break every following row's
-            // alignment. Applying here keeps visible widths correct via string-width.
-            const bodyRows = rawBodyRows.map((row) => row.map((c) => applySeverityToCell(c)));
-            // Natural content width per column (stripped of ANSI escapes) AND
-            // minimum word width per column (so wrap points never cut mid-word).
-            const colCount = headerRow.length;
-            const naturalWidths = new Array(colCount).fill(0);
-            const minWidths = new Array(colCount).fill(1);
-            for (const row of [headerRow, ...bodyRows]) {
-                for (let i = 0; i < colCount; i++) {
-                    const content = row[i] ?? '';
-                    const visible = stripAnsi(content);
-                    if (visible.length > naturalWidths[i])
-                        naturalWidths[i] = visible.length;
-                    // Longest whitespace-separated token — the minimum column width that
-                    // wordWrap can respect without mid-word breakage.
-                    for (const word of visible.split(/\s+/)) {
-                        if (word.length > minWidths[i])
-                            minWidths[i] = word.length;
-                    }
-                }
-            }
-            // Phase A #2 (2026-05-16) — was `process.stdout.columns || 120` which
-            // over-allocated in Ink mode: the Body sits next to a 30-col Sidebar,
-            // so tables sized for full terminal width wrapped inside Body and
-            // bled into the Sidebar visually. getEffectiveBodyWidth() returns
-            // `cols − sidebar − border` under Ink and the full width under classic.
-            const termWidth = getEffectiveBodyWidth();
-            const colWidths = computeColWidths(naturalWidths, minWidths, termWidth);
-            // Decide whether row separators are needed. When every row fits on one
-            // visual line we suppress them (avoids stairstep on small tables, see
-            // earlier comment). When ANY row will wrap (some cell content exceeds
-            // its allocated column width), the wrap line otherwise looks like a
-            // separate empty row to the reader — so re-enable thin separators
-            // between body rows. The header/body separator is suppressed in both
-            // cases (the cyan-bold header colour already separates them visually).
-            let anyRowWraps = false;
-            for (const row of bodyRows) {
-                for (let i = 0; i < colCount; i++) {
-                    const visible = stripAnsi(row[i] ?? '');
-                    // colWidths[i] = content width + 2 padding. Wrap happens when the
-                    // visible content exceeds the content width (colWidths[i] - 2).
-                    if (visible.length > (colWidths[i] - 2)) {
-                        anyRowWraps = true;
-                        break;
-                    }
-                }
-                if (anyRowWraps)
-                    break;
-            }
-            const tableChars = anyRowWraps
-                ? {} // default chars — keeps `mid: ─` so wrapped rows have separators
-                : { mid: '', 'left-mid': '', 'mid-mid': '', 'right-mid': '' };
-            const table = new Table({
-                head: headerRow,
-                colWidths,
-                wordWrap: true,
-                wrapOnWordBoundary: true,
-                style: { head: ['cyan', 'bold'], border: ['gray'] },
-                chars: tableChars,
-            });
-            for (const row of bodyRows)
-                table.push(row);
-            return zebraStripe(table.toString()) + '\n\n';
+            return buildTable(header, body, legacyZebra);
         },
     },
 });
+/**
+ * Shared table builder (legacy + panels). `zebra` wraps a striped body row in
+ * its background; the legacy look passes the fixed 256-colour dark gray, the
+ * panels look a theme colour that follows the terminal background.
+ */
+function buildTable(header, body, zebra) {
+    const headerRow = parseMtTableRows(header)[0] ?? [];
+    const rawBodyRows = parseMtTableRows(body);
+    if (headerRow.length === 0)
+        return `${header}${body}\n\n`;
+    // Apply severity pills to EACH CELL before cli-table3 sees them. If we
+    // left severity for the outer pipeline (applySeverity after markdown),
+    // it would wrap "HIGH" (4 chars) with " HIGH " (6 visible chars) AFTER
+    // cli-table3 had already allocated a 4-char column — the extra 2 chars
+    // then push the next `│` border right and break every following row's
+    // alignment. Applying here keeps visible widths correct via string-width.
+    const bodyRows = rawBodyRows.map((row) => row.map((c) => applySeverityToCell(c)));
+    // Natural content width per column (stripped of ANSI escapes) AND
+    // minimum word width per column (so wrap points never cut mid-word).
+    const colCount = headerRow.length;
+    const naturalWidths = new Array(colCount).fill(0);
+    const minWidths = new Array(colCount).fill(1);
+    for (const row of [headerRow, ...bodyRows]) {
+        for (let i = 0; i < colCount; i++) {
+            const content = row[i] ?? '';
+            const visible = stripAnsi(content);
+            if (visible.length > naturalWidths[i])
+                naturalWidths[i] = visible.length;
+            // Longest whitespace-separated token — the minimum column width that
+            // wordWrap can respect without mid-word breakage.
+            for (const word of visible.split(/\s+/)) {
+                if (word.length > minWidths[i])
+                    minWidths[i] = word.length;
+            }
+        }
+    }
+    // Phase A #2 (2026-05-16) — was `process.stdout.columns || 120` which
+    // over-allocated in Ink mode: the Body sits next to a 30-col Sidebar,
+    // so tables sized for full terminal width wrapped inside Body and
+    // bled into the Sidebar visually. getEffectiveBodyWidth() returns
+    // `cols − sidebar − border` under Ink and the full width under classic.
+    const termWidth = getEffectiveBodyWidth();
+    const colWidths = computeColWidths(naturalWidths, minWidths, termWidth);
+    // Decide whether row separators are needed. When every row fits on one
+    // visual line we suppress them (avoids stairstep on small tables, see
+    // earlier comment). When ANY row will wrap (some cell content exceeds
+    // its allocated column width), the wrap line otherwise looks like a
+    // separate empty row to the reader — so re-enable thin separators
+    // between body rows. The header/body separator is suppressed in both
+    // cases (the cyan-bold header colour already separates them visually).
+    let anyRowWraps = false;
+    for (const row of bodyRows) {
+        for (let i = 0; i < colCount; i++) {
+            const visible = stripAnsi(row[i] ?? '');
+            // colWidths[i] = content width + 2 padding. Wrap happens when the
+            // visible content exceeds the content width (colWidths[i] - 2).
+            if (visible.length > (colWidths[i] - 2)) {
+                anyRowWraps = true;
+                break;
+            }
+        }
+        if (anyRowWraps)
+            break;
+    }
+    const tableChars = anyRowWraps
+        ? {} // default chars — keeps `mid: ─` so wrapped rows have separators
+        : { mid: '', 'left-mid': '', 'mid-mid': '', 'right-mid': '' };
+    const table = new Table({
+        head: headerRow,
+        colWidths,
+        wordWrap: true,
+        wrapOnWordBoundary: true,
+        style: tableStyle(legacyTableStyle()),
+        chars: tableChars,
+    });
+    for (const row of bodyRows)
+        table.push(row);
+    return zebraStripe(table.toString(), zebra) + '\n\n';
+}
 /**
  * Apply subtle dark-gray background to every other body row.
  *
@@ -235,21 +251,25 @@ marked.use({
  *   - A body line is a NEW row start when the first column (between the first
  *     two `│` chars) contains non-whitespace (cli-table3 pads continuation
  *     lines of multi-line cells with whitespace in non-wrapping columns).
- *   - Odd row indices get wrapped with `\x1b[48;5;235m … \x1b[49m`. Mid-line
- *     bg-resets (e.g. when a severity pill's `\x1b[49m` ends) are rewritten
+ *   - Odd row indices get wrapped in the zebra background (legacy look:
+ *     LEGACY_ZEBRA_BG … LEGACY_ZEBRA_RESET). Mid-line background resets
+ *     (e.g. when a severity pill's background ends) are rewritten
  *     to re-apply the zebra bg so the reset doesn't punch a hole after the pill.
  */
-const ZEBRA_BG = '\x1b[48;5;235m'; // dark gray — subtle but visible
-const ZEBRA_RESET = '\x1b[49m';
-function applyZebraBg(line) {
+function applyZebraBg(line, zebra) {
+    // Split the zebra wrapper into its open/close codes (a NUL probe never
+    // occurs in table text). With colour off both are empty → line unchanged.
+    const [open = '', close = ''] = zebra('\0').split('\0');
+    if (open === '')
+        return line;
     // Re-apply zebra bg after any in-line bg-reset or full-reset so the stripe
     // survives through severity pills and inline-code spans.
     const reZebraed = line
-        .replace(/\x1B\[49m/g, ZEBRA_BG)
-        .replace(/\x1B\[0m/g, '\x1B[0m' + ZEBRA_BG);
-    return ZEBRA_BG + reZebraed + ZEBRA_RESET;
+        .replace(/\x1B\[49m/g, open)
+        .replace(/\x1B\[0m/g, '\x1B[0m' + open);
+    return open + reZebraed + close;
 }
-function zebraStripe(tableText) {
+function zebraStripe(tableText, zebra) {
     const lines = tableText.split('\n');
     const result = [];
     let sawTop = false;
@@ -279,7 +299,7 @@ function zebraStripe(tableText) {
             if (firstCellTrimmed !== '')
                 rowIndex++;
             if (rowIndex >= 0 && rowIndex % 2 === 1) {
-                result.push(applyZebraBg(line));
+                result.push(applyZebraBg(line, zebra));
             }
             else {
                 result.push(line);
@@ -291,7 +311,194 @@ function zebraStripe(tableText) {
     }
     return result.join('\n');
 }
+/** Panels table: legacy layout, zebra stripe that follows the terminal background. */
+function panelsTable(header, body) {
+    const zebra = getBackground() === 'light'
+        ? (s) => chalk.bgHex('#E8EEF5')(s)
+        : (s) => chalk.bgHex('#1B2530')(s);
+    return buildTable(header, body, zebra);
+}
+/**
+ * Panels code-block body: CSPeach's own ABAP/CDS/BDEF/DDL highlighting first;
+ * otherwise cli-highlight for languages it knows (json, sql, js … as in
+ * legacy); otherwise plain gray. supportsLanguage() is checked first so an
+ * unknown language never prints cli-highlight's "Could not find the
+ * language" stderr noise.
+ */
+function panelsCodeBody(code, info) {
+    const lang = (info ?? '').trim().split(/\s+/)[0] ?? '';
+    const ours = highlightFencedBody(code, lang);
+    if (ours !== undefined)
+        return ours;
+    if (lang !== '' && !colorOff() && supportsLanguage(lang)) {
+        try {
+            return cliHighlight(code, { language: lang, ignoreIllegals: true });
+        }
+        catch {
+            // Grammar error must never surface — fall through to plain gray.
+        }
+    }
+    return chalk.gray(code);
+}
+// Panels look (2026-09-26): a SEPARATE Marked instance so the legacy global
+// configuration above stays byte-identical. Differences: no "#" prefixes and a
+// real heading hierarchy, plain bold, CSPeach's own ABAP/CDS/BDEF colouring
+// inside code blocks, zebra stripe that follows the terminal background.
+//
+// Polish wave (P6): marked-terminal's reflow runs at a width no line reaches,
+// so it only joins soft line breaks; the real wrapping is wrapPanels() below,
+// at the CURRENT body width (not a module-load snapshot), and it never breaks
+// between "(" and a coloured word, before a closing bracket, or strands a
+// single punctuation character.
+const PANELS_REFLOW_WIDTH = 100_000;
+const panelsExt = markedTerminal({
+    showSectionPrefix: false,
+    heading: chalk.bold,
+    firstHeading: chalk.bold,
+    strong: chalk.bold,
+    em: chalk.italic,
+    codespan: (s) => paint('sap', s),
+    code: chalk.gray,
+    blockquote: chalk.gray.italic,
+    link: chalk.underline,
+    href: chalk.underline,
+    listitem: (s) => s,
+    hr: (s) => paint('frame', s),
+    paragraph: (s) => s,
+    reflowText: true,
+    width: PANELS_REFLOW_WIDTH,
+});
+const panelsMarked = new Marked();
+panelsMarked.use(panelsExt);
+panelsMarked.use({
+    renderer: {
+        heading(raw, level) {
+            // Round 7 item 6 — marked hands the heading text HTML-escaped
+            // (&quot; &amp; …); unescape it like body text (marked-terminal's
+            // own heading does this; this override skipped it).
+            const text = mtTransform(raw);
+            const t = level === 1 ? paint('sap', chalk.bold(text)) : level === 2 ? chalk.bold(text) : paint('dim', chalk.bold(text));
+            return `\n${t}\n\n`;
+        },
+        code(code, lang) {
+            const body = panelsCodeBody(code, lang);
+            const bar = paint('frame', '│');
+            return '\n' + body.split('\n').map((l) => `  ${bar} ${l}`).join('\n') + '\n\n';
+        },
+        table: panelsTable,
+        // P5: marked-terminal numbers every list from 1 and ignores marked's
+        // `start`, so a list that resumes after a paragraph restarted at "1.".
+        list(body, ordered, start) {
+            const out = panelsExt.renderer.list.call(this, body, ordered);
+            const first = typeof start === 'number' ? start : 1;
+            if (!ordered || first === 1)
+                return out;
+            return out.replace(/^( {4})(\d+)\. /gm, (_m, ind, n) => `${ind}${Number(n) + first - 1}. `);
+        },
+        hr() {
+            return paint('frame', getBoxChars().h.repeat(panelsProseWidth())) + '\n\n';
+        },
+    },
+});
+/** Panels prose width: the live body width (Ink: minus its border), 2 columns of margin like legacy. */
+function panelsProseWidth() {
+    return Math.max(20, getEffectiveBodyWidth() - 2);
+}
+// eslint-disable-next-line no-control-regex
+const SGR_RE = /\x1b\[[0-9;]*m/g;
+const visibleWidth = (s) => s.replace(ANSI_RE, '').length;
+/** Opening brackets/quotes that must stay with the NEXT word. */
+const OPENERS_ONLY = /^[([{“‘«]+$/;
+/** Closing brackets and punctuation that must stay with the PREVIOUS word. */
+const CLOSERS_ONLY = /^[)\]}”’».,;:!?…]+$/;
+/** Lines wrapWord must never touch: tables, code bars, rules, widget controls. */
+const NO_WRAP = /^\s*[│┌└├┬┴┼╭╰─|+]/;
+/**
+ * Word-wrap one rendered line to `width` visible columns. Breaks only at
+ * spaces; ANSI codes are zero-width and stay attached to their word; opening
+ * brackets glue forward and closing punctuation glues back; continuation
+ * lines hang under the text (list items: under the text after "1. ").
+ * Styles are closed at a break and re-opened after the indent, so an
+ * underline never runs into the indentation.
+ */
+function wrapLine(line, width) {
+    const plain = line.replace(ANSI_RE, '');
+    if (plain.length <= width || NO_WRAP.test(plain) || line.includes('\u0000'))
+        return [line];
+    // Prefix = everything before the first visible non-space character.
+    let i = 0;
+    while (i < line.length) {
+        if (line[i] === '\x1b') {
+            const m = /^\x1b\[[0-9;?]*[ -/]*[@-~]/.exec(line.slice(i));
+            if (m) {
+                i += m[0].length;
+                continue;
+            }
+        }
+        if (line[i] === ' ') {
+            i++;
+            continue;
+        }
+        break;
+    }
+    const prefix = line.slice(0, i);
+    const indent = visibleWidth(prefix);
+    const marker = /^(\d+\.|[*•-]) /.exec(plain.slice(indent));
+    let hang = indent + (marker ? marker[0].length : 0);
+    if (hang > width / 2)
+        hang = 0;
+    // Units: words, with openers glued forward and closers glued back.
+    const words = line.slice(i).split(' ').filter((w) => w !== '');
+    const units = [];
+    let glueNext = false;
+    for (const w of words) {
+        const vis = w.replace(ANSI_RE, '');
+        if (units.length > 0 && (glueNext || vis === '' || CLOSERS_ONLY.test(vis))) {
+            units[units.length - 1] += ' ' + w;
+        }
+        else {
+            units.push(w);
+        }
+        glueNext = OPENERS_ONLY.test(vis);
+    }
+    const out = [];
+    let cur = prefix + (units[0] ?? '');
+    let curW = indent + visibleWidth(units[0] ?? '');
+    let active = [];
+    const track = (s) => {
+        for (const code of s.match(SGR_RE) ?? []) {
+            if (code === '\x1b[0m' || code === '\x1b[m')
+                active = [];
+            else
+                active.push(code);
+        }
+    };
+    track(cur);
+    for (const u of units.slice(1)) {
+        const w = visibleWidth(u);
+        if (curW + 1 + w <= width) {
+            cur += ' ' + u;
+            curW += 1 + w;
+        }
+        else {
+            out.push(active.length > 0 ? cur + '\x1b[0m' : cur);
+            cur = ' '.repeat(hang) + active.join('') + u;
+            curW = hang + w;
+        }
+        track(u);
+    }
+    out.push(cur);
+    return out;
+}
+/** P6: wrap every rendered prose line at the current panels width. */
+function wrapPanels(rendered, width) {
+    return rendered.split('\n').flatMap((l) => wrapLine(l, width)).join('\n');
+}
 export function renderMarkdown(input) {
+    if (getLook() === 'panels') {
+        const result = panelsMarked.parse(input);
+        return typeof result === 'string' ? wrapPanels(result, panelsProseWidth()) : input;
+    }
     const result = marked.parse(input);
     return typeof result === 'string' ? result : input;
 }

package/dist/renderer/notice-log.js

@@ -0,0 +1,72 @@
+/**
+ * Notice log (live fix 2026-09-26).
+ *
+ * Panels cuts a long notice to one screen line so it never wraps mid-word.
+ * The full text must not be lost, so a cut notice is appended here — one
+ * line per notice — in the session's log file under ~/.cspeach/logs.
+ * runRepl points it at `<logsDir>/<sessionId>-notices.log`; until then (tests,
+ * one-shot) recording is a no-op. Best effort: a failed write never throws.
+ */
+import { appendFileSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+let logPath;
+export function setNoticeLogPath(p) {
+    logPath = p;
+}
+export function getNoticeLogPath() {
+    return logPath;
+}
+export function recordFullNotice(level, message) {
+    if (!logPath)
+        return;
+    try {
+        mkdirSync(dirname(logPath), { recursive: true });
+        appendFileSync(logPath, `${new Date().toISOString()} ${level} ${message.replace(/\s*\r?\n\s*/g, ' ')}\n`, 'utf8');
+    }
+    catch {
+        /* best effort — the screen line already showed the start */
+    }
+}
+/** Notice logs older than this are deleted at REPL start (review M6). */
+export const NOTICE_LOG_MAX_AGE_DAYS = 14;
+const NOTICE_LOG_SUFFIX = '-notices.log';
+/**
+ * `<logsDir>/<id>-notices.log` with the session id reduced to
+ * `[A-Za-z0-9-]` (review M6): a resumed on-disk session id must never steer
+ * the file outside the logs directory.
+ */
+export function noticeLogPathFor(logsDir, sessionId) {
+    const safe = sessionId.replace(/[^A-Za-z0-9-]/g, '') || 'session';
+    return join(logsDir, `${safe}${NOTICE_LOG_SUFFIX}`);
+}
+/**
+ * Delete `*-notices.log` files in `dir` last modified more than
+ * NOTICE_LOG_MAX_AGE_DAYS ago (review M6). Other files are left alone.
+ * Returns how many were deleted. Best effort: never throws.
+ */
+export function pruneNoticeLogs(dir, now = Date.now()) {
+    const cutoff = now - NOTICE_LOG_MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+    let removed = 0;
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return 0;
+    }
+    for (const name of names) {
+        if (!name.endsWith(NOTICE_LOG_SUFFIX))
+            continue;
+        const p = join(dir, name);
+        try {
+            if (statSync(p).mtimeMs < cutoff) {
+                unlinkSync(p);
+                removed++;
+            }
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    return removed;
+}

package/dist/renderer/notice-shape.js

@@ -0,0 +1,48 @@
+// src/renderer/notice-shape.ts
+//
+// Piece 2 §9 — the one shape for every error and notice:
+//
+//   ✗ <what failed> · <object>        (bad)
+//     <detail, dim>
+//     Next: <what the user can do>    (only when there is something)
+//   ! <needs attention> · <fact>      (warn)
+//   · <for your information>          (dim)
+//
+// Glyph at column 0, further lines indented two spaces, exactly one trailing
+// newline. Colour comes only from theme roles, so NO_COLOR (chalk level 0)
+// leaves glyphs and layout intact. All caller text (tool notices, error
+// messages, model text) is passed through sanitizeControlChars first, so it
+// cannot move the cursor or start an escape sequence.
+import chalk from 'chalk';
+import { paint } from './theme.js';
+import { getGlyphs } from './glyphs.js';
+import { sanitizeControlChars } from './sanitize.js';
+const oneLine = (s) => sanitizeControlChars(s).replace(/\s*\r?\n\s*/g, ' ').trim();
+function nextLine(next) {
+    return next && oneLine(next) !== '' ? [`  ${paint('dim', 'Next:')} ${oneLine(next)}`] : [];
+}
+export function formatFailure(p) {
+    const g = getGlyphs();
+    let head = `${paint('bad', g.failed)} ${chalk.bold(oneLine(p.what))}`;
+    if (p.object && oneLine(p.object) !== '')
+        head += paint('dim', ' · ') + paint('sap', oneLine(p.object));
+    const lines = [head];
+    for (const d of p.detail ?? []) {
+        for (const l of sanitizeControlChars(d).split(/\r?\n/)) {
+            if (l.trim() !== '')
+                lines.push(`  ${paint('dim', l.trimEnd())}`);
+        }
+    }
+    lines.push(...nextLine(p.next));
+    return lines.join('\n') + '\n';
+}
+export function formatAttention(p) {
+    const g = getGlyphs();
+    let head = `${paint('warn', g.attention)} ${chalk.bold(oneLine(p.text))}`;
+    if (p.fact && oneLine(p.fact) !== '')
+        head += paint('dim', ` · ${oneLine(p.fact)}`);
+    return [head, ...nextLine(p.next)].join('\n') + '\n';
+}
+export function formatInfo(text) {
+    return paint('dim', `${getGlyphs().info} ${oneLine(text)}`) + '\n';
+}