open-multi-agent-kit 0.78.6 → 0.78.7

package/dist/brand/rust-forge.theme.json

@@ -0,0 +1,216 @@
+{
+    "$schema": "../schemas/omk.theme.v1.schema.json",
+    "schemaVersion": "omk.theme.v1",
+    "name": "rust-forge",
+    "displayName": "OMK Rust Forge — Standalone Oxidized Forge Console",
+    "mode": "dark",
+    "primitives": {
+        "iron": "#0E0B09",
+        "coal": "#080605",
+        "forge": "#1A1310",
+        "anvil": "#241914",
+        "rust": "#FF6A3D",
+        "molten": "#FF7A4A",
+        "copper": "#E08A4B",
+        "ember": "#FFB454",
+        "oxide": "#4FB39B",
+        "quench": "#78E4C9",
+        "verdigris": "#6FD7B8",
+        "crimson": "#FF5468",
+        "steel": "#9FB0BD",
+        "scale": "#BFA08A",
+        "ash": "#C9B8A8",
+        "slag": "#8F7B6D",
+        "bone": "#F2E4D6"
+    },
+    "backgrounds": [
+        "iron",
+        "forge"
+    ],
+    "semantics": {
+        "route.active": {
+            "color": "rust",
+            "glyph": "▸",
+            "usage": "text"
+        },
+        "route.fallback": {
+            "color": "copper",
+            "glyph": "↻",
+            "usage": "text"
+        },
+        "route.dead": {
+            "color": "crimson",
+            "glyph": "✕",
+            "usage": "text"
+        },
+        "evidence.pass": {
+            "color": "oxide",
+            "glyph": "✓",
+            "usage": "text"
+        },
+        "evidence.fail": {
+            "color": "crimson",
+            "glyph": "✗",
+            "usage": "text"
+        },
+        "evidence.pending": {
+            "color": "ember",
+            "glyph": "◐",
+            "usage": "text"
+        },
+        "dag.lane.running": {
+            "color": "rust",
+            "glyph": "▶",
+            "usage": "text"
+        },
+        "dag.lane.blocked": {
+            "color": "copper",
+            "glyph": "⏸",
+            "usage": "text"
+        },
+        "dag.lane.done": {
+            "color": "verdigris",
+            "glyph": "●",
+            "usage": "text"
+        },
+        "dag.lane.queued": {
+            "color": "slag",
+            "glyph": "◌",
+            "usage": "text",
+            "adjusted": {
+                "original": "#6E5B4E",
+                "crBefore": 2.86,
+                "crAfter": 4.56
+            }
+        },
+        "telemetry.info": {
+            "color": "bone",
+            "glyph": "·",
+            "usage": "text"
+        },
+        "telemetry.warn": {
+            "color": "ember",
+            "glyph": "▲",
+            "usage": "text"
+        },
+        "telemetry.error": {
+            "color": "crimson",
+            "glyph": "✖",
+            "usage": "text"
+        },
+        "control.accent": {
+            "color": "rust",
+            "glyph": "◆",
+            "kind": "chrome",
+            "usage": "indicator"
+        },
+        "control.dim": {
+            "color": "steel",
+            "glyph": "┊",
+            "kind": "chrome",
+            "usage": "text"
+        },
+        "control.fg": {
+            "color": "bone",
+            "kind": "chrome",
+            "usage": "text"
+        },
+        "control.bg": {
+            "color": "iron",
+            "kind": "background",
+            "usage": "background"
+        },
+        "forge.heat": {
+            "color": "molten",
+            "glyph": "▰",
+            "usage": "text"
+        },
+        "forge.anvil": {
+            "color": "scale",
+            "glyph": "▣",
+            "usage": "text"
+        },
+        "forge.quench": {
+            "color": "quench",
+            "glyph": "◈",
+            "usage": "text"
+        },
+        "forge.slag": {
+            "color": "slag",
+            "glyph": "◌",
+            "usage": "text",
+            "adjusted": {
+                "original": "#6E5B4E",
+                "crBefore": 2.86,
+                "crAfter": 4.56
+            }
+        }
+    },
+    "components": {
+        "statusCard": {
+            "border": "control.accent",
+            "title": "control.fg",
+            "body": "telemetry.info",
+            "meta": "control.dim"
+        },
+        "routerTable": {
+            "active": "route.active",
+            "fallback": "route.fallback",
+            "dead": "route.dead",
+            "header": "control.accent"
+        },
+        "evidenceGate": {
+            "pass": "evidence.pass",
+            "fail": "evidence.fail",
+            "pending": "evidence.pending"
+        },
+        "dagLanes": {
+            "running": "dag.lane.running",
+            "blocked": "dag.lane.blocked",
+            "done": "dag.lane.done",
+            "queued": "dag.lane.queued"
+        },
+        "logStream": {
+            "info": "telemetry.info",
+            "warn": "telemetry.warn",
+            "error": "telemetry.error",
+            "dim": "control.dim"
+        },
+        "forgeConsole": {
+            "heat": "forge.heat",
+            "anvil": "forge.anvil",
+            "quench": "forge.quench",
+            "slag": "forge.slag",
+            "title": "control.fg"
+        }
+    },
+    "fallback16": {
+        "route.active": "brightRed",
+        "route.fallback": "brightYellow",
+        "route.dead": "brightRed",
+        "evidence.pass": "brightGreen",
+        "evidence.fail": "brightRed",
+        "evidence.pending": "brightYellow",
+        "dag.lane.running": "brightRed",
+        "dag.lane.blocked": "brightYellow",
+        "dag.lane.done": "brightGreen",
+        "dag.lane.queued": "white",
+        "telemetry.info": "brightWhite",
+        "telemetry.warn": "brightYellow",
+        "telemetry.error": "brightRed",
+        "control.accent": "brightRed",
+        "control.dim": "white",
+        "control.fg": "brightWhite",
+        "control.bg": "black",
+        "forge.heat": "brightRed",
+        "forge.anvil": "white",
+        "forge.quench": "brightGreen",
+        "forge.slag": "white"
+    },
+    "meta": {
+        "provenance": "Standalone oxidized rust-forge palette for the OMK orchestration console. Warm coal/iron/anvil backgrounds, rust-orange + molten + copper + ember heat accents, oxide/quench/verdigris patina greens for pass/done, crimson for fail/dead, steel/scale/ash grays, and bone foreground. Forge-specific heat/anvil/quench semantics make OMK control surfaces distinct from provider branding while preserving NO_COLOR glyph safety.",
+        "tierAssumptions": "16-color tier gated against stock VGA/xterm ANSI values; terminals with remapped ANSI-16 palettes are outside the contract — glyphs are the safety net. NO_COLOR note: control.dim uses ┊ so logStream info (telemetry.info ·) and dim rows stay distinguishable without color.",
+        "omkVersion": "0.78.6",
+        "independence": "OMK is the control plane; providers and models are adapter lanes, never the product identity or final authority."
+    }
+}

package/dist/brand/theme-compiled.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 type { CompiledTheme, OmkThemeV1 } from "../cli/theme/render-table.js";
+import type { ColorTier } from "../cli/theme/terminal-capability.js";
+/** Plain 0-255 RGB triple used across the brand palette public API. */
+export interface BrandRgb {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+}
+/** Primitive names the legacy brand palette requires from night-city. */
+export type NightCityPrimitive = "dark" | "surface" | "cyan" | "mint" | "magenta" | "purple" | "amber" | "red" | "cream" | "muted" | "gray";
+export type RustForgePrimitive = "iron" | "coal" | "forge" | "anvil" | "rust" | "molten" | "copper" | "ember" | "oxide" | "quench" | "verdigris" | "crimson" | "steel" | "scale" | "ash" | "slag" | "bone";
+export type BrandThemeName = "night-city" | "rust-forge";
+/** Validated night-city theme document (build-time snapshot of themes/). */
+export declare const NIGHT_CITY_THEME: OmkThemeV1;
+/** Validated rust-forge theme document (build-time snapshot of themes/). */
+export declare const RUST_FORGE_THEME: OmkThemeV1;
+export declare function resolveBrandThemeName(name: string | undefined): BrandThemeName;
+export declare function setActiveBrandTheme(name: string | undefined): BrandThemeName;
+export declare function getActiveBrandThemeName(): BrandThemeName;
+export declare function getActiveBrandTheme(): OmkThemeV1;
+export declare function activeThemeHexByRole(role: string): string;
+export declare function brandThemeHexByRole(name: BrandThemeName, role: string): string;
+export declare function brandThemeRgbByRole(name: BrandThemeName, role: string): BrandRgb;
+export declare function activeThemeRgbByRole(role: string): BrandRgb;
+export declare function activeThemeHexByPrimitive(primitive: string): string;
+/** Canonical normalized uppercase hex string for a night-city primitive. */
+export declare function nightCityHex(primitive: NightCityPrimitive): string;
+/** 0-255 RGB triple for a night-city primitive. */
+export declare function nightCityRgb(primitive: NightCityPrimitive): BrandRgb;
+/** Convert an RGB triple to canonical uppercase hex (no literal hex in source). */
+export declare function rgbToHex(color: BrandRgb): string;
+/**
+ * Compiled active brand render table for the requested (default: detected)
+ * degradation tier. The cache key includes both theme name and tier.
+ */
+export declare function getCompiledBrandTheme(tier?: ColorTier): CompiledTheme;
+/** Paint text with an active-brand semantic token at the detected color tier. */
+export declare function brandPaint(role: string, text: string): string;
+export declare function getActiveBrandChromeLabel(): string;
+export declare function getActiveBrandCockpitSubtitle(): string;
+export declare function getActiveBrandCockpitDetail(): string;
+export declare function getActiveBrandHudStatus(): string;
+export declare function getActiveBrandConsoleLine(): string;
+/**
+ * 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 declare function brandTruecolorSgr(color: BrandRgb): string;

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. */