aiden-runtime 4.1.2 → 4.1.4

package/dist/cli/v4/replyRenderer.js

@@ -27,15 +27,63 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getReplyRenderer = getReplyRenderer;
+exports.normalizeBlankLines = normalizeBlankLines;
 exports._resetForTests = _resetForTests;
 const marked_1 = require("marked");
 const skinEngine_1 = require("./skinEngine");
 const syntaxHighlight_1 = require("./syntaxHighlight");
+// v4.1.4 reply-quality polish: single source of truth for frame math.
+// Replaces 3 inline `Math.min(process.stdout.columns ?? 80, 100) - 4`
+// callsites in this file with `getBodyWidth()` and adds soft-wrap for
+// code-block lines that previously overflowed the viewport.
+const frame_1 = require("./display/frame");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
 function paint(kind) {
     return (text) => (0, skinEngine_1.getSkinEngine)().applyColors(text, kind);
 }
+/**
+ * v4.1.3-essentials: bold (`**foo**`) markdown emphasis renders as
+ * ANSI bold + underline. Previously painted 'brand' (orange) which
+ * collided with the heading hierarchy. Briefly tried bold + bright-
+ * white; landed on bold + underline because underline carries
+ * emphasis without consuming a color slot — the palette stays
+ * available for state semantics (yellow=degraded, red=error, etc.).
+ *
+ * ANSI sequence: `\x1b[1m\x1b[4m{text}\x1b[24m\x1b[22m` — bold ON +
+ * underline ON, then underline OFF + bold OFF. Reset order matters
+ * (underline first, bold second) so the closing codes don't reorder
+ * styles surprisingly on terminals that batch SGR updates.
+ *
+ * Bypasses the skin system intentionally — bold-as-underline is an
+ * opinionated default for this slice. Same caveat as the prior bold-
+ * as-color iteration: nested markdown loses the outer style after
+ * close (pre-existing limitation of the painter-stack architecture).
+ *
+ * Honors `NO_COLOR=1` per the standard (skips the wrap entirely).
+ * Strictly speaking `NO_COLOR` is about color and underline isn't
+ * a color, but the wrap still emits ANSI escapes; honoring the env
+ * var keeps output paste-safe in scripted contexts.
+ */
+function paintBoldUnderline(text) {
+    if (process.env.NO_COLOR && process.env.NO_COLOR !== '')
+        return text;
+    return `\x1b[1m\x1b[4m${text}\x1b[24m\x1b[22m`;
+}
+/**
+ * v4.1.3-essentials reply-polish: bold-on + skin paint + bold-off.
+ * Used by the 4-tier heading hierarchy so each level can pick its own
+ * color while sharing the bold weight. Emit order matches the rest of
+ * the painter stack: outer wrap is bold, inner wrap is fg color.
+ *
+ * Honors `NO_COLOR=1` via the skin engine's own gate; the bold ANSI
+ * still emits because bold is a weight, not a color (matches the
+ * paintBoldUnderline convention for `**bold**`).
+ */
+function paintBold(kind) {
+    const colorize = paint(kind);
+    return (text) => `\x1b[1m${colorize(text)}\x1b[22m`;
+}
 /**
  * Render a fenced code block: top divider with language label, body
  * with optional syntax highlighting, bottom divider.
@@ -51,10 +99,41 @@ function paint(kind) {
  * the renderer with; the older positional path is kept for
  * compatibility.
  */
+/**
+ * v4.1.3-essentials reply-polish: 24-bit dark background applied per
+ * line so code stands out from prose.
+ *
+ * Color choice: `\x1b[48;2;50;50;60m` (#32323c, slightly bluish dark
+ * grey). The original `30,30,30` (#1e1e1e) was invisible against VS
+ * Code's integrated terminal default (also #1e1e1e) and barely
+ * distinct from Windows Terminal's One Half Dark. #32323c is visibly
+ * different from every common dark-terminal default (Campbell, One
+ * Half Dark, Solarized Dark, Monokai, VS Code) while staying subtle
+ * enough to read as "code chrome" rather than a jarring highlight.
+ *
+ * Used by BOTH the block path (fenced code blocks) and the inline
+ * path (`` `code` `` spans) so the two affordances visually agree —
+ * inline code reads as "this is code" via the same chrome as block
+ * code, just shorter.
+ *
+ * NOTE: \x1b[49m is "default background", terminating the per-line
+ * background scope cleanly. Each body line is wrapped individually
+ * rather than wrapping the whole block, so the background doesn't
+ * bleed across the closing horizontal rule (which already paints fg
+ * muted with its own reset).
+ */
+const CODE_BG_ON = '\x1b[48;2;50;50;60m';
+const CODE_BG_OFF = '\x1b[49m';
 function renderCodeBlock(code, lang) {
     const sk = (0, skinEngine_1.getSkinEngine)();
-    const width = Math.min(process.stdout.columns ?? 80, 100) - 4;
+    // v4.1.4 reply-quality polish: width sourced from frame.ts. Same
+    // visual budget as the v4.1.3 formula (cols capped at 100, minus
+    // gutter+2) — but expressed via the shared helper so it tracks any
+    // future width-policy change in one place.
+    const width = (0, frame_1.getBodyWidth)();
     const langLabel = (lang ?? '').trim();
+    // v4.1.3-essentials reply-polish: language tag on the top rule
+    // already shipped; keep it. Bottom rule unlabeled (closing fence).
     const top = langLabel
         ? `── ${langLabel} ${'─'.repeat(Math.max(0, width - langLabel.length - 4))}`
         : '─'.repeat(width);
@@ -62,11 +141,43 @@ function renderCodeBlock(code, lang) {
     const body = (0, syntaxHighlight_1.isSupportedLang)(langLabel)
         ? (0, syntaxHighlight_1.highlightCode)(code, langLabel)
         : code;
-    const indented = body.split('\n').map((ln) => `  ${ln}`).join('\n');
+    // v4.1.4 reply-quality polish: per-line soft wrap. The rail + bg
+    // chrome adds 4 visible columns (` │ `, padding spaces around the
+    // line). Subtract those so wrap math targets the actual content
+    // budget. `hard: true` ensures even pathological long tokens
+    // (minified JS, hashes) break instead of escaping the frame.
+    //
+    // Width inside the body of a code line:
+    //   gutter (3) + `│ ` (2) + leading-space (1) + CONTENT + trailing-space (1)
+    // → content budget = width - gutter - 4. We further cap at width to
+    //   keep the fence rule aligned with the body's right margin.
+    const contentBudget = Math.max(8, width - frame_1.GUTTER - 4);
+    // v4.1.3-essentials reply-polish (preserved): each body line gets:
+    //   - frame gutter (was 2-space outer indent; now uses shared GUTTER)
+    //   - left rail `│ ` painted muted (mirrors blockquote's `┃ ` rail
+    //     with a different glyph so they're visually distinct)
+    //   - 24-bit dark background wrapping the rail + content (subtle
+    //     "this is code" affordance without going full TUI box-frame)
+    const rail = sk.applyColors('│', 'muted');
+    const gutter = (0, frame_1.getIndent)(0);
+    // Wrap each source line independently — code-block semantics demand
+    // that a "logical line" remains visible as one continued unit even
+    // when soft-wrapped. The CODE_BG painting closes per VISUAL line so
+    // a wrap break doesn't bleed bg across the rail of the next row.
+    const wrappedLines = [];
+    for (const srcLine of body.split('\n')) {
+        const wrapped = (0, frame_1.wrap)(srcLine, contentBudget, { trim: false, hard: true });
+        for (const visualLine of wrapped.split('\n')) {
+            wrappedLines.push(`${gutter}${rail} ${CODE_BG_ON} ${visualLine} ${CODE_BG_OFF}`);
+        }
+    }
+    const indented = wrappedLines.join('\n');
+    // Top + bottom fence rules sit at the gutter too — visually anchors
+    // the block as a unit inside the assistant frame.
     return [
-        sk.applyColors(top, 'muted'),
+        `${gutter}${sk.applyColors(top, 'muted')}`,
         indented,
-        sk.applyColors(bot, 'muted'),
+        `${gutter}${sk.applyColors(bot, 'muted')}`,
         '',
     ].join('\n') + '\n';
 }
@@ -82,26 +193,152 @@ function renderBlockquote(quote) {
         .join('\n') + '\n';
 }
 /**
- * Marked-terminal heading callback gets the rendered heading text +
- * level. We paint h1 in brand-bold, h2 in brand, h3+ in heading.
+ * v4.1.3-essentials reply-polish: 4-tier heading hierarchy using the
+ * existing palette colors so visual weight differs per level even
+ * though we don't introduce a new ColorKind.
+ *
+ *   H1 — brand   + bold + UPPERCASE  (major section heading)
+ *   H2 — brand   + bold                (subsection — same hue as H1
+ *                                       but sentence-case + no caps)
+ *   H3 — agent   + bold                (off-white, lighter weight
+ *                                       than brand)
+ *   H4+ — muted  + bold                (quietest — same grey as the
+ *                                       reply container's chrome)
+ *
+ * v4.1.3-essentials reply-polish: spacing tightened from `\n\n` to
+ * `\n` per level. marked-terminal contributes its own block
+ * separator (one more newline) → total `\n\n` between heading and
+ * next block = single blank line, matching paragraph rhythm.
+ * Previously this emitted `\n\n\n\n` (three blank lines) which made
+ * structured replies feel cramped at top and over-aired between
+ * sections.
  */
-function renderHeading(text, level, _raw) {
-    if (level <= 1)
-        return paint('brand')(text.toUpperCase()) + '\n\n';
-    if (level === 2)
-        return paint('brand')(text) + '\n\n';
-    return paint('heading')(text) + '\n\n';
+// 4-tier hierarchy. Called by the prototype-level `heading` override
+// in getReplyRenderer() which extracts depth from the token first.
+// Plain `(text, depth)` signature; the marked v15 / v14 / positional
+// translation happens in the override.
+//
+// Each tier ends with `\n\n` to fence the heading from the next block
+// with a blank line. Earlier we tried `\n` (single trailing newline)
+// assuming marked-terminal's `section()` wrapper added its own
+// padding — but the prototype-level override bypasses section(), so
+// we own the spacing end-to-end. Result with `\n\n`: heading visible
+// on its own line, blank line separates it from the next paragraph /
+// heading / list. Matches the paragraph rhythm (`text\n\n`).
+function renderHeading(text, depth) {
+    if (depth <= 1)
+        return paintBold('brand')(text.toUpperCase()) + '\n\n';
+    if (depth === 2)
+        return paintBold('brand')(text) + '\n\n';
+    if (depth === 3)
+        return paintBold('agent')(text) + '\n\n';
+    return paintBold('muted')(text) + '\n\n';
 }
 /**
- * List items get a `▸ ` glyph in muted; numbered lists keep their
- * numeric prefix (marked-terminal already prepends `N.` for ordered
- * lists, so we just paint the body).
+ * v4.1.3-essentials reply-polish: the `opts.listitem` callback used to
+ * own bullet rendering but marked-terminal's outer `list` method
+ * ALSO emits a `* ` prefix, producing visible double bullets
+ * (`  *   ▸ item`). The fix is a prototype-level override on BOTH
+ * `list` and `listitem` (mirrors the existing pattern for `code` and
+ * `link`). See the override block in getReplyRenderer().
+ *
+ * This callback now just returns the inner text unchanged so the
+ * prototype-level `list` override can do the bullet + indent work
+ * with full nesting-depth context.
  */
 function renderListItem(text) {
-    // marked-terminal feeds us the rendered child text. Strip its
-    // default tab prefix so our two-space indent stays consistent.
-    const body = text.replace(/^\s+/, '');
-    return `  ${paint('muted')('▸')} ${body}\n`;
+    return text;
+}
+/**
+ * v4.1.4 reply-quality polish — Fix C helper.
+ *
+ * Render a single list item's tokens correctly, expanding inline
+ * emphasis (strong, em, codespan) that the prior `parser.parse` path
+ * silently stranded as raw text.
+ *
+ * Marked v15 token shapes for list items:
+ *
+ *   Tight list (default — no blank lines between items):
+ *     list_item.tokens = [
+ *       { type: 'text', text: '**bold**',
+ *         tokens: [ { type: 'strong', ... } ]   ← inline children
+ *       }
+ *     ]
+ *
+ *   Loose list (blank line between items, OR an item with multiple
+ *   paragraphs):
+ *     list_item.tokens = [
+ *       { type: 'paragraph', tokens: [ inline children… ] },
+ *       { type: 'paragraph', tokens: [ … ] },
+ *     ]
+ *
+ *   Nested list (a list-token inside an item):
+ *     list_item.tokens = [
+ *       { type: 'text', tokens: [...] },   ← the item's own text first
+ *       { type: 'list', items: [...] },    ← then the nested list
+ *     ]
+ *
+ *   Item with fenced code block:
+ *     list_item.tokens = [
+ *       { type: 'text', ... },
+ *       { type: 'code', text: '…', lang: '…' },
+ *     ]
+ *
+ * Dispatch rules:
+ *   - `text` with nested `.tokens`     → parseInline(tokens)
+ *   - `text` with only `.text`          → fall through to raw text
+ *   - `paragraph`                       → parseInline(paragraph.tokens) + '\n'
+ *   - `list` / `code` / other block     → parser.parse([token]) (block path)
+ *
+ * Returns the joined rendered string. Pure-ish: depends on marked's
+ * parser instance (closure-captured) but never mutates it.
+ */
+function renderListItemTokens(it, parser) {
+    const toks = Array.isArray(it.tokens) ? it.tokens : [];
+    if (toks.length === 0)
+        return it.text ?? '';
+    const out = [];
+    for (const raw of toks) {
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const tk = raw;
+        const type = tk.type;
+        // Inline-only wrapper (tight-list common case). The `text` outer
+        // token holds inline children we want to expand into ANSI.
+        if (type === 'text') {
+            if (Array.isArray(tk.tokens) && tk.tokens.length > 0 && parser.parseInline) {
+                out.push(parser.parseInline(tk.tokens));
+            }
+            else {
+                out.push(tk.text ?? '');
+            }
+            continue;
+        }
+        // Paragraph block (loose-list case). Marked wraps each paragraph's
+        // inline content in `.tokens`; render those inline + append a
+        // newline so multi-paragraph items stack visually.
+        if (type === 'paragraph') {
+            if (Array.isArray(tk.tokens) && tk.tokens.length > 0 && parser.parseInline) {
+                out.push(parser.parseInline(tk.tokens));
+                out.push('\n');
+            }
+            else {
+                out.push(tk.text ?? '');
+            }
+            continue;
+        }
+        // Nested list, fenced code, or any other block-level token. The
+        // block parser handles these via the normal dispatch (which calls
+        // back into our own `renderer.list` override for nested lists —
+        // depth counter is already incremented before we got here).
+        if (parser.parse) {
+            out.push(parser.parse([tk]));
+            continue;
+        }
+        // Last-resort fallback: drop the token's text in raw.
+        out.push(tk.text ?? '');
+    }
+    return out.join('');
 }
 /**
  * Singleton — caching is fine since options bind to the active skin
@@ -121,14 +358,33 @@ function getReplyRenderer() {
     // method directly below.
     const opts = {
         blockquote: renderBlockquote,
-        heading: renderHeading,
-        firstHeading: (text, _level, _raw) => paint('brand')(text.toUpperCase()) + '\n\n',
-        hr: () => paint('muted')('─'.repeat(Math.min(process.stdout.columns ?? 80, 100) - 4)) + '\n',
+        // v4.1.3-essentials reply-polish: `opts.heading` and `opts.firstHeading`
+        // both removed. marked-terminal calls `opts.heading(text)` with ONLY
+        // text (audit-confirmed via toString), dropping the depth info we
+        // need for the 4-tier hierarchy. The prototype-level `renderer.heading`
+        // override below owns the depth extraction + tier selection end-to-end.
+        // marked-terminal's stripped-args call path never reaches our callback.
+        hr: () => paint('muted')('─'.repeat((0, frame_1.getBodyWidth)())) + '\n',
         listitem: renderListItem,
         paragraph: (text) => `${text}\n\n`,
-        strong: paint('brand'),
+        // v4.1.3-essentials: bold renders as ANSI bold + underline
+        // (was 'brand' / orange, then bright-white; landed on underline
+        // so the color palette stays available for state semantics).
+        strong: paintBoldUnderline,
         em: paint('muted'),
-        codespan: (text) => paint('accent')(`\`${text}\``),
+        // v4.1.3-essentials reply-polish: inline `` `code` `` — strip
+        // the literal backticks (used to leak into the visible output)
+        // and wrap with the same dark background as fenced code blocks.
+        // Visual consistency: inline code reads as "this is code" via the
+        // same chrome as block code, just shorter. One leading + trailing
+        // space inside the bg span gives the chrome a bit of padding so
+        // letters don't sit flush against the bg edge.
+        //
+        // Trade-off (accepted): if an inline-code span breaks across a
+        // line wrap, the bg painting may show a visual seam at the wrap
+        // point. Acceptable for v4.1.3 — revertable to Path A (no bg) if
+        // visual smoke surfaces a real problem.
+        codespan: (text) => `${CODE_BG_ON} ${paint('accent')(text)} ${CODE_BG_OFF}`,
         del: paint('muted'),
         // marked-terminal calls opts.link with the ASSEMBLED visual
         // (already OSC8-wrapped when the host terminal supports it),
@@ -136,7 +392,12 @@ function getReplyRenderer() {
         link: (assembled) => paint('accent')(assembled),
         href: paint('accent'),
         text: (text) => text,
-        width: Math.min(process.stdout.columns ?? 80, 100),
+        // v4.1.4 reply-quality polish: marked-terminal's `width` is the
+        // *outer* canvas it formats into. Frame-aware body width keeps the
+        // tables / hr / hard-wrap targets inside our gutter envelope.
+        // `reflowText: false` (below) stays off — we own prose wrap via
+        // frame.wrap() in the display layer, not here.
+        width: (0, frame_1.getBodyWidth)(),
         showSectionPrefix: false,
         reflowText: false,
         tab: 2,
@@ -185,6 +446,174 @@ function getReplyRenderer() {
         const painted = paint('accent')(label);
         return `\x1b]8;;${url}\x1b\\${painted}\x1b]8;;\x1b\\`;
     };
+    // v4.1.3-essentials reply-polish: prototype-level `heading` override.
+    //
+    // Why: marked-terminal's internal `heading` method extracts the
+    // token's depth, then calls `opts.heading(text)` with ONLY the
+    // text — dropping the level info on the floor. Our 4-tier hierarchy
+    // (H1 brand+caps, H2 brand, H3 agent, H4+ muted) needs level
+    // context, so we must own the whole method.
+    //
+    // The override accepts marked v15's token-object shape and falls
+    // through to v14 positional for unit tests that pass plain strings.
+    renderer.heading = function (textOrToken, levelArg, _raw) {
+        let text;
+        let depth;
+        if (typeof textOrToken === 'object' && textOrToken !== null) {
+            const tok = textOrToken;
+            depth = typeof tok.depth === 'number' ? tok.depth : 1;
+            // Prefer parseInline for rich heading content (e.g. `## H2 with **bold**`).
+            // Falls through to tok.text for the common plain-text case.
+            const parser = this.parser;
+            if (tok.tokens && parser?.parseInline) {
+                text = parser.parseInline(tok.tokens);
+            }
+            else {
+                text = String(tok.text ?? '');
+            }
+        }
+        else {
+            text = String(textOrToken ?? '');
+            depth = typeof levelArg === 'number' ? levelArg : 1;
+        }
+        return renderHeading(text, depth);
+    };
+    // v4.1.3-essentials reply-polish: prototype-level list overrides.
+    //
+    // Why two functions and a depth counter:
+    //   - marked-terminal's default `list` injects a `* ` (or `N. `)
+    //     prefix BEFORE calling our `opts.listitem` callback, producing
+    //     visible double bullets — see audit. Owning `list` at the
+    //     prototype level lets us suppress that and emit our own.
+    //   - Nesting depth determines the bullet glyph: top-level gets `•`
+    //     and any deeper level gets `▸`. marked doesn't pass depth to
+    //     the renderer, so we track it on the renderer instance via a
+    //     counter that increments on `list`-enter and decrements on
+    //     exit. This works because marked walks the token tree
+    //     synchronously: a nested list's `list` call always completes
+    //     between its parent's `list`-enter and `list`-exit.
+    //   - Items already had their child markdown rendered via the
+    //     prototype's `listitem` (which we leave as a passthrough above
+    //     in the opts block — it just returns the inner text). The
+    //     body string we receive in `list` is the concatenated children;
+    //     each child can itself be a nested list rendering, whose own
+    //     `list` call already handled its bullets + indent.
+    //
+    // Numbered lists: `start` and `ordered` come from the token; we
+    // emit `N.` prefix in muted to keep the visual rhythm consistent
+    // with bulleted lists but preserve numeric semantics.
+    //
+    // Indent: 2 spaces per nesting level. Top-level items therefore
+    // sit at column 2 (matching the rest of the reply container's
+    // chrome); nested at column 4, 6, etc.
+    const proto = renderer;
+    proto._listDepth = 0;
+    renderer.listitem = function (text, _task, _checked) {
+        // marked v15 may pass a token object; the assembled-text fallback
+        // covers older signatures. Either way we want the inner text
+        // unchanged here — bullet + indent is owned by `list` below.
+        if (typeof text === 'object' && text !== null) {
+            const tok = text;
+            if (typeof tok.text === 'string')
+                return tok.text;
+            const parser = this.parser;
+            return parser?.parseInline?.(tok.tokens ?? []) ?? '';
+        }
+        return String(text ?? '');
+    };
+    renderer.list = function (body, ordered, start) {
+        // marked v15 token shape: { ordered, start, items: [token, ...] }
+        // Older positional shape: (body, ordered, start)
+        let isOrdered = false;
+        let startNum = 1;
+        let items;
+        // CRITICAL: increment depth BEFORE walking items. Item walking via
+        // `parser.parse(it.tokens)` recurses into our own override for any
+        // nested list tokens — those nested calls need to see the parent's
+        // incremented depth so they pick the deeper bullet glyph (▸) and
+        // indent. If we increment AFTER `parser.parse`, the nested call
+        // sees depth=0, renders at top-level styling, and the visible
+        // nesting collapses. Confirmed via runtime trace.
+        proto._listDepth = (proto._listDepth ?? 0) + 1;
+        const depth = proto._listDepth;
+        if (typeof body === 'object' && body !== null) {
+            const tok = body;
+            isOrdered = tok.ordered === true;
+            startNum = typeof tok.start === 'number' ? tok.start : 1;
+            // v4.1.4 reply-quality polish — Fix C (token-type dispatch).
+            //
+            // Prior implementation called `parser.parse(it.tokens)` and let
+            // marked's block-parser dispatch each token. For tight-list items
+            // marked v15 wraps the item's content in a `text`-type outer
+            // token whose `.tokens` array holds the actual inline tokens
+            // (strong, em, codespan…). `parser.parse` dispatched the outer
+            // wrapper to `renderer.text` (our `opts.text` = identity), which
+            // returned the RAW raw `**bold**` source string — never recursing
+            // into the inline children. Result: literal asterisks in every
+            // bullet that contained inline emphasis.
+            //
+            // Fix: walk each top-level token by type. Tight-list items have
+            // a `text` wrapper → use `parseInline` on its nested tokens to
+            // expand strong/em/codespan. Loose-list items have block-level
+            // `paragraph`/`list`/`code` tokens → those need block-level
+            // recursion (delegates back to our list override for nested
+            // lists, preserving the depth counter).
+            //
+            // Confirmed against marked v15 token shapes from `marked.lexer`
+            // (see scripts/smoke-issue-c-tokens.ts).
+            const parser = this.parser;
+            items = (tok.items ?? []).map((it) => {
+                if (!parser)
+                    return it.text ?? '';
+                return renderListItemTokens(it, parser);
+            });
+        }
+        else {
+            isOrdered = ordered === true;
+            startNum = typeof start === 'number' ? start : 1;
+            // Positional `body` is the already-concatenated rendered items.
+            // Split on newlines that introduce a fresh item; marked emits
+            // each item as its own logical line. Best-effort — marked v15
+            // path above is the production case.
+            const raw = String(body ?? '');
+            items = raw.split('\n').filter((ln) => ln.trim().length > 0);
+        }
+        const indent = '  '.repeat(depth);
+        // Top-level bullet `•` (filled); nested `▸` (arrow-like) for
+        // visual depth differentiation. Numbered lists override with
+        // `N.` regardless of depth.
+        const bulletGlyph = depth === 1 ? '•' : '▸';
+        const lines = [];
+        for (let i = 0; i < items.length; i += 1) {
+            const item = items[i];
+            // Each item may itself contain newlines (nested list output,
+            // multi-line paragraph). Indent every line of the rendered
+            // item AFTER the first — the first line takes the bullet, the
+            // continuation lines align under the bullet's content column.
+            const marker = isOrdered
+                ? paint('muted')(`${startNum + i}.`)
+                : paint('muted')(bulletGlyph);
+            const itemLines = item.split('\n');
+            const head = itemLines[0] ?? '';
+            const tail = itemLines.slice(1);
+            lines.push(`${indent}${marker} ${head}`);
+            // Continuation lines: if they already have content, align them
+            // under the bullet's text column (indent + marker-width + 1
+            // space). marked-terminal's nested lists arrive pre-indented so
+            // we pass them through.
+            for (const tailLine of tail) {
+                if (tailLine.length === 0)
+                    continue;
+                lines.push(tailLine);
+            }
+        }
+        proto._listDepth -= 1;
+        // Top-level list closes with a trailing newline to separate from
+        // the next block; nested lists return without extra padding so
+        // they nest cleanly inside their parent item.
+        const out = lines.join('\n');
+        return proto._listDepth === 0 ? out + '\n' : out + '\n';
+    };
     cachedRenderer = {
         render(text) {
             try {
@@ -194,7 +623,21 @@ function getReplyRenderer() {
                 // if other code transiently swaps the renderer.
                 marked_1.marked.setOptions({ renderer: renderer });
                 const out = marked_1.marked.parse(text);
-                return typeof out === 'string' ? out : String(out);
+                const raw = typeof out === 'string' ? out : String(out);
+                // v4.1.4 Part 1.6 Issue I — collapse excess vertical spacing.
+                //
+                // Our `opts.paragraph` callback emits `text\n\n`, our
+                // `renderCodeBlock` ends with `\n\n`, and marked-terminal's
+                // outer block dispatch ALSO emits `\n\n` between adjacent
+                // blocks. Result: 4 newlines (3 visible blank lines) between
+                // paragraphs, after code blocks, between paragraphs and lists.
+                // Root-cause fix would require auditing marked-terminal's
+                // between-block separator across every override (risk-prone).
+                // Band-aid: collapse any run of 3+ newlines down to exactly 2
+                // (= one blank line). Mechanically safe — can only REMOVE
+                // excess whitespace, never add bad spacing. Existing single-
+                // blank-line gaps pass through unchanged.
+                return normalizeBlankLines(raw);
             }
             catch {
                 return text;
@@ -203,6 +646,24 @@ function getReplyRenderer() {
     };
     return cachedRenderer;
 }
+/**
+ * v4.1.4 Part 1.6 Issue I — collapse runs of 3+ consecutive newlines
+ * down to exactly 2 (a single blank line). Exported for unit-test
+ * access; pure with no side effects.
+ *
+ * Confirmed via `scripts/smoke-issue-i-spacing.ts`:
+ *   - "A\n\n\n\nB"    → "A\n\nB"     (2 paras → 1 blank line)
+ *   - "A\n\n\n\n\nB"  → "A\n\nB"     (3+ blanks all collapse)
+ *   - "A\n\nB"        → "A\n\nB"     (already correct, unchanged)
+ *   - "A\nB"          → "A\nB"       (single newline preserved)
+ *   - "A\n"           → "A\n"        (trailing pass-through)
+ *
+ * Does NOT touch the list-under-padding case (lists ending with a
+ * single `\n` before a paragraph) — that's a v4.1.5 follow-up.
+ */
+function normalizeBlankLines(text) {
+    return text.replace(/\n{3,}/g, '\n\n');
+}
 /** Test reset — drops the cached renderer so a skin change picks up. */
 function _resetForTests() {
     cachedRenderer = null;

package/dist/cli/v4/skinEngine.js

@@ -49,10 +49,23 @@ const DEFAULT_SKIN = {
         error: [0xf4, 0x47, 0x47],
         warn: [0xff, 0xc1, 0x07],
         success: [0x4c, 0xaf, 0x50],
-        // Phase 22 colour discipline: soft cyan replaces grey for secondary
-        // text (timestamps, hints, tips, dim diagnostics).
-        muted: [0x6f, 0xb3, 0xd2],
+        // v4.1.4 reply-quality polish: muted shifts from neutral grey
+        // (#888888) to warm Aiden-tinted dim (#b8a89a). Mid-grey at +56
+        // brightness on red/green channels with a slight cool-down on
+        // blue, putting muted in the same warm family as brand orange
+        // (#FF6B35) without competing with it. Reads as "intentional
+        // dim" rather than washed-out terminal grey. Used by tool-trail
+        // gutter, status footer, code-block rail, blockquote rail, and
+        // display.dim() — surfaces the user reads constantly.
+        muted: [0xb8, 0xa8, 0x9a],
         heading: BRAND_ORANGE,
+        // v4.1.3-repl-polish: session = soft cyan (ex-muted); used for IDs
+        // and the session-end card header labels.
+        session: [0x6f, 0xb3, 0xd2],
+        // v4.1.3-repl-polish: degraded = amber yellow; distinct from warn
+        // (which shares the colour) so callers can differentiate in code
+        // even though they render identically.
+        degraded: [0xff, 0xc1, 0x07],
     },
     glyphs: {
         bullet: '•',
@@ -77,8 +90,15 @@ const LIGHT_SKIN = {
         error: [0xb0, 0x10, 0x10],
         warn: [0x80, 0x60, 0x00],
         success: [0x1b, 0x5e, 0x20],
-        muted: [0x60, 0x60, 0x60],
+        // v4.1.4 reply-quality polish: proportional warm-shift for the
+        // light skin too. Was neutral #606060; new value #7a6e5e keeps the
+        // dark-on-light contrast budget but adds the same warm tint as the
+        // default skin's muted so themed surfaces feel coherent across
+        // skin switches.
+        muted: [0x7a, 0x6e, 0x5e],
         heading: [0xc4, 0x42, 0x10],
+        session: [0x00, 0x55, 0x88],
+        degraded: [0x80, 0x60, 0x00],
     },
     glyphs: { ...DEFAULT_SKIN.glyphs },
 };
@@ -96,6 +116,8 @@ const MONOCHROME_SKIN = {
         success: null,
         muted: null,
         heading: null,
+        session: null,
+        degraded: null,
     },
     glyphs: {
         bullet: '*',