aiden-runtime 4.8.1 → 4.9.1

package/dist/cli/v4/commands/memorySlash.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memory = exports.MEMORY_SHELL_ONLY = void 0;
+exports.dispatchMemorySlash = dispatchMemorySlash;
+const memory_1 = require("./memory");
+/** Actions that need the full CLI surface (confirmation / destructive). */
+exports.MEMORY_SHELL_ONLY = new Set(['remove', 'restore']);
+/**
+ * Pure dispatch — exported for tests + reuse. Either prints a shell
+ * hint OR delegates to the provided `runMemory` runner. Side effects
+ * confined to the supplied `write` sink.
+ */
+async function dispatchMemorySlash(opts) {
+    const a = (opts.action || 'list').toLowerCase();
+    if (exports.MEMORY_SHELL_ONLY.has(a)) {
+        opts.write(`⚠ /memory ${a} not available inside chat (destructive operation)\n`);
+        opts.write('  Quit (/quit) and run from shell:\n\n');
+        const tail = opts.args.length > 0 ? ' ' + opts.args.join(' ') : '';
+        opts.write(`    aiden memory ${a}${tail}\n`);
+        return;
+    }
+    await opts.runMemory(a, opts.args, { writeOut: opts.write, writeErr: opts.write });
+}
+exports.memory = {
+    name: 'memory',
+    description: 'Manage memory (list / show / add / namespaces / pending / approve / review).',
+    category: 'system',
+    icon: '🧠',
+    handler: async (ctx) => {
+        await dispatchMemorySlash({
+            action: ctx.args[0] ?? 'list',
+            args: ctx.args.slice(1),
+            write: (s) => ctx.display.write(s),
+            runMemory: memory_1.runMemorySubcommand,
+        });
+        return {};
+    },
+};

package/dist/cli/v4/commands/recovery.js

@@ -35,7 +35,7 @@ function pad(value, width) {
 }
 exports.recovery = {
     name: 'recovery',
-    description: 'Inspect recurring failure patterns + recoveries (v4.6 Phase 3b).',
+    description: 'Inspect recurring failure patterns + recoveries.',
     category: 'system',
     icon: '🩹',
     handler: async (ctx) => {

package/dist/cli/v4/commands/skin.js

@@ -7,6 +7,13 @@ exports.skin = {
     category: 'system',
     icon: '🎨',
     handler: async (ctx) => {
+        // v4.9.0 Slice 1a — /skin is now an alias for the new /theme system.
+        // The legacy color skins (~/.aiden/skins/*.yaml, RGB-tuple format)
+        // continue to work alongside the new theme system; /skin still
+        // manages the SkinEngine palette. Theme tokens (panel chrome,
+        // status footer glyphs, shimmer) are controlled by /theme.
+        ctx.display.warn('/skin is deprecated in v4.9 — use /theme for full visual customisation. ' +
+            '/skin continues to work for legacy colour skins.');
         const engine = ctx.skin;
         if (!engine) {
             ctx.display.warn('Skin engine not wired in this context.');

package/dist/cli/v4/commands/theme.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.theme = void 0;
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/theme.ts — v4.9.0 Slice 1a.
+ *
+ * `/theme`              show current theme name + path + hint
+ * `/theme reload`       force re-read of ~/.aiden/theme.yaml
+ * `/theme reset`        delete ~/.aiden/theme.yaml, restore baseline
+ * `/theme edit`         print ~/.aiden/theme.yaml path
+ *
+ * `/theme list` and `/theme set <name>` ship in Slice 1b alongside
+ * the remaining 4 bundled themes.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const themeLoader_1 = require("../../../core/v4/theme/themeLoader");
+const themeRegistry_1 = require("../../../core/v4/theme/themeRegistry");
+const bundledThemes_1 = require("../../../core/v4/theme/bundledThemes");
+function themeFilePath(ctx) {
+    const root = ctx.paths?.root;
+    if (!root)
+        return null;
+    return node_path_1.default.join(root, 'theme.yaml');
+}
+function userThemesDir(ctx) {
+    const root = ctx.paths?.root;
+    if (!root)
+        return null;
+    return node_path_1.default.join(root, 'themes');
+}
+function listUserThemes(dir) {
+    if (!dir || !(0, node_fs_1.existsSync)(dir))
+        return [];
+    try {
+        return (0, node_fs_1.readdirSync)(dir)
+            .filter((f) => f.endsWith('.yaml'))
+            .map((f) => {
+            const name = f.replace(/\.yaml$/, '');
+            let description = '';
+            try {
+                const yaml = (0, node_fs_1.readFileSync)(node_path_1.default.join(dir, f), 'utf8');
+                const { parsed } = (0, themeLoader_1.parseThemeYaml)(yaml);
+                description = parsed?.description ?? '';
+            }
+            catch { /* tolerate unreadable */ }
+            return { name, description };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+exports.theme = {
+    name: 'theme',
+    description: 'Show, reload, reset, or open the user theme.yaml.',
+    category: 'system',
+    icon: '🎨',
+    handler: async (ctx) => {
+        const sub = ctx.rawArgs.trim();
+        const themePath = themeFilePath(ctx);
+        if (sub === '' || sub === 'show') {
+            const current = (0, themeRegistry_1.getCurrentName)();
+            const active = (0, themeRegistry_1.getActivePath)();
+            ctx.display.info(`Active theme: ${current}`);
+            if (active) {
+                ctx.display.info(`Source: ${active}`);
+            }
+            else if (themePath) {
+                ctx.display.info(`No user theme.yaml at ${themePath} — using bundled default.`);
+            }
+            ctx.display.info('Use /theme list, /theme set <name>, /theme reload, /theme reset, or /theme edit.');
+            return {};
+        }
+        if (sub === 'list') {
+            const current = (0, themeRegistry_1.getCurrentName)();
+            const bundled = (0, bundledThemes_1.listBundled)();
+            const userDir = userThemesDir(ctx);
+            const userList = listUserThemes(userDir);
+            ctx.display.info(`Active theme: ${current}`);
+            ctx.display.info('Available themes:');
+            const labelW = Math.max(...bundled.map((b) => b.name.length), ...userList.map((u) => u.name.length), 4);
+            for (const b of bundled) {
+                const marker = b.name === current ? '●' : '○';
+                const padded = b.name.padEnd(labelW);
+                ctx.display.info(`  ${marker} ${padded}  (bundled)  ${b.description}`);
+            }
+            for (const u of userList) {
+                const marker = u.name === current ? '●' : '○';
+                const padded = u.name.padEnd(labelW);
+                ctx.display.info(`  ${marker} ${padded}  (user)     ${u.description}`);
+            }
+            if (bundled.length === 0 && userList.length === 0) {
+                ctx.display.warn('No themes found. Reinstall aiden-runtime or use /theme edit to author one.');
+            }
+            return {};
+        }
+        if (sub.startsWith('set ') || sub === 'set') {
+            const name = sub.replace(/^set\s*/, '').trim();
+            if (!name) {
+                ctx.display.printError('Usage: /theme set <name>', `Try one of: ${bundledThemes_1.BUNDLED_NAMES.join(', ')} or /theme list for full options.`);
+                return {};
+            }
+            if (!themePath) {
+                ctx.display.warn('/theme set needs Aiden user-data paths — try in a real session.');
+                return {};
+            }
+            // Resolution order: bundled → user themes/ dir.
+            let yamlText = null;
+            let sourceLabel = '';
+            if ((0, bundledThemes_1.isBundled)(name)) {
+                yamlText = (0, bundledThemes_1.getYaml)(name);
+                sourceLabel = 'bundled';
+            }
+            if (!yamlText) {
+                const userDir = userThemesDir(ctx);
+                if (userDir) {
+                    const userFile = node_path_1.default.join(userDir, `${name}.yaml`);
+                    if ((0, node_fs_1.existsSync)(userFile)) {
+                        try {
+                            yamlText = (0, node_fs_1.readFileSync)(userFile, 'utf8');
+                            sourceLabel = 'user';
+                        }
+                        catch { /* fall through to not-found */ }
+                    }
+                }
+            }
+            if (!yamlText) {
+                ctx.display.printError(`Theme not found: "${name}"`, `Available bundled: ${bundledThemes_1.BUNDLED_NAMES.join(', ')}. Or create ~/.aiden/themes/${name}.yaml.`);
+                return {};
+            }
+            // Copy to ~/.aiden/theme.yaml and apply immediately (don't wait
+            // for the chokidar watcher debounce — slash-command-driven
+            // changes should feel instant).
+            try {
+                (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(themePath), { recursive: true });
+                (0, node_fs_1.writeFileSync)(themePath, yamlText, 'utf8');
+            }
+            catch (err) {
+                ctx.display.printError(`Could not write ${themePath}: ${err.message}`, 'Check filesystem permissions and try again.');
+                return {};
+            }
+            const { parsed, warnings } = (0, themeLoader_1.parseThemeYaml)(yamlText);
+            for (const w of warnings)
+                ctx.display.warn(`theme: ${w}`);
+            if (parsed) {
+                (0, themeRegistry_1.applyTheme)(parsed, themePath);
+                ctx.display.success(`✓ Theme set to ${name} (${sourceLabel}). Run /theme reset to revert to default.`);
+            }
+            else {
+                ctx.display.printError(`Theme "${name}" parsed empty; current theme retained.`, 'Check the warnings above for the specific YAML / hex error.');
+            }
+            return {};
+        }
+        if (sub === 'reload') {
+            if (!themePath) {
+                ctx.display.warn('/theme reload needs Aiden user-data paths — try in a real session.');
+                return {};
+            }
+            if (!(0, node_fs_1.existsSync)(themePath)) {
+                ctx.display.warn(`No theme file at ${themePath}. Use /theme edit to create one.`);
+                return {};
+            }
+            const { parsed, warnings } = (0, themeLoader_1.loadThemeFile)(themePath);
+            for (const w of warnings)
+                ctx.display.warn(`theme: ${w}`);
+            if (parsed) {
+                (0, themeRegistry_1.applyTheme)(parsed, themePath);
+                ctx.display.success(`Theme reloaded: ${parsed.name}`);
+            }
+            else {
+                ctx.display.printError('Theme parse failed; current theme retained.', 'Check the warnings above for the specific YAML / hex error.');
+            }
+            return {};
+        }
+        if (sub === 'reset') {
+            if (!themePath) {
+                ctx.display.warn('/theme reset needs Aiden user-data paths — try in a real session.');
+                return {};
+            }
+            if ((0, node_fs_1.existsSync)(themePath)) {
+                try {
+                    (0, node_fs_1.unlinkSync)(themePath);
+                }
+                catch (err) {
+                    ctx.display.warn(`Could not delete ${themePath}: ${err.message}`);
+                    return {};
+                }
+            }
+            (0, themeRegistry_1.resetToDefault)();
+            ctx.display.success('Theme reset to bundled default.');
+            return {};
+        }
+        if (sub === 'edit') {
+            if (!themePath) {
+                ctx.display.warn('/theme edit needs Aiden user-data paths — try in a real session.');
+                return {};
+            }
+            ctx.display.info(`Theme file: ${themePath}`);
+            if (!(0, node_fs_1.existsSync)(themePath)) {
+                ctx.display.info('File does not exist yet. Create it with your editor; Aiden hot-reloads on save.');
+            }
+            return {};
+        }
+        ctx.display.printError(`Unknown /theme subcommand: ${sub}`, 'Available: /theme | /theme list | /theme set <name> | /theme reload | /theme reset | /theme edit');
+        return {};
+    },
+};

package/dist/cli/v4/commands/trigger.js

@@ -369,7 +369,7 @@ async function runAddEmail(db, argv, out, err) {
     out(`poll interval: ${spec.pollIntervalMs}ms\n`);
     out(`allow-senders: ${spec.allowedSenders.join(', ')}\n`);
     out(`⚠ Password stored in plaintext in daemon.db (chmod 600 on POSIX,\n`);
-    out(`  user-private on Windows). Encryption-at-rest is deferred to v4.6+.\n`);
+    out(`  user-private on Windows). Encryption-at-rest is deferred to a future release.\n`);
     out(`Restart the daemon to activate the trigger.\n`);
     // Note: runAddEmail returns a Promise<number>, so the outer switch must
     // await it. (Already handled — runTriggerSubcommand is async.)

package/dist/cli/v4/design/tokens.js

@@ -16,7 +16,8 @@
  * isVerbose() reads env at call time (Ollama-options precedent).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERBOSE_MODE_ENV = exports.spacing = exports.glyphs = exports.colors = exports.TRAIL_PIPE = void 0;
+exports.VERBOSE_MODE_ENV = exports.spacing = exports.BASELINE_GLYPHS = exports.BASELINE_COLORS = exports.glyphs = exports.colors = exports.TRAIL_PIPE = void 0;
+exports._restoreBaselineForTokens = _restoreBaselineForTokens;
 exports.isVerbose = isVerbose;
 // Re-export so consumers can import the trail gutter from tokens
 // alongside the rest of the design system. The original constant
@@ -24,6 +25,20 @@ exports.isVerbose = isVerbose;
 // that imports from `display/toolTrail` directly.
 var toolTrail_1 = require("../display/toolTrail");
 Object.defineProperty(exports, "TRAIL_PIPE", { enumerable: true, get: function () { return toolTrail_1.TRAIL_PIPE; } });
+/**
+ * v4.9.0 Slice 1a — `colors` and `glyphs` were previously exported with
+ * `as const` (frozen literal-typed object). They are now mutable
+ * singletons so the ThemeRegistry can swap values at runtime when a
+ * user theme is loaded from `~/.aiden/theme.yaml`. Every existing
+ * consumer (`import { colors, glyphs } from '../design/tokens'`)
+ * continues to work because property reads now reflect the LIVE
+ * current values.
+ *
+ * `BASELINE_COLORS` / `BASELINE_GLYPHS` are deep-frozen snapshots
+ * captured at module load. The registry's `resetToDefault()` restores
+ * from these. Consumers that need the unmodified default (e.g. tests)
+ * can import these directly.
+ */
 // ── Colors ────────────────────────────────────────────────────────────────
 /**
  * Hex color tokens. Mirrors skinEngine RGB tuples for existing kinds;
@@ -119,9 +134,9 @@ exports.glyphs = {
         dotOpen: '○',
         /** Status footer column separator. */
         sep: '│',
-        /** Slice 7 — turn counter prefix. Slice 9 hotfix: glyph dropped
-         *  entirely. The bare colored number (purple `metric_turn` kind)
-         *  carries the meaning, matching the timer pattern. */
+        /** Turn counter retired per v4.9.0 pre-ship UX feedback —
+         *  value-to-pixel ratio too low. Field kept (empty) so the
+         *  token-table shape stays stable for downstream consumers. */
         turn: '',
         /** Slice 7 — session timer prefix. Slice 9 hotfix: `⌛` (U+231B
          *  HOURGLASS WITH FLOWING SAND) restored. The font set Shiva
@@ -224,6 +239,39 @@ exports.glyphs = {
         track: '─',
     },
 };
+/**
+ * Deep-frozen snapshots of the baseline values, captured at module
+ * load. The ThemeRegistry uses these to reset to defaults via
+ * `resetToDefault()`, and tests can import them as the source of
+ * truth even after a user theme has been applied to the mutable
+ * `colors` / `glyphs` exports above.
+ */
+function deepFreeze(o) {
+    if (o === null || typeof o !== 'object')
+        return o;
+    for (const k of Object.keys(o)) {
+        deepFreeze(o[k]);
+    }
+    return Object.freeze(o);
+}
+function deepClone(o) {
+    if (o === null || typeof o !== 'object')
+        return o;
+    if (Array.isArray(o))
+        return o.map(deepClone);
+    const out = {};
+    for (const k of Object.keys(o)) {
+        out[k] = deepClone(o[k]);
+    }
+    return out;
+}
+exports.BASELINE_COLORS = deepFreeze(deepClone(exports.colors));
+exports.BASELINE_GLYPHS = deepFreeze(deepClone(exports.glyphs));
+/** Used by ThemeRegistry to restore baseline values into the live singletons. */
+function _restoreBaselineForTokens() {
+    Object.assign(exports.colors, deepClone(exports.BASELINE_COLORS));
+    Object.assign(exports.glyphs, deepClone(exports.BASELINE_GLYPHS));
+}
 // ── Spacing ───────────────────────────────────────────────────────────────
 /**
  * Integer spacing tokens. 0-indexed column counts; subagent depth

package/dist/cli/v4/display.js

@@ -23,6 +23,8 @@ exports.iconForTool = iconForTool;
 exports.detectConfiguredChannels = detectConfiguredChannels;
 exports.summarizeConfiguredChannels = summarizeConfiguredChannels;
 exports.summarizeChannelState = summarizeChannelState;
+exports.computeContextBarFill = computeContextBarFill;
+exports.renderContextBar = renderContextBar;
 exports.voiceIndicator = voiceIndicator;
 exports.makeNoOpToolRowHandle = makeNoOpToolRowHandle;
 exports.previewToolArgs = previewToolArgs;
@@ -214,6 +216,22 @@ const AIDEN_BANNER = String.raw `
 ██║  ██║██║██████╔╝███████╗██║ ╚████║
 ╚═╝  ╚═╝╚═╝╚═════╝ ╚══════╝╚═╝  ╚═══╝
 `;
+/**
+ * v4.9.0 pre-ship UI hotfix — pure context-bar helpers. Extracted
+ * for testability + to fix the "always empty" symptom. Scale:
+ * 0% → 0 cells, 1-19% → 1, 20-39% → 2, 40-59% → 3, 60-79% → 4,
+ * 80-100% → 5. `renderContextBar` returns the glyph array.
+ */
+function computeContextBarFill(pct, barW = 5) {
+    if (pct <= 0)
+        return 0;
+    if (pct >= 100)
+        return barW;
+    return Math.min(barW, Math.floor(pct / 20) + 1);
+}
+function renderContextBar(filled, barW = 5) {
+    return Array.from({ length: barW }, (_, i) => i < filled ? tokens_1.glyphs.bar.filled : tokens_1.glyphs.bar.empty);
+}
 class Display {
     constructor(opts = {}) {
         // ── Phase 16c: streaming surface ─────────────────────────────────────
@@ -605,23 +623,23 @@ class Display {
     statusFooter(args) {
         const sk = this.skin;
         const SEP = sk.applyColors(' │ ', 'muted');
-        const tri = this.triangle();
-        // v4.8.0 Slice 7 hotfix #2 — per-metric accent palette.
-        // Model: cyan (tool kind). Token counts: amber (warn). Bar/pct:
-        // semantic tier. Turn: purple (metric_turn). Timer: teal (success).
-        const provModel = `${tri} ${sk.applyColors(args.provider, 'muted')}` +
+        // v4.9.0 pre-ship UI hotfix — dropped the leading `▲` from
+        // provModel (prompt `▲` owns the marker; footer `▲` read as
+        // a duplicate orphan). Slice 7 per-metric palette preserved.
+        const provModel = `${sk.applyColors(args.provider, 'muted')}` +
             `${sk.applyColors(' · ', 'muted')}` +
             sk.applyColors(args.model, 'tool');
         const pct = args.ctxMax > 0
             ? Math.min(100, Math.round((args.ctxUsed / args.ctxMax) * 100))
             : 0;
-        // 5-cell bar with single-space separators — reads as discrete dots
-        // rather than a continuous line. Total visible width ≈ 9 cells,
-        // similar to the prior 10-cell solid bar so 80-col tier stays tight.
+        // v4.9.0 pre-ship UI hotfix — bar math extracted to
+        // `computeContextBarFill` (1 cell per 20% bucket, ≥1 when any
+        // context used). Old `Math.round(pct/100 * barW)` floored to 0
+        // below ~10% so the bar stayed empty all session at typical use.
         const barW = 5;
-        const filled = Math.round((pct / 100) * barW);
+        const filled = computeContextBarFill(pct, barW);
         const ctxKind = pct < 60 ? 'success' : pct < 85 ? 'warn' : 'error';
-        const cells = Array.from({ length: barW }, (_, i) => i < filled ? tokens_1.glyphs.bar.filled : tokens_1.glyphs.bar.empty);
+        const cells = renderContextBar(filled, barW);
         const bar = sk.applyColors(cells.join(' '), ctxKind);
         const ctxRatio = sk.applyColors(`${formatCompactTokens(args.ctxUsed)}/${formatCompactTokens(args.ctxMax)}`, 'warn');
         const ctxPctText = sk.applyColors(`${pct}%`, ctxKind);
@@ -638,12 +656,10 @@ class Display {
         const stateDot = args.state
             ? sk.applyColors(tokens_1.glyphs.status.dot, this.stateKind(args.state))
             : '';
-        // v4.8.0 Slice 9 hotfix — turn glyph dropped; bare colored number
-        // matches the timer pattern. Color alone (purple metric_turn)
-        // carries the semantic.
-        const turnSeg = args.turnCount !== undefined
-            ? sk.applyColors(String(args.turnCount), 'metric_turn')
-            : '';
+        // v4.9.0 pre-ship UI: turn counter retired entirely — value-to-pixel
+        // ratio too low. `args.turnCount` stays in the signature for caller
+        // back-compat; ignored here.
+        void args.turnCount;
         // v4.8.0 Slice 9 hotfix — ⌛ restored ahead of the bare elapsed
         // string. Wider font support than the retired ⏱. `sessionMs` arg
         // stays plumbed-but-unused for backward compat with the field name.
@@ -654,17 +670,14 @@ class Display {
         const ctxSegFull = `${ctxRatio} ${bar} ${ctxPctText}`;
         const ctxSegCompact = `${bar} ${ctxPctText}`;
         let segments;
-        if (cols >= 120 && stateDot && turnSeg && sessionSeg) {
-            segments = [provModel, ctxSegFull, turnSeg, sessionSeg, stateDot];
+        if (cols >= 120 && stateDot && sessionSeg) {
+            segments = [provModel, ctxSegFull, sessionSeg, stateDot];
         }
-        else if (cols >= 100 && turnSeg) {
-            // v4.8.1 Slice 2 hotfix — was `elapsed` (bare); now uses
-            // `sessionSeg` which includes the ⌛ timer glyph. The previous
-            // mid-tier dropped the glyph for "denser" packing, but Shiva's
-            // smoke at 80–110 cols showed only ` 5.1s` (leading space, no
-            // glyph). The glyph is single-cell, cheap, and load-bearing as
-            // the timer's identity affordance.
-            segments = [provModel, ctxSegFull, turnSeg, sessionSeg || elapsed];
+        else if (cols >= 100) {
+            // v4.8.1 Slice 2 hotfix — sessionSeg keeps the ⌛ identity glyph
+            // (single-cell, cheap) even at this tier. v4.9.0 pre-ship UI:
+            // turn counter retired; mid tier collapses to 2 separators.
+            segments = [provModel, ctxSegFull, sessionSeg || elapsed];
         }
         else {
             segments = [provModel, ctxSegCompact, sessionSeg || elapsed];

package/dist/cli/v4/replyRenderer.js

@@ -183,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
@@ -633,11 +633,12 @@ 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 ──────────────────────────
     //

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;