aiden-runtime 4.7.0 → 4.8.1

package/dist/cli/v4/replyRenderer.js

@@ -32,11 +32,14 @@ exports._resetForTests = _resetForTests;
 const marked_1 = require("marked");
 const skinEngine_1 = require("./skinEngine");
 const syntaxHighlight_1 = require("./syntaxHighlight");
+// v4.8.0 Slice 8 — token-sourced bullet glyphs + task-list markers.
+const tokens_1 = require("./design/tokens");
 // 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");
+const box_1 = require("./box");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
 function paint(kind) {
@@ -131,61 +134,45 @@ function paintBold(kind) {
 const CODE_BG_ON = '\x1b[48;2;50;50;60m';
 const CODE_BG_OFF = '\x1b[49m';
 function renderCodeBlock(code, lang) {
+    // v4.8.0 Slice 9 hotfix — top-divider asymmetric chrome.
+    //
+    //   ── python ─────────────────────────────────────────
+    //     print("Hello, world!")
+    //     greet("Aiden")
+    //
+    // The earlier Slice 9 version used `▎` left-rail on every line and
+    // visually competed with the dark-bg syntax highlighting. This
+    // revision drops the rail, keeps a single muted `──` top divider
+    // with the language label in brand orange, indents body content,
+    // and omits the bottom border (Slice 4 asymmetric signature).
+    // CODE_BG_ON/OFF envelope preserved.
     const sk = (0, skinEngine_1.getSkinEngine)();
-    // 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);
-    const bot = '─'.repeat(width);
     const body = (0, syntaxHighlight_1.isSupportedLang)(langLabel)
         ? (0, syntaxHighlight_1.highlightCode)(code, langLabel)
         : code;
-    // 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 indent = '  ';
+    const hLine = tokens_1.glyphs.chrome.hLine;
+    // Top divider: `── <lang> ─────` (lang in brand) OR full-width
+    // `────────────` when no language declared.
+    const top = langLabel
+        ? `${indent}${sk.applyColors(`${hLine.repeat(2)} `, 'muted')}` +
+            `${sk.applyColors(langLabel, 'brand')}` +
+            ` ${sk.applyColors(hLine.repeat(Math.max(1, width - langLabel.length - 4)), 'muted')}`
+        : `${indent}${sk.applyColors(hLine.repeat(width), 'muted')}`;
+    // Body content lands at col 4 (4-space indent inside the divider).
+    // Width budget: leave room for body indent + CODE_BG envelope spaces.
+    const bodyIndent = '    ';
+    const contentBudget = Math.max(8, width - 6);
     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}`);
+            wrappedLines.push(`${bodyIndent}${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 [
-        `${gutter}${sk.applyColors(top, 'muted')}`,
-        indented,
-        `${gutter}${sk.applyColors(bot, 'muted')}`,
-        '',
-    ].join('\n') + '\n';
+    return [top, ...wrappedLines].join('\n') + '\n';
 }
 /**
  * Render a block quote with a `┃` left rail in muted colour.
@@ -337,7 +324,16 @@ function renderListItemTokens(it, parser) {
         // 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).
+        //
+        // v4.8.0 Slice 8 hotfix — ensure inline text and following block
+        // tokens are separated by a newline. Without this, a tight-list
+        // item like `- Python` followed by a nested `- Django` collapses
+        // to `● Python    ○ Django` on a single line because head/tail
+        // split in renderer.list takes only the first line as `head`.
         if (parser.parse) {
+            if (out.length > 0 && !out[out.length - 1].endsWith('\n')) {
+                out.push('\n');
+            }
             out.push(parser.parse([tk]));
             continue;
         }
@@ -535,6 +531,10 @@ function getReplyRenderer() {
         let isOrdered = false;
         let startNum = 1;
         let items;
+        // v4.8.0 Slice 8 — task/checked flags collected alongside items so
+        // the marker dispatch below can pick ✔ (checked) or ○ (unchecked).
+        // Default false (not a task) so the bullet path stays unchanged.
+        let itemTasks = [];
         // 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
@@ -570,10 +570,14 @@ function getReplyRenderer() {
             // 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);
+            // v4.8.0 Slice 8 — capture GFM task/checked flags alongside the
+            // rendered text so the marker dispatch below can pick the right
+            // glyph (✔ checked / ○ unchecked) for task-list items.
+            const rawItems = tok.items ?? [];
+            items = rawItems.map((it) => parser ? renderListItemTokens(it, parser) : (it.text ?? ''));
+            itemTasks = rawItems.map((it) => {
+                const itx = it;
+                return { task: itx.task === true, checked: itx.checked === true };
             });
         }
         else {
@@ -587,20 +591,33 @@ function getReplyRenderer() {
             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 ? '•' : '▸';
+        // v4.8.0 Slice 8 — token-sourced bullet glyphs. Top-level (depth 1)
+        // uses filled `●`, nested (depth ≥ 2) uses hollow `○`. Both painted
+        // brand orange to give lists visual identity (was `muted` grey).
+        const bulletGlyph = depth === 1 ? tokens_1.glyphs.util.bullet : tokens_1.glyphs.util.bulletOpen;
         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 task = itemTasks[i] ?? { task: false, checked: false };
+            // v4.8.0 Slice 8 — marker dispatch:
+            //   • GFM checked task → ✔ in semantic success (green)
+            //   • GFM unchecked task → ○ in tertiary dim (looks incomplete)
+            //   • Ordered list → `N.` right-padded to 3 cols, brand orange
+            //   • Bullet → ●/○ by depth, brand orange
+            let marker;
+            if (task.task && task.checked) {
+                marker = paint('success')(tokens_1.glyphs.util.check);
+            }
+            else if (task.task) {
+                marker = paint('tertiary')(tokens_1.glyphs.util.bulletOpen);
+            }
+            else if (isOrdered) {
+                const numStr = `${startNum + i}.`.padStart(3);
+                marker = paint('brand')(numStr);
+            }
+            else {
+                marker = paint('brand')(bulletGlyph);
+            }
             const itemLines = item.split('\n');
             const head = itemLines[0] ?? '';
             const tail = itemLines.slice(1);
@@ -622,6 +639,144 @@ function getReplyRenderer() {
         const out = lines.join('\n');
         return proto._listDepth === 0 ? out + '\n' : out + '\n';
     };
+    // ── v4.8.1 Slice 2 — markdown table override ──────────────────────────
+    //
+    // Why: marked-terminal's default table renderer (cli-table3) auto-
+    // wraps cells but doesn't keep wrap-continuation lines aligned to
+    // the original row — wide tables with 5+ columns fragment into
+    // vertical pipe rails that don't read as rows. The narrow 2-col
+    // tables that smoke-tested fine were within the no-wrap budget.
+    //
+    // Strategy: own the entire render from the marked v15 token object.
+    // Use `parser.parseInline(cell.tokens)` to get ANSI-painted cell
+    // text, then proportionally distribute the terminal-width budget
+    // across columns (clamping to natural max width), wrap each cell
+    // to its column width, and render the box with the same row
+    // height for every cell in the row so visual rows stay tight.
+    //
+    // Token-source the box chars from `glyphs.chrome.*` so a single
+    // glyph swap propagates here automatically (consistent with the
+    // rest of v4.8.x chrome).
+    renderer.table = function (header, body) {
+        // marked v15 token: { header: [cellTok], rows: [[cellTok]] }.
+        // Older string-based API: (headerHtml, bodyHtml) — we fall back
+        // to a naive concatenation so the reply isn't lost entirely.
+        if (typeof header !== 'object' || header === null) {
+            return String(header ?? '') + (body !== undefined ? String(body) : '') + '\n';
+        }
+        const tok = header;
+        const parser = this.parser;
+        const renderCell = (c) => {
+            if (c.tokens && parser?.parseInline) {
+                try {
+                    return parser.parseInline(c.tokens).trim();
+                }
+                catch {
+                    return (c.text ?? '').trim();
+                }
+            }
+            return (c.text ?? '').trim();
+        };
+        const headers = (tok.header ?? []).map(renderCell);
+        const rows = (tok.rows ?? []).map((r) => r.map(renderCell));
+        const cols = headers.length;
+        if (cols === 0)
+            return '';
+        // Layout budget. Reply chrome family lives at col 2.
+        const indent = '  ';
+        const termCols = process.stdout.columns ?? 100;
+        const innerBudget = Math.max(40, Math.min(termCols, 110) - indent.length);
+        // Chrome per row = `│ ` (2) per col + trailing `│` (1) + 1 trailing
+        // space per cell already absorbed in the budget below.
+        const chromeCost = 3 * cols + 1;
+        const contentBudget = Math.max(cols * 4, innerBudget - chromeCost);
+        // Natural width = max(header, body) visible width per column.
+        const naturalW = headers.map((h, i) => {
+            const hw = (0, box_1.visibleLength)(h);
+            const cw = rows.reduce((m, r) => Math.max(m, (0, box_1.visibleLength)(r[i] ?? '')), 0);
+            return Math.max(hw, cw, 1);
+        });
+        // v4.8.1 Slice 2 hotfix #2 — header-floor + proportional allocation.
+        //
+        // Each column's minimum is `max(headerWidth, MIN_COL_W)` so column
+        // headers NEVER wrap — they are the column identifier; wrapping
+        // them ("Framework" → "Framew/ork") fragments scanability worse
+        // than wrapping body cells. Body content above the header width
+        // is what gets compressed under width pressure.
+        //
+        // Algorithm:
+        //   1. Compute `minPerCol = max(headerW[i], MIN_COL_W)` per column.
+        //   2. If sum(minPerCol) >= contentBudget (very narrow terminal),
+        //      use minPerCol as-is — body cells will wrap to fit, headers
+        //      stay intact.
+        //   3. Else if sum(naturalW) <= contentBudget, use natural widths
+        //      (no wrap needed anywhere).
+        //   4. Else: floor at minPerCol, distribute remaining budget
+        //      proportionally to each column's "extra need above min",
+        //      then hand rounding leftover to widest-natural cols first.
+        const MIN_COL_W = 4;
+        const headerW = headers.map((h) => (0, box_1.visibleLength)(h));
+        const minPerCol = naturalW.map((_, i) => Math.max(headerW[i], MIN_COL_W));
+        const totalMin = minPerCol.reduce((a, b) => a + b, 0);
+        const totalNatW = naturalW.reduce((a, b) => a + b, 0);
+        let colWidths;
+        if (totalMin >= contentBudget) {
+            colWidths = minPerCol.slice();
+        }
+        else if (totalNatW <= contentBudget) {
+            colWidths = naturalW.slice();
+        }
+        else {
+            colWidths = minPerCol.slice();
+            const extraNeed = naturalW.map((w, i) => Math.max(0, w - minPerCol[i]));
+            const totalNeed = extraNeed.reduce((a, b) => a + b, 0);
+            const pool = contentBudget - totalMin;
+            if (totalNeed > 0) {
+                for (let i = 0; i < cols; i += 1) {
+                    colWidths[i] += Math.floor((extraNeed[i] * pool) / totalNeed);
+                }
+            }
+            let leftover = contentBudget - colWidths.reduce((a, b) => a + b, 0);
+            const order = naturalW.map((_, i) => i).sort((a, b) => naturalW[b] - naturalW[a]);
+            for (let k = 0; leftover > 0 && k < cols * 2; k += 1) {
+                const idx = order[k % cols];
+                if (colWidths[idx] < naturalW[idx]) {
+                    colWidths[idx] += 1;
+                    leftover -= 1;
+                }
+            }
+        }
+        // ANSI-aware cell wrap. frameWrap handles colour-code-aware width.
+        const wrapCell = (text, w) => w <= 0 ? [''] : (0, frame_1.wrap)(text, w, { trim: false, hard: true }).split('\n');
+        const sk = (0, skinEngine_1.getSkinEngine)();
+        const ch = tokens_1.glyphs.chrome;
+        const rule = (l, m, r) => indent + sk.applyColors(l + colWidths.map((w) => ch.hLine.repeat(w + 2)).join(m) + r, 'muted');
+        const vBar = sk.applyColors(ch.vLine, 'muted');
+        const renderRow = (cells) => {
+            const height = Math.max(...cells.map((c) => c.length), 1);
+            const out = [];
+            for (let line = 0; line < height; line += 1) {
+                const cellLines = cells.map((cellLines2, ci) => {
+                    const cellLine = cellLines2[line] ?? '';
+                    const pad = Math.max(0, colWidths[ci] - (0, box_1.visibleLength)(cellLine));
+                    return ' ' + cellLine + ' '.repeat(pad) + ' ';
+                });
+                out.push(indent + vBar + cellLines.join(vBar) + vBar);
+            }
+            return out.join('\n');
+        };
+        const wrappedHeader = headers.map((h, i) => wrapCell(h, colWidths[i]));
+        const wrappedRows = rows.map((r) => r.map((c, i) => wrapCell(c, colWidths[i])));
+        const lines = [rule(ch.topLeft, ch.teeDown, ch.topRight)];
+        if (headers.length > 0) {
+            lines.push(renderRow(wrappedHeader));
+            lines.push(rule(ch.teeRight, ch.cross, ch.teeLeft));
+        }
+        for (const row of wrappedRows)
+            lines.push(renderRow(row));
+        lines.push(rule(ch.botLeft, ch.teeUp, ch.botRight));
+        return lines.join('\n') + '\n';
+    };
     cachedRenderer = {
         render(text) {
             try {

package/dist/cli/v4/setupWizard.js

@@ -47,6 +47,8 @@ const box_1 = require("./box");
 // the cost of broken unit tests under the test runtime.
 const successScreen_1 = require("./onboarding/successScreen");
 const providerPicker_1 = require("./onboarding/providerPicker");
+// v4.8.0 Slice 10b — bar + chrome tokens for step headers.
+const tokens_1 = require("./design/tokens");
 const modelFetch_1 = require("../../core/v4/providers/modelFetch");
 const probe_1 = require("../../core/v4/providers/probe");
 // Phase 30.2.1 — provider order optimised for new-user time-to-first-chat.
@@ -537,8 +539,19 @@ async function runSetupWizard(opts = {}) {
     if (opts.prompts) {
         display.printBanner();
     }
-    display.write('\nWelcome — let\'s pick a provider.\n');
-    display.write(`${kleur_1.default.dim('(Press Enter to accept Groq — free + fastest setup.)')}\n\n`);
+    // v4.8.0 Slice 10b — step-header helper. Each major wizard step
+    // starts with `  ▎ Set up Aiden  step N` painted with the orange
+    // panel bar so the flow visually consistent with /help and the
+    // approval panel. Inquirer widgets render below unchanged.
+    const stepHeader = (n) => {
+        const bar = display.applyColors(tokens_1.glyphs.panel.bar, 'brand');
+        const title = display.applyColors('Set up Aiden', 'heading');
+        const sub = display.applyColors(`step ${n}`, 'muted');
+        return `\n  ${bar}  ${title}  ${sub}\n`;
+    };
+    display.write(stepHeader(1));
+    display.write('  Welcome — let\'s pick a provider.\n');
+    display.write(`  ${kleur_1.default.dim('(Press Enter to accept Groq — free + fastest setup.)')}\n\n`);
     // Phase 30.2.1 — Groq is the new recommended default for first-time
     // users: free tier, fastest signup, and avoids the surprise charge
     // path of paid providers. Together AI moved to position [8] paid.
@@ -695,6 +708,9 @@ async function runSetupWizard(opts = {}) {
         // anyway, so the reorder bought nothing there. Existing test
         // fixtures provide inputs in legacy order; preserving custom's
         // order keeps them green.
+        if (provider.kind === 'key' || provider.kind === 'subscription' || provider.kind === 'local') {
+            display.write(stepHeader(2));
+        }
         let apiKey;
         let baseUrl;
         if (provider.kind === 'local') {
@@ -713,6 +729,7 @@ async function runSetupWizard(opts = {}) {
         }
         // provider.kind === 'custom' — defer credential prompts until AFTER
         // the model picker below.
+        display.write(stepHeader(3));
         // Step 3: live model fetch + pick.
         //
         // Test-harness gate: when the caller injected `opts.prompts` (only

package/dist/cli/v4/skinEngine.js

@@ -66,6 +66,13 @@ const DEFAULT_SKIN = {
         // (which shares the colour) so callers can differentiate in code
         // even though they render identically.
         degraded: [0xff, 0xc1, 0x07],
+        // v4.8.0 Slice 7 hotfix #2 — purple accent for the turn-counter
+        // segment (⌘) in the status footer. #a48be0 reads as a soft
+        // lavender that doesn't compete with brand orange.
+        metric_turn: [0xa4, 0x8b, 0xe0],
+        // v4.8.0 Slice 8 — tertiary dim grey, dimmer than `muted` (warm
+        // tint) for lowest-priority text like unchecked task markers.
+        tertiary: [0x6a, 0x6a, 0x6a],
     },
     glyphs: {
         bullet: '•',
@@ -99,6 +106,10 @@ const LIGHT_SKIN = {
         heading: [0xc4, 0x42, 0x10],
         session: [0x00, 0x55, 0x88],
         degraded: [0x80, 0x60, 0x00],
+        // Slice 7 hotfix #2 — deeper purple on light bg keeps contrast budget.
+        metric_turn: [0x6e, 0x50, 0xaa],
+        // Slice 8 — lighter grey on light bg keeps the dim-but-readable feel.
+        tertiary: [0x9a, 0x9a, 0x9a],
     },
     glyphs: { ...DEFAULT_SKIN.glyphs },
 };
@@ -118,6 +129,8 @@ const MONOCHROME_SKIN = {
         heading: null,
         session: null,
         degraded: null,
+        metric_turn: null,
+        tertiary: null,
     },
     glyphs: {
         bullet: '*',

package/dist/cli/v4/table.js

@@ -23,6 +23,7 @@ exports.renderTable = renderTable;
 const stringWidth = require('string-width');
 const skinEngine_1 = require("./skinEngine");
 const box_1 = require("./box");
+const tokens_1 = require("./design/tokens");
 /**
  * Visible (post-ANSI-strip) column width. Falls back to
  * `visibleLength` from box.ts when string-width is unavailable
@@ -167,13 +168,32 @@ function renderTable(rows, cols, opts = {}) {
             }
         }
     }
-    // Border characters (sharp ASCII).
-    const TL = '┌', TR = '┐', BL = '└', BR = '┘';
-    const T = '┬', B = '┴', L = '├', R = '┤';
-    const X = '┼', H = '─', V = '│';
+    // Border characters — token-sourced from design/tokens.ts (v4.8.0 Slice 3).
+    const { topLeft: TL, topRight: TR, botLeft: BL, botRight: BR } = tokens_1.glyphs.chrome;
+    const { teeDown: T, teeUp: B, teeRight: L, teeLeft: R } = tokens_1.glyphs.chrome;
+    const { cross: X, hLine: H, vLine: V } = tokens_1.glyphs.chrome;
     const ind = ' '.repeat(indent);
-    // Top border.
-    const top = TL + widths.map((w) => H.repeat(w + 2)).join(T) + TR;
+    // Total inner content width across all cells + inner separators.
+    // Used by title-embedded top border + page footer.
+    const innerWidth = widths.reduce((s, w) => s + w + 2, 0) + (numCols - 1);
+    // v4.8.0 Slice 3 — top border with optional embedded title + count.
+    // Format: `┌─ title ──────────── totalCount ──┐`
+    // Pads the centre with `─` so the right edge stays aligned regardless
+    // of title / count length. Falls back to the legacy plain top border
+    // when neither field is supplied.
+    let top;
+    if (opts.title || opts.totalCount) {
+        const titleText = opts.title ? ` ${opts.title} ` : '';
+        const countText = opts.totalCount ? ` ${opts.totalCount} ` : '';
+        const fixed = vWidth(titleText) + vWidth(countText);
+        const filler = Math.max(0, innerWidth - fixed);
+        const titlePainted = opts.title ? skin.applyColors(titleText, 'heading') : '';
+        const countPainted = opts.totalCount ? skin.applyColors(countText, 'muted') : '';
+        top = TL + H + titlePainted + H.repeat(filler) + countPainted + H + TR;
+    }
+    else {
+        top = TL + widths.map((w) => H.repeat(w + 2)).join(T) + TR;
+    }
     // Header row — heading colour, padded. Truncate first if the
     // header itself is wider than the allocated width (rare, but
     // keeps borders aligned under aggressive narrow-width pressure).
@@ -203,13 +223,50 @@ function renderTable(rows, cols, opts = {}) {
         });
         bodyLines.push(V + cells.join(V) + V);
     });
-    // Bottom border.
-    const bot = BL + widths.map((w) => H.repeat(w + 2)).join(B) + BR;
+    // v4.8.0 Slice 3 — pagination footer above the bottom border. Renders
+    // `← prev · page X/Y · next →` centred inside the inner width. Side
+    // arrows are dim when the page is at the edge so users can read
+    // "at-end" cleanly. Caller wires hotkeys; we just paint the chrome.
+    let pageFooter = null;
+    if (opts.page) {
+        const { current, total } = opts.page;
+        const atStart = current <= 1;
+        const atEnd = current >= total;
+        const leftKind = atStart ? 'muted' : 'session';
+        const rightKind = atEnd ? 'muted' : 'session';
+        const left = skin.applyColors('← prev', leftKind);
+        const mid = skin.applyColors(`page ${current}/${total}`, 'muted');
+        const right = skin.applyColors('next →', rightKind);
+        const sep = skin.applyColors(' · ', 'muted');
+        const body = `${left}${sep}${mid}${sep}${right}`;
+        const bodyW = vWidth('← prev') + vWidth(` · page ${current}/${total} · `) + vWidth('next →');
+        const padW = Math.max(0, innerWidth - bodyW);
+        const lpad = Math.floor(padW / 2);
+        const rpad = padW - lpad;
+        pageFooter = V + ' '.repeat(lpad) + body + ' '.repeat(rpad) + V;
+    }
+    // Bottom border. Skip the inner tees when the title-style top was
+    // used (legacy plain bottom keeps column alignment for un-titled
+    // tables; a title-only border on top reads cleanest with a plain
+    // bottom mirror).
+    const bot = (opts.title || opts.totalCount)
+        ? BL + H.repeat(innerWidth) + BR
+        : BL + widths.map((w) => H.repeat(w + 2)).join(B) + BR;
+    // v4.8.0 Slice 3 — empty-state path. Borders stay so the layout
+    // weight matches a populated table; the body is one centered line.
+    if (rows.length === 0 && opts.emptyMessage) {
+        const msg = skin.applyColors(opts.emptyMessage, 'muted');
+        const pad = Math.max(0, innerWidth - vWidth(opts.emptyMessage));
+        const lpad = Math.floor(pad / 2);
+        const emptyRow = V + ' '.repeat(lpad) + msg + ' '.repeat(pad - lpad) + V;
+        return [top, emptyRow, bot].map((l) => ind + l).join('\n') + '\n';
+    }
     const allLines = [
         top,
         headerRow,
         ...(showRule ? [rule] : []),
         ...bodyLines,
+        ...(pageFooter ? [pageFooter] : []),
         bot,
     ].map((l) => ind + l);
     return allLines.join('\n') + '\n';

package/dist/core/v4/aidenAgent.js

@@ -166,6 +166,7 @@ class AidenAgent {
         this.resolveVerifiedFlag = opts.resolveVerifiedFlag;
         this.resolveToolset = opts.resolveToolset;
         this.resolveMutates = opts.resolveMutates;
+        this.resolveUiOnly = opts.resolveUiOnly;
         this.promptBuilder = opts.promptBuilder;
         this.promptBuilderOptions = opts.promptBuilderOptions;
         this.contextCompressor = opts.contextCompressor;
@@ -839,6 +840,28 @@ class AidenAgent {
                     finalContent = '';
                     break;
                 }
+                // v4.8.0 — uiOnly tools are signal channels, not executable
+                // tools. The model calls them to communicate render-time
+                // state. Dispatch loop skips execute / iteration / mutation
+                // marking / verifier / trace / observability hooks and fires
+                // onUiEvent on the caller. A '(no output)' tool_result is
+                // pushed to satisfy the provider protocol (every tool_call_id
+                // needs a matching tool_result). Listener exceptions are
+                // swallowed so a bad UI handler cannot break the turn.
+                if (this.resolveUiOnly?.(call.name) === true) {
+                    turnToolMessages.push({
+                        role: 'tool',
+                        toolCallId: call.id,
+                        content: '(no output)',
+                    });
+                    try {
+                        runOptions.onUiEvent?.(call.name, call.arguments);
+                    }
+                    catch {
+                        // defensive — UI listener faults must never break dispatch
+                    }
+                    continue;
+                }
                 this.onToolCall?.(call, 'before');
                 // v4.2 Phase 4 — mark any active checkpoints as containing a
                 // mutating call BEFORE dispatch. Done pre-dispatch (not post)

package/dist/core/v4/auxiliaryClient.js

@@ -45,19 +45,35 @@ class AuxiliaryClient {
             return this.opts.adapter;
         if (!this.opts.resolver)
             return null;
-        this.resolveCallCount += 1;
-        try {
-            const adapter = await this.opts.resolver.resolve({
-                providerId: this.opts.defaultProvider,
-                modelId: this.opts.defaultModel,
-            });
-            return adapter;
-        }
-        catch (err) {
-            this.warn(`auxiliary client unavailable (${this.opts.defaultProvider}/${this.opts.defaultModel}): ${err.message}`);
-            this.adapterUnavailable = true;
-            return null;
+        // v4.8.0 Slice 11 — resolution chain: default first, then each
+        // fallback in order. The first attempt that resolves wins. This
+        // is the routing-fix entry point for the chatgpt-plus + gpt-5
+        // bug: aidenCLI hands us Groq as the default and the parent
+        // provider/model as the fallback, so auxiliary calls land on
+        // Groq when configured and the parent only sees traffic when
+        // Groq is absent.
+        const attempts = [
+            { providerId: this.opts.defaultProvider, modelId: this.opts.defaultModel },
+            ...(this.opts.fallbacks ?? []),
+        ];
+        const failures = [];
+        for (const att of attempts) {
+            this.resolveCallCount += 1;
+            try {
+                const adapter = await this.opts.resolver.resolve({
+                    providerId: att.providerId,
+                    modelId: att.modelId,
+                });
+                this.warn(`auxiliary resolved via ${att.providerId}/${att.modelId}`);
+                return adapter;
+            }
+            catch (err) {
+                failures.push(`${att.providerId}/${att.modelId}: ${err.message}`);
+            }
         }
+        this.warn(`auxiliary client unavailable (tried ${attempts.length}): ${failures.join('; ')}`);
+        this.adapterUnavailable = true;
+        return null;
     }
     /** Resolve count for tests (verifies single-resolution behaviour). */
     _resolveCallCount() {
@@ -122,7 +138,24 @@ class AuxiliaryClient {
         this.usage.set(purpose, cur);
     }
     warn(msg) {
-        (this.opts.warn ?? ((m) => console.warn(`[auxiliary] ${m}`)))(msg);
+        // v4.8.0 Slice 5 — gate console output behind AIDEN_VERBOSE.
+        // Auxiliary failures are recoverable (the main loop continues;
+        // result content is just empty), so the warning is pure noise
+        // for end users. Power users set AIDEN_VERBOSE=1 to surface them.
+        // Inline env-read preserves the core → cli no-import invariant;
+        // canonical isVerbose() lives at cli/v4/design/tokens.ts.
+        //
+        // v4.8.0 Slice 11 — if opts.warn is explicitly injected, always
+        // forward (tests + advanced callers register their own sink and
+        // expect every message). The AIDEN_VERBOSE gate now applies only
+        // to the default console.warn fallback that end-users see.
+        if (this.opts.warn) {
+            this.opts.warn(msg);
+            return;
+        }
+        if (process.env.AIDEN_VERBOSE !== '1')
+            return;
+        console.warn(`[auxiliary] ${msg}`);
     }
     async withTimeout(p, ms) {
         return new Promise((resolve, reject) => {