aiden-runtime 4.8.1 → 4.9.1

package/dist/core/v4/memory/reviewer/skipRules.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/memory/reviewer/skipRules.ts — v4.9.0 Slice 10.
+ *
+ * Hard skip rules applied to every reviewer-proposed candidate AFTER
+ * the LLM returns. Belt-and-braces — the reviewer prompt also tells
+ * the LLM not to propose these, but the parser drops violators
+ * defensively because LLMs occasionally disregard prompt constraints.
+ *
+ * Rules (each has a `class` label that appears in the drop log):
+ *   - sensitive_class  — PII / medical / political / religious / financial inference
+ *   - negation         — "not X", "doesn't Y", "no longer Z"
+ *   - transient        — "this session", "today", "just now", "recently"
+ *   - duplicate        — substring overlap with an existing live entry
+ *   - char_cap         — > 200 chars
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CANDIDATE_CHARS = void 0;
+exports.evaluateCandidate = evaluateCandidate;
+const SENSITIVE_PATTERNS = [
+    // Medical / health (broad — includes common conditions, treatments, symptoms)
+    /\b(diagnos|prescrib|medication|illness|disorder|disease|therap|antidepress|mental[- ]health|disabilit|cancer|tumou?r|anxiety|depress|HIV|AIDS\b|chronic|symptom)/i,
+    // Political / religious
+    /\b(votes? for|political affiliat|religious|conservative|liberal|democrat|republican|catholic|muslim|jewish|hindu|atheist)/i,
+    // Financial inference
+    /\b(income|salary|net worth|debt|bankrupt|tax bracket|credit score)/i,
+    // Sexual orientation / family planning
+    /\b(sexual orientat|\bgay\b|lesbian|straight\b|transgender|pregnan|fertility|miscarriage)/i,
+];
+const NEGATION_PROBES = [
+    // Explicit "X does/did/is not Y" — match the negative verb forms,
+    // not the prefix. The reviewer often phrases candidates as
+    // "User does not …" so we match `does not`, `doesn't`, etc.
+    /\b(?:does\s*not|did\s*not|do\s*not|is\s*not|are\s*not|was\s*not|were\s*not|will\s*not|cannot|can\s*not|could\s*not|should\s*not|would\s*not)\b/i,
+    // Contracted forms — match across straight quote, smart quote, or
+    // apostrophe-less typo ("dont").
+    /\b(?:don[''’]?t|doesn[''’]?t|didn[''’]?t|isn[''’]?t|aren[''’]?t|wasn[''’]?t|weren[''’]?t|won[''’]?t|can[''’]?t|couldn[''’]?t|shouldn[''’]?t|wouldn[''’]?t)\b/i,
+    // "no longer" / "never" / leading "not"
+    /\b(?:no longer|never)\b/i,
+    /^\s*not\s+\w/i,
+];
+const TRANSIENT_MARKERS = [
+    /\b(this session|this conversation|just now|right now|currently|today|tomorrow|yesterday|recently|earlier|a moment ago|this turn|last turn)\b/i,
+];
+exports.MAX_CANDIDATE_CHARS = 200;
+/**
+ * Fuzzy duplicate detection: candidate is dropped if it's a substring
+ * of any live entry (or vice-versa), case-insensitively. Cheap heuristic
+ * — matches the Slice 9 `MemoryManager.add()` substring-dedup pattern.
+ */
+function isDuplicate(candidate, liveEntries) {
+    const c = candidate.toLowerCase().trim();
+    if (c.length < 8)
+        return false; // too short to dedup against
+    for (const live of liveEntries) {
+        const l = live.toLowerCase().trim();
+        if (l.length === 0)
+            continue;
+        if (l.includes(c) || c.includes(l))
+            return true;
+    }
+    return false;
+}
+/** Evaluate a candidate against every rule. Returns the first hit. */
+function evaluateCandidate(candidate, liveEntries) {
+    const trimmed = candidate.trim();
+    if (trimmed.length === 0)
+        return { drop: true, klass: 'char_cap' };
+    if (trimmed.length > exports.MAX_CANDIDATE_CHARS)
+        return { drop: true, klass: 'char_cap' };
+    for (const p of SENSITIVE_PATTERNS) {
+        if (p.test(trimmed))
+            return { drop: true, klass: 'sensitive_class' };
+    }
+    for (const p of NEGATION_PROBES) {
+        if (p.test(trimmed))
+            return { drop: true, klass: 'negation' };
+    }
+    for (const p of TRANSIENT_MARKERS) {
+        if (p.test(trimmed))
+            return { drop: true, klass: 'transient' };
+    }
+    if (isDuplicate(trimmed, liveEntries))
+        return { drop: true, klass: 'duplicate' };
+    return { drop: false };
+}

package/dist/core/v4/memoryManager.js

@@ -50,6 +50,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryManager = exports.ENTRY_SEPARATOR = exports.USER_CHAR_LIMIT = exports.MEMORY_CHAR_LIMIT = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+// v4.9.0 Slice 11 — namespace registry generalizes 'memory'|'user' to N.
+const namespaceRegistry_1 = require("./memory/namespaceRegistry");
 /**
  * Char budgets per arch doc Memory section. NOT tokens — char counts are
  * model-independent and easy to enforce client-side.
@@ -59,8 +61,11 @@ exports.USER_CHAR_LIMIT = 1375;
 /** Entry separator: `\n§\n`. Distinct enough to never collide with content. */
 exports.ENTRY_SEPARATOR = '\n§\n';
 class MemoryManager {
-    constructor(paths) {
-        this.paths = paths;
+    // v4.9.0 Slice 11 — constructor now accepts either the legacy
+    // `AidenPaths` (back-compat) OR an options object with optional
+    // `projectRoot`. Both shapes preserve `this.paths` for the rest of
+    // the class.
+    constructor(opts) {
         this.name = 'builtin';
         this.writeQueue = Promise.resolve();
         /**
@@ -70,6 +75,15 @@ class MemoryManager {
          * fire listeners — preserves the "stale snapshot stays clean" invariant.
          */
         this.mutationListeners = new Set();
+        if (opts.paths !== undefined) {
+            const o = opts;
+            this.paths = o.paths;
+            this.projectRoot = o.projectRoot ?? null;
+        }
+        else {
+            this.paths = opts;
+            this.projectRoot = null;
+        }
     }
     /**
      * Phase 16d: subscribe to successful memory mutations. Returns an
@@ -102,12 +116,28 @@ class MemoryManager {
     async loadSnapshot() {
         const memoryMd = await readFileOrEmpty(this.paths.memoryMd);
         const userMd = await readFileOrEmpty(this.paths.userMd);
-        return {
-            memoryMd,
-            userMd,
-            loadedAt: Date.now(),
-            isEmpty: memoryMd.trim().length === 0 && userMd.trim().length === 0,
-        };
+        // v4.9.0 Slice 11 — collect every registered namespace's content
+        // into the generalized `files` map. Legacy `memoryMd` / `userMd`
+        // fields stay populated for back-compat with the 9 v4 consumers
+        // that read them directly (memoryGuard, aidenAgent listeners, ...).
+        const files = {};
+        let anyContent = memoryMd.trim().length > 0 || userMd.trim().length > 0;
+        for (const ns of (0, namespaceRegistry_1.listNamespaces)()) {
+            let p;
+            try {
+                p = ns.resolve(this.paths, this.projectRoot);
+            }
+            catch {
+                continue; /* requiresProject + no root — silently skip */
+            }
+            const content = await readFileOrEmpty(p);
+            files[ns.name] = {
+                content, charCount: content.length, charLimit: ns.charLimit, path: p,
+            };
+            if (content.trim().length > 0)
+                anyContent = true;
+        }
+        return { memoryMd, userMd, loadedAt: Date.now(), isEmpty: !anyContent, files };
     }
     add(file, content) {
         return this.serialised(async () => {
@@ -224,8 +254,21 @@ class MemoryManager {
         });
     }
     // ── Internals ────────────────────────────────────────────────────────
+    // v4.9.0 Slice 11 — resolve via namespace registry. Legacy callers
+    // passing 'memory' / 'user' hit the built-in resolvers; new namespaces
+    // (project, future plugin namespaces) flow through the same path.
     pathFor(file) {
-        return file === 'user' ? this.paths.userMd : this.paths.memoryMd;
+        if (!(0, namespaceRegistry_1.hasNamespace)(file)) {
+            throw new Error(`unknown memory namespace '${file}'`);
+        }
+        return (0, namespaceRegistry_1.getNamespace)(file).resolve(this.paths, this.projectRoot);
+    }
+    /**
+     * v4.9.0 Slice 11 — public char-limit lookup for any namespace.
+     * Replaces the legacy file-local `limitFor` switch with a registry hit.
+     */
+    charLimitFor(namespace) {
+        return (0, namespaceRegistry_1.getNamespace)(namespace).charLimit;
     }
     /**
      * Serialise mutations so two concurrent add()s can't collapse into a
@@ -238,8 +281,12 @@ class MemoryManager {
     }
 }
 exports.MemoryManager = MemoryManager;
+// v4.9.0 Slice 11 — registry-aware. Legacy two-namespace callers
+// (memoryGuard, tools) hit this via the existing add/replace/remove
+// paths; the constants above stay exported for any consumer still
+// importing them directly.
 function limitFor(file) {
-    return file === 'user' ? exports.USER_CHAR_LIMIT : exports.MEMORY_CHAR_LIMIT;
+    return (0, namespaceRegistry_1.getNamespace)(file).charLimit;
 }
 async function readFileOrEmpty(p) {
     try {

package/dist/core/v4/paths.js

@@ -102,6 +102,8 @@ function resolveAidenPaths(opts = {}) {
         skinsDir: node_path_1.default.join(root, 'skins'),
         recentCommandsFile: node_path_1.default.join(root, '.recent-commands.json'),
         sessionsDir: node_path_1.default.join(root, 'sessions'),
+        distillationsDir: node_path_1.default.join(root, 'distillations'),
+        memoryBackupsDir: node_path_1.default.join(root, 'memory-backups'),
         pluginsDir: node_path_1.default.join(root, 'plugins'),
         logsDir: node_path_1.default.join(root, 'logs'),
         bundledManifest: node_path_1.default.join(root, '.bundled_manifest'),

package/dist/core/v4/subagent/spawnSubAgent.js

@@ -29,6 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.spawnSubAgent = spawnSubAgent;
 const node_crypto_1 = require("node:crypto");
 const childBuilder_1 = require("./childBuilder");
+// v4.9.0 Slice 7 — fork ExecutionContext into the child agent.
+const identity_1 = require("../identity");
 const factory_1 = require("../logger/factory");
 // ── Constants ─────────────────────────────────────────────────────────────
 const DEFAULT_TIMEOUT_MS = 600000;
@@ -189,14 +191,25 @@ async function spawnSubAgent(spec, deps, ctx) {
     let apiCalls = 0;
     let tokensIn = 0;
     let tokensOut = 0;
+    // v4.9.0 Slice 7 — fork an ExecutionContext for the child so its
+    // tool/LLM spans chain off the parent's spanId. AsyncLocalStorage
+    // is in-process; the child runs inside `runWithContext(childCtx, ...)`
+    // so any `currentContext()` reads during the child's runConversation
+    // see the child's chain (same traceId, fresh spanId, parentSpanId =
+    // parent's spanId). Out-of-context callers (legacy paths) leave
+    // the call exactly as it was pre-Slice-7.
+    const parentCtx = (0, identity_1.currentContext)();
+    const runChild = async () => agentBundle.agent.runConversation(agentBundle.history, {
+        signal: childCtrl.signal,
+        // v4.8.0 Phase 2.2 — uiOnly events from a subagent are
+        // dropped. Subagents have no chat surface; the parent
+        // assembles their summary. Stub stays a no-op forever.
+        onUiEvent: () => { },
+    });
     try {
-        const result = await agentBundle.agent.runConversation(agentBundle.history, {
-            signal: childCtrl.signal,
-            // v4.8.0 Phase 2.2 — uiOnly events from a subagent are
-            // dropped. Subagents have no chat surface; the parent
-            // assembles their summary. Stub stays a no-op forever.
-            onUiEvent: () => { },
-        });
+        const result = await (parentCtx
+            ? (0, identity_1.runWithContext)((0, identity_1.childSpan)({ ...parentCtx, source: 'subagent' }), runChild)
+            : runChild());
         apiCalls = result.turnCount; // one provider call per turn
         tokensIn = result.totalUsage.inputTokens;
         tokensOut = result.totalUsage.outputTokens;

package/dist/core/v4/theme/bundledThemes.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/theme/bundledThemes.ts — v4.9.0 Slice 1b.
+ *
+ * Locates the bundled theme YAML files. Themes live at `themes/*.yaml`
+ * at the repo root and are included in the published npm artifact via
+ * `package.json#files`. This module resolves the on-disk path for
+ * each theme name and exposes a tiny API that the `/theme list` and
+ * `/theme set` slash commands consume without needing to know the
+ * fs layout.
+ *
+ * Defense-in-depth: if a corrupted install is missing the `themes/`
+ * directory entirely, callers fall through gracefully — `getYaml()`
+ * returns null, `/theme list` shows zero bundled themes (but still
+ * lists any user themes from `~/.aiden/themes/`).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUNDLED_NAMES = void 0;
+exports.bundledYamlPath = bundledYamlPath;
+exports.getYaml = getYaml;
+exports.listBundled = listBundled;
+exports.isBundled = isBundled;
+exports._resetForTests = _resetForTests;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/** Bundled theme names, sorted to give `/theme list` a stable order. */
+exports.BUNDLED_NAMES = ['default', 'monochrome', 'light', 'tokyo-night', 'dracula'];
+/**
+ * Walk up from `__dirname` looking for the repo root that holds the
+ * `themes/` directory. Works for:
+ *   - tsc tree    (dist/core/v4/theme/bundledThemes.js → walk 3 up)
+ *   - esbuild     (dist-bundle/cli.js → walk 1 up)
+ *   - source      (core/v4/theme/bundledThemes.ts → walk 3 up via tsx)
+ *   - npm install (node_modules/aiden-runtime/dist/... → walk to the
+ *                  aiden-runtime root)
+ *
+ * Returns null when no `themes/` directory is found within 6 ancestors
+ * (corrupted install). Callers treat null as "no bundled themes
+ * available" and degrade gracefully.
+ */
+function findThemesDir() {
+    let dir = __dirname;
+    for (let i = 0; i < 6; i += 1) {
+        const candidate = node_path_1.default.join(dir, 'themes');
+        if ((0, node_fs_1.existsSync)(candidate) && (0, node_fs_1.existsSync)(node_path_1.default.join(candidate, 'default.yaml'))) {
+            return candidate;
+        }
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+let cachedThemesDir;
+function themesDir() {
+    if (cachedThemesDir === undefined)
+        cachedThemesDir = findThemesDir();
+    return cachedThemesDir;
+}
+/** Absolute path to a bundled YAML, or null when the themes/ dir is missing. */
+function bundledYamlPath(name) {
+    const dir = themesDir();
+    if (!dir)
+        return null;
+    return node_path_1.default.join(dir, `${name}.yaml`);
+}
+/** Read the YAML for a bundled theme. Returns null on missing-file. */
+function getYaml(name) {
+    const file = bundledYamlPath(name);
+    if (!file || !(0, node_fs_1.existsSync)(file))
+        return null;
+    try {
+        return (0, node_fs_1.readFileSync)(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+const DESCRIPTIONS = {
+    default: "Aiden's signature brand-orange theme on a dark terminal.",
+    monochrome: 'Pure greyscale. Semantic accents retained for error/success readability.',
+    light: 'Light terminal. Dark text on light background. Brand orange accent.',
+    'tokyo-night': 'Inspired by Tokyo Night. Cool nocturnal palette.',
+    dracula: 'Inspired by Dracula. High-contrast dark with vivid accents.',
+};
+/** Enumerate bundled themes. Filters out any that fail to resolve on disk. */
+function listBundled() {
+    return exports.BUNDLED_NAMES
+        .filter((n) => bundledYamlPath(n) !== null)
+        .map((n) => ({ name: n, description: DESCRIPTIONS[n] }));
+}
+function isBundled(name) {
+    return exports.BUNDLED_NAMES.includes(name);
+}
+/** Test-only reset of the themes-dir cache. */
+function _resetForTests() { cachedThemesDir = undefined; }

package/dist/core/v4/theme/themeLoader.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/theme/themeLoader.ts — v4.9.0 Slice 1a.
+ *
+ * YAML parser + validator for user theme files. Permissive by design:
+ * a malformed file or invalid field warns and falls back per-field
+ * rather than rejecting the entire theme. Aiden must keep running
+ * with a sensible visual even if the user's theme.yaml has typos.
+ *
+ * Wire format (hex strings throughout — see also the legacy
+ * `skins/*.yaml` format which uses RGB tuples; the two systems
+ * deliberately use distinct formats so users can tell which file
+ * goes with which slash command):
+ *
+ *   name: "my-theme"
+ *   description: "..."
+ *   inherits: null  # or a bundled theme name
+ *   colors:
+ *     brand: { primary: "#FF6B35", muted: "#7a3119" }
+ *     # ... etc
+ *   glyphs:
+ *     panel: { bar: "│" }
+ *     trail: { gutter: "┊" }
+ *     # ... etc
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseThemeYaml = parseThemeYaml;
+exports.loadThemeFile = loadThemeFile;
+const node_fs_1 = require("node:fs");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const HEX_RE = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+/**
+ * Parse a YAML string into a ParsedTheme. Returns `parsed: null`
+ * only on top-level YAML parse failure (in which case the caller
+ * should keep the current theme). Otherwise returns the best-effort
+ * parse with per-field warnings; bad fields are silently dropped
+ * from the override maps so the baseline shows through.
+ */
+function parseThemeYaml(text) {
+    const warnings = [];
+    let doc;
+    try {
+        doc = js_yaml_1.default.load(text);
+    }
+    catch (err) {
+        warnings.push(`YAML parse error: ${err.message}`);
+        return { parsed: null, warnings };
+    }
+    // v4.9.0 Slice 1a hotfix — `yaml.load('')` returns `undefined` for
+    // an empty file. That's a benign transient state — the user just
+    // created theme.yaml via /theme edit and hasn't typed content yet,
+    // OR they cleared the file before retyping. Don't surface a warning
+    // for that case; just signal "no theme parsed" and let the caller
+    // keep the current theme active.
+    if (doc === undefined || doc === null) {
+        return { parsed: null, warnings };
+    }
+    if (typeof doc !== 'object') {
+        warnings.push('Theme root must be a mapping; got ' + typeof doc);
+        return { parsed: null, warnings };
+    }
+    const root = doc;
+    const name = typeof root.name === 'string' && root.name.trim().length > 0
+        ? root.name.trim()
+        : 'custom';
+    const description = typeof root.description === 'string'
+        ? root.description
+        : undefined;
+    const colorOverrides = {};
+    collectStringPaths(root.colors, 'colors', colorOverrides, warnings, (value, path) => {
+        if (!HEX_RE.test(value)) {
+            warnings.push(`Invalid hex at ${path}: "${value}" (expected #RGB or #RRGGBB); falling back to default.`);
+            return null;
+        }
+        return value;
+    });
+    const glyphOverrides = {};
+    collectStringPaths(root.glyphs, 'glyphs', glyphOverrides, warnings, (value /* , path */) => {
+        // Glyphs are free-form strings — no validation beyond "is a string".
+        return value;
+    });
+    // The dotted paths returned by collectStringPaths include the
+    // `colors.` / `glyphs.` prefix. Strip those so the registry can
+    // write directly into the `colors` / `glyphs` singletons.
+    const colorOverridesStripped = {};
+    for (const [k, v] of Object.entries(colorOverrides)) {
+        colorOverridesStripped[k.replace(/^colors\./, '')] = v;
+    }
+    const glyphOverridesStripped = {};
+    for (const [k, v] of Object.entries(glyphOverrides)) {
+        glyphOverridesStripped[k.replace(/^glyphs\./, '')] = v;
+    }
+    return {
+        parsed: {
+            name,
+            description,
+            colorOverrides: colorOverridesStripped,
+            glyphOverrides: glyphOverridesStripped,
+        },
+        warnings,
+    };
+}
+/**
+ * Load + parse a theme file from disk. Returns `{ parsed: null }`
+ * on missing-file or read-error so the caller can degrade gracefully.
+ */
+function loadThemeFile(filepath) {
+    let text;
+    try {
+        text = (0, node_fs_1.readFileSync)(filepath, 'utf8');
+    }
+    catch (err) {
+        return {
+            parsed: null,
+            warnings: [`Could not read theme file ${filepath}: ${err.message}`],
+        };
+    }
+    return parseThemeYaml(text);
+}
+/**
+ * Walk `node` recursively. For every string leaf, call `transform`
+ * to optionally validate / normalise it. If `transform` returns null
+ * the leaf is dropped (validation failure). Non-string non-object
+ * leaves trigger a warning and are dropped.
+ */
+function collectStringPaths(node, pathSoFar, out, warnings, transform) {
+    if (node === undefined || node === null)
+        return;
+    if (typeof node !== 'object') {
+        warnings.push(`Expected object at ${pathSoFar}; got ${typeof node}`);
+        return;
+    }
+    if (Array.isArray(node)) {
+        warnings.push(`Array not supported at ${pathSoFar}`);
+        return;
+    }
+    for (const [k, v] of Object.entries(node)) {
+        const childPath = `${pathSoFar}.${k}`;
+        if (typeof v === 'string') {
+            const value = transform(v, childPath);
+            if (value !== null)
+                out[childPath] = value;
+        }
+        else if (typeof v === 'object' && v !== null) {
+            collectStringPaths(v, childPath, out, warnings, transform);
+        }
+        else {
+            warnings.push(`Unsupported leaf type at ${childPath}: ${typeof v}`);
+        }
+    }
+}

package/dist/core/v4/theme/themeRegistry.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/theme/themeRegistry.ts — v4.9.0 Slice 1a.
+ *
+ * Singleton holding the active theme's name + path. The actual token
+ * values live on the mutable `colors` / `glyphs` exports of
+ * `cli/v4/design/tokens.ts`; this registry orchestrates applying a
+ * parsed theme onto those singletons and notifying subscribers when
+ * a hot-reload happens.
+ *
+ * Subscribers are anything that wants to be notified when the theme
+ * changes (e.g. the SkinEngine, which caches resolved RGB tuples).
+ *
+ * Why a separate module: keeps the theme-loading state machine out of
+ * `tokens.ts` (which is pure data) and out of `cli/v4/` (so core code
+ * with no UI dependency can still consult the registry without a
+ * core → cli import).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASELINE_GLYPHS = exports.BASELINE_COLORS = void 0;
+exports.applyTheme = applyTheme;
+exports.resetToDefault = resetToDefault;
+exports.getCurrentName = getCurrentName;
+exports.getActivePath = getActivePath;
+exports.subscribe = subscribe;
+const tokens_1 = require("../../../cli/v4/design/tokens");
+Object.defineProperty(exports, "BASELINE_COLORS", { enumerable: true, get: function () { return tokens_1.BASELINE_COLORS; } });
+Object.defineProperty(exports, "BASELINE_GLYPHS", { enumerable: true, get: function () { return tokens_1.BASELINE_GLYPHS; } });
+let currentName = 'default';
+let activePath = null;
+const listeners = new Set();
+/**
+ * Apply a parsed theme on top of the baseline. Restores baseline
+ * first (so successive `applyTheme` calls don't accumulate stale
+ * overrides), then walks each override path and writes the value
+ * into the live `colors` / `glyphs` singletons.
+ */
+function applyTheme(parsed, path = null) {
+    // Reset to baseline first — guarantees idempotency.
+    (0, tokens_1._restoreBaselineForTokens)();
+    for (const [dotted, value] of Object.entries(parsed.colorOverrides)) {
+        writePath(tokens_1.colors, dotted, value);
+    }
+    for (const [dotted, value] of Object.entries(parsed.glyphOverrides)) {
+        writePath(tokens_1.glyphs, dotted, value);
+    }
+    currentName = parsed.name || 'custom';
+    activePath = path;
+    notify();
+}
+/** Restore baseline token values and clear active theme metadata. */
+function resetToDefault() {
+    (0, tokens_1._restoreBaselineForTokens)();
+    currentName = 'default';
+    activePath = null;
+    notify();
+}
+function getCurrentName() { return currentName; }
+function getActivePath() { return activePath; }
+/** Subscribe; returns an unsubscribe fn. */
+function subscribe(fn) {
+    listeners.add(fn);
+    return () => { listeners.delete(fn); };
+}
+function notify() {
+    const snap = { name: currentName, activePath };
+    for (const fn of listeners) {
+        try {
+            fn(snap);
+        }
+        catch { /* listener crash must not break registry */ }
+    }
+}
+/**
+ * Write a value into a nested object via a dotted path. Creates
+ * intermediate keys as needed (won't happen with validated themes
+ * but defensive against schema drift). Last segment is the leaf
+ * write. Pure mutation on the input root.
+ */
+function writePath(root, dotted, value) {
+    const segments = dotted.split('.');
+    let node = root;
+    for (let i = 0; i < segments.length - 1; i += 1) {
+        const seg = segments[i];
+        if (typeof node[seg] !== 'object' || node[seg] === null) {
+            node[seg] = {};
+        }
+        node = node[seg];
+    }
+    node[segments[segments.length - 1]] = value;
+}