aiden-runtime 4.8.0 → 4.9.0

package/dist/cli/v4/pasteIntercept.js

@@ -6,19 +6,52 @@
  * Aiden — local-first agent.
  */
 /**
- * cli/v4/pasteIntercept.ts — Tier-3.1a (v4.1-tier3.1a)
+ * cli/v4/pasteIntercept.ts — stdin pre-tap for bracketed paste.
  *
- * Stdin pre-tap that handles bracketed paste sequences before
- * @inquirer/prompts sees them. Modern inquirer treats any internal
- * `\n` as Enter and resolves early, so a multi-line paste auto-
- * submits before the user has a chance to review. This module
- * intercepts paste boundaries (CSI 2004), captures the content,
- * persists it via the existing pasteCompression manifest, and
- * substitutes a `[paste #<id>: <N> lines, <KB>]` label on stdin.
+ * Modern @inquirer/prompts treats any embedded `\n` as Enter and
+ * resolves early, so a multi-line paste would auto-submit one line
+ * at a time. This module intercepts paste payloads BEFORE inquirer
+ * sees them, persists them to a manifest, and substitutes a
+ * `[paste #<id>: <N> lines, <bytes>]` label on stdin. The user sees
+ * the label inside inquirer's input buffer, edits it like any other
+ * text, then presses Enter to submit; `chatSession.readUserInput`
+ * swaps the label back for the original via `getPasteOriginal(id)`
+ * before handing to the agent.
  *
- * The user sees the label in inquirer's input buffer, presses Enter
- * to submit, and chatSession.readUserInput swaps the label for the
- * original via getPasteOriginal(id) before handing to the agent.
+ * v4.8.1 Slice 2 hotfix #6 — robustness rebuild for terminal-
+ * environment diversity:
+ *
+ *   • State machine survives reads split across chunk boundaries.
+ *     The begin or end marker can arrive partially in one chunk
+ *     and be completed by the next; the parser keeps state in `buf`
+ *     until a full marker is observed.
+ *
+ *   • 800ms watchdog flushes a stuck `in_marker_paste` state if
+ *     the terminal never delivers PASTE_END (mosh/tmux/SSH paths
+ *     have all been observed to drop end markers under load).
+ *
+ *   • Degraded marker forms get normalised to canonical at the
+ *     intercept boundary. Visible-escape variants (`^[[200~`) are
+ *     the common case from terminals that escape control sequences
+ *     for display.
+ *
+ *   • CRLF/CR → LF normalisation is applied universally on every
+ *     incoming chunk, not just inside marker payloads. Some
+ *     clipboard payloads carry CR-only line endings.
+ *
+ *   • 30ms timing accumulation catches line-by-line paste delivery
+ *     — the failure mode that surfaced after hotfix #5. When a
+ *     terminal delivers a paste as N small `"<line>\n"` chunks
+ *     instead of one bulk chunk, each chunk has a single trailing
+ *     `\n` and would otherwise pass through as an Enter keystroke.
+ *     The accumulator holds candidate chunks (`length > 1` so the
+ *     bare Enter keystroke `"\n"` is never held) for a 30ms window;
+ *     if another candidate arrives, both are accumulated as a
+ *     multi-line paste and substituted with the placeholder before
+ *     any `\n` reaches inquirer. If no follow-up arrives within the
+ *     window, the held chunk is emitted unchanged (normal Enter).
+ *     30ms is imperceptible to humans and well below sustained
+ *     keystroke timing.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -33,7 +66,16 @@ const node_path_1 = __importDefault(require("node:path"));
 const paths_1 = require("../../core/v4/paths");
 const PASTE_BEGIN = '\x1b[200~';
 const PASTE_END = '\x1b[201~';
-/** id → original text (in-memory swap table). */
+/**
+ * Degraded marker patterns observed in the wild. Each is rewritten
+ * to canonical at the normalisation boundary so the parser only
+ * needs to know about one form.
+ */
+const DEGRADED_BEGIN = /\^\[\[200~/g;
+const DEGRADED_END = /\^\[\[201~/g;
+const ACCUMULATION_MS = 30;
+const WATCHDOG_MS = 800;
+/** id → original text (in-memory swap table). Disk has /pastes/paste_<id>.txt as source of truth for /show. */
 const originals = new Map();
 function pastesDir() {
     return node_path_1.default.join((0, paths_1.resolveAidenPaths)().root, 'pastes');
@@ -74,18 +116,17 @@ function compressSync(text) {
 }
 /**
  * Look up the original text for a paste id. Returns undefined if the
- * id was never seen by this process (e.g. the user typed a label by
- * hand). Disk is the source of truth for /show <id>; this map is the
- * fast path for the in-flight prompt swap.
+ * id was never seen by this process. Disk (/pastes/paste_<id>.txt)
+ * is the source of truth for /show <id>; this map is the fast path
+ * for the in-flight prompt swap.
  */
 function getPasteOriginal(id) {
     return originals.get(id);
 }
 /**
  * Replace `[paste #N: …]` patterns in `input` with the corresponding
- * original text from the in-process map. Patterns whose id we don't
- * know are left intact (might be user-typed). Returns the swapped
- * string.
+ * original text. Patterns whose id we don't know are left intact
+ * (might be user-typed by hand).
  */
 function expandPasteLabels(input) {
     return input.replace(/\[paste #(\d+):[^\]]*\]/g, (m, id) => {
@@ -93,6 +134,38 @@ function expandPasteLabels(input) {
         return orig !== undefined ? orig : m;
     });
 }
+/**
+ * Universal normalisation applied at the intercept boundary:
+ * CRLF + bare CR → LF, then degraded marker variants → canonical.
+ */
+function normalize(text) {
+    let t = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    t = t.replace(DEGRADED_BEGIN, PASTE_BEGIN);
+    t = t.replace(DEGRADED_END, PASTE_END);
+    return t;
+}
+/**
+ * Decide whether `payload` should emit inline (small single-line) or
+ * be funnelled through the disk-backed placeholder system. Same
+ * thresholds for marker-wrapped and timing-accumulated paths so the
+ * user sees identical chrome regardless of how the paste arrived.
+ */
+function payloadToEmission(payload) {
+    const trimmed = payload.replace(/\n+$/, '');
+    if (!trimmed.includes('\n') && trimmed.length <= 500) {
+        return trimmed;
+    }
+    try {
+        const { id, label } = compressSync(trimmed);
+        originals.set(id, trimmed);
+        return label;
+    }
+    catch {
+        // Disk failure: collapse newlines so the auto-submit we're
+        // preventing doesn't fire downstream.
+        return trimmed.replace(/\n/g, ' ');
+    }
+}
 let installed = null;
 /**
  * Install the stdin pre-tap. Wraps `process.stdin.emit('data', …)`
@@ -103,72 +176,140 @@ let installed = null;
  * MCP serve mode: never call this — `aiden mcp serve` doesn't run
  * the REPL.
  */
-function installPasteInterceptor(stdin) {
+function installPasteInterceptor(stdin, opts = {}) {
     if (installed)
         return installed.restore;
+    const accumulationMs = opts.accumulationMs ?? ACCUMULATION_MS;
+    const watchdogMs = opts.watchdogMs ?? WATCHDOG_MS;
     const origEmit = stdin.emit.bind(stdin);
-    const state = { inPaste: false, buf: '' };
-    function processChunk(text) {
-        let out = '';
+    // State machine —
+    //   normal           : default; chunks pass through or accumulate
+    //   in_marker_paste  : between PASTE_BEGIN and PASTE_END; buf accumulates payload
+    let mode = 'normal';
+    let buf = '';
+    let markerTimer = null;
+    let pendingChunk = null;
+    let pendingTimer = null;
+    function emitDownstream(text) {
+        if (text.length === 0)
+            return;
+        origEmit('data', Buffer.from(text, 'utf8'));
+    }
+    function clearMarkerWatchdog() {
+        if (markerTimer) {
+            clearTimeout(markerTimer);
+            markerTimer = null;
+        }
+    }
+    function armMarkerWatchdog() {
+        clearMarkerWatchdog();
+        markerTimer = setTimeout(() => {
+            // PASTE_END never arrived. Flush whatever we have and reset.
+            const payload = buf;
+            buf = '';
+            mode = 'normal';
+            markerTimer = null;
+            emitDownstream(payloadToEmission(payload));
+        }, watchdogMs);
+    }
+    function clearPending() {
+        if (pendingTimer) {
+            clearTimeout(pendingTimer);
+            pendingTimer = null;
+        }
+        pendingChunk = null;
+    }
+    function flushPendingAsIs() {
+        if (pendingChunk === null)
+            return;
+        const chunk = pendingChunk;
+        clearPending();
+        // Pending was a normal Enter — emit as-is, don't placeholder.
+        emitDownstream(chunk);
+    }
+    function flushPendingAsPaste() {
+        if (pendingChunk === null)
+            return;
+        const chunk = pendingChunk;
+        clearPending();
+        emitDownstream(payloadToEmission(chunk));
+    }
+    function processNormalised(text) {
         let cursor = 0;
         while (cursor < text.length) {
-            if (state.inPaste) {
+            if (mode === 'in_marker_paste') {
                 const endIdx = text.indexOf(PASTE_END, cursor);
                 if (endIdx === -1) {
-                    state.buf += text.slice(cursor);
+                    buf += text.slice(cursor);
                     cursor = text.length;
+                    // Watchdog stays armed — extending the buf without an end
+                    // marker doesn't restart the clock; we still want to flush
+                    // if the entire turn never produces PASTE_END.
                 }
                 else {
-                    state.buf += text.slice(cursor, endIdx);
+                    buf += text.slice(cursor, endIdx);
                     cursor = endIdx + PASTE_END.length;
-                    // Tier-3.1c: terminals (and some clipboard payloads) emit a
-                    // trailing CR/LF immediately after PASTE_END. Without this
-                    // swallow the bytes pass through to readline, where they
-                    // become an Enter event and auto-submit the prompt before
-                    // the user has reviewed the paste. Eat at most one CR + one
-                    // LF (in either order) right after PASTE_END.
-                    if (text[cursor] === '\r')
-                        cursor += 1;
+                    // Swallow a trailing newline that some terminals emit
+                    // immediately after PASTE_END.
                     if (text[cursor] === '\n')
                         cursor += 1;
-                    state.inPaste = false;
-                    const original = state.buf.replace(/\r\n/g, '\n');
-                    state.buf = '';
-                    // Strip a single trailing newline (Enter at end of paste).
-                    const trimmed = original.replace(/\n+$/, '');
-                    if (!trimmed.includes('\n') && trimmed.length <= 500) {
-                        // Single-line, small — emit as-is so user can edit.
-                        out += trimmed;
-                    }
-                    else {
-                        // Multi-line or large — disk-back + emit label.
-                        try {
-                            const { id, label } = compressSync(trimmed);
-                            originals.set(id, trimmed);
-                            out += label;
-                        }
-                        catch {
-                            // Disk failure: fall back to a single-space substitute
-                            // so internal newlines don't trigger auto-submit.
-                            out += trimmed.replace(/\n/g, ' ');
-                        }
-                    }
+                    mode = 'normal';
+                    clearMarkerWatchdog();
+                    const payload = buf;
+                    buf = '';
+                    emitDownstream(payloadToEmission(payload));
                 }
+                continue;
             }
-            else {
-                const beginIdx = text.indexOf(PASTE_BEGIN, cursor);
-                if (beginIdx === -1) {
-                    out += text.slice(cursor);
-                    cursor = text.length;
+            // mode === 'normal'
+            const beginIdx = text.indexOf(PASTE_BEGIN, cursor);
+            if (beginIdx !== -1) {
+                // Pre-marker content: flush any pending and emit inline so
+                // it lands in inquirer's buffer ahead of the placeholder
+                // (preserves typed prefix when the user pastes after typing).
+                flushPendingAsIs();
+                if (beginIdx > cursor)
+                    emitDownstream(text.slice(cursor, beginIdx));
+                cursor = beginIdx + PASTE_BEGIN.length;
+                mode = 'in_marker_paste';
+                armMarkerWatchdog();
+                continue;
+            }
+            // No marker in the remainder.
+            const remainder = text.slice(cursor);
+            cursor = text.length;
+            const nlCount = (remainder.match(/\n/g) ?? []).length;
+            const hasInternalNl = nlCount > 1 || (nlCount === 1 && !remainder.endsWith('\n'));
+            if (hasInternalNl) {
+                // Single bulk chunk with internal newlines — instant
+                // placeholder. Flush pending first so any prior single-line
+                // candidate isn't lost.
+                flushPendingAsIs();
+                emitDownstream(payloadToEmission(remainder));
+                continue;
+            }
+            // Candidate paste-line: non-empty content ending in `\n` with
+            // length > 1 (excludes bare Enter keystroke `"\n"`).
+            const isCandidate = remainder.endsWith('\n') && remainder.length > 1;
+            if (isCandidate) {
+                if (pendingChunk !== null) {
+                    // Already pending — append, restart the window.
+                    pendingChunk += remainder;
+                    if (pendingTimer)
+                        clearTimeout(pendingTimer);
+                    pendingTimer = setTimeout(flushPendingAsPaste, accumulationMs);
                 }
                 else {
-                    out += text.slice(cursor, beginIdx);
-                    cursor = beginIdx + PASTE_BEGIN.length;
-                    state.inPaste = true;
+                    pendingChunk = remainder;
+                    pendingTimer = setTimeout(flushPendingAsIs, accumulationMs);
                 }
+                continue;
             }
+            // Non-candidate (bare Enter, or non-`\n`-terminated keystroke).
+            // Flush pending first since this chunk closes the window.
+            flushPendingAsIs();
+            emitDownstream(remainder);
         }
-        return out;
     }
     const wrappedEmit = function (event, ...args) {
         if (event !== 'data')
@@ -176,19 +317,22 @@ function installPasteInterceptor(stdin) {
         const chunk = args[0];
         if (chunk == null)
             return origEmit(event, ...args);
-        const text = Buffer.isBuffer(chunk)
+        const raw = Buffer.isBuffer(chunk)
             ? chunk.toString('utf8')
             : (typeof chunk === 'string' ? chunk : String(chunk));
-        const processed = processChunk(text);
-        if (processed.length === 0)
-            return true; // suppress entirely
-        const nextArgs = [Buffer.from(processed, 'utf8'), ...args.slice(1)];
-        return origEmit(event, ...nextArgs);
+        const normalised = normalize(raw);
+        processNormalised(normalised);
+        // We always claim to have handled the emit. Downstream listeners
+        // fire from `emitDownstream` immediately on the same tick OR
+        // from a deferred timer in the accumulation case.
+        return true;
     };
     stdin.emit = wrappedEmit;
     const restore = () => {
         if (!installed)
             return;
+        clearPending();
+        clearMarkerWatchdog();
         stdin.emit = origEmit;
         installed = null;
     };

package/dist/cli/v4/replyRenderer.js

@@ -39,6 +39,7 @@ const tokens_1 = require("./design/tokens");
 // 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) {
@@ -182,7 +183,7 @@ function renderBlockquote(quote) {
     return quote
         .split('\n')
         .map((ln) => (ln.length === 0 ? rail.trimEnd() : `${rail}${ln}`))
-        .join('\n') + '\n';
+        .join('\n') + '\n\n'; // v4.9.0 pre-ship UI: blank line after blockquote
 }
 /**
  * v4.1.3-essentials reply-polish: 4-tier heading hierarchy using the
@@ -632,11 +633,150 @@ function getReplyRenderer() {
             }
         }
         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.
+        // v4.9.0 pre-ship UI: top-level list closes with a BLANK LINE
+        // (`\n\n`) so a following paragraph / heading / table reads with
+        // breathing room. Nested lists stay tight (`\n`) so they nest
+        // cleanly under their parent item.
         const out = lines.join('\n');
-        return proto._listDepth === 0 ? out + '\n' : out + '\n';
+        return proto._listDepth === 0 ? out + '\n\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) {

package/dist/cli/v4/skinEngine.js

@@ -32,10 +32,58 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
+// v4.9.0 Slice 1a hotfix — read live theme overrides from tokens.ts.
+const tokens_1 = require("./design/tokens");
+const themeRegistry_1 = require("../../core/v4/theme/themeRegistry");
 /** Wrap text with a 24-bit ANSI foreground colour. */
 function ansiRgb(text, r, g, b) {
     return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
 }
+/**
+ * v4.9.0 Slice 1a hotfix — map each SkinEngine `ColorKind` to a dotted
+ * path inside the v4.8 `tokens.ts` colour tree so the legacy paint API
+ * (`applyColors(text, kind)`) can resolve user-theme overrides without
+ * touching the legacy skin YAML cache. Each kind picks the closest
+ * semantic equivalent from the new tree; kinds without a natural fit
+ * (e.g. `agent`, `user`) fall through to the skin's own RGB tuple.
+ *
+ * The lookup is only consulted when a user theme is active (i.e.
+ * `getActiveThemePath() !== null`). When no theme is loaded, the
+ * legacy skin path runs unchanged — preserves /skin custom-palette
+ * users from being silently overridden by tokens.ts baselines.
+ */
+const COLOR_KIND_TO_TOKEN_PATH = {
+    brand: 'brand.primary',
+    accent: 'brand.primary',
+    heading: 'brand.primary',
+    tool: 'metrics.model',
+    session: 'metrics.model',
+    error: 'semantic.error',
+    warn: 'semantic.warn',
+    success: 'semantic.success',
+    muted: 'content.secondary',
+    tertiary: 'content.tertiary',
+    metric_turn: 'metrics.turnCount',
+    degraded: 'semantic.warn',
+};
+function hexToRgb(hex) {
+    const m3 = /^#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])$/.exec(hex);
+    if (m3)
+        return [parseInt(m3[1] + m3[1], 16), parseInt(m3[2] + m3[2], 16), parseInt(m3[3] + m3[3], 16)];
+    const m6 = /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/.exec(hex);
+    if (m6)
+        return [parseInt(m6[1], 16), parseInt(m6[2], 16), parseInt(m6[3], 16)];
+    return null;
+}
+function readDottedPath(root, dotted) {
+    let node = root;
+    for (const seg of dotted.split('.')) {
+        if (node === null || typeof node !== 'object')
+            return undefined;
+        node = node[seg];
+    }
+    return node;
+}
 const BRAND_ORANGE = [0xff, 0x6b, 0x35];
 const DEFAULT_SKIN = {
     name: 'default',
@@ -250,6 +298,25 @@ class SkinEngine {
     applyColors(text, kind) {
         if (this.forceMono)
             return text;
+        // v4.9.0 Slice 1a hotfix — when a user theme is active, resolve
+        // the colour from the live tokens.ts tree FIRST. This lets a
+        // ~/.aiden/theme.yaml override every paint surface that routes
+        // through SkinEngine (Aiden reply chrome, panel bars, status
+        // footer text, tool rows) without requiring users to also
+        // re-author a parallel ~/.aiden/skins/<name>.yaml. When no user
+        // theme is active, the legacy skin RGB path runs unchanged —
+        // preserves /skin custom-palette users from regression.
+        if ((0, themeRegistry_1.getActivePath)() !== null) {
+            const dotted = COLOR_KIND_TO_TOKEN_PATH[kind];
+            if (dotted) {
+                const hex = readDottedPath(tokens_1.colors, dotted);
+                if (typeof hex === 'string') {
+                    const rgb = hexToRgb(hex);
+                    if (rgb)
+                        return ansiRgb(text, rgb[0], rgb[1], rgb[2]);
+                }
+            }
+        }
         const rgb = this.current.colors[kind];
         if (!rgb)
             return text;