open-multi-agent-kit 0.78.6 → 0.78.8

package/dist/cli/theme/render-table.d.ts

@@ -0,0 +1,59 @@
+/**
+ * CLI Theme — Render Table Compiler
+ * Compiles an omk.theme.v1 document (themes/*.theme.json) into per-surface
+ * render tables at startup. For each semantic token it precomputes the SGR
+ * sequence for the requested degradation tier:
+ *   truecolor → SGR 38;2;R;G;B
+ *   256       → SGR 38;5;N via the OKLab nearest-neighbor lookup (16-255 only)
+ *   16        → the theme's hand-authored ansi16 (fallback16) mapping
+ *   no-color  → empty string
+ * Single entrypoint: compileTheme(theme, tier).
+ */
+import type { ColorTier } from "./terminal-capability.js";
+export type ThemeUsage = "text" | "indicator" | "background";
+export type ThemeTokenKind = "state" | "chrome" | "background";
+export type Ansi16Name = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "brightBlack" | "brightRed" | "brightGreen" | "brightYellow" | "brightBlue" | "brightMagenta" | "brightCyan" | "brightWhite";
+export interface ThemeSemanticSpec {
+    readonly color: string;
+    readonly glyph?: string;
+    readonly kind?: ThemeTokenKind;
+    readonly usage: ThemeUsage;
+}
+export interface OmkThemeV1 {
+    readonly schemaVersion: "omk.theme.v1";
+    readonly name: string;
+    readonly displayName?: string;
+    readonly mode: "dark" | "light";
+    readonly primitives: Readonly<Record<string, string>>;
+    readonly backgrounds: readonly string[];
+    readonly semantics: Readonly<Record<string, ThemeSemanticSpec>>;
+    readonly components: Readonly<Record<string, Readonly<Record<string, string>>>>;
+    readonly fallback16: Readonly<Record<string, string>>;
+}
+export interface RenderEntry {
+    /** Semantic role this entry resolves (e.g. "dag.lane.running"). */
+    readonly role: string;
+    /** Canonical 24-bit hex of the underlying primitive. */
+    readonly hex: string;
+    /** Mandatory state glyph, or "" for chrome/background tokens. */
+    readonly glyph: string;
+    /** Precomputed SGR open sequence for the compiled tier ("" on no-color). */
+    readonly sgr: string;
+}
+export interface CompiledTheme {
+    readonly name: string;
+    readonly tier: ColorTier;
+    /** SGR reset for this tier ("" on no-color). */
+    readonly reset: string;
+    /** Semantic role → precomputed render entry. */
+    readonly tokens: Readonly<Record<string, RenderEntry>>;
+    /** Component surface → slot → precomputed render entry. */
+    readonly surfaces: Readonly<Record<string, Readonly<Record<string, RenderEntry>>>>;
+    /** Wrap text in the precomputed sequence for a semantic role. */
+    readonly paint: (role: string, text: string) => string;
+}
+/**
+ * Compile an omk.theme.v1 document into a per-surface render table for one
+ * degradation tier. Pure: computes everything up front, performs no I/O.
+ */
+export declare function compileTheme(theme: OmkThemeV1, tier: ColorTier): CompiledTheme;

package/dist/cli/theme/render-table.js

@@ -0,0 +1,112 @@
+/**
+ * CLI Theme — Render Table Compiler
+ * Compiles an omk.theme.v1 document (themes/*.theme.json) into per-surface
+ * render tables at startup. For each semantic token it precomputes the SGR
+ * sequence for the requested degradation tier:
+ *   truecolor → SGR 38;2;R;G;B
+ *   256       → SGR 38;5;N via the OKLab nearest-neighbor lookup (16-255 only)
+ *   16        → the theme's hand-authored ansi16 (fallback16) mapping
+ *   no-color  → empty string
+ * Single entrypoint: compileTheme(theme, tier).
+ */
+import { buildXterm256Lookup, normalizeHex, hexToRgb255 } from "./oklab-quantize.js";
+const ESC = "\u001b[";
+const SGR_RESET = `${ESC}0m`;
+// Foreground SGR codes for the 16-color tier (standard 30-37, bright 90-97).
+const ANSI16_FG = {
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    white: 37,
+    brightBlack: 90,
+    brightRed: 91,
+    brightGreen: 92,
+    brightYellow: 93,
+    brightBlue: 94,
+    brightMagenta: 95,
+    brightCyan: 96,
+    brightWhite: 97,
+};
+function isAnsi16Name(name) {
+    return Object.prototype.hasOwnProperty.call(ANSI16_FG, name);
+}
+function resolvePrimitiveHex(theme, role, color) {
+    const raw = theme.primitives[color];
+    if (raw === undefined) {
+        throw new Error(`compileTheme(${theme.name}): semantic "${role}" references unknown primitive "${color}"`);
+    }
+    return normalizeHex(raw);
+}
+function sgrForTier(theme, role, hex, tier, lookup256) {
+    switch (tier) {
+        case "truecolor": {
+            const [r, g, b] = hexToRgb255(hex);
+            return `${ESC}38;2;${r};${g};${b}m`;
+        }
+        case "256": {
+            const index = lookup256.get(hex);
+            if (index === undefined) {
+                throw new Error(`compileTheme(${theme.name}): missing 256-color lookup for "${role}" (${hex})`);
+            }
+            return `${ESC}38;5;${index}m`;
+        }
+        case "16": {
+            const name = theme.fallback16[role];
+            if (name === undefined || !isAnsi16Name(name)) {
+                throw new Error(`compileTheme(${theme.name}): semantic "${role}" has no valid ansi16 fallback (got "${name ?? "<missing>"}")`);
+            }
+            return `${ESC}${ANSI16_FG[name]}m`;
+        }
+        case "no-color":
+            return "";
+    }
+}
+/**
+ * Compile an omk.theme.v1 document into a per-surface render table for one
+ * degradation tier. Pure: computes everything up front, performs no I/O.
+ */
+export function compileTheme(theme, tier) {
+    // Precompute the OKLab → xterm-256 lookup once per compile (build/load time).
+    const distinctHexes = Object.entries(theme.semantics).map(([role, spec]) => resolvePrimitiveHex(theme, role, spec.color));
+    const lookup256 = tier === "256" ? buildXterm256Lookup(distinctHexes) : new Map();
+    const tokens = {};
+    for (const [role, spec] of Object.entries(theme.semantics)) {
+        const hex = resolvePrimitiveHex(theme, role, spec.color);
+        tokens[role] = {
+            role,
+            hex,
+            glyph: spec.glyph ?? "",
+            sgr: sgrForTier(theme, role, hex, tier, lookup256),
+        };
+    }
+    const surfaces = {};
+    for (const [surface, slots] of Object.entries(theme.components)) {
+        const compiled = {};
+        for (const [slot, role] of Object.entries(slots)) {
+            const entry = tokens[role];
+            if (entry === undefined) {
+                throw new Error(`compileTheme(${theme.name}): component ${surface}.${slot} references unknown semantic role "${role}"`);
+            }
+            compiled[slot] = entry;
+        }
+        surfaces[surface] = compiled;
+    }
+    const reset = tier === "no-color" ? "" : SGR_RESET;
+    return {
+        name: theme.name,
+        tier,
+        reset,
+        tokens,
+        surfaces,
+        paint(role, text) {
+            const entry = tokens[role];
+            if (entry === undefined || entry.sgr === "")
+                return text;
+            return entry.sgr + text + reset;
+        },
+    };
+}

package/dist/cli/theme/status-frame.d.ts

@@ -0,0 +1,10 @@
+/**
+ * CLI Theme — Representative Status Frame
+ * Renders the ONE representative TUI status frame shared by the four-tier
+ * degradation snapshots (test/theme-degradation.test.mjs) and the
+ * `omk theme preview <name>` CLI surface. Keeping a single renderer
+ * guarantees the CLI preview shows exactly the snapshot-gated frame.
+ */
+import type { CompiledTheme } from "./render-table.js";
+/** One representative TUI status frame built from theme tokens + glyphs. */
+export declare function renderStatusFrame(ct: CompiledTheme): string;

package/dist/cli/theme/status-frame.js

@@ -0,0 +1,22 @@
+/**
+ * CLI Theme — Representative Status Frame
+ * Renders the ONE representative TUI status frame shared by the four-tier
+ * degradation snapshots (test/theme-degradation.test.mjs) and the
+ * `omk theme preview <name>` CLI surface. Keeping a single renderer
+ * guarantees the CLI preview shows exactly the snapshot-gated frame.
+ */
+function paintWithGlyph(ct, role, text) {
+    const entry = ct.tokens[role];
+    const glyph = entry?.glyph ?? "";
+    return ct.paint(role, glyph === "" ? text : `${glyph} ${text}`);
+}
+/** One representative TUI status frame built from theme tokens + glyphs. */
+export function renderStatusFrame(ct) {
+    const p = (role, text) => paintWithGlyph(ct, role, text);
+    return [
+        `${p("control.accent", "OMK//CONTROL")} ${p("control.dim", "night-city ops console")}`,
+        `${p("dag.lane.running", "lane compile")}  ${p("dag.lane.done", "lane schema")}  ${p("dag.lane.queued", "lane docs")}`,
+        `${p("evidence.pass", "contrast 48/48")}  ${p("evidence.pending", "snapshots")}  ${p("route.fallback", "provider kimi")}`,
+        `${p("telemetry.warn", "headroom 81%")}  ${p("control.fg", "tier ready")}`,
+    ].join("\n");
+}

package/dist/cli/theme/terminal-capability.d.ts

@@ -3,15 +3,20 @@
  * Detects color support, unicode, TTY status, and terminal dimensions.
  */
 export type ColorDepth = 0 | 1 | 4 | 8 | 24;
+/** Degradation tier used by the render-table compiler. */
+export type ColorTier = "truecolor" | "256" | "16" | "no-color";
 export interface TerminalCapability {
     readonly isTty: boolean;
     readonly isCi: boolean;
     readonly colorDisabled: boolean;
     readonly colorDepth: ColorDepth;
+    readonly colorTier: ColorTier;
     readonly unicode: boolean;
     readonly width: number;
 }
-export declare function getTerminalCapability(): TerminalCapability;
+export declare function colorTierForDepth(depth: ColorDepth): ColorTier;
+export declare function detectColorTier(argv?: readonly string[]): ColorTier;
+export declare function getTerminalCapability(argv?: readonly string[]): TerminalCapability;
 export declare function defaultThemeForCapability(cap: TerminalCapability): {
     name: string;
     mode: "dark" | "light" | "auto" | "mono";

package/dist/cli/theme/terminal-capability.js

@@ -14,8 +14,11 @@ function detectCi() {
         || process.env.APPVEYOR
         || process.env.JENKINS_URL);
 }
-function detectColorDepth() {
-    // Explicit opt-out
+function detectColorDepth(argv = process.argv) {
+    // Explicit opt-out: --no-color CLI flag or NO_COLOR env
+    if (argv.includes("--no-color")) {
+        return 0;
+    }
     if (process.env.NO_COLOR !== undefined || process.env.TERM === "dumb") {
         return 0;
     }
@@ -65,14 +68,27 @@ function getTerminalWidth() {
     }
     return 80;
 }
-export function getTerminalCapability() {
+export function colorTierForDepth(depth) {
+    if (depth === 24)
+        return "truecolor";
+    if (depth === 8)
+        return "256";
+    if (depth === 4 || depth === 1)
+        return "16";
+    return "no-color";
+}
+export function detectColorTier(argv = process.argv) {
+    return colorTierForDepth(detectColorDepth(argv));
+}
+export function getTerminalCapability(argv = process.argv) {
     const isCi = detectCi();
-    const colorDepth = detectColorDepth();
+    const colorDepth = detectColorDepth(argv);
     return {
         isTty: process.stdout.isTTY ?? false,
         isCi,
         colorDisabled: colorDepth === 0,
         colorDepth,
+        colorTier: colorTierForDepth(colorDepth),
         unicode: detectUnicode(),
         width: getTerminalWidth(),
     };

package/dist/cli/theme/theme-doc.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CLI Theme — omk.theme.v1 Document Loader
+ * Discovers, loads, and structurally validates themes/*.theme.json documents
+ * (the executable twin of schemas/omk.theme.v1.schema.json, mirroring
+ * scripts/theme-check.mjs validateTheme()). Read-only filesystem access.
+ */
+import type { OmkThemeV1 } from "./render-table.js";
+export interface ThemeDocumentRef {
+    /** Theme name derived from the file name (e.g. "night-city"). */
+    readonly name: string;
+    /** Absolute path of the .theme.json document. */
+    readonly path: string;
+}
+/** List omk.theme.v1 documents discoverable from cwd (or the package root). */
+export declare function listThemeDocuments(cwd?: string): readonly ThemeDocumentRef[];
+/** Load one theme document by name. Returns undefined when absent/unreadable. */
+export declare function loadThemeDocument(name: string, cwd?: string): OmkThemeV1 | undefined;
+/**
+ * Structural validation of an omk.theme.v1 document — the same executable
+ * rules scripts/theme-check.mjs enforces in CI. Returns [] when valid.
+ */
+export declare function validateThemeDocument(theme: OmkThemeV1): readonly string[];

package/dist/cli/theme/theme-doc.js

@@ -0,0 +1,97 @@
+/**
+ * CLI Theme — omk.theme.v1 Document Loader
+ * Discovers, loads, and structurally validates themes/*.theme.json documents
+ * (the executable twin of schemas/omk.theme.v1.schema.json, mirroring
+ * scripts/theme-check.mjs validateTheme()). Read-only filesystem access.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const ANSI16_NAMES = new Set([
+    "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
+    "brightBlack", "brightRed", "brightGreen", "brightYellow",
+    "brightBlue", "brightMagenta", "brightCyan", "brightWhite",
+]);
+/** Candidate themes/ directories: project cwd first, then the package root. */
+function themesDirCandidates(cwd) {
+    const moduleRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+    const candidates = [join(cwd, "themes"), join(moduleRoot, "themes")];
+    return [...new Set(candidates)];
+}
+/** List omk.theme.v1 documents discoverable from cwd (or the package root). */
+export function listThemeDocuments(cwd = process.cwd()) {
+    for (const dir of themesDirCandidates(cwd)) {
+        if (!existsSync(dir))
+            continue;
+        const refs = readdirSync(dir)
+            .filter((f) => f.endsWith(".theme.json"))
+            .map((f) => ({ name: f.replace(/\.theme\.json$/, ""), path: join(dir, f) }));
+        if (refs.length > 0)
+            return refs;
+    }
+    return [];
+}
+/** Load one theme document by name. Returns undefined when absent/unreadable. */
+export function loadThemeDocument(name, cwd = process.cwd()) {
+    const ref = listThemeDocuments(cwd).find((r) => r.name === name);
+    if (ref === undefined)
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(ref.path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Structural validation of an omk.theme.v1 document — the same executable
+ * rules scripts/theme-check.mjs enforces in CI. Returns [] when valid.
+ */
+export function validateThemeDocument(theme) {
+    const errors = [];
+    const err = (m) => { errors.push(m); };
+    if (theme.schemaVersion !== "omk.theme.v1")
+        err(`schemaVersion must be "omk.theme.v1"`);
+    if (!/^[a-z][a-z0-9-]*$/.test(theme.name ?? ""))
+        err("invalid theme name");
+    if (theme.mode !== "dark" && theme.mode !== "light")
+        err("mode must be dark|light");
+    const primitives = theme.primitives ?? {};
+    for (const [k, v] of Object.entries(primitives)) {
+        if (!/^#[0-9A-Fa-f]{6}$/.test(v))
+            err(`primitive ${k}: bad hex ${v}`);
+    }
+    for (const bg of theme.backgrounds ?? []) {
+        if (primitives[bg] === undefined)
+            err(`background "${bg}" is not a primitive`);
+    }
+    const semantics = theme.semantics ?? {};
+    for (const [role, spec] of Object.entries(semantics)) {
+        if (primitives[spec.color] === undefined)
+            err(`semantic ${role}: color "${spec.color}" is not a primitive`);
+        const kind = spec.kind ?? "state";
+        if (kind === "state" && (spec.glyph === undefined || spec.glyph === "")) {
+            err(`semantic state ${role}: missing mandatory glyph`);
+        }
+        if (!["text", "indicator", "background"].includes(spec.usage))
+            err(`semantic ${role}: bad usage`);
+    }
+    for (const [comp, slots] of Object.entries(theme.components ?? {})) {
+        for (const [slot, role] of Object.entries(slots)) {
+            if (semantics[role] === undefined)
+                err(`component ${comp}.${slot}: unknown semantic role "${role}"`);
+        }
+    }
+    const fb = theme.fallback16 ?? {};
+    for (const role of Object.keys(semantics)) {
+        if (fb[role] === undefined)
+            err(`fallback16: missing entry for semantic role "${role}"`);
+    }
+    for (const [role, name] of Object.entries(fb)) {
+        if (!ANSI16_NAMES.has(name))
+            err(`fallback16 ${role}: unknown ANSI-16 name "${name}"`);
+        if (semantics[role] === undefined)
+            err(`fallback16 ${role}: no such semantic role`);
+    }
+    return errors;
+}

package/dist/cli/theme/theme-registry.js

@@ -3,6 +3,10 @@
  * Maps semantic tokens to ANSI colors. Reuses src/theme/colors.ts exports.
  */
 import { style } from "../../theme/colors.js";
+import { compileTheme } from "./render-table.js";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 // --- omk (full brand) ---
 const omkPalette = {
     name: "omk",
@@ -138,30 +142,47 @@ const neonCircuitPalette = {
         }
     },
 };
-// --- rust-forge (Rust/native safety console) ---
+// --- rust-forge (oxidized forge console) ---
+// Compiled from themes/rust-forge.theme.json (omk.theme.v1).
+const rustForgeDoc = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "themes", "rust-forge.theme.json"), "utf8"));
+const rustForgeCompiled = compileTheme(rustForgeDoc, "truecolor");
 const rustForgePalette = {
     name: "rust-forge",
     mode: "dark",
     supportsColor: true,
     render(semantic, text) {
+        const map = {
+            success: "evidence.pass",
+            warning: "telemetry.warn",
+            error: "telemetry.error",
+            info: "telemetry.info",
+            agent: "control.accent",
+            task: "control.fg",
+            tool: "evidence.pass",
+            header: "control.accent",
+            subheader: "dag.lane.done",
+            separator: "control.dim",
+            bullet: "control.accent",
+            labelKey: "control.dim",
+            labelValue: "control.fg",
+        };
         switch (semantic) {
-            case "success": return style.cargoGreen(text);
-            case "warning": return style.orangeBold(text);
-            case "error": return style.redBold(text);
-            case "info": return style.rustBold(text);
-            case "agent": return style.rust(text);
-            case "task": return style.cream(text);
-            case "tool": return style.cargoGreen(text);
-            case "header": return style.rustBold(text);
-            case "subheader": return style.cargoGreen(text);
-            case "dim": return style.dim + text + style.reset;
-            case "bold": return style.bold + text + style.reset;
-            case "reset": return style.reset + text;
-            case "separator": return style.rustOxide(text);
-            case "bullet": return style.rust("▣ " + text);
-            case "labelKey": return style.gray(text);
-            case "labelValue": return style.cream(text);
-            default: return text;
+            case "dim": return "\u001b[2m" + text + "\u001b[0m";
+            case "bold": return "\u001b[1m" + text + "\u001b[0m";
+            case "reset": return "\u001b[0m" + text;
+            case "bullet": {
+                const entry = rustForgeCompiled.tokens[map.bullet];
+                return entry ? entry.sgr + "▣ " + text + rustForgeCompiled.reset : text;
+            }
+            default: {
+                const role = map[semantic];
+                if (role) {
+                    const entry = rustForgeCompiled.tokens[role];
+                    if (entry)
+                        return entry.sgr + text + rustForgeCompiled.reset;
+                }
+                return text;
+            }
         }
     },
 };

package/dist/cli/theme/tier-explain.d.ts

@@ -0,0 +1,21 @@
+/**
+ * CLI Theme — Color Tier Explanation
+ * Re-derives the degradation tier with the SAME precedence rules as
+ * terminal-capability.ts detectColorDepth(), but records WHY each decision
+ * was taken (env vars, --no-color flag, TERM) for `omk doctor` reporting.
+ */
+import type { ColorTier } from "./terminal-capability.js";
+export interface ColorTierExplanation {
+    readonly tier: ColorTier;
+    /** Human-readable reasons, in detection-precedence order. */
+    readonly reasons: readonly string[];
+    /** True when NO_COLOR env or --no-color flag asked for color suppression. */
+    readonly noColorRequested: boolean;
+    /** True when a no-color request actually resulted in the no-color tier. */
+    readonly noColorHonored: boolean;
+}
+/**
+ * Explain the detected color tier. Pure given (argv, env, isTty); defaults
+ * mirror terminal-capability.ts getTerminalCapability() inputs.
+ */
+export declare function explainColorTier(argv?: readonly string[], env?: NodeJS.ProcessEnv, isTty?: boolean): ColorTierExplanation;

package/dist/cli/theme/tier-explain.js

@@ -0,0 +1,60 @@
+/**
+ * CLI Theme — Color Tier Explanation
+ * Re-derives the degradation tier with the SAME precedence rules as
+ * terminal-capability.ts detectColorDepth(), but records WHY each decision
+ * was taken (env vars, --no-color flag, TERM) for `omk doctor` reporting.
+ */
+import { colorTierForDepth } from "./terminal-capability.js";
+function decideDepth(argv, env, isTty) {
+    if (argv.includes("--no-color")) {
+        return { depth: 0, reason: "--no-color CLI flag" };
+    }
+    if (env.NO_COLOR !== undefined) {
+        return { depth: 0, reason: "NO_COLOR env var set" };
+    }
+    if (env.TERM === "dumb") {
+        return { depth: 0, reason: "TERM=dumb" };
+    }
+    const force = env.FORCE_COLOR;
+    if (force === "0" || force === "false")
+        return { depth: 0, reason: `FORCE_COLOR=${force}` };
+    if (force === "1")
+        return { depth: 1, reason: "FORCE_COLOR=1 (basic ANSI)" };
+    if (force === "2")
+        return { depth: 4, reason: "FORCE_COLOR=2 (16-color)" };
+    if (force === "3")
+        return { depth: 8, reason: "FORCE_COLOR=3 (256-color)" };
+    if (env.COLORTERM === "truecolor" || env.COLORTERM === "24bit") {
+        return { depth: 24, reason: `COLORTERM=${env.COLORTERM}` };
+    }
+    const term = env.TERM ?? "";
+    if (term.includes("256color") || term.includes("256")) {
+        return { depth: 8, reason: `TERM=${term} (256-color terminfo)` };
+    }
+    if (term.includes("color") || term.includes("xterm") || term.includes("screen") || term.includes("tmux")) {
+        return { depth: 4, reason: `TERM=${term} (basic color terminfo)` };
+    }
+    if (isTty) {
+        return { depth: 1, reason: "TTY without explicit color hints (basic ANSI assumed)" };
+    }
+    return { depth: 0, reason: "not a TTY and no color env hints" };
+}
+/**
+ * Explain the detected color tier. Pure given (argv, env, isTty); defaults
+ * mirror terminal-capability.ts getTerminalCapability() inputs.
+ */
+export function explainColorTier(argv = process.argv, env = process.env, isTty = process.stdout.isTTY ?? false) {
+    const decision = decideDepth(argv, env, isTty);
+    const tier = colorTierForDepth(decision.depth);
+    const noColorRequested = argv.includes("--no-color") || env.NO_COLOR !== undefined;
+    const reasons = [decision.reason];
+    if (noColorRequested && tier !== "no-color") {
+        reasons.push("WARNING: no-color was requested but a color tier was selected");
+    }
+    return {
+        tier,
+        reasons,
+        noColorRequested,
+        noColorHonored: !noColorRequested || tier === "no-color",
+    };
+}

package/dist/cli/ui/green-rain-renderer.js

@@ -1,6 +1,7 @@
 import gradientString from "gradient-string";
 import { System24Renderer } from "./system24-renderer.js";
 import { GREEN_RAIN_THEME, resolveTuiMotion, shouldUseAnsiColor } from "../../brand/theme.js";
+import { BRAND_HEX } from "../../brand/palette.js";
 import { renderMatrixRain } from "../../brand/matrix-rain.js";
 import { renderOmkSparkleText } from "../../ui/omk-sigil.js";
 const ESC = "\x1b[";
@@ -87,9 +88,9 @@ export class GreenRainRenderer {
         line(this.err, renderOmkSparkleText(titleLine, {
             frame: Math.floor(Date.now() / 80),
             noColor: this.noColor,
-            colors: ["#00FFC2", "#f4ffff", "#ffd166", "#00D6FF", "#9D4EDD"],
+            colors: [BRAND_HEX.mint, BRAND_HEX.sparkleWhite, BRAND_HEX.sparkleGold, BRAND_HEX.cyan, BRAND_HEX.purple],
         }), this.noColor);
-        line(this.err, gradientLine(mottoLine, ["#00FFC2", "#00D6FF"], this.noColor), this.noColor);
+        line(this.err, gradientLine(mottoLine, [BRAND_HEX.mint, BRAND_HEX.cyan], this.noColor), this.noColor);
         line(this.err, `${dim}${routeLine}${RST}`, this.noColor);
         line(this.err, `${dim}${rootLine}${RST}`, this.noColor);
     }

package/dist/cli/ui/neon-grid-renderer.js

@@ -1,6 +1,7 @@
 import gradientString from "gradient-string";
 import { System24Renderer } from "./system24-renderer.js";
 import { NEON_GRID_THEME, resolveTuiMotion, shouldUseAnsiColor } from "../../brand/theme.js";
+import { BRAND_HEX } from "../../brand/palette.js";
 import { renderOmkSparkleText } from "../../ui/omk-sigil.js";
 const ESC = "\x1b[";
 const RST = `${ESC}0m`;
@@ -89,11 +90,11 @@ export class NeonGridRenderer {
         line(this.err, renderOmkSparkleText(titleLine, {
             frame: Math.floor(Date.now() / 80),
             noColor: this.noColor,
-            colors: ["#00D6FF", "#f4ffff", "#ffd166", "#FF47B2", "#00FFC2"],
+            colors: [BRAND_HEX.cyan, BRAND_HEX.sparkleWhite, BRAND_HEX.sparkleGold, BRAND_HEX.magenta, BRAND_HEX.mint],
         }), this.noColor);
-        line(this.err, gradientLine(mottoLine, ["#00FFC2", "#00D6FF", "#9D4EDD"], this.noColor), this.noColor);
+        line(this.err, gradientLine(mottoLine, [BRAND_HEX.mint, BRAND_HEX.cyan, BRAND_HEX.purple], this.noColor), this.noColor);
         line(this.err, `${dim}${routeLine}${RST}`, this.noColor);
-        line(this.err, gradientLine(statusLine, ["#00FFC2", "#00D6FF", "#FFB000"], this.noColor), this.noColor);
+        line(this.err, gradientLine(statusLine, [BRAND_HEX.mint, BRAND_HEX.cyan, BRAND_HEX.amber], this.noColor), this.noColor);
         line(this.err, `${dim}${rootLine}${RST}`, this.noColor);
     }
 }

package/dist/cli/ui/rust-forge-renderer.js

@@ -1,5 +1,6 @@
 import { System24Renderer } from "./system24-renderer.js";
 import { RUST_FORGE_THEME, resolveTuiMotion, shouldUseAnsiColor } from "../../brand/theme.js";
+import { BRAND_HEX } from "../../brand/palette.js";
 import { renderOmkSigil, renderOmkSparkleText } from "../../ui/omk-sigil.js";
 const ESC = "\x1b[";
 const RST = `${ESC}0m`;
@@ -19,6 +20,13 @@ function center(text, width) {
     const pad = Math.max(0, Math.floor((width - visibleLength(text)) / 2));
     return `${" ".repeat(pad)}${text}`;
 }
+function forgeGauge(label, value, width) {
+    const clamped = Math.max(0, Math.min(1, value));
+    const barWidth = Math.max(6, Math.min(16, width - label.length - 10));
+    const filled = Math.round(clamped * barWidth);
+    const bar = `${"█".repeat(filled)}${"░".repeat(Math.max(0, barWidth - filled))}`;
+    return truncate(`${label} [${bar}] ${Math.round(clamped * 100)}%`, width);
+}
 function forgeScanline(seed, width) {
     const glyphs = ["═", "─", "■", "▣", "◉", "◆"];
     let hash = 0;
@@ -68,7 +76,7 @@ export class RustForgeRenderer {
         const shouldRenderScanline = this.motion !== "off" && this.started && this.err.isTTY !== false;
         const sigilName = this.resolveSigilName();
         const sigilRows = sigilName !== "none" ? this.sigilHeight(sigilName) : 0;
-        return (shouldRenderScanline ? 1 : 0) + 5 + sigilRows;
+        return (shouldRenderScanline ? 1 : 0) + 7 + sigilRows;
     }
     resolveSigilName() {
         const env = process.env.OMK_SIGIL?.trim().toLowerCase();
@@ -96,8 +104,12 @@ export class RustForgeRenderer {
         const root = event.root ? truncate(event.root, Math.max(12, width - 16)) : "root:unknown";
         const shouldRenderScanline = this.motion !== "off" && this.started && this.err.isTTY !== false;
         const routeLine = truncate(`${RUST_FORGE_THEME.symbols.signal} FORGE ${run} · provider:${event.provider} · model:${event.model ?? "auto"}`, width);
-        const statusLine = truncate(`■ CARGO safety armed · VERIFY native evidence · SCOPE MCP/skills/hooks`, width);
+        const statusLine = truncate(`■ FORGE route armed · VERIFY evidence · SCOPE MCP/skills/hooks`, width);
         const rootLine = truncate(`${RUST_FORGE_THEME.symbols.pending} PENDING root ${root}`, width);
+        const independentLine = truncate("OMK INDEPENDENT CONTROL · adapters are lanes, not authority", width);
+        const heatSeed = (event.runId ?? "rust-forge").split("").reduce((sum, char) => sum + char.charCodeAt(0), 0);
+        const heat = 0.72 + (heatSeed % 19) / 100;
+        const forgeStateLine = truncate(`${forgeGauge("HEAT", heat, Math.floor(width / 2))} · ANVIL locked · QUENCH ready`, width);
         const sigilName = this.resolveSigilName();
         const showSigil = sigilName !== "none";
         const sigilWidth = Math.min(64, Math.max(30, width - 4));
@@ -108,9 +120,11 @@ export class RustForgeRenderer {
         line(this.err, renderOmkSparkleText(center(RUST_FORGE_THEME.label.toUpperCase(), width), {
             frame: sigilFrame,
             noColor: this.noColor,
-            colors: [hot, "#f4ffff", "#ffd166", "#ff7a18", "#ff315d"],
+            colors: [hot, BRAND_HEX.sparkleWhite, BRAND_HEX.sparkleGold, BRAND_HEX.rustEmber, BRAND_HEX.rustCrimson],
         }), this.noColor);
         line(this.err, `${success}${center(truncate(RUST_FORGE_THEME.motto, width), width)}${RST}`, this.noColor);
+        line(this.err, `${hot}${center(independentLine, width)}${RST}`, this.noColor);
+        line(this.err, `${success}${center(forgeStateLine, width)}${RST}`, this.noColor);
         // Render sigil art with animated sweep
         if (showSigil) {
             const sigilLines = renderOmkSigil({