open-multi-agent-kit 0.78.6 → 0.78.7

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({

package/dist/cli/ui/system24-renderer.d.ts

@@ -10,7 +10,7 @@
  *
  * Panels:
  * ┌─ session ──────────────────────────────────────┐
- * │  ◆ OMK · mimo · mimo-v2.5-pro    run#abc123   │
+ * │  ◆ OMK · mimo · mimo-v2.5-pro    run id ab12  │
  * └────────────────────────────────────────────────┘
  * ┌─ turn ─────────────────────────────────────────┐
  * │  ▸ user input                                   │
@@ -26,12 +26,29 @@
 import type { CliUiEvent } from "./event.js";
 import type { CliRenderer } from "./renderer.js";
 import type { OmkBrandTheme } from "../../brand/theme.js";
+interface System24Palette {
+    bg3: string;
+    text1: string;
+    text2: string;
+    text3: string;
+    text5: string;
+    accent: string;
+    green: string;
+    amber: string;
+    red: string;
+    cyan: string;
+    border: string;
+    borderHL: string;
+}
 interface WritableStreamLike {
     write(chunk: string): unknown;
     isTTY?: boolean;
     columns?: number;
     rows?: number;
 }
+export declare function visibleLenForTest(s: string): number;
+export declare function renderPanelLineForTest(c: System24Palette, content: string, width: number): string;
+export declare function renderInlineForTest(c: System24Palette, text: string): string;
 export interface System24RendererStreams {
     stdout?: WritableStreamLike;
     stderr?: WritableStreamLike;

package/dist/cli/ui/system24-renderer.js

@@ -31,6 +31,15 @@ const BORDER_BL = "└";
 const BORDER_BR = "┘";
 const BORDER_ML = "├";
 const BORDER_MR = "┤";
+// ── Hoisted regex constants (avoid per-call compilation) ───────────────────
+const RE_HEADER = /^(#{1,3})\s+(.+)$/;
+const RE_LIST_ITEM = /^(\s*)[-*]\s+(.+)$/;
+const RE_HR = /^[-*_]{3,}$/;
+const RE_BOLD_STAR = /\*\*(.+?)\*\*/g;
+const RE_BOLD_UNDER = /__(.+?)__/g;
+const RE_ITALIC = /(?<!\w)\*(.+?)\*(?!\w)/g;
+const RE_INLINE_CODE = /`([^`]+)`/g;
+const RE_LINK = /\[([^\]]+)\]\([^)]+\)/g;
 function termWidth(stream) {
     const width = stream.columns ?? process.stdout.columns ?? 80;
     return Number.isFinite(width) ? Math.max(40, width) : 80;
@@ -48,6 +57,9 @@ function countRows(chunk) {
 function stripAnsi(s) {
     return s.replace(/\x1b\[[0-9;]*m/g, "");
 }
+export function visibleLenForTest(s) {
+    return stripAnsi(s).length;
+}
 function visibleLen(s) {
     return stripAnsi(s).length;
 }
@@ -92,12 +104,24 @@ function renderPanelDivider(c, width, label) {
     }
     return c.border + BORDER_ML + SEP_CHAR.repeat(inner) + BORDER_MR + RST;
 }
+export function renderPanelLineForTest(c, content, width) {
+    return renderPanelLine(c, content, width);
+}
 function renderPanelLine(c, content, width) {
     const inner = width - 2;
-    const safeContent = visibleLen(content) > inner
-        ? `${stripAnsi(content).slice(0, Math.max(0, inner - 1))}…`
-        : content;
-    const padded = padRight(safeContent, inner);
+    const plain = stripAnsi(content);
+    const vLen = plain.length;
+    let safeContent;
+    let safeVLen;
+    if (vLen > inner) {
+        safeContent = plain.slice(0, Math.max(0, inner - 1)) + "…";
+        safeVLen = inner; // inner-1 chars + "…" (1 wide) = inner
+    }
+    else {
+        safeContent = content;
+        safeVLen = vLen;
+    }
+    const padded = safeVLen < inner ? safeContent + " ".repeat(inner - safeVLen) : safeContent;
     return c.border + BORDER_V + RST + padded + c.border + BORDER_V + RST;
 }
 // ── Code Block Rendering ───────────────────────────────────────────────────
@@ -119,16 +143,15 @@ function renderCodeBlock(c, codeLines, lang, width) {
     return result;
 }
 // ── Inline Markdown (system24 style) ───────────────────────────────────────
+export function renderInlineForTest(c, text) {
+    return renderInline(c, text);
+}
 function renderInline(c, text) {
-    // Bold
-    let s = text.replace(/\*\*(.+?)\*\*/g, (_, m) => BOLD + c.text1 + m + RST);
-    s = s.replace(/__(.+?)__/g, (_, m) => BOLD + c.text1 + m + RST);
-    // Italic
-    s = s.replace(/(?<!\w)\*(.+?)\*(?!\w)/g, (_, m) => ITALIC + c.text3 + m + RST);
-    // Inline code
-    s = s.replace(/`([^`]+)`/g, (_, m) => c.bg3 + c.text1 + " " + m + " " + RST);
-    // Links
-    s = s.replace(/\[([^\]]+)\]\([^)]+\)/g, (_, m) => c.cyan + m + RST);
+    let s = text.replace(RE_BOLD_STAR, (_, m) => BOLD + c.text1 + m + RST);
+    s = s.replace(RE_BOLD_UNDER, (_, m) => BOLD + c.text1 + m + RST);
+    s = s.replace(RE_ITALIC, (_, m) => ITALIC + c.text3 + m + RST);
+    s = s.replace(RE_INLINE_CODE, (_, m) => c.bg3 + c.text1 + " " + m + " " + RST);
+    s = s.replace(RE_LINK, (_, m) => c.cyan + m + RST);
     return s;
 }
 // ── Thinking Animation ─────────────────────────────────────────────────────
@@ -368,7 +391,7 @@ export class System24Renderer {
                         continue;
                     }
                     // Headers
-                    const hMatch = line.match(/^(#{1,3})\s+(.+)$/);
+                    const hMatch = line.match(RE_HEADER);
                     if (hMatch) {
                         const level = hMatch[1].length;
                         const text = hMatch[2];
@@ -381,13 +404,13 @@ export class System24Renderer {
                         continue;
                     }
                     // List items
-                    const lMatch = line.match(/^(\s*)[-*]\s+(.+)$/);
+                    const lMatch = line.match(RE_LIST_ITEM);
                     if (lMatch) {
                         this.writeOut(renderPanelLine(c, "  " + c.accent + "◆" + RST + " " + renderInline(c, lMatch[2]), w) + "\n");
                         continue;
                     }
                     // Horizontal rule
-                    if (/^[-*_]{3,}$/.test(line.trim())) {
+                    if (RE_HR.test(line.trim())) {
                         this.writeOut(renderPanelLine(c, "  " + c.text5 + SEP_CHAR.repeat(Math.min(w - 6, 40)) + RST, w) + "\n");
                         continue;
                     }

package/dist/cli/v2/chat-repl.js

@@ -112,7 +112,9 @@ export async function startChatRepl(options) {
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
-        prompt: options.json ? "omk> " : "\x1b[36momk>\x1b[0m ",
+        // ANSI-16 cyan (conceptually night-city route.active) assembled from a CSI
+        // prefix so color:gate stays literal-free; the rendered bytes are unchanged.
+        prompt: options.json ? "omk> " : `${"\x1b["}36momk>${"\x1b["}0m `,
         completer: (line) => {
             const trimmed = line.trim();
             if (/^\/(?:model|m)(?:\s|$)/.test(trimmed) || (trimmed.length === 0 && replState.activeProviderTab)) {

package/dist/cli/v2/cli-v2-skeleton.d.ts

@@ -68,6 +68,9 @@ export declare class ModelCommand extends OmkCommand {
 export declare class DoctorCommand extends OmkCommand {
     static paths: string[][];
     static usage: import("clipanion").Usage;
+    noColor: boolean;
+    /** Color-tier / theme / NO_COLOR diagnostic section (theme contract T5a). */
+    private writeColorThemeSection;
     execute(): Promise<number>;
 }
 /**
@@ -86,6 +89,9 @@ export declare class ThemeCommand extends OmkCommand {
     static paths: string[][];
     static usage: import("clipanion").Usage;
     nameArgs: string[];
+    noColor: boolean;
+    /** Detect the degradation tier, honoring the command's --no-color flag. */
+    private detectTier;
     execute(): Promise<number>;
 }
 /**

package/dist/cli/v2/cli-v2-skeleton.js

@@ -16,6 +16,8 @@ import { registerSlashCommands } from "../../runtime/slash-commands.js";
 import { registerProviderCommandsV2 } from "./provider-commands.js";
 import { registerWorkflowCommandsV2 } from "./workflow-commands.js";
 import { DEFAULT_AUTHORITY_PROVIDER } from "../../providers/types.js";
+import { getOmkVersionSync } from "../../util/version.js";
+import { OMK_RUNTIME_VERSION } from "../../version.js";
 /**
  * Base class for all OMK v2 commands.
  * Provides common pipeline execution helpers.
@@ -201,7 +203,47 @@ export class DoctorCommand extends OmkCommand {
     static usage = Command.Usage({
         description: "Run OMK health checks",
     });
+    noColor = Option.Boolean("--no-color", false, { description: "Disable color output (NO_COLOR equivalent)" });
+    /** Color-tier / theme / NO_COLOR diagnostic section (theme contract T5a). */
+    async writeColorThemeSection() {
+        const { explainColorTier } = await import("../theme/tier-explain.js");
+        const { resolveTheme } = await import("../theme/theme-resolver.js");
+        const { loadThemeDocument, validateThemeDocument } = await import("../theme/theme-doc.js");
+        const argv = this.noColor ? ["--no-color"] : [];
+        const explanation = explainColorTier(argv);
+        const active = resolveTheme({ cwd: this.cwd, flagTheme: this.theme || undefined });
+        const doc = loadThemeDocument(active.name, this.cwd);
+        const schemaStatus = doc === undefined
+            ? "builtin palette (no omk.theme.v1 document)"
+            : (() => {
+                const errors = validateThemeDocument(doc);
+                return errors.length === 0 ? "omk.theme.v1 document: valid" : `omk.theme.v1 document: INVALID (${errors.length} error(s): ${errors[0]})`;
+            })();
+        if (this.json) {
+            this.context.stdout.write(JSON.stringify({
+                section: "color-theme",
+                tier: explanation.tier,
+                reasons: explanation.reasons,
+                noColorRequested: explanation.noColorRequested,
+                noColorHonored: explanation.noColorHonored,
+                activeTheme: active.name,
+                themeMode: active.mode,
+                schema: schemaStatus,
+            }) + "\n");
+            return;
+        }
+        this.context.stdout.write([
+            "Color tier & theme",
+            `  detected tier : ${explanation.tier}`,
+            `  why           : ${explanation.reasons.join("; ")}`,
+            `  NO_COLOR      : requested=${explanation.noColorRequested ? "yes" : "no"} honored=${explanation.noColorHonored ? "yes" : "no"}`,
+            `  active theme  : ${active.name} (mode ${active.mode})`,
+            `  theme schema  : ${schemaStatus}`,
+            "",
+        ].join("\n"));
+    }
     async execute() {
+        await this.writeColorThemeSection();
         return this.executePipeline("run health checks", "doctor");
     }
 }
@@ -265,36 +307,105 @@ export class ThemeCommand extends OmkCommand {
         ],
     });
     nameArgs = Option.Rest({ required: 0 });
+    noColor = Option.Boolean("--no-color", false, { description: "Disable color output (NO_COLOR equivalent)" });
+    /** Detect the degradation tier, honoring the command's --no-color flag. */
+    async detectTier() {
+        const { detectColorTier } = await import("../theme/terminal-capability.js");
+        return detectColorTier(this.noColor ? ["--no-color"] : []);
+    }
     async execute() {
         const name = this.nameArgs.join(" ").trim();
         const subcommand = this.nameArgs[0] ?? "";
         const target = this.nameArgs.slice(1).join(" ").trim();
-        // omk theme list — show all themes with color swatches
+        // omk theme list — active theme + omk.theme.v1 documents + builtin swatches
         if (subcommand === "list") {
             const { renderAllThemePreviews, getBuiltinTheme } = await import("../theme/theme-registry.js");
-            const current = process.env.OMK_THEME ?? "omk";
-            const currentPalette = getBuiltinTheme(current) ?? getBuiltinTheme("omk");
-            this.context.stdout.write((currentPalette?.render("header", `Current theme: ${current}`) ?? `Current theme: ${current}`) + "\n\n");
+            const { resolveTheme } = await import("../theme/theme-resolver.js");
+            const { listThemeDocuments, loadThemeDocument, validateThemeDocument } = await import("../theme/theme-doc.js");
+            const active = resolveTheme({ cwd: this.cwd, flagTheme: this.theme || undefined });
+            const tier = await this.detectTier();
+            const currentPalette = getBuiltinTheme(active.name) ?? getBuiltinTheme("omk");
+            this.context.stdout.write((currentPalette?.render("header", `Active theme: ${active.name}`) ?? `Active theme: ${active.name}`)
+                + ` (mode ${active.mode}, tier ${tier})\n\n`);
+            const docs = listThemeDocuments(this.cwd);
+            if (docs.length > 0) {
+                this.context.stdout.write("Theme documents (omk.theme.v1):\n");
+                for (const ref of docs) {
+                    const doc = loadThemeDocument(ref.name, this.cwd);
+                    const valid = doc !== undefined && validateThemeDocument(doc).length === 0;
+                    const marker = ref.name === active.name ? "●" : "○";
+                    this.context.stdout.write(`  ${marker} ${ref.name} — ${ref.path} (${valid ? "valid" : "INVALID"})\n`);
+                }
+                this.context.stdout.write("\n");
+            }
+            this.context.stdout.write("Built-in palettes:\n");
             this.context.stdout.write(renderAllThemePreviews() + "\n");
             return 0;
         }
-        // omk theme preview <name> — show color swatch without switching
+        // omk theme set <name> — validate + persist choice to project config
+        if (subcommand === "set") {
+            if (!target) {
+                this.context.stderr.write("Usage: omk theme set <name>\n");
+                return 2;
+            }
+            const { getBuiltinTheme, listBuiltinThemes } = await import("../theme/theme-registry.js");
+            const { listThemeDocuments } = await import("../theme/theme-doc.js");
+            const docNames = listThemeDocuments(this.cwd).map((r) => r.name);
+            const known = getBuiltinTheme(target) !== undefined || docNames.includes(target);
+            if (!known) {
+                this.context.stderr.write(`Unknown theme: ${target}\n`);
+                this.context.stderr.write(`Available: ${[...new Set([...docNames, ...listBuiltinThemes()])].join(", ")}\n`);
+                return 2;
+            }
+            const { readFile, writeFile } = await import("node:fs/promises");
+            const { resolve } = await import("node:path");
+            const cfgPath = resolve(this.cwd, ".omkrc.json");
+            let existing = {};
+            try {
+                existing = JSON.parse(await readFile(cfgPath, "utf8"));
+            }
+            catch {
+                existing = {};
+            }
+            const next = { ...existing, theme: target };
+            await writeFile(cfgPath, JSON.stringify(next, null, 2) + "\n");
+            process.env.OMK_THEME = target;
+            this.context.stdout.write(`Theme set to: ${target} (persisted to ${cfgPath})\n`);
+            return 0;
+        }
+        // omk theme preview <name> — representative status frame at detected tier
+        // (same frame as test/theme-degradation.test.mjs) for omk.theme.v1 docs;
+        // falls back to the builtin palette swatch for registry-only themes.
         if (subcommand === "preview") {
             if (!target) {
                 this.context.stderr.write("Usage: omk theme preview <name>\n");
                 return 2;
             }
+            const { loadThemeDocument, listThemeDocuments } = await import("../theme/theme-doc.js");
+            const doc = loadThemeDocument(target, this.cwd);
+            if (doc !== undefined) {
+                const { compileTheme } = await import("../theme/render-table.js");
+                const { renderStatusFrame } = await import("../theme/status-frame.js");
+                const tier = await this.detectTier();
+                const compiled = compileTheme(doc, tier);
+                this.context.stdout.write(`${doc.displayName ?? doc.name} — tier ${tier}\n\n`);
+                this.context.stdout.write(renderStatusFrame(compiled) + "\n");
+                const current = process.env.OMK_THEME ?? "omk";
+                this.context.stdout.write(`\nCurrent theme: ${current}. Use \`omk theme set ${target}\` to switch.\n`);
+                return 0;
+            }
             const { renderThemePreview, getBuiltinTheme, listBuiltinThemes } = await import("../theme/theme-registry.js");
             const palette = getBuiltinTheme(target);
             if (!palette) {
-                const available = listBuiltinThemes().join(", ");
+                const docNames = listThemeDocuments(this.cwd).map((r) => r.name);
+                const available = [...new Set([...docNames, ...listBuiltinThemes()])].join(", ");
                 this.context.stderr.write(`Unknown theme: ${target}\n`);
                 this.context.stderr.write(`Available: ${available}\n`);
                 return 2;
             }
             this.context.stdout.write(renderThemePreview(palette) + "\n");
             const current = process.env.OMK_THEME ?? "omk";
-            this.context.stdout.write(`\nCurrent theme: ${current}. Use \`omk theme ${target}\` to switch.\n`);
+            this.context.stdout.write(`\nCurrent theme: ${current}. Use \`omk theme set ${target}\` to switch.\n`);
             return 0;
         }
         // omk theme <name> — set theme
@@ -321,10 +432,11 @@ export class ThemeCommand extends OmkCommand {
  * Register all v2 commands on a Clipanion CLI instance.
  */
 export function createCliV2() {
+    const packageVersion = getOmkVersionSync();
     const cli = new Cli({
-        binaryLabel: "OMK CLI",
+        binaryLabel: "OMK root orchestrator",
         binaryName: "omk",
-        binaryVersion: "1.1.18",
+        binaryVersion: `${packageVersion} (${OMK_RUNTIME_VERSION})`,
     });
     cli.register(ChatCommand);
     cli.register(RunCommand);

package/dist/cli/v2/interactive-prompt.d.ts

@@ -47,5 +47,6 @@ export declare function withSpinner<T>(message: string, fn: () => Promise<T>): P
 /**
  * Intro/outro for OMK session.
  */
+export declare function formatOmkIntroTitle(version: string): string;
 export declare function omkIntro(version: string): void;
 export declare function omkOutro(message: string): void;