open-multi-agent-kit 0.78.5 → 0.78.7

package/dist/brand/theme-compiled.js

@@ -0,0 +1,241 @@
+/**
+ * OMK brand -- theme-compiled color source (theme contract T5b).
+ *
+ * Single bridge between canonical omk.theme.v1 documents and the brand
+ * palette/UI layers. Brand chrome defaults to night-city for byte parity, and
+ * can be switched at process edges to rust-forge without changing import shapes.
+ *
+ * Imports target the concrete src/cli/theme modules (render-table,
+ * terminal-capability, oklab-quantize) rather than the barrel to avoid a
+ * module cycle through theme-registry -> theme/colors -> brand/palette.
+ */
+import { compileTheme } from "../cli/theme/render-table.js";
+import { detectColorTier } from "../cli/theme/terminal-capability.js";
+import { hexToRgb255, normalizeHex } from "../cli/theme/oklab-quantize.js";
+import nightCityThemeJson from "./night-city.theme.json" with { type: "json" };
+import rustForgeThemeJson from "./rust-forge.theme.json" with { type: "json" };
+const REQUIRED_NIGHT_CITY_PRIMITIVES = [
+    "dark",
+    "surface",
+    "cyan",
+    "mint",
+    "magenta",
+    "purple",
+    "amber",
+    "red",
+    "cream",
+    "muted",
+    "gray",
+];
+const REQUIRED_RUST_FORGE_PRIMITIVES = [
+    "iron",
+    "coal",
+    "forge",
+    "anvil",
+    "rust",
+    "molten",
+    "copper",
+    "ember",
+    "oxide",
+    "quench",
+    "verdigris",
+    "crimson",
+    "steel",
+    "scale",
+    "ash",
+    "slag",
+    "bone",
+];
+function assertThemeDocument(doc, expectedName, requiredPrimitives) {
+    if (typeof doc !== "object" || doc === null) {
+        throw new Error(`brand theme-compiled: ${expectedName} theme snapshot is not an object`);
+    }
+    const candidate = doc;
+    if (candidate.schemaVersion !== "omk.theme.v1") {
+        throw new Error(`brand theme-compiled: expected schemaVersion "omk.theme.v1", got "${String(candidate.schemaVersion)}"`);
+    }
+    if (candidate.name !== expectedName) {
+        throw new Error(`brand theme-compiled: expected theme name "${expectedName}", got "${String(candidate.name)}"`);
+    }
+    if (typeof candidate.primitives !== "object" || candidate.primitives === null) {
+        throw new Error(`brand theme-compiled: ${expectedName} theme snapshot has no primitives map`);
+    }
+    if (typeof candidate.semantics !== "object" || candidate.semantics === null) {
+        throw new Error(`brand theme-compiled: ${expectedName} theme snapshot has no semantics map`);
+    }
+    if (typeof candidate.fallback16 !== "object" || candidate.fallback16 === null) {
+        throw new Error(`brand theme-compiled: ${expectedName} theme snapshot has no fallback16 map`);
+    }
+    const primitives = candidate.primitives;
+    for (const name of requiredPrimitives) {
+        if (typeof primitives[name] !== "string") {
+            throw new Error(`brand theme-compiled: ${expectedName} theme snapshot is missing primitive "${name}"`);
+        }
+    }
+    return doc;
+}
+/** Validated night-city theme document (build-time snapshot of themes/). */
+export const NIGHT_CITY_THEME = assertThemeDocument(nightCityThemeJson, "night-city", REQUIRED_NIGHT_CITY_PRIMITIVES);
+/** Validated rust-forge theme document (build-time snapshot of themes/). */
+export const RUST_FORGE_THEME = assertThemeDocument(rustForgeThemeJson, "rust-forge", REQUIRED_RUST_FORGE_PRIMITIVES);
+const BRAND_THEME_BY_NAME = {
+    "night-city": NIGHT_CITY_THEME,
+    "rust-forge": RUST_FORGE_THEME,
+};
+let activeBrandThemeName = "night-city";
+export function resolveBrandThemeName(name) {
+    const normalized = name?.trim().toLowerCase();
+    if (normalized === "rust-forge" ||
+        normalized === "rust" ||
+        normalized === "cargo" ||
+        normalized === "oxide" ||
+        normalized === "forge" ||
+        normalized === "oxidized-forge" ||
+        normalized === "oxidized" ||
+        normalized === "rust-native") {
+        return "rust-forge";
+    }
+    return "night-city";
+}
+export function setActiveBrandTheme(name) {
+    activeBrandThemeName = resolveBrandThemeName(name);
+    return activeBrandThemeName;
+}
+export function getActiveBrandThemeName() {
+    return activeBrandThemeName;
+}
+export function getActiveBrandTheme() {
+    return BRAND_THEME_BY_NAME[activeBrandThemeName];
+}
+function hexByRole(theme, role) {
+    const semantic = theme.semantics[role];
+    if (semantic === undefined) {
+        throw new Error(`brand theme-compiled: theme "${theme.name}" has no semantic role "${role}"`);
+    }
+    const raw = theme.primitives[semantic.color];
+    if (raw === undefined) {
+        throw new Error(`brand theme-compiled: theme "${theme.name}" semantic "${role}" references missing primitive "${semantic.color}"`);
+    }
+    return normalizeHex(raw);
+}
+export function activeThemeHexByRole(role) {
+    return hexByRole(getActiveBrandTheme(), role);
+}
+export function brandThemeHexByRole(name, role) {
+    return hexByRole(BRAND_THEME_BY_NAME[name], role);
+}
+export function brandThemeRgbByRole(name, role) {
+    const [r, g, b] = hexToRgb255(brandThemeHexByRole(name, role));
+    return { r, g, b };
+}
+export function activeThemeRgbByRole(role) {
+    const [r, g, b] = hexToRgb255(activeThemeHexByRole(role));
+    return { r, g, b };
+}
+const PRIMITIVE_ROLE_ALIASES = {
+    cyan: "route.active",
+    mint: "evidence.pass",
+    magenta: "control.accent",
+    purple: "control.accent",
+    amber: "route.fallback",
+    red: "telemetry.error",
+    cream: "control.fg",
+    muted: "dag.lane.queued",
+    gray: "control.dim",
+    dark: "control.bg",
+};
+export function activeThemeHexByPrimitive(primitive) {
+    const theme = getActiveBrandTheme();
+    const raw = theme.primitives[primitive];
+    if (raw !== undefined)
+        return normalizeHex(raw);
+    if (primitive === "surface") {
+        const surfacePrimitive = theme.backgrounds[1] ?? theme.backgrounds[0];
+        const surface = surfacePrimitive ? theme.primitives[surfacePrimitive] : undefined;
+        return surface === undefined ? activeThemeHexByRole("control.bg") : normalizeHex(surface);
+    }
+    const role = PRIMITIVE_ROLE_ALIASES[primitive];
+    if (role !== undefined)
+        return activeThemeHexByRole(role);
+    throw new Error(`brand theme-compiled: theme "${theme.name}" has no primitive "${primitive}"`);
+}
+/** Canonical normalized uppercase hex string for a night-city primitive. */
+export function nightCityHex(primitive) {
+    const raw = NIGHT_CITY_THEME.primitives[primitive];
+    if (raw === undefined) {
+        throw new Error(`brand theme-compiled: unknown night-city primitive "${primitive}"`);
+    }
+    return normalizeHex(raw);
+}
+/** 0-255 RGB triple for a night-city primitive. */
+export function nightCityRgb(primitive) {
+    const [r, g, b] = hexToRgb255(nightCityHex(primitive));
+    return { r, g, b };
+}
+function channelHex(value) {
+    const clamped = Math.max(0, Math.min(255, Math.round(value)));
+    return clamped.toString(16).padStart(2, "0").toUpperCase();
+}
+/** Convert an RGB triple to canonical uppercase hex (no literal hex in source). */
+export function rgbToHex(color) {
+    return `#${channelHex(color.r)}${channelHex(color.g)}${channelHex(color.b)}`;
+}
+const compiledByThemeAndTier = new Map();
+/**
+ * Compiled active brand render table for the requested (default: detected)
+ * degradation tier. The cache key includes both theme name and tier.
+ */
+export function getCompiledBrandTheme(tier = detectColorTier()) {
+    const theme = getActiveBrandTheme();
+    const cacheKey = `${theme.name}:${tier}`;
+    const cached = compiledByThemeAndTier.get(cacheKey);
+    if (cached !== undefined)
+        return cached;
+    const compiled = compileTheme(theme, tier);
+    compiledByThemeAndTier.set(cacheKey, compiled);
+    return compiled;
+}
+/** Paint text with an active-brand semantic token at the detected color tier. */
+export function brandPaint(role, text) {
+    return getCompiledBrandTheme().paint(role, text);
+}
+export function getActiveBrandChromeLabel() {
+    return activeBrandThemeName === "rust-forge" ? "Oxidized Forge" : "Night City";
+}
+export function getActiveBrandCockpitSubtitle() {
+    return activeBrandThemeName === "rust-forge"
+        ? "OXIDIZED FORGE · ROUTE · VERIFY · CONTROL"
+        : "NEON GRID · GREEN RAIN · METRICS WALL";
+}
+export function getActiveBrandCockpitDetail() {
+    return activeBrandThemeName === "rust-forge"
+        ? "forge heat · anvil evidence · quench safety · OMK control"
+        : "route · verify · loop · control · evidence gated";
+}
+export function getActiveBrandHudStatus() {
+    return activeBrandThemeName === "rust-forge" ? "OXIDIZED FORGE ONLINE" : "NEON GRID ONLINE";
+}
+export function getActiveBrandConsoleLine() {
+    return activeBrandThemeName === "rust-forge"
+        ? "Oxidized Forge Console // OMK independent control // heat anvil quench"
+        : "Night City Ops Console // cyberpunk metrics wall";
+}
+/**
+ * Unconditional truecolor SGR open sequence for a brand RGB value, produced
+ * through the theme compiler (single SGR factory -- no escape literals here).
+ * Brand theme constants intentionally stay truecolor for byte parity with the
+ * legacy palette; tier-aware rendering should use `getCompiledBrandTheme()`.
+ */
+export function brandTruecolorSgr(color) {
+    const inlineTheme = {
+        schemaVersion: "omk.theme.v1",
+        name: "omk-brand-inline",
+        mode: "dark",
+        primitives: { brand: rgbToHex(color) },
+        backgrounds: [],
+        semantics: { "brand.tone": { color: "brand", usage: "text" } },
+        components: {},
+        fallback16: { "brand.tone": "white" },
+    };
+    return compileTheme(inlineTheme, "truecolor").tokens["brand.tone"].sgr;
+}

package/dist/brand/theme.js

@@ -1,6 +1,19 @@
-const ESC = "\x1b[";
+import { P } from "./palette.js";
+import { brandThemeRgbByRole, brandTruecolorSgr } from "./theme-compiled.js";
+/**
+ * Truecolor SGR open sequence for a brand color, produced via the theme
+ * compiler (compileTheme) — no raw escape literals in this file. Brand theme
+ * constants stay truecolor on purpose for byte parity; tier-aware rendering
+ * lives in src/brand/theme-compiled.ts (getCompiledBrandTheme).
+ */
+function fg(color) {
+    return brandTruecolorSgr(color);
+}
 function rgb(r, g, b) {
-    return `${ESC}38;2;${r};${g};${b}m`;
+    return fg({ r, g, b });
+}
+function rustFg(role) {
+    return brandTruecolorSgr(brandThemeRgbByRole("rust-forge", role));
 }
 export const SYSTEM24_THEME = {
     name: "system24",
@@ -45,15 +58,15 @@ export const GREEN_RAIN_THEME = {
         signal: "◆",
     },
     colors: {
-        border: rgb(8, 39, 31),
-        borderHot: rgb(0, 255, 194),
-        text: rgb(232, 248, 255),
-        muted: rgb(117, 143, 168),
-        primary: rgb(0, 255, 194),
-        success: rgb(0, 255, 194),
-        warning: rgb(255, 176, 0),
-        danger: rgb(255, 88, 116),
-        info: rgb(0, 214, 255),
+        border: fg(P.matrixDark),
+        borderHot: fg(P.mint),
+        text: fg(P.cream),
+        muted: fg(P.gray),
+        primary: fg(P.mint),
+        success: fg(P.mint),
+        warning: fg(P.orange),
+        danger: fg(P.red),
+        info: fg(P.blue),
     },
     motion: {
         rain: true,
@@ -74,15 +87,15 @@ export const NEON_GRID_THEME = {
         signal: "◇",
     },
     colors: {
-        border: rgb(34, 50, 74),
-        borderHot: rgb(0, 214, 255),
-        text: rgb(232, 248, 255),
-        muted: rgb(117, 143, 168),
-        primary: rgb(0, 214, 255),
-        success: rgb(0, 255, 194),
-        warning: rgb(255, 176, 0),
-        danger: rgb(255, 88, 116),
-        info: rgb(0, 214, 255),
+        border: fg(P.gridLine),
+        borderHot: fg(P.blue),
+        text: fg(P.cream),
+        muted: fg(P.gray),
+        primary: fg(P.blue),
+        success: fg(P.mint),
+        warning: fg(P.orange),
+        danger: fg(P.red),
+        info: fg(P.blue),
     },
     motion: {
         rain: false,
@@ -92,8 +105,8 @@ export const NEON_GRID_THEME = {
 export const RUST_FORGE_THEME = {
     name: "rust-forge",
     label: "OMK Rust Forge",
-    tagline: "Rust-native safety console for OMK orchestration.",
-    motto: "Forge native checks. Verify the evidence. Control the loop.",
+    tagline: "Oxidized forge console for standalone OMK control.",
+    motto: "Forge the route. Verify the evidence. OMK controls the loop.",
     symbols: {
         prompt: "›",
         active: "◉",
@@ -103,15 +116,15 @@ export const RUST_FORGE_THEME = {
         signal: "▣",
     },
     colors: {
-        border: rgb(124, 45, 18),
-        borderHot: rgb(249, 115, 22),
-        text: rgb(232, 248, 255),
-        muted: rgb(117, 143, 168),
-        primary: rgb(249, 115, 22),
-        success: rgb(0, 255, 194),
-        warning: rgb(255, 176, 0),
-        danger: rgb(255, 88, 116),
-        info: rgb(0, 214, 255),
+        border: rustFg("route.fallback"),
+        borderHot: rustFg("control.accent"),
+        text: rustFg("control.fg"),
+        muted: rustFg("control.dim"),
+        primary: rustFg("control.accent"),
+        success: rustFg("evidence.pass"),
+        warning: rustFg("telemetry.warn"),
+        danger: rustFg("telemetry.error"),
+        info: rustFg("route.active"),
     },
     motion: {
         rain: false,
@@ -133,13 +146,13 @@ export const MATRIX_THEME = {
     },
     colors: {
         border: rgb(0, 20, 0),
-        borderHot: rgb(0, 255, 65),
+        borderHot: fg(P.matrixRainGreen),
         text: rgb(200, 255, 200),
-        muted: rgb(0, 95, 25),
-        primary: rgb(0, 255, 65),
-        success: rgb(0, 255, 65),
-        warning: rgb(255, 176, 0),
-        danger: rgb(255, 50, 50),
+        muted: fg(P.matrixRainDim),
+        primary: fg(P.matrixRainGreen),
+        success: fg(P.matrixRainGreen),
+        warning: fg(P.matrixWarningAmber),
+        danger: fg(P.matrixErrorRed),
         info: rgb(0, 200, 50),
     },
     motion: {

package/dist/cli/release-promotion-gate.d.ts

@@ -3,8 +3,15 @@
  *
  * Computes a release viability score R_v from ten normalized input
  * dimensions and derives a verdict: block, pre-release, or stable.
+ *
+ * Weights are sourced from the omk.weights.v1 contract (releaseGate vector,
+ * normalize:true). The historical raw weights summed to 1.05; normalization
+ * divides weights, the regression penalty, and the verdict thresholds by the
+ * SAME factor (1/1.05), a pure uniform scaling — verdicts are mathematically
+ * identical for every input. Effective thresholds: preRelease ≈ 0.714286,
+ * stable ≈ 0.857143 (printed dynamically in reason strings).
  */
-import { type ReleasePromotionInputs, type ReleasePromotionResult } from "../runtime/contracts/weakness-remediation.js";
+import type { ReleasePromotionInputs, ReleasePromotionResult } from "../runtime/contracts/weakness-remediation.js";
 /** Gate engine contract. */
 export interface ReleasePromotionGate {
     /** Evaluate inputs and return scored result with verdict. */

package/dist/cli/release-promotion-gate.js

@@ -3,18 +3,30 @@
  *
  * Computes a release viability score R_v from ten normalized input
  * dimensions and derives a verdict: block, pre-release, or stable.
+ *
+ * Weights are sourced from the omk.weights.v1 contract (releaseGate vector,
+ * normalize:true). The historical raw weights summed to 1.05; normalization
+ * divides weights, the regression penalty, and the verdict thresholds by the
+ * SAME factor (1/1.05), a pure uniform scaling — verdicts are mathematically
+ * identical for every input. Effective thresholds: preRelease ≈ 0.714286,
+ * stable ≈ 0.857143 (printed dynamically in reason strings).
  */
-import { RELEASE_GATE_WEIGHTS, } from "../runtime/contracts/weakness-remediation.js";
+import { releaseGateEffective } from "../runtime/weights-config.js";
 /** Factory that creates the default release promotion gate. */
 export function createReleasePromotionGate() {
+    const effective = releaseGateEffective();
+    const w = effective.weights;
+    const penalties = effective.penalties;
+    const preReleaseThreshold = effective.thresholds.preRelease;
+    const stableThreshold = effective.thresholds.stable;
     return {
         evaluate(inputs) {
-            const w = RELEASE_GATE_WEIGHTS;
             const demoRun = inputs.demoRun ?? false;
             const maturity = inputs.maturity ?? inputs.providerMinimum ?? 0;
             const versionConsistency = inputs.versionConsistency ?? inputs.semver ?? 1;
             const liveBenchmarkPass = inputs.liveBenchmarkPass ?? false;
             const sandboxViolationCount = inputs.sandboxViolationCount ?? Number.POSITIVE_INFINITY;
+            const exactTagCiPass = inputs.exactTagCiPass ?? false;
             const rawScore = w.ci * inputs.ci +
                 w.build * (inputs.build ?? 0) +
                 w.types * (inputs.types ?? 0) +
@@ -24,7 +36,7 @@ export function createReleasePromotionGate() {
                 w.proof * inputs.proofMedian +
                 w.maturity * maturity +
                 w.docs * inputs.docs * versionConsistency -
-                w.regression * inputs.regressionSeverity;
+                penalties.regression * inputs.regressionSeverity;
             const score = clamp01(rawScore);
             const reasons = [];
             const blocked = inputs.ci === 0 || inputs.freshInstallSmoke === 0 || versionConsistency === 0 || !demoRun;
@@ -42,25 +54,25 @@ export function createReleasePromotionGate() {
                     reasons.push("Minimal verified demo run failed or missing (blocking)");
                 }
             }
-            const stableEligible = liveBenchmarkPass && sandboxViolationCount === 0;
+            const stableEligible = liveBenchmarkPass && sandboxViolationCount === 0 && exactTagCiPass;
             let verdict;
             if (blocked) {
                 verdict = "block";
             }
-            else if (score >= 0.90 && inputs.proofMedian >= 0.85 && maturity >= 0.80 && stableEligible) {
+            else if (score >= stableThreshold && inputs.proofMedian >= 0.85 && maturity >= 0.80 && stableEligible) {
                 verdict = "stable";
-                reasons.push(`Score ${formatScore(score)} meets stable threshold (≥0.90) with proof≥0.85, maturity≥0.80, live benchmark pass, and sandbox violations=0`);
+                reasons.push(`Score ${formatScore(score)} meets stable threshold (≥${stableThreshold.toFixed(2)}) with proof≥0.85, maturity≥0.80, live benchmark pass, sandbox violations=0, and exact-tag CI pass`);
             }
-            else if (score >= 0.75 && inputs.proofMedian >= 0.75) {
+            else if (score >= preReleaseThreshold && inputs.proofMedian >= 0.75) {
                 verdict = "pre-release";
-                reasons.push(`Score ${formatScore(score)} meets pre-release threshold (≥0.75) with proof≥0.75`);
-                if (score >= 0.90 && inputs.proofMedian >= 0.85 && maturity >= 0.80 && !stableEligible) {
-                    reasons.push("Stable verdict withheld until live benchmark passes and sandboxViolationCount is 0");
+                reasons.push(`Score ${formatScore(score)} meets pre-release threshold (≥${preReleaseThreshold.toFixed(2)}) with proof≥0.75`);
+                if (score >= stableThreshold && inputs.proofMedian >= 0.85 && maturity >= 0.80 && !stableEligible) {
+                    reasons.push("Stable verdict withheld until live benchmark passes, sandboxViolationCount is 0, and exact-tag CI passes");
                 }
             }
             else {
                 verdict = "block";
-                reasons.push(`Score ${formatScore(score)} below pre-release threshold (≥0.75) or proof below 0.75`);
+                reasons.push(`Score ${formatScore(score)} below pre-release threshold (≥${preReleaseThreshold.toFixed(2)}) or proof below 0.75`);
             }
             return {
                 score,

package/dist/cli/root.d.ts

@@ -1,4 +1,5 @@
 import type { Command } from "commander";
+export declare const OMK_ROOT_ENTRY_SURFACE = "omk-root-orchestrator";
 interface RootChatLaunchArgsOptions {
     readonly cliPath: string;
     readonly runId?: string;

package/dist/cli/root.js

@@ -3,6 +3,7 @@ import { t, initI18n } from "../util/i18n.js";
 import { buildCustomHelp } from "../util/help-text.js";
 const OMK_ENTRY_BRAND = "neon-grid";
 const OMK_ENTRY_UI = "neon-grid";
+export const OMK_ROOT_ENTRY_SURFACE = "omk-root-orchestrator";
 export function buildRootChatLaunchArgs(options) {
     const chatArgs = [
         options.cliPath,
@@ -90,7 +91,7 @@ export function configureRootProgram(program, OMK_VERSION, OMK_VERSION_FOOTER) {
         });
         const childEnv = {
             ...process.env,
-            OMK_ENTRY_SURFACE: "pi-omk",
+            OMK_ENTRY_SURFACE: OMK_ROOT_ENTRY_SURFACE,
         };
         const result = spawnSync(process.execPath, chatArgs, { stdio: "inherit", env: childEnv });
         if (result.status && result.status !== 0) {

package/dist/cli/theme/index.d.ts

@@ -1,9 +1,18 @@
 /**
  * CLI Theme — Barrel export for terminal capability, theme registry, and theme resolver.
  */
-export { getTerminalCapability, defaultThemeForCapability, } from "./terminal-capability.js";
-export type { TerminalCapability, ColorDepth, } from "./terminal-capability.js";
+export { getTerminalCapability, defaultThemeForCapability, detectColorTier, colorTierForDepth, } from "./terminal-capability.js";
+export type { TerminalCapability, ColorDepth, ColorTier, } from "./terminal-capability.js";
+export { hexToOklab, hexToRgb255, normalizeHex, nearestXterm256, buildXterm256Lookup, } from "./oklab-quantize.js";
+export type { OklabColor } from "./oklab-quantize.js";
+export { compileTheme } from "./render-table.js";
+export type { Ansi16Name, CompiledTheme, OmkThemeV1, RenderEntry, ThemeSemanticSpec, ThemeTokenKind, ThemeUsage, } from "./render-table.js";
 export { getBuiltinTheme, listBuiltinThemes, registerBuiltinTheme, __registry, } from "./theme-registry.js";
 export type { SemanticToken, ThemePalette, } from "./theme-registry.js";
 export { resolveTheme } from "./theme-resolver.js";
 export type { ResolveThemeOptions } from "./theme-resolver.js";
+export { renderStatusFrame } from "./status-frame.js";
+export { listThemeDocuments, loadThemeDocument, validateThemeDocument, } from "./theme-doc.js";
+export type { ThemeDocumentRef } from "./theme-doc.js";
+export { explainColorTier } from "./tier-explain.js";
+export type { ColorTierExplanation } from "./tier-explain.js";

package/dist/cli/theme/index.js

@@ -1,6 +1,11 @@
 /**
  * CLI Theme — Barrel export for terminal capability, theme registry, and theme resolver.
  */
-export { getTerminalCapability, defaultThemeForCapability, } from "./terminal-capability.js";
+export { getTerminalCapability, defaultThemeForCapability, detectColorTier, colorTierForDepth, } from "./terminal-capability.js";
+export { hexToOklab, hexToRgb255, normalizeHex, nearestXterm256, buildXterm256Lookup, } from "./oklab-quantize.js";
+export { compileTheme } from "./render-table.js";
 export { getBuiltinTheme, listBuiltinThemes, registerBuiltinTheme, __registry, } from "./theme-registry.js";
 export { resolveTheme } from "./theme-resolver.js";
+export { renderStatusFrame } from "./status-frame.js";
+export { listThemeDocuments, loadThemeDocument, validateThemeDocument, } from "./theme-doc.js";
+export { explainColorTier } from "./tier-explain.js";

package/dist/cli/theme/oklab-quantize.d.ts

@@ -0,0 +1,29 @@
+/**
+ * CLI Theme — OKLab xterm-256 Quantizer
+ * Precomputes an OKLab nearest-neighbor lookup mapping 24-bit theme colors to
+ * xterm-256 indexes 16-255 ONLY. System colors 0-15 are never emitted because
+ * users commonly remap them, which would break theme contrast guarantees.
+ *
+ * Pure functions, no I/O. OKLab math is self-contained, ported from
+ * scripts/theme-check.mjs (Björn Ottosson sRGB → OKLab).
+ */
+export interface OklabColor {
+    readonly L: number;
+    readonly a: number;
+    readonly b: number;
+}
+/** Normalize "#aabbcc" / "AABBCC" to canonical "#AABBCC". Throws on bad input. */
+export declare function normalizeHex(hex: string): string;
+/** Parse a normalized 6-digit hex color into 0-255 RGB channels. */
+export declare function hexToRgb255(hex: string): readonly [number, number, number];
+export declare function hexToOklab(hex: string): OklabColor;
+/**
+ * Nearest xterm-256 index (16-255 only) for a 24-bit hex color, measured by
+ * Euclidean distance in OKLab.
+ */
+export declare function nearestXterm256(hex: string): number;
+/**
+ * Precompute a lookup table mapping each distinct theme color to its nearest
+ * xterm-256 index. Keys are normalized hex ("#AABBCC").
+ */
+export declare function buildXterm256Lookup(hexes: readonly string[]): ReadonlyMap<string, number>;

package/dist/cli/theme/oklab-quantize.js

@@ -0,0 +1,105 @@
+/**
+ * CLI Theme — OKLab xterm-256 Quantizer
+ * Precomputes an OKLab nearest-neighbor lookup mapping 24-bit theme colors to
+ * xterm-256 indexes 16-255 ONLY. System colors 0-15 are never emitted because
+ * users commonly remap them, which would break theme contrast guarantees.
+ *
+ * Pure functions, no I/O. OKLab math is self-contained, ported from
+ * scripts/theme-check.mjs (Björn Ottosson sRGB → OKLab).
+ */
+function linearize(c) {
+    return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function channelsToOklab(r255, g255, b255) {
+    const r = linearize(r255 / 255);
+    const g = linearize(g255 / 255);
+    const b = linearize(b255 / 255);
+    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+    const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+    const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+    return {
+        L: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+        a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+        b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+    };
+}
+const HEX6_RE = /^#?[0-9A-Fa-f]{6}$/;
+/** Normalize "#aabbcc" / "AABBCC" to canonical "#AABBCC". Throws on bad input. */
+export function normalizeHex(hex) {
+    if (!HEX6_RE.test(hex)) {
+        throw new Error(`oklab-quantize: invalid 24-bit hex color "${hex}"`);
+    }
+    const v = hex.startsWith("#") ? hex.slice(1) : hex;
+    return `#${v.toUpperCase()}`;
+}
+/** Parse a normalized 6-digit hex color into 0-255 RGB channels. */
+export function hexToRgb255(hex) {
+    const v = normalizeHex(hex).slice(1);
+    return [
+        Number.parseInt(v.slice(0, 2), 16),
+        Number.parseInt(v.slice(2, 4), 16),
+        Number.parseInt(v.slice(4, 6), 16),
+    ];
+}
+export function hexToOklab(hex) {
+    const [r, g, b] = hexToRgb255(hex);
+    return channelsToOklab(r, g, b);
+}
+// xterm 6x6x6 color-cube channel levels (indexes 16-231).
+const CUBE_LEVELS = [0, 95, 135, 175, 215, 255];
+/** Build the OKLab palette for xterm indexes 16-255 (cube + grayscale ramp). */
+function buildXtermPalette() {
+    const entries = [];
+    for (let r = 0; r < 6; r++) {
+        for (let g = 0; g < 6; g++) {
+            for (let b = 0; b < 6; b++) {
+                entries.push({
+                    index: 16 + 36 * r + 6 * g + b,
+                    lab: channelsToOklab(CUBE_LEVELS[r], CUBE_LEVELS[g], CUBE_LEVELS[b]),
+                });
+            }
+        }
+    }
+    // Grayscale ramp: indexes 232-255 map to gray levels 8, 18, ..., 238.
+    for (let i = 0; i < 24; i++) {
+        const v = 8 + 10 * i;
+        entries.push({ index: 232 + i, lab: channelsToOklab(v, v, v) });
+    }
+    return entries;
+}
+// Precomputed once at module load — this is the "theme build/load time" cost.
+const XTERM_PALETTE = buildXtermPalette();
+/**
+ * Nearest xterm-256 index (16-255 only) for a 24-bit hex color, measured by
+ * Euclidean distance in OKLab.
+ */
+export function nearestXterm256(hex) {
+    const lab = hexToOklab(hex);
+    let bestIndex = 16;
+    let bestDist = Number.POSITIVE_INFINITY;
+    for (const entry of XTERM_PALETTE) {
+        const dL = lab.L - entry.lab.L;
+        const da = lab.a - entry.lab.a;
+        const db = lab.b - entry.lab.b;
+        const dist = dL * dL + da * da + db * db;
+        if (dist < bestDist) {
+            bestDist = dist;
+            bestIndex = entry.index;
+        }
+    }
+    return bestIndex;
+}
+/**
+ * Precompute a lookup table mapping each distinct theme color to its nearest
+ * xterm-256 index. Keys are normalized hex ("#AABBCC").
+ */
+export function buildXterm256Lookup(hexes) {
+    const lookup = new Map();
+    for (const hex of hexes) {
+        const key = normalizeHex(hex);
+        if (!lookup.has(key)) {
+            lookup.set(key, nearestXterm256(key));
+        }
+    }
+    return lookup;
+}