open-multi-agent-kit 0.78.0

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

@@ -0,0 +1,99 @@
+import gradientString from "gradient-string";
+import { System24Renderer } from "./system24-renderer.js";
+import { NEON_GRID_THEME, resolveTuiMotion, shouldUseAnsiColor } from "../../brand/theme.js";
+import { renderOmkSparkleText } from "../../ui/omk-sigil.js";
+const ESC = "\x1b[";
+const RST = `${ESC}0m`;
+function stripAnsi(value) {
+    return value.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function visibleLength(value) {
+    return stripAnsi(value).length;
+}
+function line(stream, text, noColor) {
+    stream.write(`${noColor ? stripAnsi(text) : text}\n`);
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, Math.max(0, max - 1))}…` : value;
+}
+function center(text, width) {
+    const pad = Math.max(0, Math.floor((width - visibleLength(text)) / 2));
+    return `${" ".repeat(pad)}${text}`;
+}
+function signalScanline(seed, width) {
+    const glyphs = ["◇", "◆", "●", "○", "▣", "⟁", "⟐", "⟡"];
+    let hash = 0;
+    for (const char of seed)
+        hash = (hash * 33 + char.charCodeAt(0)) >>> 0;
+    const chars = [];
+    for (let i = 0; i < width; i += 1) {
+        hash = (hash * 1664525 + 1013904223) >>> 0;
+        chars.push(hash % 7 === 0 ? glyphs[hash % glyphs.length] : hash % 5 === 0 ? "─" : " ");
+    }
+    return chars.join("").trimEnd();
+}
+function gradientLine(text, colors, noColor) {
+    return noColor ? text : gradientString(colors).multiline(text);
+}
+export class NeonGridRenderer {
+    base;
+    err;
+    noColor;
+    motion;
+    started = false;
+    constructor(streams = {}) {
+        this.err = streams.stderr ?? process.stderr;
+        this.noColor = !shouldUseAnsiColor();
+        this.motion = resolveTuiMotion();
+        this.base = new System24Renderer(streams, NEON_GRID_THEME, {
+            sessionHeader: "compact",
+            noColor: this.noColor,
+            terminalControls: true,
+        });
+    }
+    start() {
+        this.started = true;
+        this.base.start();
+    }
+    emit(event) {
+        if (event.type === "session:start") {
+            this.base.setStickyHeaderPrefixRows(this.neonGridHeaderRows());
+            this.renderNeonGridHeader(event);
+        }
+        this.base.emit(event);
+    }
+    setThinkingSummary(summary) {
+        this.base.setThinkingSummary(summary);
+    }
+    stop() {
+        this.base.stop();
+    }
+    neonGridHeaderRows() {
+        const shouldRenderScanline = this.motion !== "off" && this.started && this.err.isTTY !== false;
+        return (shouldRenderScanline ? 1 : 0) + 5;
+    }
+    renderNeonGridHeader(event) {
+        const width = Math.min(76, Math.max(40, this.err.columns ?? process.stderr.columns ?? 80) - 2);
+        const dim = NEON_GRID_THEME.colors.muted;
+        const run = event.runId ? `run#${event.runId.slice(0, 7)}` : "run#pending";
+        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 titleLine = center("◢█ OMK//CONTROL █◣", width);
+        const mottoLine = center(truncate(NEON_GRID_THEME.motto, width), width);
+        const routeLine = truncate(`${NEON_GRID_THEME.symbols.signal} ROUTE ${run} · provider:${event.provider} · model:${event.model ?? "auto"}`, width);
+        const statusLine = truncate(`▣ NEON metrics live · VERIFY armed · SCOPE MCP/skills/hooks · LOOP controlled`, width);
+        const rootLine = truncate(`${NEON_GRID_THEME.symbols.pending} PENDING root ${root}`, width);
+        if (shouldRenderScanline) {
+            line(this.err, `${dim}${signalScanline(event.runId ?? "omk-control", width)}${RST}`, this.noColor);
+        }
+        line(this.err, renderOmkSparkleText(titleLine, {
+            frame: Math.floor(Date.now() / 80),
+            noColor: this.noColor,
+            colors: ["#00D6FF", "#f4ffff", "#ffd166", "#FF47B2", "#00FFC2"],
+        }), this.noColor);
+        line(this.err, gradientLine(mottoLine, ["#00FFC2", "#00D6FF", "#9D4EDD"], 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, `${dim}${rootLine}${RST}`, this.noColor);
+    }
+}

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

@@ -0,0 +1,37 @@
+/**
+ * PlainModernRenderer — opencode-style minimal CLI output.
+ *
+ * Pattern: `> provider · model` header + clean output.
+ * No route cards, no box drawing, no verbose banners.
+ */
+import type { CliUiEvent } from "./event.js";
+import type { CliRenderer } from "./renderer.js";
+interface WritableStreamLike {
+    write(chunk: string): unknown;
+    isTTY?: boolean;
+    rows?: number;
+}
+export interface PlainRendererStreams {
+    stdout?: WritableStreamLike;
+    stderr?: WritableStreamLike;
+}
+export declare function renderRouteCard(event: Extract<CliUiEvent, {
+    type: "turn:route";
+}>): string;
+export declare function renderAssistantCard(text: string): string;
+export declare class PlainModernRenderer implements CliRenderer {
+    private readonly stdout;
+    private readonly stderr;
+    private heartbeatOpen;
+    private promptOpen;
+    private alternateScreenActive;
+    private stickyScrollRegionActive;
+    constructor(streams?: PlainRendererStreams);
+    start(): void;
+    emit(event: CliUiEvent): void;
+    setThinkingSummary(_summary: string | undefined): void;
+    private writeStderrControl;
+    private activateStickyScrollRegion;
+    stop(): void;
+}
+export {};

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

@@ -0,0 +1,160 @@
+import { sanitizeUserVisibleOutput } from "../../util/user-visible-output.js";
+import { isUnsupportedRuntimeError, renderRouteBlockedPanel } from "./route-blocked-panel.js";
+const ESC = "\x1b[";
+function ensureTrailingNewline(text) {
+    return text.endsWith("\n") ? text : `${text}\n`;
+}
+function termRows(stream) {
+    const rows = stream.rows ?? process.stderr.rows ?? 24;
+    return Number.isFinite(rows) ? Math.max(10, rows) : 24;
+}
+function shouldUseTerminalControls(stream) {
+    return stream.isTTY === true && process.env.TERM !== "dumb";
+}
+function countRows(chunk) {
+    return (chunk.match(/\n/g) ?? []).length;
+}
+function joinList(values) {
+    return values && values.length > 0 ? values.join(", ") : "none";
+}
+export function renderRouteCard(event) {
+    const lines = [
+        "◇ Route",
+        `provider  ${event.provider}`,
+        `model     ${event.model ?? "auto"}`,
+        `risk      ${event.risk}`,
+        `sandbox   ${event.sandbox}`,
+        `mcp       ${joinList(event.mcp)}`,
+        `skills    ${joinList(event.skills)}`,
+        `hooks     ${joinList(event.hooks)}`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+export function renderAssistantCard(text) {
+    return `\n● Assistant\n${ensureTrailingNewline(sanitizeUserVisibleOutput(text))}`;
+}
+export class PlainModernRenderer {
+    stdout;
+    stderr;
+    heartbeatOpen = false;
+    promptOpen = false;
+    alternateScreenActive = false;
+    stickyScrollRegionActive = false;
+    constructor(streams = {}) {
+        this.stdout = streams.stdout ?? process.stdout;
+        this.stderr = streams.stderr ?? process.stderr;
+    }
+    start() {
+        this.stickyScrollRegionActive = false;
+        this.alternateScreenActive = shouldUseTerminalControls(this.stderr);
+        if (this.alternateScreenActive) {
+            this.writeStderrControl(`${ESC}?1049h${ESC}2J${ESC}H`);
+        }
+    }
+    emit(event) {
+        switch (event.type) {
+            case "session:start": {
+                const provider = event.provider === "auto" ? "omk" : event.provider;
+                const model = event.model ?? "auto";
+                const header = `\nOMK Agent Console\n> ${provider} · ${model}\n\n`;
+                this.stderr.write(header);
+                this.activateStickyScrollRegion(countRows(header));
+                break;
+            }
+            case "input:submitted":
+                if (this.promptOpen) {
+                    if (!this.stderr.isTTY)
+                        this.stderr.write(event.text);
+                    this.stderr.write("\n\n");
+                    this.promptOpen = false;
+                }
+                else {
+                    this.stderr.write(`› ${event.text}\n\n`);
+                }
+                break;
+            case "prompt:ready":
+                if (!this.promptOpen) {
+                    this.stderr.write("› ");
+                    this.promptOpen = true;
+                }
+                break;
+            case "control:output":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\n");
+                    this.heartbeatOpen = false;
+                }
+                this.stderr.write(sanitizeUserVisibleOutput(event.text));
+                break;
+            case "turn:route":
+                this.stderr.write(renderRouteCard(event));
+                break;
+            case "turn:heartbeat": {
+                const seconds = Math.floor(event.elapsedMs / 1000);
+                const activity = event.activity ?? `routing ${event.provider ?? "auto"} turn`;
+                const truncated = activity.length > 72 ? activity.slice(0, 69) + "..." : activity;
+                const line = `◌ ${truncated} · ${seconds}s`;
+                if (this.stderr.isTTY) {
+                    this.stderr.write(`\r${line}   `);
+                    this.heartbeatOpen = true;
+                }
+                else {
+                    this.stderr.write(`${line}\n`);
+                }
+                break;
+            }
+            case "assistant:final":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r                    \r");
+                    this.heartbeatOpen = false;
+                }
+                this.stdout.write(renderAssistantCard(event.text));
+                break;
+            case "turn:error":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r                    \r");
+                    this.heartbeatOpen = false;
+                }
+                {
+                    const errMsg = sanitizeUserVisibleOutput(event.message);
+                    const rendered = isUnsupportedRuntimeError(errMsg)
+                        ? renderRouteBlockedPanel(errMsg)
+                        : `  ✖ ${errMsg}`;
+                    this.stderr.write(`\n${rendered}\n\n`);
+                }
+                break;
+            case "turn:finish":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r                    \r");
+                    this.heartbeatOpen = false;
+                }
+                this.stderr.write(`● Finished ${(event.durationMs / 1000).toFixed(1)}s · exit ${event.exitCode}\n`);
+                break;
+            case "turn:start":
+                break;
+            case "session:stop":
+                // opencode shows nothing on session end
+                break;
+        }
+    }
+    setThinkingSummary(_summary) { }
+    writeStderrControl(chunk) {
+        this.stderr.write(chunk);
+    }
+    activateStickyScrollRegion(headerRows) {
+        if (!this.alternateScreenActive || this.stickyScrollRegionActive)
+            return;
+        const rows = termRows(this.stderr);
+        const top = Math.min(rows - 1, Math.max(2, headerRows + 1));
+        if (top >= rows)
+            return;
+        this.writeStderrControl(`${ESC}${top};${rows}r${ESC}${top};1H`);
+        this.stickyScrollRegionActive = true;
+    }
+    stop() {
+        if (this.alternateScreenActive) {
+            this.writeStderrControl(`${ESC}r${ESC}?1049l`);
+            this.alternateScreenActive = false;
+            this.stickyScrollRegionActive = false;
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { CliUiEvent } from "./event.js";
+export interface CliRenderer {
+    start(): Promise<void> | void;
+    emit(event: CliUiEvent): void;
+    setThinkingSummary?(summary: string | undefined): void;
+    stop(): Promise<void> | void;
+}

package/dist/cli/ui/renderer.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,32 @@
+/**
+ * RichRenderer — theme-integrated CLI output with markdown rendering.
+ *
+ * Uses OMK theme primitives (style, layout) for visual richness.
+ * Renders inline markdown: **bold**, `code`, ```code blocks```, # headers, - lists.
+ * Shows thinking/reasoning frames with visual indicators.
+ */
+import type { CliUiEvent } from "./event.js";
+import type { CliRenderer } from "./renderer.js";
+interface WritableStreamLike {
+    write(chunk: string): unknown;
+    isTTY?: boolean;
+}
+export interface RichRendererStreams {
+    stdout?: WritableStreamLike;
+    stderr?: WritableStreamLike;
+}
+export declare class RichRenderer implements CliRenderer {
+    private readonly stdout;
+    private readonly stderr;
+    private heartbeatOpen;
+    private promptOpen;
+    private thinkingSummary;
+    private sessionStartTime;
+    constructor(streams?: RichRendererStreams);
+    start(): void;
+    emit(event: CliUiEvent): void;
+    /** Update thinking summary from reasoning NLP (called externally) */
+    setThinkingSummary(summary: string | undefined): void;
+    stop(): void;
+}
+export {};

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

@@ -0,0 +1,234 @@
+import { sanitizeUserVisibleOutput } from "../../util/user-visible-output.js";
+import { style } from "../../theme/colors.js";
+import { isUnsupportedRuntimeError, renderRouteBlockedPanel } from "./route-blocked-panel.js";
+// ── Inline Markdown Renderer ──────────────────────────────────────────────
+const RE_CODE_BLOCK = /^```(\w*)$/;
+const RE_HEADER = /^(#{1,3})\s+(.+)$/;
+const RE_LIST_ITEM = /^(\s*)[-*]\s+(.+)$/;
+const RE_NUMBERED_LIST = /^(\s*)\d+\.\s+(.+)$/;
+function renderInlineMarkdown(text) {
+    // Bold: **text** or __text__
+    let s = text.replace(/\*\*(.+?)\*\*/g, (_, m) => style.whiteBold(m));
+    s = s.replace(/__(.+?)__/g, (_, m) => style.whiteBold(m));
+    // Italic: *text* or _text_ (but not inside words with underscores)
+    s = s.replace(/(?<!\w)\*(.+?)\*(?!\w)/g, (_, m) => style.cream(style.italic + m + style.reset));
+    // Inline code: `text`
+    s = s.replace(/`([^`]+)`/g, (_, m) => style.bgDark(" " + m + " "));
+    // Links: [text](url) → just show text
+    s = s.replace(/\[([^\]]+)\]\([^)]+\)/g, (_, m) => style.cyan(m));
+    return s;
+}
+function renderMarkdownBlock(lines) {
+    const output = [];
+    let inCodeBlock = false;
+    let codeLang = "";
+    let codeLines = [];
+    for (const line of lines) {
+        // Code block toggle
+        const cbMatch = line.match(RE_CODE_BLOCK);
+        if (cbMatch) {
+            if (inCodeBlock) {
+                // End code block
+                output.push(renderCodeBlock(codeLines, codeLang));
+                codeLines = [];
+                codeLang = "";
+                inCodeBlock = false;
+            }
+            else {
+                inCodeBlock = true;
+                codeLang = cbMatch[1];
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            codeLines.push(line);
+            continue;
+        }
+        // Headers
+        const hMatch = line.match(RE_HEADER);
+        if (hMatch) {
+            const level = hMatch[1].length;
+            const text = hMatch[2];
+            if (level === 1)
+                output.push(style.purpleBold("▋ " + text));
+            else if (level === 2)
+                output.push(style.mintBold("▸ " + text));
+            else
+                output.push(style.cyanBold("  · " + text));
+            continue;
+        }
+        // List items
+        const lMatch = line.match(RE_LIST_ITEM) || line.match(RE_NUMBERED_LIST);
+        if (lMatch) {
+            const indent = lMatch[1];
+            const text = lMatch[2];
+            output.push(indent + style.purple("◆") + " " + renderInlineMarkdown(text));
+            continue;
+        }
+        // Horizontal rule
+        if (/^[-*_]{3,}$/.test(line.trim())) {
+            output.push(style.gray("─".repeat(40)));
+            continue;
+        }
+        // Empty line
+        if (line.trim() === "") {
+            output.push("");
+            continue;
+        }
+        // Regular text with inline markdown
+        output.push(renderInlineMarkdown(line));
+    }
+    // Unclosed code block
+    if (inCodeBlock && codeLines.length > 0) {
+        output.push(renderCodeBlock(codeLines, codeLang));
+    }
+    return output.join("\n");
+}
+function renderCodeBlock(codeLines, lang) {
+    const maxLen = Math.max(...codeLines.map((l) => l.length), lang.length + 4);
+    const width = Math.min(maxLen + 2, 76);
+    const top = style.gray("┌" + "─".repeat(width) + "┐");
+    const bottom = style.gray("└" + "─".repeat(width) + "┘");
+    const langLabel = lang ? style.mint(" " + lang + " ") : "";
+    const body = codeLines.map((l) => style.gray("│") + style.cream(" " + l.padEnd(width - 1)) + style.gray("│"));
+    return [langLabel ? top.replace("─".repeat(width), "─".repeat(2) + langLabel + "─".repeat(Math.max(0, width - 2 - stripAnsiLen(langLabel)))) : top, ...body, bottom].join("\n");
+}
+function stripAnsiLen(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+// ── Thinking/Reasoning Display ─────────────────────────────────────────────
+const THINK_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+let thinkFrameIdx = 0;
+function renderThinkingLine(summary, elapsedMs, activity) {
+    const spinner = THINK_FRAMES[thinkFrameIdx++ % THINK_FRAMES.length];
+    const seconds = Math.floor(elapsedMs / 1000);
+    const time = style.phosphorDim(`${seconds}s`);
+    if (summary) {
+        const truncated = summary.length > 60 ? summary.slice(0, 57) + "..." : summary;
+        return `  ${style.purple(spinner)} ${style.gray(truncated)} ${time}`;
+    }
+    const active = activity ?? "routing turn · evidence gate armed";
+    const truncated = active.length > 60 ? active.slice(0, 57) + "..." : active;
+    return `  ${style.purple(spinner)} ${style.phosphorDim(truncated)} ${time}`;
+}
+// ── RichRenderer ───────────────────────────────────────────────────────────
+export class RichRenderer {
+    stdout;
+    stderr;
+    heartbeatOpen = false;
+    promptOpen = false;
+    thinkingSummary;
+    sessionStartTime = 0;
+    constructor(streams = {}) {
+        this.stdout = streams.stdout ?? process.stdout;
+        this.stderr = streams.stderr ?? process.stderr;
+    }
+    start() {
+        this.sessionStartTime = Date.now();
+    }
+    emit(event) {
+        switch (event.type) {
+            case "session:start": {
+                const provider = event.provider === "auto" ? "omk" : event.provider;
+                const model = event.model ?? "auto";
+                this.stderr.write("\n");
+                this.stderr.write(style.purpleBold("  ◆ ") + style.whiteBold(provider) + style.gray(" · ") + style.cream(model) + "\n");
+                this.stderr.write(style.gray("  " + "─".repeat(Math.min(provider.length + model.length + 5, 40))) + "\n\n");
+                break;
+            }
+            case "input:submitted": {
+                const text = event.text.length > 80 ? event.text.slice(0, 77) + "..." : event.text;
+                if (this.promptOpen) {
+                    if (!this.stderr.isTTY)
+                        this.stderr.write(style.cream(text));
+                    this.stderr.write("\n\n");
+                    this.promptOpen = false;
+                }
+                else {
+                    this.stderr.write(style.mint("  › ") + style.cream(text) + "\n\n");
+                }
+                break;
+            }
+            case "prompt:ready":
+                if (!this.promptOpen) {
+                    this.stderr.write(style.mint("  › "));
+                    this.promptOpen = true;
+                }
+                break;
+            case "control:output":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r" + " ".repeat(80) + "\r");
+                    this.heartbeatOpen = false;
+                }
+                this.stderr.write(sanitizeUserVisibleOutput(event.text));
+                break;
+            case "turn:route": {
+                // Compact route info bar
+                const parts = [];
+                parts.push(style.phosphorDim("⚙ ") + style.white(event.provider));
+                if (event.model)
+                    parts.push(style.gray(event.model));
+                if (event.risk !== "safe")
+                    parts.push(style.amber(event.risk));
+                if (event.sandbox !== "none")
+                    parts.push(style.mint(event.sandbox));
+                if (event.mcp && event.mcp.length > 0)
+                    parts.push(style.cyan(`${event.mcp.length} mcp`));
+                if (event.skills && event.skills.length > 0)
+                    parts.push(style.violet(`${event.skills.length} skills`));
+                this.stderr.write("  " + parts.join(style.gray(" · ")) + "\n");
+                break;
+            }
+            case "turn:start":
+                this.thinkingSummary = undefined;
+                break;
+            case "turn:heartbeat": {
+                const line = renderThinkingLine(this.thinkingSummary, event.elapsedMs, event.activity);
+                if (this.stderr.isTTY) {
+                    this.stderr.write("\r" + line.padEnd(80) + "\r");
+                    this.heartbeatOpen = true;
+                }
+                break;
+            }
+            case "assistant:final": {
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r" + " ".repeat(80) + "\r");
+                    this.heartbeatOpen = false;
+                }
+                const lines = event.text.split("\n");
+                const rendered = renderMarkdownBlock(lines);
+                this.stdout.write(rendered + (rendered.endsWith("\n") ? "" : "\n"));
+                break;
+            }
+            case "turn:error": {
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r" + " ".repeat(80) + "\r");
+                    this.heartbeatOpen = false;
+                }
+                const errMsg = sanitizeUserVisibleOutput(event.message);
+                if (isUnsupportedRuntimeError(errMsg)) {
+                    this.stderr.write("\n" + renderRouteBlockedPanel(errMsg) + "\n\n");
+                    break;
+                }
+                this.stderr.write("\n" + style.red("  ✖ ") + style.white(errMsg) + "\n\n");
+                break;
+            }
+            case "turn:finish": {
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r" + " ".repeat(80) + "\r");
+                    this.heartbeatOpen = false;
+                }
+                const secs = (event.durationMs / 1000).toFixed(1);
+                this.stderr.write(style.gray("  ─ turn settled · ") + style.phosphorDim(`${secs}s`) + style.gray(" ─") + "\n\n");
+                break;
+            }
+            case "session:stop":
+                break;
+        }
+    }
+    /** Update thinking summary from reasoning NLP (called externally) */
+    setThinkingSummary(summary) {
+        this.thinkingSummary = summary;
+    }
+    stop() { }
+}

package/dist/cli/ui/route-blocked-panel.d.ts

@@ -0,0 +1,5 @@
+export declare function isUnsupportedRuntimeError(message: string): boolean;
+export declare function extractUnsupportedRuntimeNode(message: string): string | null;
+export declare function renderRouteBlockedPanel(message: string, options?: {
+    width?: number;
+}): string;

package/dist/cli/ui/route-blocked-panel.js

@@ -0,0 +1,67 @@
+import { sanitizeUserVisibleOutput } from "../../util/user-visible-output.js";
+const UNSUPPORTED_RUNTIME_NODE_RE = /No runtime supports(?: task)?(?: for)? node\s+([A-Za-z0-9_.:/-]+)/i;
+export function isUnsupportedRuntimeError(message) {
+    return UNSUPPORTED_RUNTIME_NODE_RE.test(message);
+}
+export function extractUnsupportedRuntimeNode(message) {
+    const match = message.match(UNSUPPORTED_RUNTIME_NODE_RE);
+    return match?.[1] ?? null;
+}
+export function renderRouteBlockedPanel(message, options = {}) {
+    const width = Math.min(100, Math.max(56, Math.round(options.width ?? 80)));
+    const innerWidth = width - 4;
+    const node = extractUnsupportedRuntimeNode(message) ?? "unknown";
+    const safeMessage = sanitizeUserVisibleOutput(message).replace(/\s+/g, " ").trim();
+    const reason = inferSecurityReason(safeMessage);
+    const lines = [
+        "No runtime supports this task.",
+        "",
+        `Node        ${node}`,
+        "Provider    auto / check configured runtimes",
+        "Capability  provider capability mismatch",
+        `Security    ${reason.security}`,
+        reason.detail ? `Reason      ${reason.detail}` : "",
+        safeMessage && safeMessage !== message ? `Detail      ${safeMessage}` : "",
+        "",
+        `Suggested   ${reason.suggested}`,
+        "Inspect     omk runtimes · omk mcp doctor",
+    ].filter(Boolean);
+    const label = "ROUTE BLOCKED";
+    const top = `╭─ ${label} ${"─".repeat(Math.max(0, width - label.length - 5))}╮`;
+    const bottom = `╰${"─".repeat(width - 2)}╯`;
+    const body = lines.map((line) => `│ ${truncate(line, innerWidth).padEnd(innerWidth)} │`);
+    return [top, ...body, bottom].join("\n");
+}
+function inferSecurityReason(message) {
+    if (/\bMCP\b|requiresMcp|requires MCP/i.test(message)) {
+        return {
+            security: "OMK keeps MCP authority behind approved runtimes",
+            detail: "Node requires MCP authority; this runtime does not receive OMK MCP authority",
+            suggested: "/provider auto · /mode plan · replan without MCP requirement",
+        };
+    }
+    if (/\btool\b|requiresToolCalling|tool calling/i.test(message)) {
+        return {
+            security: "OMK routes tool calls through its owned tool-plane",
+            detail: "Node requires live tool authority; selected runtime cannot own it",
+            suggested: "/provider auto · /mode plan · replan with OMK tool authority",
+        };
+    }
+    if (/\bworkspace-write\b|\bshell\b|\bwrite\b|\bpatch\b/i.test(message)) {
+        return {
+            security: "This runtime is env-hardened but not OS-sandboxed",
+            detail: "Requested authority requires write or shell capability",
+            suggested: "continue with approval prompts · replan read-only · switch provider-native sandbox · abort",
+        };
+    }
+    return {
+        security: "OMK blocks runtimes that cannot satisfy node authority",
+        suggested: "omk doctor · /provider auto · /mode plan",
+    };
+}
+function truncate(value, width) {
+    const chars = [...value];
+    if (chars.length <= width)
+        return value;
+    return `${chars.slice(0, Math.max(1, width - 1)).join("")}…`;
+}

package/dist/cli/ui/rust-forge-renderer.d.ts

@@ -0,0 +1,19 @@
+import type { CliUiEvent } from "./event.js";
+import type { CliRenderer } from "./renderer.js";
+import { type System24RendererStreams } from "./system24-renderer.js";
+export declare class RustForgeRenderer implements CliRenderer {
+    private readonly base;
+    private readonly err;
+    private readonly noColor;
+    private readonly motion;
+    private started;
+    constructor(streams?: System24RendererStreams);
+    start(): void;
+    emit(event: CliUiEvent): void;
+    setThinkingSummary(summary: string | undefined): void;
+    stop(): void;
+    private rustForgeHeaderRows;
+    private resolveSigilName;
+    private sigilHeight;
+    private renderRustForgeHeader;
+}